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