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