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 John Brezak, Erik Bos, Alex Korobka.
   6  */
   7
   8 #include <stdio.h>
   9 #include <string.h>
  10 #include <signal.h>
  11 #include <sys/types.h>
  12 #include <sys/ipc.h>
  13 #include <sys/ioctl.h>
  14 #if defined(__svr4__)
  15 #include <sys/filio.h>
  16 #include <sys/ioccom.h>
  17 #endif
  18 #include <sys/msg.h>
  19 #include <sys/wait.h>
  20 #include <sys/socket.h>
  21 #include <netinet/in.h>
  22 #include <arpa/inet.h>
  23 #include <fcntl.h>
  24 #include <errno.h>
  25 #include <netdb.h>
  26 #include <unistd.h>
  27
  28 #include "windows.h"
  29 #include "winnt.h"
  30 #include "heap.h"
  31 #include "ldt.h"
  32 #include "winsock.h"
  33 #include "stddebug.h"
  34 #include "debug.h"
  35
  36 #define dump_sockaddr(a) \
  37         fprintf(stderr, "sockaddr_in: family %d, address %s, port %d\n", \
  38                         ((struct sockaddr_in *)a)->sin_family, \
  39                         inet_ntoa(((struct sockaddr_in *)a)->sin_addr), \
  40                         ntohs(((struct sockaddr_in *)a)->sin_port))
  41
  42 extern void SIGNAL_MaskAsyncEvents( BOOL32 );
  43
  44 #pragma pack(4)
  45
  46 /* ----------------------------------- internal data */
  47
  48 extern int h_errno;
  49 extern void __sigio(int);
  50
  51 ws_async_ctl            async_ctl;
  52 int                     async_qid = -1;
  53
  54 static HANDLE32         _WSHeap = 0;
  55 static unsigned char*   _ws_stub = NULL;
  56 static LPWSINFO         _wsi_list = NULL;
  57
  58 #define WS_ALLOC(size) \
  59         HeapAlloc(_WSHeap, HEAP_ZERO_MEMORY, (size) )
  60 #define WS_FREE(ptr) \
  61         HeapFree(_WSHeap, 0, (ptr) )
  62
  63 #define WS_PTR2HANDLE(ptr) \
  64         ((short)((int)(ptr) - (int)_ws_stub))
  65 #define WS_HANDLE2PTR(handle) \
  66         ((unsigned)((int)_ws_stub + (int)handle))
  67
  68 #define WSI_CHECK_RANGE(pwsi, pws) \
  69         ( ((unsigned)(pws) > (unsigned)(pwsi)) && \
  70           ((unsigned)(pws) < ((unsigned)(pwsi) + sizeof(WSINFO))) )
  71
  72 static INT16         _ws_sock_ops[] =
  73        { WS_SO_DEBUG, WS_SO_REUSEADDR, WS_SO_KEEPALIVE, WS_SO_DONTROUTE,
  74          WS_SO_BROADCAST, WS_SO_LINGER, WS_SO_OOBINLINE, WS_SO_SNDBUF,
  75          WS_SO_RCVBUF, WS_SO_ERROR, WS_SO_TYPE, WS_SO_DONTLINGER, 0 };
  76 static int           _px_sock_ops[] =
  77        { SO_DEBUG, SO_REUSEADDR, SO_KEEPALIVE, SO_DONTROUTE, SO_BROADCAST,
  78          SO_LINGER, SO_OOBINLINE, SO_SNDBUF, SO_RCVBUF, SO_ERROR, SO_TYPE,
  79          SO_LINGER };
  80
  81 static INT16 init_async_select(ws_socket* pws, HWND16 hWnd, UINT16 uMsg, UINT32 lEvent);
  82 static int notify_client(ws_socket* pws, unsigned flag);
  83
  84 static int _check_ws(LPWSINFO pwsi, ws_socket* pws);
  85 static int _check_buffer(LPWSINFO pwsi, int size);
  86
  87 static void fixup_wshe(struct ws_hostent* p_wshe, SEGPTR base);
  88 static void fixup_wspe(struct ws_protoent* p_wspe, SEGPTR base);
  89 static void fixup_wsse(struct ws_servent* p_wsse, SEGPTR base);
  90
  91 static int cancel_async_select(ws_socket*);
  92
  93 static void convert_sockopt(INT16 *level, INT16 *optname)
  94 {
  95   int           i;
  96   switch (*level)
  97   {
  98      case WS_SOL_SOCKET:
  99         *level = SOL_SOCKET;
 100         for(i=0; _ws_sock_ops[i]; i++)
 101             if( _ws_sock_ops[i] == *optname ) break;
 102         if( _ws_sock_ops[i] ) *optname = (INT16)_px_sock_ops[i];
 103         else fprintf(stderr, "convert_sockopt() unknown optname %d\n", *optname);
 104         break;
 105      case WS_IPPROTO_TCP:
 106         *optname = IPPROTO_TCP;
 107   }
 108 }
 109
 110 static void _ws_global_init()
 111 {
 112    if( !_ws_stub )
 113    {
 114      _WSHeap = HeapCreate(HEAP_ZERO_MEMORY, 8120, 32768);
 115      if( !(_ws_stub = WS_ALLOC(0x10)) )
 116        fprintf(stderr,"Fatal: failed to create WinSock heap\n");
 117    }
 118    if( async_qid == -1 )
 119      if( (async_qid = msgget(IPC_PRIVATE, IPC_CREAT | 0x1FF)) == -1 )
 120        fprintf(stderr,"Fatal: failed to create WinSock resource\n");
 121 }
 122
 123 /* ----------------------------------- Per-thread info */
 124
 125 static void wsi_link(LPWSINFO pwsi)
 126 { if( _wsi_list ) _wsi_list->prev = pwsi;
 127   pwsi->next = _wsi_list; _wsi_list = pwsi;
 128 }
 129
 130 static void wsi_unlink(LPWSINFO pwsi)
 131 {
 132   if( pwsi == _wsi_list ) _wsi_list = pwsi->next;
 133   else
 134   { pwsi->prev->next = pwsi->next;
 135     if( pwsi->next ) pwsi->next->prev = pwsi->prev; }
 136 }
 137
 138 static LPWSINFO wsi_find(HTASK16 hTask)
 139 { LPWSINFO pwsi = _wsi_list;
 140   while( pwsi && pwsi->tid != hTask ) pwsi = pwsi->next;
 141   return pwsi;
 142 }
 143
 144 static ws_socket* wsi_alloc_socket(LPWSINFO pwsi, int fd)
 145 {
 146   if( pwsi->last_free >= 0 )
 147   {
 148     int i = pwsi->last_free;
 149
 150     pwsi->last_free = pwsi->sock[i].flags;
 151     pwsi->sock[i].fd = fd;
 152     pwsi->sock[i].flags = 0;
 153     return &pwsi->sock[i];
 154   }
 155   return NULL;
 156 }
 157
 158 static void fd_set_normalize(fd_set* fds, LPWSINFO pwsi, ws_fd_set* ws, int* highfd)
 159 {
 160   FD_ZERO(fds);
 161   if(ws)
 162   {
 163     int         i;
 164     ws_socket*  pws;
 165     for(i=0;i<(ws->fd_count);i++)
 166     {
 167       pws = (ws_socket*)WS_HANDLE2PTR(ws->fd_array[i]);
 168       if( _check_ws(pwsi, pws) )
 169       {
 170         if( pws->fd > *highfd ) *highfd = pws->fd;
 171         FD_SET(pws->fd, fds);
 172       }
 173     }
 174   }
 175 }
 176
 177 /*
 178  * Note weirdness here: sockets with errors belong in exceptfds, but
 179  * are given to us in readfds or writefds, so move them to exceptfds if
 180  * there is an error. Note that this means that exceptfds may have mysterious
 181  * sockets set in it that the program never asked for.
 182  */
 183
 184 static int inline sock_error_p(int s)
 185 {
 186     unsigned int optval, optlen;
 187
 188     optlen = sizeof(optval);
 189     getsockopt(s, SOL_SOCKET, SO_ERROR, &optval, &optlen);
 190     if (optval) dprintf_winsock(stddeb, "error: %d\n", optval);
 191     return optval != 0;
 192 }
 193
 194 static void fd_set_update(LPWSINFO pwsi, fd_set* fds, ws_fd_set* ws,
 195                           fd_set *errorfds)
 196 {
 197     if( ws )
 198     {
 199         int i, j, count = ws->fd_count;
 200
 201         for( i = 0, j = 0; i < count; i++ )
 202         {
 203             ws_socket *pws = (ws_socket*)WS_HANDLE2PTR(ws->fd_array[i]);
 204             int fd = pws->fd;
 205
 206             if( _check_ws(pwsi, pws) && FD_ISSET(fd, fds) )
 207             {
 208                 /* if error, move to errorfds */
 209                 if (errorfds && (FD_ISSET(fd, errorfds) || sock_error_p(fd)))
 210                     FD_SET(fd, errorfds);
 211                 else
 212                     ws->fd_array[j++] = ws->fd_array[i];
 213             }
 214         }
 215         ws->fd_count = j;
 216         dprintf_winsock(stddeb, "\n");
 217     }
 218     return;
 219 }
 220
 221 static void fd_set_update_except(LPWSINFO pwsi, fd_set *fds, ws_fd_set *ws,
 222                                  fd_set *errorfds)
 223 {
 224     if (ws)
 225     {
 226         int i, j, count = ws->fd_count;
 227
 228         for (i=j=0; i < count; i++)
 229         {
 230             ws_socket *pws = (ws_socket *)WS_HANDLE2PTR(ws->fd_array[i]);
 231
 232             if (_check_ws(pwsi, pws) && (FD_ISSET(pws->fd, fds)
 233                                          || FD_ISSET(pws->fd, errorfds)))
 234             ws->fd_array[j++] = ws->fd_array[i];
 235         }
 236         ws->fd_count = j;
 237     }
 238     return;
 239 }
 240
 241 /* ----------------------------------- API -----
 242  *
 243  * Init / cleanup / error checking.
 244  */
 245
 246 INT16 WSAStartup(UINT16 wVersionRequested, LPWSADATA lpWSAData)
 247 {
 248   WSADATA WINSOCK_data = { 0x0101, 0x0101,
 249                           "WINE Sockets 1.1",
 250                         #ifdef linux
 251                                 "Linux/i386",
 252                         #elif defined(__NetBSD__)
 253                                 "NetBSD/i386",
 254                         #elif defined(sunos)
 255                                 "SunOS",
 256                         #elif defined(__FreeBSD__)
 257                                 "FreeBSD",
 258                         #else
 259                                 "Unknown",
 260                         #endif
 261                            WS_MAX_SOCKETS_PER_THREAD,
 262                            WS_MAX_UDP_DATAGRAM, NULL };
 263   HTASK16               tid = GetCurrentTask();
 264   LPWSINFO              pwsi;
 265
 266   dprintf_winsock(stddeb, "WSAStartup: verReq=%x\n", wVersionRequested);
 267
 268   if (LOBYTE(wVersionRequested) < 1 || (LOBYTE(wVersionRequested) == 1 &&
 269       HIBYTE(wVersionRequested) < 1)) return WSAVERNOTSUPPORTED;
 270
 271   if (!lpWSAData) return WSAEINVAL;
 272
 273   _ws_global_init();
 274   if( _WSHeap == 0 ) return WSASYSNOTREADY;
 275
 276   pwsi = wsi_find(GetCurrentTask());
 277   if( pwsi == NULL )
 278   {
 279     if( (pwsi = (LPWSINFO)WS_ALLOC( sizeof(WSINFO))) )
 280     {
 281       int i = 0;
 282       pwsi->tid = tid;
 283       for( i = 0; i < WS_MAX_SOCKETS_PER_THREAD; i++ )
 284       {
 285         pwsi->sock[i].fd = -1;
 286         pwsi->sock[i].flags = i + 1;
 287       }
 288       pwsi->sock[WS_MAX_SOCKETS_PER_THREAD - 1].flags = -1;
 289     }
 290     else return WSASYSNOTREADY;
 291     wsi_link(pwsi);
 292   } else pwsi->num_startup++;
 293
 294   /* return winsock information */
 295   memcpy(lpWSAData, &WINSOCK_data, sizeof(WINSOCK_data));
 296
 297   dprintf_winsock(stddeb, "WSAStartup: succeeded\n");
 298   return(0);
 299 }
 300
 301 void WINSOCK_Shutdown()
 302 {
 303   if( async_qid != -1 )
 304     if( msgctl(async_qid, IPC_RMID, NULL) == -1 )
 305           fprintf(stderr,"failed to delete WS message queue.\n");
 306     else async_qid = -1;
 307 }
 308
 309 INT16 WSACleanup(void)
 310 {
 311   LPWSINFO      pwsi = wsi_find(GetCurrentTask());
 312
 313   /* FIXME: do global cleanup if no current task */
 314
 315   dprintf_winsock(stddeb, "WSACleanup(%08x)\n", (unsigned)pwsi);
 316   if( pwsi )
 317   {
 318       int       i, j, n;
 319
 320       if( pwsi->num_startup-- ) return 0;
 321
 322       SIGNAL_MaskAsyncEvents( TRUE );
 323       WINSOCK_cancel_async_op(GetCurrentTask());
 324       SIGNAL_MaskAsyncEvents( FALSE );
 325
 326       wsi_unlink(pwsi);
 327       if( _wsi_list == NULL ) WINSOCK_Shutdown();
 328
 329       if( pwsi->flags & WSI_BLOCKINGCALL )
 330           dprintf_winsock(stddeb,"\tinside blocking call!\n");
 331       if( pwsi->num_async_rq )
 332           dprintf_winsock(stddeb,"\thave %i outstanding async ops!\n", pwsi->num_async_rq );
 333
 334       for(i = 0, j = 0, n = 0; i < WS_MAX_SOCKETS_PER_THREAD; i++)
 335         if( pwsi->sock[i].fd != -1 )
 336         {
 337           n += cancel_async_select(&pwsi->sock[i]);
 338           close(pwsi->sock[i].fd); j++;
 339         }
 340       if( j )
 341           dprintf_winsock(stddeb,"\tclosed %i sockets, killed %i async selects!\n", j, n);
 342
 343       if( pwsi->buffer ) SEGPTR_FREE(pwsi->buffer);
 344       if( pwsi->dbuffer ) SEGPTR_FREE(pwsi->dbuffer);
 345       WS_FREE(pwsi);
 346       return 0;
 347   }
 348   return SOCKET_ERROR;
 349 }
 350
 351 INT16 WSAGetLastError(void)
 352 {
 353   LPWSINFO      pwsi = wsi_find(GetCurrentTask());
 354   INT16         ret;
 355
 356   dprintf_winsock(stddeb, "WSAGetLastError(%08x)", (unsigned)pwsi);
 357
 358   ret = (pwsi) ? pwsi->errno : WSANOTINITIALISED;
 359
 360   dprintf_winsock(stddeb, " = %i\n", (int)ret);
 361   return ret;
 362 }
 363
 364 void WSASetLastError(INT16 iError)
 365 {
 366   LPWSINFO      pwsi = wsi_find(GetCurrentTask());
 367
 368   dprintf_winsock(stddeb, "WSASetLastError(%08x): %d\n", (unsigned)pwsi, (int)iError);
 369
 370   if( pwsi ) pwsi->errno = iError;
 371 }
 372
 373 int _check_ws(LPWSINFO pwsi, ws_socket* pws)
 374 {
 375   if( pwsi )
 376     if( pwsi->flags & WSI_BLOCKINGCALL ) pwsi->errno = WSAEINPROGRESS;
 377     else if( WSI_CHECK_RANGE(pwsi, pws) ) return 1;
 378     else pwsi->errno = WSAENOTSOCK;
 379   return 0;
 380 }
 381
 382 int _check_buffer(LPWSINFO pwsi, int size)
 383 {
 384   if( pwsi->buffer && pwsi->buflen >= size ) return 1;
 385   else SEGPTR_FREE(pwsi->buffer);
 386   pwsi->buffer = (char*)SEGPTR_ALLOC((pwsi->buflen = size));
 387   return (pwsi->buffer != NULL);
 388 }
 389
 390 /* ----- socket operations */
 391
 392 SOCKET16 WINSOCK_accept(SOCKET16 s, struct sockaddr *addr, INT16 *addrlen16)
 393 {
 394   ws_socket*    pws  = (ws_socket*)WS_HANDLE2PTR(s);
 395   LPWSINFO      pwsi = wsi_find(GetCurrentTask());
 396
 397   dprintf_winsock(stddeb, "WS_ACCEPT(%08x): socket %04x\n",
 398                                    (unsigned)pwsi, (UINT16)s);
 399   if( _check_ws(pwsi, pws) )
 400   {
 401      int        sock, fd_flags, addrlen32 = *addrlen16;
 402
 403      /* this is how block info is supposed to be used -
 404       * WSAIsBlocking() would then check WSI_BLOCKINGCALL bit.
 405       */
 406
 407      fd_flags = fcntl(pws->fd, F_GETFL, 0);
 408      if( !(fd_flags & O_NONBLOCK) ) pwsi->flags |= WSI_BLOCKINGCALL;
 409
 410      if( (sock = accept(pws->fd, addr, &addrlen32)) >= 0 )
 411      {
 412         ws_socket*      pnew = wsi_alloc_socket(pwsi, sock);
 413         notify_client(pws, WS_FD_ACCEPT);
 414         if( pnew )
 415         {
 416           if( pws->p_aop )
 417               init_async_select(pnew, pws->p_aop->hWnd,
 418                                       pws->p_aop->uMsg,
 419                                       pws->p_aop->flags & ~WS_FD_ACCEPT );
 420
 421           pwsi->flags &= ~WSI_BLOCKINGCALL;
 422           return (SOCKET16)WS_PTR2HANDLE(pnew);
 423         }
 424         else pwsi->errno = WSAENOBUFS;
 425      }
 426      else pwsi->errno = wsaErrno();
 427
 428      pwsi->flags &= ~WSI_BLOCKINGCALL;
 429   }
 430   return INVALID_SOCKET;
 431 }
 432
 433 INT16 WINSOCK_bind(SOCKET16 s, struct sockaddr *name, INT16 namelen)
 434 {
 435   ws_socket*    pws  = (ws_socket*)WS_HANDLE2PTR(s);
 436   LPWSINFO      pwsi = wsi_find(GetCurrentTask());
 437
 438   dprintf_winsock(stddeb, "WS_BIND(%08x): socket %04x, ptr %8x, length %d\n",
 439                            (unsigned)pwsi, s, (int) name, namelen);
 440 #if 0
 441   dump_sockaddr(name);
 442 #endif
 443
 444   if ( _check_ws(pwsi, pws) )
 445     if (namelen >= sizeof(*name))
 446        if ( ((struct sockaddr_in *)name)->sin_family == AF_INET )
 447           if ( bind(pws->fd, name, namelen) < 0 )
 448           {
 449              int        loc_errno = errno;
 450              dprintf_winsock(stddeb,"\tfailure - errno = %i\n", errno);
 451              errno = loc_errno;
 452              switch(errno)
 453              {
 454                 case EBADF: pwsi->errno = WSAENOTSOCK; break;
 455                 case EADDRNOTAVAIL: pwsi->errno = WSAEINVAL; break;
 456                 default: pwsi->errno = wsaErrno();
 457              }
 458           }
 459           else return 0;
 460        else pwsi->errno = WSAEAFNOSUPPORT;
 461     else pwsi->errno = WSAEFAULT;
 462   return SOCKET_ERROR;
 463 }
 464
 465 INT16 WINSOCK_closesocket(SOCKET16 s)
 466 {
 467   ws_socket*    pws  = (ws_socket*)WS_HANDLE2PTR(s);
 468   LPWSINFO      pwsi = wsi_find(GetCurrentTask());
 469
 470   dprintf_winsock(stddeb, "WS_CLOSE(%08x): socket %08x\n", (unsigned)pwsi, s);
 471
 472   if( _check_ws(pwsi, pws) )
 473   {
 474     int         fd = pws->fd;
 475
 476     cancel_async_select(pws);
 477     pws->fd = -1;
 478     pws->flags = (unsigned)pwsi->last_free;
 479     pwsi->last_free = pws - &pwsi->sock[0];
 480     if (close(fd) == 0) return 0;
 481     pwsi->errno = (errno == EBADF) ? WSAENOTSOCK : wsaErrno();
 482   }
 483   return SOCKET_ERROR;
 484 }
 485
 486 INT16 WINSOCK_connect(SOCKET16 s, struct sockaddr *name, INT16 namelen)
 487 {
 488   ws_socket*    pws  = (ws_socket*)WS_HANDLE2PTR(s);
 489   LPWSINFO      pwsi = wsi_find(GetCurrentTask());
 490
 491   dprintf_winsock(stddeb, "WS_CONNECT(%08x): socket %04x, ptr %8x, length %d\n",
 492                            (unsigned)pwsi, s, (int) name, namelen);
 493 #if 0
 494   dump_sockaddr(name);
 495 #endif
 496
 497   if( _check_ws(pwsi, pws) )
 498   {
 499     if (connect(pws->fd, name, namelen) == 0)
 500     {
 501         if( pws->p_aop )
 502             /* we need to notify handler process if
 503              * connect() succeeded NOT in response to winsock message
 504              */
 505             notify_client(pws, WS_FD_CONNECTED);
 506
 507         pws->flags &= ~(WS_FD_INACTIVE | WS_FD_CONNECT);
 508         return 0;
 509     }
 510     pwsi->errno = (errno == EINPROGRESS) ? WSAEWOULDBLOCK : wsaErrno();
 511   }
 512   return SOCKET_ERROR;
 513 }
 514
 515 INT16 WINSOCK_getpeername(SOCKET16 s, struct sockaddr *name, INT16 *namelen)
 516 {
 517   ws_socket*    pws  = (ws_socket*)WS_HANDLE2PTR(s);
 518   LPWSINFO      pwsi = wsi_find(GetCurrentTask());
 519
 520   dprintf_winsock(stddeb, "WS_GETPEERNAME(%08x): socket: %04x, ptr %8x, ptr %8x\n",
 521                            (unsigned)pwsi, s, (int) name, *namelen);
 522   if( _check_ws(pwsi, pws) )
 523   {
 524     int namelen32 = *namelen;
 525     if (getpeername(pws->fd, name, &namelen32) == 0)
 526     {
 527 #if 0
 528         dump_sockaddr(name);
 529 #endif
 530        *namelen = (INT16)namelen32;
 531         return 0;
 532     }
 533     pwsi->errno = (h_errno < 0) ? wsaErrno() : wsaHerrno();
 534   }
 535   return SOCKET_ERROR;
 536 }
 537
 538 INT16 WINSOCK_getsockname(SOCKET16 s, struct sockaddr *name, INT16 *namelen)
 539 {
 540   ws_socket*    pws  = (ws_socket*)WS_HANDLE2PTR(s);
 541   LPWSINFO      pwsi = wsi_find(GetCurrentTask());
 542
 543   dprintf_winsock(stddeb, "WS_GETSOCKNAME(%08x): socket: %04x, ptr %8x, ptr %8x\n",
 544                           (unsigned)pwsi, s, (int) name, (int) *namelen);
 545   if( _check_ws(pwsi, pws) )
 546   {
 547     int namelen32 = *namelen;
 548     if (getsockname(pws->fd, name, &namelen32) == 0)
 549     {
 550         *namelen = (INT16)namelen32;
 551          return 0;
 552     }
 553     pwsi->errno = (h_errno < 0) ? wsaErrno() : wsaHerrno();
 554   }
 555   return SOCKET_ERROR;
 556 }
 557
 558 INT16 WINSOCK_getsockopt(SOCKET16 s, INT16 level,
 559                          INT16 optname, char *optval, INT16 *optlen)
 560 {
 561   ws_socket*    pws  = (ws_socket*)WS_HANDLE2PTR(s);
 562   LPWSINFO      pwsi = wsi_find(GetCurrentTask());
 563
 564   dprintf_winsock(stddeb, "WS_GETSOCKOPT(%08x): socket: %04x, opt %d, ptr %8x, ptr %8x\n",
 565                            (unsigned)pwsi, s, level, (int) optval, (int) *optlen);
 566
 567   if( _check_ws(pwsi, pws) )
 568   {
 569      int        optlen32 = *optlen;
 570
 571      convert_sockopt(&level, &optname);
 572      if (getsockopt(pws->fd, (int) level, optname, optval, &optlen32) == 0 )
 573      { *optlen = (INT16)optlen32; return 0; }
 574      pwsi->errno = (errno == EBADF) ? WSAENOTSOCK : wsaErrno();
 575   }
 576   return SOCKET_ERROR;
 577 }
 578
 579 u_long  WINSOCK_htonl(u_long hostlong)   { return( htonl(hostlong) ); }
 580 u_short WINSOCK_htons(u_short hostshort) { return( htons(hostshort) ); }
 581 u_long  WINSOCK_inet_addr(char *cp)      { return( inet_addr(cp) ); }
 582 u_long  WINSOCK_ntohl(u_long netlong)    { return( ntohl(netlong) ); }
 583 u_short WINSOCK_ntohs(u_short netshort)  { return( ntohs(netshort) ); }
 584
 585 SEGPTR WINSOCK_inet_ntoa(struct in_addr in)
 586 {
 587   /* use "buffer for dummies" here because some applications have
 588    * propensity to decode addresses in ws_hostent structure without
 589    * saving them first...
 590    */
 591
 592   LPWSINFO      pwsi = wsi_find(GetCurrentTask());
 593
 594   if( pwsi )
 595   {
 596     char*       s = inet_ntoa(in);
 597     if( s )
 598     {
 599         if( pwsi->dbuffer == NULL )
 600             if((pwsi->dbuffer = (char*) SEGPTR_ALLOC(32)) == NULL )
 601             {
 602                 pwsi->errno = WSAENOBUFS;
 603                 return (SEGPTR)NULL;
 604             }
 605         strncpy(pwsi->dbuffer, s, 32 );
 606         return SEGPTR_GET(pwsi->dbuffer);
 607     }
 608     pwsi->errno = wsaErrno();
 609   }
 610   return (SEGPTR)NULL;
 611 }
 612
 613 INT16 WINSOCK_ioctlsocket(SOCKET16 s, UINT32 cmd, UINT32 *argp)
 614 {
 615   ws_socket*    pws  = (ws_socket*)WS_HANDLE2PTR(s);
 616   LPWSINFO      pwsi = wsi_find(GetCurrentTask());
 617
 618   dprintf_winsock(stddeb, "WS_IOCTL(%08x): socket %04x, cmd %08x, ptr %8x\n",
 619                           (unsigned)pwsi, s, cmd, (unsigned) argp);
 620   if( _check_ws(pwsi, pws) )
 621   {
 622     long        newcmd  = cmd;
 623
 624     switch( cmd )
 625     {
 626         case WS_FIONREAD:   newcmd=FIONREAD; break;
 627         case WS_FIONBIO:    newcmd=FIONBIO;
 628                             if( pws->p_aop && *argp == 0 )
 629                             {
 630                                 pwsi->errno = WSAEINVAL;
 631                                 return SOCKET_ERROR;
 632                             }
 633                             break;
 634         case WS_SIOCATMARK: newcmd=SIOCATMARK; break;
 635         case WS_IOW('f',125,u_long):
 636                           fprintf(stderr,"Warning: WS1.1 shouldn't be using async I/O\n");
 637                           pwsi->errno = WSAEINVAL; return SOCKET_ERROR;
 638         default:          fprintf(stderr,"Warning: Unknown WS_IOCTL cmd (%08x)\n", cmd);
 639     }
 640     if( ioctl(pws->fd, newcmd, (char*)argp ) == 0 ) return 0;
 641     pwsi->errno = (errno == EBADF) ? WSAENOTSOCK : wsaErrno();
 642   }
 643   return SOCKET_ERROR;
 644 }
 645
 646 INT16 WINSOCK_listen(SOCKET16 s, INT16 backlog)
 647 {
 648   ws_socket*    pws  = (ws_socket*)WS_HANDLE2PTR(s);
 649   LPWSINFO      pwsi = wsi_find(GetCurrentTask());
 650
 651   dprintf_winsock(stddeb, "WS_LISTEN(%08x): socket %04x, backlog %d\n",
 652                           (unsigned)pwsi, s, backlog);
 653   if( _check_ws(pwsi, pws) )
 654   {
 655     if( !pws->p_aop )
 656     {
 657       int  fd_flags = fcntl(pws->fd, F_GETFL, 0);
 658       if( !(fd_flags & O_NONBLOCK) ) pws->flags |= WS_FD_ACCEPT;
 659     }
 660     else notify_client(pws, WS_FD_ACCEPT);
 661
 662     if (listen(pws->fd, backlog) == 0) return 0;
 663     pwsi->errno = wsaErrno();
 664   }
 665   return SOCKET_ERROR;
 666 }
 667
 668 INT16 WINSOCK_recv(SOCKET16 s, char *buf, INT16 len, INT16 flags)
 669 {
 670   ws_socket*    pws  = (ws_socket*)WS_HANDLE2PTR(s);
 671   LPWSINFO      pwsi = wsi_find(GetCurrentTask());
 672
 673   dprintf_winsock(stddeb, "WS_RECV(%08x): socket %04x, buf %8x, len %d, flags %d",
 674                           (unsigned)pwsi, s, (unsigned)buf, len, flags);
 675   if( _check_ws(pwsi, pws) )
 676   {
 677     int length;
 678     if ((length = recv(pws->fd, buf, len, flags)) >= 0)
 679     {
 680         dprintf_winsock(stddeb, " -> %i bytes\n", length);
 681         notify_client(pws, WS_FD_READ);
 682         return (INT16)length;
 683     }
 684     pwsi->errno = wsaErrno();
 685   }
 686   dprintf_winsock(stddeb, " -> ERROR\n");
 687   return SOCKET_ERROR;
 688 }
 689
 690 INT16 WINSOCK_recvfrom(SOCKET16 s, char *buf, INT16 len, INT16 flags,
 691                 struct sockaddr *from, INT16 *fromlen16)
 692 {
 693   ws_socket*    pws  = (ws_socket*)WS_HANDLE2PTR(s);
 694   LPWSINFO      pwsi = wsi_find(GetCurrentTask());
 695
 696   dprintf_winsock(stddeb, "WS_RECVFROM(%08x): socket %04x, ptr %08x, len %d, flags %d\n",
 697                           (unsigned)pwsi, s, (unsigned)buf, len, flags);
 698   if( _check_ws(pwsi, pws) )
 699   {
 700     int length, fromlen32 = *fromlen16;
 701
 702     if ((length = recvfrom(pws->fd, buf, len, flags, from, &fromlen32)) >= 0 );
 703     {
 704       *fromlen16 = fromlen32;
 705        notify_client(pws, WS_FD_READ);
 706        return (INT16)length;
 707     }
 708     pwsi->errno = wsaErrno();
 709   }
 710   return SOCKET_ERROR;
 711 }
 712
 713 INT16 WINSOCK_select(INT16 nfds, ws_fd_set *ws_readfds,
 714                                  ws_fd_set *ws_writefds,
 715                                  ws_fd_set *ws_exceptfds, struct timeval *timeout)
 716 {
 717   LPWSINFO      pwsi = wsi_find(GetCurrentTask());
 718
 719   dprintf_winsock(stddeb, "WS_SELECT(%08x): nfds %d (ignored), read %8x, write %8x, excp %8x\n",
 720           (unsigned) pwsi, nfds, (unsigned) ws_readfds, (unsigned) ws_writefds, (unsigned) ws_exceptfds);
 721
 722   if( pwsi )
 723   {
 724      int         highfd = 0;
 725      fd_set      readfds, writefds, exceptfds, errorfds;
 726
 727      fd_set_normalize(&readfds, pwsi, ws_readfds, &highfd);
 728      fd_set_normalize(&writefds, pwsi, ws_writefds, &highfd);
 729      fd_set_normalize(&exceptfds, pwsi, ws_exceptfds, &highfd);
 730      FD_ZERO(&errorfds);
 731
 732      if( (highfd = select(highfd + 1, &readfds, &writefds, &exceptfds, timeout)) >= 0 )
 733      {
 734           if( highfd )
 735           {
 736             fd_set_update(pwsi, &readfds, ws_readfds, &errorfds);
 737             fd_set_update(pwsi, &writefds, ws_writefds, &errorfds);
 738             fd_set_update_except(pwsi, &exceptfds, ws_exceptfds, &errorfds);
 739           }
 740           return highfd;
 741      }
 742      pwsi->errno = wsaErrno();
 743   }
 744   return SOCKET_ERROR;
 745 }
 746
 747 INT16 WINSOCK_send(SOCKET16 s, char *buf, INT16 len, INT16 flags)
 748 {
 749   ws_socket*    pws  = (ws_socket*)WS_HANDLE2PTR(s);
 750   LPWSINFO      pwsi = wsi_find(GetCurrentTask());
 751
 752   dprintf_winsock(stddeb, "WS_SEND(%08x): socket %04x, ptr %08x, length %d, flags %d\n",
 753                           (unsigned)pwsi, s, (unsigned) buf, len, flags);
 754   if( _check_ws(pwsi, pws) )
 755   {
 756     int         length;
 757     if ((length = send(pws->fd, buf, len, flags)) < 0 )
 758     {
 759         length = SOCKET_ERROR;
 760         pwsi->errno = wsaErrno();
 761     }
 762     notify_client(pws, WS_FD_WRITE);
 763     return (INT16)length;
 764   }
 765   return SOCKET_ERROR;
 766 }
 767
 768 INT16 WINSOCK_sendto(SOCKET16 s, char *buf, INT16 len, INT16 flags,
 769                      struct sockaddr *to, INT16 tolen)
 770 {
 771   ws_socket*    pws  = (ws_socket*)WS_HANDLE2PTR(s);
 772   LPWSINFO      pwsi = wsi_find(GetCurrentTask());
 773
 774   dprintf_winsock(stddeb, "WS_SENDTO(%08x): socket %04x, ptr %08x, length %d, flags %d\n",
 775                           (unsigned)pwsi, s, (unsigned) buf, len, flags);
 776   if( _check_ws(pwsi, pws) )
 777   {
 778     int         length;
 779
 780     if ((length = sendto(pws->fd, buf, len, flags, to, tolen)) < 0 )
 781     {
 782         length = SOCKET_ERROR;
 783         pwsi->errno = wsaErrno();
 784     }
 785     notify_client(pws, WS_FD_WRITE);
 786     return (INT16)length;
 787   }
 788   return SOCKET_ERROR;
 789 }
 790
 791 INT16 WINSOCK_setsockopt(SOCKET16 s, INT16 level, INT16 optname,
 792                          char *optval, INT16 optlen)
 793 {
 794   ws_socket*    pws  = (ws_socket*)WS_HANDLE2PTR(s);
 795   LPWSINFO      pwsi = wsi_find(GetCurrentTask());
 796
 797   dprintf_winsock(stddeb, "WS_SETSOCKOPT(%08x): socket %04x, level %d, opt %d, ptr %08x, len %d\n",
 798                           (unsigned)pwsi, s, level, optname, (int) optval, optlen);
 799   if( _check_ws(pwsi, pws) )
 800   {
 801     int         linger32[2];
 802     convert_sockopt(&level, &optname);
 803     if( optname == SO_LINGER )
 804     {
 805         INT16*     ptr = (INT16*)optval;
 806         linger32[0] = ptr[0];
 807         linger32[1] = ptr[1];
 808         optval = (char*)&linger32;
 809         optlen = sizeof(linger32);
 810     }
 811     if (setsockopt(pws->fd, level, optname, optval, optlen) == 0) return 0;
 812     pwsi->errno = wsaErrno();
 813   }
 814   return SOCKET_ERROR;
 815 }
 816
 817 INT16 WINSOCK_shutdown(SOCKET16 s, INT16 how)
 818 {
 819   ws_socket*    pws  = (ws_socket*)WS_HANDLE2PTR(s);
 820   LPWSINFO      pwsi = wsi_find(GetCurrentTask());
 821
 822   dprintf_winsock(stddeb, "WS_SHUTDOWN(%08x): socket %04x, how %i\n",
 823                            (unsigned)pwsi, s, how );
 824   if( _check_ws(pwsi, pws) )
 825   {
 826     pws->flags |= WS_FD_INACTIVE;
 827     cancel_async_select(pws);
 828
 829     if (shutdown(pws->fd, how) == 0) return 0;
 830     pwsi->errno = wsaErrno();
 831   }
 832   return SOCKET_ERROR;
 833 }
 834
 835 SOCKET16 WINSOCK_socket(INT16 af, INT16 type, INT16 protocol)
 836 {
 837   LPWSINFO      pwsi = wsi_find(GetCurrentTask());
 838
 839   dprintf_winsock(stddeb, "WS_SOCKET(%08x): af=%d type=%d protocol=%d\n",
 840                           (unsigned)pwsi, af, type, protocol);
 841
 842   if( pwsi )
 843   {
 844     int         sock;
 845
 846     /* check the socket family */
 847     switch(af)
 848     {
 849         case AF_INET:
 850         case AF_UNSPEC: break;
 851         default:        pwsi->errno = WSAEAFNOSUPPORT; return INVALID_SOCKET;
 852     }
 853
 854     /* check the socket type */
 855     switch(type)
 856     {
 857         case SOCK_STREAM:
 858         case SOCK_DGRAM:
 859         case SOCK_RAW: break;
 860         default:       pwsi->errno = WSAESOCKTNOSUPPORT; return INVALID_SOCKET;
 861     }
 862
 863     /* check the protocol type */
 864     if ( protocol < 0 )  /* don't support negative values */
 865     { pwsi->errno = WSAEPROTONOSUPPORT; return INVALID_SOCKET; }
 866
 867     if ( af == AF_UNSPEC)  /* did they not specify the address family? */
 868         switch(protocol)
 869         {
 870           case IPPROTO_TCP:
 871              if (type == SOCK_STREAM) { af = AF_INET; break; }
 872           case IPPROTO_UDP:
 873              if (type == SOCK_DGRAM)  { af = AF_INET; break; }
 874           default: pwsi->errno = WSAEPROTOTYPE; return INVALID_SOCKET;
 875         }
 876
 877     if ((sock = socket(af, type, protocol)) >= 0)
 878     {
 879         ws_socket*      pnew = wsi_alloc_socket(pwsi, sock);
 880
 881         dprintf_winsock(stddeb,"\tcreated %04x (handle %i)\n", sock, (UINT16)WS_PTR2HANDLE(pnew));
 882
 883         if( pnew ) return (SOCKET16)WS_PTR2HANDLE(pnew);
 884         {
 885           close(sock);
 886           pwsi->errno = WSAENOBUFS;
 887           return INVALID_SOCKET;
 888         }
 889     }
 890
 891     if (errno == EPERM) /* raw socket denied */
 892     {
 893         fprintf(stderr, "WS_SOCKET: not enough privileges\n");
 894         pwsi->errno = WSAESOCKTNOSUPPORT;
 895     } else pwsi->errno = wsaErrno();
 896   }
 897
 898   dprintf_winsock(stddeb, "\t\tfailed!\n");
 899   return INVALID_SOCKET;
 900 }
 901
 902
 903 /* ----- database functions
 904  *
 905  * Note that ws_...ent structures we return have SEGPTR pointers inside them.
 906  */
 907
 908 static char*    NULL_STRING = "NULL";
 909
 910 /*
 911 struct WIN_hostent *
 912 */
 913 SEGPTR WINSOCK_gethostbyaddr(const char *addr, INT16 len, INT16 type)
 914 {
 915   LPWSINFO              pwsi = wsi_find(GetCurrentTask());
 916
 917   dprintf_winsock(stddeb, "WS_GetHostByAddr(%08x): ptr %8x, len %d, type %d\n",
 918                           (unsigned)pwsi, (unsigned) addr, len, type);
 919   if( pwsi )
 920   {
 921     struct hostent*     host;
 922     if( (host = gethostbyaddr(addr, len, type)) != NULL )
 923       if( WS_dup_he(pwsi, host, WS_DUP_SEGPTR) )
 924           return SEGPTR_GET(pwsi->buffer);
 925       else pwsi->errno = WSAENOBUFS;
 926     else pwsi->errno = (h_errno < 0) ? wsaErrno() : wsaHerrno();
 927   }
 928   return NULL;
 929 }
 930
 931 /*
 932 struct WIN_hostent *
 933 */
 934 SEGPTR WINSOCK_gethostbyname(const char *name)
 935 {
 936   LPWSINFO              pwsi = wsi_find(GetCurrentTask());
 937
 938   dprintf_winsock(stddeb, "WS_GetHostByName(%08x): %s\n",
 939                           (unsigned)pwsi, (name)?name:"NULL");
 940   if( pwsi )
 941   {
 942     struct hostent*     host;
 943     if( (host = gethostbyname(name)) != NULL )
 944       if( WS_dup_he(pwsi, host, WS_DUP_SEGPTR) )
 945           return SEGPTR_GET(pwsi->buffer);
 946       else pwsi->errno = WSAENOBUFS;
 947     else pwsi->errno = (h_errno < 0) ? wsaErrno() : wsaHerrno();
 948   }
 949   return NULL;
 950 }
 951
 952 INT16 WINSOCK_gethostname(char *name, INT16 namelen)
 953 {
 954   LPWSINFO              pwsi = wsi_find(GetCurrentTask());
 955
 956   dprintf_winsock(stddeb, "WS_GetHostName(%08x): name %s, len %d\n",
 957                           (unsigned)pwsi, (name)?name:NULL_STRING, namelen);
 958   if( pwsi )
 959   {
 960     if (gethostname(name, namelen) == 0) return 0;
 961     pwsi->errno = (errno == EINVAL) ? WSAEFAULT : wsaErrno();
 962   }
 963   return SOCKET_ERROR;
 964 }
 965
 966 /*
 967 struct WIN_protoent *
 968 */
 969 SEGPTR WINSOCK_getprotobyname(char *name)
 970 {
 971   LPWSINFO              pwsi = wsi_find(GetCurrentTask());
 972
 973   dprintf_winsock(stddeb, "WS_GetProtoByName(%08x): %s\n",
 974                           (unsigned)pwsi, (name)?name:NULL_STRING);
 975   if( pwsi )
 976   {
 977     struct protoent*     proto;
 978     if( (proto = getprotobyname(name)) != NULL )
 979       if( WS_dup_pe(pwsi, proto, WS_DUP_SEGPTR) )
 980           return SEGPTR_GET(pwsi->buffer);
 981       else pwsi->errno = WSAENOBUFS;
 982     else pwsi->errno = (h_errno < 0) ? wsaErrno() : wsaHerrno();
 983   }
 984   return NULL;
 985 }
 986
 987 /*
 988 struct WIN_protoent *
 989 */
 990 SEGPTR WINSOCK_getprotobynumber(INT16 number)
 991 {
 992   LPWSINFO              pwsi = wsi_find(GetCurrentTask());
 993
 994   dprintf_winsock(stddeb, "WS_GetProtoByNumber(%08x): %i\n", (unsigned)pwsi, number);
 995
 996   if( pwsi )
 997   {
 998     struct protoent*     proto;
 999     if( (proto = getprotobynumber(number)) != NULL )
1000       if( WS_dup_pe(pwsi, proto, WS_DUP_SEGPTR) )
1001           return SEGPTR_GET(pwsi->buffer);
1002       else pwsi->errno = WSAENOBUFS;
1003     else pwsi->errno = WSANO_DATA;
1004   }
1005   return NULL;
1006 }
1007
1008 /*
1009 struct WIN_servent *
1010 */
1011 SEGPTR WINSOCK_getservbyname(const char *name, const char *proto)
1012 {
1013   LPWSINFO              pwsi = wsi_find(GetCurrentTask());
1014
1015   dprintf_winsock(stddeb, "WS_GetServByName(%08x): '%s', '%s'\n",
1016                           (unsigned)pwsi, (name)?name:NULL_STRING, (proto)?proto:NULL_STRING);
1017
1018   if( pwsi )
1019   {
1020     struct servent*     serv;
1021     if( (serv = getservbyname(name, proto)) != NULL )
1022       if( WS_dup_se(pwsi, serv, WS_DUP_SEGPTR) )
1023           return SEGPTR_GET(pwsi->buffer);
1024       else pwsi->errno = WSAENOBUFS;
1025     else pwsi->errno = (h_errno < 0) ? wsaErrno() : wsaHerrno();
1026   }
1027   return NULL;
1028 }
1029
1030 /*
1031 struct WIN_servent *
1032 */
1033 SEGPTR WINSOCK_getservbyport(INT16 port, const char *proto)
1034 {
1035   LPWSINFO              pwsi = wsi_find(GetCurrentTask());
1036
1037   dprintf_winsock(stddeb, "WS_GetServByPort(%08x): %i, '%s'\n",
1038                           (unsigned)pwsi, (int)port, (proto)?proto:NULL_STRING);
1039   if( pwsi )
1040   {
1041     struct servent*     serv;
1042     if( (serv = getservbyport(port, proto)) != NULL )
1043       if( WS_dup_se(pwsi, serv, WS_DUP_SEGPTR) )
1044           return SEGPTR_GET(pwsi->buffer);
1045       else pwsi->errno = WSAENOBUFS;
1046     else pwsi->errno = (h_errno < 0) ? wsaErrno() : wsaHerrno();
1047   }
1048   return NULL;
1049 }
1050
1051
1052 /* ----------------------------------- Windows sockets extensions -- *
1053  *                                                                   *
1054  * ----------------------------------------------------------------- */
1055
1056 static int aop_control(ws_async_op* p_aop, int flag )
1057 {
1058   unsigned      lLength;
1059
1060   read(p_aop->fd[0], &lLength, sizeof(unsigned));
1061   if( LOWORD(lLength) )
1062     if( (int)LOWORD(lLength) <= p_aop->buflen )
1063     {
1064       char* buffer = (char*)PTR_SEG_TO_LIN(p_aop->buffer_base);
1065       read(p_aop->fd[0], buffer, LOWORD(lLength));
1066       switch( p_aop->flags )
1067       {
1068         case WSMSG_ASYNC_HOSTBYNAME:
1069         case WSMSG_ASYNC_HOSTBYADDR:
1070              fixup_wshe((struct ws_hostent*)buffer, p_aop->buffer_base); break;
1071         case WSMSG_ASYNC_PROTOBYNAME:
1072         case WSMSG_ASYNC_PROTOBYNUM:
1073              fixup_wspe((struct ws_protoent*)buffer, p_aop->buffer_base); break;
1074         case WSMSG_ASYNC_SERVBYNAME:
1075         case WSMSG_ASYNC_SERVBYPORT:
1076              fixup_wsse((struct ws_servent*)buffer, p_aop->buffer_base); break;
1077         default:
1078              if( p_aop->flags ) fprintf(stderr,"Received unknown async request!\n");
1079              return AOP_CONTROL_REMOVE;
1080       }
1081     }
1082     else lLength =  ((UINT32)LOWORD(lLength)) | ((unsigned)WSAENOBUFS << 16);
1083
1084 #if 0
1085   printf("async op completed: hWnd [%04x], uMsg [%04x], aop [%04x], event [%08x]\n",
1086          p_aop->hWnd, p_aop->uMsg, (HANDLE16)WS_PTR2HANDLE(p_aop), (LPARAM)lLength);
1087 #endif
1088
1089   PostMessage(p_aop->hWnd, p_aop->uMsg, (HANDLE16)WS_PTR2HANDLE(p_aop), (LPARAM)lLength);
1090   return AOP_CONTROL_REMOVE;
1091 }
1092
1093
1094 static HANDLE16 __WSAsyncDBQuery(LPWSINFO pwsi, HWND16 hWnd, UINT16 uMsg, LPCSTR init,
1095                                  INT16 len, INT16 type, SEGPTR sbuf, INT16 buflen, UINT32 flag)
1096 {
1097   /* queue 'flag' request and fork off its handler */
1098
1099   async_ctl.ws_aop = (ws_async_op*)WS_ALLOC(sizeof(ws_async_op));
1100
1101   if( async_ctl.ws_aop )
1102   {
1103       HANDLE16        handle = (HANDLE16)WS_PTR2HANDLE(async_ctl.ws_aop);
1104
1105       if( pipe(async_ctl.ws_aop->fd) == 0 )
1106       {
1107         async_ctl.init = (char*)init;
1108         async_ctl.lLength = len;
1109         async_ctl.lEvent = type;
1110
1111         async_ctl.ws_aop->hWnd = hWnd;
1112         async_ctl.ws_aop->uMsg = uMsg;
1113
1114         async_ctl.ws_aop->buffer_base = sbuf; async_ctl.ws_aop->buflen = buflen;
1115         async_ctl.ws_aop->flags = flag;
1116         async_ctl.ws_aop->aop_control = &aop_control;
1117         WINSOCK_link_async_op( async_ctl.ws_aop );
1118
1119         async_ctl.ws_aop->pid = fork();
1120         if( async_ctl.ws_aop->pid )
1121         {
1122             close(async_ctl.ws_aop->fd[1]);        /* write endpoint */
1123
1124            /* Damn, BSD'ish SIGIO doesn't work on pipes/streams
1125             *
1126             * async_io(async_ctl.ws_aop->fd[0], 1);
1127             */
1128
1129             dprintf_winsock(stddeb, "\tasync_op = %04x (child %i)\n",
1130                                     handle, async_ctl.ws_aop->pid);
1131             return handle;
1132         } else
1133                 /* child process */
1134                  {
1135                    close(async_ctl.ws_aop->fd[0]); /* read endpoint */
1136                    switch(flag)
1137                    {
1138                      case WSMSG_ASYNC_HOSTBYADDR:
1139                      case WSMSG_ASYNC_HOSTBYNAME:
1140                         WS_do_async_gethost(pwsi,flag);
1141                      case WSMSG_ASYNC_PROTOBYNUM:
1142                      case WSMSG_ASYNC_PROTOBYNAME:
1143                         WS_do_async_getproto(pwsi,flag);
1144                      case WSMSG_ASYNC_SERVBYPORT:
1145                      case WSMSG_ASYNC_SERVBYNAME:
1146                         WS_do_async_getserv(pwsi,flag);
1147                    }
1148                    _exit(0); /* skip atexit()'ed cleanup */
1149                  }
1150       }
1151       WS_FREE(async_ctl.ws_aop);
1152       pwsi->errno = wsaErrno();
1153   } else pwsi->errno = WSAEWOULDBLOCK;
1154   return 0;
1155 }
1156
1157 HANDLE16 WSAAsyncGetHostByAddr(HWND16 hWnd, UINT16 uMsg, LPCSTR addr,
1158                                INT16 len, INT16 type, SEGPTR sbuf, INT16 buflen)
1159 {
1160   LPWSINFO              pwsi = wsi_find(GetCurrentTask());
1161
1162   dprintf_winsock(stddeb, "WS_AsyncGetHostByAddr(%08x): hwnd %04x, msg %04x, addr %08x[%i]\n",
1163                           (unsigned)pwsi, hWnd, uMsg, (unsigned)addr , len );
1164
1165   if( pwsi )
1166     return __WSAsyncDBQuery(pwsi, hWnd, uMsg, addr, len,
1167                             type, sbuf, buflen, WSMSG_ASYNC_HOSTBYADDR );
1168   return 0;
1169 }
1170
1171
1172 HANDLE16 WSAAsyncGetHostByName(HWND16 hWnd, UINT16 uMsg, LPCSTR name,
1173                                SEGPTR sbuf, INT16 buflen)
1174 {
1175   LPWSINFO              pwsi = wsi_find(GetCurrentTask());
1176
1177   dprintf_winsock(stddeb, "WS_AsyncGetHostByName(%08x): hwnd %04x, msg %04x, host %s, buffer %i\n",
1178                           (unsigned)pwsi, hWnd, uMsg, (name)?name:NULL_STRING, (int)buflen );
1179
1180   if( pwsi )
1181     return __WSAsyncDBQuery(pwsi, hWnd, uMsg, name, 0,
1182                             0, sbuf, buflen, WSMSG_ASYNC_HOSTBYNAME );
1183   return 0;
1184 }
1185
1186
1187 HANDLE16 WSAAsyncGetProtoByName(HWND16 hWnd, UINT16 uMsg, LPCSTR name,
1188                                 SEGPTR sbuf, INT16 buflen)
1189 {
1190   LPWSINFO              pwsi = wsi_find(GetCurrentTask());
1191
1192   dprintf_winsock(stddeb, "WS_AsyncGetProtoByName(%08x): hwnd %04x, msg %04x, protocol %s\n",
1193                           (unsigned)pwsi, hWnd, uMsg, (name)?name:NULL_STRING );
1194
1195   if( pwsi )
1196     return __WSAsyncDBQuery(pwsi, hWnd, uMsg, name, 0,
1197                             0, sbuf, buflen, WSMSG_ASYNC_PROTOBYNAME );
1198   return 0;
1199 }
1200
1201
1202 HANDLE16 WSAAsyncGetProtoByNumber(HWND16 hWnd, UINT16 uMsg, INT16 number,
1203                                   SEGPTR sbuf, INT16 buflen)
1204 {
1205   LPWSINFO              pwsi = wsi_find(GetCurrentTask());
1206
1207   dprintf_winsock(stddeb, "WS_AsyncGetProtoByNumber(%08x): hwnd %04x, msg %04x, num %i\n",
1208                           (unsigned)pwsi, hWnd, uMsg, number );
1209
1210   if( pwsi )
1211     return __WSAsyncDBQuery(pwsi, hWnd, uMsg, NULL, 0,
1212                             number, sbuf, buflen, WSMSG_ASYNC_PROTOBYNUM );
1213   return 0;
1214 }
1215
1216
1217 HANDLE16 WSAAsyncGetServByName(HWND16 hWnd, UINT16 uMsg, LPCSTR name,
1218                                LPCSTR proto, SEGPTR sbuf, INT16 buflen)
1219 {
1220   LPWSINFO              pwsi = wsi_find(GetCurrentTask());
1221
1222   dprintf_winsock(stddeb, "WS_AsyncGetServByName(%08x): hwnd %04x, msg %04x, name %s, proto %s\n",
1223                    (unsigned)pwsi, hWnd, uMsg, (name)?name:NULL_STRING, (proto)?proto:NULL_STRING );
1224
1225   if( pwsi )
1226   {
1227     async_ctl.buffer = (char*)proto;
1228     return __WSAsyncDBQuery(pwsi, hWnd, uMsg, name, 0,
1229                             0, sbuf, buflen, WSMSG_ASYNC_SERVBYNAME );
1230   }
1231   return 0;
1232 }
1233
1234
1235 HANDLE16 WSAAsyncGetServByPort(HWND16 hWnd, UINT16 uMsg, INT16 port,
1236                                LPCSTR proto, SEGPTR sbuf, INT16 buflen)
1237 {
1238   LPWSINFO              pwsi = wsi_find(GetCurrentTask());
1239
1240   dprintf_winsock(stddeb, "WS_AsyncGetServByPort(%08x): hwnd %04x, msg %04x, port %i, proto %s\n",
1241                            (unsigned)pwsi, hWnd, uMsg, port, (proto)?proto:NULL_STRING );
1242
1243   if( pwsi )
1244     return __WSAsyncDBQuery(pwsi, hWnd, uMsg, proto, 0,
1245                             port, sbuf, buflen, WSMSG_ASYNC_SERVBYPORT );
1246   return 0;
1247 }
1248
1249 INT16 WSACancelAsyncRequest(HANDLE16 hAsyncTaskHandle)
1250 {
1251   LPWSINFO              pwsi = wsi_find(GetCurrentTask());
1252   ws_async_op*          p_aop = (ws_async_op*)WS_HANDLE2PTR(hAsyncTaskHandle);
1253
1254   dprintf_winsock(stddeb, "WS_CancelAsyncRequest(%08x): handle %04x\n",
1255                            (unsigned)pwsi, hAsyncTaskHandle);
1256   if( pwsi )
1257     if( WINSOCK_check_async_op(p_aop) )
1258     {
1259         kill(p_aop->pid, SIGKILL);
1260         waitpid(p_aop->pid, NULL, 0); /* just in case */
1261         close(p_aop->fd[0]);
1262         WINSOCK_unlink_async_op(p_aop);
1263         WS_FREE(p_aop);
1264         return 0;
1265     }
1266     else pwsi->errno = WSAEINVAL;
1267   return SOCKET_ERROR;
1268 }
1269
1270 /* ----- asynchronous select() */
1271
1272 int cancel_async_select(ws_socket* pws)
1273 {
1274   if( pws->p_aop )
1275   {
1276     kill(pws->p_aop->pid, SIGKILL);
1277     waitpid(pws->p_aop->pid, NULL, 0);
1278     WS_FREE(pws->p_aop);
1279     pws->p_aop = NULL;
1280     return 1;
1281   }
1282   return 0;
1283 }
1284
1285 void _sigusr1_handler_parent(int sig)
1286 {
1287   /* child process puts MTYPE_CLIENT data packet into the
1288    * 'async_qid' message queue and signals us with SIGUSR1.
1289    * This handler reads the queue and posts 'uMsg' notification
1290    * message.
1291    */
1292
1293   ipc_packet            ipack;
1294
1295   signal( SIGUSR1, _sigusr1_handler_parent);
1296   while( msgrcv(async_qid, (struct msgbuf*)&ipack,
1297           MTYPE_CLIENT_SIZE, MTYPE_CLIENT, IPC_NOWAIT) != -1 )
1298   {
1299     if( ipack.wParam && abs((short)ipack.wParam) < 32768 )
1300     {
1301       ws_socket*        pws = (ws_socket*)WS_HANDLE2PTR(ipack.wParam);
1302       if( pws->p_aop && abs((char*)_ws_stub - (char*)pws->p_aop) < 32768 )
1303       {
1304           pws->flags &= ~(ipack.lParam);
1305 #if 0
1306           printf("async event - hWnd %04x, uMsg %04x [%08x]\n",
1307                   pws->p_aop->hWnd, pws->p_aop->uMsg, ipack.lParam );
1308 #endif
1309           PostMessage(pws->p_aop->hWnd, pws->p_aop->uMsg,
1310                      (WPARAM16)ipack.wParam, (LPARAM)ipack.lParam );
1311       }
1312       else fprintf(stderr,"AsyncSelect:stray async_op in socket %04x!\n", ipack.wParam);
1313     }
1314     else fprintf(stderr,"AsyncSelect:stray socket at %04x!\n", ipack.wParam);
1315   }
1316 }
1317
1318 int notify_client( ws_socket* pws, unsigned flag )
1319 {
1320   if( pws->p_aop && ((pws->p_aop->flags & flag) ||
1321                      (flag == WS_FD_CONNECTED && pws->flags & WS_FD_CONNECT)) )
1322   {
1323      async_ctl.ip.mtype = MTYPE_PARENT;
1324      async_ctl.ip.lParam = flag;
1325      while( msgsnd(async_qid, (struct msgbuf*)&(async_ctl.ip),
1326                                MTYPE_PARENT_SIZE, 0) == -1 )
1327      {
1328         if( errno == EINTR ) continue;
1329         else
1330         {
1331             perror("AsyncSelect(parent)");
1332             cancel_async_select(pws);
1333             pws->flags &= WS_FD_INTERNAL;
1334             return 0;
1335         }
1336      }
1337      kill(pws->p_aop->pid, SIGUSR1);
1338      return 1;
1339   }
1340   return 0;
1341 }
1342
1343 INT16 init_async_select(ws_socket* pws, HWND16 hWnd, UINT16 uMsg, UINT32 lEvent)
1344 {
1345     ws_async_op*        p_aop;
1346
1347     if( cancel_async_select(pws) )  /* delete old async handler if any */
1348       pws->flags &= WS_FD_INTERNAL;
1349
1350     if( lEvent == 0 ) return 0;
1351
1352     /* setup async handler - some data may be redundant */
1353
1354     WINSOCK_unblock_io(pws->fd, 1);
1355     if( (p_aop = (ws_async_op*)WS_ALLOC(sizeof(ws_async_op))) )
1356     {
1357       p_aop->hWnd = hWnd;
1358       p_aop->uMsg = uMsg;
1359       pws->p_aop = p_aop;
1360
1361       async_ctl.lEvent = p_aop->flags = lEvent;
1362       async_ctl.ws_sock = pws;
1363       async_ctl.ip.wParam = (UINT16)WS_PTR2HANDLE(pws);
1364       async_ctl.ip.lParam = 0;
1365
1366       p_aop->pid = fork();
1367       if( p_aop->pid != -1 )
1368         if( p_aop->pid == 0 ) WINSOCK_do_async_select(); /* child process */
1369         else pws->flags |= lEvent;
1370
1371       signal( SIGUSR1, _sigusr1_handler_parent );
1372       return 0;                                  /* Wine process */
1373     }
1374     return SOCKET_ERROR;
1375 }
1376
1377 INT16 WSAAsyncSelect(SOCKET16 s, HWND16 hWnd, UINT16 uMsg, UINT32 lEvent)
1378 {
1379   ws_socket*    pws  = (ws_socket*)WS_HANDLE2PTR(s);
1380   LPWSINFO      pwsi = wsi_find(GetCurrentTask());
1381
1382   dprintf_winsock(stddeb, "WS_AsyncSelect(%08x): %04x, hWnd %04x, uMsg %04x, event %08x\n",
1383                           (unsigned)pwsi, s, hWnd, uMsg, (unsigned)lEvent );
1384   if( _check_ws(pwsi, pws) )
1385     if( init_async_select(pws, hWnd, uMsg, lEvent) == 0 ) return 0;
1386     else pwsi->errno = WSAENOBUFS;
1387   return SOCKET_ERROR;
1388 }
1389
1390 /* ----- miscellaneous */
1391
1392 INT16 __WSAFDIsSet(SOCKET16 fd, ws_fd_set *set)
1393 {
1394   int i = set->fd_count;
1395
1396   dprintf_winsock(stddeb, "__WSAFDIsSet(%d,%8lx)\n",fd,(unsigned long)set);
1397
1398   while (i--)
1399       if (set->fd_array[i] == fd) return 1;
1400   return 0;
1401 }
1402
1403 BOOL16 WSAIsBlocking(void)
1404 {
1405   /* By default WinSock should set all its sockets to non-blocking mode
1406    * and poll in PeekMessage loop when processing "blocking" ones. This
1407    * function * is supposed to tell if program is in this loop. Our
1408    * blocking calls are truly blocking so we always return FALSE.
1409    *
1410    * Note: It is allowed to call this function without prior WSAStartup().
1411    */
1412
1413   dprintf_winsock(stddeb, "WS_IsBlocking()\n");
1414   return FALSE;
1415 }
1416
1417 INT16 WSACancelBlockingCall(void)
1418 {
1419   LPWSINFO              pwsi = wsi_find(GetCurrentTask());
1420
1421   dprintf_winsock(stddeb, "WS_CancelBlockingCall(%08x)\n", (unsigned)pwsi);
1422
1423   if( pwsi ) return 0;
1424   return SOCKET_ERROR;
1425 }
1426
1427 FARPROC16 WSASetBlockingHook(FARPROC16 lpBlockFunc)
1428 {
1429   FARPROC16             prev;
1430   LPWSINFO              pwsi = wsi_find(GetCurrentTask());
1431
1432   dprintf_winsock(stddeb, "WS_SetBlockingHook(%08x): hook %08x\n",
1433                           (unsigned)pwsi, (unsigned) lpBlockFunc);
1434
1435   if( pwsi ) {
1436       prev = pwsi->blocking_hook;
1437       pwsi->blocking_hook = lpBlockFunc;
1438       return prev;
1439   }
1440   return 0;
1441 }
1442
1443 INT16 WSAUnhookBlockingHook(void)
1444 {
1445   LPWSINFO              pwsi = wsi_find(GetCurrentTask());
1446
1447   dprintf_winsock(stddeb, "WS_UnhookBlockingHook(%08x)\n", (unsigned)pwsi);
1448   if( pwsi ) return (INT16)(INT32)(pwsi->blocking_hook = (FARPROC16)NULL);
1449   return SOCKET_ERROR;
1450 }
1451
1452 VOID
1453 WsControl(DWORD x1,DWORD x2,LPDWORD x3,LPDWORD x4,LPDWORD x5,LPDWORD x6)
1454 {
1455         fprintf(stdnimp,"WsControl(%lx,%lx,%p,%p,%p,%p)\n",
1456                 x1,x2,x3,x4,x5,x6
1457         );
1458         fprintf(stdnimp,"WsControl(x,x,%lx,%lx,%lx,%lx)\n",
1459                 x3?*x3:0,x4?*x4:0,x5?*x5:0,x6?*x6:0
1460         );
1461         return;
1462 }
1463 /* ----------------------------------- end of API stuff */
1464
1465
1466
1467 /* ----------------------------------- helper functions */
1468
1469 static int list_size(char** l, int item_size)
1470 {
1471   int i,j = 0;
1472   if(l)
1473   { for(i=0;l[i];i++)
1474         j += (item_size) ? item_size : strlen(l[i]) + 1;
1475     j += (i + 1) * sizeof(char*); }
1476   return j;
1477 }
1478
1479 static int list_dup(char** l_src, char* ref, char* base, int item_size)
1480 {
1481    /* base is either either equal to ref or 0 or SEGPTR */
1482
1483    char*                p = ref;
1484    char**               l_to = (char**)ref;
1485    int                  i,j,k;
1486
1487    for(j=0;l_src[j];j++) ;
1488    p += (j + 1) * sizeof(char*);
1489    for(i=0;i<j;i++)
1490    { l_to[i] = base + (p - ref);
1491      k = ( item_size ) ? item_size : strlen(l_src[i]) + 1;
1492      memcpy(p, l_src[i], k); p += k; }
1493    l_to[i] = NULL;
1494    return (p - ref);
1495 }
1496
1497 /* ----- hostent */
1498
1499 static int hostent_size(struct hostent* p_he)
1500 {
1501   int size = 0;
1502   if( p_he )
1503   { size  = sizeof(struct hostent);
1504     size += strlen(p_he->h_name) + 1;
1505     size += list_size(p_he->h_aliases, 0);
1506     size += list_size(p_he->h_addr_list, p_he->h_length ); }
1507   return size;
1508 }
1509
1510 int WS_dup_he(LPWSINFO pwsi, struct hostent* p_he, int flag)
1511 {
1512    /* Duplicate hostent structure and flatten data (with its pointers)
1513     * into pwsi->buffer. Internal pointers can be linear, SEGPTR, or
1514     * relative to 0 depending on "flag" value. Return data size (also
1515     * in the pwsi->buflen).
1516     */
1517
1518    int size = hostent_size(p_he);
1519    if( size )
1520    {
1521      char*           p_name,*p_aliases,*p_addr,*p_base,*p;
1522
1523      _check_buffer(pwsi, size);
1524      p = pwsi->buffer;
1525      p_base = (flag & WS_DUP_OFFSET) ? NULL
1526                                      : ((flag & WS_DUP_SEGPTR) ? (char*)SEGPTR_GET(p) : p);
1527      p += (flag & WS_DUP_SEGPTR) ? sizeof(struct ws_hostent) : sizeof(struct hostent);
1528      p_name = p;
1529      strcpy(p, p_he->h_name); p += strlen(p) + 1;
1530      p_aliases = p;
1531      p += list_dup(p_he->h_aliases, p, p_base + (p - pwsi->buffer), 0);
1532      p_addr = p;
1533      list_dup(p_he->h_addr_list, p, p_base + (p - pwsi->buffer), p_he->h_length);
1534      if( !(flag & WS_DUP_SEGPTR) )
1535      { struct hostent* p_to = (struct hostent*)pwsi->buffer;
1536        p_to->h_addrtype = p_he->h_addrtype; p_to->h_length = p_he->h_length;
1537        p_to->h_name = p_base + (p_name - pwsi->buffer);
1538        p_to->h_aliases = (char**)(p_base + (p_aliases - pwsi->buffer));
1539        p_to->h_addr_list = (char**)(p_base + (p_addr - pwsi->buffer)); }
1540      else
1541      { struct ws_hostent* p_to = (struct ws_hostent*)pwsi->buffer;
1542        p_to->h_addrtype = (INT16)p_he->h_addrtype;
1543        p_to->h_length = (INT16)p_he->h_length;
1544        p_to->h_name = (SEGPTR)(p_base + (p_name - pwsi->buffer));
1545        p_to->h_aliases = (SEGPTR)(p_base + (p_aliases - pwsi->buffer));
1546        p_to->h_addr_list = (SEGPTR)(p_base + (p_addr - pwsi->buffer));
1547
1548        return (size + sizeof(struct ws_hostent) - sizeof(struct hostent)); }
1549    }
1550    return size;
1551 }
1552
1553 void fixup_wshe(struct ws_hostent* p_wshe, SEGPTR base)
1554 {
1555    /* add 'base' to ws_hostent pointers to convert them from offsets */
1556
1557    int i;
1558    unsigned*    p_aliases,*p_addr;
1559
1560    p_aliases = (unsigned*)((char*)p_wshe + (unsigned)p_wshe->h_aliases);
1561    p_addr = (unsigned*)((char*)p_wshe + (unsigned)p_wshe->h_addr_list);
1562    ((unsigned)(p_wshe->h_name)) += (unsigned)base;
1563    ((unsigned)(p_wshe->h_aliases)) += (unsigned)base;
1564    ((unsigned)(p_wshe->h_addr_list)) += (unsigned)base;
1565    for(i=0;p_aliases[i];i++) p_aliases[i] += (unsigned)base;
1566    for(i=0;p_addr[i];i++) p_addr[i] += (unsigned)base;
1567 }
1568
1569 /* ----- protoent */
1570
1571 static int protoent_size(struct protoent* p_pe)
1572 {
1573   int size = 0;
1574   if( p_pe )
1575   { size  = sizeof(struct protoent);
1576     size += strlen(p_pe->p_name) + 1;
1577     size += list_size(p_pe->p_aliases, 0); }
1578   return size;
1579 }
1580
1581 int WS_dup_pe(LPWSINFO pwsi, struct protoent* p_pe, int flag)
1582 {
1583    int size = protoent_size(p_pe);
1584    if( size )
1585    {
1586      char*            p_name,*p_aliases,*p_base,*p;
1587
1588      _check_buffer(pwsi, size);
1589      p = pwsi->buffer;
1590      p_base = (flag & WS_DUP_OFFSET) ? NULL
1591                                      : ((flag & WS_DUP_SEGPTR) ? (char*)SEGPTR_GET(p) : p);
1592      p += (flag & WS_DUP_SEGPTR)? sizeof(struct ws_protoent) : sizeof(struct protoent);
1593      p_name = p;
1594      strcpy(p, p_pe->p_name); p += strlen(p) + 1;
1595      p_aliases = p;
1596      list_dup(p_pe->p_aliases, p, p_base + (p - pwsi->buffer), 0);
1597      if( !(flag & WS_DUP_NATIVE) )
1598      { struct protoent* p_to = (struct protoent*)pwsi->buffer;
1599        p_to->p_proto = p_pe->p_proto;
1600        p_to->p_name = p_base + (p_name - pwsi->buffer);
1601        p_to->p_aliases = (char**)(p_base + (p_aliases - pwsi->buffer)); }
1602      else
1603      { struct ws_protoent* p_to = (struct ws_protoent*)pwsi->buffer;
1604        p_to->p_proto = (INT16)p_pe->p_proto;
1605        p_to->p_name = (SEGPTR)(p_base) + (p_name - pwsi->buffer);
1606        p_to->p_aliases = (SEGPTR)((p_base) + (p_aliases - pwsi->buffer));
1607        return (size + sizeof(struct ws_protoent) - sizeof(struct protoent)); }
1608    }
1609    return size;
1610 }
1611
1612 void fixup_wspe(struct ws_protoent* p_wspe, SEGPTR base)
1613 {
1614    int i;
1615    unsigned*       p_aliases = (unsigned*)((char*)p_wspe + (unsigned)p_wspe->p_aliases);
1616    ((unsigned)(p_wspe->p_name)) += (unsigned)base;
1617    ((unsigned)(p_wspe->p_aliases)) += (unsigned)base;
1618    for(i=0;p_aliases[i];i++) p_aliases[i] += (unsigned)base;
1619 }
1620
1621 /* ----- servent */
1622
1623 static int servent_size(struct servent* p_se)
1624 {
1625   int size = 0;
1626   if( p_se )
1627   { size += sizeof(struct servent);
1628     size += strlen(p_se->s_proto) + strlen(p_se->s_name) + 2;
1629     size += list_size(p_se->s_aliases, 0); }
1630   return size;
1631 }
1632
1633 int WS_dup_se(LPWSINFO pwsi, struct servent* p_se, int flag)
1634 {
1635    int size = servent_size(p_se);
1636    if( size )
1637    {
1638      char*           p_name,*p_aliases,*p_proto,*p_base,*p;
1639
1640      _check_buffer(pwsi, size);
1641      p = pwsi->buffer;
1642      p_base = (flag & WS_DUP_OFFSET) ? NULL
1643                                      : ((flag & WS_DUP_SEGPTR) ? (char*)SEGPTR_GET(p) : p);
1644      p += (flag & WS_DUP_SEGPTR)? sizeof(struct ws_servent) : sizeof(struct servent);
1645      p_name = p;
1646      strcpy(p, p_se->s_name); p += strlen(p) + 1;
1647      p_proto = p;
1648      strcpy(p, p_se->s_proto); p += strlen(p) + 1;
1649      p_aliases = p;
1650      list_dup(p_se->s_aliases, p, p_base + (p - pwsi->buffer), 0);
1651
1652      if( !(flag & WS_DUP_SEGPTR) )
1653      { struct servent* p_to = (struct servent*)pwsi->buffer;
1654        p_to->s_port = p_se->s_port;
1655        p_to->s_name = p_base + (p_name - pwsi->buffer);
1656        p_to->s_proto = p_base + (p_proto - pwsi->buffer);
1657        p_to->s_aliases = (char**)(p_base + (p_aliases - pwsi->buffer)); }
1658      else
1659      { struct ws_servent* p_to = (struct ws_servent*)pwsi->buffer;
1660        p_to->s_port = (INT16)p_se->s_port;
1661        p_to->s_name = (SEGPTR)(p_base + (p_name - pwsi->buffer));
1662        p_to->s_proto = (SEGPTR)(p_base + (p_proto - pwsi->buffer));
1663        p_to->s_aliases = (SEGPTR)(p_base + (p_aliases - pwsi->buffer));
1664        return (size + sizeof(struct ws_servent) - sizeof(struct servent)); }
1665    }
1666    return size;
1667 }
1668
1669 void fixup_wsse(struct ws_servent* p_wsse, SEGPTR base)
1670 {
1671    int i;
1672    unsigned*       p_aliases = (unsigned*)((char*)p_wsse + (unsigned)p_wsse->s_aliases);
1673    ((unsigned)(p_wsse->s_name)) += (unsigned)base;
1674    ((p_wsse->s_proto)) += (unsigned)base;
1675    ((p_wsse->s_aliases)) += (unsigned)base;
1676    for(i=0;p_aliases[i];i++) p_aliases[i] += (unsigned)base;
1677 }
1678
1679 /* ----------------------------------- error handling */
1680
1681 UINT16 wsaErrno(void)
1682 {
1683     int loc_errno = errno;
1684 #if defined(__FreeBSD__)
1685        dprintf_winsock(stderr, "winsock: errno %d, (%s).\n",
1686                                          errno, sys_errlist[errno]);
1687 #else
1688        dprintf_winsock(stderr, "winsock: errno %d\n", errno);
1689 #endif
1690
1691     switch(loc_errno)
1692     {
1693         case EINTR:             return WSAEINTR;
1694         case EBADF:             return WSAEBADF;
1695         case EACCES:            return WSAEACCES;
1696         case EFAULT:            return WSAEFAULT;
1697         case EINVAL:            return WSAEINVAL;
1698         case EMFILE:            return WSAEMFILE;
1699         case EWOULDBLOCK:       return WSAEWOULDBLOCK;
1700         case EINPROGRESS:       return WSAEINPROGRESS;
1701         case EALREADY:          return WSAEALREADY;
1702         case ENOTSOCK:          return WSAENOTSOCK;
1703         case EDESTADDRREQ:      return WSAEDESTADDRREQ;
1704         case EMSGSIZE:          return WSAEMSGSIZE;
1705         case EPROTOTYPE:        return WSAEPROTOTYPE;
1706         case ENOPROTOOPT:       return WSAENOPROTOOPT;
1707         case EPROTONOSUPPORT:   return WSAEPROTONOSUPPORT;
1708         case ESOCKTNOSUPPORT:   return WSAESOCKTNOSUPPORT;
1709         case EOPNOTSUPP:        return WSAEOPNOTSUPP;
1710         case EPFNOSUPPORT:      return WSAEPFNOSUPPORT;
1711         case EAFNOSUPPORT:      return WSAEAFNOSUPPORT;
1712         case EADDRINUSE:        return WSAEADDRINUSE;
1713         case EADDRNOTAVAIL:     return WSAEADDRNOTAVAIL;
1714         case ENETDOWN:          return WSAENETDOWN;
1715         case ENETUNREACH:       return WSAENETUNREACH;
1716         case ENETRESET:         return WSAENETRESET;
1717         case ECONNABORTED:      return WSAECONNABORTED;
1718         case ECONNRESET:        return WSAECONNRESET;
1719         case ENOBUFS:           return WSAENOBUFS;
1720         case EISCONN:           return WSAEISCONN;
1721         case ENOTCONN:          return WSAENOTCONN;
1722         case ESHUTDOWN:         return WSAESHUTDOWN;
1723         case ETOOMANYREFS:      return WSAETOOMANYREFS;
1724         case ETIMEDOUT:         return WSAETIMEDOUT;
1725         case ECONNREFUSED:      return WSAECONNREFUSED;
1726         case ELOOP:             return WSAELOOP;
1727         case ENAMETOOLONG:      return WSAENAMETOOLONG;
1728         case EHOSTDOWN:         return WSAEHOSTDOWN;
1729         case EHOSTUNREACH:      return WSAEHOSTUNREACH;
1730         case ENOTEMPTY:         return WSAENOTEMPTY;
1731 #ifdef EPROCLIM
1732         case EPROCLIM:          return WSAEPROCLIM;
1733 #endif
1734 #ifdef EUSERS
1735         case EUSERS:            return WSAEUSERS;
1736 #endif
1737 #ifdef EDQUOT
1738         case EDQUOT:            return WSAEDQUOT;
1739 #endif
1740         case ESTALE:            return WSAESTALE;
1741         case EREMOTE:           return WSAEREMOTE;
1742
1743        /* just in case we ever get here and there are no problems */
1744         case 0:                 return 0;
1745         default:
1746                 fprintf(stderr, "winsock: unknown errno %d!\n", errno);
1747                 return WSAEOPNOTSUPP;
1748     }
1749 }
1750
1751 UINT16 wsaHerrno(void)
1752 {
1753     int         loc_errno = h_errno;
1754
1755 #if defined(__FreeBSD__)
1756     dprintf_winsock(stderr, "winsock: h_errno %d, (%s).\n",
1757                     h_errno, sys_errlist[h_errno]);
1758 #else
1759     dprintf_winsock(stderr, "winsock: h_errno %d.\n", h_errno);
1760 #ifndef sun
1761     if( debugging_winsock )  herror("wine: winsock: wsaherrno");
1762 #endif
1763 #endif
1764
1765     switch(loc_errno)
1766     {
1767         case HOST_NOT_FOUND:    return WSAHOST_NOT_FOUND;
1768         case TRY_AGAIN:         return WSATRY_AGAIN;
1769         case NO_RECOVERY:       return WSANO_RECOVERY;
1770         case NO_DATA:           return WSANO_DATA;
1771
1772         case 0:                 return 0;
1773         default:
1774                 fprintf(stderr, "winsock: unknown h_errno %d!\n", h_errno);
1775                 return WSAEOPNOTSUPP;
1776     }
1777 }
1778
1779