win32/wincesck.c

   1 /* Time-stamp: <01/08/01 21:01:12 keuchel@w2k> */
   2
   3 /* wincesck.c
   4  *
   5  * (c) 1995 Microsoft Corporation. All rights reserved.
   6  *              Developed by hip communications inc., http://info.hip.com/info/
   7  * Portions (c) 1993 Intergraph Corporation. All rights reserved.
   8  *
   9  *    You may distribute under the terms of either the GNU General Public
  10  *    License or the Artistic License, as specified in the README file.
  11  */
  12
  13 /* The socket calls use fd functions from celib... */
  14
  15 #define WIN32IO_IS_STDIO
  16 #define WIN32SCK_IS_STDSCK
  17 #define WIN32_LEAN_AND_MEAN
  18
  19 #ifdef __GNUC__
  20 #define Win32_Winsock
  21 #endif
  22
  23 #include <windows.h>
  24
  25 #define wince_private
  26 #include "errno.h"
  27
  28 #include "EXTERN.h"
  29 #include "perl.h"
  30
  31 #include "Win32iop.h"
  32 #include <sys/socket.h>
  33
  34 #ifndef UNDER_CE
  35 #include <fcntl.h>
  36 #include <sys/stat.h>
  37 #include <assert.h>
  38 #include <io.h>
  39 #endif
  40
  41 #ifdef UNDER_CE
  42
  43 XCE_EXPORT struct servent *xcegetservbyname(const char *sname, const char *sproto);
  44 XCE_EXPORT struct servent * xcegetservbyport(int aport, const char *sproto);
  45 XCE_EXPORT struct protoent *xcegetprotobyname(const char *name);
  46 XCE_EXPORT struct protoent *xcegetprotobynumber(int number);
  47
  48 #define getservbyname xcegetservbyname
  49 #define getservbyport xcegetservbyport
  50 #define getprotobyname xcegetprotobyname
  51 #define getprotobynumber xcegetprotobynumber
  52
  53 /* uses fdtab... */
  54 #include "cesocket2.h"
  55
  56 #endif
  57
  58 #define TO_SOCKET(X) (X)
  59
  60 #define StartSockets() \
  61     STMT_START {                                        \
  62         if (!wsock_started) {                           \
  63             start_sockets();                            \
  64             set_socktype();                             \
  65         }                                               \
  66     } STMT_END
  67
  68 #define SOCKET_TEST(x, y) \
  69     STMT_START {                                        \
  70         StartSockets();                                 \
  71         if((x) == (y))                                  \
  72             errno = WSAGetLastError();                  \
  73     } STMT_END
  74
  75 #define SOCKET_TEST_ERROR(x) SOCKET_TEST(x, SOCKET_ERROR)
  76
  77 static struct servent* win32_savecopyservent(struct servent*d,
  78                                              struct servent*s,
  79                                              const char *proto);
  80
  81 static int wsock_started = 0;
  82
  83 EXTERN_C void
  84 EndSockets(void)
  85 {
  86     if (wsock_started)
  87         WSACleanup();
  88 }
  89
  90 void
  91 start_sockets(void)
  92 {
  93     dTHX;
  94     unsigned short version;
  95     WSADATA retdata;
  96     int ret;
  97
  98     /*
  99      * initalize the winsock interface and insure that it is
 100      * cleaned up at exit.
 101      */
 102     version = 0x101;
 103     if(ret = WSAStartup(version, &retdata))
 104         Perl_croak_nocontext("Unable to locate winsock library!\n");
 105     if(retdata.wVersion != version)
 106         Perl_croak_nocontext("Could not find version 1.1 of winsock dll\n");
 107
 108     /* atexit((void (*)(void)) EndSockets); */
 109     wsock_started = 1;
 110 }
 111
 112 void
 113 set_socktype(void)
 114 {
 115 }
 116
 117 u_long
 118 win32_htonl(u_long hostlong)
 119 {
 120     StartSockets();
 121     return htonl(hostlong);
 122 }
 123
 124 u_short
 125 win32_htons(u_short hostshort)
 126 {
 127     StartSockets();
 128     return htons(hostshort);
 129 }
 130
 131 u_long
 132 win32_ntohl(u_long netlong)
 133 {
 134     StartSockets();
 135     return ntohl(netlong);
 136 }
 137
 138 u_short
 139 win32_ntohs(u_short netshort)
 140 {
 141     StartSockets();
 142     return ntohs(netshort);
 143 }
 144
 145 SOCKET
 146 win32_socket(int af, int type, int protocol)
 147 {
 148   StartSockets();
 149   return xcesocket(af, type, protocol);
 150 }
 151
 152 SOCKET
 153 win32_accept(SOCKET s, struct sockaddr *addr, int *addrlen)
 154 {
 155   StartSockets();
 156   return xceaccept(s, addr, addrlen);
 157 }
 158
 159 int
 160 win32_bind(SOCKET s, const struct sockaddr *addr, int addrlen)
 161 {
 162   StartSockets();
 163   return xcebind(s, addr, addrlen);
 164 }
 165
 166 int
 167 win32_connect(SOCKET s, const struct sockaddr *addr, int addrlen)
 168 {
 169   StartSockets();
 170   return xceconnect(s, addr, addrlen);
 171 }
 172
 173
 174 int
 175 win32_getpeername(SOCKET s, struct sockaddr *addr, int *addrlen)
 176 {
 177   StartSockets();
 178   return xcegetpeername(s, addr, addrlen);
 179 }
 180
 181 int
 182 win32_getsockname(SOCKET s, struct sockaddr *addr, int *addrlen)
 183 {
 184   StartSockets();
 185   return xcegetsockname(s, addr, addrlen);
 186 }
 187
 188 int
 189 win32_getsockopt(SOCKET s, int level, int optname, char *optval, int *optlen)
 190 {
 191   StartSockets();
 192   return xcegetsockopt(s, level, optname, optval, optlen);
 193 }
 194
 195 int
 196 win32_ioctlsocket(SOCKET s, long cmd, u_long *argp)
 197 {
 198   StartSockets();
 199   return xceioctlsocket(s, cmd, argp);
 200 }
 201
 202 int
 203 win32_listen(SOCKET s, int backlog)
 204 {
 205   StartSockets();
 206   return xcelisten(s, backlog);
 207 }
 208
 209 int
 210 win32_recv(SOCKET s, char *buf, int len, int flags)
 211 {
 212   StartSockets();
 213   return xcerecv(s, buf, len, flags);
 214 }
 215
 216 int
 217 win32_recvfrom(SOCKET s, char *buf, int len, int flags,
 218                struct sockaddr *from, int *fromlen)
 219 {
 220   StartSockets();
 221   return xcerecvfrom(s, buf, len, flags, from, fromlen);
 222 }
 223
 224 int
 225 win32_select(int nfds, Perl_fd_set* rd, Perl_fd_set* wr,
 226              Perl_fd_set* ex, const struct timeval* timeout)
 227 {
 228   StartSockets();
 229   /* select not yet fixed */
 230   errno = ENOSYS;
 231   return -1;
 232 }
 233
 234 int
 235 win32_send(SOCKET s, const char *buf, int len, int flags)
 236 {
 237   StartSockets();
 238   return xcesend(s, buf, len, flags);
 239 }
 240
 241 int
 242 win32_sendto(SOCKET s, const char *buf, int len, int flags,
 243              const struct sockaddr *to, int tolen)
 244 {
 245   StartSockets();
 246   return xcesendto(s, buf, len, flags, to, tolen);
 247 }
 248
 249 int
 250 win32_setsockopt(SOCKET s, int level, int optname,
 251                  const char *optval, int optlen)
 252 {
 253   StartSockets();
 254   return xcesetsockopt(s, level, optname, optval, optlen);
 255 }
 256
 257 int
 258 win32_shutdown(SOCKET s, int how)
 259 {
 260   StartSockets();
 261   return xceshutdown(s, how);
 262 }
 263
 264 int
 265 win32_closesocket(SOCKET s)
 266 {
 267   StartSockets();
 268   return xceclosesocket(s);
 269 }
 270
 271 struct hostent *
 272 win32_gethostbyaddr(const char *addr, int len, int type)
 273 {
 274   struct hostent *r;
 275
 276   SOCKET_TEST(r = gethostbyaddr(addr, len, type), NULL);
 277   return r;
 278 }
 279
 280 struct hostent *
 281 win32_gethostbyname(const char *name)
 282 {
 283   struct hostent *r;
 284
 285   SOCKET_TEST(r = gethostbyname(name), NULL);
 286   return r;
 287 }
 288
 289 int
 290 win32_gethostname(char *name, int len)
 291 {
 292   int r;
 293
 294   SOCKET_TEST_ERROR(r = gethostname(name, len));
 295   return r;
 296 }
 297
 298 struct protoent *
 299 win32_getprotobyname(const char *name)
 300 {
 301     struct protoent *r;
 302
 303     SOCKET_TEST(r = getprotobyname(name), NULL);
 304     return r;
 305 }
 306
 307 struct protoent *
 308 win32_getprotobynumber(int num)
 309 {
 310     struct protoent *r;
 311
 312     SOCKET_TEST(r = getprotobynumber(num), NULL);
 313     return r;
 314 }
 315
 316 struct servent *
 317 win32_getservbyname(const char *name, const char *proto)
 318 {
 319     dTHX;
 320     struct servent *r;
 321
 322     SOCKET_TEST(r = getservbyname(name, proto), NULL);
 323     if (r) {
 324         r = win32_savecopyservent(&w32_servent, r, proto);
 325     }
 326     return r;
 327 }
 328
 329 struct servent *
 330 win32_getservbyport(int port, const char *proto)
 331 {
 332     dTHX;
 333     struct servent *r;
 334
 335     SOCKET_TEST(r = getservbyport(port, proto), NULL);
 336     if (r) {
 337         r = win32_savecopyservent(&w32_servent, r, proto);
 338     }
 339     return r;
 340 }
 341
 342 int
 343 win32_ioctl(int i, unsigned int u, char *data)
 344 {
 345     dTHX;
 346     u_long u_long_arg;
 347     int retval;
 348
 349     if (!wsock_started) {
 350         Perl_croak_nocontext("ioctl implemented only on sockets");
 351         /* NOTREACHED */
 352     }
 353
 354     /* mauke says using memcpy avoids alignment issues */
 355     memcpy(&u_long_arg, data, sizeof u_long_arg);
 356     retval = ioctlsocket(TO_SOCKET(i), (long)u, &u_long_arg);
 357     memcpy(data, &u_long_arg, sizeof u_long_arg);
 358
 359     if (retval == SOCKET_ERROR) {
 360         if (WSAGetLastError() == WSAENOTSOCK) {
 361             Perl_croak_nocontext("ioctl implemented only on sockets");
 362             /* NOTREACHED */
 363         }
 364         errno = WSAGetLastError();
 365     }
 366     return retval;
 367 }
 368
 369 char FAR *
 370 win32_inet_ntoa(struct in_addr in)
 371 {
 372     StartSockets();
 373     return inet_ntoa(in);
 374 }
 375
 376 unsigned long
 377 win32_inet_addr(const char FAR *cp)
 378 {
 379     StartSockets();
 380     return inet_addr(cp);
 381 }
 382
 383 /*
 384  * Networking stubs
 385  */
 386
 387 void
 388 win32_endhostent()
 389 {
 390     dTHX;
 391     Perl_croak_nocontext("endhostent not implemented!\n");
 392 }
 393
 394 void
 395 win32_endnetent()
 396 {
 397     dTHX;
 398     Perl_croak_nocontext("endnetent not implemented!\n");
 399 }
 400
 401 void
 402 win32_endprotoent()
 403 {
 404     dTHX;
 405     Perl_croak_nocontext("endprotoent not implemented!\n");
 406 }
 407
 408 void
 409 win32_endservent()
 410 {
 411     dTHX;
 412     Perl_croak_nocontext("endservent not implemented!\n");
 413 }
 414
 415
 416 struct netent *
 417 win32_getnetent(void)
 418 {
 419     dTHX;
 420     Perl_croak_nocontext("getnetent not implemented!\n");
 421     return (struct netent *) NULL;
 422 }
 423
 424 struct netent *
 425 win32_getnetbyname(char *name)
 426 {
 427     dTHX;
 428     Perl_croak_nocontext("getnetbyname not implemented!\n");
 429     return (struct netent *)NULL;
 430 }
 431
 432 struct netent *
 433 win32_getnetbyaddr(long net, int type)
 434 {
 435     dTHX;
 436     Perl_croak_nocontext("getnetbyaddr not implemented!\n");
 437     return (struct netent *)NULL;
 438 }
 439
 440 struct protoent *
 441 win32_getprotoent(void)
 442 {
 443     dTHX;
 444     Perl_croak_nocontext("getprotoent not implemented!\n");
 445     return (struct protoent *) NULL;
 446 }
 447
 448 struct servent *
 449 win32_getservent(void)
 450 {
 451     dTHX;
 452     Perl_croak_nocontext("getservent not implemented!\n");
 453     return (struct servent *) NULL;
 454 }
 455
 456 void
 457 win32_sethostent(int stayopen)
 458 {
 459     dTHX;
 460     Perl_croak_nocontext("sethostent not implemented!\n");
 461 }
 462
 463
 464 void
 465 win32_setnetent(int stayopen)
 466 {
 467     dTHX;
 468     Perl_croak_nocontext("setnetent not implemented!\n");
 469 }
 470
 471
 472 void
 473 win32_setprotoent(int stayopen)
 474 {
 475     dTHX;
 476     Perl_croak_nocontext("setprotoent not implemented!\n");
 477 }
 478
 479
 480 void
 481 win32_setservent(int stayopen)
 482 {
 483     dTHX;
 484     Perl_croak_nocontext("setservent not implemented!\n");
 485 }
 486
 487 static struct servent*
 488 win32_savecopyservent(struct servent*d, struct servent*s, const char *proto)
 489 {
 490     d->s_name = s->s_name;
 491     d->s_aliases = s->s_aliases;
 492     d->s_port = s->s_port;
 493 #ifndef __BORLANDC__    /* Buggy on Win95 and WinNT-with-Borland-WSOCK */
 494     if (!IsWin95() && s->s_proto && strlen(s->s_proto))
 495         d->s_proto = s->s_proto;
 496     else
 497 #endif
 498     if (proto && strlen(proto))
 499         d->s_proto = (char *)proto;
 500     else
 501         d->s_proto = "tcp";
 502
 503     return d;
 504 }