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 #ifdef USE_SOCKETS_AS_HANDLES 33 # define OPEN_SOCKET(x) win32_open_osfhandle(x,O_RDWR|O_BINARY) 34 # define TO_SOCKET(x) _get_osfhandle(x) 35 #else 36 # define OPEN_SOCKET(x) (x) 37 # define TO_SOCKET(x) (x) 38 #endif /* USE_SOCKETS_AS_HANDLES */ 39 40 #define StartSockets() \ 41 STMT_START { \ 42 if (!wsock_started) \ 43 start_sockets(); \ 44 } STMT_END 45 46 #define SOCKET_TEST(x, y) \ 47 STMT_START { \ 48 StartSockets(); \ 49 if((x) == (y)) \ 50 errno = WSAGetLastError(); \ 51 } STMT_END 52 53 #define SOCKET_TEST_ERROR(x) SOCKET_TEST(x, SOCKET_ERROR) 54 55 static struct servent* win32_savecopyservent(struct servent*d, 56 struct servent*s, 57 const char *proto); 58 59 static int wsock_started = 0; 60 61 EXTERN_C void 62 EndSockets(void) 63 { 64 if (wsock_started) 65 WSACleanup(); 66 } 67 68 void 69 start_sockets(void) 70 { 71 dTHX; 72 unsigned short version; 73 WSADATA retdata; 74 int ret; 75 76 /* 77 * initalize the winsock interface and insure that it is 78 * cleaned up at exit. 79 */ 80 version = 0x2; 81 if(ret = WSAStartup(version, &retdata)) 82 Perl_croak_nocontext("Unable to locate winsock library!\n"); 83 if(retdata.wVersion != version) 84 Perl_croak_nocontext("Could not find version 2.0 of winsock dll\n"); 85 86 /* atexit((void (*)(void)) EndSockets); */ 87 wsock_started = 1; 88 } 89 90 #ifndef USE_SOCKETS_AS_HANDLES 91 #undef fdopen 92 FILE * 93 my_fdopen(int fd, char *mode) 94 { 95 FILE *fp; 96 char sockbuf[256]; 97 int optlen = sizeof(sockbuf); 98 int retval; 99 100 if (!wsock_started) 101 return(fdopen(fd, mode)); 102 103 retval = getsockopt((SOCKET)fd, SOL_SOCKET, SO_TYPE, sockbuf, &optlen); 104 if(retval == SOCKET_ERROR && WSAGetLastError() == WSAENOTSOCK) { 105 return(fdopen(fd, mode)); 106 } 107 108 /* 109 * If we get here, then fd is actually a socket. 110 */ 111 Newxz(fp, 1, FILE); /* XXX leak, good thing this code isn't used */ 112 if(fp == NULL) { 113 errno = ENOMEM; 114 return NULL; 115 } 116 117 fp->_file = fd; 118 if(*mode == 'r') 119 fp->_flag = _IOREAD; 120 else 121 fp->_flag = _IOWRT; 122 123 return fp; 124 } 125 #endif /* USE_SOCKETS_AS_HANDLES */ 126 127 128 u_long 129 win32_htonl(u_long hostlong) 130 { 131 StartSockets(); 132 return htonl(hostlong); 133 } 134 135 u_short 136 win32_htons(u_short hostshort) 137 { 138 StartSockets(); 139 return htons(hostshort); 140 } 141 142 u_long 143 win32_ntohl(u_long netlong) 144 { 145 StartSockets(); 146 return ntohl(netlong); 147 } 148 149 u_short 150 win32_ntohs(u_short netshort) 151 { 152 StartSockets(); 153 return ntohs(netshort); 154 } 155 156 157 158 SOCKET 159 win32_accept(SOCKET s, struct sockaddr *addr, int *addrlen) 160 { 161 SOCKET r; 162 163 SOCKET_TEST((r = accept(TO_SOCKET(s), addr, addrlen)), INVALID_SOCKET); 164 return OPEN_SOCKET(r); 165 } 166 167 int 168 win32_bind(SOCKET s, const struct sockaddr *addr, int addrlen) 169 { 170 int r; 171 172 SOCKET_TEST_ERROR(r = bind(TO_SOCKET(s), addr, addrlen)); 173 return r; 174 } 175 176 int 177 win32_connect(SOCKET s, const struct sockaddr *addr, int addrlen) 178 { 179 int r; 180 181 SOCKET_TEST_ERROR(r = connect(TO_SOCKET(s), addr, addrlen)); 182 return r; 183 } 184 185 186 int 187 win32_getpeername(SOCKET s, struct sockaddr *addr, int *addrlen) 188 { 189 int r; 190 191 SOCKET_TEST_ERROR(r = getpeername(TO_SOCKET(s), addr, addrlen)); 192 return r; 193 } 194 195 int 196 win32_getsockname(SOCKET s, struct sockaddr *addr, int *addrlen) 197 { 198 int r; 199 200 SOCKET_TEST_ERROR(r = getsockname(TO_SOCKET(s), addr, addrlen)); 201 return r; 202 } 203 204 int 205 win32_getsockopt(SOCKET s, int level, int optname, char *optval, int *optlen) 206 { 207 int r; 208 209 SOCKET_TEST_ERROR(r = getsockopt(TO_SOCKET(s), level, optname, optval, optlen)); 210 return r; 211 } 212 213 int 214 win32_ioctlsocket(SOCKET s, long cmd, u_long *argp) 215 { 216 int r; 217 218 SOCKET_TEST_ERROR(r = ioctlsocket(TO_SOCKET(s), cmd, argp)); 219 return r; 220 } 221 222 int 223 win32_listen(SOCKET s, int backlog) 224 { 225 int r; 226 227 SOCKET_TEST_ERROR(r = listen(TO_SOCKET(s), backlog)); 228 return r; 229 } 230 231 int 232 win32_recv(SOCKET s, char *buf, int len, int flags) 233 { 234 int r; 235 236 SOCKET_TEST_ERROR(r = recv(TO_SOCKET(s), buf, len, flags)); 237 return r; 238 } 239 240 int 241 win32_recvfrom(SOCKET s, char *buf, int len, int flags, struct sockaddr *from, int *fromlen) 242 { 243 int r; 244 int frombufsize = *fromlen; 245 246 SOCKET_TEST_ERROR(r = recvfrom(TO_SOCKET(s), buf, len, flags, from, fromlen)); 247 /* Winsock's recvfrom() only returns a valid 'from' when the socket 248 * is connectionless. Perl expects a valid 'from' for all types 249 * of sockets, so go the extra mile. 250 */ 251 if (r != SOCKET_ERROR && frombufsize == *fromlen) 252 (void)win32_getpeername(s, from, fromlen); 253 return r; 254 } 255 256 /* select contributed by Vincent R. Slyngstad (vrs@ibeam.intel.com) */ 257 int 258 win32_select(int nfds, Perl_fd_set* rd, Perl_fd_set* wr, Perl_fd_set* ex, const struct timeval* timeout) 259 { 260 int r; 261 #ifdef USE_SOCKETS_AS_HANDLES 262 int i, fd, save_errno = errno; 263 FD_SET nrd, nwr, nex; 264 bool just_sleep = TRUE; 265 266 StartSockets(); 267 268 FD_ZERO(&nrd); 269 FD_ZERO(&nwr); 270 FD_ZERO(&nex); 271 for (i = 0; i < nfds; i++) { 272 if (rd && PERL_FD_ISSET(i,rd)) { 273 fd = TO_SOCKET(i); 274 FD_SET((unsigned)fd, &nrd); 275 just_sleep = FALSE; 276 } 277 if (wr && PERL_FD_ISSET(i,wr)) { 278 fd = TO_SOCKET(i); 279 FD_SET((unsigned)fd, &nwr); 280 just_sleep = FALSE; 281 } 282 if (ex && PERL_FD_ISSET(i,ex)) { 283 fd = TO_SOCKET(i); 284 FD_SET((unsigned)fd, &nex); 285 just_sleep = FALSE; 286 } 287 } 288 289 /* winsock seems incapable of dealing with all three fd_sets being empty, 290 * so do the (millisecond) sleep as a special case 291 */ 292 if (just_sleep) { 293 if (timeout) 294 Sleep(timeout->tv_sec * 1000 + 295 timeout->tv_usec / 1000); /* do the best we can */ 296 else 297 Sleep(UINT_MAX); 298 return 0; 299 } 300 301 errno = save_errno; 302 SOCKET_TEST_ERROR(r = select(nfds, &nrd, &nwr, &nex, timeout)); 303 save_errno = errno; 304 305 for (i = 0; i < nfds; i++) { 306 if (rd && PERL_FD_ISSET(i,rd)) { 307 fd = TO_SOCKET(i); 308 if (!FD_ISSET(fd, &nrd)) 309 PERL_FD_CLR(i,rd); 310 } 311 if (wr && PERL_FD_ISSET(i,wr)) { 312 fd = TO_SOCKET(i); 313 if (!FD_ISSET(fd, &nwr)) 314 PERL_FD_CLR(i,wr); 315 } 316 if (ex && PERL_FD_ISSET(i,ex)) { 317 fd = TO_SOCKET(i); 318 if (!FD_ISSET(fd, &nex)) 319 PERL_FD_CLR(i,ex); 320 } 321 } 322 errno = save_errno; 323 #else 324 SOCKET_TEST_ERROR(r = select(nfds, rd, wr, ex, timeout)); 325 #endif 326 return r; 327 } 328 329 int 330 win32_send(SOCKET s, const char *buf, int len, int flags) 331 { 332 int r; 333 334 SOCKET_TEST_ERROR(r = send(TO_SOCKET(s), buf, len, flags)); 335 return r; 336 } 337 338 int 339 win32_sendto(SOCKET s, const char *buf, int len, int flags, 340 const struct sockaddr *to, int tolen) 341 { 342 int r; 343 344 SOCKET_TEST_ERROR(r = sendto(TO_SOCKET(s), buf, len, flags, to, tolen)); 345 return r; 346 } 347 348 int 349 win32_setsockopt(SOCKET s, int level, int optname, const char *optval, int optlen) 350 { 351 int r; 352 353 SOCKET_TEST_ERROR(r = setsockopt(TO_SOCKET(s), level, optname, optval, optlen)); 354 return r; 355 } 356 357 int 358 win32_shutdown(SOCKET s, int how) 359 { 360 int r; 361 362 SOCKET_TEST_ERROR(r = shutdown(TO_SOCKET(s), how)); 363 return r; 364 } 365 366 int 367 win32_closesocket(SOCKET s) 368 { 369 int r; 370 371 SOCKET_TEST_ERROR(r = closesocket(TO_SOCKET(s))); 372 return r; 373 } 374 375 #ifdef USE_SOCKETS_AS_HANDLES 376 #define WIN32_OPEN_SOCKET(af, type, protocol) open_ifs_socket(af, type, protocol) 377 378 void 379 convert_proto_info_w2a(WSAPROTOCOL_INFOW *in, WSAPROTOCOL_INFOA *out) 380 { 381 Copy(in, out, 1, WSAPROTOCOL_INFOA); 382 wcstombs(out->szProtocol, in->szProtocol, sizeof(out->szProtocol)); 383 } 384 385 SOCKET 386 open_ifs_socket(int af, int type, int protocol) 387 { 388 dTHX; 389 char *s; 390 unsigned long proto_buffers_len = 0; 391 int error_code; 392 SOCKET out = INVALID_SOCKET; 393 394 if ((s = PerlEnv_getenv("PERL_ALLOW_NON_IFS_LSP")) && atoi(s)) 395 return WSASocket(af, type, protocol, NULL, 0, 0); 396 397 if (WSCEnumProtocols(NULL, NULL, &proto_buffers_len, &error_code) == SOCKET_ERROR 398 && error_code == WSAENOBUFS) 399 { 400 WSAPROTOCOL_INFOW *proto_buffers; 401 int protocols_available = 0; 402 403 Newx(proto_buffers, proto_buffers_len / sizeof(WSAPROTOCOL_INFOW), 404 WSAPROTOCOL_INFOW); 405 406 if ((protocols_available = WSCEnumProtocols(NULL, proto_buffers, 407 &proto_buffers_len, &error_code)) != SOCKET_ERROR) 408 { 409 int i; 410 for (i = 0; i < protocols_available; i++) 411 { 412 WSAPROTOCOL_INFOA proto_info; 413 414 if ((af != AF_UNSPEC && af != proto_buffers[i].iAddressFamily) 415 || (type != proto_buffers[i].iSocketType) 416 || (protocol != 0 && proto_buffers[i].iProtocol != 0 && 417 protocol != proto_buffers[i].iProtocol)) 418 continue; 419 420 if ((proto_buffers[i].dwServiceFlags1 & XP1_IFS_HANDLES) == 0) 421 continue; 422 423 convert_proto_info_w2a(&(proto_buffers[i]), &proto_info); 424 425 out = WSASocket(af, type, protocol, &proto_info, 0, 0); 426 break; 427 } 428 } 429 430 Safefree(proto_buffers); 431 } 432 433 return out; 434 } 435 436 #else 437 #define WIN32_OPEN_SOCKET(af, type, protocol) socket(af, type, protocol) 438 #endif 439 440 SOCKET 441 win32_socket(int af, int type, int protocol) 442 { 443 SOCKET s; 444 445 #ifndef USE_SOCKETS_AS_HANDLES 446 SOCKET_TEST(s = socket(af, type, protocol), INVALID_SOCKET); 447 #else 448 StartSockets(); 449 450 if((s = WIN32_OPEN_SOCKET(af, type, protocol)) == INVALID_SOCKET) 451 errno = WSAGetLastError(); 452 else 453 s = OPEN_SOCKET(s); 454 #endif /* USE_SOCKETS_AS_HANDLES */ 455 456 return s; 457 } 458 459 /* 460 * close RTL fd while respecting sockets 461 * added as temporary measure until PerlIO has real 462 * Win32 native layer 463 * -- BKS, 11-11-2000 464 */ 465 466 int my_close(int fd) 467 { 468 int osf; 469 if (!wsock_started) /* No WinSock? */ 470 return(close(fd)); /* Then not a socket. */ 471 osf = TO_SOCKET(fd);/* Get it now before it's gone! */ 472 if (osf != -1) { 473 int err; 474 err = closesocket(osf); 475 if (err == 0) { 476 #if defined(USE_FIXED_OSFHANDLE) || defined(PERL_MSVCRT_READFIX) 477 _set_osfhnd(fd, INVALID_HANDLE_VALUE); 478 #endif 479 (void)close(fd); /* handle already closed, ignore error */ 480 return 0; 481 } 482 else if (err == SOCKET_ERROR) { 483 err = WSAGetLastError(); 484 if (err != WSAENOTSOCK) { 485 (void)close(fd); 486 errno = err; 487 return EOF; 488 } 489 } 490 } 491 return close(fd); 492 } 493 494 #undef fclose 495 int 496 my_fclose (FILE *pf) 497 { 498 int osf; 499 if (!wsock_started) /* No WinSock? */ 500 return(fclose(pf)); /* Then not a socket. */ 501 osf = TO_SOCKET(win32_fileno(pf));/* Get it now before it's gone! */ 502 if (osf != -1) { 503 int err; 504 win32_fflush(pf); 505 err = closesocket(osf); 506 if (err == 0) { 507 #if defined(USE_FIXED_OSFHANDLE) || defined(PERL_MSVCRT_READFIX) 508 _set_osfhnd(win32_fileno(pf), INVALID_HANDLE_VALUE); 509 #endif 510 (void)fclose(pf); /* handle already closed, ignore error */ 511 return 0; 512 } 513 else if (err == SOCKET_ERROR) { 514 err = WSAGetLastError(); 515 if (err != WSAENOTSOCK) { 516 (void)fclose(pf); 517 errno = err; 518 return EOF; 519 } 520 } 521 } 522 return fclose(pf); 523 } 524 525 #undef fstat 526 int 527 my_fstat(int fd, Stat_t *sbufptr) 528 { 529 /* This fixes a bug in fstat() on Windows 9x. fstat() uses the 530 * GetFileType() win32 syscall, which will fail on Windows 9x. 531 * So if we recognize a socket on Windows 9x, we return the 532 * same results as on Windows NT/2000. 533 * XXX this should be extended further to set S_IFSOCK on 534 * sbufptr->st_mode. 535 */ 536 int osf; 537 if (!wsock_started || IsWinNT()) { 538 #if defined(WIN64) || defined(USE_LARGE_FILES) 539 #if defined(__BORLANDC__) /* buk */ 540 return win32_fstat(fd, sbufptr ); 541 #else 542 return _fstati64(fd, sbufptr); 543 #endif 544 #else 545 return fstat(fd, sbufptr); 546 #endif 547 } 548 549 osf = TO_SOCKET(fd); 550 if (osf != -1) { 551 char sockbuf[256]; 552 int optlen = sizeof(sockbuf); 553 int retval; 554 555 retval = getsockopt((SOCKET)osf, SOL_SOCKET, SO_TYPE, sockbuf, &optlen); 556 if (retval != SOCKET_ERROR || WSAGetLastError() != WSAENOTSOCK) { 557 #if defined(__BORLANDC__)&&(__BORLANDC__<=0x520) 558 sbufptr->st_mode = S_IFIFO; 559 #else 560 sbufptr->st_mode = _S_IFIFO; 561 #endif 562 sbufptr->st_rdev = sbufptr->st_dev = (dev_t)fd; 563 sbufptr->st_nlink = 1; 564 sbufptr->st_uid = sbufptr->st_gid = sbufptr->st_ino = 0; 565 sbufptr->st_atime = sbufptr->st_mtime = sbufptr->st_ctime = 0; 566 sbufptr->st_size = (Off_t)0; 567 return 0; 568 } 569 } 570 #if defined(WIN64) || defined(USE_LARGE_FILES) 571 #if defined(__BORLANDC__) /* buk */ 572 return win32_fstat(fd, sbufptr ); 573 #else 574 return _fstati64(fd, sbufptr); 575 #endif 576 #else 577 return fstat(fd, sbufptr); 578 #endif 579 } 580 581 struct hostent * 582 win32_gethostbyaddr(const char *addr, int len, int type) 583 { 584 struct hostent *r; 585 586 SOCKET_TEST(r = gethostbyaddr(addr, len, type), NULL); 587 return r; 588 } 589 590 struct hostent * 591 win32_gethostbyname(const char *name) 592 { 593 struct hostent *r; 594 595 SOCKET_TEST(r = gethostbyname(name), NULL); 596 return r; 597 } 598 599 int 600 win32_gethostname(char *name, int len) 601 { 602 int r; 603 604 SOCKET_TEST_ERROR(r = gethostname(name, len)); 605 return r; 606 } 607 608 struct protoent * 609 win32_getprotobyname(const char *name) 610 { 611 struct protoent *r; 612 613 SOCKET_TEST(r = getprotobyname(name), NULL); 614 return r; 615 } 616 617 struct protoent * 618 win32_getprotobynumber(int num) 619 { 620 struct protoent *r; 621 622 SOCKET_TEST(r = getprotobynumber(num), NULL); 623 return r; 624 } 625 626 struct servent * 627 win32_getservbyname(const char *name, const char *proto) 628 { 629 dTHX; 630 struct servent *r; 631 632 SOCKET_TEST(r = getservbyname(name, proto), NULL); 633 if (r) { 634 r = win32_savecopyservent(&w32_servent, r, proto); 635 } 636 return r; 637 } 638 639 struct servent * 640 win32_getservbyport(int port, const char *proto) 641 { 642 dTHX; 643 struct servent *r; 644 645 SOCKET_TEST(r = getservbyport(port, proto), NULL); 646 if (r) { 647 r = win32_savecopyservent(&w32_servent, r, proto); 648 } 649 return r; 650 } 651 652 int 653 win32_ioctl(int i, unsigned int u, char *data) 654 { 655 dTHX; 656 u_long u_long_arg; 657 int retval; 658 659 if (!wsock_started) { 660 Perl_croak_nocontext("ioctl implemented only on sockets"); 661 /* NOTREACHED */ 662 } 663 664 /* mauke says using memcpy avoids alignment issues */ 665 memcpy(&u_long_arg, data, sizeof u_long_arg); 666 retval = ioctlsocket(TO_SOCKET(i), (long)u, &u_long_arg); 667 memcpy(data, &u_long_arg, sizeof u_long_arg); 668 669 if (retval == SOCKET_ERROR) { 670 if (WSAGetLastError() == WSAENOTSOCK) { 671 Perl_croak_nocontext("ioctl implemented only on sockets"); 672 /* NOTREACHED */ 673 } 674 errno = WSAGetLastError(); 675 } 676 return retval; 677 } 678 679 char FAR * 680 win32_inet_ntoa(struct in_addr in) 681 { 682 StartSockets(); 683 return inet_ntoa(in); 684 } 685 686 unsigned long 687 win32_inet_addr(const char FAR *cp) 688 { 689 StartSockets(); 690 return inet_addr(cp); 691 } 692 693 /* 694 * Networking stubs 695 */ 696 697 void 698 win32_endhostent() 699 { 700 dTHX; 701 Perl_croak_nocontext("endhostent not implemented!\n"); 702 } 703 704 void 705 win32_endnetent() 706 { 707 dTHX; 708 Perl_croak_nocontext("endnetent not implemented!\n"); 709 } 710 711 void 712 win32_endprotoent() 713 { 714 dTHX; 715 Perl_croak_nocontext("endprotoent not implemented!\n"); 716 } 717 718 void 719 win32_endservent() 720 { 721 dTHX; 722 Perl_croak_nocontext("endservent not implemented!\n"); 723 } 724 725 726 struct netent * 727 win32_getnetent(void) 728 { 729 dTHX; 730 Perl_croak_nocontext("getnetent not implemented!\n"); 731 return (struct netent *) NULL; 732 } 733 734 struct netent * 735 win32_getnetbyname(char *name) 736 { 737 dTHX; 738 Perl_croak_nocontext("getnetbyname not implemented!\n"); 739 return (struct netent *)NULL; 740 } 741 742 struct netent * 743 win32_getnetbyaddr(long net, int type) 744 { 745 dTHX; 746 Perl_croak_nocontext("getnetbyaddr not implemented!\n"); 747 return (struct netent *)NULL; 748 } 749 750 struct protoent * 751 win32_getprotoent(void) 752 { 753 dTHX; 754 Perl_croak_nocontext("getprotoent not implemented!\n"); 755 return (struct protoent *) NULL; 756 } 757 758 struct servent * 759 win32_getservent(void) 760 { 761 dTHX; 762 Perl_croak_nocontext("getservent not implemented!\n"); 763 return (struct servent *) NULL; 764 } 765 766 void 767 win32_sethostent(int stayopen) 768 { 769 dTHX; 770 Perl_croak_nocontext("sethostent not implemented!\n"); 771 } 772 773 774 void 775 win32_setnetent(int stayopen) 776 { 777 dTHX; 778 Perl_croak_nocontext("setnetent not implemented!\n"); 779 } 780 781 782 void 783 win32_setprotoent(int stayopen) 784 { 785 dTHX; 786 Perl_croak_nocontext("setprotoent not implemented!\n"); 787 } 788 789 790 void 791 win32_setservent(int stayopen) 792 { 793 dTHX; 794 Perl_croak_nocontext("setservent not implemented!\n"); 795 } 796 797 static struct servent* 798 win32_savecopyservent(struct servent*d, struct servent*s, const char *proto) 799 { 800 d->s_name = s->s_name; 801 d->s_aliases = s->s_aliases; 802 d->s_port = s->s_port; 803 #ifndef __BORLANDC__ /* Buggy on Win95 and WinNT-with-Borland-WSOCK */ 804 if (!IsWin95() && s->s_proto && strlen(s->s_proto)) 805 d->s_proto = s->s_proto; 806 else 807 #endif 808 if (proto && strlen(proto)) 809 d->s_proto = (char *)proto; 810 else 811 d->s_proto = "tcp"; 812 813 return d; 814 } 815 816 817