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_FQDN = 0x20;
571 enum AI_ADDRCONFIG = 0x40;
572 enum AI_MASK = AI_PASSIVE | AI_CANONNAME | AI_NUMERICHOST | AI_NUMERICSERV | AI_FQDN | AI_ADDRCONFIG;
573
574 enum NI_NUMERICHOST = 1;
575 enum NI_NUMERICSERV = 2;
576 enum NI_NOFQDN = 4;
577 enum NI_NAMEREQD = 8;
578 enum NI_DGRAM = 16;
579 //enum NI_NUMERICSCOPE = 32;
580 enum NI_MAXHOST = 256; // non-standard
581 enum NI_MAXSERV = 32; // non-standard
582
583 enum EAI_NONAME = -1;
584 enum EAI_BADFLAGS = -2;
585 enum EAI_AGAIN = -3;
586 enum EAI_FAIL = -4;
587 enum EAI_NODATA = -5;
588 enum EAI_FAMILY = -6;
589 enum EAI_SOCKTYPE = -7;
590 enum EAI_SERVICE = -8;
591 enum EAI_ADDRFAMILY = -9;
592 enum EAI_MEMORY = -10;
593 enum EAI_SYSTEM = -11;
594 enum EAI_BADHINTS = -12;
595 enum EAI_PROTOCOL = -13;
596 enum EAI_OVERFLOW = -14;
597 }
version(DragonFlyBSD)598 else version (DragonFlyBSD)
599 {
600 /*
601 * Error return codes from gethostbyname() and gethostbyaddr()
602 * (left in h_errno).
603 */
604 struct hostent
605 {
606 char* h_name;
607 char** h_aliases;
608 int h_addrtype;
609 int h_length;
610 char** h_addr_list;
611 extern (D) char* h_addr() @property { return h_addr_list[0]; } // non-standard
612 }
613
614 struct netent
615 {
616 char* n_name;
617 char** n_aliases;
618 int n_addrtype;
619 uint32_t n_net;
620 }
621
622 struct protoent
623 {
624 char* p_name;
625 char** p_aliases;
626 int p_proto;
627 }
628
629 struct servent
630 {
631 char* s_name;
632 char** s_aliases;
633 int s_port;
634 char* s_proto;
635 }
636
637 struct addrinfo
638 {
639 int ai_flags;
640 int ai_family;
641 int ai_socktype = SOCK_STREAM; /* socktype default value required to be able to perform getAddrInfo on DragonFlyBSD
642 * without socktype set, you get 'servname not supported for ai_socktype'
643 */
644 int ai_protocol;
645 socklen_t ai_addrlen;
646 char* ai_canonname;
647 sockaddr* ai_addr;
648 addrinfo* ai_next;
649 }
650
651 enum IPPORT_RESERVED = 1024;
652
653 enum NETDB_INTERNAL = -1;
654 enum NETDB_SUCCESS = 0;
655 enum HOST_NOT_FOUND = 1;
656 enum TRY_AGAIN = 2;
657 enum NO_RECOVERY = 3;
658 enum NO_DATA = 4;
659 enum NO_ADDRESS = NO_DATA;
660
661 //enum EAI_ADDRFAMILY = 1; // deprecated
662 enum EAI_AGAIN = 2;
663 enum EAI_BADFLAGS = 3;
664 enum EAI_FAIL = 4;
665 enum EAI_FAMILY = 5;
666 enum EAI_MEMORY = 6;
667 //enum EAI_NODATA = 7; // deprecated
668 enum EAI_NONAME = 8;
669 enum EAI_SERVICE = 9;
670 enum EAI_SOCKTYPE = 10;
671 enum EAI_SYSTEM = 11;
672 enum EAI_BADHINTS = 12;
673 enum EAI_PROTOCOL = 13;
674 enum EAI_OVERFLOW = 14;
675
676 enum AI_PASSIVE = 0x001;
677 enum AI_CANONNAME = 0x002;
678 enum AI_NUMERICHOST = 0x004;
679 enum AI_NUMERICSERV = 0x008;
680 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)
681 enum AI_ALL = 0x100;
682 enum AI_V4MAPPED_CFG = 0x200;
683 enum AI_ADDRCONFIG = 0x400;
684 enum AI_V4MAPPED = 0x800;
685 enum AI_DEFAULT = (AI_V4MAPPED_CFG | AI_ADDRCONFIG);
686
687 enum NI_MAXHOST = 1025; // non-standard
688 enum NI_MAXSERV = 32; // non-standard
689
690 enum NI_NOFQDN = 0x01;
691 enum NI_NUMERICHOST = 0x02;
692 enum NI_NAMEREQD = 0x04;
693 enum NI_NUMERICSERV = 0x08;
694 enum NI_DGRAM = 0x10;
695 //enum NI_WITHSCOPEID = 0x20; // deprecated
696 enum NI_NUMERICSCOPE = 0x40;
697
698 }
version(Solaris)699 else version (Solaris)
700 {
701 struct hostent
702 {
703 char* h_name;
704 char** h_aliases;
705 int h_addrtype;
706 int h_length;
707 char** h_addr_list;
708
709 extern (D) char* h_addr() @property { return h_addr_list[0]; } // non-standard
710 }
711
712 struct netent
713 {
714 char* n_name;
715 char** n_aliases;
716 int n_addrtype;
717 uint32_t n_net;
718 }
719
720 struct protoent
721 {
722 char* p_name;
723 char** p_aliases;
724 int p_proto;
725 }
726
727 struct servent
728 {
729 char* s_name;
730 char** s_aliases;
731 int s_port;
732 char* s_proto;
733 }
734
735 enum HOST_NOT_FOUND = 1;
736 enum TRY_AGAIN = 2;
737 enum NO_RECOVERY = 3;
738 enum NO_DATA = 4;
739
740 struct addrinfo
741 {
742 int ai_flags;
743 int ai_family;
744 int ai_socktype;
745 int ai_protocol;
746
747 version (SPARC64)
748 int _ai_pad;
749
750 socklen_t ai_addrlen;
751 char* ai_canonname;
752 sockaddr* ai_addr;
753 addrinfo* ai_next;
754 }
755
756 enum AI_PASSIVE = 0x0008;
757 enum AI_CANONNAME = 0x0010;
758 enum AI_NUMERICHOST = 0x0020;
759 enum AI_NUMERICSERV = 0x0040;
760 enum AI_V4MAPPED = 0x0001;
761 enum AI_ALL = 0x0002;
762 enum AI_ADDRCONFIG = 0x0004;
763
764 enum NI_NOFQDN = 0x0001;
765 enum NI_NUMERICHOST = 0x0002;
766 enum NI_NAMEREQD = 0x0004;
767 enum NI_NUMERICSERV = 0x0008;
768 enum NI_DGRAM = 0x0010;
769 enum NI_WITHSCOPEID = 0x0020;
770 enum NI_NUMERICSCOPE = 0x0040;
771 enum NI_MAXHOST = 1025;
772 enum NI_MAXSERV = 32;
773
774 enum EAI_AGAIN = 2;
775 enum EAI_BADFLAGS = 3;
776 enum EAI_FAIL = 4;
777 enum EAI_FAMILY = 5;
778 enum EAI_MEMORY = 6;
779 enum EAI_NONAME = 8;
780 enum EAI_SERVICE = 9;
781 enum EAI_SOCKTYPE = 10;
782 enum EAI_SYSTEM = 11;
783 enum EAI_OVERFLOW = 14;
784 enum EAI_PROTOCOL = 13;
785 enum EAI_MAX = 14;
786 }
version(CRuntime_Bionic)787 else version (CRuntime_Bionic)
788 {
789 struct hostent
790 {
791 char* h_name;
792 char** h_aliases;
793 int h_addrtype;
794 int h_length;
795 char** h_addr_list;
796 extern (D) char* h_addr() @property { return h_addr_list[0]; } // non-standard
797 }
798
799 struct netent
800 {
801 char* n_name;
802 char** n_aliases;
803 int n_addrtype;
804 uint32_t n_net;
805 }
806
807 struct protoent
808 {
809 char* p_name;
810 char** p_aliases;
811 int p_proto;
812 }
813
814 struct servent
815 {
816 char* s_name;
817 char** s_aliases;
818 int s_port;
819 char* s_proto;
820 }
821
822 enum IPPORT_RESERVED = 1024;
823
824 enum HOST_NOT_FOUND = 1;
825 enum NO_DATA = 4;
826 enum NO_RECOVERY = 3;
827 enum TRY_AGAIN = 2;
828
829 struct addrinfo
830 {
831 int ai_flags;
832 int ai_family;
833 int ai_socktype;
834 int ai_protocol;
835 socklen_t ai_addrlen;
836 char* ai_canonname;
837 sockaddr* ai_addr;
838 addrinfo* ai_next;
839 }
840
841 enum AI_PASSIVE = 0x1;
842 enum AI_CANONNAME = 0x2;
843 enum AI_NUMERICHOST = 0x4;
844 enum AI_NUMERICSERV = 0x8;
845 enum AI_V4MAPPED = 0x800;
846 enum AI_ALL = 0x100;
847 enum AI_ADDRCONFIG = 0x400;
848
849 enum NI_NOFQDN = 0x1;
850 enum NI_NUMERICHOST = 0x2;
851 enum NI_NAMEREQD = 0x4;
852 enum NI_NUMERICSERV = 0x8;
853 enum NI_DGRAM = 0x10;
854 enum NI_MAXHOST = 1025; // non-standard
855 enum NI_MAXSERV = 32; // non-standard
856
857 enum EAI_AGAIN = 2;
858 enum EAI_BADFLAGS = 3;
859 enum EAI_FAIL = 4;
860 enum EAI_FAMILY = 5;
861 enum EAI_MEMORY = 6;
862 enum EAI_NONAME = 8;
863 enum EAI_SERVICE = 9;
864 enum EAI_SOCKTYPE = 10;
865 enum EAI_SYSTEM = 11;
866 enum EAI_OVERFLOW = 14;
867 }
version(CRuntime_Musl)868 else version (CRuntime_Musl)
869 {
870 struct hostent
871 {
872 char* h_name;
873 char** h_aliases;
874 int h_addrtype;
875 int h_length;
876 char** h_addr_list;
877 char* h_addr() @property { return h_addr_list[0]; } // non-standard
878 }
879
880 struct netent
881 {
882 char* n_name;
883 char** n_aliases;
884 int n_addrtype;
885 uint32_t n_net;
886 }
887
888 struct protoent
889 {
890 char* p_name;
891 char** p_aliases;
892 int p_proto;
893 }
894
895 struct servent
896 {
897 char* s_name;
898 char** s_aliases;
899 int s_port;
900 char* s_proto;
901 }
902
903 struct addrinfo
904 {
905 int ai_flags;
906 int ai_family;
907 int ai_socktype;
908 int ai_protocol;
909 socklen_t ai_addrlen;
910 sockaddr* ai_addr;
911 char* ai_canonname;
912 addrinfo* ai_next;
913 }
914
915 enum {
916 AI_PASSIVE = 0x1,
917 AI_CANONNAME = 0x2,
918 AI_NUMERICHOST = 0x4,
919 AI_NUMERICSERV = 0x400,
920 AI_V4MAPPED = 0x8,
921 AI_ALL = 0x10,
922 AI_ADDRCONFIG = 0x20,
923 }
924 enum {
925 NI_NUMERICHOST = 1,
926 NI_NUMERICSERV = 2,
927 NI_NOFQDN = 4,
928 NI_NAMEREQD = 8,
929 NI_DGRAM = 16,
930 NI_MAXSERV = 32,
931 NI_MAXHOST = 255,
932 }
933 enum {
934 EAI_BADFLAGS = -1,
935 EAI_NONAME = -2,
936 EAI_AGAIN = -3,
937 EAI_FAIL = -4,
938 EAI_FAMILY = -6,
939 EAI_SOCKTYPE = -7,
940 EAI_SERVICE = -8,
941 EAI_MEMORY = -10,
942 EAI_SYSTEM = -11,
943 EAI_OVERFLOW = -12,
944 }
945 }
version(CRuntime_UClibc)946 else version (CRuntime_UClibc)
947 {
948 struct hostent
949 {
950 char* h_name;
951 char** h_aliases;
952 int h_addrtype;
953 int h_length;
954 char** h_addr_list;
955 extern (D) char* h_addr() @property { return h_addr_list[0]; } // non-standard
956 }
957
958 struct netent
959 {
960 char* n_name;
961 char** n_aliases;
962 int n_addrtype;
963 uint32_t n_net;
964 }
965
966 struct protoent
967 {
968 char* p_name;
969 char** p_aliases;
970 int p_proto;
971 }
972
973 struct servent
974 {
975 char* s_name;
976 char** s_aliases;
977 int s_port;
978 char* s_proto;
979 }
980
981 enum IPPORT_RESERVED = 1024;
982
983 enum HOST_NOT_FOUND = 1;
984 enum NO_DATA = 4;
985 enum NO_RECOVERY = 3;
986 enum TRY_AGAIN = 2;
987
988 struct addrinfo
989 {
990 int ai_flags;
991 int ai_family;
992 int ai_socktype;
993 int ai_protocol;
994 socklen_t ai_addrlen;
995 sockaddr* ai_addr;
996 char* ai_canonname;
997 addrinfo* ai_next;
998 }
999
1000 enum AI_PASSIVE = 0x1;
1001 enum AI_CANONNAME = 0x2;
1002 enum AI_NUMERICHOST = 0x4;
1003 enum AI_NUMERICSERV = 0x400;
1004 enum AI_V4MAPPED = 0x8;
1005 enum AI_ALL = 0x10;
1006 enum AI_ADDRCONFIG = 0x20;
1007
1008 enum NI_NOFQDN = 4;
1009 enum NI_NUMERICHOST = 1;
1010 enum NI_NAMEREQD = 8;
1011 enum NI_NUMERICSERV = 2;
1012 enum NI_DGRAM = 16;
1013 enum NI_MAXHOST = 1025; // non-standard
1014 enum NI_MAXSERV = 32; // non-standard
1015
1016 enum EAI_AGAIN = -3;
1017 enum EAI_BADFLAGS = -1;
1018 enum EAI_FAIL = -4;
1019 enum EAI_FAMILY = -6;
1020 enum EAI_MEMORY = -10;
1021 enum EAI_NONAME = -2;
1022 enum EAI_SERVICE = -8;
1023 enum EAI_SOCKTYPE = -7;
1024 enum EAI_SYSTEM = -11;
1025 enum EAI_OVERFLOW = -12;
1026
1027 enum EAI_NODATA = -5;
1028 enum EAI_ADDRFAMILY = -9;
1029 enum EAI_INPROGRESS = -100;
1030 enum EAI_CANCELED = -101;
1031 enum EAI_NOTCANCELED = -102;
1032 enum EAI_ALLDONE = -103;
1033 enum EAI_INTR = -104;
1034 enum EAI_IDN_ENCODE = -105;
1035 }
1036 else
1037 {
1038 static assert(false, "Unsupported platform");
1039 }
1040
1041 void endhostent();
1042 void endnetent();
1043 void endprotoent();
1044 void endservent();
1045 void freeaddrinfo(addrinfo*);
1046 const(char)* gai_strerror(int);
1047 int getaddrinfo(const(char)*, const(char)*, const(addrinfo)*, addrinfo**);
1048 hostent* gethostbyaddr(const(void)*, socklen_t, int);
1049 hostent* gethostbyname(const(char)*);
1050 hostent* gethostent();
1051 int getnameinfo(const(sockaddr)*, socklen_t, char*, socklen_t, char*, socklen_t, int);
1052 netent* getnetbyaddr(uint32_t, int);
1053 netent* getnetbyname(const(char)*);
1054 netent* getnetent();
1055 protoent* getprotobyname(const(char)*);
1056 protoent* getprotobynumber(int);
1057 protoent* getprotoent();
1058 servent* getservbyname(const(char)*, const(char)*);
1059 servent* getservbyport(int, const(char)*);
1060 servent* getservent();
1061 void sethostent(int);
1062 void setnetent(int);
1063 void setprotoent(int);
1064 void setservent(int);
1065