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 <sys/types.h>
  11 #include <sys/socket.h>
  12 #include <netinet/in.h>
  13 #include <arpa/inet.h>
  14 #include <errno.h>
  15 #include <netdb.h>
  16 #include <unistd.h>
  17 #include "winsock.h"
  18
  19 #define DEBUG_WINSOCK
  20
  21 /* XXX per task */
  22 WORD wsa_errno;
  23 int  wsa_initted;
  24
  25 WORD errno_to_wsaerrno(int errno)
  26 {
  27         switch(errno) {
  28         case ENETDOWN:
  29                 return WSAENETDOWN;
  30         case EAFNOSUPPORT:
  31                 return WSAEAFNOSUPPORT;
  32         case EMFILE:
  33                 return WSAEMFILE;
  34         case ENOBUFS:
  35                 return WSAENOBUFS;
  36         case EPROTONOSUPPORT:
  37                 return EPROTONOSUPPORT;
  38         case EPROTOTYPE:
  39                 return WSAEPROTOTYPE;
  40         case EBADF:
  41         case ENOTSOCK:
  42                 return WSAENOTSOCK;
  43
  44         default:
  45 #ifndef sun
  46 #if defined(__FreeBSD__)
  47                 fprintf(stderr, "winsock: errno_to_wsaerrno translation failure.\n\t: %s (%d)\n",
  48                         sys_errlist[errno], errno);
  49 #else
  50                 fprintf(stderr, "winsock: errno_to_wsaerrno translation failure.\n\t: %s (%d)\n",
  51                         strerror[errno], errno);
  52 #endif
  53 #else
  54                 fprintf (stderr, "winsock: errno_to_wsaerrno translation failure.\n");
  55 #endif
  56                 return WSAENETDOWN;
  57         }
  58 }
  59
  60 SOCKET Winsock_accept(SOCKET s, struct sockaddr FAR *addr, int FAR *addrlen)
  61 {
  62         int sock;
  63
  64         if ((sock = accept(s, addr, addrlen)) < 0) {
  65                 wsa_errno = errno_to_wsaerrno(errno);
  66                 return INVALID_SOCKET;
  67         }
  68         return sock;
  69 }
  70
  71 int Winsock_bind(SOCKET s, struct sockaddr FAR *name, int namelen)
  72 {
  73         if (bind(s, name, namelen) < 0) {
  74                 wsa_errno = errno_to_wsaerrno(errno);
  75                 return SOCKET_ERROR;
  76         }
  77         return 0;
  78 }
  79
  80 int Winsock_closesocket(SOCKET s)
  81 {
  82         if (close(s) < 0) {
  83                 wsa_errno = errno_to_wsaerrno(errno);
  84                 return SOCKET_ERROR;
  85         }
  86         return 0;
  87 }
  88
  89 int Winsock_connect(SOCKET s, struct sockaddr FAR *name, int namelen)
  90 {
  91         if (connect(s, name, namelen) < 0) {
  92                 wsa_errno = errno_to_wsaerrno(errno);
  93                 return SOCKET_ERROR;
  94         }
  95         return 0;
  96 }
  97
  98 int Winsock_getpeername(SOCKET s, struct sockaddr FAR *name, int FAR *namelen)
  99 {
 100         if (getpeername(s, name, namelen) < 0) {
 101                 wsa_errno = errno_to_wsaerrno(errno);
 102                 return SOCKET_ERROR;
 103         }
 104         return 0;
 105 }
 106
 107 int Winsock_getsockname(SOCKET s, struct sockaddr FAR *name, int FAR *namelen)
 108 {
 109         if (getsockname(s, name, namelen) < 0) {
 110                 wsa_errno = errno_to_wsaerrno(errno);
 111                 return SOCKET_ERROR;
 112         }
 113         return 0;
 114 }
 115
 116 int Winsock_getsockopt(SOCKET s, int loptname, char FAR *optval, int FAR *optlen)
 117 {
 118         if (getsockopt(s, 0, loptname, optval, optlen) < 0) {
 119                 wsa_errno = errno_to_wsaerrno(errno);
 120                 return SOCKET_ERROR;
 121         }
 122         return 0;
 123 }
 124
 125 u_long Winsock_htonl(u_long hostlong)
 126 {
 127         return( htonl(hostlong) );
 128 }
 129
 130 u_short Winsock_htons(u_short hostshort)
 131 {
 132         return( htons(hostshort) );
 133 }
 134
 135 u_long Winsock_inet_addr(char FAR *cp)
 136 {
 137         return( inet_addr(cp) );
 138 }
 139
 140 char *Winsock_inet_ntoa(struct in_addr in)
 141 {
 142         char *s;
 143
 144         if ((s = inet_ntoa(in)) == NULL) {
 145                 wsa_errno = errno_to_wsaerrno(errno);
 146                 return NULL;
 147         }
 148         return s;
 149 }
 150
 151 int Winsock_ioctlsocket(SOCKET s, long cmd, u_long FAR *argp)
 152 {
 153         if (ioctl(s, cmd, argp) < 0) {
 154                 wsa_errno = errno_to_wsaerrno(errno);
 155                 return SOCKET_ERROR;
 156         }
 157         return 0;
 158 }
 159
 160 int Winsock_listen(SOCKET s, int backlog)
 161 {
 162         if (listen(s, backlog) < 0) {
 163                 wsa_errno = errno_to_wsaerrno(errno);
 164                 return SOCKET_ERROR;
 165         }
 166         return 0;
 167 }
 168
 169 u_long Winsock_ntohl(u_long netlong)
 170 {
 171         return( ntohl(netlong) );
 172 }
 173
 174 u_short Winsock_ntohs(u_short netshort)
 175 {
 176         return( ntohs(netshort) );
 177 }
 178
 179 int Winsock_recv(SOCKET s, char FAR *buf, int len, int flags)
 180 {
 181         int length;
 182
 183         if ((length = recv(s, buf, len, flags)) < 0) {
 184                 wsa_errno = errno_to_wsaerrno(errno);
 185                 return SOCKET_ERROR;
 186         }
 187         return length;
 188 }
 189
 190 int Winsock_recvfrom(SOCKET s, char FAR *buf, int len, int flags,
 191                 struct sockaddr FAR *from, int FAR *fromlen)
 192 {
 193         int length;
 194
 195         if ((length = recvfrom(s, buf, len, flags, from, fromlen)) < 0) {
 196                 wsa_errno = errno_to_wsaerrno(errno);
 197                 return SOCKET_ERROR;
 198         }
 199         return length;
 200 }
 201
 202 int Winsock_select(int nfds, fd_set FAR *readfds, fd_set FAR *writefds,
 203         fd_set FAR *exceptfds, struct timeval FAR *timeout)
 204 {
 205         return(select(nfds, readfds, writefds, exceptfds, timeout));
 206 }
 207
 208 int Winsock_send(SOCKET s, char FAR *buf, int len, int flags)
 209 {
 210         int length;
 211
 212         if ((length = send(s, buf, len, flags)) < 0) {
 213                 wsa_errno = errno_to_wsaerrno(errno);
 214                 return SOCKET_ERROR;
 215         }
 216         return length;
 217 }
 218
 219 int Winsock_sendto(SOCKET s, char FAR *buf, int len, int flags,
 220                 struct sockaddr FAR *to, int tolen)
 221 {
 222         int length;
 223
 224         if ((length = sendto(s, buf, len, flags, to, tolen)) < 0) {
 225                 wsa_errno = errno_to_wsaerrno(errno);
 226                 return SOCKET_ERROR;
 227         }
 228         return length;
 229 }
 230
 231 int Winsock_setsockopt(SOCKET s, int level, int optname, const char FAR *optval,
 232                 int optlen)
 233 {
 234         if (setsockopt(s, level, optname, optval, optlen) < 0) {
 235                 wsa_errno = errno_to_wsaerrno(errno);
 236                 return SOCKET_ERROR;
 237         }
 238         return 0;
 239 }
 240
 241 int Winsock_shutdown(SOCKET s, int how)
 242 {
 243         if (shutdown(s, how) < 0) {
 244                 wsa_errno = errno_to_wsaerrno(errno);
 245                 return SOCKET_ERROR;
 246         }
 247         return 0;
 248 }
 249
 250 SOCKET Winsock_socket(WORD af, WORD type, WORD protocol)
 251 {
 252     int sock;
 253
 254 #ifdef DEBUG_WINSOCK
 255     printf("Winsock_socket: af=%d type=%d protocol=%d\n", af, type, protocol);
 256 #endif
 257
 258 /*  let the kernel do the dirty work..
 259
 260     if (!wsa_initted) {
 261             wsa_errno = WSANOTINITIALISED;
 262             return INVALID_SOCKET;
 263     }
 264 */
 265     if ((sock = socket(af, type, protocol)) < 0) {
 266             wsa_errno = errno_to_wsaerrno(errno);
 267             return INVALID_SOCKET;
 268     }
 269     return sock;
 270 }
 271
 272 struct hostent *Winsock_gethostbyaddr(const char FAR *addr, int len,  int type)
 273 {
 274         struct hostent *host;
 275
 276         if ((host = gethostbyaddr(addr, len, type)) == NULL) {
 277                 wsa_errno = errno_to_wsaerrno(errno);
 278                 return NULL;
 279         }
 280         return host;
 281 }
 282
 283 struct hostent *Winsock_gethostbyname(const char FAR *name)
 284 {
 285         struct hostent *host;
 286
 287         if ((host = gethostbyname(name)) == NULL) {
 288                 wsa_errno = errno_to_wsaerrno(errno);
 289                 return NULL;
 290         }
 291         return host;
 292 }
 293
 294 int Winsock_gethostname(char FAR *name, int namelen)
 295 {
 296         if (gethostname(name, namelen) < 0) {
 297                 wsa_errno = errno_to_wsaerrno(errno);
 298                 return SOCKET_ERROR;
 299         }
 300         return 0;
 301 }
 302
 303 struct protoent *Winsock_getprotobyname(char FAR *name)
 304 {
 305         struct protoent *proto;
 306
 307         if ((proto = getprotobyname(name)) == NULL) {
 308                 wsa_errno = errno_to_wsaerrno(errno);
 309                 return NULL;
 310         }
 311         return proto;
 312 }
 313
 314 struct protoent *Winsock_getprotobynumber(int number)
 315 {
 316         struct protoent *proto;
 317
 318         if ((proto = getprotobynumber(number)) == NULL) {
 319                 wsa_errno = errno_to_wsaerrno(errno);
 320                 return NULL;
 321         }
 322         return proto;
 323 }
 324
 325 struct servent *Winsock_getservbyname(const char FAR *name, const char FAR *proto)
 326 {
 327         struct servent *service;
 328
 329         if ((service = getservbyname(name, proto)) == NULL) {
 330                 wsa_errno = errno_to_wsaerrno(errno);
 331                 return NULL;
 332         }
 333         return service;
 334 }
 335
 336 struct servent *Winsock_getservbyport(int port, const char FAR *proto)
 337 {
 338         struct servent *service;
 339
 340         if ((service = getservbyport(port, proto)) == NULL) {
 341                 wsa_errno = errno_to_wsaerrno(errno);
 342                 return NULL;
 343         }
 344         return service;
 345 }
 346
 347 HANDLE WSAAsyncGetHostByAddr(HWND hWnd, u_int wMsg, const char FAR *addr,
 348                  int len, int type, const char FAR *buf, int buflen)
 349 {
 350
 351 }
 352
 353 HANDLE WSAAsyncGetHostByName(HWND hWnd, u_int wMsg, const char FAR *name,
 354                         char FAR *buf, int buflen)
 355 {
 356
 357 }
 358
 359 HANDLE WSAAsyncGetProtoByName(HWND hWnd, u_int wMsg, const char FAR *name,
 360                         char FAR *buf, int buflen)
 361 {
 362
 363 }
 364
 365 HANDLE WSAAsyncGetProtoByNumber(HWND hWnd, u_int wMsg, int number,
 366                         char FAR *buf, int buflen)
 367 {
 368
 369 }
 370
 371 HANDLE WSAAsyncGetServByName(HWND hWnd, u_int wMsg, const char FAR *name,
 372                         const char FAR *proto, char FAR *buf, int buflen)
 373 {
 374
 375 }
 376
 377 HANDLE WSAAsyncGetServByPort(HWND hWnd, u_int wMsg, int port, const char FAR
 378                         *proto, char FAR *buf, int buflen)
 379 {
 380
 381 }
 382
 383 int WSAAsyncSelect(SOCKET s, HWND hWnd, u_int wMsg, long lEvent)
 384 {
 385
 386 }
 387
 388 int WSAFDIsSet(int fd, fd_set *set)
 389 {
 390         return( FD_ISSET(fd, set) );
 391 }
 392
 393 WSACancelAsyncRequest(HANDLE hAsyncTaskHandle)
 394 {
 395
 396 }
 397
 398 WSACancelBlockingCall ( void )
 399 {
 400
 401 }
 402
 403 int WSAGetLastError(void)
 404 {
 405     return wsa_errno;
 406 }
 407
 408 void WSASetLastError(int iError)
 409 {
 410     wsa_errno = iError;
 411 }
 412
 413 BOOL WSAIsBlocking (void)
 414 {
 415
 416 }
 417
 418 FARPROC WSASetBlockingHook(FARPROC lpBlockFunc)
 419 {
 420
 421 }
 422
 423 int WSAUnhookBlockingHook(void)
 424 {
 425
 426 }
 427
 428 WSADATA Winsock_data = {
 429         0x0101,
 430         0x0101,
 431         "WINE Sockets",
 432 #ifdef linux
 433         "LINUX/i386",
 434 #endif
 435 #ifdef __NetBSD__
 436         "NetBSD/i386",
 437 #endif
 438 #ifdef sunos
 439         "SunOS",
 440 #endif
 441         128,
 442         1024,
 443         NULL
 444 };
 445
 446 int WSAStartup(WORD wVersionRequested, LPWSADATA lpWSAData)
 447 {
 448 #ifdef DEBUG_WINSOCK
 449     fprintf(stderr, "WSAStartup: verReq=%x\n", wVersionRequested);
 450 #endif
 451
 452     if (LOBYTE(wVersionRequested) < 1 ||
 453         (LOBYTE(wVersionRequested) == 1 &&
 454          HIBYTE(wVersionRequested) < 1))
 455         return WSAVERNOTSUPPORTED;
 456
 457     if (!lpWSAData)
 458         return WSAEINVAL;
 459
 460     bcopy(&Winsock_data, lpWSAData, sizeof(Winsock_data));
 461
 462     wsa_initted = 1;
 463
 464     return(0);
 465 }
 466
 467 int WSACleanup(void)
 468 {
 469     wsa_initted = 0;
 470     return 0;
 471 }