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

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