xref: /netbsd-src/external/gpl3/gcc/dist/libphobos/libdruntime/core/sys/posix/netdb.d (revision 0a3071956a3a9fdebdbf7f338cf2d439b45fc728)
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