git.oblomov.eu Git - wine/blob - misc/winsock.c

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