1 /* 2 Written by Christopher E. Miller 3 $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost License 1.0). 4 */ 5 6 7 /// Automatically imported and edited from the druntime module 8 /// core.sys.windows.winsock2 for the auto-generated win32 package. 9 module win32.winsock2; 10 //version (Windows): 11 @system: 12 13 version (Win32_UseLib) pragma(lib, "ws2_32"); 14 15 extern(Windows): 16 nothrow: 17 18 alias SOCKET = size_t; 19 alias socklen_t = int; 20 21 enum SOCKET INVALID_SOCKET = cast(SOCKET)~0; 22 enum int SOCKET_ERROR = -1; 23 24 enum WSADESCRIPTION_LEN = 256; 25 enum WSASYS_STATUS_LEN = 128; 26 27 struct WSADATA 28 { 29 ushort wVersion; 30 ushort wHighVersion; 31 char[WSADESCRIPTION_LEN + 1] szDescription = 0; 32 char[WSASYS_STATUS_LEN + 1] szSystemStatus = 0; 33 ushort iMaxSockets; 34 ushort iMaxUdpDg; 35 char* lpVendorInfo; 36 } 37 alias LPWSADATA = WSADATA*; 38 39 40 enum int IOCPARM_MASK = 0x7F; 41 enum int IOC_IN = cast(int)0x80000000; 42 enum int FIONBIO = cast(int)(IOC_IN | ((uint.sizeof & IOCPARM_MASK) << 16) | (102 << 8) | 126); 43 44 enum NI_MAXHOST = 1025; 45 enum NI_MAXSERV = 32; 46 47 @nogc 48 { 49 int WSAStartup(ushort wVersionRequested, LPWSADATA lpWSAData); 50 int WSACleanup(); 51 SOCKET socket(int af, int type, int protocol); 52 int ioctlsocket(SOCKET s, int cmd, uint* argp); 53 int bind(SOCKET s, const(sockaddr)* name, socklen_t namelen); 54 int connect(SOCKET s, const(sockaddr)* name, socklen_t namelen); 55 int listen(SOCKET s, int backlog); 56 SOCKET accept(SOCKET s, sockaddr* addr, socklen_t* addrlen); 57 int closesocket(SOCKET s); 58 int shutdown(SOCKET s, int how); 59 int getpeername(SOCKET s, sockaddr* name, socklen_t* namelen); 60 int getsockname(SOCKET s, sockaddr* name, socklen_t* namelen); 61 int send(SOCKET s, const(void)* buf, int len, int flags); 62 int sendto(SOCKET s, const(void)* buf, int len, int flags, const(sockaddr)* to, socklen_t tolen); 63 int recv(SOCKET s, void* buf, int len, int flags); 64 int recvfrom(SOCKET s, void* buf, int len, int flags, sockaddr* from, socklen_t* fromlen); 65 int getsockopt(SOCKET s, int level, int optname, void* optval, socklen_t* optlen); 66 int setsockopt(SOCKET s, int level, int optname, const(void)* optval, socklen_t optlen); 67 uint inet_addr(const char* cp); 68 int select(int nfds, fd_set* readfds, fd_set* writefds, fd_set* errorfds, const(timeval)* timeout); 69 char* inet_ntoa(in_addr ina); 70 hostent* gethostbyname(const char* name); 71 hostent* gethostbyaddr(const(void)* addr, int len, int type); 72 protoent* getprotobyname(const char* name); 73 protoent* getprotobynumber(int number); 74 servent* getservbyname(const char* name, const char* proto); 75 servent* getservbyport(int port, const char* proto); 76 } 77 78 enum: int 79 { 80 NI_NOFQDN = 0x01, 81 NI_NUMERICHOST = 0x02, 82 NI_NAMEREQD = 0x04, 83 NI_NUMERICSERV = 0x08, 84 NI_DGRAM = 0x10, 85 } 86 87 @nogc 88 { 89 int gethostname(const char* name, int namelen); 90 int getaddrinfo(const(char)* nodename, const(char)* servname, const(addrinfo)* hints, addrinfo** res); 91 void freeaddrinfo(addrinfo* ai); 92 int getnameinfo(const(sockaddr)* sa, socklen_t salen, char* host, uint hostlen, char* serv, uint servlen, int flags); 93 } 94 95 enum WSABASEERR = 10000; 96 97 enum: int 98 { 99 /* 100 * Windows Sockets definitions of regular Microsoft C error constants 101 */ 102 WSAEINTR = (WSABASEERR+4), 103 WSAEBADF = (WSABASEERR+9), 104 WSAEACCES = (WSABASEERR+13), 105 WSAEFAULT = (WSABASEERR+14), 106 WSAEINVAL = (WSABASEERR+22), 107 WSAEMFILE = (WSABASEERR+24), 108 109 /* 110 * Windows Sockets definitions of regular Berkeley error constants 111 */ 112 WSAEWOULDBLOCK = (WSABASEERR+35), 113 WSAEINPROGRESS = (WSABASEERR+36), 114 WSAEALREADY = (WSABASEERR+37), 115 WSAENOTSOCK = (WSABASEERR+38), 116 WSAEDESTADDRREQ = (WSABASEERR+39), 117 WSAEMSGSIZE = (WSABASEERR+40), 118 WSAEPROTOTYPE = (WSABASEERR+41), 119 WSAENOPROTOOPT = (WSABASEERR+42), 120 WSAEPROTONOSUPPORT = (WSABASEERR+43), 121 WSAESOCKTNOSUPPORT = (WSABASEERR+44), 122 WSAEOPNOTSUPP = (WSABASEERR+45), 123 WSAEPFNOSUPPORT = (WSABASEERR+46), 124 WSAEAFNOSUPPORT = (WSABASEERR+47), 125 WSAEADDRINUSE = (WSABASEERR+48), 126 WSAEADDRNOTAVAIL = (WSABASEERR+49), 127 WSAENETDOWN = (WSABASEERR+50), 128 WSAENETUNREACH = (WSABASEERR+51), 129 WSAENETRESET = (WSABASEERR+52), 130 WSAECONNABORTED = (WSABASEERR+53), 131 WSAECONNRESET = (WSABASEERR+54), 132 WSAENOBUFS = (WSABASEERR+55), 133 WSAEISCONN = (WSABASEERR+56), 134 WSAENOTCONN = (WSABASEERR+57), 135 WSAESHUTDOWN = (WSABASEERR+58), 136 WSAETOOMANYREFS = (WSABASEERR+59), 137 WSAETIMEDOUT = (WSABASEERR+60), 138 WSAECONNREFUSED = (WSABASEERR+61), 139 WSAELOOP = (WSABASEERR+62), 140 WSAENAMETOOLONG = (WSABASEERR+63), 141 WSAEHOSTDOWN = (WSABASEERR+64), 142 WSAEHOSTUNREACH = (WSABASEERR+65), 143 WSAENOTEMPTY = (WSABASEERR+66), 144 WSAEPROCLIM = (WSABASEERR+67), 145 WSAEUSERS = (WSABASEERR+68), 146 WSAEDQUOT = (WSABASEERR+69), 147 WSAESTALE = (WSABASEERR+70), 148 WSAEREMOTE = (WSABASEERR+71), 149 150 /* 151 * Extended Windows Sockets error constant definitions 152 */ 153 WSASYSNOTREADY = (WSABASEERR+91), 154 WSAVERNOTSUPPORTED = (WSABASEERR+92), 155 WSANOTINITIALISED = (WSABASEERR+93), 156 157 /* Authoritative Answer: Host not found */ 158 WSAHOST_NOT_FOUND = (WSABASEERR+1001), 159 HOST_NOT_FOUND = WSAHOST_NOT_FOUND, 160 161 /* Non-Authoritative: Host not found, or SERVERFAIL */ 162 WSATRY_AGAIN = (WSABASEERR+1002), 163 TRY_AGAIN = WSATRY_AGAIN, 164 165 /* Non recoverable errors, FORMERR, REFUSED, NOTIMP */ 166 WSANO_RECOVERY = (WSABASEERR+1003), 167 NO_RECOVERY = WSANO_RECOVERY, 168 169 /* Valid name, no data record of requested type */ 170 WSANO_DATA = (WSABASEERR+1004), 171 NO_DATA = WSANO_DATA, 172 173 /* no address, look for MX record */ 174 WSANO_ADDRESS = WSANO_DATA, 175 NO_ADDRESS = WSANO_ADDRESS 176 } 177 178 /* 179 * Windows Sockets errors redefined as regular Berkeley error constants 180 */ 181 enum: int 182 { 183 EWOULDBLOCK = WSAEWOULDBLOCK, 184 EINPROGRESS = WSAEINPROGRESS, 185 EALREADY = WSAEALREADY, 186 ENOTSOCK = WSAENOTSOCK, 187 EDESTADDRREQ = WSAEDESTADDRREQ, 188 EMSGSIZE = WSAEMSGSIZE, 189 EPROTOTYPE = WSAEPROTOTYPE, 190 ENOPROTOOPT = WSAENOPROTOOPT, 191 EPROTONOSUPPORT = WSAEPROTONOSUPPORT, 192 ESOCKTNOSUPPORT = WSAESOCKTNOSUPPORT, 193 EOPNOTSUPP = WSAEOPNOTSUPP, 194 EPFNOSUPPORT = WSAEPFNOSUPPORT, 195 EAFNOSUPPORT = WSAEAFNOSUPPORT, 196 EADDRINUSE = WSAEADDRINUSE, 197 EADDRNOTAVAIL = WSAEADDRNOTAVAIL, 198 ENETDOWN = WSAENETDOWN, 199 ENETUNREACH = WSAENETUNREACH, 200 ENETRESET = WSAENETRESET, 201 ECONNABORTED = WSAECONNABORTED, 202 ECONNRESET = WSAECONNRESET, 203 ENOBUFS = WSAENOBUFS, 204 EISCONN = WSAEISCONN, 205 ENOTCONN = WSAENOTCONN, 206 ESHUTDOWN = WSAESHUTDOWN, 207 ETOOMANYREFS = WSAETOOMANYREFS, 208 ETIMEDOUT = WSAETIMEDOUT, 209 ECONNREFUSED = WSAECONNREFUSED, 210 ELOOP = WSAELOOP, 211 ENAMETOOLONG = WSAENAMETOOLONG, 212 EHOSTDOWN = WSAEHOSTDOWN, 213 EHOSTUNREACH = WSAEHOSTUNREACH, 214 ENOTEMPTY = WSAENOTEMPTY, 215 EPROCLIM = WSAEPROCLIM, 216 EUSERS = WSAEUSERS, 217 EDQUOT = WSAEDQUOT, 218 ESTALE = WSAESTALE, 219 EREMOTE = WSAEREMOTE 220 } 221 222 enum: int 223 { 224 EAI_NONAME = WSAHOST_NOT_FOUND, 225 } 226 227 int WSAGetLastError() @trusted @nogc; 228 229 230 enum: int 231 { 232 AF_UNSPEC = 0, 233 234 AF_UNIX = 1, 235 AF_INET = 2, 236 AF_IMPLINK = 3, 237 AF_PUP = 4, 238 AF_CHAOS = 5, 239 AF_NS = 6, 240 AF_IPX = AF_NS, 241 AF_ISO = 7, 242 AF_OSI = AF_ISO, 243 AF_ECMA = 8, 244 AF_DATAKIT = 9, 245 AF_CCITT = 10, 246 AF_SNA = 11, 247 AF_DECnet = 12, 248 AF_DLI = 13, 249 AF_LAT = 14, 250 AF_HYLINK = 15, 251 AF_APPLETALK = 16, 252 AF_NETBIOS = 17, 253 AF_VOICEVIEW = 18, 254 AF_FIREFOX = 19, 255 AF_UNKNOWN1 = 20, 256 AF_BAN = 21, 257 AF_ATM = 22, 258 AF_INET6 = 23, 259 AF_CLUSTER = 24, 260 AF_12844 = 25, 261 AF_IRDA = 26, 262 AF_NETDES = 28, 263 264 AF_MAX = 29, 265 266 267 PF_UNSPEC = AF_UNSPEC, 268 269 PF_UNIX = AF_UNIX, 270 PF_INET = AF_INET, 271 PF_IMPLINK = AF_IMPLINK, 272 PF_PUP = AF_PUP, 273 PF_CHAOS = AF_CHAOS, 274 PF_NS = AF_NS, 275 PF_IPX = AF_IPX, 276 PF_ISO = AF_ISO, 277 PF_OSI = AF_OSI, 278 PF_ECMA = AF_ECMA, 279 PF_DATAKIT = AF_DATAKIT, 280 PF_CCITT = AF_CCITT, 281 PF_SNA = AF_SNA, 282 PF_DECnet = AF_DECnet, 283 PF_DLI = AF_DLI, 284 PF_LAT = AF_LAT, 285 PF_HYLINK = AF_HYLINK, 286 PF_APPLETALK = AF_APPLETALK, 287 PF_VOICEVIEW = AF_VOICEVIEW, 288 PF_FIREFOX = AF_FIREFOX, 289 PF_UNKNOWN1 = AF_UNKNOWN1, 290 PF_BAN = AF_BAN, 291 PF_INET6 = AF_INET6, 292 293 PF_MAX = AF_MAX, 294 } 295 296 297 enum: int 298 { 299 SOL_SOCKET = 0xFFFF, 300 } 301 302 303 enum: int 304 { 305 SO_DEBUG = 0x0001, 306 SO_ACCEPTCONN = 0x0002, 307 SO_REUSEADDR = 0x0004, 308 SO_KEEPALIVE = 0x0008, 309 SO_DONTROUTE = 0x0010, 310 SO_BROADCAST = 0x0020, 311 SO_USELOOPBACK = 0x0040, 312 SO_LINGER = 0x0080, 313 SO_DONTLINGER = ~SO_LINGER, 314 SO_OOBINLINE = 0x0100, 315 SO_SNDBUF = 0x1001, 316 SO_RCVBUF = 0x1002, 317 SO_SNDLOWAT = 0x1003, 318 SO_RCVLOWAT = 0x1004, 319 SO_SNDTIMEO = 0x1005, 320 SO_RCVTIMEO = 0x1006, 321 SO_ERROR = 0x1007, 322 SO_TYPE = 0x1008, 323 SO_EXCLUSIVEADDRUSE = ~SO_REUSEADDR, 324 325 TCP_NODELAY = 1, 326 327 IP_OPTIONS = 1, 328 329 IP_HDRINCL = 2, 330 IP_TOS = 3, 331 IP_TTL = 4, 332 IP_MULTICAST_IF = 9, 333 IP_MULTICAST_TTL = 10, 334 IP_MULTICAST_LOOP = 11, 335 IP_ADD_MEMBERSHIP = 12, 336 IP_DROP_MEMBERSHIP = 13, 337 IP_DONTFRAGMENT = 14, 338 IP_ADD_SOURCE_MEMBERSHIP = 15, 339 IP_DROP_SOURCE_MEMBERSHIP = 16, 340 IP_BLOCK_SOURCE = 17, 341 IP_UNBLOCK_SOURCE = 18, 342 IP_PKTINFO = 19, 343 344 IPV6_UNICAST_HOPS = 4, 345 IPV6_MULTICAST_IF = 9, 346 IPV6_MULTICAST_HOPS = 10, 347 IPV6_MULTICAST_LOOP = 11, 348 IPV6_ADD_MEMBERSHIP = 12, 349 IPV6_DROP_MEMBERSHIP = 13, 350 IPV6_JOIN_GROUP = IPV6_ADD_MEMBERSHIP, 351 IPV6_LEAVE_GROUP = IPV6_DROP_MEMBERSHIP, 352 IPV6_V6ONLY = 27, 353 } 354 355 356 /// Default FD_SETSIZE value. 357 /// In C/C++, it is redefinable by #define-ing the macro before #include-ing 358 /// winsock.h. In D, use the $(D FD_CREATE) function to allocate a $(D fd_set) 359 /// of an arbitrary size. 360 enum int FD_SETSIZE = 64; 361 362 363 struct fd_set_custom(uint SETSIZE) 364 { 365 uint fd_count; 366 SOCKET[SETSIZE] fd_array; 367 } 368 369 alias fd_set = fd_set_custom!FD_SETSIZE; 370 371 // Removes. 372 void FD_CLR(SOCKET fd, fd_set* set) pure @nogc 373 { 374 uint c = set.fd_count; 375 SOCKET* start = set.fd_array.ptr; 376 SOCKET* stop = start + c; 377 378 for (; start != stop; start++) 379 { 380 if (*start == fd) 381 goto found; 382 } 383 return; //not found 384 385 found: 386 for (++start; start != stop; start++) 387 { 388 *(start - 1) = *start; 389 } 390 391 set.fd_count = c - 1; 392 } 393 394 395 // Tests. 396 int FD_ISSET(SOCKET fd, const(fd_set)* set) pure @nogc 397 { 398 const(SOCKET)* start = set.fd_array.ptr; 399 const(SOCKET)* stop = start + set.fd_count; 400 401 for (; start != stop; start++) 402 { 403 if (*start == fd) 404 return true; 405 } 406 return false; 407 } 408 409 410 // Adds. 411 void FD_SET(SOCKET fd, fd_set* set) pure @nogc 412 { 413 uint c = set.fd_count; 414 set.fd_array.ptr[c] = fd; 415 set.fd_count = c + 1; 416 } 417 418 419 // Resets to zero. 420 void FD_ZERO(fd_set* set) pure @nogc 421 { 422 set.fd_count = 0; 423 } 424 425 426 /// Creates a new $(D fd_set) with the specified capacity. 427 fd_set* FD_CREATE(uint capacity) pure 428 { 429 // Take into account alignment (SOCKET may be 64-bit and require 64-bit alignment on 64-bit systems) 430 size_t size = (fd_set_custom!1).sizeof - SOCKET.sizeof + (SOCKET.sizeof * capacity); 431 auto data = new ubyte[size]; 432 auto set = cast(fd_set*)data.ptr; 433 FD_ZERO(set); 434 return set; 435 } 436 437 struct linger 438 { 439 ushort l_onoff; 440 ushort l_linger; 441 } 442 443 444 struct protoent 445 { 446 char* p_name; 447 char** p_aliases; 448 short p_proto; 449 } 450 451 452 struct servent 453 { 454 char* s_name; 455 char** s_aliases; 456 457 version (Win64) 458 { 459 char* s_proto; 460 short s_port; 461 } 462 else version (Win32) 463 { 464 short s_port; 465 char* s_proto; 466 } 467 } 468 469 470 /+ 471 union in6_addr 472 { 473 private union _u_t 474 { 475 ubyte[16] Byte; 476 ushort[8] Word; 477 } 478 _u_t u; 479 } 480 481 482 struct in_addr6 483 { 484 ubyte[16] s6_addr; 485 } 486 +/ 487 488 @safe pure @nogc 489 { 490 ushort htons(ushort x); 491 uint htonl(uint x); 492 ushort ntohs(ushort x); 493 uint ntohl(uint x); 494 } 495 496 497 enum: int 498 { 499 SOCK_STREAM = 1, 500 SOCK_DGRAM = 2, 501 SOCK_RAW = 3, 502 SOCK_RDM = 4, 503 SOCK_SEQPACKET = 5, 504 } 505 506 507 enum: int 508 { 509 IPPROTO_IP = 0, 510 IPPROTO_ICMP = 1, 511 IPPROTO_IGMP = 2, 512 IPPROTO_GGP = 3, 513 IPPROTO_TCP = 6, 514 IPPROTO_PUP = 12, 515 IPPROTO_UDP = 17, 516 IPPROTO_IDP = 22, 517 IPPROTO_IPV6 = 41, 518 IPPROTO_ND = 77, 519 IPPROTO_RAW = 255, 520 521 IPPROTO_MAX = 256, 522 } 523 524 525 enum: int 526 { 527 MSG_OOB = 0x1, 528 MSG_PEEK = 0x2, 529 MSG_DONTROUTE = 0x4 530 } 531 532 533 enum: int 534 { 535 SD_RECEIVE = 0, 536 SD_SEND = 1, 537 SD_BOTH = 2, 538 } 539 540 541 enum: uint 542 { 543 INADDR_ANY = 0, 544 INADDR_LOOPBACK = 0x7F000001, 545 INADDR_BROADCAST = 0xFFFFFFFF, 546 INADDR_NONE = 0xFFFFFFFF, 547 ADDR_ANY = INADDR_ANY, 548 } 549 550 551 enum: int 552 { 553 AI_PASSIVE = 0x1, 554 AI_CANONNAME = 0x2, 555 AI_NUMERICHOST = 0x4, 556 AI_ADDRCONFIG = 0x0400, 557 AI_NON_AUTHORITATIVE = 0x04000, 558 AI_SECURE = 0x08000, 559 AI_RETURN_PREFERRED_NAMES = 0x010000, 560 } 561 562 563 struct timeval 564 { 565 int tv_sec; 566 int tv_usec; 567 } 568 569 570 union in_addr 571 { 572 private union _S_un_t 573 { 574 private struct _S_un_b_t 575 { 576 ubyte s_b1, s_b2, s_b3, s_b4; 577 } 578 _S_un_b_t S_un_b; 579 580 private struct _S_un_w_t 581 { 582 ushort s_w1, s_w2; 583 } 584 _S_un_w_t S_un_w; 585 586 uint S_addr; 587 } 588 _S_un_t S_un; 589 590 uint s_addr; 591 592 struct 593 { 594 ubyte s_net, s_host; 595 596 union 597 { 598 ushort s_imp; 599 600 struct 601 { 602 ubyte s_lh, s_impno; 603 } 604 } 605 } 606 } 607 608 609 union in6_addr 610 { 611 private union _in6_u_t 612 { 613 ubyte[16] u6_addr8; 614 ushort[8] u6_addr16; 615 uint[4] u6_addr32; 616 } 617 _in6_u_t in6_u; 618 619 ubyte[16] s6_addr8; 620 ushort[8] s6_addr16; 621 uint[4] s6_addr32; 622 623 alias s6_addr = s6_addr8; 624 } 625 626 627 enum in6_addr IN6ADDR_ANY = { s6_addr8: [0] }; 628 enum in6_addr IN6ADDR_LOOPBACK = { s6_addr8: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1] }; 629 //alias IN6ADDR_ANY_INIT = IN6ADDR_ANY; 630 //alias IN6ADDR_LOOPBACK_INIT = IN6ADDR_LOOPBACK; 631 632 enum int INET_ADDRSTRLEN = 16; 633 enum int INET6_ADDRSTRLEN = 46; 634 635 636 637 638 struct sockaddr 639 { 640 short sa_family; 641 ubyte[14] sa_data; 642 } 643 alias sockaddr SOCKADDR; 644 alias SOCKADDR* PSOCKADDR, LPSOCKADDR; 645 646 struct sockaddr_storage 647 { 648 short ss_family; 649 char[6] __ss_pad1 = void; 650 long __ss_align; 651 char[112] __ss_pad2 = void; 652 } 653 alias sockaddr_storage SOCKADDR_STORAGE; 654 alias SOCKADDR_STORAGE* PSOCKADDR_STORAGE; 655 656 struct sockaddr_in 657 { 658 short sin_family = AF_INET; 659 ushort sin_port; 660 in_addr sin_addr; 661 ubyte[8] sin_zero; 662 } 663 alias sockaddr_in SOCKADDR_IN; 664 alias SOCKADDR_IN* PSOCKADDR_IN, LPSOCKADDR_IN; 665 666 667 struct sockaddr_in6 668 { 669 short sin6_family = AF_INET6; 670 ushort sin6_port; 671 uint sin6_flowinfo; 672 in6_addr sin6_addr; 673 uint sin6_scope_id; 674 } 675 676 677 struct addrinfo 678 { 679 int ai_flags; 680 int ai_family; 681 int ai_socktype; 682 int ai_protocol; 683 size_t ai_addrlen; 684 char* ai_canonname; 685 sockaddr* ai_addr; 686 addrinfo* ai_next; 687 } 688 689 690 struct hostent 691 { 692 char* h_name; 693 char** h_aliases; 694 short h_addrtype; 695 short h_length; 696 char** h_addr_list; 697 698 699 char* h_addr() @safe pure nothrow @nogc 700 { 701 return h_addr_list[0]; 702 } 703 } 704 705 // Note: These are Winsock2!! 706 struct WSAOVERLAPPED; 707 alias LPWSAOVERLAPPED = WSAOVERLAPPED*; 708 alias LPWSAOVERLAPPED_COMPLETION_ROUTINE = void function(uint, uint, LPWSAOVERLAPPED, uint); 709 int WSAIoctl(SOCKET s, uint dwIoControlCode, 710 void* lpvInBuffer, uint cbInBuffer, 711 void* lpvOutBuffer, uint cbOutBuffer, 712 uint* lpcbBytesReturned, 713 LPWSAOVERLAPPED lpOverlapped, LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine); 714 715 716 enum IOC_VENDOR = 0x18000000; 717 enum SIO_KEEPALIVE_VALS = IOC_IN | IOC_VENDOR | 4; 718 719 /* Argument structure for SIO_KEEPALIVE_VALS */ 720 struct tcp_keepalive 721 { 722 uint onoff; 723 uint keepalivetime; 724 uint keepaliveinterval; 725 }