misc/winsocket.c

   1 /*
   2  * based on Windows Sockets 1.1 specs
   3  * (ftp.microsoft.com:/Advsys/winsock/spec11/WINSOCK.TXT)
   4  *
   5  * (C) 1993,1994 John Brezak, Erik Bos.
   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/socket.h>
  14 #include <netinet/in.h>
  15 #include <arpa/inet.h>
  16 #include <fcntl.h>
  17 #include <errno.h>
  18 #include <netdb.h>
  19 #include <unistd.h>
  20 #include "heap.h"
  21 #include "winsock.h"
  22
  23 #define DEBUG_WINSOCK
  24
  25 static WORD wsa_errno;
  26 static int wsa_initted;
  27 static key_t wine_key = 0;
  28 static FARPROC BlockFunction;
  29 static fd_set fd_in_use;
  30
  31 struct ipc_packet {
  32         long    mtype;
  33         HANDLE  handle;
  34         HWND    hWnd;
  35         WORD    wMsg;
  36         LONG    lParam;
  37 };
  38 #define IPC_PACKET_SIZE (sizeof(struct ipc_packet) - sizeof(long))
  39
  40 #define MTYPE 0xb0b0eb05
  41
  42 struct WinSockHeap {
  43         char    ntoa_buffer[32];
  44
  45         struct  hostent hostent_addr;
  46         struct  hostent hostent_name;
  47         struct  protoent protoent_name;
  48         struct  protoent protoent_number;
  49         struct  servent servent_name;
  50         struct  servent servent_port;
  51
  52         struct  hostent WSAhostent_addr;
  53         struct  hostent WSAhostent_name;
  54         struct  protoent WSAprotoent_name;
  55         struct  protoent WSAprotoent_number;
  56         struct  servent WSAservent_name;
  57         struct  servent WSAservent_port;
  58 };
  59 static struct WinSockHeap *heap;
  60
  61 #define dump_sockaddr(a) \
  62         fprintf(stderr, "sockaddr_in: family %d, address %s, port %d\n", \
  63                         ((struct sockaddr_in *)a)->sin_family, \
  64                         inet_ntoa(((struct sockaddr_in *)a)->sin_addr), \
  65                         ntohs(((struct sockaddr_in *)a)->sin_port))
  66
  67 static WORD wsaerrno(void)
  68 {
  69 #ifdef DEBUG_WINSOCK
  70 #ifndef sun
  71 #if defined(__FreeBSD__)
  72                 fprintf(stderr, "winsock: errno %d, (%s).\n",
  73                                         errno, sys_errlist[errno]);
  74 #else
  75                 fprintf(stderr, "winsock: errno %d, (%s).\n",
  76                                         errno, strerror(errno));
  77 #endif
  78 #else
  79                 fprintf(stderr, "winsock: errno %d\n", errno);
  80 #endif
  81 #endif
  82
  83         switch(errno)
  84         {
  85         case EINTR:             return WSAEINTR;
  86         case EACCES:            return WSAEACCES;
  87         case EFAULT:            return WSAEFAULT;
  88         case EINVAL:            return WSAEINVAL;
  89         case EMFILE:            return WSAEMFILE;
  90         case EWOULDBLOCK:       return WSAEWOULDBLOCK;
  91         case EINPROGRESS:       return WSAEINPROGRESS;
  92         case EALREADY:          return WSAEALREADY;
  93         case EBADF:
  94         case ENOTSOCK:          return WSAENOTSOCK;
  95         case EDESTADDRREQ:      return WSAEDESTADDRREQ;
  96         case EMSGSIZE:          return WSAEMSGSIZE;
  97         case EPROTOTYPE:        return WSAEPROTOTYPE;
  98         case ENOPROTOOPT:       return WSAENOPROTOOPT;
  99         case EPROTONOSUPPORT:   return WSAEPROTONOSUPPORT;
 100         case ESOCKTNOSUPPORT:   return WSAESOCKTNOSUPPORT;
 101         case EOPNOTSUPP:        return WSAEOPNOTSUPP;
 102         case EPFNOSUPPORT:      return WSAEPFNOSUPPORT;
 103         case EAFNOSUPPORT:      return WSAEAFNOSUPPORT;
 104         case EADDRINUSE:        return WSAEADDRINUSE;
 105         case EADDRNOTAVAIL:     return WSAEADDRNOTAVAIL;
 106         case ENETDOWN:          return WSAENETDOWN;
 107         case ENETUNREACH:       return WSAENETUNREACH;
 108         case ENETRESET:         return WSAENETRESET;
 109         case ECONNABORTED:      return WSAECONNABORTED;
 110         case ECONNRESET:        return WSAECONNRESET;
 111         case ENOBUFS:           return WSAENOBUFS;
 112         case EISCONN:           return WSAEISCONN;
 113         case ENOTCONN:          return WSAENOTCONN;
 114         case ESHUTDOWN:         return WSAESHUTDOWN;
 115         case ETOOMANYREFS:      return WSAETOOMANYREFS;
 116         case ETIMEDOUT:         return WSAETIMEDOUT;
 117         case ECONNREFUSED:      return WSAECONNREFUSED;
 118         case ELOOP:             return WSAELOOP;
 119         case ENAMETOOLONG:      return WSAENAMETOOLONG;
 120         case EHOSTDOWN:         return WSAEHOSTDOWN;
 121         case EHOSTUNREACH:      return WSAEHOSTUNREACH;
 122         case ENOTEMPTY:         return WSAENOTEMPTY;
 123 /*      case EPROCLIM:          return WSAEPROCLIM; */
 124         case EUSERS:            return WSAEUSERS;
 125         case EDQUOT:            return WSAEDQUOT;
 126         case ESTALE:            return WSAESTALE;
 127         case EREMOTE:           return WSAEREMOTE;
 128
 129         default:
 130                 fprintf(stderr, "winsock: unknown errorno %d!\n", errno);
 131                 return WSAEOPNOTSUPP;
 132         }
 133 }
 134
 135 static WORD errno_to_wsaerrno(void)
 136 {
 137         wsa_errno = wsaerrno();
 138 }
 139
 140 SOCKET Winsock_accept(SOCKET s, struct sockaddr FAR *addr, INT FAR *addrlen)
 141 {
 142         int sock;
 143
 144 #ifdef DEBUG_WINSOCK
 145         fprintf(stderr, "WSA_accept: socket %d, ptr %8x, length %d\n", s, (int) addr, addrlen);
 146 #endif
 147
 148         if ((sock = accept(s, addr, (int *) addrlen)) < 0) {
 149                 errno_to_wsaerrno();
 150                 return INVALID_SOCKET;
 151         }
 152         return sock;
 153 }
 154
 155 INT Winsock_bind(SOCKET s, struct sockaddr FAR *name, INT namelen)
 156 {
 157 #ifdef DEBUG_WINSOCK
 158         fprintf(stderr, "WSA_bind: socket %d, ptr %8x, length %d\n", s, (int) name, namelen);
 159         dump_sockaddr(name);
 160 #endif
 161
 162         if (bind(s, name, namelen) < 0) {
 163                 errno_to_wsaerrno();
 164                 return SOCKET_ERROR;
 165         }
 166         return 0;
 167 }
 168
 169 INT Winsock_closesocket(SOCKET s)
 170 {
 171 #ifdef DEBUG_WINSOCK
 172         fprintf(stderr, "WSA_closesocket: socket %d\n", s);
 173 #endif
 174
 175         FD_CLR(s, &fd_in_use);
 176
 177         if (close(s) < 0) {
 178                 errno_to_wsaerrno();
 179                 return SOCKET_ERROR;
 180         }
 181         return 0;
 182 }
 183
 184 INT Winsock_connect(SOCKET s, struct sockaddr FAR *name, INT namelen)
 185 {
 186 #ifdef DEBUG_WINSOCK
 187         fprintf(stderr, "WSA_connect: socket %d, ptr %8x, length %d\n", s, (int) name, namelen);
 188         dump_sockaddr(name);
 189 #endif
 190
 191         if (connect(s, name, namelen) < 0) {
 192                 errno_to_wsaerrno();
 193                 return SOCKET_ERROR;
 194         }
 195         return 0;
 196 }
 197
 198 INT Winsock_getpeername(SOCKET s, struct sockaddr FAR *name, INT FAR *namelen)
 199 {
 200 #ifdef DEBUG_WINSOCK
 201         fprintf(stderr, "WSA_getpeername: socket: %d, ptr %8x, ptr %8x\n", s, (int) name, *namelen);
 202         dump_sockaddr(name);
 203 #endif
 204
 205         if (getpeername(s, name, (int *) namelen) < 0) {
 206                 errno_to_wsaerrno();
 207                 return SOCKET_ERROR;
 208         }
 209         return 0;
 210 }
 211
 212 INT Winsock_getsockname(SOCKET s, struct sockaddr FAR *name, INT FAR *namelen)
 213 {
 214 #ifdef DEBUG_WINSOCK
 215         fprintf(stderr, "WSA_getsockname: socket: %d, ptr %8x, ptr %8x\n", s, (int) name, (int) *namelen);
 216 #endif
 217         if (getsockname(s, name, (int *) namelen) < 0) {
 218                 errno_to_wsaerrno();
 219                 return SOCKET_ERROR;
 220         }
 221         return 0;
 222 }
 223
 224 INT Winsock_getsockopt(SOCKET s, INT loptname, char FAR *optval, INT FAR *optlen)
 225 {
 226 #ifdef DEBUG_WINSOCK
 227         fprintf(stderr, "WSA_getsockopt: socket: %d, opt %d, ptr %8x, ptr %8x\n", s, loptname, (int) optval, (int) *optlen);
 228 #endif
 229         if (getsockopt(s, 0, (int) loptname, optval, (int *) optlen) < 0) {
 230                 errno_to_wsaerrno();
 231                 return SOCKET_ERROR;
 232         }
 233         return 0;
 234 }
 235
 236 u_long Winsock_htonl(u_long hostlong)
 237 {
 238         return( htonl(hostlong) );
 239 }
 240
 241 u_short Winsock_htons(u_short hostshort)
 242 {
 243         return( htons(hostshort) );
 244 }
 245
 246 u_long Winsock_inet_addr(char FAR *cp)
 247 {
 248         return( inet_addr(cp) );
 249 }
 250
 251 char *Winsock_inet_ntoa(struct in_addr in)
 252 {
 253         char *s;
 254
 255 #ifdef DEBUG_WINSOCK
 256         fprintf(stderr, "WSA_inet_ntoa: %8x\n", in);
 257 #endif
 258
 259         if ((s = inet_ntoa(in)) == NULL) {
 260                 errno_to_wsaerrno();
 261                 return NULL;
 262         }
 263
 264         strncpy(heap->ntoa_buffer, s, sizeof(heap->ntoa_buffer) );
 265
 266         return (char *) &heap->ntoa_buffer;
 267 }
 268
 269 INT Winsock_ioctlsocket(SOCKET s, long cmd, u_long FAR *argp)
 270 {
 271 #ifdef DEBUG_WINSOCK
 272         fprintf(stderr, "WSA_ioctl: socket %d, cmd %d, ptr %8x\n", s, cmd, (int) argp);
 273 #endif
 274
 275         if (ioctl(s, cmd, argp) < 0) {
 276                 errno_to_wsaerrno();
 277                 return SOCKET_ERROR;
 278         }
 279         return 0;
 280 }
 281
 282 INT Winsock_listen(SOCKET s, INT backlog)
 283 {
 284 #ifdef DEBUG_WINSOCK
 285         fprintf(stderr, "WSA_listen: socket %d, backlog %d\n", s, backlog);
 286 #endif
 287
 288         if (listen(s, backlog) < 0) {
 289                 errno_to_wsaerrno();
 290                 return SOCKET_ERROR;
 291         }
 292         return 0;
 293 }
 294
 295 u_long Winsock_ntohl(u_long netlong)
 296 {
 297         return( ntohl(netlong) );
 298 }
 299
 300 u_short Winsock_ntohs(u_short netshort)
 301 {
 302         return( ntohs(netshort) );
 303 }
 304
 305 INT Winsock_recv(SOCKET s, char FAR *buf, INT len, INT flags)
 306 {
 307         int length;
 308
 309 #ifdef DEBUG_WINSOCK
 310         fprintf(stderr, "WSA_recv: socket %d, ptr %8x, length %d, flags %d\n", s, (int) buf, len, flags);
 311 #endif
 312
 313         if ((length = recv(s, buf, len, flags)) < 0) {
 314                 errno_to_wsaerrno();
 315                 return SOCKET_ERROR;
 316         }
 317         return length;
 318 }
 319
 320 INT Winsock_recvfrom(SOCKET s, char FAR *buf, INT len, INT flags,
 321                 struct sockaddr FAR *from, int FAR *fromlen)
 322 {
 323         int length;
 324
 325 #ifdef DEBUG_WINSOCK
 326         fprintf(stderr, "WSA_recvfrom: socket %d, ptr %8x, length %d, flags %d\n", s, buf, len, flags);
 327 #endif
 328
 329         if ((length = recvfrom(s, buf, len, flags, from, fromlen)) < 0) {
 330                 errno_to_wsaerrno();
 331                 return SOCKET_ERROR;
 332         }
 333         return length;
 334 }
 335
 336 INT Winsock_select(INT nfds, fd_set FAR *readfds, fd_set FAR *writefds,
 337         fd_set FAR *exceptfds, struct timeval FAR *timeout)
 338 {
 339 #ifdef DEBUG_WINSOCK
 340         fprintf(stderr, "WSA_select: fd # %d, ptr %8x, ptr %8x, ptr %*X\n", nfds, readfds, writefds, exceptfds);
 341 #endif
 342
 343         return(select(nfds, readfds, writefds, exceptfds, timeout));
 344 }
 345
 346 INT Winsock_send(SOCKET s, char FAR *buf, INT len, INT flags)
 347 {
 348         int length;
 349
 350 #ifdef DEBUG_WINSOCK
 351         fprintf(stderr, "WSA_send: socket %d, ptr %8x, length %d, flags %d\n", s, buf, len, flags);
 352 #endif
 353
 354         if ((length = send(s, buf, len, flags)) < 0) {
 355                 errno_to_wsaerrno();
 356                 return SOCKET_ERROR;
 357         }
 358         return length;
 359 }
 360
 361 INT Winsock_sendto(SOCKET s, char FAR *buf, INT len, INT flags,
 362                 struct sockaddr FAR *to, INT tolen)
 363 {
 364         int length;
 365
 366 #ifdef DEBUG_WINSOCK
 367         fprintf(stderr, "WSA_sendto: socket %d, ptr %8x, length %d, flags %d\n", s, buf, len, flags);
 368 #endif
 369
 370         if ((length = sendto(s, buf, len, flags, to, tolen)) < 0) {
 371                 errno_to_wsaerrno();
 372                 return SOCKET_ERROR;
 373         }
 374         return length;
 375 }
 376
 377 INT Winsock_setsockopt(SOCKET s, INT level, INT optname, const char FAR *optval,
 378                         INT optlen)
 379 {
 380 #ifdef DEBUG_WINSOCK
 381         fprintf(stderr, "WSA_setsockopt: socket %d, level %d, opt %d, ptr %8x, len %d\n", s, level, optname, (int) optval, optlen);
 382 #endif
 383
 384         if (setsockopt(s, level, optname, optval, optlen) < 0) {
 385                 errno_to_wsaerrno();
 386                 return SOCKET_ERROR;
 387         }
 388         return 0;
 389 }
 390
 391 INT Winsock_shutdown(SOCKET s, INT how)
 392 {
 393 #ifdef DEBUG_WINSOCK
 394         fprintf(stderr, "WSA_shutdown: socket s %d, how %d\n", s, how);
 395 #endif
 396
 397         if (shutdown(s, how) < 0) {
 398                 errno_to_wsaerrno();
 399                 return SOCKET_ERROR;
 400         }
 401         return 0;
 402 }
 403
 404 SOCKET Winsock_socket(INT af, INT type, INT protocol)
 405 {
 406     int sock;
 407
 408 #ifdef DEBUG_WINSOCK
 409     fprintf(stderr, "WSA_socket: af=%d type=%d protocol=%d\n", af, type, protocol);
 410 #endif
 411
 412     if ((sock = socket(af, type, protocol)) < 0) {
 413             errno_to_wsaerrno();
 414 #ifdef DEBUG_WINSOCK
 415     fprintf(stderr, "WSA_socket: failed !\n");
 416 #endif
 417             return INVALID_SOCKET;
 418     }
 419
 420     if (sock > 0xffff) {
 421         wsa_errno = WSAEMFILE;
 422         return INVALID_SOCKET;
 423     }
 424
 425     FD_SET(sock, &fd_in_use);
 426
 427 #ifdef DEBUG_WINSOCK
 428     fprintf(stderr, "WSA_socket: fd %d\n", sock);
 429 #endif
 430     return sock;
 431 }
 432
 433 struct hostent *Winsock_gethostbyaddr(const char FAR *addr, INT len, INT type)
 434 {
 435         struct hostent *host;
 436
 437 #ifdef DEBUG_WINSOCK
 438         fprintf(stderr, "WSA_gethostbyaddr: ptr %8x, len %d, type %d\n", (int) addr, len, type);
 439 #endif
 440
 441         if ((host = gethostbyaddr(addr, len, type)) == NULL) {
 442                 errno_to_wsaerrno();
 443                 return NULL;
 444         }
 445         memcpy(&heap->hostent_addr, host, sizeof(struct hostent));
 446
 447         return (struct hostent *) &heap->hostent_addr;
 448 }
 449
 450 struct hostent *Winsock_gethostbyname(const char FAR *name)
 451 {
 452         struct hostent *host;
 453
 454 #ifdef DEBUG_WINSOCK
 455         fprintf(stderr, "WSA_gethostbyname: name %s\n", name);
 456 #endif
 457
 458         if ((host = gethostbyname(name)) == NULL) {
 459                 errno_to_wsaerrno();
 460                 return NULL;
 461         }
 462         memcpy(&heap->hostent_name, host, sizeof(struct hostent));
 463
 464         return (struct hostent *) &heap->hostent_name;
 465 }
 466
 467 int Winsock_gethostname(char FAR *name, INT namelen)
 468 {
 469
 470 #ifdef DEBUG_WINSOCK
 471         fprintf(stderr, "WSA_gethostname: name %d, len %d\n", name, namelen);
 472 #endif
 473
 474         if (gethostname(name, namelen) < 0) {
 475                 errno_to_wsaerrno();
 476                 return SOCKET_ERROR;
 477         }
 478         return 0;
 479 }
 480
 481 struct protoent *Winsock_getprotobyname(char FAR *name)
 482 {
 483         struct protoent *proto;
 484
 485 #ifdef DEBUG_WINSOCK
 486         fprintf(stderr, "WSA_getprotobyname: name %s\n", name);
 487 #endif
 488
 489         if ((proto = getprotobyname(name)) == NULL) {
 490                 errno_to_wsaerrno();
 491                 return NULL;
 492         }
 493         memcpy(&heap->protoent_name, proto, sizeof(struct protoent));
 494
 495         return (struct protoent *) &heap->protoent_name;
 496 }
 497
 498 struct protoent *Winsock_getprotobynumber(INT number)
 499 {
 500         struct protoent *proto;
 501
 502 #ifdef DEBUG_WINSOCK
 503         fprintf(stderr, "WSA_getprotobynumber: num %d\n", number);
 504 #endif
 505
 506         if ((proto = getprotobynumber(number)) == NULL) {
 507                 errno_to_wsaerrno();
 508                 return NULL;
 509         }
 510         memcpy(&heap->protoent_number, proto, sizeof(struct protoent));
 511
 512         return (struct protoent *) &heap->protoent_number;
 513 }
 514
 515 struct servent *Winsock_getservbyname(const char FAR *name, const char FAR *proto)
 516 {
 517         struct servent *service;
 518
 519 #ifdef DEBUG_WINSOCK
 520         fprintf(stderr, "WSA_getservbyname: name %s, proto %s\n", name, proto);
 521 #endif
 522
 523         if ((service = getservbyname(name, proto)) == NULL) {
 524                 errno_to_wsaerrno();
 525                 return NULL;
 526         }
 527         memcpy(&heap->servent_name, service, sizeof(struct servent));
 528
 529         return (struct servent *) &heap->servent_name;
 530 }
 531
 532 struct servent *Winsock_getservbyport(INT port, const char FAR *proto)
 533 {
 534         struct servent *service;
 535
 536 #ifdef DEBUG_WINSOCK
 537         fprintf(stderr, "WSA_getservbyport: port %d, name %s\n", port, proto);
 538 #endif
 539
 540         if ((service = getservbyport(port, proto)) == NULL) {
 541                 errno_to_wsaerrno();
 542                 return NULL;
 543         }
 544         memcpy(&heap->servent_port, service, sizeof(struct servent));
 545
 546         return (struct servent *) &heap->servent_port;
 547 }
 548
 549 /******************** winsock specific functions ************************
 550  *
 551  */
 552 static HANDLE new_handle = 0;
 553
 554 HANDLE AllocWSAHandle(void)
 555 {
 556         return new_handle++;
 557 }
 558
 559 static void recv_message(int sig)
 560 {
 561         struct ipc_packet message;
 562
 563         if (msgrcv(wine_key, &message, IPC_PACKET_SIZE, MTYPE, IPC_NOWAIT) == -1)
 564                 perror("wine: msgrcv");
 565
 566         fprintf(stderr,
 567                 "WSA: PostMessage (hwnd %d, wMsg %d, wParam %d, lParam %d)\n",
 568                 message.hWnd,
 569                 message.wMsg,
 570                 message.handle,
 571                 message.lParam);
 572
 573         PostMessage(message.hWnd, message.wMsg, message.handle, message.lParam);
 574
 575         signal(SIGUSR1, recv_message);
 576 }
 577
 578
 579 static void send_message(HANDLE handle, HWND hWnd, u_int wMsg, long lParam)
 580 {
 581         struct ipc_packet message;
 582
 583         message.mtype = MTYPE;
 584         message.handle = handle;
 585         message.hWnd = hWnd;
 586         message.wMsg = wMsg;
 587         message.lParam = lParam;
 588
 589         fprintf(stderr,
 590                 "WSA: send (hwnd %d, wMsg %d, handle %d, lParam %d)\n",
 591                 hWnd, wMsg, handle, lParam);
 592
 593         if (msgsnd(wine_key, &message,  IPC_PACKET_SIZE, IPC_NOWAIT) == -1)
 594                 perror("wine: msgsnd");
 595
 596         kill(getppid(), SIGUSR1);
 597 }
 598
 599
 600 HANDLE WSAAsyncGetHostByAddr(HWND hWnd, u_int wMsg, const char FAR *addr,
 601                  INT len, INT type, char FAR *buf, INT buflen)
 602 {
 603         HANDLE handle;
 604         struct hostent *host;
 605
 606         handle = AllocWSAHandle();
 607
 608         if (fork()) {
 609                 return handle;
 610         } else {
 611                 if ((host = gethostbyaddr(addr, len, type)) == NULL) {
 612                         send_message(hWnd, wMsg, handle, wsaerrno() << 16);
 613                         exit(0);
 614                 }
 615                 memcpy(buf, host, buflen);
 616                 send_message(hWnd, wMsg, handle, 0);
 617                 exit(0);
 618         }
 619 }
 620
 621
 622 HANDLE WSAAsyncGetHostByName(HWND hWnd, u_int wMsg, const char FAR *name,
 623                         char FAR *buf, INT buflen)
 624 {
 625         HANDLE handle;
 626         struct hostent *host;
 627
 628         handle = AllocWSAHandle();
 629
 630         if (fork()) {
 631                 return handle;
 632         } else {
 633                 if ((host = gethostbyname(name)) == NULL) {
 634                         send_message(hWnd, wMsg, handle, wsaerrno() << 16);
 635                         exit(0);
 636                 }
 637                 memcpy(buf, host, buflen);
 638                 send_message(hWnd, wMsg, handle, 0);
 639                 exit(0);
 640         }
 641 }
 642
 643
 644 HANDLE WSAAsyncGetProtoByName(HWND hWnd, u_int wMsg, const char FAR *name,
 645                         char FAR *buf, INT buflen)
 646 {
 647         HANDLE handle;
 648         struct protoent *proto;
 649
 650         handle = AllocWSAHandle();
 651
 652         if (fork()) {
 653                 return handle;
 654         } else {
 655                 if ((proto = getprotobyname(name)) == NULL) {
 656                         send_message(hWnd, wMsg, handle, wsaerrno() << 16);
 657                         exit(0);
 658                 }
 659                 memcpy(buf, proto, buflen);
 660                 send_message(hWnd, wMsg, handle, 0);
 661                 exit(0);
 662         }
 663 }
 664
 665
 666 HANDLE WSAAsyncGetProtoByNumber(HWND hWnd, u_int wMsg, INT number,
 667                         char FAR *buf, INT buflen)
 668 {
 669         HANDLE handle;
 670         struct protoent *proto;
 671
 672         handle = AllocWSAHandle();
 673
 674         if (fork()) {
 675                 return handle;
 676         } else {
 677                 if ((proto = getprotobynumber(number)) == NULL) {
 678                         send_message(hWnd, wMsg, handle, wsaerrno() << 16);
 679                         exit(0);
 680                 }
 681                 memcpy(buf, proto, buflen);
 682                 send_message(hWnd, wMsg, handle, 0);
 683                 exit(0);
 684         }
 685 }
 686
 687
 688 HANDLE WSAAsyncGetServByName(HWND hWnd, u_int wMsg, const char FAR *name,
 689                         const char FAR *proto, char FAR *buf, INT buflen)
 690 {
 691         HANDLE handle;
 692         struct servent *service;
 693
 694         handle = AllocWSAHandle();
 695
 696         if (fork()) {
 697                 return handle;
 698         } else {
 699                 if ((service = getservbyname(name, proto)) == NULL) {
 700                         send_message(hWnd, wMsg, handle, wsaerrno() << 16);
 701                         exit(0);
 702                 }
 703                 memcpy(buf, service, buflen);
 704                 send_message(hWnd, wMsg, handle, 0);
 705                 exit(0);
 706         }
 707 }
 708
 709
 710 HANDLE WSAAsyncGetServByPort(HWND hWnd, u_int wMsg, INT port, const char FAR
 711                         *proto, char FAR *buf, INT buflen)
 712 {
 713         HANDLE handle;
 714         struct servent *service;
 715
 716         handle = AllocWSAHandle();
 717
 718         if (fork()) {
 719                 return handle;
 720         } else {
 721                 if ((service = getservbyport(port, proto)) == NULL) {
 722                         send_message(hWnd, wMsg, handle, wsaerrno() << 16);
 723                         exit(0);
 724                 }
 725                 memcpy(buf, service, buflen);
 726                 send_message(hWnd, wMsg, handle, 0);
 727                 exit(0);
 728         }
 729 }
 730
 731 INT WSAAsyncSelect(SOCKET s, HWND hWnd, u_int wMsg, long lEvent)
 732 {
 733         long event;
 734         fd_set read_fds, write_fds, except_fds;
 735
 736 #ifdef DEBUG_WINSOCK
 737         fprintf(stderr, "WSA_AsyncSelect: socket %d, HWND %d, wMsg %d, event %d\n", s, hWnd, wMsg, lEvent);
 738 #endif
 739
 740         /* remove outstanding asyncselect() processes */
 741         /* kill */
 742
 743         if (wMsg == 0 && lEvent == 0)
 744                 return 0;
 745
 746         if (fork()) {
 747                 return 0;
 748         } else {
 749                 while (1) {
 750                         FD_ZERO(&read_fds);
 751                         FD_ZERO(&write_fds);
 752                         FD_ZERO(&except_fds);
 753
 754                         if (lEvent & FD_READ)
 755                                 FD_SET(s, &read_fds);
 756                         if (lEvent & FD_WRITE)
 757                                 FD_SET(s, &write_fds);
 758
 759                         fcntl(s, F_SETFL, O_NONBLOCK);
 760                         select(s + 1, &read_fds, &write_fds, &except_fds, NULL);
 761
 762                         event = 0;
 763                         if (FD_ISSET(s, &read_fds))
 764                                 event |= FD_READ;
 765                         if (FD_ISSET(s, &write_fds))
 766                                 event |= FD_WRITE;
 767
 768                         send_message(hWnd, wMsg, s, (wsaerrno() << 16) | event);
 769                 }
 770         }
 771 }
 772
 773 INT WSAFDIsSet(INT fd, fd_set *set)
 774 {
 775         return( FD_ISSET(fd, set) );
 776 }
 777
 778 INT WSACancelAsyncRequest(HANDLE hAsyncTaskHandle)
 779 {
 780 #ifdef DEBUG_WINSOCK
 781         fprintf(stderr, "WSA_AsyncRequest: handle %d\n", hAsyncTaskHandle);
 782 #endif
 783
 784         return 0;
 785 }
 786
 787 INT WSACancelBlockingCall(void)
 788 {
 789 #ifdef DEBUG_WINSOCK
 790         fprintf(stderr, "WSA_CancelBlockCall\n");
 791 #endif
 792         return 0;
 793 }
 794
 795 INT WSAGetLastError(void)
 796 {
 797 #ifdef DEBUG_WINSOCK
 798         fprintf(stderr, "WSA_GetLastError\n");
 799 #endif
 800
 801     return wsa_errno;
 802 }
 803
 804 void WSASetLastError(INT iError)
 805 {
 806 #ifdef DEBUG_WINSOCK
 807         fprintf(stderr, "WSA_SetLastErorr %d\n", iError);
 808 #endif
 809
 810     wsa_errno = iError;
 811 }
 812
 813 BOOL WSAIsBlocking(void)
 814 {
 815 #ifdef DEBUG_WINSOCK
 816         fprintf(stderr, "WSA_IsBlocking\n");
 817 #endif
 818 }
 819
 820 FARPROC WSASetBlockingHook(FARPROC lpBlockFunc)
 821 {
 822 #ifdef DEBUG_WINSOCK
 823         fprintf(stderr, "WSA_SetBlockHook %8x, STUB!\n", lpBlockFunc);
 824 #endif
 825         BlockFunction = lpBlockFunc;
 826
 827         return lpBlockFunc;
 828 }
 829
 830 INT WSAUnhookBlockingHook(void)
 831 {
 832 #ifdef DEBUG_WINSOCK
 833         fprintf(stderr, "WSA_UnhookBlockingHook\n");
 834 #endif
 835         BlockFunction = NULL;
 836
 837         return 0;
 838 }
 839
 840 WSADATA Winsock_data = {
 841         0x0101,
 842         0x0101,
 843         "WINE Sockets",
 844 #ifdef linux
 845         "LINUX/i386",
 846 #endif
 847 #ifdef __NetBSD__
 848         "NetBSD/i386",
 849 #endif
 850 #ifdef sunos
 851         "SunOS",
 852 #endif
 853         128,
 854         1024,
 855         NULL
 856 };
 857
 858 INT WSAStartup(WORD wVersionRequested, LPWSADATA lpWSAData)
 859 {
 860     int HeapHandle;
 861     MDESC *MyHeap;
 862
 863 #ifdef DEBUG_WINSOCK
 864     fprintf(stderr, "WSAStartup: verReq=%x\n", wVersionRequested);
 865 #endif
 866
 867     if (LOBYTE(wVersionRequested) < 1 ||
 868         (LOBYTE(wVersionRequested) == 1 &&
 869          HIBYTE(wVersionRequested) < 1))
 870         return WSAVERNOTSUPPORTED;
 871
 872     if (!lpWSAData)
 873         return WSAEINVAL;
 874
 875         /* alloc winsock heap */
 876
 877     if ((HeapHandle = GlobalAlloc(GMEM_FIXED,sizeof(struct WinSockHeap))) == 0)
 878         return WSASYSNOTREADY;
 879
 880     heap = (struct WinSockHeap *) GlobalLock(HeapHandle);
 881 #ifndef WINELIB
 882     HEAP_Init(&MyHeap, heap, sizeof(struct WinSockHeap));
 883 #endif
 884     bcopy(&Winsock_data, lpWSAData, sizeof(Winsock_data));
 885
 886     /* ipc stuff */
 887
 888     if ((wine_key = msgget(IPC_PRIVATE, 0600)) == -1)
 889         perror("wine: msgget");
 890
 891     signal(SIGUSR1, recv_message);
 892
 893     /* clear */
 894
 895     FD_ZERO(&fd_in_use);
 896
 897     wsa_initted = 1;
 898     return(0);
 899 }
 900
 901 INT WSACleanup(void)
 902 {
 903         int fd;
 904
 905         if (wine_key)
 906                 if (msgctl(wine_key, IPC_RMID, NULL) == -1)
 907                         perror("wine: shmctl");
 908
 909         for (fd = 0; fd != FD_SETSIZE; fd++)
 910                 if (FD_ISSET(fd, &fd_in_use))
 911                         close(fd);
 912
 913         wsa_initted = 0;
 914         return 0;
 915 }