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