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

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