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