git.oblomov.eu Git - wine/blob - dlls/winsock/socket.c

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