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