1 /* win32sck.c 2 * 3 * (c) 1995 Microsoft Corporation. All rights reserved. 4 * Developed by hip communications inc. 5 * Portions (c) 1993 Intergraph Corporation. All rights reserved. 6 * 7 * You may distribute under the terms of either the GNU General Public 8 * License or the Artistic License, as specified in the README file. 9 */ 10 11 #define WIN32IO_IS_STDIO 12 #define WIN32SCK_IS_STDSCK 13 #define WIN32_LEAN_AND_MEAN 14 #define PERLIO_NOT_STDIO 0 15 #ifdef __GNUC__ 16 #define Win32_Winsock 17 #endif 18 #include <windows.h> 19 #include <ws2spi.h> 20 21 #include "EXTERN.h" 22 #include "perl.h" 23 24 #include "Win32iop.h" 25 #include <sys/socket.h> 26 #include <fcntl.h> 27 #include <sys/stat.h> 28 #include <assert.h> 29 #include <io.h> 30 31 /* thanks to Beverly Brown (beverly@datacube.com) */ 32 #define OPEN_SOCKET(x) win32_open_osfhandle(x,O_RDWR|O_BINARY) 33 #define TO_SOCKET(x) _get_osfhandle(x) 34 35 #define StartSockets() \ 36 STMT_START { \ 37 if (!wsock_started) \ 38 start_sockets(); \ 39 } STMT_END 40 41 #define SOCKET_TEST(x, y) \ 42 STMT_START { \ 43 StartSockets(); \ 44 if((x) == (y)) \ 45 errno = get_last_socket_error(); \ 46 } STMT_END 47 48 #define SOCKET_TEST_ERROR(x) SOCKET_TEST(x, SOCKET_ERROR) 49 50 static int get_last_socket_error(void); 51 static struct servent* win32_savecopyservent(struct servent*d, 52 struct servent*s, 53 const char *proto); 54 55 static int wsock_started = 0; 56 57 #ifdef WIN32_DYN_IOINFO_SIZE 58 EXTERN_C Size_t w32_ioinfo_size; 59 #endif 60 61 EXTERN_C void 62 EndSockets(void) 63 { 64 if (wsock_started) 65 WSACleanup(); 66 } 67 68 /* Translate WSAExxx values to corresponding Exxx values where possible. Not all 69 * WSAExxx constants have corresponding Exxx constants in <errno.h> (even in 70 * VC++ 2010 and above, which have expanded <errno.h> with more values), but 71 * most missing constants are provided by win32/include/sys/errno2.h. The few 72 * that are not are returned unchanged. 73 * 74 * The list of possible WSAExxx values used here comes from the MSDN page 75 * titled "Windows Sockets Error Codes". 76 * 77 * (Note: Only the WSAExxx values are handled here; other WSAxxx values are 78 * returned unchanged. The return value normally ends up in errno/$! and at 79 * the Perl code level may be tested against the Exxx constants exported by 80 * the Errno and POSIX modules, which have never handled the other WSAxxx 81 * values themselves, apparently without any ill effect so far.) 82 */ 83 int 84 convert_wsa_error_to_errno(int wsaerr) 85 { 86 switch (wsaerr) { 87 case WSAEINTR: 88 return EINTR; 89 case WSAEBADF: 90 return EBADF; 91 case WSAEACCES: 92 return EACCES; 93 case WSAEFAULT: 94 return EFAULT; 95 case WSAEINVAL: 96 return EINVAL; 97 case WSAEMFILE: 98 return EMFILE; 99 case WSAEWOULDBLOCK: 100 return EWOULDBLOCK; 101 case WSAEINPROGRESS: 102 return EINPROGRESS; 103 case WSAEALREADY: 104 return EALREADY; 105 case WSAENOTSOCK: 106 return ENOTSOCK; 107 case WSAEDESTADDRREQ: 108 return EDESTADDRREQ; 109 case WSAEMSGSIZE: 110 return EMSGSIZE; 111 case WSAEPROTOTYPE: 112 return EPROTOTYPE; 113 case WSAENOPROTOOPT: 114 return ENOPROTOOPT; 115 case WSAEPROTONOSUPPORT: 116 return EPROTONOSUPPORT; 117 case WSAESOCKTNOSUPPORT: 118 return ESOCKTNOSUPPORT; 119 case WSAEOPNOTSUPP: 120 return EOPNOTSUPP; 121 case WSAEPFNOSUPPORT: 122 return EPFNOSUPPORT; 123 case WSAEAFNOSUPPORT: 124 return EAFNOSUPPORT; 125 case WSAEADDRINUSE: 126 return EADDRINUSE; 127 case WSAEADDRNOTAVAIL: 128 return EADDRNOTAVAIL; 129 case WSAENETDOWN: 130 return ENETDOWN; 131 case WSAENETUNREACH: 132 return ENETUNREACH; 133 case WSAENETRESET: 134 return ENETRESET; 135 case WSAECONNABORTED: 136 return ECONNABORTED; 137 case WSAECONNRESET: 138 return ECONNRESET; 139 case WSAENOBUFS: 140 return ENOBUFS; 141 case WSAEISCONN: 142 return EISCONN; 143 case WSAENOTCONN: 144 return ENOTCONN; 145 case WSAESHUTDOWN: 146 return ESHUTDOWN; 147 case WSAETOOMANYREFS: 148 return ETOOMANYREFS; 149 case WSAETIMEDOUT: 150 return ETIMEDOUT; 151 case WSAECONNREFUSED: 152 return ECONNREFUSED; 153 case WSAELOOP: 154 return ELOOP; 155 case WSAENAMETOOLONG: 156 return ENAMETOOLONG; 157 case WSAEHOSTDOWN: 158 return WSAEHOSTDOWN; /* EHOSTDOWN is not defined */ 159 case WSAEHOSTUNREACH: 160 return EHOSTUNREACH; 161 case WSAENOTEMPTY: 162 return ENOTEMPTY; 163 case WSAEPROCLIM: 164 return EPROCLIM; 165 case WSAEUSERS: 166 return EUSERS; 167 case WSAEDQUOT: 168 return EDQUOT; 169 case WSAESTALE: 170 return ESTALE; 171 case WSAEREMOTE: 172 return EREMOTE; 173 case WSAEDISCON: 174 return WSAEDISCON; /* EDISCON is not defined */ 175 case WSAENOMORE: 176 return WSAENOMORE; /* ENOMORE is not defined */ 177 #ifdef WSAECANCELLED 178 case WSAECANCELLED: /* New in WinSock2 */ 179 return ECANCELED; 180 #endif 181 case WSAEINVALIDPROCTABLE: 182 return WSAEINVALIDPROCTABLE; /* EINVALIDPROCTABLE is not defined */ 183 case WSAEINVALIDPROVIDER: 184 return WSAEINVALIDPROVIDER; /* EINVALIDPROVIDER is not defined */ 185 case WSAEPROVIDERFAILEDINIT: 186 return WSAEPROVIDERFAILEDINIT; /* EPROVIDERFAILEDINIT is not defined */ 187 case WSAEREFUSED: 188 return WSAEREFUSED; /* EREFUSED is not defined */ 189 } 190 191 return wsaerr; 192 } 193 194 #ifdef ERRNO_HAS_POSIX_SUPPLEMENT 195 /* Translate Exxx values in the POSIX supplement range defined in VC++ 2010 and 196 * above (EADDRINUSE <= err <= EWOULDBLOCK) to corresponding WSAExxx values. Not 197 * all such Exxx constants have corresponding WSAExxx constants in <winsock*.h>; 198 * we just use ERROR_INVALID_FUNCTION for those that are missing but do not 199 * really expect to encounter them anyway in the context in which this function 200 * is called. 201 * Some versions of MinGW/gcc-4.8 and above also define most, but not all, of 202 * these extra Exxx values. The missing ones are all cases for which there is no 203 * corresponding WSAExxx constant anyway, so we simply omit the cases for them 204 * here. 205 * Other Exxx values (err < sys_nerr) are returned unchanged. 206 */ 207 int 208 convert_errno_to_wsa_error(int err) 209 { 210 switch (err) { 211 case EADDRINUSE: 212 return WSAEADDRINUSE; 213 case EADDRNOTAVAIL: 214 return WSAEADDRNOTAVAIL; 215 case EAFNOSUPPORT: 216 return WSAEAFNOSUPPORT; 217 case EALREADY: 218 return WSAEALREADY; 219 #ifdef EBADMSG 220 case EBADMSG: /* Not defined in gcc-4.8.0 */ 221 return ERROR_INVALID_FUNCTION; 222 #endif 223 case ECANCELED: 224 #ifdef WSAECANCELLED 225 return WSAECANCELLED; /* New in WinSock2 */ 226 #else 227 return ERROR_INVALID_FUNCTION; 228 #endif 229 case ECONNABORTED: 230 return WSAECONNABORTED; 231 case ECONNREFUSED: 232 return WSAECONNREFUSED; 233 case ECONNRESET: 234 return WSAECONNRESET; 235 case EDESTADDRREQ: 236 return WSAEDESTADDRREQ; 237 case EHOSTUNREACH: 238 return WSAEHOSTUNREACH; 239 #ifdef EIDRM 240 case EIDRM: /* Not defined in gcc-4.8.0 */ 241 return ERROR_INVALID_FUNCTION; 242 #endif 243 case EINPROGRESS: 244 return WSAEINPROGRESS; 245 case EISCONN: 246 return WSAEISCONN; 247 case ELOOP: 248 return WSAELOOP; 249 case EMSGSIZE: 250 return WSAEMSGSIZE; 251 case ENETDOWN: 252 return WSAENETDOWN; 253 case ENETRESET: 254 return WSAENETRESET; 255 case ENETUNREACH: 256 return WSAENETUNREACH; 257 case ENOBUFS: 258 return WSAENOBUFS; 259 #ifdef ENODATA 260 case ENODATA: /* Not defined in gcc-4.8.0 */ 261 return ERROR_INVALID_FUNCTION; 262 #endif 263 #ifdef ENOLINK 264 case ENOLINK: /* Not defined in gcc-4.8.0 */ 265 return ERROR_INVALID_FUNCTION; 266 #endif 267 #ifdef ENOMSG 268 case ENOMSG: /* Not defined in gcc-4.8.0 */ 269 return ERROR_INVALID_FUNCTION; 270 #endif 271 case ENOPROTOOPT: 272 return WSAENOPROTOOPT; 273 #ifdef ENOSR 274 case ENOSR: /* Not defined in gcc-4.8.0 */ 275 return ERROR_INVALID_FUNCTION; 276 #endif 277 #ifdef ENOSTR 278 case ENOSTR: /* Not defined in gcc-4.8.0 */ 279 return ERROR_INVALID_FUNCTION; 280 #endif 281 case ENOTCONN: 282 return WSAENOTCONN; 283 #ifdef ENOTRECOVERABLE 284 case ENOTRECOVERABLE: /* Not defined in gcc-4.8.0 */ 285 return ERROR_INVALID_FUNCTION; 286 #endif 287 case ENOTSOCK: 288 return WSAENOTSOCK; 289 case ENOTSUP: 290 return ERROR_INVALID_FUNCTION; 291 case EOPNOTSUPP: 292 return WSAEOPNOTSUPP; 293 #ifdef EOTHER 294 case EOTHER: /* Not defined in gcc-4.8.0 */ 295 return ERROR_INVALID_FUNCTION; 296 #endif 297 case EOVERFLOW: 298 return ERROR_INVALID_FUNCTION; 299 case EOWNERDEAD: 300 return ERROR_INVALID_FUNCTION; 301 case EPROTO: 302 return ERROR_INVALID_FUNCTION; 303 case EPROTONOSUPPORT: 304 return WSAEPROTONOSUPPORT; 305 case EPROTOTYPE: 306 return WSAEPROTOTYPE; 307 #ifdef ETIME 308 case ETIME: /* Not defined in gcc-4.8.0 */ 309 return ERROR_INVALID_FUNCTION; 310 #endif 311 case ETIMEDOUT: 312 return WSAETIMEDOUT; 313 #ifdef ETXTBSY 314 case ETXTBSY: /* Not defined in gcc-4.8.0 */ 315 return ERROR_INVALID_FUNCTION; 316 #endif 317 case EWOULDBLOCK: 318 return WSAEWOULDBLOCK; 319 } 320 321 return err; 322 } 323 #endif /* ERRNO_HAS_POSIX_SUPPLEMENT */ 324 325 static int 326 get_last_socket_error(void) 327 { 328 return convert_wsa_error_to_errno(WSAGetLastError()); 329 } 330 331 void 332 start_sockets(void) 333 { 334 unsigned short version; 335 WSADATA retdata; 336 int ret; 337 338 /* 339 * initalize the winsock interface and insure that it is 340 * cleaned up at exit. 341 */ 342 version = 0x2; 343 if(ret = WSAStartup(version, &retdata)) 344 Perl_croak_nocontext("Unable to locate winsock library!\n"); 345 if(retdata.wVersion != version) 346 Perl_croak_nocontext("Could not find version 2.0 of winsock dll\n"); 347 348 /* atexit((void (*)(void)) EndSockets); */ 349 wsock_started = 1; 350 } 351 352 /* in no sockets Win32 builds, these use the inline functions defined in 353 * perl.h 354 */ 355 u_long 356 win32_htonl(u_long hostlong) 357 { 358 #ifndef WIN32_NO_SOCKETS 359 StartSockets(); 360 #endif 361 return htonl(hostlong); 362 } 363 364 u_short 365 win32_htons(u_short hostshort) 366 { 367 #ifndef WIN32_NO_SOCKETS 368 StartSockets(); 369 #endif 370 return htons(hostshort); 371 } 372 373 u_long 374 win32_ntohl(u_long netlong) 375 { 376 #ifndef WIN32_NO_SOCKETS 377 StartSockets(); 378 #endif 379 return ntohl(netlong); 380 } 381 382 u_short 383 win32_ntohs(u_short netshort) 384 { 385 #ifndef WIN32_NO_SOCKETS 386 StartSockets(); 387 #endif 388 return ntohs(netshort); 389 } 390 391 392 393 SOCKET 394 win32_accept(SOCKET s, struct sockaddr *addr, int *addrlen) 395 { 396 SOCKET r; 397 398 SOCKET_TEST((r = accept(TO_SOCKET(s), addr, addrlen)), INVALID_SOCKET); 399 return OPEN_SOCKET(r); 400 } 401 402 int 403 win32_bind(SOCKET s, const struct sockaddr *addr, int addrlen) 404 { 405 int r; 406 407 SOCKET_TEST_ERROR(r = bind(TO_SOCKET(s), addr, addrlen)); 408 return r; 409 } 410 411 int 412 win32_connect(SOCKET s, const struct sockaddr *addr, int addrlen) 413 { 414 int r; 415 416 SOCKET_TEST_ERROR(r = connect(TO_SOCKET(s), addr, addrlen)); 417 return r; 418 } 419 420 421 int 422 win32_getpeername(SOCKET s, struct sockaddr *addr, int *addrlen) 423 { 424 int r; 425 426 SOCKET_TEST_ERROR(r = getpeername(TO_SOCKET(s), addr, addrlen)); 427 return r; 428 } 429 430 int 431 win32_getsockname(SOCKET s, struct sockaddr *addr, int *addrlen) 432 { 433 int r; 434 435 SOCKET_TEST_ERROR(r = getsockname(TO_SOCKET(s), addr, addrlen)); 436 return r; 437 } 438 439 int 440 win32_getsockopt(SOCKET s, int level, int optname, char *optval, int *optlen) 441 { 442 int r; 443 444 SOCKET_TEST_ERROR(r = getsockopt(TO_SOCKET(s), level, optname, optval, optlen)); 445 return r; 446 } 447 448 int 449 win32_ioctlsocket(SOCKET s, long cmd, u_long *argp) 450 { 451 int r; 452 453 SOCKET_TEST_ERROR(r = ioctlsocket(TO_SOCKET(s), cmd, argp)); 454 return r; 455 } 456 457 int 458 win32_listen(SOCKET s, int backlog) 459 { 460 int r; 461 462 SOCKET_TEST_ERROR(r = listen(TO_SOCKET(s), backlog)); 463 return r; 464 } 465 466 int 467 win32_recv(SOCKET s, char *buf, int len, int flags) 468 { 469 int r; 470 471 SOCKET_TEST_ERROR(r = recv(TO_SOCKET(s), buf, len, flags)); 472 return r; 473 } 474 475 int 476 win32_recvfrom(SOCKET s, char *buf, int len, int flags, struct sockaddr *from, int *fromlen) 477 { 478 int r; 479 int frombufsize = *fromlen; 480 481 SOCKET_TEST_ERROR(r = recvfrom(TO_SOCKET(s), buf, len, flags, from, fromlen)); 482 /* Winsock's recvfrom() only returns a valid 'from' when the socket 483 * is connectionless. Perl expects a valid 'from' for all types 484 * of sockets, so go the extra mile. 485 */ 486 if (r != SOCKET_ERROR && frombufsize == *fromlen) 487 (void)win32_getpeername(s, from, fromlen); 488 return r; 489 } 490 491 /* select contributed by Vincent R. Slyngstad (vrs@ibeam.intel.com) */ 492 int 493 win32_select(int nfds, Perl_fd_set* rd, Perl_fd_set* wr, Perl_fd_set* ex, const struct timeval* timeout) 494 { 495 int r; 496 int i, fd, save_errno = errno; 497 FD_SET nrd, nwr, nex; 498 bool just_sleep = TRUE; 499 500 StartSockets(); 501 502 FD_ZERO(&nrd); 503 FD_ZERO(&nwr); 504 FD_ZERO(&nex); 505 for (i = 0; i < nfds; i++) { 506 if (rd && PERL_FD_ISSET(i,rd)) { 507 fd = TO_SOCKET(i); 508 FD_SET((unsigned)fd, &nrd); 509 just_sleep = FALSE; 510 } 511 if (wr && PERL_FD_ISSET(i,wr)) { 512 fd = TO_SOCKET(i); 513 FD_SET((unsigned)fd, &nwr); 514 just_sleep = FALSE; 515 } 516 if (ex && PERL_FD_ISSET(i,ex)) { 517 fd = TO_SOCKET(i); 518 FD_SET((unsigned)fd, &nex); 519 just_sleep = FALSE; 520 } 521 } 522 523 /* winsock seems incapable of dealing with all three fd_sets being empty, 524 * so do the (millisecond) sleep as a special case 525 */ 526 if (just_sleep) { 527 if (timeout) 528 Sleep(timeout->tv_sec * 1000 + 529 timeout->tv_usec / 1000); /* do the best we can */ 530 else 531 Sleep(UINT_MAX); 532 return 0; 533 } 534 535 errno = save_errno; 536 SOCKET_TEST_ERROR(r = select(nfds, &nrd, &nwr, &nex, timeout)); 537 save_errno = errno; 538 539 for (i = 0; i < nfds; i++) { 540 if (rd && PERL_FD_ISSET(i,rd)) { 541 fd = TO_SOCKET(i); 542 if (!FD_ISSET(fd, &nrd)) 543 PERL_FD_CLR(i,rd); 544 } 545 if (wr && PERL_FD_ISSET(i,wr)) { 546 fd = TO_SOCKET(i); 547 if (!FD_ISSET(fd, &nwr)) 548 PERL_FD_CLR(i,wr); 549 } 550 if (ex && PERL_FD_ISSET(i,ex)) { 551 fd = TO_SOCKET(i); 552 if (!FD_ISSET(fd, &nex)) 553 PERL_FD_CLR(i,ex); 554 } 555 } 556 errno = save_errno; 557 return r; 558 } 559 560 int 561 win32_send(SOCKET s, const char *buf, int len, int flags) 562 { 563 int r; 564 565 SOCKET_TEST_ERROR(r = send(TO_SOCKET(s), buf, len, flags)); 566 return r; 567 } 568 569 int 570 win32_sendto(SOCKET s, const char *buf, int len, int flags, 571 const struct sockaddr *to, int tolen) 572 { 573 int r; 574 575 SOCKET_TEST_ERROR(r = sendto(TO_SOCKET(s), buf, len, flags, to, tolen)); 576 return r; 577 } 578 579 int 580 win32_setsockopt(SOCKET s, int level, int optname, const char *optval, int optlen) 581 { 582 int r; 583 584 SOCKET_TEST_ERROR(r = setsockopt(TO_SOCKET(s), level, optname, optval, optlen)); 585 return r; 586 } 587 588 int 589 win32_shutdown(SOCKET s, int how) 590 { 591 int r; 592 593 SOCKET_TEST_ERROR(r = shutdown(TO_SOCKET(s), how)); 594 return r; 595 } 596 597 int 598 win32_closesocket(SOCKET s) 599 { 600 int r; 601 602 SOCKET_TEST_ERROR(r = closesocket(TO_SOCKET(s))); 603 return r; 604 } 605 606 void 607 convert_proto_info_w2a(WSAPROTOCOL_INFOW *in, WSAPROTOCOL_INFOA *out) 608 { 609 Copy(in, out, 1, WSAPROTOCOL_INFOA); 610 wcstombs(out->szProtocol, in->szProtocol, sizeof(out->szProtocol)); 611 } 612 613 SOCKET 614 open_ifs_socket(int af, int type, int protocol) 615 { 616 dTHX; 617 char *s; 618 unsigned long proto_buffers_len = 0; 619 int error_code; 620 SOCKET out = INVALID_SOCKET; 621 622 if ((s = PerlEnv_getenv("PERL_ALLOW_NON_IFS_LSP")) && atoi(s)) 623 return WSASocket(af, type, protocol, NULL, 0, 0); 624 625 if (WSCEnumProtocols(NULL, NULL, &proto_buffers_len, &error_code) == SOCKET_ERROR 626 && error_code == WSAENOBUFS) 627 { 628 WSAPROTOCOL_INFOW *proto_buffers; 629 int protocols_available = 0; 630 631 Newx(proto_buffers, proto_buffers_len / sizeof(WSAPROTOCOL_INFOW), 632 WSAPROTOCOL_INFOW); 633 634 if ((protocols_available = WSCEnumProtocols(NULL, proto_buffers, 635 &proto_buffers_len, &error_code)) != SOCKET_ERROR) 636 { 637 int i; 638 for (i = 0; i < protocols_available; i++) 639 { 640 WSAPROTOCOL_INFOA proto_info; 641 642 if ((af != AF_UNSPEC && af != proto_buffers[i].iAddressFamily) 643 || (type != proto_buffers[i].iSocketType) 644 || (protocol != 0 && proto_buffers[i].iProtocol != 0 && 645 protocol != proto_buffers[i].iProtocol)) 646 continue; 647 648 if ((proto_buffers[i].dwServiceFlags1 & XP1_IFS_HANDLES) == 0) 649 continue; 650 651 convert_proto_info_w2a(&(proto_buffers[i]), &proto_info); 652 653 out = WSASocket(af, type, protocol, &proto_info, 0, 0); 654 break; 655 } 656 } 657 658 Safefree(proto_buffers); 659 } 660 661 return out; 662 } 663 664 SOCKET 665 win32_socket(int af, int type, int protocol) 666 { 667 SOCKET s; 668 669 StartSockets(); 670 671 if((s = open_ifs_socket(af, type, protocol)) == INVALID_SOCKET) 672 errno = get_last_socket_error(); 673 else 674 s = OPEN_SOCKET(s); 675 676 return s; 677 } 678 679 /* 680 * close RTL fd while respecting sockets 681 * added as temporary measure until PerlIO has real 682 * Win32 native layer 683 * -- BKS, 11-11-2000 684 */ 685 686 int my_close(int fd) 687 { 688 int osf; 689 if (!wsock_started) /* No WinSock? */ 690 return(close(fd)); /* Then not a socket. */ 691 osf = TO_SOCKET(fd);/* Get it now before it's gone! */ 692 if (osf != -1) { 693 int err; 694 err = closesocket(osf); 695 if (err == 0) { 696 assert(_osfhnd(fd) == osf); /* catch a bad ioinfo struct def */ 697 /* don't close freed handle */ 698 _set_osfhnd(fd, INVALID_HANDLE_VALUE); 699 return close(fd); 700 } 701 else if (err == SOCKET_ERROR) { 702 err = get_last_socket_error(); 703 if (err != ENOTSOCK) { 704 (void)close(fd); 705 errno = err; 706 return EOF; 707 } 708 } 709 } 710 return close(fd); 711 } 712 713 #undef fclose 714 int 715 my_fclose (FILE *pf) 716 { 717 int osf; 718 if (!wsock_started) /* No WinSock? */ 719 return(fclose(pf)); /* Then not a socket. */ 720 osf = TO_SOCKET(win32_fileno(pf));/* Get it now before it's gone! */ 721 if (osf != -1) { 722 int err; 723 win32_fflush(pf); 724 err = closesocket(osf); 725 if (err == 0) { 726 assert(_osfhnd(win32_fileno(pf)) == osf); /* catch a bad ioinfo struct def */ 727 /* don't close freed handle */ 728 _set_osfhnd(win32_fileno(pf), INVALID_HANDLE_VALUE); 729 return fclose(pf); 730 } 731 else if (err == SOCKET_ERROR) { 732 err = get_last_socket_error(); 733 if (err != ENOTSOCK) { 734 (void)fclose(pf); 735 errno = err; 736 return EOF; 737 } 738 } 739 } 740 return fclose(pf); 741 } 742 743 struct hostent * 744 win32_gethostbyaddr(const char *addr, int len, int type) 745 { 746 struct hostent *r; 747 748 SOCKET_TEST(r = gethostbyaddr(addr, len, type), NULL); 749 return r; 750 } 751 752 struct hostent * 753 win32_gethostbyname(const char *name) 754 { 755 struct hostent *r; 756 757 SOCKET_TEST(r = gethostbyname(name), NULL); 758 return r; 759 } 760 761 int 762 win32_gethostname(char *name, int len) 763 { 764 int r; 765 766 SOCKET_TEST_ERROR(r = gethostname(name, len)); 767 return r; 768 } 769 770 struct protoent * 771 win32_getprotobyname(const char *name) 772 { 773 struct protoent *r; 774 775 SOCKET_TEST(r = getprotobyname(name), NULL); 776 return r; 777 } 778 779 struct protoent * 780 win32_getprotobynumber(int num) 781 { 782 struct protoent *r; 783 784 SOCKET_TEST(r = getprotobynumber(num), NULL); 785 return r; 786 } 787 788 struct servent * 789 win32_getservbyname(const char *name, const char *proto) 790 { 791 dTHXa(NULL); 792 struct servent *r; 793 794 SOCKET_TEST(r = getservbyname(name, proto), NULL); 795 if (r) { 796 aTHXa(PERL_GET_THX); 797 r = win32_savecopyservent(&w32_servent, r, proto); 798 } 799 return r; 800 } 801 802 struct servent * 803 win32_getservbyport(int port, const char *proto) 804 { 805 dTHXa(NULL); 806 struct servent *r; 807 808 SOCKET_TEST(r = getservbyport(port, proto), NULL); 809 if (r) { 810 aTHXa(PERL_GET_THX); 811 r = win32_savecopyservent(&w32_servent, r, proto); 812 } 813 return r; 814 } 815 816 int 817 win32_ioctl(int i, unsigned int u, char *data) 818 { 819 u_long u_long_arg; 820 int retval; 821 822 if (!wsock_started) { 823 Perl_croak_nocontext("ioctl implemented only on sockets"); 824 /* NOTREACHED */ 825 } 826 827 /* mauke says using memcpy avoids alignment issues */ 828 memcpy(&u_long_arg, data, sizeof u_long_arg); 829 retval = ioctlsocket(TO_SOCKET(i), (long)u, &u_long_arg); 830 memcpy(data, &u_long_arg, sizeof u_long_arg); 831 832 if (retval == SOCKET_ERROR) { 833 int err = get_last_socket_error(); 834 if (err == ENOTSOCK) { 835 Perl_croak_nocontext("ioctl implemented only on sockets"); 836 /* NOTREACHED */ 837 } 838 errno = err; 839 } 840 return retval; 841 } 842 843 char FAR * 844 win32_inet_ntoa(struct in_addr in) 845 { 846 StartSockets(); 847 return inet_ntoa(in); 848 } 849 850 unsigned long 851 win32_inet_addr(const char FAR *cp) 852 { 853 StartSockets(); 854 return inet_addr(cp); 855 } 856 857 /* 858 * Networking stubs 859 */ 860 861 void 862 win32_endhostent() 863 { 864 win32_croak_not_implemented("endhostent"); 865 } 866 867 void 868 win32_endnetent() 869 { 870 win32_croak_not_implemented("endnetent"); 871 } 872 873 void 874 win32_endprotoent() 875 { 876 win32_croak_not_implemented("endprotoent"); 877 } 878 879 void 880 win32_endservent() 881 { 882 win32_croak_not_implemented("endservent"); 883 } 884 885 886 struct netent * 887 win32_getnetent(void) 888 { 889 win32_croak_not_implemented("getnetent"); 890 return (struct netent *) NULL; 891 } 892 893 struct netent * 894 win32_getnetbyname(char *name) 895 { 896 win32_croak_not_implemented("getnetbyname"); 897 return (struct netent *)NULL; 898 } 899 900 struct netent * 901 win32_getnetbyaddr(long net, int type) 902 { 903 win32_croak_not_implemented("getnetbyaddr"); 904 return (struct netent *)NULL; 905 } 906 907 struct protoent * 908 win32_getprotoent(void) 909 { 910 win32_croak_not_implemented("getprotoent"); 911 return (struct protoent *) NULL; 912 } 913 914 struct servent * 915 win32_getservent(void) 916 { 917 win32_croak_not_implemented("getservent"); 918 return (struct servent *) NULL; 919 } 920 921 void 922 win32_sethostent(int stayopen) 923 { 924 win32_croak_not_implemented("sethostent"); 925 } 926 927 928 void 929 win32_setnetent(int stayopen) 930 { 931 win32_croak_not_implemented("setnetent"); 932 } 933 934 935 void 936 win32_setprotoent(int stayopen) 937 { 938 win32_croak_not_implemented("setprotoent"); 939 } 940 941 942 void 943 win32_setservent(int stayopen) 944 { 945 win32_croak_not_implemented("setservent"); 946 } 947 948 static struct servent* 949 win32_savecopyservent(struct servent*d, struct servent*s, const char *proto) 950 { 951 d->s_name = s->s_name; 952 d->s_aliases = s->s_aliases; 953 d->s_port = s->s_port; 954 if (s->s_proto && strlen(s->s_proto)) 955 d->s_proto = s->s_proto; 956 else 957 if (proto && strlen(proto)) 958 d->s_proto = (char *)proto; 959 else 960 d->s_proto = "tcp"; 961 962 return d; 963 } 964 965 966