?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
push 96093b2868a8b399dfba4b98166e1ffce49bf2f1
[wine/hacks.git] / dlls / ws2_32 / socket.c
blob2bd4c14de40fdb0dd37670036908b2e90f694ca5
1 /*
2 * based on Windows Sockets 1.1 specs
3 * (ftp.microsoft.com:/Advsys/winsock/spec11/WINSOCK.TXT)
4 *
5 * Copyright (C) 1993,1994,1996,1997 John Brezak, Erik Bos, Alex Korobka.
6 * Copyright (C) 2005 Marcus Meissner
7 * Copyright (C) 2006 Kai Blin
8 *
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
13 *
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 *
23 * NOTE: If you make any changes to fix a particular app, make sure
24 * they don't break something else like Netscape or telnet and ftp
25 * clients and servers (www.winsite.com got a lot of those).
26 */
27
28 #include "config.h"
29 #include "wine/port.h"
30
31 #include <stdarg.h>
32 #include <stdio.h>
33 #include <string.h>
34 #include <sys/types.h>
35 #ifdef HAVE_SYS_IPC_H
36 # include <sys/ipc.h>
37 #endif
38 #ifdef HAVE_SYS_IOCTL_H
39 # include <sys/ioctl.h>
40 #endif
41 #ifdef HAVE_SYS_FILIO_H
42 # include <sys/filio.h>
43 #endif
44 #ifdef HAVE_SYS_SOCKIO_H
45 # include <sys/sockio.h>
46 #endif
47
48 #if defined(__EMX__)
49 # include <sys/so_ioctl.h>
50 #endif
51
52 #ifdef HAVE_SYS_PARAM_H
53 # include <sys/param.h>
54 #endif
55
56 #ifdef HAVE_SYS_MSG_H
57 # include <sys/msg.h>
58 #endif
59 #ifdef HAVE_SYS_WAIT_H
60 # include <sys/wait.h>
61 #endif
62 #ifdef HAVE_SYS_UIO_H
63 # include <sys/uio.h>
64 #endif
65 #ifdef HAVE_SYS_SOCKET_H
66 #include <sys/socket.h>
67 #endif
68 #ifdef HAVE_NETINET_IN_H
69 # include <netinet/in.h>
70 #endif
71 #ifdef HAVE_NETINET_TCP_H
72 # include <netinet/tcp.h>
73 #endif
74 #ifdef HAVE_ARPA_INET_H
75 # include <arpa/inet.h>
76 #endif
77 #include <ctype.h>
78 #include <fcntl.h>
79 #include <errno.h>
80 #ifdef HAVE_SYS_ERRNO_H
81 #include <sys/errno.h>
82 #endif
83 #ifdef HAVE_NETDB_H
84 #include <netdb.h>
85 #endif
86 #ifdef HAVE_UNISTD_H
87 # include <unistd.h>
88 #endif
89 #include <stdlib.h>
90 #ifdef HAVE_ARPA_NAMESER_H
91 # include <arpa/nameser.h>
92 #endif
93 #ifdef HAVE_RESOLV_H
94 # include <resolv.h>
95 #endif
96 #ifdef HAVE_NET_IF_H
97 # include <net/if.h>
98 #endif
99
100 #ifdef HAVE_NETIPX_IPX_H
101 # include <netipx/ipx.h>
102 # define HAVE_IPX
103 #elif defined(HAVE_LINUX_IPX_H)
104 # ifdef HAVE_ASM_TYPES_H
105 # include <asm/types.h>
106 # endif
107 # include <linux/ipx.h>
108 # define HAVE_IPX
109 #endif
110
111 #ifdef HAVE_POLL_H
112 #include <poll.h>
113 #endif
114 #ifdef HAVE_SYS_POLL_H
115 # include <sys/poll.h>
116 #endif
117 #ifdef HAVE_SYS_TIME_H
118 # include <sys/time.h>
119 #endif
120
121 #define NONAMELESSUNION
122 #define NONAMELESSSTRUCT
123 #include "ntstatus.h"
124 #define WIN32_NO_STATUS
125 #include "windef.h"
126 #include "winbase.h"
127 #include "wingdi.h"
128 #include "winuser.h"
129 #include "winerror.h"
130 #include "winnls.h"
131 #include "winsock2.h"
132 #include "mswsock.h"
133 #include "ws2tcpip.h"
134 #include "ws2spi.h"
135 #include "wsipx.h"
136 #include "winnt.h"
137 #include "iphlpapi.h"
138 #include "thread.h"
139 #include "wine/server.h"
140 #include "wine/debug.h"
141 #include "wine/unicode.h"
142
143 #ifdef HAVE_IPX
144 # include "wsnwlink.h"
145 #endif
146
147
148 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
149 # define sipx_network sipx_addr.x_net
150 # define sipx_node sipx_addr.x_host.c_host
151 #endif /* __FreeBSD__ */
152
153 #ifndef INADDR_NONE
154 #define INADDR_NONE ~0UL
155 #endif
156
157 WINE_DEFAULT_DEBUG_CHANNEL(winsock);
158
159 /* critical section to protect some non-rentrant net function */
160 extern CRITICAL_SECTION csWSgetXXXbyYYY;
161
162 union generic_unix_sockaddr
163 {
164 struct sockaddr addr;
165 char data[128]; /* should be big enough for all families */
166 };
167
168 static inline const char *debugstr_sockaddr( const struct WS_sockaddr *a )
169 {
170 if (!a) return "(nil)";
171 return wine_dbg_sprintf("{ family %d, address %s, port %d }",
172 ((const struct sockaddr_in *)a)->sin_family,
173 inet_ntoa(((const struct sockaddr_in *)a)->sin_addr),
174 ntohs(((const struct sockaddr_in *)a)->sin_port));
175 }
176
177 /* HANDLE<->SOCKET conversion (SOCKET is UINT_PTR). */
178 #define SOCKET2HANDLE(s) ((HANDLE)(s))
179 #define HANDLE2SOCKET(h) ((SOCKET)(h))
180
181 /****************************************************************
182 * Async IO declarations
183 ****************************************************************/
184
185 typedef struct ws2_async
186 {
187 HANDLE hSocket;
188 enum ws2_mode {ws2m_read, ws2m_write, ws2m_sd_read, ws2m_sd_write} mode;
189 LPWSAOVERLAPPED user_overlapped;
190 LPWSAOVERLAPPED_COMPLETION_ROUTINE completion_func;
191 IO_STATUS_BLOCK local_iosb;
192 struct iovec iovec[WS_MSG_MAXIOVLEN];
193 int n_iovecs;
194 struct WS_sockaddr *addr;
195 union
196 {
197 int val; /* for send operations */
198 int *ptr; /* for recv operations */
199 } addrlen;
200 DWORD flags;
201 HANDLE event;
202 } ws2_async;
203
204 /****************************************************************/
205
206 /* ----------------------------------- internal data */
207
208 /* ws_... struct conversion flags */
209
210 typedef struct /* WSAAsyncSelect() control struct */
211 {
212 HANDLE service, event, sock;
213 HWND hWnd;
214 UINT uMsg;
215 LONG lEvent;
216 } ws_select_info;
217
218 #define WS_MAX_SOCKETS_PER_PROCESS 128 /* reasonable guess */
219 #define WS_MAX_UDP_DATAGRAM 1024
220 static INT WINAPI WSA_DefaultBlockingHook( FARPROC x );
221
222 /* hostent's, servent's and protent's are stored in one buffer per thread,
223 * as documented on MSDN for the functions that return any of the buffers */
224 struct per_thread_data
225 {
226 int opentype;
227 struct WS_hostent *he_buffer;
228 struct WS_servent *se_buffer;
229 struct WS_protoent *pe_buffer;
230 int he_len;
231 int se_len;
232 int pe_len;
233 };
234
235 static INT num_startup; /* reference counter */
236 static FARPROC blocking_hook = (FARPROC)WSA_DefaultBlockingHook;
237
238 /* function prototypes */
239 static struct WS_hostent *WS_dup_he(const struct hostent* p_he);
240 static struct WS_protoent *WS_dup_pe(const struct protoent* p_pe);
241 static struct WS_servent *WS_dup_se(const struct servent* p_se);
242
243 int WSAIOCTL_GetInterfaceCount(void);
244 int WSAIOCTL_GetInterfaceName(int intNumber, char *intName);
245
246 UINT wsaErrno(void);
247 UINT wsaHerrno(int errnr);
248
249 #define MAP_OPTION(opt) { WS_##opt, opt }
250
251 static const int ws_sock_map[][2] =
252 {
253 MAP_OPTION( SO_DEBUG ),
254 MAP_OPTION( SO_ACCEPTCONN ),
255 MAP_OPTION( SO_REUSEADDR ),
256 MAP_OPTION( SO_KEEPALIVE ),
257 MAP_OPTION( SO_DONTROUTE ),
258 MAP_OPTION( SO_BROADCAST ),
259 MAP_OPTION( SO_LINGER ),
260 MAP_OPTION( SO_OOBINLINE ),
261 MAP_OPTION( SO_SNDBUF ),
262 MAP_OPTION( SO_RCVBUF ),
263 MAP_OPTION( SO_ERROR ),
264 MAP_OPTION( SO_TYPE ),
265 #ifdef SO_RCVTIMEO
266 MAP_OPTION( SO_RCVTIMEO ),
267 #endif
268 #ifdef SO_SNDTIMEO
269 MAP_OPTION( SO_SNDTIMEO ),
270 #endif
271 };
272
273 static const int ws_tcp_map[][2] =
274 {
275 #ifdef TCP_NODELAY
276 MAP_OPTION( TCP_NODELAY ),
277 #endif
278 };
279
280 static const int ws_ip_map[][2] =
281 {
282 MAP_OPTION( IP_MULTICAST_IF ),
283 MAP_OPTION( IP_MULTICAST_TTL ),
284 MAP_OPTION( IP_MULTICAST_LOOP ),
285 MAP_OPTION( IP_ADD_MEMBERSHIP ),
286 MAP_OPTION( IP_DROP_MEMBERSHIP ),
287 MAP_OPTION( IP_OPTIONS ),
288 #ifdef IP_HDRINCL
289 MAP_OPTION( IP_HDRINCL ),
290 #endif
291 MAP_OPTION( IP_TOS ),
292 MAP_OPTION( IP_TTL ),
293 };
294
295 static const int ws_af_map[][2] =
296 {
297 MAP_OPTION( AF_UNSPEC ),
298 MAP_OPTION( AF_INET ),
299 MAP_OPTION( AF_INET6 ),
300 #ifdef HAVE_IPX
301 MAP_OPTION( AF_IPX ),
302 #endif
303 };
304
305 static const int ws_socktype_map[][2] =
306 {
307 MAP_OPTION( SOCK_DGRAM ),
308 MAP_OPTION( SOCK_STREAM ),
309 MAP_OPTION( SOCK_RAW ),
310 };
311
312 static const int ws_proto_map[][2] =
313 {
314 MAP_OPTION( IPPROTO_IP ),
315 MAP_OPTION( IPPROTO_TCP ),
316 MAP_OPTION( IPPROTO_UDP ),
317 MAP_OPTION( IPPROTO_ICMP ),
318 MAP_OPTION( IPPROTO_IGMP ),
319 MAP_OPTION( IPPROTO_RAW ),
320 };
321
322 static const int ws_aiflag_map[][2] =
323 {
324 MAP_OPTION( AI_PASSIVE ),
325 MAP_OPTION( AI_CANONNAME ),
326 MAP_OPTION( AI_NUMERICHOST ),
327 /* Linux/UNIX knows a lot more. But Windows only
328 * has 3 as far as I could see. -Marcus
329 */
330 };
331
332 static const int ws_eai_map[][2] =
333 {
334 MAP_OPTION( EAI_AGAIN ),
335 MAP_OPTION( EAI_BADFLAGS ),
336 MAP_OPTION( EAI_FAIL ),
337 MAP_OPTION( EAI_FAMILY ),
338 MAP_OPTION( EAI_MEMORY ),
339 /* Note: EAI_NODATA is deprecated, but still
340 * used by Windows and Linux... We map the newer
341 * EAI_NONAME to EAI_NODATA for now until Windows
342 * changes too.
343 */
344 #ifdef EAI_NODATA
345 MAP_OPTION( EAI_NODATA ),
346 #endif
347 #ifdef EAI_NONAME
348 { WS_EAI_NODATA, EAI_NONAME },
349 #endif
350
351 MAP_OPTION( EAI_SERVICE ),
352 MAP_OPTION( EAI_SOCKTYPE ),
353 { 0, 0 }
354 };
355
356 static inline DWORD NtStatusToWSAError( const DWORD status )
357 {
358 /* We only need to cover the status codes set by server async request handling */
359 DWORD wserr;
360 switch ( status )
361 {
362 case STATUS_SUCCESS: wserr = 0; break;
363 case STATUS_PENDING: wserr = WSA_IO_PENDING; break;
364 case STATUS_INVALID_HANDLE: wserr = WSAENOTSOCK; break; /* WSAEBADF ? */
365 case STATUS_INVALID_PARAMETER: wserr = WSAEINVAL; break;
366 case STATUS_PIPE_DISCONNECTED: wserr = WSAESHUTDOWN; break;
367 case STATUS_CANCELLED: wserr = WSA_OPERATION_ABORTED; break;
368 case STATUS_TIMEOUT: wserr = WSAETIMEDOUT; break;
369 case STATUS_NO_MEMORY: wserr = WSAEFAULT; break;
370 default:
371 if ( status >= WSABASEERR && status <= WSABASEERR+1004 )
372 /* It is not an NT status code but a winsock error */
373 wserr = status;
374 else
375 {
376 wserr = RtlNtStatusToDosError( status );
377 FIXME( "Status code %08x converted to DOS error code %x\n", status, wserr );
378 }
379 }
380 return wserr;
381 }
382
383 /* set last error code from NT status without mapping WSA errors */
384 static inline unsigned int set_error( unsigned int err )
385 {
386 if (err)
387 {
388 err = NtStatusToWSAError( err );
389 SetLastError( err );
390 }
391 return err;
392 }
393
394 static inline int get_sock_fd( SOCKET s, DWORD access, unsigned int *options )
395 {
396 int fd;
397 if (set_error( wine_server_handle_to_fd( SOCKET2HANDLE(s), access, &fd, options ) ))
398 return -1;
399 return fd;
400 }
401
402 static inline void release_sock_fd( SOCKET s, int fd )
403 {
404 wine_server_release_fd( SOCKET2HANDLE(s), fd );
405 }
406
407 static void _enable_event( HANDLE s, unsigned int event,
408 unsigned int sstate, unsigned int cstate )
409 {
410 SERVER_START_REQ( enable_socket_event )
411 {
412 req->handle = s;
413 req->mask = event;
414 req->sstate = sstate;
415 req->cstate = cstate;
416 wine_server_call( req );
417 }
418 SERVER_END_REQ;
419 }
420
421 static int _is_blocking(SOCKET s)
422 {
423 int ret;
424 SERVER_START_REQ( get_socket_event )
425 {
426 req->handle = SOCKET2HANDLE(s);
427 req->service = FALSE;
428 req->c_event = 0;
429 wine_server_call( req );
430 ret = (reply->state & FD_WINE_NONBLOCKING) == 0;
431 }
432 SERVER_END_REQ;
433 return ret;
434 }
435
436 static unsigned int _get_sock_mask(SOCKET s)
437 {
438 unsigned int ret;
439 SERVER_START_REQ( get_socket_event )
440 {
441 req->handle = SOCKET2HANDLE(s);
442 req->service = FALSE;
443 req->c_event = 0;
444 wine_server_call( req );
445 ret = reply->mask;
446 }
447 SERVER_END_REQ;
448 return ret;
449 }
450
451 static void _sync_sock_state(SOCKET s)
452 {
453 /* do a dummy wineserver request in order to let
454 the wineserver run through its select loop once */
455 (void)_is_blocking(s);
456 }
457
458 static int _get_sock_error(SOCKET s, unsigned int bit)
459 {
460 int events[FD_MAX_EVENTS];
461
462 SERVER_START_REQ( get_socket_event )
463 {
464 req->handle = SOCKET2HANDLE(s);
465 req->service = FALSE;
466 req->c_event = 0;
467 wine_server_set_reply( req, events, sizeof(events) );
468 wine_server_call( req );
469 }
470 SERVER_END_REQ;
471 return events[bit];
472 }
473
474 static struct per_thread_data *get_per_thread_data(void)
475 {
476 struct per_thread_data * ptb = NtCurrentTeb()->WinSockData;
477 /* lazy initialization */
478 if (!ptb)
479 {
480 ptb = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*ptb) );
481 NtCurrentTeb()->WinSockData = ptb;
482 }
483 return ptb;
484 }
485
486 static void free_per_thread_data(void)
487 {
488 struct per_thread_data * ptb = NtCurrentTeb()->WinSockData;
489
490 if (!ptb) return;
491
492 /* delete scratch buffers */
493 HeapFree( GetProcessHeap(), 0, ptb->he_buffer );
494 HeapFree( GetProcessHeap(), 0, ptb->se_buffer );
495 HeapFree( GetProcessHeap(), 0, ptb->pe_buffer );
496 ptb->he_buffer = NULL;
497 ptb->se_buffer = NULL;
498 ptb->pe_buffer = NULL;
499
500 HeapFree( GetProcessHeap(), 0, ptb );
501 NtCurrentTeb()->WinSockData = NULL;
502 }
503
504 /***********************************************************************
505 * DllMain (WS2_32.init)
506 */
507 BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID fImpLoad)
508 {
509 TRACE("%p 0x%x %p\n", hInstDLL, fdwReason, fImpLoad);
510 switch (fdwReason) {
511 case DLL_PROCESS_ATTACH:
512 break;
513 case DLL_PROCESS_DETACH:
514 free_per_thread_data();
515 num_startup = 0;
516 break;
517 case DLL_THREAD_DETACH:
518 free_per_thread_data();
519 break;
520 }
521 return TRUE;
522 }
523
524 /***********************************************************************
525 * convert_sockopt()
526 *
527 * Converts socket flags from Windows format.
528 * Return 1 if converted, 0 if not (error).
529 */
530 static int convert_sockopt(INT *level, INT *optname)
531 {
532 int i;
533 switch (*level)
534 {
535 case WS_SOL_SOCKET:
536 *level = SOL_SOCKET;
537 for(i=0; i<sizeof(ws_sock_map)/sizeof(ws_sock_map[0]); i++) {
538 if( ws_sock_map[i][0] == *optname )
539 {
540 *optname = ws_sock_map[i][1];
541 return 1;
542 }
543 }
544 FIXME("Unknown SOL_SOCKET optname 0x%x\n", *optname);
545 break;
546 case WS_IPPROTO_TCP:
547 *level = IPPROTO_TCP;
548 for(i=0; i<sizeof(ws_tcp_map)/sizeof(ws_tcp_map[0]); i++) {
549 if ( ws_tcp_map[i][0] == *optname )
550 {
551 *optname = ws_tcp_map[i][1];
552 return 1;
553 }
554 }
555 FIXME("Unknown IPPROTO_TCP optname 0x%x\n", *optname);
556 break;
557 case WS_IPPROTO_IP:
558 *level = IPPROTO_IP;
559 for(i=0; i<sizeof(ws_ip_map)/sizeof(ws_ip_map[0]); i++) {
560 if (ws_ip_map[i][0] == *optname )
561 {
562 *optname = ws_ip_map[i][1];
563 return 1;
564 }
565 }
566 FIXME("Unknown IPPROTO_IP optname 0x%x\n", *optname);
567 break;
568 default: FIXME("Unimplemented or unknown socket level\n");
569 }
570 return 0;
571 }
572
573 static inline BOOL is_timeout_option( int optname )
574 {
575 #ifdef SO_RCVTIMEO
576 if (optname == SO_RCVTIMEO) return TRUE;
577 #endif
578 #ifdef SO_SNDTIMEO
579 if (optname == SO_SNDTIMEO) return TRUE;
580 #endif
581 return FALSE;
582 }
583
584 /* ----------------------------------- Per-thread info (or per-process?) */
585
586 static char *strdup_lower(const char *str)
587 {
588 int i;
589 char *ret = HeapAlloc( GetProcessHeap(), 0, strlen(str) + 1 );
590
591 if (ret)
592 {
593 for (i = 0; str[i]; i++) ret[i] = tolower(str[i]);
594 ret[i] = 0;
595 }
596 else SetLastError(WSAENOBUFS);
597 return ret;
598 }
599
600 static inline int sock_error_p(int s)
601 {
602 unsigned int optval, optlen;
603
604 optlen = sizeof(optval);
605 getsockopt(s, SOL_SOCKET, SO_ERROR, (void *) &optval, &optlen);
606 if (optval) WARN("\t[%i] error: %d\n", s, optval);
607 return optval != 0;
608 }
609
610 /* Utility: get the SO_RCVTIMEO or SO_SNDTIMEO socket option
611 * from an fd and return the value converted to milli seconds
612 * or -1 if there is an infinite time out */
613 static inline int get_rcvsnd_timeo( int fd, int optname)
614 {
615 struct timeval tv;
616 unsigned int len = sizeof(tv);
617 int ret = getsockopt(fd, SOL_SOCKET, optname, &tv, &len);
618 if( ret >= 0)
619 ret = tv.tv_sec * 1000 + tv.tv_usec / 1000;
620 if( ret <= 0 ) /* tv == {0,0} means infinite time out */
621 return -1;
622 return ret;
623 }
624
625 /* macro wrappers for portability */
626 #ifdef SO_RCVTIMEO
627 #define GET_RCVTIMEO(fd) get_rcvsnd_timeo( (fd), SO_RCVTIMEO)
628 #else
629 #define GET_RCVTIMEO(fd) (-1)
630 #endif
631
632 #ifdef SO_SNDTIMEO
633 #define GET_SNDTIMEO(fd) get_rcvsnd_timeo( (fd), SO_SNDTIMEO)
634 #else
635 #define GET_SNDTIMEO(fd) (-1)
636 #endif
637
638 /* utility: given an fd, will block until one of the events occurs */
639 static inline int do_block( int fd, int events, int timeout )
640 {
641 struct pollfd pfd;
642 int ret;
643
644 pfd.fd = fd;
645 pfd.events = events;
646
647 while ((ret = poll(&pfd, 1, timeout)) < 0)
648 {
649 if (errno != EINTR)
650 return -1;
651 }
652 if( ret == 0 )
653 return 0;
654 return pfd.revents;
655 }
656
657 static int
658 convert_af_w2u(int windowsaf) {
659 int i;
660
661 for (i=0;i<sizeof(ws_af_map)/sizeof(ws_af_map[0]);i++)
662 if (ws_af_map[i][0] == windowsaf)
663 return ws_af_map[i][1];
664 FIXME("unhandled Windows address family %d\n", windowsaf);
665 return -1;
666 }
667
668 static int
669 convert_af_u2w(int unixaf) {
670 int i;
671
672 for (i=0;i<sizeof(ws_af_map)/sizeof(ws_af_map[0]);i++)
673 if (ws_af_map[i][1] == unixaf)
674 return ws_af_map[i][0];
675 FIXME("unhandled UNIX address family %d\n", unixaf);
676 return -1;
677 }
678
679 static int
680 convert_proto_w2u(int windowsproto) {
681 int i;
682
683 for (i=0;i<sizeof(ws_proto_map)/sizeof(ws_proto_map[0]);i++)
684 if (ws_proto_map[i][0] == windowsproto)
685 return ws_proto_map[i][1];
686 FIXME("unhandled Windows socket protocol %d\n", windowsproto);
687 return -1;
688 }
689
690 static int
691 convert_proto_u2w(int unixproto) {
692 int i;
693
694 for (i=0;i<sizeof(ws_proto_map)/sizeof(ws_proto_map[0]);i++)
695 if (ws_proto_map[i][1] == unixproto)
696 return ws_proto_map[i][0];
697 FIXME("unhandled UNIX socket protocol %d\n", unixproto);
698 return -1;
699 }
700
701 static int
702 convert_socktype_w2u(int windowssocktype) {
703 int i;
704
705 for (i=0;i<sizeof(ws_socktype_map)/sizeof(ws_socktype_map[0]);i++)
706 if (ws_socktype_map[i][0] == windowssocktype)
707 return ws_socktype_map[i][1];
708 FIXME("unhandled Windows socket type %d\n", windowssocktype);
709 return -1;
710 }
711
712 static int
713 convert_socktype_u2w(int unixsocktype) {
714 int i;
715
716 for (i=0;i<sizeof(ws_socktype_map)/sizeof(ws_socktype_map[0]);i++)
717 if (ws_socktype_map[i][1] == unixsocktype)
718 return ws_socktype_map[i][0];
719 FIXME("unhandled UNIX socket type %d\n", unixsocktype);
720 return -1;
721 }
722
723 /* ----------------------------------- API -----
724 *
725 * Init / cleanup / error checking.
726 */
727
728 /***********************************************************************
729 * WSAStartup (WS2_32.115)
730 */
731 int WINAPI WSAStartup(WORD wVersionRequested, LPWSADATA lpWSAData)
732 {
733 TRACE("verReq=%x\n", wVersionRequested);
734
735 if (LOBYTE(wVersionRequested) < 1)
736 return WSAVERNOTSUPPORTED;
737
738 if (!lpWSAData) return WSAEINVAL;
739
740 num_startup++;
741
742 /* that's the whole of the negotiation for now */
743 lpWSAData->wVersion = wVersionRequested;
744 /* return winsock information */
745 lpWSAData->wHighVersion = 0x0202;
746 strcpy(lpWSAData->szDescription, "WinSock 2.0" );
747 strcpy(lpWSAData->szSystemStatus, "Running" );
748 lpWSAData->iMaxSockets = WS_MAX_SOCKETS_PER_PROCESS;
749 lpWSAData->iMaxUdpDg = WS_MAX_UDP_DATAGRAM;
750 /* don't do anything with lpWSAData->lpVendorInfo */
751 /* (some apps don't allocate the space for this field) */
752
753 TRACE("succeeded\n");
754 return 0;
755 }
756
757
758 /***********************************************************************
759 * WSACleanup (WS2_32.116)
760 */
761 INT WINAPI WSACleanup(void)
762 {
763 if (num_startup) {
764 num_startup--;
765 return 0;
766 }
767 SetLastError(WSANOTINITIALISED);
768 return SOCKET_ERROR;
769 }
770
771
772 /***********************************************************************
773 * WSAGetLastError (WINSOCK.111)
774 * WSAGetLastError (WS2_32.111)
775 */
776 INT WINAPI WSAGetLastError(void)
777 {
778 return GetLastError();
779 }
780
781 /***********************************************************************
782 * WSASetLastError (WS2_32.112)
783 */
784 void WINAPI WSASetLastError(INT iError) {
785 SetLastError(iError);
786 }
787
788 static struct WS_hostent *check_buffer_he(int size)
789 {
790 struct per_thread_data * ptb = get_per_thread_data();
791 if (ptb->he_buffer)
792 {
793 if (ptb->he_len >= size ) return ptb->he_buffer;
794 HeapFree( GetProcessHeap(), 0, ptb->he_buffer );
795 }
796 ptb->he_buffer = HeapAlloc( GetProcessHeap(), 0, (ptb->he_len = size) );
797 if (!ptb->he_buffer) SetLastError(WSAENOBUFS);
798 return ptb->he_buffer;
799 }
800
801 static struct WS_servent *check_buffer_se(int size)
802 {
803 struct per_thread_data * ptb = get_per_thread_data();
804 if (ptb->se_buffer)
805 {
806 if (ptb->se_len >= size ) return ptb->se_buffer;
807 HeapFree( GetProcessHeap(), 0, ptb->se_buffer );
808 }
809 ptb->se_buffer = HeapAlloc( GetProcessHeap(), 0, (ptb->se_len = size) );
810 if (!ptb->se_buffer) SetLastError(WSAENOBUFS);
811 return ptb->se_buffer;
812 }
813
814 static struct WS_protoent *check_buffer_pe(int size)
815 {
816 struct per_thread_data * ptb = get_per_thread_data();
817 if (ptb->pe_buffer)
818 {
819 if (ptb->pe_len >= size ) return ptb->pe_buffer;
820 HeapFree( GetProcessHeap(), 0, ptb->pe_buffer );
821 }
822 ptb->pe_buffer = HeapAlloc( GetProcessHeap(), 0, (ptb->pe_len = size) );
823 if (!ptb->pe_buffer) SetLastError(WSAENOBUFS);
824 return ptb->pe_buffer;
825 }
826
827 /* ----------------------------------- i/o APIs */
828
829 #ifdef HAVE_IPX
830 #define SUPPORTED_PF(pf) ((pf)==WS_AF_INET || (pf)== WS_AF_IPX || (pf) == WS_AF_INET6)
831 #else
832 #define SUPPORTED_PF(pf) ((pf)==WS_AF_INET || (pf) == WS_AF_INET6)
833 #endif
834
835
836 /**********************************************************************/
837
838 /* Returns the length of the converted address if successful, 0 if it was too small to
839 * start with.
840 */
841 static unsigned int ws_sockaddr_ws2u(const struct WS_sockaddr* wsaddr, int wsaddrlen,
842 union generic_unix_sockaddr *uaddr)
843 {
844 unsigned int uaddrlen = 0;
845
846 switch (wsaddr->sa_family)
847 {
848 #ifdef HAVE_IPX
849 case WS_AF_IPX:
850 {
851 const struct WS_sockaddr_ipx* wsipx=(const struct WS_sockaddr_ipx*)wsaddr;
852 struct sockaddr_ipx* uipx = (struct sockaddr_ipx *)uaddr;
853
854 if (wsaddrlen<sizeof(struct WS_sockaddr_ipx))
855 return 0;
856
857 uaddrlen = sizeof(struct sockaddr_ipx);
858 uipx->sipx_family=AF_IPX;
859 uipx->sipx_port=wsipx->sa_socket;
860 /* copy sa_netnum and sa_nodenum to sipx_network and sipx_node
861 * in one go
862 */
863 memcpy(&uipx->sipx_network,wsipx->sa_netnum,sizeof(uipx->sipx_network)+sizeof(uipx->sipx_node));
864 #ifdef IPX_FRAME_NONE
865 uipx->sipx_type=IPX_FRAME_NONE;
866 #endif
867 break;
868 }
869 #endif
870 case WS_AF_INET6: {
871 struct sockaddr_in6* uin6 = (struct sockaddr_in6 *)uaddr;
872 const struct WS_sockaddr_in6* win6 = (const struct WS_sockaddr_in6*)wsaddr;
873
874 /* Note: Windows has 2 versions of the sockaddr_in6 struct, one with
875 * scope_id, one without. Check:
876 * http://msdn.microsoft.com/library/en-us/winsock/winsock/sockaddr_2.asp
877 */
878 if (wsaddrlen >= sizeof(struct WS_sockaddr_in6_old)) {
879 uaddrlen = sizeof(struct sockaddr_in6);
880 uin6->sin6_family = AF_INET6;
881 uin6->sin6_port = win6->sin6_port;
882 uin6->sin6_flowinfo = win6->sin6_flowinfo;
883 #ifdef HAVE_STRUCT_SOCKADDR_IN6_SIN6_SCOPE_ID
884 if (wsaddrlen >= sizeof(struct WS_sockaddr_in6)) uin6->sin6_scope_id = win6->sin6_scope_id;
885 #endif
886 memcpy(&uin6->sin6_addr,&win6->sin6_addr,16); /* 16 bytes = 128 address bits */
887 break;
888 }
889 FIXME("bad size %d for WS_sockaddr_in6\n",wsaddrlen);
890 return 0;
891 }
892 case WS_AF_INET: {
893 struct sockaddr_in* uin = (struct sockaddr_in *)uaddr;
894 const struct WS_sockaddr_in* win = (const struct WS_sockaddr_in*)wsaddr;
895
896 if (wsaddrlen<sizeof(struct WS_sockaddr_in))
897 return 0;
898 uaddrlen = sizeof(struct sockaddr_in);
899 uin->sin_family = AF_INET;
900 uin->sin_port = win->sin_port;
901 memcpy(&uin->sin_addr,&win->sin_addr,4); /* 4 bytes = 32 address bits */
902 break;
903 }
904 case WS_AF_UNSPEC: {
905 /* Try to determine the needed space by the passed windows sockaddr space */
906 switch (wsaddrlen) {
907 default: /* likely a ipv4 address */
908 case sizeof(struct WS_sockaddr_in):
909 uaddrlen = sizeof(struct sockaddr_in);
910 break;
911 #ifdef HAVE_IPX
912 case sizeof(struct WS_sockaddr_ipx):
913 uaddrlen = sizeof(struct sockaddr_ipx);
914 break;
915 #endif
916 case sizeof(struct WS_sockaddr_in6):
917 case sizeof(struct WS_sockaddr_in6_old):
918 uaddrlen = sizeof(struct sockaddr_in6);
919 break;
920 }
921 memset( uaddr, 0, uaddrlen );
922 break;
923 }
924 default:
925 FIXME("Unknown address family %d, return NULL.\n", wsaddr->sa_family);
926 return 0;
927 }
928 return uaddrlen;
929 }
930
931 /* Returns 0 if successful, -1 if the buffer is too small */
932 static int ws_sockaddr_u2ws(const struct sockaddr* uaddr, struct WS_sockaddr* wsaddr, int* wsaddrlen)
933 {
934 int res;
935
936 switch(uaddr->sa_family)
937 {
938 #ifdef HAVE_IPX
939 case AF_IPX:
940 {
941 const struct sockaddr_ipx* uipx=(const struct sockaddr_ipx*)uaddr;
942 struct WS_sockaddr_ipx* wsipx=(struct WS_sockaddr_ipx*)wsaddr;
943
944 res=-1;
945 switch (*wsaddrlen) /* how much can we copy? */
946 {
947 default:
948 res=0; /* enough */
949 *wsaddrlen = sizeof(*wsipx);
950 wsipx->sa_socket=uipx->sipx_port;
951 /* fall through */
952 case 13:
953 case 12:
954 memcpy(wsipx->sa_nodenum,uipx->sipx_node,sizeof(wsipx->sa_nodenum));
955 /* fall through */
956 case 11:
957 case 10:
958 case 9:
959 case 8:
960 case 7:
961 case 6:
962 memcpy(wsipx->sa_netnum,&uipx->sipx_network,sizeof(wsipx->sa_netnum));
963 /* fall through */
964 case 5:
965 case 4:
966 case 3:
967 case 2:
968 wsipx->sa_family=WS_AF_IPX;
969 /* fall through */
970 case 1:
971 case 0:
972 /* way too small */
973 break;
974 }
975 }
976 break;
977 #endif
978 case AF_INET6: {
979 const struct sockaddr_in6* uin6 = (const struct sockaddr_in6*)uaddr;
980 struct WS_sockaddr_in6_old* win6old = (struct WS_sockaddr_in6_old*)wsaddr;
981
982 if (*wsaddrlen < sizeof(struct WS_sockaddr_in6_old))
983 return -1;
984 win6old->sin6_family = WS_AF_INET6;
985 win6old->sin6_port = uin6->sin6_port;
986 win6old->sin6_flowinfo = uin6->sin6_flowinfo;
987 memcpy(&win6old->sin6_addr,&uin6->sin6_addr,16); /* 16 bytes = 128 address bits */
988 *wsaddrlen = sizeof(struct WS_sockaddr_in6_old);
989 #ifdef HAVE_STRUCT_SOCKADDR_IN6_SIN6_SCOPE_ID
990 if (*wsaddrlen >= sizeof(struct WS_sockaddr_in6)) {
991 struct WS_sockaddr_in6* win6 = (struct WS_sockaddr_in6*)wsaddr;
992 win6->sin6_scope_id = uin6->sin6_scope_id;
993 *wsaddrlen = sizeof(struct WS_sockaddr_in6);
994 }
995 #endif
996 return 0;
997 }
998 case AF_INET: {
999 const struct sockaddr_in* uin = (const struct sockaddr_in*)uaddr;
1000 struct WS_sockaddr_in* win = (struct WS_sockaddr_in*)wsaddr;
1001
1002 if (*wsaddrlen < sizeof(struct WS_sockaddr_in))
1003 return -1;
1004 win->sin_family = WS_AF_INET;
1005 win->sin_port = uin->sin_port;
1006 memcpy(&win->sin_addr,&uin->sin_addr,4); /* 4 bytes = 32 address bits */
1007 memset(&win->sin_zero, 0, 8); /* Make sure the null padding is null */
1008 *wsaddrlen = sizeof(struct WS_sockaddr_in);
1009 return 0;
1010 }
1011 case AF_UNSPEC: {
1012 memset(wsaddr,0,*wsaddrlen);
1013 return 0;
1014 }
1015 default:
1016 FIXME("Unknown address family %d\n", uaddr->sa_family);
1017 return -1;
1018 }
1019 return res;
1020 }
1021
1022 /**************************************************************************
1023 * Functions for handling overlapped I/O
1024 **************************************************************************/
1025
1026 static void ws2_async_terminate(ws2_async* as, IO_STATUS_BLOCK* iosb, NTSTATUS status, ULONG count)
1027 {
1028 TRACE( "as: %p uovl %p ovl %p\n", as, as->user_overlapped, iosb );
1029
1030 iosb->u.Status = status;
1031 iosb->Information = count;
1032 if (as->completion_func)
1033 as->completion_func( NtStatusToWSAError(status),
1034 count, as->user_overlapped, as->flags );
1035
1036 HeapFree( GetProcessHeap(), 0, as );
1037 }
1038
1039 /***********************************************************************
1040 * WS2_make_async (INTERNAL)
1041 */
1042
1043 static NTSTATUS WS2_async_recv(void*, IO_STATUS_BLOCK*, NTSTATUS);
1044 static NTSTATUS WS2_async_send(void*, IO_STATUS_BLOCK*, NTSTATUS);
1045 static NTSTATUS WS2_async_shutdown( void*, IO_STATUS_BLOCK*, NTSTATUS);
1046
1047 static inline struct ws2_async*
1048 WS2_make_async(SOCKET s, enum ws2_mode mode, struct iovec *iovec, DWORD dwBufferCount,
1049 LPDWORD lpFlags, struct WS_sockaddr *addr,
1050 LPINT addrlen, LPWSAOVERLAPPED lpOverlapped,
1051 LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine,
1052 IO_STATUS_BLOCK **piosb)
1053 {
1054 struct ws2_async *wsa = HeapAlloc( GetProcessHeap(), 0, sizeof( ws2_async ) );
1055
1056 TRACE( "wsa %p\n", wsa );
1057
1058 if (!wsa)
1059 return NULL;
1060
1061 wsa->hSocket = (HANDLE) s;
1062 wsa->mode = mode;
1063 switch (mode)
1064 {
1065 case ws2m_read:
1066 case ws2m_sd_read:
1067 wsa->flags = *lpFlags;
1068 wsa->addrlen.ptr = addrlen;
1069 break;
1070 case ws2m_write:
1071 case ws2m_sd_write:
1072 wsa->flags = 0;
1073 wsa->addrlen.val = *addrlen;
1074 break;
1075 default:
1076 ERR("Invalid async mode: %d\n", mode);
1077 }
1078 wsa->user_overlapped = lpOverlapped;
1079 wsa->completion_func = lpCompletionRoutine;
1080 memcpy( wsa->iovec, iovec, dwBufferCount * sizeof(*iovec) );
1081 wsa->n_iovecs = dwBufferCount;
1082 wsa->addr = addr;
1083 wsa->event = 0;
1084
1085 if ( lpOverlapped )
1086 {
1087 *piosb = (IO_STATUS_BLOCK*)lpOverlapped;
1088 if (!lpCompletionRoutine)
1089 wsa->event = lpOverlapped->hEvent;
1090 }
1091 else
1092 *piosb = &wsa->local_iosb;
1093
1094 TRACE( "wsa %p, h %p, ev %p, iosb %p, uov %p, cfunc %p\n",
1095 wsa, wsa->hSocket, wsa->event,
1096 *piosb, wsa->user_overlapped, wsa->completion_func );
1097
1098 return wsa;
1099 }
1100
1101 static ULONG ws2_queue_async(struct ws2_async* wsa, IO_STATUS_BLOCK* iosb)
1102 {
1103 NTSTATUS (*apc)(void *, IO_STATUS_BLOCK *, NTSTATUS);
1104 int type;
1105 NTSTATUS status;
1106
1107 switch (wsa->mode)
1108 {
1109 case ws2m_read: apc = WS2_async_recv; type = ASYNC_TYPE_READ; break;
1110 case ws2m_write: apc = WS2_async_send; type = ASYNC_TYPE_WRITE; break;
1111 case ws2m_sd_read: apc = WS2_async_shutdown; type = ASYNC_TYPE_READ; break;
1112 case ws2m_sd_write: apc = WS2_async_shutdown; type = ASYNC_TYPE_WRITE; break;
1113 default: FIXME("Unknown internal mode (%d)\n", wsa->mode); return STATUS_INVALID_PARAMETER;
1114 }
1115
1116 SERVER_START_REQ( register_async )
1117 {
1118 req->handle = wsa->hSocket;
1119 req->async.callback = apc;
1120 req->async.iosb = iosb;
1121 req->async.arg = wsa;
1122 req->async.event = wsa->event;
1123 req->type = type;
1124 status = wine_server_call( req );
1125 }
1126 SERVER_END_REQ;
1127
1128 if (status != STATUS_PENDING)
1129 ws2_async_terminate(wsa, iosb, status, 0);
1130 else
1131 NtCurrentTeb()->num_async_io++;
1132 return status;
1133 }
1134
1135 /***********************************************************************
1136 * WS2_recv (INTERNAL)
1137 *
1138 * Workhorse for both synchronous and asynchronous recv() operations.
1139 */
1140 static int WS2_recv( int fd, struct iovec* iov, int count,
1141 struct WS_sockaddr *lpFrom, LPINT lpFromlen,
1142 LPDWORD lpFlags )
1143 {
1144 struct msghdr hdr;
1145 union generic_unix_sockaddr unix_sockaddr;
1146 int n;
1147 TRACE( "fd %d, iovec %p, count %d addr %s, len %p, flags %x\n",
1148 fd, iov, count, debugstr_sockaddr(lpFrom), lpFromlen, *lpFlags);
1149
1150 hdr.msg_name = NULL;
1151
1152 if ( lpFrom )
1153 {
1154 hdr.msg_namelen = sizeof(unix_sockaddr);
1155 hdr.msg_name = &unix_sockaddr;
1156 }
1157 else
1158 hdr.msg_namelen = 0;
1159
1160 hdr.msg_iov = iov;
1161 hdr.msg_iovlen = count;
1162 #ifdef HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS
1163 hdr.msg_accrights = NULL;
1164 hdr.msg_accrightslen = 0;
1165 #else
1166 hdr.msg_control = NULL;
1167 hdr.msg_controllen = 0;
1168 hdr.msg_flags = 0;
1169 #endif
1170
1171 if ( (n = recvmsg(fd, &hdr, *lpFlags)) == -1 )
1172 {
1173 TRACE( "recvmsg error %d\n", errno);
1174 return -1;
1175 }
1176
1177 if ( lpFrom &&
1178 ws_sockaddr_u2ws( &unix_sockaddr.addr, lpFrom, lpFromlen ) != 0 )
1179 {
1180 /* The from buffer was too small, but we read the data
1181 * anyway. Is that really bad?
1182 */
1183 WARN( "Address buffer too small\n" );
1184 }
1185
1186 TRACE("-> %d\n", n);
1187 return n;
1188 }
1189
1190 /***********************************************************************
1191 * WS2_async_recv (INTERNAL)
1192 *
1193 * Handler for overlapped recv() operations.
1194 */
1195 static NTSTATUS WS2_async_recv( void* user, IO_STATUS_BLOCK* iosb, NTSTATUS status)
1196 {
1197 ws2_async* wsa = user;
1198 int result = 0, fd;
1199
1200 TRACE( "(%p %p %x)\n", wsa, iosb, status );
1201
1202 switch (status)
1203 {
1204 case STATUS_ALERTED:
1205 if ((status = wine_server_handle_to_fd( wsa->hSocket, FILE_READ_DATA, &fd, NULL ) ))
1206 break;
1207
1208 result = WS2_recv( fd, wsa->iovec, wsa->n_iovecs,
1209 wsa->addr, wsa->addrlen.ptr, &wsa->flags );
1210 wine_server_release_fd( wsa->hSocket, fd );
1211 if (result >= 0)
1212 {
1213 status = STATUS_SUCCESS;
1214 TRACE( "received %d bytes\n", result );
1215 _enable_event( wsa->hSocket, FD_READ, 0, 0 );
1216 }
1217 else
1218 {
1219 if (errno == EINTR || errno == EAGAIN)
1220 {
1221 status = STATUS_PENDING;
1222 _enable_event( wsa->hSocket, FD_READ, 0, 0 );
1223 TRACE( "still pending\n" );
1224 }
1225 else
1226 {
1227 result = 0;
1228 status = wsaErrno(); /* FIXME: is this correct ???? */
1229 TRACE( "Error: %x\n", status );
1230 }
1231 }
1232 break;
1233 }
1234 if (status != STATUS_PENDING) ws2_async_terminate(wsa, iosb, status, result);
1235 return status;
1236 }
1237
1238 /***********************************************************************
1239 * WS2_send (INTERNAL)
1240 *
1241 * Workhorse for both synchronous and asynchronous send() operations.
1242 */
1243 static int WS2_send( int fd, struct iovec* iov, int count,
1244 const struct WS_sockaddr *to, INT tolen, DWORD dwFlags )
1245 {
1246 struct msghdr hdr;
1247 union generic_unix_sockaddr unix_addr;
1248
1249 TRACE( "fd %d, iovec %p, count %d, addr %s, len %d, flags %x\n",
1250 fd, iov, count, debugstr_sockaddr(to), tolen, dwFlags);
1251
1252 hdr.msg_name = NULL;
1253
1254 if ( to )
1255 {
1256 hdr.msg_name = &unix_addr;
1257 hdr.msg_namelen = ws_sockaddr_ws2u( to, tolen, &unix_addr );
1258 if ( !hdr.msg_namelen )
1259 {
1260 errno = EFAULT;
1261 return -1;
1262 }
1263
1264 #ifdef HAVE_IPX
1265 if(to->sa_family == WS_AF_IPX)
1266 {
1267 #ifdef SOL_IPX
1268 struct sockaddr_ipx* uipx = (struct sockaddr_ipx*)hdr.msg_name;
1269 int val=0;
1270 unsigned int len=sizeof(int);
1271
1272 /* The packet type is stored at the ipx socket level; At least the linux kernel seems
1273 * to do something with it in case hdr.msg_name is NULL. Nonetheless can we use it to store
1274 * the packet type and then we can retrieve it using getsockopt. After that we can set the
1275 * ipx type in the sockaddr_opx structure with the stored value.
1276 */
1277 if(getsockopt(fd, SOL_IPX, IPX_TYPE, &val, &len) != -1)
1278 {
1279 TRACE("ptype: %d (fd:%d)\n", val, fd);
1280 uipx->sipx_type = val;
1281 }
1282 #endif
1283 }
1284 #endif
1285
1286 }
1287 else
1288 hdr.msg_namelen = 0;
1289
1290 hdr.msg_iov = iov;
1291 hdr.msg_iovlen = count;
1292 #ifdef HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS
1293 hdr.msg_accrights = NULL;
1294 hdr.msg_accrightslen = 0;
1295 #else
1296 hdr.msg_control = NULL;
1297 hdr.msg_controllen = 0;
1298 hdr.msg_flags = 0;
1299 #endif
1300
1301 return sendmsg(fd, &hdr, dwFlags);
1302 }
1303
1304 /***********************************************************************
1305 * WS2_async_send (INTERNAL)
1306 *
1307 * Handler for overlapped send() operations.
1308 */
1309 static NTSTATUS WS2_async_send(void* user, IO_STATUS_BLOCK* iosb, NTSTATUS status)
1310 {
1311 ws2_async* wsa = user;
1312 int result = 0, fd;
1313
1314 TRACE( "(%p %p %x)\n", wsa, iosb, status );
1315
1316 switch (status)
1317 {
1318 case STATUS_ALERTED:
1319 if ((status = wine_server_handle_to_fd( wsa->hSocket, FILE_WRITE_DATA, &fd, NULL ) ))
1320 break;
1321
1322 /* check to see if the data is ready (non-blocking) */
1323 result = WS2_send( fd, wsa->iovec, wsa->n_iovecs, wsa->addr, wsa->addrlen.val, wsa->flags );
1324 wine_server_release_fd( wsa->hSocket, fd );
1325
1326 if (result >= 0)
1327 {
1328 status = STATUS_SUCCESS;
1329 TRACE( "sent %d bytes\n", result );
1330 _enable_event( wsa->hSocket, FD_WRITE, 0, 0 );
1331 }
1332 else
1333 {
1334 if (errno == EINTR || errno == EAGAIN)
1335 {
1336 status = STATUS_PENDING;
1337 _enable_event( wsa->hSocket, FD_WRITE, 0, 0 );
1338 TRACE( "still pending\n" );
1339 }
1340 else
1341 {
1342 /* We set the status to a winsock error code and check for that
1343 later in NtStatusToWSAError () */
1344 status = wsaErrno();
1345 result = 0;
1346 TRACE( "Error: %x\n", status );
1347 }
1348 }
1349 break;
1350 }
1351 if (status != STATUS_PENDING) ws2_async_terminate(wsa, iosb, status, result);
1352 return status;
1353 }
1354
1355 /***********************************************************************
1356 * WS2_async_shutdown (INTERNAL)
1357 *
1358 * Handler for shutdown() operations on overlapped sockets.
1359 */
1360 static NTSTATUS WS2_async_shutdown( void* user, PIO_STATUS_BLOCK iosb, NTSTATUS status )
1361 {
1362 ws2_async* wsa = user;
1363 int fd, err = 1;
1364
1365 TRACE( "async %p %d\n", wsa, wsa->mode );
1366 switch (status)
1367 {
1368 case STATUS_ALERTED:
1369 if ((status = wine_server_handle_to_fd( wsa->hSocket, 0, &fd, NULL ) ))
1370 break;
1371
1372 switch ( wsa->mode )
1373 {
1374 case ws2m_sd_read: err = shutdown( fd, 0 ); break;
1375 case ws2m_sd_write: err = shutdown( fd, 1 ); break;
1376 default: ERR("invalid mode: %d\n", wsa->mode );
1377 }
1378 wine_server_release_fd( wsa->hSocket, fd );
1379 status = err ? wsaErrno() : STATUS_SUCCESS;
1380 break;
1381 }
1382 ws2_async_terminate(wsa, iosb, status, 0);
1383 return status;
1384 }
1385
1386 /***********************************************************************
1387 * WS2_register_async_shutdown (INTERNAL)
1388 *
1389 * Helper function for WS_shutdown() on overlapped sockets.
1390 */
1391 static int WS2_register_async_shutdown( SOCKET s, enum ws2_mode mode )
1392 {
1393 struct ws2_async *wsa;
1394 int ret, err = WSAEFAULT;
1395 DWORD dwflags = 0;
1396 int len = 0;
1397 LPWSAOVERLAPPED ovl = HeapAlloc(GetProcessHeap(), 0, sizeof( WSAOVERLAPPED ));
1398 IO_STATUS_BLOCK *iosb = NULL;
1399
1400 TRACE("s %ld mode %d\n", s, mode);
1401 if (!ovl)
1402 goto out;
1403
1404 ovl->hEvent = WSACreateEvent();
1405 if ( ovl->hEvent == WSA_INVALID_EVENT )
1406 goto out_free;
1407
1408 wsa = WS2_make_async( s, mode, NULL, 0, &dwflags, NULL, &len, ovl, NULL, &iosb );
1409 if ( !wsa )
1410 goto out_close;
1411
1412 /* Hack: this will cause ws2_async_terminate() to free the overlapped structure */
1413 wsa->user_overlapped = NULL;
1414 if ((ret = ws2_queue_async( wsa, iosb )) != STATUS_PENDING)
1415 {
1416 err = NtStatusToWSAError( ret );
1417 goto out;
1418 }
1419 /* Try immediate completion */
1420 while ( WaitForSingleObjectEx( ovl->hEvent, 0, TRUE ) == STATUS_USER_APC );
1421 return 0;
1422
1423 out_close:
1424 WSACloseEvent( ovl->hEvent );
1425 out_free:
1426 HeapFree( GetProcessHeap(), 0, ovl );
1427 out:
1428 return err;
1429 }
1430
1431 /***********************************************************************
1432 * accept (WS2_32.1)
1433 */
1434 SOCKET WINAPI WS_accept(SOCKET s, struct WS_sockaddr *addr,
1435 int *addrlen32)
1436 {
1437 SOCKET as;
1438 BOOL is_blocking;
1439
1440 TRACE("socket %04lx\n", s );
1441 is_blocking = _is_blocking(s);
1442
1443 do {
1444 if (is_blocking)
1445 {
1446 int fd = get_sock_fd( s, FILE_READ_DATA, NULL );
1447 if (fd == -1) return INVALID_SOCKET;
1448 /* block here */
1449 do_block(fd, POLLIN, -1);
1450 _sync_sock_state(s); /* let wineserver notice connection */
1451 release_sock_fd( s, fd );
1452 /* retrieve any error codes from it */
1453 SetLastError(_get_sock_error(s, FD_ACCEPT_BIT));
1454 /* FIXME: care about the error? */
1455 }
1456 SERVER_START_REQ( accept_socket )
1457 {
1458 req->lhandle = SOCKET2HANDLE(s);
1459 req->access = GENERIC_READ|GENERIC_WRITE|SYNCHRONIZE;
1460 req->attributes = OBJ_INHERIT;
1461 set_error( wine_server_call( req ) );
1462 as = HANDLE2SOCKET( reply->handle );
1463 }
1464 SERVER_END_REQ;
1465 if (as)
1466 {
1467 if (addr) WS_getpeername(as, addr, addrlen32);
1468 return as;
1469 }
1470 } while (is_blocking);
1471 return INVALID_SOCKET;
1472 }
1473
1474 /***********************************************************************
1475 * bind (WS2_32.2)
1476 */
1477 int WINAPI WS_bind(SOCKET s, const struct WS_sockaddr* name, int namelen)
1478 {
1479 int fd = get_sock_fd( s, 0, NULL );
1480 int res = SOCKET_ERROR;
1481
1482 TRACE("socket %04lx, ptr %p %s, length %d\n", s, name, debugstr_sockaddr(name), namelen);
1483
1484 if (fd != -1)
1485 {
1486 if (!name || (name->sa_family && !SUPPORTED_PF(name->sa_family)))
1487 {
1488 SetLastError(WSAEAFNOSUPPORT);
1489 }
1490 else
1491 {
1492 union generic_unix_sockaddr uaddr;
1493 unsigned int uaddrlen = ws_sockaddr_ws2u(name, namelen, &uaddr);
1494 if (!uaddrlen)
1495 {
1496 SetLastError(WSAEFAULT);
1497 }
1498 else
1499 {
1500 if (bind(fd, &uaddr.addr, uaddrlen) < 0)
1501 {
1502 int loc_errno = errno;
1503 WARN("\tfailure - errno = %i\n", errno);
1504 errno = loc_errno;
1505 switch (errno)
1506 {
1507 case EBADF:
1508 SetLastError(WSAENOTSOCK);
1509 break;
1510 case EADDRNOTAVAIL:
1511 SetLastError(WSAEINVAL);
1512 break;
1513 default:
1514 SetLastError(wsaErrno());
1515 break;
1516 }
1517 }
1518 else
1519 {
1520 res=0; /* success */
1521 }
1522 }
1523 }
1524 release_sock_fd( s, fd );
1525 }
1526 return res;
1527 }
1528
1529 /***********************************************************************
1530 * closesocket (WS2_32.3)
1531 */
1532 int WINAPI WS_closesocket(SOCKET s)
1533 {
1534 TRACE("socket %04lx\n", s);
1535 if (CloseHandle(SOCKET2HANDLE(s))) return 0;
1536 return SOCKET_ERROR;
1537 }
1538
1539 /***********************************************************************
1540 * connect (WS2_32.4)
1541 */
1542 int WINAPI WS_connect(SOCKET s, const struct WS_sockaddr* name, int namelen)
1543 {
1544 int fd = get_sock_fd( s, FILE_READ_DATA, NULL );
1545
1546 TRACE("socket %04lx, ptr %p %s, length %d\n", s, name, debugstr_sockaddr(name), namelen);
1547
1548 if (fd != -1)
1549 {
1550 union generic_unix_sockaddr uaddr;
1551 unsigned int uaddrlen = ws_sockaddr_ws2u(name, namelen, &uaddr);
1552
1553 if (!uaddrlen)
1554 {
1555 SetLastError(WSAEFAULT);
1556 }
1557 else
1558 {
1559 if (connect(fd, &uaddr.addr, uaddrlen) == 0)
1560 goto connect_success;
1561 }
1562
1563 if (errno == EINPROGRESS)
1564 {
1565 /* tell wineserver that a connection is in progress */
1566 _enable_event(SOCKET2HANDLE(s), FD_CONNECT|FD_READ|FD_WRITE,
1567 FD_CONNECT|FD_READ|FD_WRITE,
1568 FD_WINE_CONNECTED|FD_WINE_LISTENING);
1569 if (_is_blocking(s))
1570 {
1571 int result;
1572 /* block here */
1573 do_block(fd, POLLIN | POLLOUT, -1);
1574 _sync_sock_state(s); /* let wineserver notice connection */
1575 /* retrieve any error codes from it */
1576 result = _get_sock_error(s, FD_CONNECT_BIT);
1577 if (result)
1578 SetLastError(result);
1579 else
1580 {
1581 goto connect_success;
1582 }
1583 }
1584 else
1585 {
1586 SetLastError(WSAEWOULDBLOCK);
1587 }
1588 }
1589 else
1590 {
1591 SetLastError(wsaErrno());
1592 }
1593 release_sock_fd( s, fd );
1594 }
1595 return SOCKET_ERROR;
1596
1597 connect_success:
1598 release_sock_fd( s, fd );
1599 _enable_event(SOCKET2HANDLE(s), FD_CONNECT|FD_READ|FD_WRITE,
1600 FD_WINE_CONNECTED|FD_READ|FD_WRITE,
1601 FD_CONNECT|FD_WINE_LISTENING);
1602 return 0;
1603 }
1604
1605 /***********************************************************************
1606 * WSAConnect (WS2_32.30)
1607 */
1608 int WINAPI WSAConnect( SOCKET s, const struct WS_sockaddr* name, int namelen,
1609 LPWSABUF lpCallerData, LPWSABUF lpCalleeData,
1610 LPQOS lpSQOS, LPQOS lpGQOS )
1611 {
1612 if ( lpCallerData || lpCalleeData || lpSQOS || lpGQOS )
1613 FIXME("unsupported parameters!\n");
1614 return WS_connect( s, name, namelen );
1615 }
1616
1617
1618 /***********************************************************************
1619 * getpeername (WS2_32.5)
1620 */
1621 int WINAPI WS_getpeername(SOCKET s, struct WS_sockaddr *name, int *namelen)
1622 {
1623 int fd;
1624 int res;
1625
1626 TRACE("socket: %04lx, ptr %p, len %08x\n", s, name, *namelen);
1627
1628 /* Check if what we've received is valid. Should we use IsBadReadPtr? */
1629 if( (name == NULL) || (namelen == NULL) )
1630 {
1631 SetLastError( WSAEFAULT );
1632 return SOCKET_ERROR;
1633 }
1634
1635 fd = get_sock_fd( s, 0, NULL );
1636 res = SOCKET_ERROR;
1637
1638 if (fd != -1)
1639 {
1640 union generic_unix_sockaddr uaddr;
1641 unsigned int uaddrlen = sizeof(uaddr);
1642
1643 if (getpeername(fd, &uaddr.addr, &uaddrlen) != 0)
1644 {
1645 SetLastError(wsaErrno());
1646 }
1647 else if (ws_sockaddr_u2ws(&uaddr.addr, name, namelen) != 0)
1648 {
1649 /* The buffer was too small */
1650 SetLastError(WSAEFAULT);
1651 }
1652 else
1653 {
1654 res=0;
1655 }
1656 release_sock_fd( s, fd );
1657 }
1658 return res;
1659 }
1660
1661 /***********************************************************************
1662 * getsockname (WS2_32.6)
1663 */
1664 int WINAPI WS_getsockname(SOCKET s, struct WS_sockaddr *name, int *namelen)
1665 {
1666 int fd;
1667 int res;
1668
1669 TRACE("socket: %04lx, ptr %p, len %8x\n", s, name, *namelen);
1670
1671 /* Check if what we've received is valid. Should we use IsBadReadPtr? */
1672 if( (name == NULL) || (namelen == NULL) )
1673 {
1674 SetLastError( WSAEFAULT );
1675 return SOCKET_ERROR;
1676 }
1677
1678 fd = get_sock_fd( s, 0, NULL );
1679 res = SOCKET_ERROR;
1680
1681 if (fd != -1)
1682 {
1683 union generic_unix_sockaddr uaddr;
1684 unsigned int uaddrlen = sizeof(uaddr);
1685
1686 if (getsockname(fd, &uaddr.addr, &uaddrlen) != 0)
1687 {
1688 SetLastError(wsaErrno());
1689 }
1690 else if (ws_sockaddr_u2ws(&uaddr.addr, name, namelen) != 0)
1691 {
1692 /* The buffer was too small */
1693 SetLastError(WSAEFAULT);
1694 }
1695 else
1696 {
1697 res=0;
1698 }
1699 release_sock_fd( s, fd );
1700 }
1701 return res;
1702 }
1703
1704 /***********************************************************************
1705 * getsockopt (WS2_32.7)
1706 */
1707 INT WINAPI WS_getsockopt(SOCKET s, INT level,
1708 INT optname, char *optval, INT *optlen)
1709 {
1710 int fd;
1711 INT ret = 0;
1712
1713 TRACE("socket: %04lx, level 0x%x, name 0x%x, ptr %p, len %d\n",
1714 s, level, optname, optval, *optlen);
1715
1716 switch(level)
1717 {
1718 case WS_SOL_SOCKET:
1719 {
1720 switch(optname)
1721 {
1722 /* Handle common cases. The special cases are below, sorted
1723 * alphabetically */
1724 case WS_SO_ACCEPTCONN:
1725 case WS_SO_BROADCAST:
1726 case WS_SO_DEBUG:
1727 case WS_SO_ERROR:
1728 case WS_SO_KEEPALIVE:
1729 case WS_SO_OOBINLINE:
1730 case WS_SO_RCVBUF:
1731 case WS_SO_SNDBUF:
1732 case WS_SO_TYPE:
1733 if ( (fd = get_sock_fd( s, 0, NULL )) == -1)
1734 return SOCKET_ERROR;
1735 convert_sockopt(&level, &optname);
1736 if (getsockopt(fd,(int) level, optname, optval,
1737 (unsigned int *)optlen) != 0 )
1738 {
1739 SetLastError((errno == EBADF) ? WSAENOTSOCK : wsaErrno());
1740 ret = SOCKET_ERROR;
1741 }
1742 release_sock_fd( s, fd );
1743 return ret;
1744
1745 case WS_SO_DONTLINGER:
1746 {
1747 struct linger lingval;
1748 unsigned int len = sizeof(struct linger);
1749
1750 if (!optlen || *optlen < sizeof(BOOL)|| !optval)
1751 {
1752 SetLastError(WSAEFAULT);
1753 return SOCKET_ERROR;
1754 }
1755 if ( (fd = get_sock_fd( s, 0, NULL )) == -1)
1756 return SOCKET_ERROR;
1757
1758 if (getsockopt(fd, SOL_SOCKET, SO_LINGER, &lingval, &len) != 0 )
1759 {
1760 SetLastError((errno == EBADF) ? WSAENOTSOCK : wsaErrno());
1761 ret = SOCKET_ERROR;
1762 }
1763 else
1764 {
1765 *(BOOL *)optval = (lingval.l_onoff) ? FALSE : TRUE;
1766 *optlen = sizeof(BOOL);
1767 }
1768
1769 release_sock_fd( s, fd );
1770 return ret;
1771 }
1772
1773 /* As mentioned in setsockopt, Windows ignores this, so we
1774 * always return true here */
1775 case WS_SO_DONTROUTE:
1776 if (!optlen || *optlen < sizeof(BOOL) || !optval)
1777 {
1778 SetLastError(WSAEFAULT);
1779 return SOCKET_ERROR;
1780 }
1781 *(BOOL *)optval = TRUE;
1782 *optlen = sizeof(BOOL);
1783 return 0;
1784
1785 case WS_SO_LINGER:
1786 {
1787 struct linger lingval;
1788 unsigned int len = sizeof(struct linger);
1789
1790 /* struct linger and LINGER have different sizes */
1791 if (!optlen || *optlen < sizeof(LINGER) || !optval)
1792 {
1793 SetLastError(WSAEFAULT);
1794 return SOCKET_ERROR;
1795 }
1796 if ( (fd = get_sock_fd( s, 0, NULL )) == -1)
1797 return SOCKET_ERROR;
1798
1799 if (getsockopt(fd, SOL_SOCKET, SO_LINGER, &lingval, &len) != 0 )
1800 {
1801 SetLastError((errno == EBADF) ? WSAENOTSOCK : wsaErrno());
1802 ret = SOCKET_ERROR;
1803 }
1804 else
1805 {
1806 ((LINGER *)optval)->l_onoff = lingval.l_onoff;
1807 ((LINGER *)optval)->l_linger = lingval.l_linger;
1808 *optlen = sizeof(struct linger);
1809 }
1810
1811 release_sock_fd( s, fd );
1812 return ret;
1813 }
1814
1815 case WS_SO_MAX_MSG_SIZE:
1816 if (!optlen || *optlen < sizeof(int) || !optval)
1817 {
1818 SetLastError(WSAEFAULT);
1819 return SOCKET_ERROR;
1820 }
1821 TRACE("getting global SO_MAX_MSG_SIZE = 65507\n");
1822 *(int *)optval = 65507;
1823 *optlen = sizeof(int);
1824 return 0;
1825
1826 /* SO_OPENTYPE does not require a valid socket handle. */
1827 case WS_SO_OPENTYPE:
1828 if (!optlen || *optlen < sizeof(int) || !optval)
1829 {
1830 SetLastError(WSAEFAULT);
1831 return SOCKET_ERROR;
1832 }
1833 *(int *)optval = get_per_thread_data()->opentype;
1834 *optlen = sizeof(int);
1835 TRACE("getting global SO_OPENTYPE = 0x%x\n", *((int*)optval) );
1836 return 0;
1837
1838 #ifdef SO_RCVTIMEO
1839 case WS_SO_RCVTIMEO:
1840 #endif
1841 #ifdef SO_SNDTIMEO
1842 case WS_SO_SNDTIMEO:
1843 #endif
1844 #if defined(SO_RCVTIMEO) || defined(SO_SNDTIMEO)
1845 {
1846 struct timeval tv;
1847 unsigned int len = sizeof(struct timeval);
1848
1849 if (!optlen || *optlen < sizeof(int)|| !optval)
1850 {
1851 SetLastError(WSAEFAULT);
1852 return SOCKET_ERROR;
1853 }
1854 if ( (fd = get_sock_fd( s, 0, NULL )) == -1)
1855 return SOCKET_ERROR;
1856
1857 convert_sockopt(&level, &optname);
1858 if (getsockopt(fd,(int) level, optname, &tv, &len) != 0 )
1859 {
1860 SetLastError((errno == EBADF) ? WSAENOTSOCK : wsaErrno());
1861 ret = SOCKET_ERROR;
1862 }
1863 else
1864 {
1865 *(int *)optval = tv.tv_sec * 1000 + tv.tv_usec / 1000;
1866 *optlen = sizeof(int);
1867 }
1868
1869 release_sock_fd( s, fd );
1870 return ret;
1871 }
1872 #endif
1873 /* As mentioned in setsockopt, the windows style SO_REUSEADDR is
1874 * not possible in Unix, so always return false here. */
1875 case WS_SO_REUSEADDR:
1876 if (!optlen || *optlen < sizeof(int) || !optval)
1877 {
1878 SetLastError(WSAEFAULT);
1879 return SOCKET_ERROR;
1880 }
1881 *(int *)optval = 0;
1882 *optlen = sizeof(int);
1883 return 0;
1884
1885 default:
1886 TRACE("Unknown SOL_SOCKET optname: 0x%08x\n", optname);
1887 SetLastError(WSAENOPROTOOPT);
1888 return SOCKET_ERROR;
1889 } /* end switch(optname) */
1890 }/* end case WS_SOL_SOCKET */
1891 #ifdef HAVE_IPX
1892 case NSPROTO_IPX:
1893 {
1894 struct WS_sockaddr_ipx addr;
1895 IPX_ADDRESS_DATA *data;
1896 int namelen;
1897 switch(optname)
1898 {
1899 case IPX_PTYPE:
1900 if ((fd = get_sock_fd( s, 0, NULL )) == -1) return SOCKET_ERROR;
1901 #ifdef SOL_IPX
1902 if(getsockopt(fd, SOL_IPX, IPX_TYPE, optval, (unsigned int*)optlen) == -1)
1903 {
1904 ret = SOCKET_ERROR;
1905 }
1906 #else
1907 {
1908 struct ipx val;
1909 socklen_t len=sizeof(struct ipx);
1910 if(getsockopt(fd, 0, SO_DEFAULT_HEADERS, &val, &len) == -1 )
1911 ret = SOCKET_ERROR;
1912 else
1913 *optval = (int)val.ipx_pt;
1914 }
1915 #endif
1916 TRACE("ptype: %d (fd: %d)\n", *(int*)optval, fd);
1917 release_sock_fd( s, fd );
1918 return ret;
1919
1920 case IPX_ADDRESS:
1921 /*
1922 * On a Win2000 system with one network card there are usually
1923 * three ipx devices one with a speed of 28.8kbps, 10Mbps and 100Mbps.
1924 * Using this call you can then retrieve info about this all.
1925 * In case of Linux it is a bit different. Usually you have
1926 * only "one" device active and further it is not possible to
1927 * query things like the linkspeed.
1928 */
1929 FIXME("IPX_ADDRESS\n");
1930 namelen = sizeof(struct WS_sockaddr_ipx);
1931 memset(&addr, 0, sizeof(struct WS_sockaddr_ipx));
1932 WS_getsockname(s, (struct WS_sockaddr*)&addr, &namelen);
1933
1934 data = (IPX_ADDRESS_DATA*)optval;
1935 memcpy(data->nodenum,&addr.sa_nodenum,sizeof(data->nodenum));
1936 memcpy(data->netnum,&addr.sa_netnum,sizeof(data->netnum));
1937 data->adapternum = 0;
1938 data->wan = FALSE; /* We are not on a wan for now .. */
1939 data->status = FALSE; /* Since we are not on a wan, the wan link isn't up */
1940 data->maxpkt = 1467; /* This value is the default one, at least on Win2k/WinXP */
1941 data->linkspeed = 100000; /* Set the line speed in 100bit/s to 10 Mbit;
1942 * note 1MB = 1000kB in this case */
1943 return 0;
1944
1945 case IPX_MAX_ADAPTER_NUM:
1946 FIXME("IPX_MAX_ADAPTER_NUM\n");
1947 *(int*)optval = 1; /* As noted under IPX_ADDRESS we have just one card. */
1948 return 0;
1949
1950 default:
1951 FIXME("IPX optname:%x\n", optname);
1952 return SOCKET_ERROR;
1953 }/* end switch(optname) */
1954 } /* end case NSPROTO_IPX */
1955 #endif
1956 /* Levels WS_IPPROTO_TCP and WS_IPPROTO_IP convert directly */
1957 case WS_IPPROTO_TCP:
1958 switch(optname)
1959 {
1960 case WS_TCP_NODELAY:
1961 if ( (fd = get_sock_fd( s, 0, NULL )) == -1)
1962 return SOCKET_ERROR;
1963 convert_sockopt(&level, &optname);
1964 if (getsockopt(fd,(int) level, optname, optval,
1965 (unsigned int *)optlen) != 0 )
1966 {
1967 SetLastError((errno == EBADF) ? WSAENOTSOCK : wsaErrno());
1968 ret = SOCKET_ERROR;
1969 }
1970 release_sock_fd( s, fd );
1971 return ret;
1972 }
1973 FIXME("Unknown IPPROTO_TCP optname 0x%08x\n", optname);
1974 return SOCKET_ERROR;
1975
1976 case WS_IPPROTO_IP:
1977 switch(optname)
1978 {
1979 case WS_IP_ADD_MEMBERSHIP:
1980 case WS_IP_DROP_MEMBERSHIP:
1981 #ifdef IP_HDRINCL
1982 case WS_IP_HDRINCL:
1983 #endif
1984 case WS_IP_MULTICAST_IF:
1985 case WS_IP_MULTICAST_LOOP:
1986 case WS_IP_MULTICAST_TTL:
1987 case WS_IP_OPTIONS:
1988 case WS_IP_TOS:
1989 case WS_IP_TTL:
1990 if ( (fd = get_sock_fd( s, 0, NULL )) == -1)
1991 return SOCKET_ERROR;
1992 convert_sockopt(&level, &optname);
1993 if (getsockopt(fd,(int) level, optname, optval,
1994 (unsigned int *)optlen) != 0 )
1995 {
1996 SetLastError((errno == EBADF) ? WSAENOTSOCK : wsaErrno());
1997 ret = SOCKET_ERROR;
1998 }
1999 release_sock_fd( s, fd );
2000 return ret;
2001 }
2002 FIXME("Unknown IPPROTO_IP optname 0x%08x\n", optname);
2003 return SOCKET_ERROR;
2004
2005 default:
2006 FIXME("Unknown level: 0x%08x\n", level);
2007 return SOCKET_ERROR;
2008 } /* end switch(level) */
2009 }
2010
2011 /***********************************************************************
2012 * htonl (WINSOCK.8)
2013 * htonl (WS2_32.8)
2014 */
2015 WS_u_long WINAPI WS_htonl(WS_u_long hostlong)
2016 {
2017 return htonl(hostlong);
2018 }
2019
2020
2021 /***********************************************************************
2022 * htons (WINSOCK.9)
2023 * htons (WS2_32.9)
2024 */
2025 WS_u_short WINAPI WS_htons(WS_u_short hostshort)
2026 {
2027 return htons(hostshort);
2028 }
2029
2030 /***********************************************************************
2031 * WSAHtonl (WS2_32.46)
2032 * From MSDN decription of error codes, this function should also
2033 * check if WinSock has been initialized and the socket is a valid
2034 * socket. But why? This function only translates a host byte order
2035 * u_long into a network byte order u_long...
2036 */
2037 int WINAPI WSAHtonl(SOCKET s, WS_u_long hostlong, WS_u_long *lpnetlong)
2038 {
2039 if (lpnetlong)
2040 {
2041 *lpnetlong = htonl(hostlong);
2042 return 0;
2043 }
2044 WSASetLastError(WSAEFAULT);
2045 return SOCKET_ERROR;
2046 }
2047
2048 /***********************************************************************
2049 * WSAHtons (WS2_32.47)
2050 * From MSDN decription of error codes, this function should also
2051 * check if WinSock has been initialized and the socket is a valid
2052 * socket. But why? This function only translates a host byte order
2053 * u_short into a network byte order u_short...
2054 */
2055 int WINAPI WSAHtons(SOCKET s, WS_u_short hostshort, WS_u_short *lpnetshort)
2056 {
2057
2058 if (lpnetshort)
2059 {
2060 *lpnetshort = htons(hostshort);
2061 return 0;
2062 }
2063 WSASetLastError(WSAEFAULT);
2064 return SOCKET_ERROR;
2065 }
2066
2067
2068 /***********************************************************************
2069 * inet_addr (WINSOCK.10)
2070 * inet_addr (WS2_32.11)
2071 */
2072 WS_u_long WINAPI WS_inet_addr(const char *cp)
2073 {
2074 if (!cp) return INADDR_NONE;
2075 return inet_addr(cp);
2076 }
2077
2078
2079 /***********************************************************************
2080 * ntohl (WINSOCK.14)
2081 * ntohl (WS2_32.14)
2082 */
2083 WS_u_long WINAPI WS_ntohl(WS_u_long netlong)
2084 {
2085 return ntohl(netlong);
2086 }
2087
2088
2089 /***********************************************************************
2090 * ntohs (WINSOCK.15)
2091 * ntohs (WS2_32.15)
2092 */
2093 WS_u_short WINAPI WS_ntohs(WS_u_short netshort)
2094 {
2095 return ntohs(netshort);
2096 }
2097
2098
2099 /***********************************************************************
2100 * inet_ntoa (WS2_32.12)
2101 */
2102 char* WINAPI WS_inet_ntoa(struct WS_in_addr in)
2103 {
2104 /* use "buffer for dummies" here because some applications have a
2105 * propensity to decode addresses in ws_hostent structure without
2106 * saving them first...
2107 */
2108 static char dbuffer[16]; /* Yes, 16: 4*3 digits + 3 '.' + 1 '\0' */
2109
2110 char* s = inet_ntoa(*((struct in_addr*)&in));
2111 if( s )
2112 {
2113 strcpy(dbuffer, s);
2114 return dbuffer;
2115 }
2116 SetLastError(wsaErrno());
2117 return NULL;
2118 }
2119
2120 /**********************************************************************
2121 * WSAIoctl (WS2_32.50)
2122 *
2123 */
2124 INT WINAPI WSAIoctl(SOCKET s,
2125 DWORD dwIoControlCode,
2126 LPVOID lpvInBuffer,
2127 DWORD cbInBuffer,
2128 LPVOID lpbOutBuffer,
2129 DWORD cbOutBuffer,
2130 LPDWORD lpcbBytesReturned,
2131 LPWSAOVERLAPPED lpOverlapped,
2132 LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
2133 {
2134 TRACE("%ld, 0x%08x, %p, %d, %p, %d, %p, %p, %p\n",
2135 s, dwIoControlCode, lpvInBuffer, cbInBuffer, lpbOutBuffer,
2136 cbOutBuffer, lpcbBytesReturned, lpOverlapped, lpCompletionRoutine);
2137
2138 switch( dwIoControlCode )
2139 {
2140 case WS_FIONBIO:
2141 if (cbInBuffer != sizeof(WS_u_long)) {
2142 WSASetLastError(WSAEFAULT);
2143 return SOCKET_ERROR;
2144 }
2145 return WS_ioctlsocket( s, WS_FIONBIO, lpvInBuffer);
2146
2147 case WS_FIONREAD:
2148 if (cbOutBuffer != sizeof(WS_u_long)) {
2149 WSASetLastError(WSAEFAULT);
2150 return SOCKET_ERROR;
2151 }
2152 return WS_ioctlsocket( s, WS_FIONREAD, lpbOutBuffer);
2153
2154 case WS_SIO_GET_INTERFACE_LIST:
2155 {
2156 INTERFACE_INFO* intArray = (INTERFACE_INFO*)lpbOutBuffer;
2157 DWORD size, numInt, apiReturn;
2158 int fd;
2159
2160 TRACE("-> SIO_GET_INTERFACE_LIST request\n");
2161
2162 if (!lpbOutBuffer)
2163 {
2164 WSASetLastError(WSAEFAULT);
2165 return SOCKET_ERROR;
2166 }
2167 if (!lpcbBytesReturned)
2168 {
2169 WSASetLastError(WSAEFAULT);
2170 return SOCKET_ERROR;
2171 }
2172
2173 fd = get_sock_fd( s, 0, NULL );
2174 if (fd == -1) return SOCKET_ERROR;
2175
2176 apiReturn = GetAdaptersInfo(NULL, &size);
2177 if (apiReturn == ERROR_NO_DATA)
2178 {
2179 numInt = 0;
2180 }
2181 else if (apiReturn == ERROR_BUFFER_OVERFLOW)
2182 {
2183 PIP_ADAPTER_INFO table = HeapAlloc(GetProcessHeap(),0,size);
2184
2185 if (table)
2186 {
2187 if (GetAdaptersInfo(table, &size) == NO_ERROR)
2188 {
2189 PIP_ADAPTER_INFO ptr;
2190
2191 if (size*sizeof(INTERFACE_INFO)/sizeof(IP_ADAPTER_INFO) > cbOutBuffer)
2192 {
2193 WARN("Buffer too small = %u, cbOutBuffer = %u\n", size, cbOutBuffer);
2194 HeapFree(GetProcessHeap(),0,table);
2195 release_sock_fd( s, fd );
2196 WSASetLastError(WSAEFAULT);
2197 return SOCKET_ERROR;
2198 }
2199 for (ptr = table, numInt = 0; ptr;
2200 ptr = ptr->Next, intArray++, numInt++)
2201 {
2202 unsigned int addr, mask, bcast;
2203 struct ifreq ifInfo;
2204
2205 /* Socket Status Flags */
2206 lstrcpynA(ifInfo.ifr_name, ptr->AdapterName, IFNAMSIZ);
2207 if (ioctl(fd, SIOCGIFFLAGS, &ifInfo) < 0)
2208 {
2209 ERR("Error obtaining status flags for socket!\n");
2210 HeapFree(GetProcessHeap(),0,table);
2211 release_sock_fd( s, fd );
2212 WSASetLastError(WSAEINVAL);
2213 return SOCKET_ERROR;
2214 }
2215 else
2216 {
2217 /* set flags; the values of IFF_* are not the same
2218 under Linux and Windows, therefore must generate
2219 new flags */
2220 intArray->iiFlags = 0;
2221 if (ifInfo.ifr_flags & IFF_BROADCAST)
2222 intArray->iiFlags |= WS_IFF_BROADCAST;
2223 #ifdef IFF_POINTOPOINT
2224 if (ifInfo.ifr_flags & IFF_POINTOPOINT)
2225 intArray->iiFlags |= WS_IFF_POINTTOPOINT;
2226 #endif
2227 if (ifInfo.ifr_flags & IFF_LOOPBACK)
2228 intArray->iiFlags |= WS_IFF_LOOPBACK;
2229 if (ifInfo.ifr_flags & IFF_UP)
2230 intArray->iiFlags |= WS_IFF_UP;
2231 if (ifInfo.ifr_flags & IFF_MULTICAST)
2232 intArray->iiFlags |= WS_IFF_MULTICAST;
2233 }
2234
2235 addr = inet_addr(ptr->IpAddressList.IpAddress.String);
2236 mask = inet_addr(ptr->IpAddressList.IpMask.String);
2237 bcast = addr | (addr & !mask);
2238 intArray->iiAddress.AddressIn.sin_family = AF_INET;
2239 intArray->iiAddress.AddressIn.sin_port = 0;
2240 intArray->iiAddress.AddressIn.sin_addr.WS_s_addr =
2241 addr;
2242 intArray->iiNetmask.AddressIn.sin_family = AF_INET;
2243 intArray->iiNetmask.AddressIn.sin_port = 0;
2244 intArray->iiNetmask.AddressIn.sin_addr.WS_s_addr =
2245 mask;
2246 intArray->iiBroadcastAddress.AddressIn.sin_family =
2247 AF_INET;
2248 intArray->iiBroadcastAddress.AddressIn.sin_port = 0;
2249 intArray->iiBroadcastAddress.AddressIn.sin_addr.
2250 WS_s_addr = bcast;
2251 }
2252 }
2253 else
2254 {
2255 ERR("Unable to get interface table!\n");
2256 release_sock_fd( s, fd );
2257 HeapFree(GetProcessHeap(),0,table);
2258 WSASetLastError(WSAEINVAL);
2259 return SOCKET_ERROR;
2260 }
2261 HeapFree(GetProcessHeap(),0,table);
2262 }
2263 else
2264 {
2265 release_sock_fd( s, fd );
2266 WSASetLastError(WSAEINVAL);
2267 return SOCKET_ERROR;
2268 }
2269 }
2270 else
2271 {
2272 ERR("Unable to get interface table!\n");
2273 release_sock_fd( s, fd );
2274 WSASetLastError(WSAEINVAL);
2275 return SOCKET_ERROR;
2276 }
2277 /* Calculate the size of the array being returned */
2278 *lpcbBytesReturned = sizeof(INTERFACE_INFO) * numInt;
2279 release_sock_fd( s, fd );
2280 break;
2281 }
2282
2283 case WS_SIO_ADDRESS_LIST_CHANGE:
2284 FIXME("-> SIO_ADDRESS_LIST_CHANGE request: stub\n");
2285 /* FIXME: error and return code depend on whether socket was created
2286 * with WSA_FLAG_OVERLAPPED, but there is no easy way to get this */
2287 break;
2288
2289 case WS_SIO_ADDRESS_LIST_QUERY:
2290 {
2291 DWORD size;
2292
2293 TRACE("-> SIO_ADDRESS_LIST_QUERY request\n");
2294
2295 if (!lpcbBytesReturned)
2296 {
2297 WSASetLastError(WSAEFAULT);
2298 return SOCKET_ERROR;
2299 }
2300
2301 if (GetAdaptersInfo(NULL, &size) == ERROR_BUFFER_OVERFLOW)
2302 {
2303 IP_ADAPTER_INFO *p, *table = HeapAlloc(GetProcessHeap(), 0, size);
2304 DWORD need, num;
2305
2306 if (!table || GetAdaptersInfo(table, &size))
2307 {
2308 HeapFree(GetProcessHeap(), 0, table);
2309 WSASetLastError(WSAEINVAL);
2310 return SOCKET_ERROR;
2311 }
2312
2313 for (p = table, num = 0; p; p = p->Next)
2314 if (p->IpAddressList.IpAddress.String[0]) num++;
2315
2316 need = sizeof(SOCKET_ADDRESS_LIST) + sizeof(SOCKET_ADDRESS) * (num - 1);
2317 need += sizeof(SOCKADDR) * num;
2318 *lpcbBytesReturned = need;
2319
2320 if (need > cbOutBuffer)
2321 {
2322 HeapFree(GetProcessHeap(), 0, table);
2323 WSASetLastError(WSAEFAULT);
2324 return SOCKET_ERROR;
2325 }
2326
2327 if (lpbOutBuffer)
2328 {
2329 unsigned int i;
2330 SOCKET_ADDRESS *sa;
2331 SOCKET_ADDRESS_LIST *sa_list = (SOCKET_ADDRESS_LIST *)lpbOutBuffer;
2332 SOCKADDR_IN *sockaddr;
2333
2334 sa = sa_list->Address;
2335 sockaddr = (SOCKADDR_IN *)((char *)sa + num * sizeof(SOCKET_ADDRESS));
2336 sa_list->iAddressCount = num;
2337
2338 for (p = table, i = 0; p; p = p->Next)
2339 {
2340 if (!p->IpAddressList.IpAddress.String[0]) continue;
2341
2342 sa[i].lpSockaddr = (SOCKADDR *)&sockaddr[i];
2343 sa[i].iSockaddrLength = sizeof(SOCKADDR);
2344
2345 sockaddr[i].sin_family = AF_INET;
2346 sockaddr[i].sin_port = 0;
2347 sockaddr[i].sin_addr.WS_s_addr = inet_addr(p->IpAddressList.IpAddress.String);
2348 i++;
2349 }
2350 }
2351
2352 HeapFree(GetProcessHeap(), 0, table);
2353 return 0;
2354 }
2355 else
2356 {
2357 WARN("unable to get IP address list\n");
2358 WSASetLastError(WSAEINVAL);
2359 return SOCKET_ERROR;
2360 }
2361 }
2362 case WS_SIO_FLUSH:
2363 FIXME("SIO_FLUSH: stub.\n");
2364 break;
2365
2366 default:
2367 FIXME("unsupported WS_IOCTL cmd (%08x)\n", dwIoControlCode);
2368 WSASetLastError(WSAEOPNOTSUPP);
2369 return SOCKET_ERROR;
2370 }
2371
2372 return 0;
2373 }
2374
2375
2376 /***********************************************************************
2377 * ioctlsocket (WS2_32.10)
2378 */
2379 int WINAPI WS_ioctlsocket(SOCKET s, long cmd, WS_u_long *argp)
2380 {
2381 int fd;
2382 long newcmd = cmd;
2383
2384 TRACE("socket %04lx, cmd %08lx, ptr %p\n", s, cmd, argp);
2385
2386 switch( cmd )
2387 {
2388 case WS_FIONREAD:
2389 newcmd=FIONREAD;
2390 break;
2391
2392 case WS_FIONBIO:
2393 if( _get_sock_mask(s) )
2394 {
2395 /* AsyncSelect()'ed sockets are always nonblocking */
2396 if (*argp) return 0;
2397 SetLastError(WSAEINVAL);
2398 return SOCKET_ERROR;
2399 }
2400 fd = get_sock_fd( s, 0, NULL );
2401 if (fd != -1)
2402 {
2403 int ret;
2404 if (*argp)
2405 {
2406 _enable_event(SOCKET2HANDLE(s), 0, FD_WINE_NONBLOCKING, 0);
2407 ret = fcntl( fd, F_SETFL, O_NONBLOCK );
2408 }
2409 else
2410 {
2411 _enable_event(SOCKET2HANDLE(s), 0, 0, FD_WINE_NONBLOCKING);
2412 ret = fcntl( fd, F_SETFL, 0 );
2413 }
2414 release_sock_fd( s, fd );
2415 if (!ret) return 0;
2416 SetLastError((errno == EBADF) ? WSAENOTSOCK : wsaErrno());
2417 }
2418 return SOCKET_ERROR;
2419
2420 case WS_SIOCATMARK:
2421 newcmd=SIOCATMARK;
2422 break;
2423
2424 case WS_FIOASYNC:
2425 WARN("Warning: WS1.1 shouldn't be using async I/O\n");
2426 SetLastError(WSAEINVAL);
2427 return SOCKET_ERROR;
2428
2429 case SIOCGIFBRDADDR:
2430 case SIOCGIFNETMASK:
2431 case SIOCGIFADDR:
2432 /* These don't need any special handling. They are used by
2433 WsControl, and are here to suppress an unnecessary warning. */
2434 break;
2435
2436 default:
2437 /* Netscape tries hard to use bogus ioctl 0x667e */
2438 /* FIXME: 0x667e above is ('f' << 8) | 126, and is a low word of
2439 * FIONBIO (_IOW('f', 126, u_long)), how that should be handled?
2440 */
2441 WARN("\tunknown WS_IOCTL cmd (%08lx)\n", cmd);
2442 break;
2443 }
2444
2445 fd = get_sock_fd( s, 0, NULL );
2446 if (fd != -1)
2447 {
2448 if( ioctl(fd, newcmd, (char*)argp ) == 0 )
2449 {
2450 release_sock_fd( s, fd );
2451 return 0;
2452 }
2453 SetLastError((errno == EBADF) ? WSAENOTSOCK : wsaErrno());
2454 release_sock_fd( s, fd );
2455 }
2456 return SOCKET_ERROR;
2457 }
2458
2459 /***********************************************************************
2460 * listen (WS2_32.13)
2461 */
2462 int WINAPI WS_listen(SOCKET s, int backlog)
2463 {
2464 int fd = get_sock_fd( s, FILE_READ_DATA, NULL );
2465
2466 TRACE("socket %04lx, backlog %d\n", s, backlog);
2467 if (fd != -1)
2468 {
2469 if (listen(fd, backlog) == 0)
2470 {
2471 release_sock_fd( s, fd );
2472 _enable_event(SOCKET2HANDLE(s), FD_ACCEPT,
2473 FD_WINE_LISTENING,
2474 FD_CONNECT|FD_WINE_CONNECTED);
2475 return 0;
2476 }
2477 SetLastError(wsaErrno());
2478 release_sock_fd( s, fd );
2479 }
2480 return SOCKET_ERROR;
2481 }
2482
2483 /***********************************************************************
2484 * recv (WS2_32.16)
2485 */
2486 int WINAPI WS_recv(SOCKET s, char *buf, int len, int flags)
2487 {
2488 DWORD n, dwFlags = flags;
2489 WSABUF wsabuf;
2490
2491 wsabuf.len = len;
2492 wsabuf.buf = buf;
2493
2494 if ( WSARecvFrom(s, &wsabuf, 1, &n, &dwFlags, NULL, NULL, NULL, NULL) == SOCKET_ERROR )
2495 return SOCKET_ERROR;
2496 else
2497 return n;
2498 }
2499
2500 /***********************************************************************
2501 * recvfrom (WS2_32.17)
2502 */
2503 int WINAPI WS_recvfrom(SOCKET s, char *buf, INT len, int flags,
2504 struct WS_sockaddr *from, int *fromlen)
2505 {
2506 DWORD n, dwFlags = flags;
2507 WSABUF wsabuf;
2508
2509 wsabuf.len = len;
2510 wsabuf.buf = buf;
2511
2512 if ( WSARecvFrom(s, &wsabuf, 1, &n, &dwFlags, from, fromlen, NULL, NULL) == SOCKET_ERROR )
2513 return SOCKET_ERROR;
2514 else
2515 return n;
2516 }
2517
2518 /* allocate a poll array for the corresponding fd sets */
2519 static struct pollfd *fd_sets_to_poll( const WS_fd_set *readfds, const WS_fd_set *writefds,
2520 const WS_fd_set *exceptfds, int *count_ptr )
2521 {
2522 int i, j = 0, count = 0;
2523 struct pollfd *fds;
2524
2525 if (readfds) count += readfds->fd_count;
2526 if (writefds) count += writefds->fd_count;
2527 if (exceptfds) count += exceptfds->fd_count;
2528 *count_ptr = count;
2529 if (!count) return NULL;
2530 if (!(fds = HeapAlloc( GetProcessHeap(), 0, count * sizeof(fds[0])))) return NULL;
2531 if (readfds)
2532 for (i = 0; i < readfds->fd_count; i++, j++)
2533 {
2534 fds[j].fd = get_sock_fd( readfds->fd_array[i], FILE_READ_DATA, NULL );
2535 fds[j].events = POLLIN;
2536 fds[j].revents = 0;
2537 }
2538 if (writefds)
2539 for (i = 0; i < writefds->fd_count; i++, j++)
2540 {
2541 fds[j].fd = get_sock_fd( writefds->fd_array[i], FILE_WRITE_DATA, NULL );
2542 fds[j].events = POLLOUT;
2543 fds[j].revents = 0;
2544 }
2545 if (exceptfds)
2546 for (i = 0; i < exceptfds->fd_count; i++, j++)
2547 {
2548 fds[j].fd = get_sock_fd( exceptfds->fd_array[i], 0, NULL );
2549 fds[j].events = POLLHUP;
2550 fds[j].revents = 0;
2551 }
2552 return fds;
2553 }
2554
2555 /* release the file descriptor obtained in fd_sets_to_poll */
2556 /* must be called with the original fd_set arrays, before calling get_poll_results */
2557 static void release_poll_fds( const WS_fd_set *readfds, const WS_fd_set *writefds,
2558 const WS_fd_set *exceptfds, struct pollfd *fds )
2559 {
2560 int i, j = 0;
2561
2562 if (readfds)
2563 {
2564 for (i = 0; i < readfds->fd_count; i++, j++)
2565 if (fds[j].fd != -1) release_sock_fd( readfds->fd_array[i], fds[j].fd );
2566 }
2567 if (writefds)
2568 {
2569 for (i = 0; i < writefds->fd_count; i++, j++)
2570 if (fds[j].fd != -1) release_sock_fd( writefds->fd_array[i], fds[j].fd );
2571 }
2572 if (exceptfds)
2573 {
2574 for (i = 0; i < exceptfds->fd_count; i++, j++)
2575 if (fds[j].fd != -1)
2576 {
2577 /* make sure we have a real error before releasing the fd */
2578 if (!sock_error_p( fds[j].fd )) fds[j].revents = 0;
2579 release_sock_fd( exceptfds->fd_array[i], fds[j].fd );
2580 }
2581 }
2582 }
2583
2584 /* map the poll results back into the Windows fd sets */
2585 static int get_poll_results( WS_fd_set *readfds, WS_fd_set *writefds, WS_fd_set *exceptfds,
2586 const struct pollfd *fds )
2587 {
2588 int i, j = 0, k, total = 0;
2589
2590 if (readfds)
2591 {
2592 for (i = k = 0; i < readfds->fd_count; i++, j++)
2593 if (fds[j].revents) readfds->fd_array[k++] = readfds->fd_array[i];
2594 readfds->fd_count = k;
2595 total += k;
2596 }
2597 if (writefds)
2598 {
2599 for (i = k = 0; i < writefds->fd_count; i++, j++)
2600 if (fds[j].revents) writefds->fd_array[k++] = writefds->fd_array[i];
2601 writefds->fd_count = k;
2602 total += k;
2603 }
2604 if (exceptfds)
2605 {
2606 for (i = k = 0; i < exceptfds->fd_count; i++, j++)
2607 if (fds[j].revents) exceptfds->fd_array[k++] = exceptfds->fd_array[i];
2608 exceptfds->fd_count = k;
2609 total += k;
2610 }
2611 return total;
2612 }
2613
2614
2615 /***********************************************************************
2616 * select (WS2_32.18)
2617 */
2618 int WINAPI WS_select(int nfds, WS_fd_set *ws_readfds,
2619 WS_fd_set *ws_writefds, WS_fd_set *ws_exceptfds,
2620 const struct WS_timeval* ws_timeout)
2621 {
2622 struct pollfd *pollfds;
2623 int count, ret, timeout = -1;
2624
2625 TRACE("read %p, write %p, excp %p timeout %p\n",
2626 ws_readfds, ws_writefds, ws_exceptfds, ws_timeout);
2627
2628 if (!(pollfds = fd_sets_to_poll( ws_readfds, ws_writefds, ws_exceptfds, &count )) && count)
2629 {
2630 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
2631 return SOCKET_ERROR;
2632 }
2633
2634 if (ws_timeout) timeout = (ws_timeout->tv_sec * 1000) + (ws_timeout->tv_usec + 999) / 1000;
2635
2636 ret = poll( pollfds, count, timeout );
2637 release_poll_fds( ws_readfds, ws_writefds, ws_exceptfds, pollfds );
2638
2639 if (ret == -1) SetLastError(wsaErrno());
2640 else ret = get_poll_results( ws_readfds, ws_writefds, ws_exceptfds, pollfds );
2641 HeapFree( GetProcessHeap(), 0, pollfds );
2642 return ret;
2643 }
2644
2645
2646 /***********************************************************************
2647 * send (WS2_32.19)
2648 */
2649 int WINAPI WS_send(SOCKET s, const char *buf, int len, int flags)
2650 {
2651 DWORD n;
2652 WSABUF wsabuf;
2653
2654 wsabuf.len = len;
2655 wsabuf.buf = (char*) buf;
2656
2657 if ( WSASendTo( s, &wsabuf, 1, &n, flags, NULL, 0, NULL, NULL) == SOCKET_ERROR )
2658 return SOCKET_ERROR;
2659 else
2660 return n;
2661 }
2662
2663 /***********************************************************************
2664 * WSASend (WS2_32.72)
2665 */
2666 INT WINAPI WSASend( SOCKET s, LPWSABUF lpBuffers, DWORD dwBufferCount,
2667 LPDWORD lpNumberOfBytesSent, DWORD dwFlags,
2668 LPWSAOVERLAPPED lpOverlapped,
2669 LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine )
2670 {
2671 return WSASendTo( s, lpBuffers, dwBufferCount, lpNumberOfBytesSent, dwFlags,
2672 NULL, 0, lpOverlapped, lpCompletionRoutine );
2673 }
2674
2675 /***********************************************************************
2676 * WSASendDisconnect (WS2_32.73)
2677 */
2678 INT WINAPI WSASendDisconnect( SOCKET s, LPWSABUF lpBuffers )
2679 {
2680 return WS_shutdown( s, SD_SEND );
2681 }
2682
2683
2684 /***********************************************************************
2685 * WSASendTo (WS2_32.74)
2686 */
2687 INT WINAPI WSASendTo( SOCKET s, LPWSABUF lpBuffers, DWORD dwBufferCount,
2688 LPDWORD lpNumberOfBytesSent, DWORD dwFlags,
2689 const struct WS_sockaddr *to, int tolen,
2690 LPWSAOVERLAPPED lpOverlapped,
2691 LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine )
2692 {
2693 unsigned int i, options;
2694 int n, fd, err = WSAENOTSOCK, ret;
2695 struct iovec iovec[WS_MSG_MAXIOVLEN];
2696 struct ws2_async *wsa;
2697 IO_STATUS_BLOCK* iosb;
2698
2699 TRACE("socket %04lx, wsabuf %p, nbufs %d, flags %d, to %p, tolen %d, ovl %p, func %p\n",
2700 s, lpBuffers, dwBufferCount, dwFlags,
2701 to, tolen, lpOverlapped, lpCompletionRoutine);
2702
2703 if (dwBufferCount > WS_MSG_MAXIOVLEN)
2704 {
2705 WSASetLastError( WSAEINVAL );
2706 return SOCKET_ERROR;
2707 }
2708
2709 fd = get_sock_fd( s, FILE_WRITE_DATA, &options );
2710 TRACE( "fd=%d, options=%x\n", fd, options );
2711
2712 if ( fd == -1 ) return SOCKET_ERROR;
2713
2714 if ( !lpNumberOfBytesSent )
2715 {
2716 err = WSAEFAULT;
2717 goto error;
2718 }
2719
2720 for ( i = 0; i < dwBufferCount; i++ )
2721 {
2722 iovec[i].iov_base = lpBuffers[i].buf;
2723 iovec[i].iov_len = lpBuffers[i].len;
2724 }
2725
2726 if ( (lpOverlapped || lpCompletionRoutine) &&
2727 !(options & (FILE_SYNCHRONOUS_IO_ALERT | FILE_SYNCHRONOUS_IO_NONALERT)))
2728 {
2729 wsa = WS2_make_async( s, ws2m_write, iovec, dwBufferCount,
2730 &dwFlags, (struct WS_sockaddr*) to, &tolen,
2731 lpOverlapped, lpCompletionRoutine, &iosb );
2732 if ( !wsa )
2733 {
2734 err = WSAEFAULT;
2735 goto error;
2736 }
2737
2738 if ((ret = ws2_queue_async( wsa, iosb )) != STATUS_PENDING)
2739 {
2740 err = NtStatusToWSAError( ret );
2741
2742 HeapFree( GetProcessHeap(), 0, wsa );
2743 goto error;
2744 }
2745 release_sock_fd( s, fd );
2746
2747 /* Try immediate completion */
2748 if ( lpOverlapped )
2749 {
2750 if ( WSAGetOverlappedResult( s, lpOverlapped,
2751 lpNumberOfBytesSent, FALSE, &dwFlags) )
2752 return 0;
2753
2754 if ( (err = WSAGetLastError()) != WSA_IO_INCOMPLETE )
2755 return SOCKET_ERROR;
2756 }
2757
2758 WSASetLastError( WSA_IO_PENDING );
2759 return SOCKET_ERROR;
2760 }
2761
2762 *lpNumberOfBytesSent = 0;
2763 if ( _is_blocking(s) )
2764 {
2765 /* On a blocking non-overlapped stream socket,
2766 * sending blocks until the entire buffer is sent. */
2767 struct iovec *piovec = iovec;
2768 int finish_time = GET_SNDTIMEO(fd);
2769 if (finish_time >= 0)
2770 finish_time += GetTickCount();
2771 while ( dwBufferCount > 0 )
2772 {
2773 int timeout;
2774 if ( finish_time >= 0 )
2775 {
2776 timeout = finish_time - GetTickCount();
2777 if ( timeout < 0 )
2778 timeout = 0;
2779 }
2780 else
2781 timeout = finish_time;
2782 /* FIXME: exceptfds? */
2783 if( !do_block(fd, POLLOUT, timeout)) {
2784 err = WSAETIMEDOUT;
2785 goto error; /* msdn says a timeout in send is fatal */
2786 }
2787
2788 n = WS2_send( fd, piovec, dwBufferCount, to, tolen, dwFlags );
2789 if ( n == -1 )
2790 {
2791 err = wsaErrno();
2792 goto error;
2793 }
2794 *lpNumberOfBytesSent += n;
2795
2796 while ( n > 0 )
2797 {
2798 if ( piovec->iov_len > n )
2799 {
2800 piovec->iov_base = (char*)piovec->iov_base + n;
2801 piovec->iov_len -= n;
2802 n = 0;
2803 }
2804 else
2805 {
2806 n -= piovec->iov_len;
2807 --dwBufferCount;
2808 ++piovec;
2809 }
2810 }
2811 }
2812 }
2813 else
2814 {
2815 n = WS2_send( fd, iovec, dwBufferCount, to, tolen, dwFlags );
2816 if ( n == -1 )
2817 {
2818 err = wsaErrno();
2819 if ( err == WSAEWOULDBLOCK )
2820 _enable_event(SOCKET2HANDLE(s), FD_WRITE, 0, 0);
2821 goto error;
2822 }
2823 else
2824 _enable_event(SOCKET2HANDLE(s), FD_WRITE, 0, 0);
2825 *lpNumberOfBytesSent = n;
2826 }
2827
2828 TRACE(" -> %i bytes\n", *lpNumberOfBytesSent);
2829
2830 release_sock_fd( s, fd );
2831 return 0;
2832
2833 error:
2834 release_sock_fd( s, fd );
2835 WARN(" -> ERROR %d\n", err);
2836 WSASetLastError(err);
2837 return SOCKET_ERROR;
2838 }
2839
2840 /***********************************************************************
2841 * sendto (WS2_32.20)
2842 */
2843 int WINAPI WS_sendto(SOCKET s, const char *buf, int len, int flags,
2844 const struct WS_sockaddr *to, int tolen)
2845 {
2846 DWORD n;
2847 WSABUF wsabuf;
2848
2849 wsabuf.len = len;
2850 wsabuf.buf = (char*) buf;
2851
2852 if ( WSASendTo(s, &wsabuf, 1, &n, flags, to, tolen, NULL, NULL) == SOCKET_ERROR )
2853 return SOCKET_ERROR;
2854 else
2855 return n;
2856 }
2857
2858 /***********************************************************************
2859 * setsockopt (WS2_32.21)
2860 */
2861 int WINAPI WS_setsockopt(SOCKET s, int level, int optname,
2862 const char *optval, int optlen)
2863 {
2864 int fd;
2865 int woptval;
2866 struct linger linger;
2867 struct timeval tval;
2868
2869 TRACE("socket: %04lx, level 0x%x, name 0x%x, ptr %p, len %d\n",
2870 s, level, optname, optval, optlen);
2871
2872 switch(level)
2873 {
2874 case WS_SOL_SOCKET:
2875 switch(optname)
2876 {
2877 /* Some options need some conversion before they can be sent to
2878 * setsockopt. The conversions are done here, then they will fall though
2879 * to the general case. Special options that are not passed to
2880 * setsockopt follow below that.*/
2881
2882 case WS_SO_DONTLINGER:
2883 linger.l_onoff = *((const int*)optval) ? 0: 1;
2884 linger.l_linger = 0;
2885 level = SOL_SOCKET;
2886 optname = SO_LINGER;
2887 optval = (char*)&linger;
2888 optlen = sizeof(struct linger);
2889 break;
2890
2891 case WS_SO_LINGER:
2892 linger.l_onoff = ((LINGER*)optval)->l_onoff;
2893 linger.l_linger = ((LINGER*)optval)->l_linger;
2894 /* FIXME: what is documented behavior if SO_LINGER optval
2895 is null?? */
2896 level = SOL_SOCKET;
2897 optname = SO_LINGER;
2898 optval = (char*)&linger;
2899 optlen = sizeof(struct linger);
2900 break;
2901
2902 case WS_SO_RCVBUF:
2903 if (*(const int*)optval < 2048)
2904 {
2905 WARN("SO_RCVBF for %d bytes is too small: ignored\n", *(const int*)optval );
2906 return 0;
2907 }
2908 /* Fall through */
2909
2910 /* The options listed here don't need any special handling. Thanks to
2911 * the conversion happening above, options from there will fall through
2912 * to this, too.*/
2913 case WS_SO_ACCEPTCONN:
2914 case WS_SO_BROADCAST:
2915 case WS_SO_ERROR:
2916 case WS_SO_KEEPALIVE:
2917 case WS_SO_OOBINLINE:
2918 case WS_SO_SNDBUF:
2919 case WS_SO_TYPE:
2920 convert_sockopt(&level, &optname);
2921 break;
2922
2923 /* SO_DEBUG is a privileged operation, ignore it. */
2924 case WS_SO_DEBUG:
2925 TRACE("Ignoring SO_DEBUG\n");
2926 return 0;
2927
2928 /* For some reason the game GrandPrixLegends does set SO_DONTROUTE on its
2929 * socket. According to MSDN, this option is silently ignored.*/
2930 case WS_SO_DONTROUTE:
2931 TRACE("Ignoring SO_DONTROUTE\n");
2932 return 0;
2933
2934 /* Stops two sockets from being bound to the same port. Always happens
2935 * on unix systems, so just drop it. */
2936 case WS_SO_EXCLUSIVEADDRUSE:
2937 TRACE("Ignoring SO_EXCLUSIVEADDRUSE, is always set.\n");
2938 return 0;
2939
2940 /* SO_OPENTYPE does not require a valid socket handle. */
2941 case WS_SO_OPENTYPE:
2942 if (!optlen || optlen < sizeof(int) || !optval)
2943 {
2944 SetLastError(WSAEFAULT);
2945 return SOCKET_ERROR;
2946 }
2947 get_per_thread_data()->opentype = *(const int *)optval;
2948 TRACE("setting global SO_OPENTYPE = 0x%x\n", *((int*)optval) );
2949 return 0;
2950
2951 /* SO_REUSEADDR allows two applications to bind to the same port at at
2952 * same time. There is no direct way to do that in unix. While Wineserver
2953 * might do this, it does not seem useful for now, so just ignore it.*/
2954 case WS_SO_REUSEADDR:
2955 TRACE("Ignoring SO_REUSEADDR, does not translate\n");
2956 return 0;
2957
2958 #ifdef SO_RCVTIMEO
2959 case WS_SO_RCVTIMEO:
2960 #endif
2961 #ifdef SO_SNDTIMEO
2962 case WS_SO_SNDTIMEO:
2963 #endif
2964 #if defined(SO_RCVTIMEO) || defined(SO_SNDTIMEO)
2965 if (optval && optlen == sizeof(UINT32)) {
2966 /* WinSock passes miliseconds instead of struct timeval */
2967 tval.tv_usec = (*(const UINT32*)optval % 1000) * 1000;
2968 tval.tv_sec = *(const UINT32*)optval / 1000;
2969 /* min of 500 milisec */
2970 if (tval.tv_sec == 0 && tval.tv_usec < 500000)
2971 tval.tv_usec = 500000;
2972 optlen = sizeof(struct timeval);
2973 optval = (char*)&tval;
2974 } else if (optlen == sizeof(struct timeval)) {
2975 WARN("SO_SND/RCVTIMEO for %d bytes: assuming unixism\n", optlen);
2976 } else {
2977 WARN("SO_SND/RCVTIMEO for %d bytes is weird: ignored\n", optlen);
2978 return 0;
2979 }
2980 convert_sockopt(&level, &optname);
2981 break;
2982 #endif
2983
2984 default:
2985 TRACE("Unknown SOL_SOCKET optname: 0x%08x\n", optname);
2986 SetLastError(WSAENOPROTOOPT);
2987 return SOCKET_ERROR;
2988 }
2989 break; /* case WS_SOL_SOCKET */
2990
2991 #ifdef HAVE_IPX
2992 case NSPROTO_IPX:
2993 switch(optname)
2994 {
2995 case IPX_PTYPE:
2996 fd = get_sock_fd( s, 0, NULL );
2997 TRACE("trying to set IPX_PTYPE: %d (fd: %d)\n", *(const int*)optval, fd);
2998
2999 /* We try to set the ipx type on ipx socket level. */
3000 #ifdef SOL_IPX
3001 if(setsockopt(fd, SOL_IPX, IPX_TYPE, optval, optlen) == -1)
3002 {
3003 ERR("IPX: could not set ipx option type; expect weird behaviour\n");
3004 release_sock_fd( s, fd );
3005 return SOCKET_ERROR;
3006 }
3007 #else
3008 {
3009 struct ipx val;
3010 /* Should we retrieve val using a getsockopt call and then
3011 * set the modified one? */
3012 val.ipx_pt = *optval;
3013 setsockopt(fd, 0, SO_DEFAULT_HEADERS, &val, sizeof(struct ipx));
3014 }
3015 #endif
3016 release_sock_fd( s, fd );
3017 return 0;
3018
3019 case IPX_FILTERPTYPE:
3020 /* Sets the receive filter packet type, at the moment we don't support it */
3021 FIXME("IPX_FILTERPTYPE: %x\n", *optval);
3022 /* Returning 0 is better for now than returning a SOCKET_ERROR */
3023 return 0;
3024
3025 default:
3026 FIXME("opt_name:%x\n", optname);
3027 return SOCKET_ERROR;
3028 }
3029 break; /* case NSPROTO_IPX */
3030 #endif
3031
3032 /* Levels WS_IPPROTO_TCP and WS_IPPROTO_IP convert directly */
3033 case WS_IPPROTO_TCP:
3034 switch(optname)
3035 {
3036 case WS_TCP_NODELAY:
3037 convert_sockopt(&level, &optname);
3038 break;
3039 default:
3040 FIXME("Unknown IPPROTO_TCP optname 0x%08x\n", optname);
3041 return SOCKET_ERROR;
3042 }
3043 break;
3044
3045 case WS_IPPROTO_IP:
3046 switch(optname)
3047 {
3048 case WS_IP_ADD_MEMBERSHIP:
3049 case WS_IP_DROP_MEMBERSHIP:
3050 #ifdef IP_HDRINCL
3051 case WS_IP_HDRINCL:
3052 #endif
3053 case WS_IP_MULTICAST_IF:
3054 case WS_IP_MULTICAST_LOOP:
3055 case WS_IP_MULTICAST_TTL:
3056 case WS_IP_OPTIONS:
3057 case WS_IP_TOS:
3058 case WS_IP_TTL:
3059 convert_sockopt(&level, &optname);
3060 break;
3061 default:
3062 FIXME("Unknown IPPROTO_IP optname 0x%08x\n", optname);
3063 return SOCKET_ERROR;
3064 }
3065 break;
3066
3067 default:
3068 FIXME("Unknown level: 0x%08x\n", level);
3069 return SOCKET_ERROR;
3070 } /* end switch(level) */
3071
3072 /* avoid endianness issues if argument is a 16-bit int */
3073 if (optval && optlen < sizeof(int))
3074 {
3075 woptval= *((const INT16 *) optval);
3076 optval= (char*) &woptval;
3077 optlen=sizeof(int);
3078 }
3079 fd = get_sock_fd( s, 0, NULL );
3080 if (fd == -1) return SOCKET_ERROR;
3081
3082 if (setsockopt(fd, level, optname, optval, optlen) == 0)
3083 {
3084 release_sock_fd( s, fd );
3085 return 0;
3086 }
3087 TRACE("Setting socket error, %d\n", wsaErrno());
3088 SetLastError(wsaErrno());
3089 release_sock_fd( s, fd );
3090
3091 return SOCKET_ERROR;
3092 }
3093
3094 /***********************************************************************
3095 * shutdown (WS2_32.22)
3096 */
3097 int WINAPI WS_shutdown(SOCKET s, int how)
3098 {
3099 int fd, err = WSAENOTSOCK;
3100 unsigned int options, clear_flags = 0;
3101
3102 fd = get_sock_fd( s, 0, &options );
3103 TRACE("socket %04lx, how %i %x\n", s, how, options );
3104
3105 if (fd == -1)
3106 return SOCKET_ERROR;
3107
3108 switch( how )
3109 {
3110 case 0: /* drop receives */
3111 clear_flags |= FD_READ;
3112 break;
3113 case 1: /* drop sends */
3114 clear_flags |= FD_WRITE;
3115 break;
3116 case 2: /* drop all */
3117 clear_flags |= FD_READ|FD_WRITE;
3118 default:
3119 clear_flags |= FD_WINE_LISTENING;
3120 }
3121
3122 if (!(options & (FILE_SYNCHRONOUS_IO_ALERT | FILE_SYNCHRONOUS_IO_NONALERT)))
3123 {
3124 switch ( how )
3125 {
3126 case SD_RECEIVE:
3127 err = WS2_register_async_shutdown( s, ws2m_sd_read );
3128 break;
3129 case SD_SEND:
3130 err = WS2_register_async_shutdown( s, ws2m_sd_write );
3131 break;
3132 case SD_BOTH:
3133 default:
3134 err = WS2_register_async_shutdown( s, ws2m_sd_read );
3135 if (!err) err = WS2_register_async_shutdown( s, ws2m_sd_write );
3136 break;
3137 }
3138 if (err) goto error;
3139 }
3140 else /* non-overlapped mode */
3141 {
3142 if ( shutdown( fd, how ) )
3143 {
3144 err = wsaErrno();
3145 goto error;
3146 }
3147 }
3148
3149 release_sock_fd( s, fd );
3150 _enable_event( SOCKET2HANDLE(s), 0, 0, clear_flags );
3151 if ( how > 1) WSAAsyncSelect( s, 0, 0, 0 );
3152 return 0;
3153
3154 error:
3155 release_sock_fd( s, fd );
3156 _enable_event( SOCKET2HANDLE(s), 0, 0, clear_flags );
3157 WSASetLastError( err );
3158 return SOCKET_ERROR;
3159 }
3160
3161 /***********************************************************************
3162 * socket (WS2_32.23)
3163 */
3164 SOCKET WINAPI WS_socket(int af, int type, int protocol)
3165 {
3166 TRACE("af=%d type=%d protocol=%d\n", af, type, protocol);
3167
3168 return WSASocketA( af, type, protocol, NULL, 0,
3169 get_per_thread_data()->opentype ? 0 : WSA_FLAG_OVERLAPPED );
3170 }
3171
3172
3173 /***********************************************************************
3174 * gethostbyaddr (WS2_32.51)
3175 */
3176 struct WS_hostent* WINAPI WS_gethostbyaddr(const char *addr, int len, int type)
3177 {
3178 struct WS_hostent *retval = NULL;
3179 struct hostent* host;
3180
3181 #ifdef HAVE_LINUX_GETHOSTBYNAME_R_6
3182 char *extrabuf;
3183 int ebufsize=1024;
3184 struct hostent hostentry;
3185 int locerr=ENOBUFS;
3186 host = NULL;
3187 extrabuf=HeapAlloc(GetProcessHeap(),0,ebufsize) ;
3188 while(extrabuf) {
3189 int res = gethostbyaddr_r(addr, len, type,
3190 &hostentry, extrabuf, ebufsize, &host, &locerr);
3191 if( res != ERANGE) break;
3192 ebufsize *=2;
3193 extrabuf=HeapReAlloc(GetProcessHeap(),0,extrabuf,ebufsize) ;
3194 }
3195 if (!host) SetLastError((locerr < 0) ? wsaErrno() : wsaHerrno(locerr));
3196 #else
3197 EnterCriticalSection( &csWSgetXXXbyYYY );
3198 host = gethostbyaddr(addr, len, type);
3199 if (!host) SetLastError((h_errno < 0) ? wsaErrno() : wsaHerrno(h_errno));
3200 #endif
3201 if( host != NULL ) retval = WS_dup_he(host);
3202 #ifdef HAVE_LINUX_GETHOSTBYNAME_R_6
3203 HeapFree(GetProcessHeap(),0,extrabuf);
3204 #else
3205 LeaveCriticalSection( &csWSgetXXXbyYYY );
3206 #endif
3207 TRACE("ptr %p, len %d, type %d ret %p\n", addr, len, type, retval);
3208 return retval;
3209 }
3210
3211 /***********************************************************************
3212 * gethostbyname (WS2_32.52)
3213 */
3214 struct WS_hostent* WINAPI WS_gethostbyname(const char* name)
3215 {
3216 struct WS_hostent *retval = NULL;
3217 struct hostent* host;
3218 #ifdef HAVE_LINUX_GETHOSTBYNAME_R_6
3219 char *extrabuf;
3220 int ebufsize=1024;
3221 struct hostent hostentry;
3222 int locerr = ENOBUFS;
3223 #endif
3224 char buf[100];
3225 if( !name || !name[0]) {
3226 name = buf;
3227 if( gethostname( buf, 100) == -1) {
3228 SetLastError( WSAENOBUFS); /* appropriate ? */
3229 return retval;
3230 }
3231 }
3232 #ifdef HAVE_LINUX_GETHOSTBYNAME_R_6
3233 host = NULL;
3234 extrabuf=HeapAlloc(GetProcessHeap(),0,ebufsize) ;
3235 while(extrabuf) {
3236 int res = gethostbyname_r(name, &hostentry, extrabuf, ebufsize, &host, &locerr);
3237 if( res != ERANGE) break;
3238 ebufsize *=2;
3239 extrabuf=HeapReAlloc(GetProcessHeap(),0,extrabuf,ebufsize) ;
3240 }
3241 if (!host) SetLastError((locerr < 0) ? wsaErrno() : wsaHerrno(locerr));
3242 #else
3243 EnterCriticalSection( &csWSgetXXXbyYYY );
3244 host = gethostbyname(name);
3245 if (!host) SetLastError((h_errno < 0) ? wsaErrno() : wsaHerrno(h_errno));
3246 #endif
3247 if (host) retval = WS_dup_he(host);
3248 #ifdef HAVE_LINUX_GETHOSTBYNAME_R_6
3249 HeapFree(GetProcessHeap(),0,extrabuf);
3250 #else
3251 LeaveCriticalSection( &csWSgetXXXbyYYY );
3252 #endif
3253 TRACE( "%s ret %p\n", debugstr_a(name), retval );
3254 return retval;
3255 }
3256
3257
3258 /***********************************************************************
3259 * getprotobyname (WS2_32.53)
3260 */
3261 struct WS_protoent* WINAPI WS_getprotobyname(const char* name)
3262 {
3263 struct WS_protoent* retval = NULL;
3264 #ifdef HAVE_GETPROTOBYNAME
3265 struct protoent* proto;
3266 EnterCriticalSection( &csWSgetXXXbyYYY );
3267 if( (proto = getprotobyname(name)) != NULL )
3268 {
3269 retval = WS_dup_pe(proto);
3270 }
3271 else {
3272 MESSAGE("protocol %s not found; You might want to add "
3273 "this to /etc/protocols\n", debugstr_a(name) );
3274 SetLastError(WSANO_DATA);
3275 }
3276 LeaveCriticalSection( &csWSgetXXXbyYYY );
3277 #endif
3278 TRACE( "%s ret %p\n", debugstr_a(name), retval );
3279 return retval;
3280 }
3281
3282
3283 /***********************************************************************
3284 * getprotobynumber (WS2_32.54)
3285 */
3286 struct WS_protoent* WINAPI WS_getprotobynumber(int number)
3287 {
3288 struct WS_protoent* retval = NULL;
3289 #ifdef HAVE_GETPROTOBYNUMBER
3290 struct protoent* proto;
3291 EnterCriticalSection( &csWSgetXXXbyYYY );
3292 if( (proto = getprotobynumber(number)) != NULL )
3293 {
3294 retval = WS_dup_pe(proto);
3295 }
3296 else {
3297 MESSAGE("protocol number %d not found; You might want to add "
3298 "this to /etc/protocols\n", number );
3299 SetLastError(WSANO_DATA);
3300 }
3301 LeaveCriticalSection( &csWSgetXXXbyYYY );
3302 #endif
3303 TRACE("%i ret %p\n", number, retval);
3304 return retval;
3305 }
3306
3307
3308 /***********************************************************************
3309 * getservbyname (WS2_32.55)
3310 */
3311 struct WS_servent* WINAPI WS_getservbyname(const char *name, const char *proto)
3312 {
3313 struct WS_servent* retval = NULL;
3314 struct servent* serv;
3315 char *name_str;
3316 char *proto_str = NULL;
3317
3318 if (!(name_str = strdup_lower(name))) return NULL;
3319
3320 if (proto && *proto)
3321 {
3322 if (!(proto_str = strdup_lower(proto)))
3323 {
3324 HeapFree( GetProcessHeap(), 0, name_str );
3325 return NULL;
3326 }
3327 }
3328
3329 EnterCriticalSection( &csWSgetXXXbyYYY );
3330 serv = getservbyname(name_str, proto_str);
3331 if( serv != NULL )
3332 {
3333 retval = WS_dup_se(serv);
3334 }
3335 else SetLastError(WSANO_DATA);
3336 LeaveCriticalSection( &csWSgetXXXbyYYY );
3337 HeapFree( GetProcessHeap(), 0, proto_str );
3338 HeapFree( GetProcessHeap(), 0, name_str );
3339 TRACE( "%s, %s ret %p\n", debugstr_a(name), debugstr_a(proto), retval );
3340 return retval;
3341 }
3342
3343 /***********************************************************************
3344 * freeaddrinfo (WS2_32.@)
3345 */
3346 void WINAPI WS_freeaddrinfo(struct WS_addrinfo *res)
3347 {
3348 while (res) {
3349 struct WS_addrinfo *next;
3350
3351 HeapFree(GetProcessHeap(),0,res->ai_canonname);
3352 HeapFree(GetProcessHeap(),0,res->ai_addr);
3353 next = res->ai_next;
3354 HeapFree(GetProcessHeap(),0,res);
3355 res = next;
3356 }
3357 }
3358
3359 /* helper functions for getaddrinfo() */
3360 static int convert_aiflag_w2u(int winflags) {
3361 int i, unixflags = 0;
3362
3363 for (i=0;i<sizeof(ws_aiflag_map)/sizeof(ws_aiflag_map[0]);i++)
3364 if (ws_aiflag_map[i][0] & winflags) {
3365 unixflags |= ws_aiflag_map[i][1];
3366 winflags &= ~ws_aiflag_map[i][0];
3367 }
3368 if (winflags)
3369 FIXME("Unhandled windows AI_xxx flags %x\n", winflags);
3370 return unixflags;
3371 }
3372
3373 static int convert_aiflag_u2w(int unixflags) {
3374 int i, winflags = 0;
3375
3376 for (i=0;i<sizeof(ws_aiflag_map)/sizeof(ws_aiflag_map[0]);i++)
3377 if (ws_aiflag_map[i][1] & unixflags) {
3378 winflags |= ws_aiflag_map[i][0];
3379 unixflags &= ~ws_aiflag_map[i][1];
3380 }
3381 if (unixflags) /* will warn usually */
3382 WARN("Unhandled UNIX AI_xxx flags %x\n", unixflags);
3383 return winflags;
3384 }
3385
3386 static int convert_eai_u2w(int unixret) {
3387 int i;
3388
3389 for (i=0;ws_eai_map[i][0];i++)
3390 if (ws_eai_map[i][1] == unixret)
3391 return ws_eai_map[i][0];
3392 return unixret;
3393 }
3394
3395 /***********************************************************************
3396 * getaddrinfo (WS2_32.@)
3397 */
3398 int WINAPI WS_getaddrinfo(LPCSTR nodename, LPCSTR servname, const struct WS_addrinfo *hints, struct WS_addrinfo **res)
3399 {
3400 #if HAVE_GETADDRINFO
3401 struct addrinfo *unixaires = NULL;
3402 int result;
3403 struct addrinfo unixhints, *punixhints = NULL;
3404 CHAR *node = NULL, *serv = NULL;
3405
3406 if (nodename)
3407 if (!(node = strdup_lower(nodename))) return WSA_NOT_ENOUGH_MEMORY;
3408
3409 if (servname) {
3410 if (!(serv = strdup_lower(servname))) {
3411 HeapFree(GetProcessHeap(), 0, node);
3412 return WSA_NOT_ENOUGH_MEMORY;
3413 }
3414 }
3415
3416 if (hints) {
3417 punixhints = &unixhints;
3418
3419 memset(&unixhints, 0, sizeof(unixhints));
3420 punixhints->ai_flags = convert_aiflag_w2u(hints->ai_flags);
3421 if (hints->ai_family == 0) /* wildcard, specific to getaddrinfo() */
3422 punixhints->ai_family = 0;
3423 else
3424 punixhints->ai_family = convert_af_w2u(hints->ai_family);
3425 if (hints->ai_socktype == 0) /* wildcard, specific to getaddrinfo() */
3426 punixhints->ai_socktype = 0;
3427 else
3428 punixhints->ai_socktype = convert_socktype_w2u(hints->ai_socktype);
3429 if (hints->ai_protocol == 0) /* wildcard, specific to getaddrinfo() */
3430 punixhints->ai_protocol = 0;
3431 else
3432 punixhints->ai_protocol = convert_proto_w2u(hints->ai_protocol);
3433 }
3434
3435 /* getaddrinfo(3) is thread safe, no need to wrap in CS */
3436 result = getaddrinfo(nodename, servname, punixhints, &unixaires);
3437
3438 TRACE("%s, %s %p -> %p %d\n", nodename, servname, hints, res, result);
3439
3440 HeapFree(GetProcessHeap(), 0, node);
3441 HeapFree(GetProcessHeap(), 0, serv);
3442
3443 if (!result) {
3444 struct addrinfo *xuai = unixaires;
3445 struct WS_addrinfo **xai = res;
3446
3447 *xai = NULL;
3448 while (xuai) {
3449 struct WS_addrinfo *ai = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY, sizeof(struct WS_addrinfo));
3450 int len;
3451
3452 if (!ai)
3453 goto outofmem;
3454
3455 *xai = ai;xai = &ai->ai_next;
3456 ai->ai_flags = convert_aiflag_u2w(xuai->ai_flags);
3457 ai->ai_family = convert_af_u2w(xuai->ai_family);
3458 ai->ai_socktype = convert_socktype_u2w(xuai->ai_socktype);
3459 ai->ai_protocol = convert_proto_u2w(xuai->ai_protocol);
3460 if (xuai->ai_canonname) {
3461 TRACE("canon name - %s\n",debugstr_a(xuai->ai_canonname));
3462 ai->ai_canonname = HeapAlloc(GetProcessHeap(),0,strlen(xuai->ai_canonname)+1);
3463 if (!ai->ai_canonname)
3464 goto outofmem;
3465 strcpy(ai->ai_canonname,xuai->ai_canonname);
3466 }
3467 len = xuai->ai_addrlen;
3468 ai->ai_addr = HeapAlloc(GetProcessHeap(),0,len);
3469 if (!ai->ai_addr)
3470 goto outofmem;
3471 ai->ai_addrlen = len;
3472 do {
3473 int winlen = ai->ai_addrlen;
3474
3475 if (!ws_sockaddr_u2ws(xuai->ai_addr, ai->ai_addr, &winlen)) {
3476 ai->ai_addrlen = winlen;
3477 break;
3478 }
3479 len = 2*len;
3480 ai->ai_addr = HeapReAlloc(GetProcessHeap(),0,ai->ai_addr,len);
3481 if (!ai->ai_addr)
3482 goto outofmem;
3483 ai->ai_addrlen = len;
3484 } while (1);
3485 xuai = xuai->ai_next;
3486 }
3487 freeaddrinfo(unixaires);
3488 } else {
3489 result = convert_eai_u2w(result);
3490 }
3491 return result;
3492
3493 outofmem:
3494 if (*res) WS_freeaddrinfo(*res);
3495 if (unixaires) freeaddrinfo(unixaires);
3496 *res = NULL;
3497 return WSA_NOT_ENOUGH_MEMORY;
3498 #else
3499 FIXME("getaddrinfo() failed, not found during buildtime.\n");
3500 return EAI_FAIL;
3501 #endif
3502 }
3503
3504 /***********************************************************************
3505 * GetAddrInfoW (WS2_32.@)
3506 */
3507 int WINAPI GetAddrInfoW(LPCWSTR nodename, LPCWSTR servname, const ADDRINFOW *hints, PADDRINFOW *res)
3508 {
3509 FIXME("empty stub!\n");
3510 return EAI_FAIL;
3511 }
3512
3513 int WINAPI WS_getnameinfo(const SOCKADDR *sa, WS_socklen_t salen, PCHAR host,
3514 DWORD hostlen, PCHAR serv, DWORD servlen, INT flags)
3515 {
3516 #if HAVE_GETNAMEINFO
3517 int ret;
3518 union generic_unix_sockaddr sa_u;
3519 unsigned int size;
3520
3521 TRACE("%s %d %p %d %p %d %d\n", debugstr_sockaddr(sa), salen, host, hostlen,
3522 serv, servlen, flags);
3523
3524 size = ws_sockaddr_ws2u(sa, salen, &sa_u);
3525 if (!size)
3526 {
3527 WSASetLastError(WSAEFAULT);
3528 return WSA_NOT_ENOUGH_MEMORY;
3529 }
3530 ret = getnameinfo(&sa_u.addr, size, host, hostlen, serv, servlen, convert_aiflag_w2u(flags));
3531 return convert_eai_u2w(ret);
3532 #else
3533 FIXME("getnameinfo() failed, not found during buildtime.\n");
3534 return EAI_FAIL;
3535 #endif
3536 }
3537
3538 /***********************************************************************
3539 * getservbyport (WS2_32.56)
3540 */
3541 struct WS_servent* WINAPI WS_getservbyport(int port, const char *proto)
3542 {
3543 struct WS_servent* retval = NULL;
3544 #ifdef HAVE_GETSERVBYPORT
3545 struct servent* serv;
3546 char *proto_str = NULL;
3547
3548 if (proto && *proto)
3549 {
3550 if (!(proto_str = strdup_lower(proto))) return NULL;
3551 }
3552 EnterCriticalSection( &csWSgetXXXbyYYY );
3553 if( (serv = getservbyport(port, proto_str)) != NULL ) {
3554 retval = WS_dup_se(serv);
3555 }
3556 else SetLastError(WSANO_DATA);
3557 LeaveCriticalSection( &csWSgetXXXbyYYY );
3558 HeapFree( GetProcessHeap(), 0, proto_str );
3559 #endif
3560 TRACE("%d (i.e. port %d), %s ret %p\n", port, (int)ntohl(port), debugstr_a(proto), retval);
3561 return retval;
3562 }
3563
3564
3565 /***********************************************************************
3566 * gethostname (WS2_32.57)
3567 */
3568 int WINAPI WS_gethostname(char *name, int namelen)
3569 {
3570 TRACE("name %p, len %d\n", name, namelen);
3571
3572 if (gethostname(name, namelen) == 0)
3573 {
3574 TRACE("<- '%s'\n", name);
3575 return 0;
3576 }
3577 SetLastError((errno == EINVAL) ? WSAEFAULT : wsaErrno());
3578 TRACE("<- ERROR !\n");
3579 return SOCKET_ERROR;
3580 }
3581
3582
3583 /* ------------------------------------- Windows sockets extensions -- *
3584 * *
3585 * ------------------------------------------------------------------- */
3586
3587 /***********************************************************************
3588 * WSAEnumNetworkEvents (WS2_32.36)
3589 */
3590 int WINAPI WSAEnumNetworkEvents(SOCKET s, WSAEVENT hEvent, LPWSANETWORKEVENTS lpEvent)
3591 {
3592 int ret;
3593
3594 TRACE("%08lx, hEvent %p, lpEvent %p\n", s, hEvent, lpEvent );
3595
3596 SERVER_START_REQ( get_socket_event )
3597 {
3598 req->handle = SOCKET2HANDLE(s);
3599 req->service = TRUE;
3600 req->c_event = hEvent;
3601 wine_server_set_reply( req, lpEvent->iErrorCode, sizeof(lpEvent->iErrorCode) );
3602 if (!(ret = wine_server_call(req))) lpEvent->lNetworkEvents = reply->pmask & reply->mask;
3603 }
3604 SERVER_END_REQ;
3605 if (!ret) return 0;
3606 SetLastError(WSAEINVAL);
3607 return SOCKET_ERROR;
3608 }
3609
3610 /***********************************************************************
3611 * WSAEventSelect (WS2_32.39)
3612 */
3613 int WINAPI WSAEventSelect(SOCKET s, WSAEVENT hEvent, long lEvent)
3614 {
3615 int ret;
3616
3617 TRACE("%08lx, hEvent %p, event %08x\n", s, hEvent, (unsigned)lEvent );
3618
3619 SERVER_START_REQ( set_socket_event )
3620 {
3621 req->handle = SOCKET2HANDLE(s);
3622 req->mask = lEvent;
3623 req->event = hEvent;
3624 req->window = 0;
3625 req->msg = 0;
3626 ret = wine_server_call( req );
3627 }
3628 SERVER_END_REQ;
3629 if (!ret) return 0;
3630 SetLastError(WSAEINVAL);
3631 return SOCKET_ERROR;
3632 }
3633
3634 /**********************************************************************
3635 * WSAGetOverlappedResult (WS2_32.40)
3636 */
3637 BOOL WINAPI WSAGetOverlappedResult( SOCKET s, LPWSAOVERLAPPED lpOverlapped,
3638 LPDWORD lpcbTransfer, BOOL fWait,
3639 LPDWORD lpdwFlags )
3640 {
3641 DWORD r;
3642
3643 TRACE( "socket %04lx ovl %p trans %p, wait %d flags %p\n",
3644 s, lpOverlapped, lpcbTransfer, fWait, lpdwFlags );
3645
3646 if ( lpOverlapped == NULL )
3647 {
3648 ERR( "Invalid pointer\n" );
3649 WSASetLastError(WSA_INVALID_PARAMETER);
3650 return FALSE;
3651 }
3652
3653 if ( fWait )
3654 {
3655 if (lpOverlapped->hEvent)
3656 while ( WaitForSingleObjectEx(lpOverlapped->hEvent,
3657 INFINITE, TRUE) == STATUS_USER_APC );
3658 else /* busy loop */
3659 while ( ((volatile OVERLAPPED*)lpOverlapped)->Internal == STATUS_PENDING )
3660 Sleep( 10 );
3661
3662 }
3663 else if ( lpOverlapped->Internal == STATUS_PENDING )
3664 {
3665 /* Wait in order to give APCs a chance to run. */
3666 /* This is cheating, so we must set the event again in case of success -
3667 it may be a non-manual reset event. */
3668 while ( (r = WaitForSingleObjectEx(lpOverlapped->hEvent, 0, TRUE)) == STATUS_USER_APC );
3669 if ( r == WAIT_OBJECT_0 && lpOverlapped->hEvent )
3670 NtSetEvent( lpOverlapped->hEvent, NULL );
3671 }
3672
3673 if ( lpcbTransfer )
3674 *lpcbTransfer = lpOverlapped->InternalHigh;
3675
3676 if ( lpdwFlags )
3677 *lpdwFlags = lpOverlapped->u.s.Offset;
3678
3679 switch ( lpOverlapped->Internal )
3680 {
3681 case STATUS_SUCCESS:
3682 return TRUE;
3683 case STATUS_PENDING:
3684 WSASetLastError( WSA_IO_INCOMPLETE );
3685 if (fWait) ERR("PENDING status after waiting!\n");
3686 return FALSE;
3687 default:
3688 WSASetLastError( NtStatusToWSAError( lpOverlapped->Internal ));
3689 return FALSE;
3690 }
3691 }
3692
3693
3694 /***********************************************************************
3695 * WSAAsyncSelect (WS2_32.101)
3696 */
3697 INT WINAPI WSAAsyncSelect(SOCKET s, HWND hWnd, UINT uMsg, long lEvent)
3698 {
3699 int ret;
3700
3701 TRACE("%lx, hWnd %p, uMsg %08x, event %08lx\n", s, hWnd, uMsg, lEvent );
3702
3703 SERVER_START_REQ( set_socket_event )
3704 {
3705 req->handle = SOCKET2HANDLE(s);
3706 req->mask = lEvent;
3707 req->event = 0;
3708 req->window = hWnd;
3709 req->msg = uMsg;
3710 ret = wine_server_call( req );
3711 }
3712 SERVER_END_REQ;
3713 if (!ret) return 0;
3714 SetLastError(WSAEINVAL);
3715 return SOCKET_ERROR;
3716 }
3717
3718 /***********************************************************************
3719 * WSACreateEvent (WS2_32.31)
3720 *
3721 */
3722 WSAEVENT WINAPI WSACreateEvent(void)
3723 {
3724 /* Create a manual-reset event, with initial state: unsignaled */
3725 TRACE("\n");
3726
3727 return CreateEventW(NULL, TRUE, FALSE, NULL);
3728 }
3729
3730 /***********************************************************************
3731 * WSACloseEvent (WS2_32.29)
3732 *
3733 */
3734 BOOL WINAPI WSACloseEvent(WSAEVENT event)
3735 {
3736 TRACE ("event=%p\n", event);
3737
3738 return CloseHandle(event);
3739 }
3740
3741 /***********************************************************************
3742 * WSASocketA (WS2_32.78)
3743 *
3744 */
3745 SOCKET WINAPI WSASocketA(int af, int type, int protocol,
3746 LPWSAPROTOCOL_INFOA lpProtocolInfo,
3747 GROUP g, DWORD dwFlags)
3748 {
3749 INT len;
3750 WSAPROTOCOL_INFOW info;
3751
3752 TRACE("af=%d type=%d protocol=%d protocol_info=%p group=%d flags=0x%x\n",
3753 af, type, protocol, lpProtocolInfo, g, dwFlags);
3754
3755 if (!lpProtocolInfo) return WSASocketW(af, type, protocol, NULL, g, dwFlags);
3756
3757 memcpy(&info, lpProtocolInfo, FIELD_OFFSET(WSAPROTOCOL_INFOW, szProtocol));
3758 len = MultiByteToWideChar(CP_ACP, 0, lpProtocolInfo->szProtocol, -1,
3759 info.szProtocol, WSAPROTOCOL_LEN + 1);
3760
3761 if (!len)
3762 {
3763 WSASetLastError( WSAEINVAL);
3764 return SOCKET_ERROR;
3765 }
3766
3767 return WSASocketW(af, type, protocol, &info, g, dwFlags);
3768 }
3769
3770 /***********************************************************************
3771 * WSASocketW (WS2_32.79)
3772 *
3773 */
3774 SOCKET WINAPI WSASocketW(int af, int type, int protocol,
3775 LPWSAPROTOCOL_INFOW lpProtocolInfo,
3776 GROUP g, DWORD dwFlags)
3777 {
3778 SOCKET ret;
3779
3780 /*
3781 FIXME: The "advanced" parameters of WSASocketW (lpProtocolInfo,
3782 g, dwFlags except WSA_FLAG_OVERLAPPED) are ignored.
3783 */
3784
3785 TRACE("af=%d type=%d protocol=%d protocol_info=%p group=%d flags=0x%x\n",
3786 af, type, protocol, lpProtocolInfo, g, dwFlags );
3787
3788 /* hack for WSADuplicateSocket */
3789 if (lpProtocolInfo && lpProtocolInfo->dwServiceFlags4 == 0xff00ff00) {
3790 ret = lpProtocolInfo->dwCatalogEntryId;
3791 TRACE("\tgot duplicate %04lx\n", ret);
3792 return ret;
3793 }
3794
3795 /* check and convert the socket family */
3796 af = convert_af_w2u(af);
3797 if (af == -1)
3798 {
3799 FIXME("Unsupported socket family %d!\n", af);
3800 SetLastError(WSAEAFNOSUPPORT);
3801 return INVALID_SOCKET;
3802 }
3803
3804 /* check the socket type */
3805 type = convert_socktype_w2u(type);
3806 if (type == -1)
3807 {
3808 SetLastError(WSAESOCKTNOSUPPORT);
3809 return INVALID_SOCKET;
3810 }
3811
3812 /* check the protocol type */
3813 if ( protocol < 0 ) /* don't support negative values */
3814 {
3815 SetLastError(WSAEPROTONOSUPPORT);
3816 return INVALID_SOCKET;
3817 }
3818
3819 if ( af == AF_UNSPEC) /* did they not specify the address family? */
3820 switch(protocol)
3821 {
3822 case IPPROTO_TCP:
3823 if (type == SOCK_STREAM) { af = AF_INET; break; }
3824 case IPPROTO_UDP:
3825 if (type == SOCK_DGRAM) { af = AF_INET; break; }
3826 default: SetLastError(WSAEPROTOTYPE); return INVALID_SOCKET;
3827 }
3828
3829 SERVER_START_REQ( create_socket )
3830 {
3831 req->family = af;
3832 req->type = type;
3833 req->protocol = protocol;
3834 req->access = GENERIC_READ|GENERIC_WRITE|SYNCHRONIZE;
3835 req->attributes = OBJ_INHERIT;
3836 req->flags = dwFlags;
3837 set_error( wine_server_call( req ) );
3838 ret = HANDLE2SOCKET( reply->handle );
3839 }
3840 SERVER_END_REQ;
3841 if (ret)
3842 {
3843 TRACE("\tcreated %04lx\n", ret );
3844 return ret;
3845 }
3846
3847 if (GetLastError() == WSAEACCES) /* raw socket denied */
3848 {
3849 if (type == SOCK_RAW)
3850 MESSAGE("WARNING: Trying to create a socket of type SOCK_RAW, will fail unless running as root\n");
3851 else
3852 MESSAGE("WS_SOCKET: not enough privileges to create socket, try running as root\n");
3853 SetLastError(WSAESOCKTNOSUPPORT);
3854 }
3855
3856 WARN("\t\tfailed!\n");
3857 return INVALID_SOCKET;
3858 }
3859
3860 /***********************************************************************
3861 * WSAJoinLeaf (WS2_32.58)
3862 *
3863 */
3864 SOCKET WINAPI WSAJoinLeaf(
3865 SOCKET s,
3866 const struct WS_sockaddr *addr,
3867 int addrlen,
3868 LPWSABUF lpCallerData,
3869 LPWSABUF lpCalleeData,
3870 LPQOS lpSQOS,
3871 LPQOS lpGQOS,
3872 DWORD dwFlags)
3873 {
3874 FIXME("stub.\n");
3875 return INVALID_SOCKET;
3876 }
3877
3878 /***********************************************************************
3879 * __WSAFDIsSet (WS2_32.151)
3880 */
3881 int WINAPI __WSAFDIsSet(SOCKET s, WS_fd_set *set)
3882 {
3883 int i = set->fd_count;
3884
3885 TRACE("(%ld,%p(%i))\n", s, set, i);
3886
3887 while (i--)
3888 if (set->fd_array[i] == s) return 1;
3889 return 0;
3890 }
3891
3892 /***********************************************************************
3893 * WSAIsBlocking (WINSOCK.114)
3894 * WSAIsBlocking (WS2_32.114)
3895 */
3896 BOOL WINAPI WSAIsBlocking(void)
3897 {
3898 /* By default WinSock should set all its sockets to non-blocking mode
3899 * and poll in PeekMessage loop when processing "blocking" ones. This
3900 * function is supposed to tell if the program is in this loop. Our
3901 * blocking calls are truly blocking so we always return FALSE.
3902 *
3903 * Note: It is allowed to call this function without prior WSAStartup().
3904 */
3905
3906 TRACE("\n");
3907 return FALSE;
3908 }
3909
3910 /***********************************************************************
3911 * WSACancelBlockingCall (WINSOCK.113)
3912 * WSACancelBlockingCall (WS2_32.113)
3913 */
3914 INT WINAPI WSACancelBlockingCall(void)
3915 {
3916 TRACE("\n");
3917 return 0;
3918 }
3919
3920 static INT WINAPI WSA_DefaultBlockingHook( FARPROC x )
3921 {
3922 FIXME("How was this called?\n");
3923 return x();
3924 }
3925
3926
3927 /***********************************************************************
3928 * WSASetBlockingHook (WS2_32.109)
3929 */
3930 FARPROC WINAPI WSASetBlockingHook(FARPROC lpBlockFunc)
3931 {
3932 FARPROC prev = blocking_hook;
3933 blocking_hook = lpBlockFunc;
3934 TRACE("hook %p\n", lpBlockFunc);
3935 return prev;
3936 }
3937
3938
3939 /***********************************************************************
3940 * WSAUnhookBlockingHook (WS2_32.110)
3941 */
3942 INT WINAPI WSAUnhookBlockingHook(void)
3943 {
3944 blocking_hook = (FARPROC)WSA_DefaultBlockingHook;
3945 return 0;
3946 }
3947
3948
3949 /* ----------------------------------- end of API stuff */
3950
3951 /* ----------------------------------- helper functions -
3952 *
3953 * TODO: Merge WS_dup_..() stuff into one function that
3954 * would operate with a generic structure containing internal
3955 * pointers (via a template of some kind).
3956 */
3957
3958 static int list_size(char** l, int item_size)
3959 {
3960 int i,j = 0;
3961 if(l)
3962 { for(i=0;l[i];i++)
3963 j += (item_size) ? item_size : strlen(l[i]) + 1;
3964 j += (i + 1) * sizeof(char*); }
3965 return j;
3966 }
3967
3968 static int list_dup(char** l_src, char** l_to, int item_size)
3969 {
3970 char *p;
3971 int i;
3972
3973 for (i = 0; l_src[i]; i++) ;
3974 p = (char *)(l_to + i + 1);
3975 for (i = 0; l_src[i]; i++)
3976 {
3977 int count = ( item_size ) ? item_size : strlen(l_src[i]) + 1;
3978 memcpy(p, l_src[i], count);
3979 l_to[i] = p;
3980 p += count;
3981 }
3982 l_to[i] = NULL;
3983 return p - (char *)l_to;
3984 }
3985
3986 /* ----- hostent */
3987
3988 /* duplicate hostent entry
3989 * and handle all Win16/Win32 dependent things (struct size, ...) *correctly*.
3990 * Dito for protoent and servent.
3991 */
3992 static struct WS_hostent *WS_dup_he(const struct hostent* p_he)
3993 {
3994 char *p;
3995 struct WS_hostent *p_to;
3996
3997 int size = (sizeof(*p_he) +
3998 strlen(p_he->h_name) + 1 +
3999 list_size(p_he->h_aliases, 0) +
4000 list_size(p_he->h_addr_list, p_he->h_length));
4001
4002 if (!(p_to = check_buffer_he(size))) return NULL;
4003 p_to->h_addrtype = p_he->h_addrtype;
4004 p_to->h_length = p_he->h_length;
4005
4006 p = (char *)(p_to + 1);
4007 p_to->h_name = p;
4008 strcpy(p, p_he->h_name);
4009 p += strlen(p) + 1;
4010
4011 p_to->h_aliases = (char **)p;
4012 p += list_dup(p_he->h_aliases, p_to->h_aliases, 0);
4013
4014 p_to->h_addr_list = (char **)p;
4015 list_dup(p_he->h_addr_list, p_to->h_addr_list, p_he->h_length);
4016 return p_to;
4017 }
4018
4019 /* ----- protoent */
4020
4021 static struct WS_protoent *WS_dup_pe(const struct protoent* p_pe)
4022 {
4023 char *p;
4024 struct WS_protoent *p_to;
4025
4026 int size = (sizeof(*p_pe) +
4027 strlen(p_pe->p_name) + 1 +
4028 list_size(p_pe->p_aliases, 0));
4029
4030 if (!(p_to = check_buffer_pe(size))) return NULL;
4031 p_to->p_proto = p_pe->p_proto;
4032
4033 p = (char *)(p_to + 1);
4034 p_to->p_name = p;
4035 strcpy(p, p_pe->p_name);
4036 p += strlen(p) + 1;
4037
4038 p_to->p_aliases = (char **)p;
4039 list_dup(p_pe->p_aliases, p_to->p_aliases, 0);
4040 return p_to;
4041 }
4042
4043 /* ----- servent */
4044
4045 static struct WS_servent *WS_dup_se(const struct servent* p_se)
4046 {
4047 char *p;
4048 struct WS_servent *p_to;
4049
4050 int size = (sizeof(*p_se) +
4051 strlen(p_se->s_proto) + 1 +
4052 strlen(p_se->s_name) + 1 +
4053 list_size(p_se->s_aliases, 0));
4054
4055 if (!(p_to = check_buffer_se(size))) return NULL;
4056 p_to->s_port = p_se->s_port;
4057
4058 p = (char *)(p_to + 1);
4059 p_to->s_name = p;
4060 strcpy(p, p_se->s_name);
4061 p += strlen(p) + 1;
4062
4063 p_to->s_proto = p;
4064 strcpy(p, p_se->s_proto);
4065 p += strlen(p) + 1;
4066
4067 p_to->s_aliases = (char **)p;
4068 list_dup(p_se->s_aliases, p_to->s_aliases, 0);
4069 return p_to;
4070 }
4071
4072 /* ----------------------------------- error handling */
4073
4074 UINT wsaErrno(void)
4075 {
4076 int loc_errno = errno;
4077 WARN("errno %d, (%s).\n", loc_errno, strerror(loc_errno));
4078
4079 switch(loc_errno)
4080 {
4081 case EINTR: return WSAEINTR;
4082 case EBADF: return WSAEBADF;
4083 case EPERM:
4084 case EACCES: return WSAEACCES;
4085 case EFAULT: return WSAEFAULT;
4086 case EINVAL: return WSAEINVAL;
4087 case EMFILE: return WSAEMFILE;
4088 case EWOULDBLOCK: return WSAEWOULDBLOCK;
4089 case EINPROGRESS: return WSAEINPROGRESS;
4090 case EALREADY: return WSAEALREADY;
4091 case ENOTSOCK: return WSAENOTSOCK;
4092 case EDESTADDRREQ: return WSAEDESTADDRREQ;
4093 case EMSGSIZE: return WSAEMSGSIZE;
4094 case EPROTOTYPE: return WSAEPROTOTYPE;
4095 case ENOPROTOOPT: return WSAENOPROTOOPT;
4096 case EPROTONOSUPPORT: return WSAEPROTONOSUPPORT;
4097 case ESOCKTNOSUPPORT: return WSAESOCKTNOSUPPORT;
4098 case EOPNOTSUPP: return WSAEOPNOTSUPP;
4099 case EPFNOSUPPORT: return WSAEPFNOSUPPORT;
4100 case EAFNOSUPPORT: return WSAEAFNOSUPPORT;
4101 case EADDRINUSE: return WSAEADDRINUSE;
4102 case EADDRNOTAVAIL: return WSAEADDRNOTAVAIL;
4103 case ENETDOWN: return WSAENETDOWN;
4104 case ENETUNREACH: return WSAENETUNREACH;
4105 case ENETRESET: return WSAENETRESET;
4106 case ECONNABORTED: return WSAECONNABORTED;
4107 case EPIPE:
4108 case ECONNRESET: return WSAECONNRESET;
4109 case ENOBUFS: return WSAENOBUFS;
4110 case EISCONN: return WSAEISCONN;
4111 case ENOTCONN: return WSAENOTCONN;
4112 case ESHUTDOWN: return WSAESHUTDOWN;
4113 case ETOOMANYREFS: return WSAETOOMANYREFS;
4114 case ETIMEDOUT: return WSAETIMEDOUT;
4115 case ECONNREFUSED: return WSAECONNREFUSED;
4116 case ELOOP: return WSAELOOP;
4117 case ENAMETOOLONG: return WSAENAMETOOLONG;
4118 case EHOSTDOWN: return WSAEHOSTDOWN;
4119 case EHOSTUNREACH: return WSAEHOSTUNREACH;
4120 case ENOTEMPTY: return WSAENOTEMPTY;
4121 #ifdef EPROCLIM
4122 case EPROCLIM: return WSAEPROCLIM;
4123 #endif
4124 #ifdef EUSERS
4125 case EUSERS: return WSAEUSERS;
4126 #endif
4127 #ifdef EDQUOT
4128 case EDQUOT: return WSAEDQUOT;
4129 #endif
4130 #ifdef ESTALE
4131 case ESTALE: return WSAESTALE;
4132 #endif
4133 #ifdef EREMOTE
4134 case EREMOTE: return WSAEREMOTE;
4135 #endif
4136
4137 /* just in case we ever get here and there are no problems */
4138 case 0: return 0;
4139 default:
4140 WARN("Unknown errno %d!\n", loc_errno);
4141 return WSAEOPNOTSUPP;
4142 }
4143 }
4144
4145 UINT wsaHerrno(int loc_errno)
4146 {
4147
4148 WARN("h_errno %d.\n", loc_errno);
4149
4150 switch(loc_errno)
4151 {
4152 case HOST_NOT_FOUND: return WSAHOST_NOT_FOUND;
4153 case TRY_AGAIN: return WSATRY_AGAIN;
4154 case NO_RECOVERY: return WSANO_RECOVERY;
4155 case NO_DATA: return WSANO_DATA;
4156 case ENOBUFS: return WSAENOBUFS;
4157
4158 case 0: return 0;
4159 default:
4160 WARN("Unknown h_errno %d!\n", loc_errno);
4161 return WSAEOPNOTSUPP;
4162 }
4163 }
4164
4165
4166 /***********************************************************************
4167 * WSARecv (WS2_32.67)
4168 */
4169 int WINAPI WSARecv(SOCKET s, LPWSABUF lpBuffers, DWORD dwBufferCount,
4170 LPDWORD NumberOfBytesReceived, LPDWORD lpFlags,
4171 LPWSAOVERLAPPED lpOverlapped,
4172 LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
4173 {
4174 return WSARecvFrom(s, lpBuffers, dwBufferCount, NumberOfBytesReceived, lpFlags,
4175 NULL, NULL, lpOverlapped, lpCompletionRoutine);
4176 }
4177
4178 /***********************************************************************
4179 * WSARecvFrom (WS2_32.69)
4180 */
4181 INT WINAPI WSARecvFrom( SOCKET s, LPWSABUF lpBuffers, DWORD dwBufferCount,
4182 LPDWORD lpNumberOfBytesRecvd, LPDWORD lpFlags, struct WS_sockaddr *lpFrom,
4183 LPINT lpFromlen, LPWSAOVERLAPPED lpOverlapped,
4184 LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine )
4185
4186 {
4187 unsigned int i, options;
4188 int n, fd, err;
4189 DWORD timeout_start = GetTickCount();
4190 struct iovec iovec[WS_MSG_MAXIOVLEN];
4191 struct ws2_async *wsa;
4192 IO_STATUS_BLOCK* iosb;
4193
4194 TRACE("socket %04lx, wsabuf %p, nbufs %d, flags %d, from %p, fromlen %d, ovl %p, func %p\n",
4195 s, lpBuffers, dwBufferCount, *lpFlags, lpFrom,
4196 (lpFromlen ? *lpFromlen : -1),
4197 lpOverlapped, lpCompletionRoutine);
4198
4199 if (dwBufferCount > WS_MSG_MAXIOVLEN)
4200 {
4201 WSASetLastError( WSAEINVAL );
4202 return SOCKET_ERROR;
4203 }
4204
4205 fd = get_sock_fd( s, FILE_READ_DATA, &options );
4206 TRACE( "fd=%d, options=%x\n", fd, options );
4207
4208 if (fd == -1) return SOCKET_ERROR;
4209
4210 for (i = 0; i < dwBufferCount; i++)
4211 {
4212 iovec[i].iov_base = lpBuffers[i].buf;
4213 iovec[i].iov_len = lpBuffers[i].len;
4214 }
4215
4216 for (;;)
4217 {
4218 n = WS2_recv( fd, iovec, dwBufferCount, lpFrom, lpFromlen, lpFlags );
4219 if (n != -1) break;
4220
4221 if (errno == EINTR) continue;
4222 if (errno != EAGAIN)
4223 {
4224 err = wsaErrno();
4225 goto error;
4226 }
4227
4228 if ((lpOverlapped || lpCompletionRoutine) &&
4229 !(options & (FILE_SYNCHRONOUS_IO_ALERT | FILE_SYNCHRONOUS_IO_NONALERT)))
4230 {
4231 wsa = WS2_make_async( s, ws2m_read, iovec, dwBufferCount,
4232 lpFlags, lpFrom, lpFromlen,
4233 lpOverlapped, lpCompletionRoutine, &iosb );
4234 if ( !wsa )
4235 {
4236 err = WSAEFAULT;
4237 goto error;
4238 }
4239 release_sock_fd( s, fd );
4240
4241 iosb->u.Status = STATUS_PENDING;
4242 iosb->Information = 0;
4243
4244 SERVER_START_REQ( register_async )
4245 {
4246 req->handle = wsa->hSocket;
4247 req->type = ASYNC_TYPE_READ;
4248 req->async.callback = WS2_async_recv;
4249 req->async.iosb = iosb;
4250 req->async.arg = wsa;
4251 req->async.event = lpCompletionRoutine ? 0 : lpOverlapped->hEvent;
4252 err = wine_server_call( req );
4253 }
4254 SERVER_END_REQ;
4255
4256 if (err == STATUS_PENDING)
4257 NtCurrentTeb()->num_async_io++;
4258 else
4259 ws2_async_terminate(wsa, iosb, err, 0);
4260
4261 WSASetLastError( NtStatusToWSAError( err ));
4262 return SOCKET_ERROR;
4263 }
4264
4265 if ( _is_blocking(s) )
4266 {
4267 struct pollfd pfd;
4268 int timeout = GET_RCVTIMEO(fd);
4269 if (timeout != -1)
4270 {
4271 timeout -= GetTickCount() - timeout_start;
4272 if (timeout < 0) timeout = 0;
4273 }
4274
4275 pfd.fd = fd;
4276 pfd.events = POLLIN;
4277 if (*lpFlags & WS_MSG_OOB) pfd.events |= POLLPRI;
4278
4279 if (!timeout || !poll( &pfd, 1, timeout ))
4280 {
4281 err = WSAETIMEDOUT;
4282 /* a timeout is not fatal */
4283 _enable_event(SOCKET2HANDLE(s), FD_READ, 0, 0);
4284 goto error;
4285 }
4286 }
4287 else
4288 {
4289 _enable_event(SOCKET2HANDLE(s), FD_READ, 0, 0);
4290 err = WSAEWOULDBLOCK;
4291 goto error;
4292 }
4293 }
4294
4295 TRACE(" -> %i bytes\n", n);
4296 *lpNumberOfBytesRecvd = n;
4297
4298 release_sock_fd( s, fd );
4299 _enable_event(SOCKET2HANDLE(s), FD_READ, 0, 0);
4300
4301 return 0;
4302
4303 error:
4304 release_sock_fd( s, fd );
4305 WARN(" -> ERROR %d\n", err);
4306 WSASetLastError( err );
4307 return SOCKET_ERROR;
4308 }
4309
4310 /***********************************************************************
4311 * WSCInstallProvider (WS2_32.88)
4312 */
4313 INT WINAPI WSCInstallProvider( const LPGUID lpProviderId,
4314 LPCWSTR lpszProviderDllPath,
4315 const LPWSAPROTOCOL_INFOW lpProtocolInfoList,
4316 DWORD dwNumberOfEntries,
4317 LPINT lpErrno )
4318 {
4319 FIXME("(%s, %s, %p, %d, %p): stub !\n", debugstr_guid(lpProviderId),
4320 debugstr_w(lpszProviderDllPath), lpProtocolInfoList,
4321 dwNumberOfEntries, lpErrno);
4322 *lpErrno = 0;
4323 return 0;
4324 }
4325
4326
4327 /***********************************************************************
4328 * WSCDeinstallProvider (WS2_32.83)
4329 */
4330 INT WINAPI WSCDeinstallProvider(LPGUID lpProviderId, LPINT lpErrno)
4331 {
4332 FIXME("(%s, %p): stub !\n", debugstr_guid(lpProviderId), lpErrno);
4333 *lpErrno = 0;
4334 return 0;
4335 }
4336
4337
4338 /***********************************************************************
4339 * WSAAccept (WS2_32.26)
4340 */
4341 SOCKET WINAPI WSAAccept( SOCKET s, struct WS_sockaddr *addr, LPINT addrlen,
4342 LPCONDITIONPROC lpfnCondition, DWORD dwCallbackData)
4343 {
4344
4345 int ret = 0, size = 0;
4346 WSABUF CallerId, CallerData, CalleeId, CalleeData;
4347 /* QOS SQOS, GQOS; */
4348 GROUP g;
4349 SOCKET cs;
4350 SOCKADDR src_addr, dst_addr;
4351
4352 TRACE("Socket %04lx, sockaddr %p, addrlen %p, fnCondition %p, dwCallbackData %d\n",
4353 s, addr, addrlen, lpfnCondition, dwCallbackData);
4354
4355
4356 size = sizeof(src_addr);
4357 cs = WS_accept(s, &src_addr, &size);
4358
4359 if (cs == SOCKET_ERROR) return SOCKET_ERROR;
4360
4361 CallerId.buf = (char *)&src_addr;
4362 CallerId.len = sizeof(src_addr);
4363
4364 CallerData.buf = NULL;
4365 CallerData.len = (ULONG)NULL;
4366
4367 WS_getsockname(cs, &dst_addr, &size);
4368
4369 CalleeId.buf = (char *)&dst_addr;
4370 CalleeId.len = sizeof(dst_addr);
4371
4372
4373 ret = (*lpfnCondition)(&CallerId, &CallerData, NULL, NULL,
4374 &CalleeId, &CalleeData, &g, dwCallbackData);
4375
4376 switch (ret)
4377 {
4378 case CF_ACCEPT:
4379 if (addr && addrlen)
4380 addr = memcpy(addr, &src_addr, (*addrlen > size) ? size : *addrlen );
4381 return cs;
4382 case CF_DEFER:
4383 SERVER_START_REQ( set_socket_deferred )
4384 {
4385 req->handle = SOCKET2HANDLE(s);
4386 req->deferred = SOCKET2HANDLE(cs);
4387 if ( !wine_server_call_err ( req ) )
4388 {
4389 SetLastError( WSATRY_AGAIN );
4390 WS_closesocket( cs );
4391 }
4392 }
4393 SERVER_END_REQ;
4394 return SOCKET_ERROR;
4395 case CF_REJECT:
4396 WS_closesocket(cs);
4397 SetLastError(WSAECONNREFUSED);
4398 return SOCKET_ERROR;
4399 default:
4400 FIXME("Unknown return type from Condition function\n");
4401 SetLastError(WSAENOTSOCK);
4402 return SOCKET_ERROR;
4403 }
4404 }
4405
4406 /***********************************************************************
4407 * WSADuplicateSocketA (WS2_32.32)
4408 */
4409 int WINAPI WSADuplicateSocketA( SOCKET s, DWORD dwProcessId, LPWSAPROTOCOL_INFOA lpProtocolInfo )
4410 {
4411 HANDLE hProcess;
4412
4413 TRACE("(%ld,%x,%p)\n", s, dwProcessId, lpProtocolInfo);
4414 memset(lpProtocolInfo, 0, sizeof(*lpProtocolInfo));
4415 /* FIXME: WS_getsockopt(s, WS_SOL_SOCKET, SO_PROTOCOL_INFO, lpProtocolInfo, sizeof(*lpProtocolInfo)); */
4416 /* I don't know what the real Windoze does next, this is a hack */
4417 /* ...we could duplicate and then use ConvertToGlobalHandle on the duplicate, then let
4418 * the target use the global duplicate, or we could copy a reference to us to the structure
4419 * and let the target duplicate it from us, but let's do it as simple as possible */
4420 hProcess = OpenProcess(PROCESS_DUP_HANDLE, FALSE, dwProcessId);
4421 DuplicateHandle(GetCurrentProcess(), SOCKET2HANDLE(s),
4422 hProcess, (LPHANDLE)&lpProtocolInfo->dwCatalogEntryId,
4423 0, FALSE, DUPLICATE_SAME_ACCESS);
4424 CloseHandle(hProcess);
4425 lpProtocolInfo->dwServiceFlags4 = 0xff00ff00; /* magic */
4426 return 0;
4427 }
4428
4429 /***********************************************************************
4430 * WSADuplicateSocketW (WS2_32.33)
4431 */
4432 int WINAPI WSADuplicateSocketW( SOCKET s, DWORD dwProcessId, LPWSAPROTOCOL_INFOW lpProtocolInfo )
4433 {
4434 HANDLE hProcess;
4435
4436 TRACE("(%ld,%x,%p)\n", s, dwProcessId, lpProtocolInfo);
4437
4438 memset(lpProtocolInfo, 0, sizeof(*lpProtocolInfo));
4439 hProcess = OpenProcess(PROCESS_DUP_HANDLE, FALSE, dwProcessId);
4440 DuplicateHandle(GetCurrentProcess(), SOCKET2HANDLE(s),
4441 hProcess, (LPHANDLE)&lpProtocolInfo->dwCatalogEntryId,
4442 0, FALSE, DUPLICATE_SAME_ACCESS);
4443 CloseHandle(hProcess);
4444 lpProtocolInfo->dwServiceFlags4 = 0xff00ff00; /* magic */
4445 return 0;
4446 }
4447
4448 /***********************************************************************
4449 * WSAInstallServiceClassA (WS2_32.48)
4450 */
4451 int WINAPI WSAInstallServiceClassA(LPWSASERVICECLASSINFOA info)
4452 {
4453 FIXME("Request to install service %s\n",debugstr_a(info->lpszServiceClassName));
4454 WSASetLastError(WSAEACCES);
4455 return SOCKET_ERROR;
4456 }
4457
4458 /***********************************************************************
4459 * WSAInstallServiceClassW (WS2_32.49)
4460 */
4461 int WINAPI WSAInstallServiceClassW(LPWSASERVICECLASSINFOW info)
4462 {
4463 FIXME("Request to install service %s\n",debugstr_w(info->lpszServiceClassName));
4464 WSASetLastError(WSAEACCES);
4465 return SOCKET_ERROR;
4466 }
4467
4468 /***********************************************************************
4469 * WSARemoveServiceClass (WS2_32.70)
4470 */
4471 int WINAPI WSARemoveServiceClass(LPGUID info)
4472 {
4473 FIXME("Request to remove service %p\n",info);
4474 WSASetLastError(WSATYPE_NOT_FOUND);
4475 return SOCKET_ERROR;
4476 }
4477
4478 /***********************************************************************
4479 * WSAStringToAddressA (WS2_32.80)
4480 */
4481 INT WINAPI WSAStringToAddressA(LPSTR AddressString,
4482 INT AddressFamily,
4483 LPWSAPROTOCOL_INFOA lpProtocolInfo,
4484 LPSOCKADDR lpAddress,
4485 LPINT lpAddressLength)
4486 {
4487 INT res=0;
4488 struct in_addr inetaddr;
4489 LPSTR workBuffer=NULL,ptrPort;
4490
4491 TRACE( "(%s, %x, %p, %p, %p)\n", AddressString, AddressFamily, lpProtocolInfo,
4492 lpAddress, lpAddressLength );
4493
4494 if (!lpAddressLength || !lpAddress) return SOCKET_ERROR;
4495
4496 if (AddressString)
4497 {
4498 workBuffer = HeapAlloc( GetProcessHeap(), 0, strlen(AddressString)+1 );
4499 if (workBuffer)
4500 {
4501 strcpy(workBuffer,AddressString);
4502 switch (AddressFamily)
4503 {
4504 case AF_INET:
4505 /* caller wants to know the size of the socket buffer */
4506 if (*lpAddressLength < sizeof(SOCKADDR_IN))
4507 {
4508 *lpAddressLength = sizeof(SOCKADDR_IN);
4509 res = WSAEFAULT;
4510 }
4511 else
4512 {
4513 /* caller wants to translate an AddressString into a SOCKADDR */
4514 if (lpAddress)
4515 {
4516 memset(lpAddress,0,sizeof(SOCKADDR_IN));
4517 ((LPSOCKADDR_IN)lpAddress)->sin_family = AF_INET;
4518 ptrPort = strchr(workBuffer,':');
4519 if (ptrPort)
4520 {
4521 ((LPSOCKADDR_IN)lpAddress)->sin_port = (WS_u_short)atoi(ptrPort+1);
4522 *ptrPort = '\0';
4523 }
4524 else
4525 ((LPSOCKADDR_IN)lpAddress)->sin_port = 0;
4526 if (inet_aton(workBuffer, &inetaddr) > 0)
4527 {
4528 ((LPSOCKADDR_IN)lpAddress)->sin_addr.WS_s_addr = inetaddr.s_addr;
4529 res = 0;
4530 }
4531 else
4532 res = WSAEINVAL;
4533 }
4534 }
4535 if (lpProtocolInfo)
4536 FIXME("(%s, %x, %p, %p, %p) - ProtocolInfo not implemented!\n",
4537 AddressString, AddressFamily,
4538 lpProtocolInfo, lpAddress, lpAddressLength);
4539
4540 break;
4541 default:
4542 FIXME("(%s, %x, %p, %p, %p) - AddressFamiliy not implemented!\n",
4543 AddressString, AddressFamily,
4544 lpProtocolInfo, lpAddress, lpAddressLength);
4545 }
4546 HeapFree( GetProcessHeap(), 0, workBuffer );
4547 }
4548 else
4549 res = WSA_NOT_ENOUGH_MEMORY;
4550 }
4551 else
4552 res = WSAEINVAL;
4553
4554 if (!res) return 0;
4555 WSASetLastError(res);
4556 return SOCKET_ERROR;
4557 }
4558
4559 /***********************************************************************
4560 * WSAStringToAddressW (WS2_32.81)
4561 *
4562 * Does anybody know if this functions allows to use hebrew/arabic/chinese... digits?
4563 * If this should be the case, it would be required to map these digits
4564 * to Unicode digits (0-9) using FoldString first.
4565 */
4566 INT WINAPI WSAStringToAddressW(LPWSTR AddressString,
4567 INT AddressFamily,
4568 LPWSAPROTOCOL_INFOW lpProtocolInfo,
4569 LPSOCKADDR lpAddress,
4570 LPINT lpAddressLength)
4571 {
4572 INT sBuffer,res=0;
4573 LPSTR workBuffer=NULL;
4574 WSAPROTOCOL_INFOA infoA;
4575 LPWSAPROTOCOL_INFOA lpProtoInfoA = NULL;
4576
4577 TRACE( "(%s, %x, %p, %p, %p)\n", debugstr_w(AddressString), AddressFamily, lpProtocolInfo,
4578 lpAddress, lpAddressLength );
4579
4580 if (!lpAddressLength || !lpAddress) return SOCKET_ERROR;
4581
4582 /* if ProtocolInfo is available - convert to ANSI variant */
4583 if (lpProtocolInfo)
4584 {
4585 lpProtoInfoA = &infoA;
4586 memcpy( lpProtoInfoA, lpProtocolInfo, FIELD_OFFSET( WSAPROTOCOL_INFOA, szProtocol ) );
4587
4588 if (!WideCharToMultiByte( CP_ACP, 0, lpProtocolInfo->szProtocol, -1,
4589 lpProtoInfoA->szProtocol, WSAPROTOCOL_LEN+1, NULL, NULL ))
4590 {
4591 WSASetLastError( WSAEINVAL);
4592 return SOCKET_ERROR;
4593 }
4594 }
4595
4596 if (AddressString)
4597 {
4598 /* Translate AddressString to ANSI code page - assumes that only
4599 standard digits 0-9 are used with this API call */
4600 sBuffer = WideCharToMultiByte( CP_ACP, 0, AddressString, -1, NULL, 0, NULL, NULL );
4601 workBuffer = HeapAlloc( GetProcessHeap(), 0, sBuffer );
4602
4603 if (workBuffer)
4604 {
4605 WideCharToMultiByte( CP_ACP, 0, AddressString, -1, workBuffer, sBuffer, NULL, NULL );
4606 res = WSAStringToAddressA(workBuffer,AddressFamily,lpProtoInfoA,
4607 lpAddress,lpAddressLength);
4608 HeapFree( GetProcessHeap(), 0, workBuffer );
4609 return res;
4610 }
4611 else
4612 res = WSA_NOT_ENOUGH_MEMORY;
4613 }
4614 else
4615 res = WSAEINVAL;
4616
4617 WSASetLastError(res);
4618 return SOCKET_ERROR;
4619 }
4620
4621 /***********************************************************************
4622 * WSAAddressToStringA (WS2_32.27)
4623 *
4624 * See WSAAddressToStringW
4625 */
4626 INT WINAPI WSAAddressToStringA( LPSOCKADDR sockaddr, DWORD len,
4627 LPWSAPROTOCOL_INFOA info, LPSTR string,
4628 LPDWORD lenstr )
4629 {
4630 INT size;
4631 CHAR buffer[22]; /* 12 digits + 3 dots + ':' + 5 digits + '\0' */
4632 CHAR *p;
4633
4634 TRACE( "(%p, %d, %p, %p, %p)\n", sockaddr, len, info, string, lenstr );
4635
4636 if (!sockaddr || len < sizeof(SOCKADDR_IN)) return SOCKET_ERROR;
4637 if (!string || !lenstr) return SOCKET_ERROR;
4638
4639 /* sin_family is guaranteed to be the first u_short */
4640 if (((SOCKADDR_IN *)sockaddr)->sin_family != AF_INET) return SOCKET_ERROR;
4641
4642 sprintf( buffer, "%u.%u.%u.%u:%u",
4643 (unsigned int)(ntohl( ((SOCKADDR_IN *)sockaddr)->sin_addr.WS_s_addr ) >> 24 & 0xff),
4644 (unsigned int)(ntohl( ((SOCKADDR_IN *)sockaddr)->sin_addr.WS_s_addr ) >> 16 & 0xff),
4645 (unsigned int)(ntohl( ((SOCKADDR_IN *)sockaddr)->sin_addr.WS_s_addr ) >> 8 & 0xff),
4646 (unsigned int)(ntohl( ((SOCKADDR_IN *)sockaddr)->sin_addr.WS_s_addr ) & 0xff),
4647 ntohs( ((SOCKADDR_IN *)sockaddr)->sin_port ) );
4648
4649 p = strchr( buffer, ':' );
4650 if (!((SOCKADDR_IN *)sockaddr)->sin_port) *p = 0;
4651
4652 size = strlen( buffer );
4653
4654 if (*lenstr < size)
4655 {
4656 *lenstr = size;
4657 WSASetLastError(WSAEFAULT);
4658 return SOCKET_ERROR;
4659 }
4660
4661 strcpy( string, buffer );
4662 return 0;
4663 }
4664
4665 /***********************************************************************
4666 * WSAAddressToStringW (WS2_32.28)
4667 *
4668 * Convert a sockaddr address into a readable address string.
4669 *
4670 * PARAMS
4671 * sockaddr [I] Pointer to a sockaddr structure.
4672 * len [I] Size of the sockaddr structure.
4673 * info [I] Pointer to a WSAPROTOCOL_INFOW structure (optional).
4674 * string [I/O] Pointer to a buffer to receive the address string.
4675 * lenstr [I/O] Size of the receive buffer in WCHARs.
4676 *
4677 * RETURNS
4678 * Success: 0
4679 * Failure: SOCKET_ERROR
4680 *
4681 * NOTES
4682 * The 'info' parameter is ignored.
4683 *
4684 * BUGS
4685 * Only supports AF_INET addresses.
4686 */
4687 INT WINAPI WSAAddressToStringW( LPSOCKADDR sockaddr, DWORD len,
4688 LPWSAPROTOCOL_INFOW info, LPWSTR string,
4689 LPDWORD lenstr )
4690 {
4691 INT size;
4692 WCHAR buffer[22]; /* 12 digits + 3 dots + ':' + 5 digits + '\0' */
4693 static const WCHAR format[] = { '%','u','.','%','u','.','%','u','.','%','u',':','%','u',0 };
4694 WCHAR *p;
4695
4696 TRACE( "(%p, %x, %p, %p, %p)\n", sockaddr, len, info, string, lenstr );
4697
4698 if (!sockaddr || len < sizeof(SOCKADDR_IN)) return SOCKET_ERROR;
4699 if (!string || !lenstr) return SOCKET_ERROR;
4700
4701 /* sin_family is guaranteed to be the first u_short */
4702 if (((SOCKADDR_IN *)sockaddr)->sin_family != AF_INET) return SOCKET_ERROR;
4703
4704 sprintfW( buffer, format,
4705 (unsigned int)(ntohl( ((SOCKADDR_IN *)sockaddr)->sin_addr.WS_s_addr ) >> 24 & 0xff),
4706 (unsigned int)(ntohl( ((SOCKADDR_IN *)sockaddr)->sin_addr.WS_s_addr ) >> 16 & 0xff),
4707 (unsigned int)(ntohl( ((SOCKADDR_IN *)sockaddr)->sin_addr.WS_s_addr ) >> 8 & 0xff),
4708 (unsigned int)(ntohl( ((SOCKADDR_IN *)sockaddr)->sin_addr.WS_s_addr ) & 0xff),
4709 ntohs( ((SOCKADDR_IN *)sockaddr)->sin_port ) );
4710
4711 p = strchrW( buffer, ':' );
4712 if (!((SOCKADDR_IN *)sockaddr)->sin_port) *p = 0;
4713
4714 size = lstrlenW( buffer );
4715
4716 if (*lenstr < size)
4717 {
4718 *lenstr = size;
4719 return SOCKET_ERROR;
4720 }
4721
4722 lstrcpyW( string, buffer );
4723 return 0;
4724 }
4725
4726 /***********************************************************************
4727 * WSAEnumNameSpaceProvidersA (WS2_32.34)
4728 */
4729 INT WINAPI WSAEnumNameSpaceProvidersA( LPDWORD len, LPWSANAMESPACE_INFOA buffer )
4730 {
4731 FIXME( "(%p %p) Stub!\n", len, buffer );
4732 return 0;
4733 }
4734
4735 /***********************************************************************
4736 * WSAEnumNameSpaceProvidersW (WS2_32.35)
4737 */
4738 INT WINAPI WSAEnumNameSpaceProvidersW( LPDWORD len, LPWSANAMESPACE_INFOW buffer )
4739 {
4740 FIXME( "(%p %p) Stub!\n", len, buffer );
4741 return 0;
4742 }
4743
4744 /***********************************************************************
4745 * WSAGetQOSByName (WS2_32.41)
4746 */
4747 BOOL WINAPI WSAGetQOSByName( SOCKET s, LPWSABUF lpQOSName, LPQOS lpQOS )
4748 {
4749 FIXME( "(0x%04lx %p %p) Stub!\n", s, lpQOSName, lpQOS );
4750 return FALSE;
4751 }
4752
4753 /***********************************************************************
4754 * WSAGetServiceClassInfoA (WS2_32.42)
4755 */
4756 INT WINAPI WSAGetServiceClassInfoA( LPGUID provider, LPGUID service, LPDWORD len,
4757 LPWSASERVICECLASSINFOA info )
4758 {
4759 FIXME( "(%s %s %p %p) Stub!\n", debugstr_guid(provider), debugstr_guid(service),
4760 len, info );
4761 WSASetLastError(WSA_NOT_ENOUGH_MEMORY);
4762 return SOCKET_ERROR;
4763 }
4764
4765 /***********************************************************************
4766 * WSAGetServiceClassInfoW (WS2_32.43)
4767 */
4768 INT WINAPI WSAGetServiceClassInfoW( LPGUID provider, LPGUID service, LPDWORD len,
4769 LPWSASERVICECLASSINFOW info )
4770 {
4771 FIXME( "(%s %s %p %p) Stub!\n", debugstr_guid(provider), debugstr_guid(service),
4772 len, info );
4773 WSASetLastError(WSA_NOT_ENOUGH_MEMORY);
4774 return SOCKET_ERROR;
4775 }
4776
4777 /***********************************************************************
4778 * WSAGetServiceClassNameByClassIdA (WS2_32.44)
4779 */
4780 INT WINAPI WSAGetServiceClassNameByClassIdA( LPGUID class, LPSTR service, LPDWORD len )
4781 {
4782 FIXME( "(%s %p %p) Stub!\n", debugstr_guid(class), service, len );
4783 WSASetLastError(WSA_NOT_ENOUGH_MEMORY);
4784 return SOCKET_ERROR;
4785 }
4786
4787 /***********************************************************************
4788 * WSAGetServiceClassNameByClassIdW (WS2_32.45)
4789 */
4790 INT WINAPI WSAGetServiceClassNameByClassIdW( LPGUID class, LPWSTR service, LPDWORD len )
4791 {
4792 FIXME( "(%s %p %p) Stub!\n", debugstr_guid(class), service, len );
4793 WSASetLastError(WSA_NOT_ENOUGH_MEMORY);
4794 return SOCKET_ERROR;
4795 }
4796
4797 /***********************************************************************
4798 * WSALookupServiceBeginA (WS2_32.59)
4799 */
4800 INT WINAPI WSALookupServiceBeginA( LPWSAQUERYSETA lpqsRestrictions,
4801 DWORD dwControlFlags,
4802 LPHANDLE lphLookup)
4803 {
4804 FIXME("(%p 0x%08x %p) Stub!\n", lpqsRestrictions, dwControlFlags,
4805 lphLookup);
4806 WSASetLastError(WSA_NOT_ENOUGH_MEMORY);
4807 return SOCKET_ERROR;
4808 }
4809
4810 /***********************************************************************
4811 * WSALookupServiceBeginW (WS2_32.60)
4812 */
4813 INT WINAPI WSALookupServiceBeginW( LPWSAQUERYSETW lpqsRestrictions,
4814 DWORD dwControlFlags,
4815 LPHANDLE lphLookup)
4816 {
4817 FIXME("(%p 0x%08x %p) Stub!\n", lpqsRestrictions, dwControlFlags,
4818 lphLookup);
4819 WSASetLastError(WSA_NOT_ENOUGH_MEMORY);
4820 return SOCKET_ERROR;
4821 }
4822
4823 /***********************************************************************
4824 * WSALookupServiceBeginW (WS2_32.61)
4825 */
4826 INT WINAPI WSALookupServiceEnd( HANDLE lookup )
4827 {
4828 FIXME("(%p) Stub!\n", lookup );
4829 return 0;
4830 }
4831
4832 /***********************************************************************
4833 * WSALookupServiceNextA (WS2_32.62)
4834 */
4835 INT WINAPI WSALookupServiceNextA( HANDLE lookup, DWORD flags, LPDWORD len, LPWSAQUERYSETA results )
4836 {
4837 FIXME( "(%p 0x%08x %p %p) Stub!\n", lookup, flags, len, results );
4838 return 0;
4839 }
4840
4841 /***********************************************************************
4842 * WSALookupServiceNextW (WS2_32.63)
4843 */
4844 INT WINAPI WSALookupServiceNextW( HANDLE lookup, DWORD flags, LPDWORD len, LPWSAQUERYSETW results )
4845 {
4846 FIXME( "(%p 0x%08x %p %p) Stub!\n", lookup, flags, len, results );
4847 return 0;
4848 }
4849
4850 /***********************************************************************
4851 * WSANtohl (WS2_32.64)
4852 */
4853 INT WINAPI WSANtohl( SOCKET s, WS_u_long netlong, WS_u_long* lphostlong )
4854 {
4855 TRACE( "(0x%04lx 0x%08x %p)\n", s, netlong, lphostlong );
4856
4857 if (!lphostlong) return WSAEFAULT;
4858
4859 *lphostlong = ntohl( netlong );
4860 return 0;
4861 }
4862
4863 /***********************************************************************
4864 * WSANtohs (WS2_32.65)
4865 */
4866 INT WINAPI WSANtohs( SOCKET s, WS_u_short netshort, WS_u_short* lphostshort )
4867 {
4868 TRACE( "(0x%04lx 0x%08x %p)\n", s, netshort, lphostshort );
4869
4870 if (!lphostshort) return WSAEFAULT;
4871
4872 *lphostshort = ntohs( netshort );
4873 return 0;
4874 }
4875
4876 /***********************************************************************
4877 * WSAProviderConfigChange (WS2_32.66)
4878 */
4879 INT WINAPI WSAProviderConfigChange( LPHANDLE handle, LPWSAOVERLAPPED overlapped,
4880 LPWSAOVERLAPPED_COMPLETION_ROUTINE completion )
4881 {
4882 FIXME( "(%p %p %p) Stub!\n", handle, overlapped, completion );
4883 return SOCKET_ERROR;
4884 }
4885
4886 /***********************************************************************
4887 * WSARecvDisconnect (WS2_32.68)
4888 */
4889 INT WINAPI WSARecvDisconnect( SOCKET s, LPWSABUF disconnectdata )
4890 {
4891 TRACE( "(0x%04lx %p)\n", s, disconnectdata );
4892
4893 return WS_shutdown( s, 0 );
4894 }
4895
4896 /***********************************************************************
4897 * WSASetServiceA (WS2_32.76)
4898 */
4899 INT WINAPI WSASetServiceA( LPWSAQUERYSETA query, WSAESETSERVICEOP operation, DWORD flags )
4900 {
4901 FIXME( "(%p 0x%08x 0x%08x) Stub!\n", query, operation, flags );
4902 return 0;
4903 }
4904
4905 /***********************************************************************
4906 * WSASetServiceW (WS2_32.77)
4907 */
4908 INT WINAPI WSASetServiceW( LPWSAQUERYSETW query, WSAESETSERVICEOP operation, DWORD flags )
4909 {
4910 FIXME( "(%p 0x%08x 0x%08x) Stub!\n", query, operation, flags );
4911 return 0;
4912 }
4913
4914 /***********************************************************************
4915 * WSCEnableNSProvider (WS2_32.84)
4916 */
4917 INT WINAPI WSCEnableNSProvider( LPGUID provider, BOOL enable )
4918 {
4919 FIXME( "(%s 0x%08x) Stub!\n", debugstr_guid(provider), enable );
4920 return 0;
4921 }
4922
4923 /***********************************************************************
4924 * WSCGetProviderPath (WS2_32.86)
4925 */
4926 INT WINAPI WSCGetProviderPath( LPGUID provider, LPWSTR path, LPINT len, LPINT errcode )
4927 {
4928 FIXME( "(%s %p %p %p) Stub!\n", debugstr_guid(provider), path, len, errcode );
4929
4930 if (!errcode || !provider || !len) return WSAEFAULT;
4931
4932 *errcode = WSAEINVAL;
4933 return SOCKET_ERROR;
4934 }
4935
4936 /***********************************************************************
4937 * WSCInstallNameSpace (WS2_32.87)
4938 */
4939 INT WINAPI WSCInstallNameSpace( LPWSTR identifier, LPWSTR path, DWORD namespace,
4940 DWORD version, LPGUID provider )
4941 {
4942 FIXME( "(%s %s 0x%08x 0x%08x %s) Stub!\n", debugstr_w(identifier), debugstr_w(path),
4943 namespace, version, debugstr_guid(provider) );
4944 return 0;
4945 }
4946
4947 /***********************************************************************
4948 * WSCUnInstallNameSpace (WS2_32.89)
4949 */
4950 INT WINAPI WSCUnInstallNameSpace( LPGUID lpProviderId )
4951 {
4952 FIXME("(%p) Stub!\n", lpProviderId);
4953 return NO_ERROR;
4954 }
4955
4956 /***********************************************************************
4957 * WSCWriteProviderOrder (WS2_32.91)
4958 */
4959 INT WINAPI WSCWriteProviderOrder( LPDWORD entry, DWORD number )
4960 {
4961 FIXME("(%p 0x%08x) Stub!\n", entry, number);
4962 return 0;
4963 }
useful hacks and other patches not (yet) suitable for mainline