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