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 */
15 module core.sys.posix.netdb;
16
17 import core.sys.posix.config;
18 public import core.stdc.inttypes; // for uint32_t
19 public import core.sys.posix.netinet.in_; // for in_port_t, in_addr_t
20 public import core.sys.posix.sys.types; // for ino_t
21 public import core.sys.posix.sys.socket; // for socklen_t
22
23 version (OSX)
24 version = Darwin;
25 else version (iOS)
26 version = Darwin;
27 else version (TVOS)
28 version = Darwin;
29 else version (WatchOS)
30 version = Darwin;
31
version(Posix)32 version (Posix):
33 extern (C):
34 nothrow:
35 @nogc:
36 @system:
37
38 //
39 // Required
40 //
41 /*
42 struct 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
51 struct netent
52 {
53 char* n_name;
54 char** n_aliase;
55 int n_addrtype;
56 uint32_t n_net;
57 }
58
59 struct protoent
60 {
61 char* p_name;
62 char** p_aliases;
63 int p_proto;
64 }
65
66 struct servent
67 {
68 char* s_name;
69 char** s_aliases;
70 int s_port;
71 char* s_proto;
72 }
73
74 IPPORT_RESERVED
75
76 h_errno
77
78 HOST_NOT_FOUND
79 NO_DATA
80 NO_RECOVERY
81 TRY_AGAIN
82
83 struct 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
95 AI_PASSIVE
96 AI_CANONNAME
97 AI_NUMERICHOST
98 AI_NUMERICSERV
99 AI_V4MAPPED
100 AI_ALL
101 AI_ADDRCONFIG
102
103 NI_NOFQDN
104 NI_NUMERICHOST
105 NI_NAMEREQD
106 NI_NUMERICSERV
107 NI_NUMERICSCOPE
108 NI_DGRAM
109
110 EAI_AGAIN
111 EAI_BADFLAGS
112 EAI_FAIL
113 EAI_FAMILY
114 EAI_MEMORY
115 EAI_NONAME
116
117 EAI_SERVICE
118 EAI_SOCKTYPE
119 EAI_SYSTEM
120 EAI_OVERFLOW
121
122 void endhostent();
123 void endnetent();
124 void endprotoent();
125 void endservent();
126 void freeaddrinfo(addrinfo*);
127 const(char)* gai_strerror(int);
128 int getaddrinfo(const(char)*, const(char)*, const(addrinfo)*, addrinfo**);
129 hostent* gethostbyaddr(const(void)*, socklen_t, int);
130 hostent* gethostbyname(const(char)*);
131 hostent* gethostent();
132 int getnameinfo(const(sockaddr)*, socklen_t, char*, socklen_t, char*, socklen_t, int);
133 netent* getnetbyaddr(uint32_t, int);
134 netent* getnetbyname(const(char)*);
135 netent* getnetent();
136 protoent* getprotobyname(const(char)*);
137 protoent* getprotobynumber(int);
138 protoent* getprotoent();
139 servent* getservbyname(const(char)*, const(char)*);
140 servent* getservbyport(int, const(char)*);
141 servent* getservent();
142 void sethostent(int);
143 void setnetent(int);
144 void setprotoent(int);
145 void setservent(int);
146 */
147
148 version (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 }
version(Darwin)232 else 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 }
version(FreeBSD)316 else 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 }
version(NetBSD)400 else 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 }
version(OpenBSD)507 else 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 }
version(DragonFlyBSD)599 else 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 }
version(Solaris)700 else 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 }
version(CRuntime_Bionic)788 else 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 }
version(CRuntime_Musl)869 else 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 }
version(CRuntime_UClibc)947 else 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 }
1037 else
1038 {
1039 static assert(false, "Unsupported platform");
1040 }
1041
1042 void endhostent();
1043 void endnetent();
1044 void endprotoent();
1045 void endservent();
1046 void freeaddrinfo(addrinfo*);
1047 const(char)* gai_strerror(int);
1048 int getaddrinfo(const(char)*, const(char)*, const(addrinfo)*, addrinfo**);
1049 hostent* gethostbyaddr(const(void)*, socklen_t, int);
1050 hostent* gethostbyname(const(char)*);
1051 hostent* gethostent();
1052 int getnameinfo(const(sockaddr)*, socklen_t, char*, socklen_t, char*, socklen_t, int);
1053 netent* getnetbyaddr(uint32_t, int);
1054 netent* getnetbyname(const(char)*);
1055 netent* getnetent();
1056 protoent* getprotobyname(const(char)*);
1057 protoent* getprotobynumber(int);
1058 protoent* getprotoent();
1059 servent* getservbyname(const(char)*, const(char)*);
1060 servent* getservbyport(int, const(char)*);
1061 servent* getservent();
1062 void sethostent(int);
1063 void setnetent(int);
1064 void setprotoent(int);
1065 void setservent(int);
1066