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  * (C) 1993,1994,1996,1997 John Brezak, Erik Bos, Alex Korobka.
   6  *
   7  * NOTE: If you make any changes to fix a particular app, make sure
   8  * they don't break something else like Netscape or telnet and ftp
   9  * clients and servers (www.winsite.com got a lot of those).
  10  *
  11  */
  12
  13 #include "config.h"
  14
  15 #include <string.h>
  16 #include <sys/types.h>
  17 #ifdef HAVE_SYS_IPC_H
  18 # include <sys/ipc.h>
  19 #endif
  20 #include <sys/ioctl.h>
  21 #ifdef HAVE_SYS_FILIO_H
  22 # include <sys/filio.h>
  23 #endif
  24 #ifdef HAVE_SYS_SOCKIO_H
  25 # include <sys/sockio.h>
  26 #endif
  27
  28 #if defined(__EMX__)
  29 # include <sys/so_ioctl.h>
  30 #endif
  31
  32 #ifdef HAVE_SYS_PARAM_H
  33 # include <sys/param.h>
  34 #endif
  35
  36 #ifdef HAVE_SYS_MSG_H
  37 # include <sys/msg.h>
  38 #endif
  39 #ifdef HAVE_SYS_WAIT_H
  40 # include <sys/wait.h>
  41 #endif
  42 #ifdef HAVE_SYS_SOCKET_H
  43 #include <sys/socket.h>
  44 #endif
  45 #ifdef HAVE_NETINET_IN_H
  46 # include <netinet/in.h>
  47 #endif
  48 #ifdef HAVE_NETINET_TCP_H
  49 # include <netinet/tcp.h>
  50 #endif
  51 #ifdef HAVE_ARPA_INET_H
  52 # include <arpa/inet.h>
  53 #endif
  54 #include <ctype.h>
  55 #include <fcntl.h>
  56 #include <errno.h>
  57 #ifdef HAVE_SYS_ERRNO_H
  58 #include <sys/errno.h>
  59 #endif
  60 #include <netdb.h>
  61 #include <unistd.h>
  62 #include <stdlib.h>
  63 #ifdef HAVE_ARPA_NAMESER_H
  64 # include <arpa/nameser.h>
  65 #endif
  66 #ifdef HAVE_RESOLV_H
  67 # include <resolv.h>
  68 #endif
  69 #ifdef HAVE_NET_IF_H
  70 # include <net/if.h>
  71 #endif
  72
  73 #include "wine/winbase16.h"
  74 #include "wingdi.h"
  75 #include "winuser.h"
  76 #include "winsock2.h"
  77 #include "winnt.h"
  78 #include "heap.h"
  79 #include "task.h"
  80 #include "message.h"
  81 #include "miscemu.h"
  82 #include "wine/port.h"
  83 #include "services.h"
  84 #include "server.h"
  85 #include "debugtools.h"
  86
  87
  88 DEFAULT_DEBUG_CHANNEL(winsock)
  89
  90 #define DEBUG_SOCKADDR 0
  91 #define dump_sockaddr(a) \
  92         DPRINTF("sockaddr_in: family %d, address %s, port %d\n", \
  93                         ((struct sockaddr_in *)a)->sin_family, \
  94                         inet_ntoa(((struct sockaddr_in *)a)->sin_addr), \
  95                         ntohs(((struct sockaddr_in *)a)->sin_port))
  96
  97 /* ----------------------------------- internal data */
  98
  99 /* ws_... struct conversion flags */
 100
 101 #define WS_DUP_LINEAR           0x0001
 102 #define WS_DUP_NATIVE           0x0000          /* not used anymore */
 103 #define WS_DUP_OFFSET           0x0002          /* internal pointers are offsets */
 104 #define WS_DUP_SEGPTR           0x0004          /* internal pointers are SEGPTRs */
 105                                                 /* by default, internal pointers are linear */
 106 typedef struct          /* WSAAsyncSelect() control struct */
 107 {
 108   HANDLE      service, event, sock;
 109   HWND        hWnd;
 110   UINT        uMsg;
 111   LONG        lEvent;
 112   struct _WSINFO *pwsi;
 113 } ws_select_info;
 114
 115 #define WS_MAX_SOCKETS_PER_PROCESS      128     /* reasonable guess */
 116 #define WS_MAX_UDP_DATAGRAM             1024
 117
 118 #define WS_ACCEPT_QUEUE 6
 119
 120 #define WSI_BLOCKINGCALL        0x00000001      /* per-thread info flags */
 121 #define WSI_BLOCKINGHOOK        0x00000002      /* 32-bit callback */
 122
 123 #define PROCFS_NETDEV_FILE   "/proc/net/dev" /* Points to the file in the /proc fs
 124                                                 that lists the network devices.
 125                                                 Do we need an #ifdef LINUX for this? */
 126
 127 typedef struct _WSINFO
 128 {
 129   DWORD                 dwThisProcess;
 130   struct _WSINFO       *lpNextIData;
 131
 132   unsigned              flags;
 133   INT16                 num_startup;            /* reference counter */
 134   INT16                 num_async_rq;
 135   INT16                 last_free;              /* entry in the socket table */
 136   UINT16                buflen;
 137   char*                 buffer;                 /* allocated from SEGPTR heap */
 138   struct ws_hostent     *he;
 139   int                   helen;
 140   struct ws_servent     *se;
 141   int                   selen;
 142   struct ws_protoent    *pe;
 143   int                   pelen;
 144   char*                 dbuffer;                /* buffer for dummies (32 bytes) */
 145
 146   DWORD                 blocking_hook;
 147
 148   volatile HANDLE       accept_old[WS_ACCEPT_QUEUE], accept_new[WS_ACCEPT_QUEUE];
 149 } WSINFO, *LPWSINFO;
 150
 151 /* function prototypes */
 152 int WS_dup_he(LPWSINFO pwsi, struct hostent* p_he, int flag);
 153 int WS_dup_pe(LPWSINFO pwsi, struct protoent* p_pe, int flag);
 154 int WS_dup_se(LPWSINFO pwsi, struct servent* p_se, int flag);
 155
 156 int WSAIOCTL_GetInterfaceCount(void);
 157 int WSAIOCTL_GetInterfaceName(int intNumber, char *intName);
 158
 159 UINT16 wsaErrno(void);
 160 UINT16 wsaHerrno(void);
 161
 162 static HANDLE   _WSHeap = 0;
 163
 164 #define WS_ALLOC(size) \
 165         HeapAlloc(_WSHeap, HEAP_ZERO_MEMORY, (size) )
 166 #define WS_FREE(ptr) \
 167         HeapFree(_WSHeap, 0, (ptr) )
 168
 169 static INT         _ws_sock_ops[] =
 170        { WS_SO_DEBUG, WS_SO_REUSEADDR, WS_SO_KEEPALIVE, WS_SO_DONTROUTE,
 171          WS_SO_BROADCAST, WS_SO_LINGER, WS_SO_OOBINLINE, WS_SO_SNDBUF,
 172          WS_SO_RCVBUF, WS_SO_ERROR, WS_SO_TYPE, WS_SO_DONTLINGER,
 173 #ifdef SO_RCVTIMEO
 174          WS_SO_RCVTIMEO,
 175 #endif
 176          0 };
 177 static int           _px_sock_ops[] =
 178        { SO_DEBUG, SO_REUSEADDR, SO_KEEPALIVE, SO_DONTROUTE, SO_BROADCAST,
 179          SO_LINGER, SO_OOBINLINE, SO_SNDBUF, SO_RCVBUF, SO_ERROR, SO_TYPE,
 180          WS_SO_DONTLINGER,  /* no unix equivalent */
 181 #ifdef SO_RCVTIMEO
 182          SO_RCVTIMEO,
 183 #endif
 184         };
 185
 186 static INT _ws_tcp_ops[] = {
 187 #ifdef TCP_NODELAY
 188         WS_TCP_NODELAY,
 189 #endif
 190         0
 191 };
 192 static int _px_tcp_ops[] = {
 193 #ifdef TCP_NODELAY
 194         TCP_NODELAY,
 195 #endif
 196         0
 197 };
 198
 199 /* we need a special routine to handle WSA* errors */
 200 static inline int sock_server_call( enum request req )
 201 {
 202     unsigned int res = server_call_noerr( req );
 203     if (res)
 204     {
 205         /* do not map WSA errors */
 206         if ((res < WSABASEERR) || (res >= 0x10000000)) res = RtlNtStatusToDosError(res);
 207         SetLastError( res );
 208     }
 209     return res;
 210 }
 211
 212 static int   _check_ws(LPWSINFO pwsi, SOCKET s);
 213 static char* _check_buffer(LPWSINFO pwsi, int size);
 214
 215 static int _get_sock_fd(SOCKET s)
 216 {
 217     struct get_read_fd_request *req = get_req_buffer();
 218     int fd;
 219
 220     req->handle = s;
 221     server_call_fd( REQ_GET_READ_FD, -1, &fd );
 222     if (fd == -1)
 223         FIXME("handle %d is not a socket (GLE %ld)\n",s,GetLastError());
 224     return fd;
 225 }
 226
 227 static void _enable_event(SOCKET s, unsigned int event,
 228                           unsigned int sstate, unsigned int cstate)
 229 {
 230     struct enable_socket_event_request *req = get_req_buffer();
 231
 232     req->handle = s;
 233     req->mask   = event;
 234     req->sstate = sstate;
 235     req->cstate = cstate;
 236     sock_server_call( REQ_ENABLE_SOCKET_EVENT );
 237 }
 238
 239 static int _is_blocking(SOCKET s)
 240 {
 241     struct get_socket_event_request *req = get_req_buffer();
 242
 243     req->handle  = s;
 244     req->service = FALSE;
 245     req->s_event = 0;
 246     req->c_event = 0;
 247     sock_server_call( REQ_GET_SOCKET_EVENT );
 248     return (req->state & WS_FD_NONBLOCKING) == 0;
 249 }
 250
 251 static unsigned int _get_sock_mask(SOCKET s)
 252 {
 253     struct get_socket_event_request *req = get_req_buffer();
 254
 255     req->handle  = s;
 256     req->service = FALSE;
 257     req->s_event = 0;
 258     req->c_event = 0;
 259     sock_server_call( REQ_GET_SOCKET_EVENT );
 260     return req->mask;
 261 }
 262
 263 static void _sync_sock_state(SOCKET s)
 264 {
 265     /* do a dummy wineserver request in order to let
 266        the wineserver run through its select loop once */
 267     (void)_is_blocking(s);
 268 }
 269
 270 static int _get_sock_error(SOCKET s, unsigned int bit)
 271 {
 272     struct get_socket_event_request *req = get_req_buffer();
 273
 274     req->handle  = s;
 275     req->service = FALSE;
 276     req->s_event = 0;
 277     req->c_event = 0;
 278     sock_server_call( REQ_GET_SOCKET_EVENT );
 279     return req->errors[bit];
 280 }
 281
 282 static LPWSINFO lpFirstIData = NULL;
 283
 284 static LPWSINFO WINSOCK_GetIData(void)
 285 {
 286     DWORD pid = GetCurrentProcessId();
 287     LPWSINFO iData;
 288
 289     for (iData = lpFirstIData; iData; iData = iData->lpNextIData) {
 290         if (iData->dwThisProcess == pid)
 291             break;
 292     }
 293     return iData;
 294 }
 295
 296 static BOOL WINSOCK_CreateIData(void)
 297 {
 298     LPWSINFO iData;
 299
 300     iData = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WSINFO));
 301     if (!iData)
 302         return FALSE;
 303     iData->dwThisProcess = GetCurrentProcessId();
 304     iData->lpNextIData = lpFirstIData;
 305     lpFirstIData = iData;
 306     return TRUE;
 307 }
 308
 309 static void WINSOCK_DeleteIData(void)
 310 {
 311     LPWSINFO iData = WINSOCK_GetIData();
 312     LPWSINFO* ppid;
 313     if (iData) {
 314         for (ppid = &lpFirstIData; *ppid; ppid = &(*ppid)->lpNextIData) {
 315             if (*ppid == iData) {
 316                 *ppid = iData->lpNextIData;
 317                 break;
 318             }
 319         }
 320
 321         if( iData->flags & WSI_BLOCKINGCALL )
 322             TRACE("\tinside blocking call!\n");
 323
 324         /* delete scratch buffers */
 325
 326         if( iData->buffer ) SEGPTR_FREE(iData->buffer);
 327         if( iData->dbuffer ) SEGPTR_FREE(iData->dbuffer);
 328
 329         HeapFree(GetProcessHeap(), 0, iData);
 330     }
 331 }
 332
 333 /***********************************************************************
 334  *              WSOCK32_LibMain (WSOCK32.init)
 335  */
 336 BOOL WINAPI WSOCK32_LibMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID fImpLoad)
 337 {
 338     TRACE("0x%x 0x%lx %p\n", hInstDLL, fdwReason, fImpLoad);
 339     switch (fdwReason) {
 340     case DLL_PROCESS_DETACH:
 341         WINSOCK_DeleteIData();
 342         break;
 343     }
 344     return TRUE;
 345 }
 346
 347 /***********************************************************************
 348  *              WINSOCK_LibMain (WINSOCK.init)
 349  */
 350 BOOL WINAPI WINSOCK_LibMain(DWORD fdwReason, HINSTANCE hInstDLL, WORD ds,
 351                             WORD wHeapSize, DWORD dwReserved1, WORD wReserved2)
 352 {
 353     TRACE("0x%x 0x%lx\n", hInstDLL, fdwReason);
 354     switch (fdwReason) {
 355     case DLL_PROCESS_DETACH:
 356         WINSOCK_DeleteIData();
 357         break;
 358     }
 359     return TRUE;
 360 }
 361
 362 /***********************************************************************
 363  *          convert_sockopt()
 364  *
 365  * Converts socket flags from Windows format.
 366  */
 367 static void convert_sockopt(INT *level, INT *optname)
 368 {
 369   int i;
 370   switch (*level)
 371   {
 372      case WS_SOL_SOCKET:
 373         *level = SOL_SOCKET;
 374         for(i=0; _ws_sock_ops[i]; i++)
 375             if( _ws_sock_ops[i] == *optname ) break;
 376         if( _ws_sock_ops[i] ) *optname = _px_sock_ops[i];
 377         else FIXME("Unknown SOL_SOCKET optname %d\n", *optname);
 378         break;
 379      case WS_IPPROTO_TCP:
 380         *level = IPPROTO_TCP;
 381         for(i=0; _ws_tcp_ops[i]; i++)
 382                 if ( _ws_tcp_ops[i] == *optname ) break;
 383         if( _ws_tcp_ops[i] ) *optname = _px_tcp_ops[i];
 384         else FIXME("Unknown IPPROTO_TCP optname %d\n", *optname);
 385         break;
 386   }
 387 }
 388
 389 /* ----------------------------------- Per-thread info (or per-process?) */
 390
 391 static int wsi_strtolo(LPWSINFO pwsi, const char* name, const char* opt)
 392 {
 393     /* Stuff a lowercase copy of the string into the local buffer */
 394
 395     int i = strlen(name) + 2;
 396     char* p = _check_buffer(pwsi, i + ((opt)?strlen(opt):0));
 397
 398     if( p )
 399     {
 400         do *p++ = tolower(*name); while(*name++);
 401         i = (p - (char*)(pwsi->buffer));
 402         if( opt ) do *p++ = tolower(*opt); while(*opt++);
 403         return i;
 404     }
 405     return 0;
 406 }
 407
 408 static fd_set* fd_set_import( fd_set* fds, LPWSINFO pwsi, void* wsfds, int* highfd, int lfd[], BOOL b32 )
 409 {
 410     /* translate Winsock fd set into local fd set */
 411
 412     if( wsfds )
 413     {
 414 #define wsfds16 ((ws_fd_set16*)wsfds)
 415 #define wsfds32 ((ws_fd_set32*)wsfds)
 416         int i, count;
 417
 418         FD_ZERO(fds);
 419         count = b32 ? wsfds32->fd_count : wsfds16->fd_count;
 420
 421         for( i = 0; i < count; i++ )
 422         {
 423              int s = (b32) ? wsfds32->fd_array[i]
 424                            : wsfds16->fd_array[i];
 425              if( _check_ws(pwsi, s) )
 426              {
 427                     int fd = _get_sock_fd(s);
 428                     lfd[ i ] = fd;
 429                     if( fd > *highfd ) *highfd = fd;
 430                     FD_SET(fd, fds);
 431              }
 432              else lfd[ i ] = -1;
 433         }
 434 #undef wsfds32
 435 #undef wsfds16
 436         return fds;
 437     }
 438     return NULL;
 439 }
 440
 441 inline static int sock_error_p(int s)
 442 {
 443     unsigned int optval, optlen;
 444
 445     optlen = sizeof(optval);
 446     getsockopt(s, SOL_SOCKET, SO_ERROR, (void *) &optval, &optlen);
 447     if (optval) WARN("\t[%i] error: %d\n", s, optval);
 448     return optval != 0;
 449 }
 450
 451 static int fd_set_export( LPWSINFO pwsi, fd_set* fds, fd_set* exceptfds, void* wsfds, int lfd[], BOOL b32 )
 452 {
 453     int num_err = 0;
 454
 455     /* translate local fd set into Winsock fd set, adding
 456      * errors to exceptfds (only if app requested it) */
 457
 458     if( wsfds )
 459     {
 460 #define wsfds16 ((ws_fd_set16*)wsfds)
 461 #define wsfds32 ((ws_fd_set32*)wsfds)
 462         int i, j, count = (b32) ? wsfds32->fd_count : wsfds16->fd_count;
 463
 464         for( i = 0, j = 0; i < count; i++ )
 465         {
 466             if( lfd[i] >= 0 )
 467             {
 468                 int fd = lfd[i];
 469                 if( FD_ISSET(fd, fds) )
 470                 {
 471                     if ( exceptfds && sock_error_p(fd) )
 472                     {
 473                         FD_SET(fd, exceptfds);
 474                         num_err++;
 475                     }
 476                     else if( b32 )
 477                              wsfds32->fd_array[j++] = wsfds32->fd_array[i];
 478                          else
 479                              wsfds16->fd_array[j++] = wsfds16->fd_array[i];
 480                 }
 481                 close(fd);
 482                 lfd[i] = -1;
 483             }
 484         }
 485
 486         if( b32 ) wsfds32->fd_count = j;
 487         else wsfds16->fd_count = j;
 488
 489         TRACE("\n");
 490 #undef wsfds32
 491 #undef wsfds16
 492     }
 493     return num_err;
 494 }
 495
 496 static void fd_set_unimport( void* wsfds, int lfd[], BOOL b32 )
 497 {
 498     if ( wsfds )
 499     {
 500 #define wsfds16 ((ws_fd_set16*)wsfds)
 501 #define wsfds32 ((ws_fd_set32*)wsfds)
 502         int i, count = (b32) ? wsfds32->fd_count : wsfds16->fd_count;
 503
 504         for( i = 0; i < count; i++ )
 505             if ( lfd[i] >= 0 )
 506                 close(lfd[i]);
 507
 508         TRACE("\n");
 509 #undef wsfds32
 510 #undef wsfds16
 511     }
 512 }
 513
 514 static int do_block( int fd, int mask )
 515 {
 516     fd_set fds[3];
 517     int i, r;
 518
 519     FD_ZERO(&fds[0]);
 520     FD_ZERO(&fds[1]);
 521     FD_ZERO(&fds[2]);
 522     for (i=0; i<3; i++)
 523         if (mask & (1<<i))
 524             FD_SET(fd, &fds[i]);
 525     i = select( fd+1, &fds[0], &fds[1], &fds[2], NULL );
 526     if (i <= 0) return -1;
 527     r = 0;
 528     for (i=0; i<3; i++)
 529         if (FD_ISSET(fd, &fds[i]))
 530             r |= 1<<i;
 531     return r;
 532 }
 533
 534 void* __ws_memalloc( int size )
 535 {
 536     return WS_ALLOC(size);
 537 }
 538
 539 void __ws_memfree(void* ptr)
 540 {
 541     WS_FREE(ptr);
 542 }
 543
 544
 545 /* ----------------------------------- API -----
 546  *
 547  * Init / cleanup / error checking.
 548  */
 549
 550 /***********************************************************************
 551  *      WSAStartup16()                  (WINSOCK.115)
 552  *
 553  * Create socket control struct, attach it to the global list and
 554  * update a pointer in the task struct.
 555  */
 556 INT16 WINAPI WSAStartup16(UINT16 wVersionRequested, LPWSADATA lpWSAData)
 557 {
 558     WSADATA WINSOCK_data = { 0x0101, 0x0101,
 559                           "WINE Sockets 1.1",
 560                         #ifdef linux
 561                                 "Linux/i386",
 562                         #elif defined(__NetBSD__)
 563                                 "NetBSD/i386",
 564                         #elif defined(sunos)
 565                                 "SunOS",
 566                         #elif defined(__FreeBSD__)
 567                                 "FreeBSD",
 568                         #elif defined(__OpenBSD__)
 569                                 "OpenBSD/i386",
 570                         #else
 571                                 "Unknown",
 572                         #endif
 573                            WS_MAX_SOCKETS_PER_PROCESS,
 574                            WS_MAX_UDP_DATAGRAM, (SEGPTR)NULL };
 575     LPWSINFO            pwsi;
 576
 577     TRACE("verReq=%x\n", wVersionRequested);
 578
 579     if (LOBYTE(wVersionRequested) < 1 || (LOBYTE(wVersionRequested) == 1 &&
 580         HIBYTE(wVersionRequested) < 1)) return WSAVERNOTSUPPORTED;
 581
 582     if (!lpWSAData) return WSAEINVAL;
 583
 584     /* initialize socket heap */
 585
 586     if( !_WSHeap )
 587     {
 588         _WSHeap = HeapCreate(HEAP_ZERO_MEMORY, 8120, 32768);
 589         if( !_WSHeap )
 590         {
 591             ERR("Fatal: failed to create WinSock heap\n");
 592             return 0;
 593         }
 594     }
 595     if( _WSHeap == 0 ) return WSASYSNOTREADY;
 596
 597     pwsi = WINSOCK_GetIData();
 598     if( pwsi == NULL )
 599     {
 600         WINSOCK_CreateIData();
 601         pwsi = WINSOCK_GetIData();
 602         if (!pwsi) return WSASYSNOTREADY;
 603     }
 604     pwsi->num_startup++;
 605
 606     /* return winsock information */
 607
 608     memcpy(lpWSAData, &WINSOCK_data, sizeof(WINSOCK_data));
 609
 610     TRACE("succeeded\n");
 611     return 0;
 612 }
 613
 614 /***********************************************************************
 615  *      WSAStartup()            (WS2_32.115)
 616  */
 617 INT WINAPI WSAStartup(UINT wVersionRequested, LPWSADATA lpWSAData)
 618 {
 619     WSADATA WINSOCK_data = { 0x0202, 0x0202,
 620                           "WINE Sockets 2.0",
 621                         #ifdef linux
 622                                 "Linux/i386",
 623                         #elif defined(__NetBSD__)
 624                                 "NetBSD/i386",
 625                         #elif defined(sunos)
 626                                 "SunOS",
 627                         #elif defined(__FreeBSD__)
 628                                 "FreeBSD",
 629                         #elif defined(__OpenBSD__)
 630                                 "OpenBSD/i386",
 631                         #else
 632                                 "Unknown",
 633                         #endif
 634                            WS_MAX_SOCKETS_PER_PROCESS,
 635                            WS_MAX_UDP_DATAGRAM, (SEGPTR)NULL };
 636     LPWSINFO            pwsi;
 637
 638     TRACE("verReq=%x\n", wVersionRequested);
 639
 640     if (LOBYTE(wVersionRequested) < 1)
 641         return WSAVERNOTSUPPORTED;
 642
 643     if (!lpWSAData) return WSAEINVAL;
 644
 645     /* initialize socket heap */
 646
 647     if( !_WSHeap )
 648     {
 649         _WSHeap = HeapCreate(HEAP_ZERO_MEMORY, 8120, 32768);
 650         if( !_WSHeap )
 651         {
 652             ERR("Fatal: failed to create WinSock heap\n");
 653             return 0;
 654         }
 655     }
 656     if( _WSHeap == 0 ) return WSASYSNOTREADY;
 657
 658     pwsi = WINSOCK_GetIData();
 659     if( pwsi == NULL )
 660     {
 661         WINSOCK_CreateIData();
 662         pwsi = WINSOCK_GetIData();
 663         if (!pwsi) return WSASYSNOTREADY;
 664     }
 665     pwsi->num_startup++;
 666
 667     /* return winsock information */
 668     memcpy(lpWSAData, &WINSOCK_data, sizeof(WINSOCK_data));
 669
 670     /* that's the whole of the negotiation for now */
 671     lpWSAData->wVersion = wVersionRequested;
 672
 673     TRACE("succeeded\n");
 674     return 0;
 675 }
 676
 677
 678 /***********************************************************************
 679  *      WSACleanup()                    (WINSOCK.116)
 680  */
 681 INT WINAPI WSACleanup(void)
 682 {
 683     LPWSINFO pwsi = WINSOCK_GetIData();
 684     if( pwsi ) {
 685         if( --pwsi->num_startup > 0 ) return 0;
 686
 687         WINSOCK_DeleteIData();
 688         return 0;
 689     }
 690     SetLastError(WSANOTINITIALISED);
 691     return SOCKET_ERROR;
 692 }
 693
 694
 695 /***********************************************************************
 696  *      WSAGetLastError()               (WSOCK32.111)(WINSOCK.111)
 697  */
 698 INT WINAPI WSAGetLastError(void)
 699 {
 700         return GetLastError();
 701 }
 702
 703 /***********************************************************************
 704  *      WSASetLastError()               (WSOCK32.112)
 705  */
 706 void WINAPI WSASetLastError(INT iError) {
 707     SetLastError(iError);
 708 }
 709
 710 /***********************************************************************
 711  *      WSASetLastError16()             (WINSOCK.112)
 712  */
 713 void WINAPI WSASetLastError16(INT16 iError)
 714 {
 715     WSASetLastError(iError);
 716 }
 717
 718 int _check_ws(LPWSINFO pwsi, SOCKET s)
 719 {
 720     if( pwsi )
 721     {
 722         int fd;
 723         if( pwsi->flags & WSI_BLOCKINGCALL ) SetLastError(WSAEINPROGRESS);
 724         if ( (fd = _get_sock_fd(s)) < 0 ) {
 725             SetLastError(WSAENOTSOCK);
 726             return 0;
 727         }
 728         /* FIXME: maybe check whether fd is really a socket? */
 729         close( fd );
 730         return 1;
 731     }
 732     return 0;
 733 }
 734
 735 char* _check_buffer(LPWSINFO pwsi, int size)
 736 {
 737     if( pwsi->buffer && pwsi->buflen >= size ) return pwsi->buffer;
 738     else SEGPTR_FREE(pwsi->buffer);
 739
 740     pwsi->buffer = (char*)SEGPTR_ALLOC((pwsi->buflen = size));
 741     return pwsi->buffer;
 742 }
 743
 744 struct ws_hostent* _check_buffer_he(LPWSINFO pwsi, int size)
 745 {
 746     if( pwsi->he && pwsi->helen >= size ) return pwsi->he;
 747     else SEGPTR_FREE(pwsi->he);
 748
 749     pwsi->he = (struct ws_hostent*)SEGPTR_ALLOC((pwsi->helen = size));
 750     return pwsi->he;
 751 }
 752
 753 struct ws_servent* _check_buffer_se(LPWSINFO pwsi, int size)
 754 {
 755     if( pwsi->se && pwsi->selen >= size ) return pwsi->se;
 756     else SEGPTR_FREE(pwsi->se);
 757
 758     pwsi->se = (struct ws_servent*)SEGPTR_ALLOC((pwsi->selen = size));
 759     return pwsi->se;
 760 }
 761
 762 struct ws_protoent* _check_buffer_pe(LPWSINFO pwsi, int size)
 763 {
 764     if( pwsi->pe && pwsi->pelen >= size ) return pwsi->pe;
 765     else SEGPTR_FREE(pwsi->pe);
 766
 767     pwsi->pe = (struct ws_protoent*)SEGPTR_ALLOC((pwsi->pelen = size));
 768     return pwsi->pe;
 769 }
 770
 771 /* ----------------------------------- i/o APIs */
 772
 773 /***********************************************************************
 774  *              accept()                (WSOCK32.1)
 775  */
 776 static void WSOCK32_async_accept(LPWSINFO pwsi, SOCKET s, SOCKET as)
 777 {
 778     int q;
 779     /* queue socket for WSAAsyncSelect */
 780     for (q=0; q<WS_ACCEPT_QUEUE; q++)
 781         if (InterlockedCompareExchange((PVOID*)&pwsi->accept_old[q], (PVOID)s, (PVOID)0) == (PVOID)0)
 782             break;
 783     if (q<WS_ACCEPT_QUEUE)
 784         pwsi->accept_new[q] = as;
 785     else
 786         ERR("accept queue too small\n");
 787     /* now signal our AsyncSelect handler */
 788     _enable_event(s, WS_FD_SERVEVENT, 0, 0);
 789 }
 790
 791 SOCKET WINAPI WSOCK32_accept(SOCKET s, struct sockaddr *addr,
 792                                  INT *addrlen32)
 793 {
 794     LPWSINFO                 pwsi = WINSOCK_GetIData();
 795 #ifdef HAVE_IPX
 796     struct ws_sockaddr_ipx*  addr2 = (struct ws_sockaddr_ipx *)addr;
 797 #endif
 798     struct accept_socket_request *req = get_req_buffer();
 799
 800     TRACE("(%08x): socket %04x\n",
 801                                   (unsigned)pwsi, (UINT16)s );
 802     if( _check_ws(pwsi, s) )
 803     {
 804         if (_is_blocking(s))
 805         {
 806             /* block here */
 807             int fd = _get_sock_fd(s);
 808             do_block(fd, 5);
 809             close(fd);
 810             _sync_sock_state(s); /* let wineserver notice connection */
 811             /* retrieve any error codes from it */
 812             SetLastError(_get_sock_error(s, FD_ACCEPT_BIT));
 813             /* FIXME: care about the error? */
 814         }
 815         req->lhandle = s;
 816         req->access  = GENERIC_READ|GENERIC_WRITE|SYNCHRONIZE;
 817         req->inherit = TRUE;
 818         sock_server_call( REQ_ACCEPT_SOCKET );
 819         if( req->handle >= 0 )
 820         {
 821             SOCKET as = req->handle;
 822             unsigned omask = _get_sock_mask( s );
 823             int fd = _get_sock_fd( as );
 824             if( getpeername(fd, addr, addrlen32) != -1 )
 825             {
 826 #ifdef HAVE_IPX
 827                 if (addr && ((struct sockaddr_ipx *)addr)->sipx_family == AF_IPX) {
 828                     addr = (struct sockaddr *)
 829                                 malloc(addrlen32 ? *addrlen32 : sizeof(*addr2));
 830                     memcpy(addr, addr2,
 831                                 addrlen32 ? *addrlen32 : sizeof(*addr2));
 832                     addr2->sipx_family = WS_AF_IPX;
 833                     addr2->sipx_network = ((struct sockaddr_ipx *)addr)->sipx_network;
 834                     addr2->sipx_port = ((struct sockaddr_ipx *)addr)->sipx_port;
 835                     memcpy(addr2->sipx_node,
 836                         ((struct sockaddr_ipx *)addr)->sipx_node, IPX_NODE_LEN);
 837                     free(addr);
 838                 }
 839 #endif
 840             } else SetLastError(wsaErrno());
 841             close(fd);
 842             if (omask & WS_FD_SERVEVENT)
 843                 WSOCK32_async_accept(pwsi, s, as);
 844             return as;
 845         }
 846     }
 847     return INVALID_SOCKET;
 848 }
 849
 850 /***********************************************************************
 851  *              accept()                (WINSOCK.1)
 852  */
 853 SOCKET16 WINAPI WINSOCK_accept16(SOCKET16 s, struct sockaddr* addr,
 854                                  INT16* addrlen16 )
 855 {
 856     INT addrlen32 = addrlen16 ? *addrlen16 : 0;
 857     SOCKET retSocket = WSOCK32_accept( s, addr, &addrlen32 );
 858     if( addrlen16 ) *addrlen16 = (INT16)addrlen32;
 859     return (SOCKET16)retSocket;
 860 }
 861
 862 /***********************************************************************
 863  *              bind()                  (WSOCK32.2)
 864  */
 865 INT WINAPI WSOCK32_bind(SOCKET s, struct sockaddr *name, INT namelen)
 866 {
 867     LPWSINFO                 pwsi = WINSOCK_GetIData();
 868 #ifdef HAVE_IPX
 869     struct ws_sockaddr_ipx*  name2 = (struct ws_sockaddr_ipx *)name;
 870 #endif
 871
 872     TRACE("(%08x): socket %04x, ptr %8x, length %d\n",
 873                            (unsigned)pwsi, s, (int) name, namelen);
 874 #if DEBUG_SOCKADDR
 875     dump_sockaddr(name);
 876 #endif
 877
 878     if ( _check_ws(pwsi, s) )
 879     {
 880       int fd = _get_sock_fd(s);
 881       /* FIXME: what family does this really map to on the Unix side? */
 882       if (name && ((struct ws_sockaddr_ipx *)name)->sipx_family == WS_AF_PUP)
 883         ((struct ws_sockaddr_ipx *)name)->sipx_family = AF_UNSPEC;
 884 #ifdef HAVE_IPX
 885       else if (name &&
 886                 ((struct ws_sockaddr_ipx *)name)->sipx_family == WS_AF_IPX)
 887       {
 888         name = (struct sockaddr *) malloc(sizeof(struct sockaddr_ipx));
 889         memset(name, '\0', sizeof(struct sockaddr_ipx));
 890         ((struct sockaddr_ipx *)name)->sipx_family = AF_IPX;
 891         ((struct sockaddr_ipx *)name)->sipx_port = name2->sipx_port;
 892         ((struct sockaddr_ipx *)name)->sipx_network = name2->sipx_network;
 893         memcpy(((struct sockaddr_ipx *)name)->sipx_node,
 894                 name2->sipx_node, IPX_NODE_LEN);
 895         namelen = sizeof(struct sockaddr_ipx);
 896       }
 897 #endif
 898       if ( namelen >= sizeof(*name) )
 899       {
 900         if ( name && (((struct ws_sockaddr_in *)name)->sin_family == AF_INET
 901 #ifdef HAVE_IPX
 902              || ((struct sockaddr_ipx *)name)->sipx_family == AF_IPX
 903 #endif
 904            ))
 905         {
 906           if ( bind(fd, name, namelen) < 0 )
 907           {
 908              int        loc_errno = errno;
 909              WARN("\tfailure - errno = %i\n", errno);
 910              errno = loc_errno;
 911              switch(errno)
 912              {
 913                 case EBADF: SetLastError(WSAENOTSOCK); break;
 914                 case EADDRNOTAVAIL: SetLastError(WSAEINVAL); break;
 915                 default: SetLastError(wsaErrno());break;
 916              }
 917           }
 918           else {
 919 #ifdef HAVE_IPX
 920             if (((struct sockaddr_ipx *)name)->sipx_family == AF_IPX)
 921                 free(name);
 922 #endif
 923             close(fd);
 924             return 0; /* success */
 925           }
 926         } else SetLastError(WSAEAFNOSUPPORT);
 927       } else SetLastError(WSAEFAULT);
 928 #ifdef HAVE_IPX
 929       if (name && ((struct sockaddr_ipx *)name)->sipx_family == AF_IPX)
 930         free(name);
 931 #endif
 932       close(fd);
 933     }
 934     return SOCKET_ERROR;
 935 }
 936
 937 /***********************************************************************
 938  *              bind()                  (WINSOCK.2)
 939  */
 940 INT16 WINAPI WINSOCK_bind16(SOCKET16 s, struct sockaddr *name, INT16 namelen)
 941 {
 942   return (INT16)WSOCK32_bind( s, name, namelen );
 943 }
 944
 945 /***********************************************************************
 946  *              closesocket()           (WSOCK32.3)
 947  */
 948 INT WINAPI WSOCK32_closesocket(SOCKET s)
 949 {
 950     LPWSINFO      pwsi = WINSOCK_GetIData();
 951
 952     TRACE("(%08x): socket %08x\n", (unsigned)pwsi, s);
 953
 954     if( _check_ws(pwsi, s) )
 955     {
 956         if( CloseHandle(s) )
 957             return 0;
 958     }
 959     return SOCKET_ERROR;
 960 }
 961
 962 /***********************************************************************
 963  *              closesocket()           (WINSOCK.3)
 964  */
 965 INT16 WINAPI WINSOCK_closesocket16(SOCKET16 s)
 966 {
 967     return (INT16)WSOCK32_closesocket(s);
 968 }
 969
 970 /***********************************************************************
 971  *              connect()               (WSOCK32.4)
 972  */
 973 INT WINAPI WSOCK32_connect(SOCKET s, struct sockaddr *name, INT namelen)
 974 {
 975   LPWSINFO                 pwsi = WINSOCK_GetIData();
 976 #ifdef HAVE_IPX
 977   struct ws_sockaddr_ipx*  name2 = (struct ws_sockaddr_ipx *)name;
 978 #endif
 979
 980   TRACE("(%08x): socket %04x, ptr %8x, length %d\n",
 981                            (unsigned)pwsi, s, (int) name, namelen);
 982 #if DEBUG_SOCKADDR
 983   dump_sockaddr(name);
 984 #endif
 985
 986   if( _check_ws(pwsi, s) )
 987   {
 988     int fd = _get_sock_fd(s);
 989     if (name && ((struct ws_sockaddr_ipx *)name)->sipx_family == WS_AF_PUP)
 990         ((struct ws_sockaddr_ipx *)name)->sipx_family = AF_UNSPEC;
 991 #ifdef HAVE_IPX
 992     else if (name && ((struct ws_sockaddr_ipx *)name)->sipx_family == WS_AF_IPX)
 993     {
 994         name = (struct sockaddr *) malloc(sizeof(struct sockaddr_ipx));
 995         memset(name, '\0', sizeof(struct sockaddr_ipx));
 996         ((struct sockaddr_ipx *)name)->sipx_family = AF_IPX;
 997         ((struct sockaddr_ipx *)name)->sipx_port = name2->sipx_port;
 998         ((struct sockaddr_ipx *)name)->sipx_network = name2->sipx_network;
 999         memcpy(((struct sockaddr_ipx *)name)->sipx_node,
1000                 name2->sipx_node, IPX_NODE_LEN);
1001         namelen = sizeof(struct sockaddr_ipx);
1002     }
1003 #endif
1004     if (connect(fd, name, namelen) == 0) {
1005         close(fd);
1006         goto connect_success;
1007     }
1008     if (errno == EINPROGRESS)
1009     {
1010         /* tell wineserver that a connection is in progress */
1011         _enable_event(s, FD_CONNECT|FD_READ|FD_WRITE,
1012                       WS_FD_CONNECT|WS_FD_READ|WS_FD_WRITE,
1013                       WS_FD_CONNECTED|WS_FD_LISTENING);
1014         if (_is_blocking(s))
1015         {
1016             int result;
1017             /* block here */
1018             do_block(fd, 6);
1019             _sync_sock_state(s); /* let wineserver notice connection */
1020             /* retrieve any error codes from it */
1021             result = _get_sock_error(s, FD_CONNECT_BIT);
1022             if (result)
1023                 SetLastError(result);
1024             else {
1025                 close(fd);
1026                 goto connect_success;
1027             }
1028         }
1029         else SetLastError(WSAEWOULDBLOCK);
1030         close(fd);
1031     }
1032     else
1033     {
1034         SetLastError(wsaErrno());
1035         close(fd);
1036     }
1037   }
1038 #ifdef HAVE_IPX
1039   if (name && ((struct sockaddr_ipx *)name)->sipx_family == AF_IPX)
1040     free(name);
1041 #endif
1042   return SOCKET_ERROR;
1043 connect_success:
1044 #ifdef HAVE_IPX
1045     if (((struct sockaddr_ipx *)name)->sipx_family == AF_IPX)
1046         free(name);
1047 #endif
1048     _enable_event(s, FD_CONNECT|FD_READ|FD_WRITE,
1049                   WS_FD_CONNECTED|WS_FD_READ|WS_FD_WRITE,
1050                   WS_FD_CONNECT|WS_FD_LISTENING);
1051     return 0;
1052 }
1053
1054 /***********************************************************************
1055  *              connect()               (WINSOCK.4)
1056  */
1057 INT16 WINAPI WINSOCK_connect16(SOCKET16 s, struct sockaddr *name, INT16 namelen)
1058 {
1059   return (INT16)WSOCK32_connect( s, name, namelen );
1060 }
1061
1062 /***********************************************************************
1063  *              getpeername()           (WSOCK32.5)
1064  */
1065 INT WINAPI WSOCK32_getpeername(SOCKET s, struct sockaddr *name,
1066                                    INT *namelen)
1067 {
1068     LPWSINFO                 pwsi = WINSOCK_GetIData();
1069 #ifdef HAVE_IPX
1070     struct ws_sockaddr_ipx*  name2 = (struct ws_sockaddr_ipx *)name;
1071 #endif
1072
1073     TRACE("(%08x): socket: %04x, ptr %8x, ptr %8x\n",
1074                            (unsigned)pwsi, s, (int) name, *namelen);
1075     if( _check_ws(pwsi, s) )
1076     {
1077         int fd = _get_sock_fd(s);
1078         if (getpeername(fd, name, namelen) == 0) {
1079 #ifdef HAVE_IPX
1080             if (((struct ws_sockaddr_ipx *)name)->sipx_family == AF_IPX) {
1081                 name = (struct sockaddr *)
1082                                 malloc(namelen ? *namelen : sizeof(*name2));
1083                 memcpy(name, name2, namelen ? *namelen : sizeof(*name2));
1084                 name2->sipx_family = WS_AF_IPX;
1085                 name2->sipx_network = ((struct sockaddr_ipx *)name)->sipx_network;
1086                 name2->sipx_port = ((struct sockaddr_ipx *)name)->sipx_port;
1087                 memcpy(name2->sipx_node,
1088                         ((struct sockaddr_ipx *)name)->sipx_node, IPX_NODE_LEN);
1089                 free(name);
1090             }
1091 #endif
1092             close(fd);
1093             return 0;
1094         }
1095         SetLastError(wsaErrno());
1096         close(fd);
1097     }
1098     return SOCKET_ERROR;
1099 }
1100
1101 /***********************************************************************
1102  *              getpeername()           (WINSOCK.5)
1103  */
1104 INT16 WINAPI WINSOCK_getpeername16(SOCKET16 s, struct sockaddr *name,
1105                                    INT16 *namelen16)
1106 {
1107     INT namelen32 = *namelen16;
1108     INT retVal = WSOCK32_getpeername( s, name, &namelen32 );
1109
1110 #if DEBUG_SOCKADDR
1111     dump_sockaddr(name);
1112 #endif
1113
1114    *namelen16 = namelen32;
1115     return (INT16)retVal;
1116 }
1117
1118 /***********************************************************************
1119  *              getsockname()           (WSOCK32.6)
1120  */
1121 INT WINAPI WSOCK32_getsockname(SOCKET s, struct sockaddr *name,
1122                                    INT *namelen)
1123 {
1124     LPWSINFO                 pwsi = WINSOCK_GetIData();
1125 #ifdef HAVE_IPX
1126     struct ws_sockaddr_ipx*  name2 = (struct ws_sockaddr_ipx *)name;
1127 #endif
1128
1129     TRACE("(%08x): socket: %04x, ptr %8x, ptr %8x\n",
1130                           (unsigned)pwsi, s, (int) name, (int) *namelen);
1131     if( _check_ws(pwsi, s) )
1132     {
1133         int fd = _get_sock_fd(s);
1134         if (getsockname(fd, name, namelen) == 0) {
1135 #ifdef HAVE_IPX
1136             if (((struct sockaddr_ipx *)name)->sipx_family == AF_IPX) {
1137                 name = (struct sockaddr *)
1138                                 malloc(namelen ? *namelen : sizeof(*name2));
1139                 memcpy(name, name2, namelen ? *namelen : sizeof(*name2));
1140                 name2->sipx_family = WS_AF_IPX;
1141                 name2->sipx_network = ((struct sockaddr_ipx *)name)->sipx_network;
1142                 name2->sipx_port = ((struct sockaddr_ipx *)name)->sipx_port;
1143                 memcpy(name2->sipx_node,
1144                         ((struct sockaddr_ipx *)name)->sipx_node, IPX_NODE_LEN);
1145                 free(name);
1146             }
1147 #endif
1148             close(fd);
1149             return 0;
1150         }
1151         SetLastError(wsaErrno());
1152         close(fd);
1153     }
1154     return SOCKET_ERROR;
1155 }
1156
1157 /***********************************************************************
1158  *              getsockname()           (WINSOCK.6)
1159  */
1160 INT16 WINAPI WINSOCK_getsockname16(SOCKET16 s, struct sockaddr *name,
1161                                    INT16 *namelen16)
1162 {
1163     INT retVal;
1164
1165     if( namelen16 )
1166     {
1167         INT namelen32 = *namelen16;
1168         retVal = WSOCK32_getsockname( s, name, &namelen32 );
1169        *namelen16 = namelen32;
1170
1171 #if DEBUG_SOCKADDR
1172     dump_sockaddr(name);
1173 #endif
1174
1175     }
1176     else retVal = SOCKET_ERROR;
1177     return (INT16)retVal;
1178 }
1179
1180
1181 /***********************************************************************
1182  *              getsockopt()            (WSOCK32.7)
1183  */
1184 INT WINAPI WSOCK32_getsockopt(SOCKET s, INT level,
1185                                   INT optname, char *optval, INT *optlen)
1186 {
1187     LPWSINFO      pwsi = WINSOCK_GetIData();
1188
1189     TRACE("(%08x): socket: %04x, opt %d, ptr %8x, ptr %8x\n",
1190                            (unsigned)pwsi, s, level, (int) optval, (int) *optlen);
1191     if( _check_ws(pwsi, s) )
1192     {
1193         int fd = _get_sock_fd(s);
1194         convert_sockopt(&level, &optname);
1195         if (getsockopt(fd, (int) level, optname, optval, optlen) == 0 )
1196         {
1197             close(fd);
1198             return 0;
1199         }
1200         SetLastError((errno == EBADF) ? WSAENOTSOCK : wsaErrno());
1201         close(fd);
1202     }
1203     return SOCKET_ERROR;
1204 }
1205
1206 /***********************************************************************
1207  *              getsockopt()            (WINSOCK.7)
1208  */
1209 INT16 WINAPI WINSOCK_getsockopt16(SOCKET16 s, INT16 level,
1210                                   INT16 optname, char *optval, INT16 *optlen)
1211 {
1212     INT optlen32;
1213     INT *p = &optlen32;
1214     INT retVal;
1215     if( optlen ) optlen32 = *optlen; else p = NULL;
1216     retVal = WSOCK32_getsockopt( s, (UINT16)level, optname, optval, p );
1217     if( optlen ) *optlen = optlen32;
1218     return (INT16)retVal;
1219 }
1220
1221 /***********************************************************************
1222  *              htonl()                 (WINSOCK.8)(WSOCK32.8)
1223  */
1224 u_long WINAPI WINSOCK_htonl(u_long hostlong)   { return( htonl(hostlong) ); }
1225 /***********************************************************************
1226  *              htons()                 (WINSOCK.9)(WSOCK32.9)
1227  */
1228 u_short WINAPI WINSOCK_htons(u_short hostshort) { return( htons(hostshort) ); }
1229 /***********************************************************************
1230  *              inet_addr()             (WINSOCK.10)(WSOCK32.10)
1231  */
1232 u_long WINAPI WINSOCK_inet_addr(char *cp)      { return( inet_addr(cp) ); }
1233 /***********************************************************************
1234  *              ntohl()                 (WINSOCK.14)(WSOCK32.14)
1235  */
1236 u_long WINAPI WINSOCK_ntohl(u_long netlong)    { return( ntohl(netlong) ); }
1237 /***********************************************************************
1238  *              ntohs()                 (WINSOCK.15)(WSOCK32.15)
1239  */
1240 u_short WINAPI WINSOCK_ntohs(u_short netshort)  { return( ntohs(netshort) ); }
1241
1242 /***********************************************************************
1243  *              inet_ntoa()             (WINSOCK.11)(WSOCK32.11)
1244  */
1245 char* WINAPI WSOCK32_inet_ntoa(struct in_addr in)
1246 {
1247   /* use "buffer for dummies" here because some applications have
1248    * propensity to decode addresses in ws_hostent structure without
1249    * saving them first...
1250    */
1251
1252     LPWSINFO      pwsi = WINSOCK_GetIData();
1253
1254     if( pwsi )
1255     {
1256         char*   s = inet_ntoa(in);
1257         if( s )
1258         {
1259             if( pwsi->dbuffer == NULL ) {
1260                 /* Yes, 16: 4*3 digits + 3 '.' + 1 '\0' */
1261                 if((pwsi->dbuffer = (char*) SEGPTR_ALLOC(16)) == NULL )
1262                 {
1263                     SetLastError(WSAENOBUFS);
1264                     return NULL;
1265                 }
1266             }
1267             strcpy(pwsi->dbuffer, s);
1268             return pwsi->dbuffer;
1269         }
1270         SetLastError(wsaErrno());
1271     }
1272     return NULL;
1273 }
1274
1275 SEGPTR WINAPI WINSOCK_inet_ntoa16(struct in_addr in)
1276 {
1277   char* retVal = WSOCK32_inet_ntoa(in);
1278   return retVal ? SEGPTR_GET(retVal) : (SEGPTR)NULL;
1279 }
1280
1281
1282 /**********************************************************************
1283  *              WSAIoctl                (WS2_32)
1284  *
1285  *
1286  *   FIXME:  Only SIO_GET_INTERFACE_LIST option implemented.
1287  */
1288 INT WINAPI WSAIoctl (SOCKET s,
1289                      DWORD   dwIoControlCode,
1290                      LPVOID  lpvInBuffer,
1291                      DWORD   cbInBuffer,
1292                      LPVOID  lpbOutBuffer,
1293                      DWORD   cbOutBuffer,
1294                      LPDWORD lpcbBytesReturned,
1295                      LPWSAOVERLAPPED lpOverlapped,
1296                      LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
1297 {
1298    LPWSINFO pwsi = WINSOCK_GetIData();
1299
1300    if( _check_ws(pwsi, s) )
1301    {
1302       int fd = _get_sock_fd(s);
1303
1304       switch( dwIoControlCode )
1305       {
1306          case SIO_GET_INTERFACE_LIST:
1307          {
1308             INTERFACE_INFO* intArray = (INTERFACE_INFO*)lpbOutBuffer;
1309             int i, numInt;
1310             struct ifreq ifInfo;
1311             char ifName[512];
1312
1313
1314             TRACE ("-> SIO_GET_INTERFACE_LIST request\n");
1315
1316             numInt = WSAIOCTL_GetInterfaceCount();
1317             if (numInt < 0)
1318             {
1319                ERR ("Unable to open /proc filesystem to determine number of network interfaces!\n");
1320                close(fd);
1321                WSASetLastError(WSAEINVAL);
1322                return (SOCKET_ERROR);
1323             }
1324
1325             for (i=0; i<numInt; i++)
1326             {
1327                if (!WSAIOCTL_GetInterfaceName(i, ifName))
1328                {
1329                   ERR ("Error parsing /proc filesystem!\n");
1330                   close(fd);
1331                   WSASetLastError(WSAEINVAL);
1332                   return (SOCKET_ERROR);
1333                }
1334
1335                ifInfo.ifr_addr.sa_family = AF_INET;
1336
1337                /* IP Address */
1338                strcpy (ifInfo.ifr_name, ifName);
1339                if (ioctl(fd, SIOCGIFADDR, &ifInfo) < 0)
1340                {
1341                   ERR ("Error obtaining IP address\n");
1342                   close(fd);
1343                   WSASetLastError(WSAEINVAL);
1344                   return (SOCKET_ERROR);
1345                }
1346                else
1347                {
1348                   struct ws_sockaddr_in *ipTemp = (struct ws_sockaddr_in *)&ifInfo.ifr_addr;
1349
1350                   intArray->iiAddress.AddressIn.sin_family = AF_INET;
1351                   intArray->iiAddress.AddressIn.sin_port = ipTemp->sin_port;
1352                   intArray->iiAddress.AddressIn.sin_addr.ws_addr = ipTemp->sin_addr.S_un.S_addr;
1353                }
1354
1355                /* Broadcast Address */
1356                strcpy (ifInfo.ifr_name, ifName);
1357                if (ioctl(fd, SIOCGIFBRDADDR, &ifInfo) < 0)
1358                {
1359                   ERR ("Error obtaining Broadcast IP address\n");
1360                   close(fd);
1361                   WSASetLastError(WSAEINVAL);
1362                   return (SOCKET_ERROR);
1363                }
1364                else
1365                {
1366                   struct ws_sockaddr_in *ipTemp = (struct ws_sockaddr_in *)&ifInfo.ifr_broadaddr;
1367
1368                   intArray->iiBroadcastAddress.AddressIn.sin_family = AF_INET;
1369                   intArray->iiBroadcastAddress.AddressIn.sin_port = ipTemp->sin_port;
1370                   intArray->iiBroadcastAddress.AddressIn.sin_addr.ws_addr = ipTemp->sin_addr.S_un.S_addr;
1371                }
1372
1373                /* Subnet Mask */
1374                strcpy (ifInfo.ifr_name, ifName);
1375                if (ioctl(fd, SIOCGIFNETMASK, &ifInfo) < 0)
1376                {
1377                   ERR ("Error obtaining Subnet IP address\n");
1378                   close(fd);
1379                   WSASetLastError(WSAEINVAL);
1380                   return (SOCKET_ERROR);
1381                }
1382                else
1383                {
1384                   /* Trying to avoid some compile problems across platforms.
1385                      (Linux, FreeBSD, Solaris...) */
1386                   #ifndef ifr_netmask
1387                     #ifndef ifr_addr
1388                        intArray->iiNetmask.AddressIn.sin_family = AF_INET;
1389                        intArray->iiNetmask.AddressIn.sin_port = 0;
1390                        intArray->iiNetmask.AddressIn.sin_addr.ws_addr = 0;
1391                        ERR ("Unable to determine Netmask on your platform!\n");
1392                     #else
1393                        struct ws_sockaddr_in *ipTemp = (struct ws_sockaddr_in *)&ifInfo.ifr_addr;
1394
1395                        intArray->iiNetmask.AddressIn.sin_family = AF_INET;
1396                        intArray->iiNetmask.AddressIn.sin_port = ipTemp->sin_port;
1397                        intArray->iiNetmask.AddressIn.sin_addr.ws_addr = ipTemp->sin_addr.S_un.S_addr;
1398                     #endif
1399                   #else
1400                      struct ws_sockaddr_in *ipTemp = (struct ws_sockaddr_in *)&ifInfo.ifr_netmask;
1401
1402                      intArray->iiNetmask.AddressIn.sin_family = AF_INET;
1403                      intArray->iiNetmask.AddressIn.sin_port = ipTemp->sin_port;
1404                      intArray->iiNetmask.AddressIn.sin_addr.ws_addr = ipTemp->sin_addr.S_un.S_addr;
1405                   #endif
1406                }
1407
1408                /* Socket Status Flags */
1409                strcpy(ifInfo.ifr_name, ifName);
1410                if (ioctl(fd, SIOCGIFFLAGS, &ifInfo) < 0)
1411                {
1412                   ERR ("Error obtaining status flags for socket!\n");
1413                   close(fd);
1414                   WSASetLastError(WSAEINVAL);
1415                   return (SOCKET_ERROR);
1416                }
1417                else
1418                {
1419                   /* FIXME - Is this the right flag to use? */
1420                   intArray->iiFlags = ifInfo.ifr_flags;
1421                }
1422                intArray++; /* Prepare for another interface */
1423             }
1424
1425             /* Calculate the size of the array being returned */
1426             *lpcbBytesReturned = sizeof(INTERFACE_INFO) * numInt;
1427             break;
1428          }
1429
1430          default:
1431          {
1432             WARN("\tunsupported WS_IOCTL cmd (%08lx)\n", dwIoControlCode);
1433             close(fd);
1434             WSASetLastError(WSAEOPNOTSUPP);
1435             return (SOCKET_ERROR);
1436          }
1437       }
1438
1439       /* Function executed with no errors */
1440       close(fd);
1441       return (0);
1442    }
1443    else
1444    {
1445       WSASetLastError(WSAENOTSOCK);
1446       return (SOCKET_ERROR);
1447    }
1448 }
1449
1450
1451 /*
1452   Helper function for WSAIoctl - Get count of the number of interfaces
1453   by parsing /proc filesystem.
1454 */
1455 int WSAIOCTL_GetInterfaceCount(void)
1456 {
1457    FILE *procfs;
1458    char buf[512];  /* Size doesn't matter, something big */
1459    int  intcnt=0;
1460
1461
1462    /* Open /proc filesystem file for network devices */
1463    procfs = fopen(PROCFS_NETDEV_FILE, "r");
1464    if (!procfs)
1465    {
1466       /* If we can't open the file, return an error */
1467       return (-1);
1468    }
1469
1470    /* Omit first two lines, they are only headers */
1471    fgets(buf, sizeof buf, procfs);
1472    fgets(buf, sizeof buf, procfs);
1473
1474    while (fgets(buf, sizeof buf, procfs))
1475    {
1476       /* Each line in the file represents a network interface */
1477       intcnt++;
1478    }
1479
1480    fclose(procfs);
1481    return(intcnt);
1482 }
1483
1484
1485 /*
1486    Helper function for WSAIoctl - Get name of device from interface number
1487    by parsing /proc filesystem.
1488 */
1489 int WSAIOCTL_GetInterfaceName(int intNumber, char *intName)
1490 {
1491    FILE *procfs;
1492    char buf[512]; /* Size doesn't matter, something big */
1493    int  i;
1494
1495    /* Open /proc filesystem file for network devices */
1496    procfs = fopen(PROCFS_NETDEV_FILE, "r");
1497    if (!procfs)
1498    {
1499       /* If we can't open the file, return an error */
1500       return (-1);
1501    }
1502
1503    /* Omit first two lines, they are only headers */
1504    fgets(buf, sizeof(buf), procfs);
1505    fgets(buf, sizeof(buf), procfs);
1506
1507    for (i=0; i<intNumber; i++)
1508    {
1509       /* Skip the lines that don't interest us. */
1510       fgets(buf, sizeof(buf), procfs);
1511    }
1512    fgets(buf, sizeof(buf), procfs); /* This is the line we want */
1513
1514
1515    /* Parse out the line, grabbing only the name of the device
1516       to the intName variable
1517
1518       The Line comes in like this: (we only care about the device name)
1519       lo:   21970 377 0 0 0 0 0 0 21970 377 0 0 0 0 0 0
1520    */
1521    i=0;
1522    while (isspace(buf[i])) /* Skip initial space(s) */
1523    {
1524       i++;
1525    }
1526
1527    while (buf[i])
1528    {
1529       if (isspace(buf[i]))
1530       {
1531          break;
1532       }
1533
1534       if (buf[i] == ':')  /* FIXME: Not sure if this block (alias detection) works properly */
1535       {
1536          /* This interface could be an alias... */
1537          int hold = i;
1538          char *dotname = intName;
1539          *intName++ = buf[i++];
1540
1541          while (isdigit(buf[i]))
1542          {
1543             *intName++ = buf[i++];
1544          }
1545
1546          if (buf[i] != ':')
1547          {
1548             /* ... It wasn't, so back up */
1549             i = hold;
1550             intName = dotname;
1551          }
1552
1553          if (buf[i] == '\0')
1554          {
1555             fclose(procfs);
1556             return(FALSE);
1557          }
1558
1559          i++;
1560          break;
1561       }
1562
1563       *intName++ = buf[i++];
1564    }
1565    *intName++ = '\0';
1566
1567    fclose(procfs);
1568    return(TRUE);
1569  }
1570
1571
1572 /***********************************************************************
1573  *              ioctlsocket()           (WSOCK32.12)
1574  */
1575 INT WINAPI WSOCK32_ioctlsocket(SOCKET s, LONG cmd, ULONG *argp)
1576 {
1577   LPWSINFO      pwsi = WINSOCK_GetIData();
1578
1579   TRACE("(%08x): socket %04x, cmd %08lx, ptr %8x\n",
1580                           (unsigned)pwsi, s, cmd, (unsigned) argp);
1581   if( _check_ws(pwsi, s) )
1582   {
1583     int         fd = _get_sock_fd(s);
1584     long        newcmd  = cmd;
1585
1586     switch( cmd )
1587     {
1588         case WS_FIONREAD:
1589                 newcmd=FIONREAD;
1590                 break;
1591
1592         case WS_FIONBIO:
1593                 newcmd=FIONBIO;
1594                 if( _get_sock_mask(s) )
1595                 {
1596                     /* AsyncSelect()'ed sockets are always nonblocking */
1597                     if (*argp) {
1598                         close(fd);
1599                         return 0;
1600                     }
1601                     SetLastError(WSAEINVAL);
1602                     close(fd);
1603                     return SOCKET_ERROR;
1604                 }
1605                 close(fd);
1606                 if (*argp)
1607                     _enable_event(s, 0, WS_FD_NONBLOCKING, 0);
1608                 else
1609                     _enable_event(s, 0, 0, WS_FD_NONBLOCKING);
1610                 return 0;
1611
1612         case WS_SIOCATMARK:
1613                 newcmd=SIOCATMARK;
1614                 break;
1615
1616         case WS_IOW('f',125,u_long):
1617                 WARN("Warning: WS1.1 shouldn't be using async I/O\n");
1618                 SetLastError(WSAEINVAL);
1619                 return SOCKET_ERROR;
1620
1621         default:
1622                 /* Netscape tries hard to use bogus ioctl 0x667e */
1623                 WARN("\tunknown WS_IOCTL cmd (%08lx)\n", cmd);
1624     }
1625     if( ioctl(fd, newcmd, (char*)argp ) == 0 )
1626     {
1627         close(fd);
1628         return 0;
1629     }
1630     SetLastError((errno == EBADF) ? WSAENOTSOCK : wsaErrno());
1631     close(fd);
1632   }
1633   return SOCKET_ERROR;
1634 }
1635
1636 /***********************************************************************
1637  *              ioctlsocket()           (WINSOCK.12)
1638  */
1639 INT16 WINAPI WINSOCK_ioctlsocket16(SOCKET16 s, LONG cmd, ULONG *argp)
1640 {
1641     return (INT16)WSOCK32_ioctlsocket( s, cmd, argp );
1642 }
1643
1644
1645 /***********************************************************************
1646  *              listen()                (WSOCK32.13)
1647  */
1648 INT WINAPI WSOCK32_listen(SOCKET s, INT backlog)
1649 {
1650     LPWSINFO      pwsi = WINSOCK_GetIData();
1651
1652     TRACE("(%08x): socket %04x, backlog %d\n",
1653                             (unsigned)pwsi, s, backlog);
1654     if( _check_ws(pwsi, s) )
1655     {
1656         int fd = _get_sock_fd(s);
1657         if (listen(fd, backlog) == 0)
1658         {
1659             close(fd);
1660             _enable_event(s, FD_ACCEPT,
1661                           WS_FD_LISTENING,
1662                           WS_FD_CONNECT|WS_FD_CONNECTED);
1663             return 0;
1664         }
1665         SetLastError(wsaErrno());
1666     }
1667     else SetLastError(WSAENOTSOCK);
1668     return SOCKET_ERROR;
1669 }
1670
1671 /***********************************************************************
1672  *              listen()                (WINSOCK.13)
1673  */
1674 INT16 WINAPI WINSOCK_listen16(SOCKET16 s, INT16 backlog)
1675 {
1676     return (INT16)WSOCK32_listen( s, backlog );
1677 }
1678
1679
1680 /***********************************************************************
1681  *              recv()                  (WSOCK32.16)
1682  */
1683 INT WINAPI WSOCK32_recv(SOCKET s, char *buf, INT len, INT flags)
1684 {
1685     LPWSINFO      pwsi = WINSOCK_GetIData();
1686
1687     TRACE("(%08x): socket %04x, buf %8x, len %d, "
1688                     "flags %d\n", (unsigned)pwsi, s, (unsigned)buf,
1689                     len, flags);
1690     if( _check_ws(pwsi, s) )
1691     {
1692         int fd = _get_sock_fd(s);
1693         INT length;
1694
1695         if (_is_blocking(s))
1696         {
1697             /* block here */
1698             /* FIXME: OOB and exceptfds? */
1699             do_block(fd, 1);
1700         }
1701         if ((length = recv(fd, buf, len, flags)) >= 0)
1702         {
1703             TRACE(" -> %i bytes\n", length);
1704
1705             close(fd);
1706             _enable_event(s, FD_READ, 0, 0);
1707             return length;
1708         }
1709         SetLastError(wsaErrno());
1710         close(fd);
1711     }
1712     else SetLastError(WSAENOTSOCK);
1713     WARN(" -> ERROR\n");
1714     return SOCKET_ERROR;
1715 }
1716
1717 /***********************************************************************
1718  *              recv()                  (WINSOCK.16)
1719  */
1720 INT16 WINAPI WINSOCK_recv16(SOCKET16 s, char *buf, INT16 len, INT16 flags)
1721 {
1722     return (INT16)WSOCK32_recv( s, buf, len, flags );
1723 }
1724
1725
1726 /***********************************************************************
1727  *              recvfrom()              (WSOCK32.17)
1728  */
1729 INT WINAPI WSOCK32_recvfrom(SOCKET s, char *buf, INT len, INT flags,
1730                                 struct sockaddr *from, INT *fromlen32)
1731 {
1732     LPWSINFO                 pwsi = WINSOCK_GetIData();
1733 #ifdef HAVE_IPX
1734     struct ws_sockaddr_ipx*  from2 = (struct ws_sockaddr_ipx *)from;
1735 #endif
1736
1737     TRACE("(%08x): socket %04x, ptr %08x, "
1738                     "len %d, flags %d\n", (unsigned)pwsi, s, (unsigned)buf,
1739                     len, flags);
1740 #if DEBUG_SOCKADDR
1741     if( from ) dump_sockaddr(from);
1742     else DPRINTF("from = NULL\n");
1743 #endif
1744
1745     if( _check_ws(pwsi, s) )
1746     {
1747         int fd = _get_sock_fd(s);
1748         int length;
1749
1750         if (_is_blocking(s))
1751         {
1752             /* block here */
1753             /* FIXME: OOB and exceptfds */
1754             do_block(fd, 1);
1755         }
1756         if ((length = recvfrom(fd, buf, len, flags, from, fromlen32)) >= 0)
1757         {
1758             TRACE(" -> %i bytes\n", length);
1759
1760 #ifdef HAVE_IPX
1761         if (from && ((struct sockaddr_ipx *)from)->sipx_family == AF_IPX) {
1762             from = (struct sockaddr *)
1763                                 malloc(fromlen32 ? *fromlen32 : sizeof(*from2));
1764             memcpy(from, from2, fromlen32 ? *fromlen32 : sizeof(*from2));
1765             from2->sipx_family = WS_AF_IPX;
1766             from2->sipx_network = ((struct sockaddr_ipx *)from)->sipx_network;
1767             from2->sipx_port = ((struct sockaddr_ipx *)from)->sipx_port;
1768             memcpy(from2->sipx_node,
1769                         ((struct sockaddr_ipx *)from)->sipx_node, IPX_NODE_LEN);
1770             free(from);
1771         }
1772 #endif
1773             close(fd);
1774             _enable_event(s, FD_READ, 0, 0);
1775             return (INT16)length;
1776         }
1777         SetLastError(wsaErrno());
1778         close(fd);
1779     }
1780     else SetLastError(WSAENOTSOCK);
1781     WARN(" -> ERROR\n");
1782 #ifdef HAVE_IPX
1783     if (from && ((struct sockaddr_ipx *)from)->sipx_family == AF_IPX) {
1784         from = (struct sockaddr *)
1785                                 malloc(fromlen32 ? *fromlen32 : sizeof(*from2));
1786         memcpy(from, from2, fromlen32 ? *fromlen32 : sizeof(*from2));
1787         from2->sipx_family = WS_AF_IPX;
1788         from2->sipx_network = ((struct sockaddr_ipx *)from)->sipx_network;
1789         from2->sipx_port = ((struct sockaddr_ipx *)from)->sipx_port;
1790         memcpy(from2->sipx_node,
1791                 ((struct sockaddr_ipx *)from)->sipx_node, IPX_NODE_LEN);
1792         free(from);
1793     }
1794 #endif
1795     return SOCKET_ERROR;
1796 }
1797
1798 /***********************************************************************
1799  *              recvfrom()              (WINSOCK.17)
1800  */
1801 INT16 WINAPI WINSOCK_recvfrom16(SOCKET16 s, char *buf, INT16 len, INT16 flags,
1802                                 struct sockaddr *from, INT16 *fromlen16)
1803 {
1804     INT fromlen32;
1805     INT *p = &fromlen32;
1806     INT retVal;
1807
1808     if( fromlen16 ) fromlen32 = *fromlen16; else p = NULL;
1809     retVal = WSOCK32_recvfrom( s, buf, len, flags, from, p );
1810     if( fromlen16 ) *fromlen16 = fromlen32;
1811     return (INT16)retVal;
1812 }
1813
1814 /***********************************************************************
1815  *              select()                (WINSOCK.18)(WSOCK32.18)
1816  */
1817 static INT __ws_select( BOOL b32, void *ws_readfds, void *ws_writefds, void *ws_exceptfds,
1818                           struct timeval *timeout )
1819 {
1820     LPWSINFO      pwsi = WINSOCK_GetIData();
1821
1822     TRACE("(%08x): read %8x, write %8x, excp %8x\n",
1823     (unsigned) pwsi, (unsigned) ws_readfds, (unsigned) ws_writefds, (unsigned) ws_exceptfds);
1824
1825     if( pwsi )
1826     {
1827         int         highfd = 0;
1828         fd_set      readfds, writefds, exceptfds;
1829         fd_set     *p_read, *p_write, *p_except;
1830         int         readfd[FD_SETSIZE], writefd[FD_SETSIZE], exceptfd[FD_SETSIZE];
1831
1832         p_read = fd_set_import(&readfds, pwsi, ws_readfds, &highfd, readfd, b32);
1833         p_write = fd_set_import(&writefds, pwsi, ws_writefds, &highfd, writefd, b32);
1834         p_except = fd_set_import(&exceptfds, pwsi, ws_exceptfds, &highfd, exceptfd, b32);
1835
1836         if( (highfd = select(highfd + 1, p_read, p_write, p_except, timeout)) > 0 )
1837         {
1838             fd_set_export(pwsi, &readfds, p_except, ws_readfds, readfd, b32);
1839             fd_set_export(pwsi, &writefds, p_except, ws_writefds, writefd, b32);
1840
1841             if (p_except && ws_exceptfds)
1842             {
1843 #define wsfds16 ((ws_fd_set16*)ws_exceptfds)
1844 #define wsfds32 ((ws_fd_set32*)ws_exceptfds)
1845                 int i, j, count = (b32) ? wsfds32->fd_count : wsfds16->fd_count;
1846
1847                 for (i = j = 0; i < count; i++)
1848                 {
1849                     int fd = exceptfd[i];
1850                     if( fd >= 0 && FD_ISSET(fd, &exceptfds) )
1851                     {
1852                         if( b32 )
1853                                 wsfds32->fd_array[j++] = wsfds32->fd_array[i];
1854                         else
1855                                 wsfds16->fd_array[j++] = wsfds16->fd_array[i];
1856                     }
1857                     if( fd >= 0 ) close(fd);
1858                     exceptfd[i] = -1;
1859                 }
1860                 if( b32 )
1861                     wsfds32->fd_count = j;
1862                 else
1863                     wsfds16->fd_count = j;
1864 #undef wsfds32
1865 #undef wsfds16
1866             }
1867             return highfd;
1868         }
1869         fd_set_unimport(ws_readfds, readfd, b32);
1870         fd_set_unimport(ws_writefds, writefd, b32);
1871         fd_set_unimport(ws_exceptfds, exceptfd, b32);
1872         if( ws_readfds ) ((ws_fd_set32*)ws_readfds)->fd_count = 0;
1873         if( ws_writefds ) ((ws_fd_set32*)ws_writefds)->fd_count = 0;
1874         if( ws_exceptfds ) ((ws_fd_set32*)ws_exceptfds)->fd_count = 0;
1875
1876         if( highfd == 0 ) return 0;
1877         SetLastError(wsaErrno());
1878     }
1879     return SOCKET_ERROR;
1880 }
1881
1882 INT16 WINAPI WINSOCK_select16(INT16 nfds, ws_fd_set16 *ws_readfds,
1883                               ws_fd_set16 *ws_writefds, ws_fd_set16 *ws_exceptfds,
1884                               struct timeval *timeout)
1885 {
1886     return (INT16)__ws_select( FALSE, ws_readfds, ws_writefds, ws_exceptfds, timeout );
1887 }
1888
1889 INT WINAPI WSOCK32_select(INT nfds, ws_fd_set32 *ws_readfds,
1890                               ws_fd_set32 *ws_writefds, ws_fd_set32 *ws_exceptfds,
1891                               struct timeval *timeout)
1892 {
1893     /* struct timeval is the same for both 32- and 16-bit code */
1894     return (INT)__ws_select( TRUE, ws_readfds, ws_writefds, ws_exceptfds, timeout );
1895 }
1896
1897
1898 /***********************************************************************
1899  *              send()                  (WSOCK32.19)
1900  */
1901 INT WINAPI WSOCK32_send(SOCKET s, char *buf, INT len, INT flags)
1902 {
1903     LPWSINFO      pwsi = WINSOCK_GetIData();
1904
1905     TRACE("(%08x): socket %04x, ptr %08x, length %d, flags %d\n",
1906                            (unsigned)pwsi, s, (unsigned) buf, len, flags);
1907     if( _check_ws(pwsi, s) )
1908     {
1909         int     fd = _get_sock_fd(s);
1910         int     length;
1911
1912         if (_is_blocking(s))
1913         {
1914             /* block here */
1915             /* FIXME: exceptfds */
1916             do_block(fd, 2);
1917         }
1918         if ((length = send(fd, buf, len, flags)) < 0 )
1919         {
1920             SetLastError(wsaErrno());
1921             if( GetLastError() == WSAEWOULDBLOCK )
1922                 _enable_event(s, FD_WRITE, 0, 0);
1923         }
1924         else
1925         {
1926             close(fd);
1927             return (INT16)length;
1928         }
1929         close(fd);
1930     }
1931     else SetLastError(WSAENOTSOCK);
1932     return SOCKET_ERROR;
1933 }
1934
1935 /***********************************************************************
1936  *              send()                  (WINSOCK.19)
1937  */
1938 INT16 WINAPI WINSOCK_send16(SOCKET16 s, char *buf, INT16 len, INT16 flags)
1939 {
1940     return WSOCK32_send( s, buf, len, flags );
1941 }
1942
1943 /***********************************************************************
1944  *              sendto()                (WSOCK32.20)
1945  */
1946 INT WINAPI WSOCK32_sendto(SOCKET s, char *buf, INT len, INT flags,
1947                               struct sockaddr *to, INT tolen)
1948 {
1949     LPWSINFO                 pwsi = WINSOCK_GetIData();
1950 #ifdef HAVE_IPX
1951     struct ws_sockaddr_ipx*  to2 = (struct ws_sockaddr_ipx *)to;
1952 #endif
1953
1954     TRACE("(%08x): socket %04x, ptr %08x, length %d, flags %d\n",
1955                           (unsigned)pwsi, s, (unsigned) buf, len, flags);
1956     if( _check_ws(pwsi, s) )
1957     {
1958         int     fd = _get_sock_fd(s);
1959         INT     length;
1960
1961         if (to && ((struct ws_sockaddr_ipx *)to)->sipx_family == WS_AF_PUP)
1962             ((struct ws_sockaddr_ipx *)to)->sipx_family = AF_UNSPEC;
1963 #ifdef HAVE_IPX
1964         else if (to &&
1965                 ((struct ws_sockaddr_ipx *)to)->sipx_family == WS_AF_IPX)
1966         {
1967             to = (struct sockaddr *) malloc(sizeof(struct sockaddr_ipx));
1968             memset(to, '\0', sizeof(struct sockaddr_ipx));
1969             ((struct sockaddr_ipx *)to)->sipx_family = AF_IPX;
1970             ((struct sockaddr_ipx *)to)->sipx_port = to2->sipx_port;
1971             ((struct sockaddr_ipx *)to)->sipx_network = to2->sipx_network;
1972             memcpy(((struct sockaddr_ipx *)to)->sipx_node,
1973                         to2->sipx_node, IPX_NODE_LEN);
1974             tolen = sizeof(struct sockaddr_ipx);
1975         }
1976 #endif
1977         if (_is_blocking(s))
1978         {
1979             /* block here */
1980             /* FIXME: exceptfds */
1981             do_block(fd, 2);
1982         }
1983         if ((length = sendto(fd, buf, len, flags, to, tolen)) < 0 )
1984         {
1985             SetLastError(wsaErrno());
1986             if( GetLastError() == WSAEWOULDBLOCK )
1987                 _enable_event(s, FD_WRITE, 0, 0);
1988         }
1989         else {
1990 #ifdef HAVE_IPX
1991             if (to && ((struct sockaddr_ipx *)to)->sipx_family == AF_IPX) {
1992                 free(to);
1993             }
1994 #endif
1995             close(fd);
1996             return length;
1997         }
1998         close(fd);
1999     }
2000     else SetLastError(WSAENOTSOCK);
2001 #ifdef HAVE_IPX
2002     if (to && ((struct sockaddr_ipx *)to)->sipx_family == AF_IPX) {
2003         free(to);
2004     }
2005 #endif
2006     return SOCKET_ERROR;
2007 }
2008
2009 /***********************************************************************
2010  *              sendto()                (WINSOCK.20)
2011  */
2012 INT16 WINAPI WINSOCK_sendto16(SOCKET16 s, char *buf, INT16 len, INT16 flags,
2013                               struct sockaddr *to, INT16 tolen)
2014 {
2015     return (INT16)WSOCK32_sendto( s, buf, len, flags, to, tolen );
2016 }
2017
2018 /***********************************************************************
2019  *              setsockopt()            (WSOCK32.21)
2020  */
2021 INT WINAPI WSOCK32_setsockopt(SOCKET16 s, INT level, INT optname,
2022                                   char *optval, INT optlen)
2023 {
2024     LPWSINFO      pwsi = WINSOCK_GetIData();
2025
2026     TRACE("(%08x): socket %04x, lev %d, opt %d, ptr %08x, len %d\n",
2027                           (unsigned)pwsi, s, level, optname, (int) optval, optlen);
2028     if( _check_ws(pwsi, s) )
2029     {
2030         struct  linger linger;
2031         int fd = _get_sock_fd(s);
2032         int woptval;
2033
2034         convert_sockopt(&level, &optname);
2035         if(optname == WS_SO_DONTLINGER) {
2036             linger.l_onoff      = *((int*)optval) ? 0: 1;
2037             linger.l_linger     = 0;
2038             optname=SO_LINGER;
2039             optval = (char*)&linger;
2040             optlen = sizeof(struct linger);
2041         }else{
2042             if (optname == SO_LINGER && optval) {
2043                 /* yes, uses unsigned short in both win16/win32 */
2044                 linger.l_onoff  = ((UINT16*)optval)[0];
2045                 linger.l_linger = ((UINT16*)optval)[1];
2046                 /* FIXME: what is documented behavior if SO_LINGER optval
2047                    is null?? */
2048                 optval = (char*)&linger;
2049                 optlen = sizeof(struct linger);
2050             } else if (optlen < sizeof(int)){
2051                 woptval= *((INT16 *) optval);
2052                 optval= (char*) &woptval;
2053                 optlen=sizeof(int);
2054             }
2055         }
2056         if (setsockopt(fd, level, optname, optval, optlen) == 0)
2057         {
2058             close(fd);
2059             return 0;
2060         }
2061         SetLastError(wsaErrno());
2062         close(fd);
2063     }
2064     else SetLastError(WSAENOTSOCK);
2065     return SOCKET_ERROR;
2066 }
2067
2068 /***********************************************************************
2069  *              setsockopt()            (WINSOCK.21)
2070  */
2071 INT16 WINAPI WINSOCK_setsockopt16(SOCKET16 s, INT16 level, INT16 optname,
2072                                   char *optval, INT16 optlen)
2073 {
2074     if( !optval ) return SOCKET_ERROR;
2075     return (INT16)WSOCK32_setsockopt( s, (UINT16)level, optname, optval, optlen );
2076 }
2077
2078
2079 /***********************************************************************
2080  *              shutdown()              (WSOCK32.22)
2081  */
2082 INT WINAPI WSOCK32_shutdown(SOCKET s, INT how)
2083 {
2084     LPWSINFO      pwsi = WINSOCK_GetIData();
2085
2086     TRACE("(%08x): socket %04x, how %i\n",
2087                             (unsigned)pwsi, s, how );
2088     if( _check_ws(pwsi, s) )
2089     {
2090         int fd = _get_sock_fd(s);
2091             switch( how )
2092             {
2093                 case 0: /* drop receives */
2094                         _enable_event(s, 0, 0, WS_FD_READ);
2095 #ifdef SHUT_RD
2096                         how = SHUT_RD;
2097 #endif
2098                         break;
2099
2100                 case 1: /* drop sends */
2101                         _enable_event(s, 0, 0, WS_FD_WRITE);
2102 #ifdef SHUT_WR
2103                         how = SHUT_WR;
2104 #endif
2105                         break;
2106
2107                 case 2: /* drop all */
2108 #ifdef SHUT_RDWR
2109                         how = SHUT_RDWR;
2110 #endif
2111                 default:
2112                         WSAAsyncSelect( s, 0, 0, 0 );
2113                         break;
2114             }
2115
2116         if (shutdown(fd, how) == 0)
2117         {
2118             if( how > 1 )
2119             {
2120                 _enable_event(s, 0, 0, WS_FD_CONNECTED|WS_FD_LISTENING);
2121             }
2122             close(fd);
2123             return 0;
2124         }
2125         SetLastError(wsaErrno());
2126         close(fd);
2127     }
2128     else SetLastError(WSAENOTSOCK);
2129     return SOCKET_ERROR;
2130 }
2131
2132 /***********************************************************************
2133  *              shutdown()              (WINSOCK.22)
2134  */
2135 INT16 WINAPI WINSOCK_shutdown16(SOCKET16 s, INT16 how)
2136 {
2137     return (INT16)WSOCK32_shutdown( s, how );
2138 }
2139
2140
2141 /***********************************************************************
2142  *              socket()                (WSOCK32.23)
2143  */
2144 SOCKET WINAPI WSOCK32_socket(INT af, INT type, INT protocol)
2145 {
2146   LPWSINFO      pwsi = WINSOCK_GetIData();
2147   struct create_socket_request *req = get_req_buffer();
2148
2149   TRACE("(%08x): af=%d type=%d protocol=%d\n",
2150                           (unsigned)pwsi, af, type, protocol);
2151
2152   if( pwsi )
2153   {
2154     /* check the socket family */
2155     switch(af)
2156     {
2157 #ifdef HAVE_IPX
2158         case WS_AF_IPX: af = AF_IPX;
2159 #endif
2160         case AF_INET:
2161         case AF_UNSPEC: break;
2162         default:        SetLastError(WSAEAFNOSUPPORT);
2163                         return INVALID_SOCKET;
2164     }
2165
2166     /* check the socket type */
2167     switch(type)
2168     {
2169         case SOCK_STREAM:
2170         case SOCK_DGRAM:
2171         case SOCK_RAW:  break;
2172         default:        SetLastError(WSAESOCKTNOSUPPORT);
2173                         return INVALID_SOCKET;
2174     }
2175
2176     /* check the protocol type */
2177     if ( protocol < 0 )  /* don't support negative values */
2178     { SetLastError(WSAEPROTONOSUPPORT); return INVALID_SOCKET; }
2179
2180     if ( af == AF_UNSPEC)  /* did they not specify the address family? */
2181         switch(protocol)
2182         {
2183           case IPPROTO_TCP:
2184              if (type == SOCK_STREAM) { af = AF_INET; break; }
2185           case IPPROTO_UDP:
2186              if (type == SOCK_DGRAM)  { af = AF_INET; break; }
2187           default: SetLastError(WSAEPROTOTYPE); return INVALID_SOCKET;
2188         }
2189
2190     req->family   = af;
2191     req->type     = type;
2192     req->protocol = protocol;
2193     req->access   = GENERIC_READ|GENERIC_WRITE|SYNCHRONIZE;
2194     req->inherit  = TRUE;
2195     sock_server_call( REQ_CREATE_SOCKET );
2196     if ( req->handle >= 0)
2197     {
2198         TRACE("\tcreated %04x\n", req->handle);
2199
2200         return req->handle;
2201     }
2202
2203     if (GetLastError() == WSAEACCES) /* raw socket denied */
2204     {
2205         if (type == SOCK_RAW)
2206             MESSAGE("WARNING: Trying to create a socket of type SOCK_RAW, will fail unless running as root\n");
2207         else
2208             MESSAGE("WS_SOCKET: not enough privileges to create socket, try running as root\n");
2209         SetLastError(WSAESOCKTNOSUPPORT);
2210     }
2211   }
2212
2213   WARN("\t\tfailed!\n");
2214   return INVALID_SOCKET;
2215 }
2216
2217 /***********************************************************************
2218  *              socket()                (WINSOCK.23)
2219  */
2220 SOCKET16 WINAPI WINSOCK_socket16(INT16 af, INT16 type, INT16 protocol)
2221 {
2222     return (SOCKET16)WSOCK32_socket( af, type, protocol );
2223 }
2224
2225
2226 /* ----------------------------------- DNS services
2227  *
2228  * IMPORTANT: 16-bit API structures have SEGPTR pointers inside them.
2229  * Also, we have to use wsock32 stubs to convert structures and
2230  * error codes from Unix to WSA, hence there is no direct mapping in
2231  * the relay32/wsock32.spec.
2232  */
2233
2234 static char*    NULL_STRING = "NULL";
2235
2236 /***********************************************************************
2237  *              gethostbyaddr()         (WINSOCK.51)(WSOCK32.51)
2238  */
2239 static struct WIN_hostent* __ws_gethostbyaddr(const char *addr, int len, int type, int dup_flag)
2240 {
2241     LPWSINFO            pwsi = WINSOCK_GetIData();
2242
2243     if( pwsi )
2244     {
2245         struct hostent* host;
2246         if( (host = gethostbyaddr(addr, len, type)) != NULL )
2247             if( WS_dup_he(pwsi, host, dup_flag) )
2248                 return (struct WIN_hostent*)(pwsi->he);
2249             else
2250                 SetLastError(WSAENOBUFS);
2251         else
2252             SetLastError((h_errno < 0) ? wsaErrno() : wsaHerrno());
2253     }
2254     return NULL;
2255 }
2256
2257 SEGPTR WINAPI WINSOCK_gethostbyaddr16(const char *addr, INT16 len, INT16 type)
2258 {
2259     struct WIN_hostent* retval;
2260     TRACE("ptr %08x, len %d, type %d\n",
2261                             (unsigned) addr, len, type);
2262     retval = __ws_gethostbyaddr( addr, len, type, WS_DUP_SEGPTR );
2263     return retval ? SEGPTR_GET(retval) : ((SEGPTR)NULL);
2264 }
2265
2266 struct WIN_hostent* WINAPI WSOCK32_gethostbyaddr(const char *addr, INT len,
2267                                                 INT type)
2268 {
2269     TRACE("ptr %08x, len %d, type %d\n",
2270                              (unsigned) addr, len, type);
2271     return __ws_gethostbyaddr(addr, len, type, WS_DUP_LINEAR);
2272 }
2273
2274 /***********************************************************************
2275  *              gethostbyname()         (WINSOCK.52)(WSOCK32.52)
2276  */
2277 static struct WIN_hostent * __ws_gethostbyname(const char *name, int dup_flag)
2278 {
2279     LPWSINFO              pwsi = WINSOCK_GetIData();
2280
2281     if( pwsi )
2282     {
2283         struct hostent*     host;
2284         if( (host = gethostbyname(name)) != NULL )
2285              if( WS_dup_he(pwsi, host, dup_flag) )
2286                  return (struct WIN_hostent*)(pwsi->he);
2287              else SetLastError(WSAENOBUFS);
2288         else SetLastError((h_errno < 0) ? wsaErrno() : wsaHerrno());
2289     }
2290     return NULL;
2291 }
2292
2293 SEGPTR WINAPI WINSOCK_gethostbyname16(const char *name)
2294 {
2295     struct WIN_hostent* retval;
2296     TRACE("%s\n", (name)?name:NULL_STRING);
2297     retval = __ws_gethostbyname( name, WS_DUP_SEGPTR );
2298     return (retval)? SEGPTR_GET(retval) : ((SEGPTR)NULL) ;
2299 }
2300
2301 struct WIN_hostent* WINAPI WSOCK32_gethostbyname(const char* name)
2302 {
2303     TRACE("%s\n", (name)?name:NULL_STRING);
2304     return __ws_gethostbyname( name, WS_DUP_LINEAR );
2305 }
2306
2307
2308 /***********************************************************************
2309  *              getprotobyname()        (WINSOCK.53)(WSOCK32.53)
2310  */
2311 static struct WIN_protoent* __ws_getprotobyname(const char *name, int dup_flag)
2312 {
2313     LPWSINFO              pwsi = WINSOCK_GetIData();
2314
2315     if( pwsi )
2316     {
2317         struct protoent*     proto;
2318         if( (proto = getprotobyname(name)) != NULL )
2319             if( WS_dup_pe(pwsi, proto, dup_flag) )
2320                 return (struct WIN_protoent*)(pwsi->pe);
2321             else SetLastError(WSAENOBUFS);
2322         else {
2323             MESSAGE("protocol %s not found; You might want to add "
2324                     "this to /etc/protocols\n", debugstr_a(name) );
2325             SetLastError(WSANO_DATA);
2326         }
2327     } else SetLastError(WSANOTINITIALISED);
2328     return NULL;
2329 }
2330
2331 SEGPTR WINAPI WINSOCK_getprotobyname16(const char *name)
2332 {
2333     struct WIN_protoent* retval;
2334     TRACE("%s\n", (name)?name:NULL_STRING);
2335     retval = __ws_getprotobyname(name, WS_DUP_SEGPTR);
2336     return retval ? SEGPTR_GET(retval) : ((SEGPTR)NULL);
2337 }
2338
2339 struct WIN_protoent* WINAPI WSOCK32_getprotobyname(const char* name)
2340 {
2341     TRACE("%s\n", (name)?name:NULL_STRING);
2342     return __ws_getprotobyname(name, WS_DUP_LINEAR);
2343 }
2344
2345
2346 /***********************************************************************
2347  *              getprotobynumber()      (WINSOCK.54)(WSOCK32.54)
2348  */
2349 static struct WIN_protoent* __ws_getprotobynumber(int number, int dup_flag)
2350 {
2351     LPWSINFO              pwsi = WINSOCK_GetIData();
2352
2353     if( pwsi )
2354     {
2355         struct protoent*     proto;
2356         if( (proto = getprotobynumber(number)) != NULL )
2357             if( WS_dup_pe(pwsi, proto, dup_flag) )
2358                 return (struct WIN_protoent*)(pwsi->pe);
2359             else SetLastError(WSAENOBUFS);
2360         else {
2361             MESSAGE("protocol number %d not found; You might want to add "
2362                     "this to /etc/protocols\n", number );
2363             SetLastError(WSANO_DATA);
2364         }
2365     } else SetLastError(WSANOTINITIALISED);
2366     return NULL;
2367 }
2368
2369 SEGPTR WINAPI WINSOCK_getprotobynumber16(INT16 number)
2370 {
2371     struct WIN_protoent* retval;
2372     TRACE("%i\n", number);
2373     retval = __ws_getprotobynumber(number, WS_DUP_SEGPTR);
2374     return retval ? SEGPTR_GET(retval) : ((SEGPTR)NULL);
2375 }
2376
2377 struct WIN_protoent* WINAPI WSOCK32_getprotobynumber(INT number)
2378 {
2379     TRACE("%i\n", number);
2380     return __ws_getprotobynumber(number, WS_DUP_LINEAR);
2381 }
2382
2383
2384 /***********************************************************************
2385  *              getservbyname()         (WINSOCK.55)(WSOCK32.55)
2386  */
2387 struct WIN_servent* __ws_getservbyname(const char *name, const char *proto, int dup_flag)
2388 {
2389     LPWSINFO              pwsi = WINSOCK_GetIData();
2390
2391     if( pwsi )
2392     {
2393         struct servent*     serv;
2394         int i = wsi_strtolo( pwsi, name, proto );
2395
2396         if( i ) {
2397             serv = getservbyname(pwsi->buffer,
2398                                  proto ? (pwsi->buffer + i) : NULL);
2399             if( serv != NULL )
2400                 if( WS_dup_se(pwsi, serv, dup_flag) )
2401                     return (struct WIN_servent*)(pwsi->se);
2402                 else SetLastError(WSAENOBUFS);
2403             else {
2404                 MESSAGE("service %s protocol %s not found; You might want to add "
2405                         "this to /etc/services\n", debugstr_a(pwsi->buffer),
2406                         proto ? debugstr_a(pwsi->buffer+i):"*");
2407                 SetLastError(WSANO_DATA);
2408             }
2409         }
2410         else SetLastError(WSAENOBUFS);
2411     } else SetLastError(WSANOTINITIALISED);
2412     return NULL;
2413 }
2414
2415 SEGPTR WINAPI WINSOCK_getservbyname16(const char *name, const char *proto)
2416 {
2417     struct WIN_servent* retval;
2418     TRACE("'%s', '%s'\n",
2419                             (name)?name:NULL_STRING, (proto)?proto:NULL_STRING);
2420     retval = __ws_getservbyname(name, proto, WS_DUP_SEGPTR);
2421     return retval ? SEGPTR_GET(retval) : ((SEGPTR)NULL);
2422 }
2423
2424 struct WIN_servent* WINAPI WSOCK32_getservbyname(const char *name, const char *proto)
2425 {
2426     TRACE("'%s', '%s'\n",
2427                             (name)?name:NULL_STRING, (proto)?proto:NULL_STRING);
2428     return __ws_getservbyname(name, proto, WS_DUP_LINEAR);
2429 }
2430
2431
2432 /***********************************************************************
2433  *              getservbyport()         (WINSOCK.56)(WSOCK32.56)
2434  */
2435 static struct WIN_servent* __ws_getservbyport(int port, const char* proto, int dup_flag)
2436 {
2437     LPWSINFO              pwsi = WINSOCK_GetIData();
2438
2439     if( pwsi )
2440     {
2441         struct servent*     serv;
2442         if (!proto || wsi_strtolo( pwsi, proto, NULL )) {
2443             if( (serv = getservbyport(port, (proto) ? pwsi->buffer : NULL)) != NULL ) {
2444                 if( WS_dup_se(pwsi, serv, dup_flag) )
2445                     return (struct WIN_servent*)(pwsi->se);
2446                 else SetLastError(WSAENOBUFS);
2447             }
2448             else {
2449                 MESSAGE("service on port %lu protocol %s not found; You might want to add "
2450                         "this to /etc/services\n", (unsigned long)ntohl(port),
2451                         proto ? debugstr_a(pwsi->buffer) : "*");
2452                 SetLastError(WSANO_DATA);
2453             }
2454         }
2455         else SetLastError(WSAENOBUFS);
2456     } else SetLastError(WSANOTINITIALISED);
2457     return NULL;
2458 }
2459
2460 SEGPTR WINAPI WINSOCK_getservbyport16(INT16 port, const char *proto)
2461 {
2462     struct WIN_servent* retval;
2463     TRACE("%i, '%s'\n",
2464                             (int)port, (proto)?proto:NULL_STRING);
2465     retval = __ws_getservbyport(port, proto, WS_DUP_SEGPTR);
2466     return retval ? SEGPTR_GET(retval) : ((SEGPTR)NULL);
2467 }
2468
2469 struct WIN_servent* WINAPI WSOCK32_getservbyport(INT port, const char *proto)
2470 {
2471     TRACE("%i, '%s'\n",
2472                             (int)port, (proto)?proto:NULL_STRING);
2473     return __ws_getservbyport(port, proto, WS_DUP_LINEAR);
2474 }
2475
2476
2477 /***********************************************************************
2478  *              gethostname()           (WSOCK32.57)
2479  */
2480 INT WINAPI WSOCK32_gethostname(char *name, INT namelen)
2481 {
2482     LPWSINFO              pwsi = WINSOCK_GetIData();
2483
2484     TRACE("(%08x): name %s, len %d\n",
2485                           (unsigned)pwsi, (name)?name:NULL_STRING, namelen);
2486     if( pwsi )
2487     {
2488         if (gethostname(name, namelen) == 0) return 0;
2489         SetLastError((errno == EINVAL) ? WSAEFAULT : wsaErrno());
2490     }
2491     return SOCKET_ERROR;
2492 }
2493
2494 /***********************************************************************
2495  *              gethostname()           (WINSOCK.57)
2496  */
2497 INT16 WINAPI WINSOCK_gethostname16(char *name, INT16 namelen)
2498 {
2499     return (INT16)WSOCK32_gethostname(name, namelen);
2500 }
2501
2502
2503 /* ------------------------------------- Windows sockets extensions -- *
2504  *                                                                     *
2505  * ------------------------------------------------------------------- */
2506
2507 /***********************************************************************
2508  *              WSAEnumNetworkEvents
2509  */
2510 int WINAPI WSAEnumNetworkEvents(SOCKET s, WSAEVENT hEvent, LPWSANETWORKEVENTS lpEvent)
2511 {
2512     LPWSINFO      pwsi = WINSOCK_GetIData();
2513     struct get_socket_event_request *req = get_req_buffer();
2514
2515     TRACE("(%08x): %08x, hEvent %08x, lpEvent %08x\n",
2516                           (unsigned)pwsi, s, hEvent, (unsigned)lpEvent );
2517     if( _check_ws(pwsi, s) )
2518     {
2519         req->handle  = s;
2520         req->service = TRUE;
2521         req->s_event = 0;
2522         req->c_event = hEvent;
2523         sock_server_call( REQ_GET_SOCKET_EVENT );
2524         lpEvent->lNetworkEvents = req->pmask;
2525         memcpy(lpEvent->iErrorCode, req->errors, sizeof(lpEvent->iErrorCode));
2526         return 0;
2527     }
2528     else SetLastError(WSAEINVAL);
2529     return SOCKET_ERROR;
2530 }
2531
2532 /***********************************************************************
2533  *              WSAEventSelect
2534  */
2535 int WINAPI WSAEventSelect(SOCKET s, WSAEVENT hEvent, LONG lEvent)
2536 {
2537     LPWSINFO      pwsi = WINSOCK_GetIData();
2538     struct set_socket_event_request *req = get_req_buffer();
2539
2540     TRACE("(%08x): %08x, hEvent %08x, event %08x\n",
2541                           (unsigned)pwsi, s, hEvent, (unsigned)lEvent );
2542     if( _check_ws(pwsi, s) )
2543     {
2544         req->handle = s;
2545         req->mask   = lEvent;
2546         req->event  = hEvent;
2547         sock_server_call( REQ_SET_SOCKET_EVENT );
2548         return 0;
2549     }
2550     else SetLastError(WSAEINVAL);
2551     return SOCKET_ERROR;
2552 }
2553
2554 /***********************************************************************
2555  *      WSAAsyncSelect()                (WINSOCK.101)(WSOCK32.101)
2556  */
2557
2558 VOID CALLBACK WINSOCK_DoAsyncEvent( ULONG_PTR ptr )
2559 {
2560     ws_select_info *info = (ws_select_info*)ptr;
2561     LPWSINFO      pwsi = info->pwsi;
2562     struct get_socket_event_request *req = get_req_buffer();
2563     unsigned int i, pmask, orphan = FALSE;
2564
2565     TRACE("socket %08x, event %08x\n", info->sock, info->event);
2566     SetLastError(0);
2567     req->handle  = info->sock;
2568     req->service = TRUE;
2569     req->s_event = info->event; /* <== avoid race conditions */
2570     req->c_event = info->event;
2571     sock_server_call( REQ_GET_SOCKET_EVENT );
2572     if ( (GetLastError() == WSAENOTSOCK) || (GetLastError() == WSAEINVAL) )
2573     {
2574         /* orphaned event (socket closed or something) */
2575         pmask = WS_FD_SERVEVENT;
2576         orphan = TRUE;
2577     } else
2578         pmask = req->pmask;
2579     /* check for accepted sockets that needs to inherit WSAAsyncSelect */
2580     if (pmask & WS_FD_SERVEVENT) {
2581         int q;
2582         for (q=0; q<WS_ACCEPT_QUEUE; q++)
2583             if (pwsi->accept_old[q] == info->sock) {
2584                 /* there's only one service thread per pwsi, no lock necessary */
2585                 HANDLE as = pwsi->accept_new[q];
2586                 if (as) {
2587                     pwsi->accept_new[q] = 0;
2588                     pwsi->accept_old[q] = 0;
2589                     WSAAsyncSelect(as, info->hWnd, info->uMsg, info->lEvent);
2590                 }
2591             }
2592         pmask &= ~WS_FD_SERVEVENT;
2593     }
2594     /* dispatch network events */
2595     for (i=0; i<FD_MAX_EVENTS; i++)
2596         if (pmask & (1<<i)) {
2597             TRACE("post: event bit %d, error %d\n", i, req->errors[i]);
2598             PostMessageA(info->hWnd, info->uMsg, info->sock,
2599                          WSAMAKESELECTREPLY(1<<i, req->errors[i]));
2600         }
2601     /* cleanup */
2602     if (orphan)
2603     {
2604         TRACE("orphaned event, self-destructing\n");
2605         /* SERVICE_Delete closes the event object */
2606         SERVICE_Delete( info->service );
2607         WS_FREE(info);
2608     }
2609 }
2610
2611 INT WINAPI WSAAsyncSelect(SOCKET s, HWND hWnd, UINT uMsg, LONG lEvent)
2612 {
2613     LPWSINFO      pwsi = WINSOCK_GetIData();
2614
2615     TRACE("(%08x): %04x, hWnd %04x, uMsg %08x, event %08x\n",
2616                           (unsigned)pwsi, (SOCKET16)s, (HWND16)hWnd, uMsg, (unsigned)lEvent );
2617     if( _check_ws(pwsi, s) )
2618     {
2619         if( lEvent )
2620         {
2621             ws_select_info *info = (ws_select_info*)WS_ALLOC(sizeof(ws_select_info));
2622             if( info )
2623             {
2624                 HANDLE hObj = CreateEventA( NULL, TRUE, FALSE, NULL );
2625                 INT err;
2626
2627                 info->sock   = s;
2628                 info->event  = hObj;
2629                 info->hWnd   = hWnd;
2630                 info->uMsg   = uMsg;
2631                 info->lEvent = lEvent;
2632                 info->pwsi   = pwsi;
2633                 info->service = SERVICE_AddObject( hObj, WINSOCK_DoAsyncEvent, (ULONG_PTR)info );
2634
2635                 err = WSAEventSelect( s, hObj, lEvent | WS_FD_SERVEVENT );
2636                 if (err) {
2637                     /* SERVICE_Delete closes the event object */
2638                     SERVICE_Delete( info->service );
2639                     WS_FREE(info);
2640                     return err;
2641                 }
2642
2643                 return 0; /* success */
2644             }
2645             else SetLastError(WSAENOBUFS);
2646         }
2647         else
2648         {
2649             WSAEventSelect(s, 0, 0);
2650             return 0;
2651         }
2652     }
2653     else SetLastError(WSAEINVAL);
2654     return SOCKET_ERROR;
2655 }
2656
2657 INT16 WINAPI WSAAsyncSelect16(SOCKET16 s, HWND16 hWnd, UINT16 wMsg, LONG lEvent)
2658 {
2659     return (INT16)WSAAsyncSelect( s, hWnd, wMsg, lEvent );
2660 }
2661
2662 /***********************************************************************
2663  *              WSARecvEx()                     (WSOCK32.1107)
2664  *
2665  * WSARecvEx is a Microsoft specific extension to winsock that is identical to recv
2666  * except that has an in/out argument call flags that has the value MSG_PARTIAL ored
2667  * into the flags parameter when a partial packet is read. This only applies to
2668  * sockets using the datagram protocol. This method does not seem to be implemented
2669  * correctly by microsoft as the winsock implementation does not set the MSG_PARTIAL
2670  * flag when a fragmented packet arrives.
2671  */
2672 INT     WINAPI   WSARecvEx(SOCKET s, char *buf, INT len, INT *flags) {
2673   FIXME("(WSARecvEx) partial packet return value not set \n");
2674
2675   return WSOCK32_recv(s, buf, len, *flags);
2676 }
2677
2678
2679 /***********************************************************************
2680  *              WSARecvEx16()                   (WINSOCK.1107)
2681  *
2682  * See description for WSARecvEx()
2683  */
2684 INT16     WINAPI WSARecvEx16(SOCKET16 s, char *buf, INT16 len, INT16 *flags) {
2685   FIXME("(WSARecvEx16) partial packet return value not set \n");
2686
2687   return WINSOCK_recv16(s, buf, len, *flags);
2688 }
2689
2690
2691 /***********************************************************************
2692  *      WSACreateEvent()          (WS2_32.???)
2693  *
2694  */
2695 WSAEVENT WINAPI WSACreateEvent(void)
2696 {
2697     /* Create a manual-reset event, with initial state: unsignealed */
2698     TRACE("\n");
2699
2700     return CreateEventA(NULL, TRUE, FALSE, NULL);
2701 }
2702
2703 /***********************************************************************
2704  *      WSACloseEvent()          (WS2_32.???)
2705  *
2706  */
2707 BOOL WINAPI WSACloseEvent(WSAEVENT event)
2708 {
2709     TRACE ("event=0x%x\n", event);
2710
2711     return CloseHandle(event);
2712 }
2713
2714 /***********************************************************************
2715  *      WSASocketA()          (WS2_32.???)
2716  *
2717  */
2718 SOCKET WINAPI WSASocketA(int af, int type, int protocol,
2719                          LPWSAPROTOCOL_INFOA lpProtocolInfo,
2720                          GROUP g, DWORD dwFlags)
2721 {
2722    /*
2723       FIXME: The "advanced" parameters of WSASocketA (lpProtocolInfo,
2724       g, dwFlags) are ignored.
2725    */
2726
2727    TRACE("af=%d type=%d protocol=%d protocol_info=%p group=%d flags=0x%lx\n",
2728          af, type, protocol, lpProtocolInfo, g, dwFlags );
2729
2730    return ( WSOCK32_socket (af, type, protocol) );
2731 }
2732
2733
2734 /***********************************************************************
2735  *      __WSAFDIsSet()                  (WINSOCK.151)
2736  */
2737 INT16 WINAPI __WSAFDIsSet16(SOCKET16 s, ws_fd_set16 *set)
2738 {
2739   int i = set->fd_count;
2740
2741   TRACE("(%d,%8lx(%i))\n", s,(unsigned long)set, i);
2742
2743   while (i--)
2744       if (set->fd_array[i] == s) return 1;
2745   return 0;
2746 }
2747
2748 /***********************************************************************
2749  *      __WSAFDIsSet()                  (WSOCK32.151)
2750  */
2751 INT WINAPI __WSAFDIsSet(SOCKET s, ws_fd_set32 *set)
2752 {
2753   int i = set->fd_count;
2754
2755   TRACE("(%d,%8lx(%i))\n", s,(unsigned long)set, i);
2756
2757   while (i--)
2758       if (set->fd_array[i] == s) return 1;
2759   return 0;
2760 }
2761
2762 /***********************************************************************
2763  *      WSAIsBlocking()                 (WINSOCK.114)(WSOCK32.114)
2764  */
2765 BOOL WINAPI WSAIsBlocking(void)
2766 {
2767   /* By default WinSock should set all its sockets to non-blocking mode
2768    * and poll in PeekMessage loop when processing "blocking" ones. This
2769    * function is supposed to tell if the program is in this loop. Our
2770    * blocking calls are truly blocking so we always return FALSE.
2771    *
2772    * Note: It is allowed to call this function without prior WSAStartup().
2773    */
2774
2775   TRACE("\n");
2776   return FALSE;
2777 }
2778
2779 /***********************************************************************
2780  *      WSACancelBlockingCall()         (WINSOCK.113)(WSOCK32.113)
2781  */
2782 INT WINAPI WSACancelBlockingCall(void)
2783 {
2784   LPWSINFO              pwsi = WINSOCK_GetIData();
2785
2786   TRACE("(%08x)\n", (unsigned)pwsi);
2787
2788   if( pwsi ) return 0;
2789   return SOCKET_ERROR;
2790 }
2791
2792
2793 /***********************************************************************
2794  *      WSASetBlockingHook16()          (WINSOCK.109)
2795  */
2796 FARPROC16 WINAPI WSASetBlockingHook16(FARPROC16 lpBlockFunc)
2797 {
2798   FARPROC16             prev;
2799   LPWSINFO              pwsi = WINSOCK_GetIData();
2800
2801   TRACE("(%08x): hook %08x\n",
2802                (unsigned)pwsi, (unsigned) lpBlockFunc);
2803   if( pwsi )
2804   {
2805       prev = (FARPROC16)pwsi->blocking_hook;
2806       pwsi->blocking_hook = (DWORD)lpBlockFunc;
2807       pwsi->flags &= ~WSI_BLOCKINGHOOK;
2808       return prev;
2809   }
2810   return 0;
2811 }
2812
2813
2814 /***********************************************************************
2815  *      WSASetBlockingHook()
2816  */
2817 FARPROC WINAPI WSASetBlockingHook(FARPROC lpBlockFunc)
2818 {
2819   FARPROC             prev;
2820   LPWSINFO              pwsi = WINSOCK_GetIData();
2821
2822   TRACE("(%08x): hook %08x\n",
2823                (unsigned)pwsi, (unsigned) lpBlockFunc);
2824   if( pwsi ) {
2825       prev = (FARPROC)pwsi->blocking_hook;
2826       pwsi->blocking_hook = (DWORD)lpBlockFunc;
2827       pwsi->flags |= WSI_BLOCKINGHOOK;
2828       return prev;
2829   }
2830   return NULL;
2831 }
2832
2833
2834 /***********************************************************************
2835  *      WSAUnhookBlockingHook16()       (WINSOCK.110)
2836  */
2837 INT16 WINAPI WSAUnhookBlockingHook16(void)
2838 {
2839     LPWSINFO              pwsi = WINSOCK_GetIData();
2840
2841     TRACE("(%08x)\n", (unsigned)pwsi);
2842     if( pwsi ) return (INT16)(pwsi->blocking_hook = 0);
2843     return SOCKET_ERROR;
2844 }
2845
2846
2847 /***********************************************************************
2848  *      WSAUnhookBlockingHook()
2849  */
2850 INT WINAPI WSAUnhookBlockingHook(void)
2851 {
2852     LPWSINFO              pwsi = WINSOCK_GetIData();
2853
2854     TRACE("(%08x)\n", (unsigned)pwsi);
2855     if( pwsi )
2856     {
2857         pwsi->blocking_hook = 0;
2858         pwsi->flags &= ~WSI_BLOCKINGHOOK;
2859         return 0;
2860     }
2861     return SOCKET_ERROR;
2862 }
2863
2864
2865 /* ----------------------------------- end of API stuff */
2866
2867 /* ----------------------------------- helper functions -
2868  *
2869  * TODO: Merge WS_dup_..() stuff into one function that
2870  * would operate with a generic structure containing internal
2871  * pointers (via a template of some kind).
2872  */
2873
2874 static int list_size(char** l, int item_size)
2875 {
2876   int i,j = 0;
2877   if(l)
2878   { for(i=0;l[i];i++)
2879         j += (item_size) ? item_size : strlen(l[i]) + 1;
2880     j += (i + 1) * sizeof(char*); }
2881   return j;
2882 }
2883
2884 static int list_dup(char** l_src, char* ref, char* base, int item_size)
2885 {
2886    /* base is either either equal to ref or 0 or SEGPTR */
2887
2888    char*                p = ref;
2889    char**               l_to = (char**)ref;
2890    int                  i,j,k;
2891
2892    for(j=0;l_src[j];j++) ;
2893    p += (j + 1) * sizeof(char*);
2894    for(i=0;i<j;i++)
2895    { l_to[i] = base + (p - ref);
2896      k = ( item_size ) ? item_size : strlen(l_src[i]) + 1;
2897      memcpy(p, l_src[i], k); p += k; }
2898    l_to[i] = NULL;
2899    return (p - ref);
2900 }
2901
2902 /* ----- hostent */
2903
2904 static int hostent_size(struct hostent* p_he)
2905 {
2906   int size = 0;
2907   if( p_he )
2908   { size  = sizeof(struct hostent);
2909     size += strlen(p_he->h_name) + 1;
2910     size += list_size(p_he->h_aliases, 0);
2911     size += list_size(p_he->h_addr_list, p_he->h_length ); }
2912   return size;
2913 }
2914
2915 int WS_dup_he(LPWSINFO pwsi, struct hostent* p_he, int flag)
2916 {
2917    /* Convert hostent structure into ws_hostent so that the data fits
2918     * into pwsi->buffer. Internal pointers can be linear, SEGPTR, or
2919     * relative to pwsi->buffer depending on "flag" value. Returns size
2920     * of the data copied (also in the pwsi->buflen).
2921     */
2922
2923    int size = hostent_size(p_he);
2924
2925    if( size )
2926    {
2927      struct ws_hostent* p_to;
2928      char* p_name,*p_aliases,*p_addr,*p_base,*p;
2929
2930      _check_buffer_he(pwsi, size);
2931      p_to = (struct ws_hostent*)pwsi->he;
2932      p = (char*)pwsi->he;
2933      p_base = (flag & WS_DUP_OFFSET) ? NULL
2934                                      : ((flag & WS_DUP_SEGPTR) ? (char*)SEGPTR_GET(p) : p);
2935      p += sizeof(struct ws_hostent);
2936      p_name = p;
2937      strcpy(p, p_he->h_name); p += strlen(p) + 1;
2938      p_aliases = p;
2939      p += list_dup(p_he->h_aliases, p, p_base + (p - (char*)pwsi->he), 0);
2940      p_addr = p;
2941      list_dup(p_he->h_addr_list, p, p_base + (p - (char*)pwsi->he), p_he->h_length);
2942
2943      p_to->h_addrtype = (INT16)p_he->h_addrtype;
2944      p_to->h_length = (INT16)p_he->h_length;
2945      p_to->h_name = (SEGPTR)(p_base + (p_name - (char*)pwsi->he));
2946      p_to->h_aliases = (SEGPTR)(p_base + (p_aliases - (char*)pwsi->he));
2947      p_to->h_addr_list = (SEGPTR)(p_base + (p_addr - (char*)pwsi->he));
2948
2949      size += (sizeof(struct ws_hostent) - sizeof(struct hostent));
2950    }
2951    return size;
2952 }
2953
2954 /* ----- protoent */
2955
2956 static int protoent_size(struct protoent* p_pe)
2957 {
2958   int size = 0;
2959   if( p_pe )
2960   { size  = sizeof(struct protoent);
2961     size += strlen(p_pe->p_name) + 1;
2962     size += list_size(p_pe->p_aliases, 0); }
2963   return size;
2964 }
2965
2966 int WS_dup_pe(LPWSINFO pwsi, struct protoent* p_pe, int flag)
2967 {
2968    int size = protoent_size(p_pe);
2969    if( size )
2970    {
2971      struct ws_protoent* p_to;
2972      char* p_name,*p_aliases,*p_base,*p;
2973
2974      _check_buffer_pe(pwsi, size);
2975      p_to = (struct ws_protoent*)pwsi->pe;
2976      p = (char*)pwsi->pe;
2977      p_base = (flag & WS_DUP_OFFSET) ? NULL
2978                                      : ((flag & WS_DUP_SEGPTR) ? (char*)SEGPTR_GET(p) : p);
2979      p += sizeof(struct ws_protoent);
2980      p_name = p;
2981      strcpy(p, p_pe->p_name); p += strlen(p) + 1;
2982      p_aliases = p;
2983      list_dup(p_pe->p_aliases, p, p_base + (p - (char*)pwsi->pe), 0);
2984
2985      p_to->p_proto = (INT16)p_pe->p_proto;
2986      p_to->p_name = (SEGPTR)(p_base) + (p_name - (char*)pwsi->pe);
2987      p_to->p_aliases = (SEGPTR)((p_base) + (p_aliases - (char*)pwsi->pe));
2988
2989      size += (sizeof(struct ws_protoent) - sizeof(struct protoent));
2990    }
2991    return size;
2992 }
2993
2994 /* ----- servent */
2995
2996 static int servent_size(struct servent* p_se)
2997 {
2998   int size = 0;
2999   if( p_se )
3000   { size += sizeof(struct servent);
3001     size += strlen(p_se->s_proto) + strlen(p_se->s_name) + 2;
3002     size += list_size(p_se->s_aliases, 0); }
3003   return size;
3004 }
3005
3006 int WS_dup_se(LPWSINFO pwsi, struct servent* p_se, int flag)
3007 {
3008    int size = servent_size(p_se);
3009    if( size )
3010    {
3011      struct ws_servent* p_to;
3012      char* p_name,*p_aliases,*p_proto,*p_base,*p;
3013
3014      _check_buffer_se(pwsi, size);
3015      p_to = (struct ws_servent*)pwsi->se;
3016      p = (char*)pwsi->se;
3017      p_base = (flag & WS_DUP_OFFSET) ? NULL
3018                                      : ((flag & WS_DUP_SEGPTR) ? (char*)SEGPTR_GET(p) : p);
3019      p += sizeof(struct ws_servent);
3020      p_name = p;
3021      strcpy(p, p_se->s_name); p += strlen(p) + 1;
3022      p_proto = p;
3023      strcpy(p, p_se->s_proto); p += strlen(p) + 1;
3024      p_aliases = p;
3025      list_dup(p_se->s_aliases, p, p_base + (p - (char*)pwsi->se), 0);
3026
3027      p_to->s_port = (INT16)p_se->s_port;
3028      p_to->s_name = (SEGPTR)(p_base + (p_name - (char*)pwsi->se));
3029      p_to->s_proto = (SEGPTR)(p_base + (p_proto - (char*)pwsi->se));
3030      p_to->s_aliases = (SEGPTR)(p_base + (p_aliases - (char*)pwsi->se));
3031
3032      size += (sizeof(struct ws_servent) - sizeof(struct servent));
3033    }
3034    return size;
3035 }
3036
3037 /* ----------------------------------- error handling */
3038
3039 UINT16 wsaErrno(void)
3040 {
3041     int loc_errno = errno;
3042 #ifdef HAVE_STRERROR
3043     WARN("errno %d, (%s).\n", loc_errno, strerror(loc_errno));
3044 #else
3045     WARN("errno %d\n", loc_errno);
3046 #endif
3047
3048     switch(loc_errno)
3049     {
3050         case EINTR:             return WSAEINTR;
3051         case EBADF:             return WSAEBADF;
3052         case EPERM:
3053         case EACCES:            return WSAEACCES;
3054         case EFAULT:            return WSAEFAULT;
3055         case EINVAL:            return WSAEINVAL;
3056         case EMFILE:            return WSAEMFILE;
3057         case EWOULDBLOCK:       return WSAEWOULDBLOCK;
3058         case EINPROGRESS:       return WSAEINPROGRESS;
3059         case EALREADY:          return WSAEALREADY;
3060         case ENOTSOCK:          return WSAENOTSOCK;
3061         case EDESTADDRREQ:      return WSAEDESTADDRREQ;
3062         case EMSGSIZE:          return WSAEMSGSIZE;
3063         case EPROTOTYPE:        return WSAEPROTOTYPE;
3064         case ENOPROTOOPT:       return WSAENOPROTOOPT;
3065         case EPROTONOSUPPORT:   return WSAEPROTONOSUPPORT;
3066         case ESOCKTNOSUPPORT:   return WSAESOCKTNOSUPPORT;
3067         case EOPNOTSUPP:        return WSAEOPNOTSUPP;
3068         case EPFNOSUPPORT:      return WSAEPFNOSUPPORT;
3069         case EAFNOSUPPORT:      return WSAEAFNOSUPPORT;
3070         case EADDRINUSE:        return WSAEADDRINUSE;
3071         case EADDRNOTAVAIL:     return WSAEADDRNOTAVAIL;
3072         case ENETDOWN:          return WSAENETDOWN;
3073         case ENETUNREACH:       return WSAENETUNREACH;
3074         case ENETRESET:         return WSAENETRESET;
3075         case ECONNABORTED:      return WSAECONNABORTED;
3076         case EPIPE:
3077         case ECONNRESET:        return WSAECONNRESET;
3078         case ENOBUFS:           return WSAENOBUFS;
3079         case EISCONN:           return WSAEISCONN;
3080         case ENOTCONN:          return WSAENOTCONN;
3081         case ESHUTDOWN:         return WSAESHUTDOWN;
3082         case ETOOMANYREFS:      return WSAETOOMANYREFS;
3083         case ETIMEDOUT:         return WSAETIMEDOUT;
3084         case ECONNREFUSED:      return WSAECONNREFUSED;
3085         case ELOOP:             return WSAELOOP;
3086         case ENAMETOOLONG:      return WSAENAMETOOLONG;
3087         case EHOSTDOWN:         return WSAEHOSTDOWN;
3088         case EHOSTUNREACH:      return WSAEHOSTUNREACH;
3089         case ENOTEMPTY:         return WSAENOTEMPTY;
3090 #ifdef EPROCLIM
3091         case EPROCLIM:          return WSAEPROCLIM;
3092 #endif
3093 #ifdef EUSERS
3094         case EUSERS:            return WSAEUSERS;
3095 #endif
3096 #ifdef EDQUOT
3097         case EDQUOT:            return WSAEDQUOT;
3098 #endif
3099 #ifdef ESTALE
3100         case ESTALE:            return WSAESTALE;
3101 #endif
3102 #ifdef EREMOTE
3103         case EREMOTE:           return WSAEREMOTE;
3104 #endif
3105
3106        /* just in case we ever get here and there are no problems */
3107         case 0:                 return 0;
3108         default:
3109                 WARN("Unknown errno %d!\n", loc_errno);
3110                 return WSAEOPNOTSUPP;
3111     }
3112 }
3113
3114 UINT16 wsaHerrno(void)
3115 {
3116     int         loc_errno = h_errno;
3117
3118     WARN("h_errno %d.\n", loc_errno);
3119
3120     switch(loc_errno)
3121     {
3122         case HOST_NOT_FOUND:    return WSAHOST_NOT_FOUND;
3123         case TRY_AGAIN:         return WSATRY_AGAIN;
3124         case NO_RECOVERY:       return WSANO_RECOVERY;
3125         case NO_DATA:           return WSANO_DATA;
3126
3127         case 0:                 return 0;
3128         default:
3129                 WARN("Unknown h_errno %d!\n", loc_errno);
3130                 return WSAEOPNOTSUPP;
3131     }
3132 }