1/** 2 * D header file for POSIX. 3 * 4 * Copyright: Copyright David Nadlinger 2011. 5 * License: $(HTTP www.boost.org/LICENSE_1_0.txt, Boost License 1.0). 6 * Authors: David Nadlinger, Sean Kelly, Alex R��nne Petersen 7 * Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition 8 */ 9 10/* Copyright David Nadlinger 2011. 11 * Distributed under the Boost Software License, Version 1.0. 12 * (See accompanying file LICENSE or copy at 13 * http://www.boost.org/LICENSE_1_0.txt) 14 */ 15module core.sys.posix.netdb; 16 17import core.sys.posix.config; 18public import core.stdc.inttypes; // for uint32_t 19public import core.sys.posix.netinet.in_; // for in_port_t, in_addr_t 20public import core.sys.posix.sys.types; // for ino_t 21public import core.sys.posix.sys.socket; // for socklen_t 22 23version (OSX) 24 version = Darwin; 25else version (iOS) 26 version = Darwin; 27else version (TVOS) 28 version = Darwin; 29else version (WatchOS) 30 version = Darwin; 31 32version (Posix): 33extern (C): 34nothrow: 35@nogc: 36@system: 37 38// 39// Required 40// 41/* 42struct hostent 43{ 44 char* h_name; 45 char** h_aliases; 46 int h_addrtype; 47 int h_length; 48 char** h_addr_list; 49} 50 51struct netent 52{ 53 char* n_name; 54 char** n_aliase; 55 int n_addrtype; 56 uint32_t n_net; 57} 58 59struct protoent 60{ 61 char* p_name; 62 char** p_aliases; 63 int p_proto; 64} 65 66struct servent 67{ 68 char* s_name; 69 char** s_aliases; 70 int s_port; 71 char* s_proto; 72} 73 74IPPORT_RESERVED 75 76h_errno 77 78HOST_NOT_FOUND 79NO_DATA 80NO_RECOVERY 81TRY_AGAIN 82 83struct addrinfo 84{ 85 int ai_flags; 86 int ai_family; 87 int ai_socktype; 88 int ai_protocol; 89 socklen_t ai_addrlen; 90 sockaddr* ai_addr; 91 char* ai_canonname; 92 addrinfo* ai_next; 93} 94 95AI_PASSIVE 96AI_CANONNAME 97AI_NUMERICHOST 98AI_NUMERICSERV 99AI_V4MAPPED 100AI_ALL 101AI_ADDRCONFIG 102 103NI_NOFQDN 104NI_NUMERICHOST 105NI_NAMEREQD 106NI_NUMERICSERV 107NI_NUMERICSCOPE 108NI_DGRAM 109 110EAI_AGAIN 111EAI_BADFLAGS 112EAI_FAIL 113EAI_FAMILY 114EAI_MEMORY 115EAI_NONAME 116 117EAI_SERVICE 118EAI_SOCKTYPE 119EAI_SYSTEM 120EAI_OVERFLOW 121 122void endhostent(); 123void endnetent(); 124void endprotoent(); 125void endservent(); 126void freeaddrinfo(addrinfo*); 127const(char)* gai_strerror(int); 128int getaddrinfo(const(char)*, const(char)*, const(addrinfo)*, addrinfo**); 129hostent* gethostbyaddr(const(void)*, socklen_t, int); 130hostent* gethostbyname(const(char)*); 131hostent* gethostent(); 132int getnameinfo(const(sockaddr)*, socklen_t, char*, socklen_t, char*, socklen_t, int); 133netent* getnetbyaddr(uint32_t, int); 134netent* getnetbyname(const(char)*); 135netent* getnetent(); 136protoent* getprotobyname(const(char)*); 137protoent* getprotobynumber(int); 138protoent* getprotoent(); 139servent* getservbyname(const(char)*, const(char)*); 140servent* getservbyport(int, const(char)*); 141servent* getservent(); 142void sethostent(int); 143void setnetent(int); 144void setprotoent(int); 145void setservent(int); 146*/ 147 148version (CRuntime_Glibc) 149{ 150 struct hostent 151 { 152 char* h_name; 153 char** h_aliases; 154 int h_addrtype; 155 int h_length; 156 char** h_addr_list; 157 char* h_addr() @property { return h_addr_list[0]; } // non-standard 158 } 159 160 struct netent 161 { 162 char* n_name; 163 char** n_aliases; 164 int n_addrtype; 165 uint32_t n_net; 166 } 167 168 struct protoent 169 { 170 char* p_name; 171 char** p_aliases; 172 int p_proto; 173 } 174 175 struct servent 176 { 177 char* s_name; 178 char** s_aliases; 179 int s_port; 180 char* s_proto; 181 } 182 183 enum IPPORT_RESERVED = 1024; 184 185 //h_errno 186 187 enum HOST_NOT_FOUND = 1; 188 enum NO_DATA = 4; 189 enum NO_RECOVERY = 3; 190 enum TRY_AGAIN = 2; 191 192 struct addrinfo 193 { 194 int ai_flags; 195 int ai_family; 196 int ai_socktype; 197 int ai_protocol; 198 socklen_t ai_addrlen; 199 sockaddr* ai_addr; 200 char* ai_canonname; 201 addrinfo* ai_next; 202 } 203 204 enum AI_PASSIVE = 0x1; 205 enum AI_CANONNAME = 0x2; 206 enum AI_NUMERICHOST = 0x4; 207 enum AI_NUMERICSERV = 0x400; 208 enum AI_V4MAPPED = 0x8; 209 enum AI_ALL = 0x10; 210 enum AI_ADDRCONFIG = 0x20; 211 212 enum NI_NOFQDN = 4; 213 enum NI_NUMERICHOST = 1; 214 enum NI_NAMEREQD = 8; 215 enum NI_NUMERICSERV = 2; 216 //enum NI_NUMERICSCOPE = ?; 217 enum NI_DGRAM = 16; 218 enum NI_MAXHOST = 1025; // non-standard 219 enum NI_MAXSERV = 32; // non-standard 220 221 enum EAI_AGAIN = -3; 222 enum EAI_BADFLAGS = -1; 223 enum EAI_FAIL = -4; 224 enum EAI_FAMILY = -6; 225 enum EAI_MEMORY = -10; 226 enum EAI_NONAME = -2; 227 enum EAI_SERVICE = -8; 228 enum EAI_SOCKTYPE = -7; 229 enum EAI_SYSTEM = -11; 230 enum EAI_OVERFLOW = -12; 231} 232else version (Darwin) 233{ 234 struct hostent 235 { 236 char* h_name; 237 char** h_aliases; 238 int h_addrtype; 239 int h_length; 240 char** h_addr_list; 241 char* h_addr() @property { return h_addr_list[0]; } // non-standard 242 } 243 244 struct netent 245 { 246 char* n_name; 247 char** n_aliases; 248 int n_addrtype; 249 uint32_t n_net; 250 } 251 252 struct protoent 253 { 254 char* p_name; 255 char** p_aliases; 256 int p_proto; 257 } 258 259 struct servent 260 { 261 char* s_name; 262 char** s_aliases; 263 int s_port; 264 char* s_proto; 265 } 266 267 enum IPPORT_RESERVED = 1024; 268 269 //h_errno 270 271 enum HOST_NOT_FOUND = 1; 272 enum NO_DATA = 4; 273 enum NO_RECOVERY = 3; 274 enum TRY_AGAIN = 2; 275 276 struct addrinfo 277 { 278 int ai_flags; 279 int ai_family; 280 int ai_socktype; 281 int ai_protocol; 282 socklen_t ai_addrlen; 283 char* ai_canonname; 284 sockaddr* ai_addr; 285 addrinfo* ai_next; 286 } 287 288 enum AI_PASSIVE = 0x1; 289 enum AI_CANONNAME = 0x2; 290 enum AI_NUMERICHOST = 0x4; 291 enum AI_NUMERICSERV = 0x1000; 292 enum AI_V4MAPPED = 0x800; 293 enum AI_ALL = 0x100; 294 enum AI_ADDRCONFIG = 0x400; 295 296 enum NI_NOFQDN = 0x1; 297 enum NI_NUMERICHOST = 0x2; 298 enum NI_NAMEREQD = 0x4; 299 enum NI_NUMERICSERV = 0x8; 300 //enum NI_NUMERICSCOPE = ?; 301 enum NI_DGRAM = 0x10; 302 enum NI_MAXHOST = 1025; // non-standard 303 enum NI_MAXSERV = 32; // non-standard 304 305 enum EAI_AGAIN = 2; 306 enum EAI_BADFLAGS = 3; 307 enum EAI_FAIL = 4; 308 enum EAI_FAMILY = 5; 309 enum EAI_MEMORY = 6; 310 enum EAI_NONAME = 8; 311 enum EAI_SERVICE = 9; 312 enum EAI_SOCKTYPE = 10; 313 enum EAI_SYSTEM = 11; 314 enum EAI_OVERFLOW = 14; 315} 316else version (FreeBSD) 317{ 318 struct hostent 319 { 320 char* h_name; 321 char** h_aliases; 322 int h_addrtype; 323 int h_length; 324 char** h_addr_list; 325 extern (D) char* h_addr() @property { return h_addr_list[0]; } // non-standard 326 } 327 328 struct netent 329 { 330 char* n_name; 331 char** n_aliases; 332 int n_addrtype; 333 uint32_t n_net; 334 } 335 336 struct protoent 337 { 338 char* p_name; 339 char** p_aliases; 340 int p_proto; 341 } 342 343 struct servent 344 { 345 char* s_name; 346 char** s_aliases; 347 int s_port; 348 char* s_proto; 349 } 350 351 enum IPPORT_RESERVED = 1024; 352 353 //h_errno 354 355 enum HOST_NOT_FOUND = 1; 356 enum NO_DATA = 4; 357 enum NO_RECOVERY = 3; 358 enum TRY_AGAIN = 2; 359 360 struct addrinfo 361 { 362 int ai_flags; 363 int ai_family; 364 int ai_socktype; 365 int ai_protocol; 366 socklen_t ai_addrlen; 367 char* ai_canonname; 368 sockaddr* ai_addr; 369 addrinfo* ai_next; 370 } 371 372 enum AI_PASSIVE = 0x1; 373 enum AI_CANONNAME = 0x2; 374 enum AI_NUMERICHOST = 0x4; 375 enum AI_NUMERICSERV = 0x8; 376 enum AI_V4MAPPED = 0x800; 377 enum AI_ALL = 0x100; 378 enum AI_ADDRCONFIG = 0x400; 379 380 enum NI_NOFQDN = 0x1; 381 enum NI_NUMERICHOST = 0x2; 382 enum NI_NAMEREQD = 0x4; 383 enum NI_NUMERICSERV = 0x8; 384 //enum NI_NUMERICSCOPE = ?; 385 enum NI_DGRAM = 0x10; 386 enum NI_MAXHOST = 1025; // non-standard 387 enum NI_MAXSERV = 32; // non-standard 388 389 enum EAI_AGAIN = 2; 390 enum EAI_BADFLAGS = 3; 391 enum EAI_FAIL = 4; 392 enum EAI_FAMILY = 5; 393 enum EAI_MEMORY = 6; 394 enum EAI_NONAME = 8; 395 enum EAI_SERVICE = 9; 396 enum EAI_SOCKTYPE = 10; 397 enum EAI_SYSTEM = 11; 398 enum EAI_OVERFLOW = 14; 399} 400else version (NetBSD) 401{ 402 struct hostent 403 { 404 char* h_name; 405 char** h_aliases; 406 int h_addrtype; 407 int h_length; 408 char** h_addr_list; 409 extern (D) char* h_addr() @property { return h_addr_list[0]; } // non-standard 410 } 411 412 struct netent 413 { 414 char* n_name; 415 char** n_aliases; 416 int n_addrtype; 417 uint32_t n_net; 418/+ todo 419#if (defined(__sparc__) && defined(_LP64)) || \ 420 (defined(__sh__) && defined(_LP64) && (_BYTE_ORDER == _BIG_ENDIAN)) 421 int __n_pad0; /* ABI compatibility */ 422#endif 423 uint32_t n_net; /*%< network # */ 424#if defined(__alpha__) || (defined(__i386__) && defined(_LP64)) || \ 425 (defined(__sh__) && defined(_LP64) && (_BYTE_ORDER == _LITTLE_ENDIAN)) 426 int __n_pad0; /* ABI compatibility */ 427#endif 428 429+/ 430 } 431 432 struct protoent 433 { 434 char* p_name; 435 char** p_aliases; 436 int p_proto; 437 } 438 439 struct servent 440 { 441 char* s_name; 442 char** s_aliases; 443 int s_port; 444 char* s_proto; 445 } 446 447 enum IPPORT_RESERVED = 1024; 448 449 //h_errno 450 451 enum HOST_NOT_FOUND = 1; 452 enum NO_DATA = 4; 453 enum NO_RECOVERY = 3; 454 enum TRY_AGAIN = 2; 455 456 struct addrinfo 457 { 458 int ai_flags; 459 int ai_family; 460 int ai_socktype; 461 int ai_protocol; 462/+todo 463#if defined(__sparc__) && defined(_LP64) 464 int __ai_pad0; /* ABI compatibility */ 465#endif 466+/ 467 socklen_t ai_addrlen; 468/+todo 469#if defined(__alpha__) || (defined(__i386__) && defined(_LP64)) 470 int __ai_pad0; /* ABI compatibility */ 471#endif 472+/ 473 char* ai_canonname; 474 sockaddr* ai_addr; 475 addrinfo* ai_next; 476 } 477 478 enum AI_PASSIVE = 0x1; 479 enum AI_CANONNAME = 0x2; 480 enum AI_NUMERICHOST = 0x4; 481 enum AI_NUMERICSERV = 0x8; 482 enum AI_V4MAPPED = 0x800; 483 enum AI_ALL = 0x100; 484 enum AI_ADDRCONFIG = 0x400; 485 486 enum NI_NOFQDN = 0x1; 487 enum NI_NUMERICHOST = 0x2; 488 enum NI_NAMEREQD = 0x4; 489 enum NI_NUMERICSERV = 0x8; 490 enum NI_DGRAM = 0x10; 491 enum NI_WITHSCOPEID = 0x00000020; 492 enum NI_NUMERICSCOPE = 0x00000040; 493 enum NI_MAXHOST = 1025; // non-standard 494 enum NI_MAXSERV = 32; // non-standard 495 496 enum EAI_AGAIN = 2; 497 enum EAI_BADFLAGS = 3; 498 enum EAI_FAIL = 4; 499 enum EAI_FAMILY = 5; 500 enum EAI_MEMORY = 6; 501 enum EAI_NONAME = 8; 502 enum EAI_SERVICE = 9; 503 enum EAI_SOCKTYPE = 10; 504 enum EAI_SYSTEM = 11; 505 enum EAI_OVERFLOW = 14; 506} 507else version (OpenBSD) 508{ 509 struct hostent 510 { 511 char* h_name; 512 char** h_aliases; 513 int h_addrtype; 514 int h_length; 515 char** h_addr_list; 516 extern (D) char* h_addr() @property { return h_addr_list[0]; } // non-standard 517 } 518 519 struct netent 520 { 521 char* n_name; 522 char** n_aliases; 523 int n_addrtype; 524 in_addr_t n_net; 525 } 526 527 struct protoent 528 { 529 char* p_name; 530 char** p_aliases; 531 int p_proto; 532 } 533 534 struct servent 535 { 536 char* s_name; 537 char** s_aliases; 538 int s_port; 539 char* s_proto; 540 } 541 542 enum IPPORT_RESERVED = 1024; 543 544 //h_errno 545 546 enum NETDB_INTERNAL = -1; 547 enum NETDB_SUCCESS = 0; 548 enum HOST_NOT_FOUND = 1; 549 enum NO_DATA = 4; 550 enum NO_RECOVERY = 3; 551 enum TRY_AGAIN = 2; 552 553 struct addrinfo 554 { 555 int ai_flags; 556 int ai_family; 557 int ai_socktype; 558 int ai_protocol; 559 socklen_t ai_addrlen; 560 char* ai_canonname; 561 sockaddr* ai_addr; 562 addrinfo* ai_next; 563 } 564 565 enum AI_PASSIVE = 0x1; 566 enum AI_CANONNAME = 0x2; 567 enum AI_NUMERICHOST = 0x4; 568 enum AI_EXT = 0x8; 569 enum AI_NUMERICSERV = 0x10; 570 enum AI_V4MAPPED = 0; // Not supported 571 enum AI_FQDN = 0x20; 572 enum AI_ADDRCONFIG = 0x40; 573 enum AI_MASK = AI_PASSIVE | AI_CANONNAME | AI_NUMERICHOST | AI_NUMERICSERV | AI_FQDN | AI_ADDRCONFIG; 574 575 enum NI_NUMERICHOST = 1; 576 enum NI_NUMERICSERV = 2; 577 enum NI_NOFQDN = 4; 578 enum NI_NAMEREQD = 8; 579 enum NI_DGRAM = 16; 580 //enum NI_NUMERICSCOPE = 32; 581 enum NI_MAXHOST = 256; // non-standard 582 enum NI_MAXSERV = 32; // non-standard 583 584 enum EAI_NONAME = -1; 585 enum EAI_BADFLAGS = -2; 586 enum EAI_AGAIN = -3; 587 enum EAI_FAIL = -4; 588 enum EAI_NODATA = -5; 589 enum EAI_FAMILY = -6; 590 enum EAI_SOCKTYPE = -7; 591 enum EAI_SERVICE = -8; 592 enum EAI_ADDRFAMILY = -9; 593 enum EAI_MEMORY = -10; 594 enum EAI_SYSTEM = -11; 595 enum EAI_BADHINTS = -12; 596 enum EAI_PROTOCOL = -13; 597 enum EAI_OVERFLOW = -14; 598} 599else version (DragonFlyBSD) 600{ 601 /* 602 * Error return codes from gethostbyname() and gethostbyaddr() 603 * (left in h_errno). 604 */ 605 struct hostent 606 { 607 char* h_name; 608 char** h_aliases; 609 int h_addrtype; 610 int h_length; 611 char** h_addr_list; 612 extern (D) char* h_addr() @property { return h_addr_list[0]; } // non-standard 613 } 614 615 struct netent 616 { 617 char* n_name; 618 char** n_aliases; 619 int n_addrtype; 620 uint32_t n_net; 621 } 622 623 struct protoent 624 { 625 char* p_name; 626 char** p_aliases; 627 int p_proto; 628 } 629 630 struct servent 631 { 632 char* s_name; 633 char** s_aliases; 634 int s_port; 635 char* s_proto; 636 } 637 638 struct addrinfo 639 { 640 int ai_flags; 641 int ai_family; 642 int ai_socktype = SOCK_STREAM; /* socktype default value required to be able to perform getAddrInfo on DragonFlyBSD 643 * without socktype set, you get 'servname not supported for ai_socktype' 644 */ 645 int ai_protocol; 646 socklen_t ai_addrlen; 647 char* ai_canonname; 648 sockaddr* ai_addr; 649 addrinfo* ai_next; 650 } 651 652 enum IPPORT_RESERVED = 1024; 653 654 enum NETDB_INTERNAL = -1; 655 enum NETDB_SUCCESS = 0; 656 enum HOST_NOT_FOUND = 1; 657 enum TRY_AGAIN = 2; 658 enum NO_RECOVERY = 3; 659 enum NO_DATA = 4; 660 enum NO_ADDRESS = NO_DATA; 661 662 //enum EAI_ADDRFAMILY = 1; // deprecated 663 enum EAI_AGAIN = 2; 664 enum EAI_BADFLAGS = 3; 665 enum EAI_FAIL = 4; 666 enum EAI_FAMILY = 5; 667 enum EAI_MEMORY = 6; 668 //enum EAI_NODATA = 7; // deprecated 669 enum EAI_NONAME = 8; 670 enum EAI_SERVICE = 9; 671 enum EAI_SOCKTYPE = 10; 672 enum EAI_SYSTEM = 11; 673 enum EAI_BADHINTS = 12; 674 enum EAI_PROTOCOL = 13; 675 enum EAI_OVERFLOW = 14; 676 677 enum AI_PASSIVE = 0x001; 678 enum AI_CANONNAME = 0x002; 679 enum AI_NUMERICHOST = 0x004; 680 enum AI_NUMERICSERV = 0x008; 681 enum AI_MASK = (AI_PASSIVE | AI_CANONNAME | AI_NUMERICHOST | AI_NUMERICSERV | AI_ADDRCONFIG); // valid flags for addrinfo (not a standard def, apps should not use it) 682 enum AI_ALL = 0x100; 683 enum AI_V4MAPPED_CFG = 0x200; 684 enum AI_ADDRCONFIG = 0x400; 685 enum AI_V4MAPPED = 0x800; 686 enum AI_DEFAULT = (AI_V4MAPPED_CFG | AI_ADDRCONFIG); 687 688 enum NI_MAXHOST = 1025; // non-standard 689 enum NI_MAXSERV = 32; // non-standard 690 691 enum NI_NOFQDN = 0x01; 692 enum NI_NUMERICHOST = 0x02; 693 enum NI_NAMEREQD = 0x04; 694 enum NI_NUMERICSERV = 0x08; 695 enum NI_DGRAM = 0x10; 696 //enum NI_WITHSCOPEID = 0x20; // deprecated 697 enum NI_NUMERICSCOPE = 0x40; 698 699} 700else version (Solaris) 701{ 702 struct hostent 703 { 704 char* h_name; 705 char** h_aliases; 706 int h_addrtype; 707 int h_length; 708 char** h_addr_list; 709 710 extern (D) char* h_addr() @property { return h_addr_list[0]; } // non-standard 711 } 712 713 struct netent 714 { 715 char* n_name; 716 char** n_aliases; 717 int n_addrtype; 718 uint32_t n_net; 719 } 720 721 struct protoent 722 { 723 char* p_name; 724 char** p_aliases; 725 int p_proto; 726 } 727 728 struct servent 729 { 730 char* s_name; 731 char** s_aliases; 732 int s_port; 733 char* s_proto; 734 } 735 736 enum HOST_NOT_FOUND = 1; 737 enum TRY_AGAIN = 2; 738 enum NO_RECOVERY = 3; 739 enum NO_DATA = 4; 740 741 struct addrinfo 742 { 743 int ai_flags; 744 int ai_family; 745 int ai_socktype; 746 int ai_protocol; 747 748 version (SPARC64) 749 int _ai_pad; 750 751 socklen_t ai_addrlen; 752 char* ai_canonname; 753 sockaddr* ai_addr; 754 addrinfo* ai_next; 755 } 756 757 enum AI_PASSIVE = 0x0008; 758 enum AI_CANONNAME = 0x0010; 759 enum AI_NUMERICHOST = 0x0020; 760 enum AI_NUMERICSERV = 0x0040; 761 enum AI_V4MAPPED = 0x0001; 762 enum AI_ALL = 0x0002; 763 enum AI_ADDRCONFIG = 0x0004; 764 765 enum NI_NOFQDN = 0x0001; 766 enum NI_NUMERICHOST = 0x0002; 767 enum NI_NAMEREQD = 0x0004; 768 enum NI_NUMERICSERV = 0x0008; 769 enum NI_DGRAM = 0x0010; 770 enum NI_WITHSCOPEID = 0x0020; 771 enum NI_NUMERICSCOPE = 0x0040; 772 enum NI_MAXHOST = 1025; 773 enum NI_MAXSERV = 32; 774 775 enum EAI_AGAIN = 2; 776 enum EAI_BADFLAGS = 3; 777 enum EAI_FAIL = 4; 778 enum EAI_FAMILY = 5; 779 enum EAI_MEMORY = 6; 780 enum EAI_NONAME = 8; 781 enum EAI_SERVICE = 9; 782 enum EAI_SOCKTYPE = 10; 783 enum EAI_SYSTEM = 11; 784 enum EAI_OVERFLOW = 14; 785 enum EAI_PROTOCOL = 13; 786 enum EAI_MAX = 14; 787} 788else version (CRuntime_Bionic) 789{ 790 struct hostent 791 { 792 char* h_name; 793 char** h_aliases; 794 int h_addrtype; 795 int h_length; 796 char** h_addr_list; 797 extern (D) char* h_addr() @property { return h_addr_list[0]; } // non-standard 798 } 799 800 struct netent 801 { 802 char* n_name; 803 char** n_aliases; 804 int n_addrtype; 805 uint32_t n_net; 806 } 807 808 struct protoent 809 { 810 char* p_name; 811 char** p_aliases; 812 int p_proto; 813 } 814 815 struct servent 816 { 817 char* s_name; 818 char** s_aliases; 819 int s_port; 820 char* s_proto; 821 } 822 823 enum IPPORT_RESERVED = 1024; 824 825 enum HOST_NOT_FOUND = 1; 826 enum NO_DATA = 4; 827 enum NO_RECOVERY = 3; 828 enum TRY_AGAIN = 2; 829 830 struct addrinfo 831 { 832 int ai_flags; 833 int ai_family; 834 int ai_socktype; 835 int ai_protocol; 836 socklen_t ai_addrlen; 837 char* ai_canonname; 838 sockaddr* ai_addr; 839 addrinfo* ai_next; 840 } 841 842 enum AI_PASSIVE = 0x1; 843 enum AI_CANONNAME = 0x2; 844 enum AI_NUMERICHOST = 0x4; 845 enum AI_NUMERICSERV = 0x8; 846 enum AI_V4MAPPED = 0x800; 847 enum AI_ALL = 0x100; 848 enum AI_ADDRCONFIG = 0x400; 849 850 enum NI_NOFQDN = 0x1; 851 enum NI_NUMERICHOST = 0x2; 852 enum NI_NAMEREQD = 0x4; 853 enum NI_NUMERICSERV = 0x8; 854 enum NI_DGRAM = 0x10; 855 enum NI_MAXHOST = 1025; // non-standard 856 enum NI_MAXSERV = 32; // non-standard 857 858 enum EAI_AGAIN = 2; 859 enum EAI_BADFLAGS = 3; 860 enum EAI_FAIL = 4; 861 enum EAI_FAMILY = 5; 862 enum EAI_MEMORY = 6; 863 enum EAI_NONAME = 8; 864 enum EAI_SERVICE = 9; 865 enum EAI_SOCKTYPE = 10; 866 enum EAI_SYSTEM = 11; 867 enum EAI_OVERFLOW = 14; 868} 869else version (CRuntime_Musl) 870{ 871 struct hostent 872 { 873 char* h_name; 874 char** h_aliases; 875 int h_addrtype; 876 int h_length; 877 char** h_addr_list; 878 char* h_addr() @property { return h_addr_list[0]; } // non-standard 879 } 880 881 struct netent 882 { 883 char* n_name; 884 char** n_aliases; 885 int n_addrtype; 886 uint32_t n_net; 887 } 888 889 struct protoent 890 { 891 char* p_name; 892 char** p_aliases; 893 int p_proto; 894 } 895 896 struct servent 897 { 898 char* s_name; 899 char** s_aliases; 900 int s_port; 901 char* s_proto; 902 } 903 904 struct addrinfo 905 { 906 int ai_flags; 907 int ai_family; 908 int ai_socktype; 909 int ai_protocol; 910 socklen_t ai_addrlen; 911 sockaddr* ai_addr; 912 char* ai_canonname; 913 addrinfo* ai_next; 914 } 915 916 enum { 917 AI_PASSIVE = 0x1, 918 AI_CANONNAME = 0x2, 919 AI_NUMERICHOST = 0x4, 920 AI_NUMERICSERV = 0x400, 921 AI_V4MAPPED = 0x8, 922 AI_ALL = 0x10, 923 AI_ADDRCONFIG = 0x20, 924 } 925 enum { 926 NI_NUMERICHOST = 1, 927 NI_NUMERICSERV = 2, 928 NI_NOFQDN = 4, 929 NI_NAMEREQD = 8, 930 NI_DGRAM = 16, 931 NI_MAXSERV = 32, 932 NI_MAXHOST = 255, 933 } 934 enum { 935 EAI_BADFLAGS = -1, 936 EAI_NONAME = -2, 937 EAI_AGAIN = -3, 938 EAI_FAIL = -4, 939 EAI_FAMILY = -6, 940 EAI_SOCKTYPE = -7, 941 EAI_SERVICE = -8, 942 EAI_MEMORY = -10, 943 EAI_SYSTEM = -11, 944 EAI_OVERFLOW = -12, 945 } 946} 947else version (CRuntime_UClibc) 948{ 949 struct hostent 950 { 951 char* h_name; 952 char** h_aliases; 953 int h_addrtype; 954 int h_length; 955 char** h_addr_list; 956 extern (D) char* h_addr() @property { return h_addr_list[0]; } // non-standard 957 } 958 959 struct netent 960 { 961 char* n_name; 962 char** n_aliases; 963 int n_addrtype; 964 uint32_t n_net; 965 } 966 967 struct protoent 968 { 969 char* p_name; 970 char** p_aliases; 971 int p_proto; 972 } 973 974 struct servent 975 { 976 char* s_name; 977 char** s_aliases; 978 int s_port; 979 char* s_proto; 980 } 981 982 enum IPPORT_RESERVED = 1024; 983 984 enum HOST_NOT_FOUND = 1; 985 enum NO_DATA = 4; 986 enum NO_RECOVERY = 3; 987 enum TRY_AGAIN = 2; 988 989 struct addrinfo 990 { 991 int ai_flags; 992 int ai_family; 993 int ai_socktype; 994 int ai_protocol; 995 socklen_t ai_addrlen; 996 sockaddr* ai_addr; 997 char* ai_canonname; 998 addrinfo* ai_next; 999 } 1000 1001 enum AI_PASSIVE = 0x1; 1002 enum AI_CANONNAME = 0x2; 1003 enum AI_NUMERICHOST = 0x4; 1004 enum AI_NUMERICSERV = 0x400; 1005 enum AI_V4MAPPED = 0x8; 1006 enum AI_ALL = 0x10; 1007 enum AI_ADDRCONFIG = 0x20; 1008 1009 enum NI_NOFQDN = 4; 1010 enum NI_NUMERICHOST = 1; 1011 enum NI_NAMEREQD = 8; 1012 enum NI_NUMERICSERV = 2; 1013 enum NI_DGRAM = 16; 1014 enum NI_MAXHOST = 1025; // non-standard 1015 enum NI_MAXSERV = 32; // non-standard 1016 1017 enum EAI_AGAIN = -3; 1018 enum EAI_BADFLAGS = -1; 1019 enum EAI_FAIL = -4; 1020 enum EAI_FAMILY = -6; 1021 enum EAI_MEMORY = -10; 1022 enum EAI_NONAME = -2; 1023 enum EAI_SERVICE = -8; 1024 enum EAI_SOCKTYPE = -7; 1025 enum EAI_SYSTEM = -11; 1026 enum EAI_OVERFLOW = -12; 1027 1028 enum EAI_NODATA = -5; 1029 enum EAI_ADDRFAMILY = -9; 1030 enum EAI_INPROGRESS = -100; 1031 enum EAI_CANCELED = -101; 1032 enum EAI_NOTCANCELED = -102; 1033 enum EAI_ALLDONE = -103; 1034 enum EAI_INTR = -104; 1035 enum EAI_IDN_ENCODE = -105; 1036} 1037else 1038{ 1039 static assert(false, "Unsupported platform"); 1040} 1041 1042void endhostent(); 1043void endnetent(); 1044void endprotoent(); 1045void endservent(); 1046void freeaddrinfo(addrinfo*); 1047const(char)* gai_strerror(int); 1048int getaddrinfo(const(char)*, const(char)*, const(addrinfo)*, addrinfo**); 1049hostent* gethostbyaddr(const(void)*, socklen_t, int); 1050hostent* gethostbyname(const(char)*); 1051hostent* gethostent(); 1052int getnameinfo(const(sockaddr)*, socklen_t, char*, socklen_t, char*, socklen_t, int); 1053netent* getnetbyaddr(uint32_t, int); 1054netent* getnetbyname(const(char)*); 1055netent* getnetent(); 1056protoent* getprotobyname(const(char)*); 1057protoent* getprotobynumber(int); 1058protoent* getprotoent(); 1059servent* getservbyname(const(char)*, const(char)*); 1060servent* getservbyport(int, const(char)*); 1061servent* getservent(); 1062void sethostent(int); 1063void setnetent(int); 1064void setprotoent(int); 1065void setservent(int); 1066