xref: /netbsd-src/external/gpl3/gcc/dist/libphobos/libdruntime/core/sys/posix/sys/socket.d (revision 0a3071956a3a9fdebdbf7f338cf2d439b45fc728)
1 /**
2  * D header file for POSIX.
3  *
4  * Copyright: Copyright Sean Kelly 2005 - 2009.
5  * License:   $(HTTP www.boost.org/LICENSE_1_0.txt, Boost License 1.0).
6  * Authors:   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 Sean Kelly 2005 - 2009.
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.sys.socket;
16 
17 import core.sys.posix.config;
18 public import core.sys.posix.sys.types; // for ssize_t
19 public import core.sys.posix.sys.uio;   // for iovec
20 
21 version (OSX)
22     version = Darwin;
23 else version (iOS)
24     version = Darwin;
25 else version (TVOS)
26     version = Darwin;
27 else version (WatchOS)
28     version = Darwin;
29 
30 version (ARM)     version = ARM_Any;
31 version (AArch64) version = ARM_Any;
32 version (HPPA)    version = HPPA_Any;
33 version (MIPS32)  version = MIPS_Any;
34 version (MIPS64)  version = MIPS_Any;
35 version (PPC)     version = PPC_Any;
36 version (PPC64)   version = PPC_Any;
37 version (RISCV32) version = RISCV_Any;
38 version (RISCV64) version = RISCV_Any;
39 version (S390)    version = IBMZ_Any;
40 version (SPARC)   version = SPARC_Any;
41 version (SPARC64) version = SPARC_Any;
42 version (SystemZ) version = IBMZ_Any;
43 version (X86)     version = X86_Any;
44 version (X86_64)  version = X86_Any;
45 
version(Posix)46 version (Posix):
47 extern (C) nothrow @nogc:
48 @system:
49 
50 //
51 // Required
52 //
53 /*
54 socklen_t
55 sa_family_t
56 
57 struct sockaddr
58 {
59     sa_family_t sa_family;
60     char        sa_data[];
61 }
62 
63 struct sockaddr_storage
64 {
65     sa_family_t ss_family;
66 }
67 
68 struct msghdr
69 {
70     void*         msg_name;
71     socklen_t     msg_namelen;
72     struct iovec* msg_iov;
73     int           msg_iovlen;
74     void*         msg_control;
75     socklen_t     msg_controllen;
76     int           msg_flags;
77 }
78 
79 struct iovec {} // from core.sys.posix.sys.uio
80 
81 struct cmsghdr
82 {
83     socklen_t cmsg_len;
84     int       cmsg_level;
85     int       cmsg_type;
86 }
87 
88 SCM_RIGHTS
89 
90 CMSG_DATA(cmsg)
91 CMSG_NXTHDR(mhdr,cmsg)
92 CMSG_FIRSTHDR(mhdr)
93 
94 struct linger
95 {
96     int l_onoff;
97     int l_linger;
98 }
99 
100 SOCK_DGRAM
101 SOCK_SEQPACKET
102 SOCK_STREAM
103 
104 SOL_SOCKET
105 
106 SO_ACCEPTCONN
107 SO_BROADCAST
108 SO_DEBUG
109 SO_DONTROUTE
110 SO_ERROR
111 SO_KEEPALIVE
112 SO_LINGER
113 SO_OOBINLINE
114 SO_RCVBUF
115 SO_RCVLOWAT
116 SO_RCVTIMEO
117 SO_REUSEADDR
118 SO_SNDBUF
119 SO_SNDLOWAT
120 SO_SNDTIMEO
121 SO_TYPE
122 
123 SOMAXCONN
124 
125 MSG_CTRUNC
126 MSG_DONTROUTE
127 MSG_EOR
128 MSG_OOB
129 MSG_PEEK
130 MSG_TRUNC
131 MSG_WAITALL
132 
133 AF_INET
134 AF_UNIX
135 AF_UNSPEC
136 
137 SHUT_RD
138 SHUT_RDWR
139 SHUT_WR
140 */
141 
142 version (linux)
143 {
144     alias uint   socklen_t;
145     alias ushort sa_family_t;
146 
147     struct sockaddr
148     {
149         sa_family_t sa_family;
150         byte[14]    sa_data;
151     }
152 
153     private enum : size_t
154     {
155         _SS_SIZE    = 128,
156         _SS_PADSIZE = _SS_SIZE - c_ulong.sizeof - sa_family_t.sizeof
157     }
158 
159     struct sockaddr_storage
160     {
161         sa_family_t ss_family;
162         byte[_SS_PADSIZE] __ss_padding;
163         c_ulong     __ss_align;
164     }
165 
166     struct msghdr
167     {
168         void*     msg_name;
169         socklen_t msg_namelen;
170         iovec*    msg_iov;
171         size_t    msg_iovlen;
172         void*     msg_control;
173         size_t    msg_controllen;
174         int       msg_flags;
175     }
176 
177     struct cmsghdr
178     {
179         size_t cmsg_len;
180         int    cmsg_level;
181         int    cmsg_type;
182     }
183 
184     enum : uint
185     {
186         SCM_RIGHTS = 0x01
187     }
188 
189     extern (D) inout(ubyte)*   CMSG_DATA( return scope inout(cmsghdr)* cmsg ) pure nothrow @nogc { return cast(ubyte*)( cmsg + 1 ); }
190 
191     private inout(cmsghdr)* __cmsg_nxthdr(inout(msghdr)*, inout(cmsghdr)*) pure nothrow @nogc;
192     extern (D)  inout(cmsghdr)* CMSG_NXTHDR(inout(msghdr)* msg, inout(cmsghdr)* cmsg) pure nothrow @nogc
193     {
194         return __cmsg_nxthdr(msg, cmsg);
195     }
196 
197     extern (D) inout(cmsghdr)* CMSG_FIRSTHDR( inout(msghdr)* mhdr ) pure nothrow @nogc
198     {
199         return ( cast(size_t)mhdr.msg_controllen >= cmsghdr.sizeof
200                              ? cast(inout(cmsghdr)*) mhdr.msg_control
201                              : cast(inout(cmsghdr)*) null );
202     }
203 
204     extern (D)
205     {
206         size_t CMSG_ALIGN( size_t len ) pure nothrow @nogc
207         {
208             return (len + size_t.sizeof - 1) & cast(size_t) (~(size_t.sizeof - 1));
209         }
210 
211         size_t CMSG_LEN( size_t len ) pure nothrow @nogc
212         {
213             return CMSG_ALIGN(cmsghdr.sizeof) + len;
214         }
215     }
216 
217     extern (D) size_t CMSG_SPACE(size_t len) pure nothrow @nogc
218     {
219         return CMSG_ALIGN(len) + CMSG_ALIGN(cmsghdr.sizeof);
220     }
221 
222     struct linger
223     {
224         int l_onoff;
225         int l_linger;
226     }
227 
228     version (X86_Any)
229     {
230         enum
231         {
232             SOCK_DGRAM      = 2,
233             SOCK_SEQPACKET  = 5,
234             SOCK_STREAM     = 1
235         }
236 
237         enum
238         {
239             SOL_SOCKET      = 1
240         }
241 
242         enum
243         {
244             SO_ACCEPTCONN   = 30,
245             SO_BROADCAST    = 6,
246             SO_DEBUG        = 1,
247             SO_DONTROUTE    = 5,
248             SO_ERROR        = 4,
249             SO_KEEPALIVE    = 9,
250             SO_LINGER       = 13,
251             SO_OOBINLINE    = 10,
252             SO_RCVBUF       = 8,
253             SO_RCVLOWAT     = 18,
254             SO_RCVTIMEO     = 20,
255             SO_REUSEADDR    = 2,
256             SO_REUSEPORT    = 15,
257             SO_SNDBUF       = 7,
258             SO_SNDLOWAT     = 19,
259             SO_SNDTIMEO     = 21,
260             SO_TYPE         = 3
261         }
262     }
263     else version (HPPA_Any)
264     {
265         enum
266         {
267             SOCK_DGRAM      = 2,
268             SOCK_SEQPACKET  = 5,
269             SOCK_STREAM     = 1,
270         }
271 
272         enum
273         {
274             SOL_SOCKET      = 0xffff
275         }
276 
277         enum
278         {
279             SO_ACCEPTCONN   = 0x401c,
280             SO_BROADCAST    = 0x0020,
281             SO_DEBUG        = 0x0001,
282             SO_DONTROUTE    = 0x0010,
283             SO_ERROR        = 0x1007,
284             SO_KEEPALIVE    = 0x0008,
285             SO_LINGER       = 0x0080,
286             SO_OOBINLINE    = 0x0100,
287             SO_RCVBUF       = 0x1002,
288             SO_RCVLOWAT     = 0x1004,
289             SO_RCVTIMEO     = 0x1006,
290             SO_REUSEADDR    = 0x0004,
291             SO_SNDBUF       = 0x1001,
292             SO_SNDLOWAT     = 0x1003,
293             SO_SNDTIMEO     = 0x1005,
294             SO_TYPE         = 0x1008,
295         }
296     }
297     else version (MIPS_Any)
298     {
299         enum
300         {
301             SOCK_DGRAM      = 1,
302             SOCK_SEQPACKET  = 5,
303             SOCK_STREAM     = 2,
304         }
305 
306         enum
307         {
308             SOL_SOCKET      = 0xffff
309         }
310 
311         enum
312         {
313             SO_ACCEPTCONN   = 0x1009,
314             SO_BROADCAST    = 0x0020,
315             SO_DEBUG        = 0x0001,
316             SO_DONTROUTE    = 0x0010,
317             SO_ERROR        = 0x1007,
318             SO_KEEPALIVE    = 0x0008,
319             SO_LINGER       = 0x0080,
320             SO_OOBINLINE    = 0x0100,
321             SO_RCVBUF       = 0x1002,
322             SO_RCVLOWAT     = 0x1004,
323             SO_RCVTIMEO     = 0x1006,
324             SO_REUSEADDR    = 0x0004,
325             SO_SNDBUF       = 0x1001,
326             SO_SNDLOWAT     = 0x1003,
327             SO_SNDTIMEO     = 0x1005,
328             SO_TYPE         = 0x1008,
329         }
330     }
331     else version (PPC_Any)
332     {
333         enum
334         {
335             SOCK_DGRAM      = 2,
336             SOCK_SEQPACKET  = 5,
337             SOCK_STREAM     = 1
338         }
339 
340         enum
341         {
342             SOL_SOCKET      = 1
343         }
344 
345         enum
346         {
347             SO_ACCEPTCONN   = 30,
348             SO_BROADCAST    = 6,
349             SO_DEBUG        = 1,
350             SO_DONTROUTE    = 5,
351             SO_ERROR        = 4,
352             SO_KEEPALIVE    = 9,
353             SO_LINGER       = 13,
354             SO_OOBINLINE    = 10,
355             SO_RCVBUF       = 8,
356             SO_RCVLOWAT     = 16,
357             SO_RCVTIMEO     = 18,
358             SO_REUSEADDR    = 2,
359             SO_SNDBUF       = 7,
360             SO_SNDLOWAT     = 17,
361             SO_SNDTIMEO     = 19,
362             SO_TYPE         = 3
363         }
364     }
365     else version (ARM_Any)
366     {
367         enum
368         {
369             SOCK_DGRAM      = 2,
370             SOCK_SEQPACKET  = 5,
371             SOCK_STREAM     = 1
372         }
373 
374         enum
375         {
376             SOL_SOCKET      = 1
377         }
378 
379         enum
380         {
381             SO_ACCEPTCONN   = 30,
382             SO_BROADCAST    = 6,
383             SO_DEBUG        = 1,
384             SO_DONTROUTE    = 5,
385             SO_ERROR        = 4,
386             SO_KEEPALIVE    = 9,
387             SO_LINGER       = 13,
388             SO_OOBINLINE    = 10,
389             SO_RCVBUF       = 8,
390             SO_RCVLOWAT     = 18,
391             SO_RCVTIMEO     = 20,
392             SO_REUSEADDR    = 2,
393             SO_REUSEPORT    = 15,
394             SO_SNDBUF       = 7,
395             SO_SNDLOWAT     = 19,
396             SO_SNDTIMEO     = 21,
397             SO_TYPE         = 3
398         }
399     }
400     else version (RISCV_Any)
401     {
402         enum
403         {
404             SOCK_DGRAM      = 2,
405             SOCK_SEQPACKET  = 5,
406             SOCK_STREAM     = 1
407         }
408 
409         enum
410         {
411             SOL_SOCKET      = 1
412         }
413 
414         enum
415         {
416             SO_ACCEPTCONN   = 30,
417             SO_BROADCAST    = 6,
418             SO_DEBUG        = 1,
419             SO_DONTROUTE    = 5,
420             SO_ERROR        = 4,
421             SO_KEEPALIVE    = 9,
422             SO_LINGER       = 13,
423             SO_OOBINLINE    = 10,
424             SO_RCVBUF       = 8,
425             SO_RCVLOWAT     = 18,
426             SO_RCVTIMEO     = 20,
427             SO_REUSEADDR    = 2,
428             SO_SNDBUF       = 7,
429             SO_SNDLOWAT     = 19,
430             SO_SNDTIMEO     = 21,
431             SO_TYPE         = 3
432         }
433     }
434     else version (SPARC_Any)
435     {
436         enum
437         {
438             SOCK_DGRAM      = 2,
439             SOCK_SEQPACKET  = 5,
440             SOCK_STREAM     = 1
441         }
442 
443         enum
444         {
445             SOL_SOCKET      = 1
446         }
447 
448         enum
449         {
450             SO_ACCEPTCONN   = 30,
451             SO_BROADCAST    = 6,
452             SO_DEBUG        = 1,
453             SO_DONTROUTE    = 5,
454             SO_ERROR        = 4,
455             SO_KEEPALIVE    = 9,
456             SO_LINGER       = 13,
457             SO_OOBINLINE    = 10,
458             SO_RCVBUF       = 8,
459             SO_RCVLOWAT     = 18,
460             SO_RCVTIMEO     = 20,
461             SO_REUSEADDR    = 2,
462             SO_SNDBUF       = 7,
463             SO_SNDLOWAT     = 19,
464             SO_SNDTIMEO     = 21,
465             SO_TYPE         = 3
466         }
467     }
468     else version (IBMZ_Any)
469     {
470         enum
471         {
472             SOCK_DGRAM      = 2,
473             SOCK_SEQPACKET  = 5,
474             SOCK_STREAM     = 1
475         }
476 
477         enum
478         {
479             SOL_SOCKET      = 1
480         }
481 
482         enum
483         {
484             SO_ACCEPTCONN   = 30,
485             SO_BROADCAST    = 6,
486             SO_DEBUG        = 1,
487             SO_DONTROUTE    = 5,
488             SO_ERROR        = 4,
489             SO_KEEPALIVE    = 9,
490             SO_LINGER       = 13,
491             SO_OOBINLINE    = 10,
492             SO_RCVBUF       = 8,
493             SO_RCVLOWAT     = 18,
494             SO_RCVTIMEO     = 20,
495             SO_REUSEADDR    = 2,
496             SO_SNDBUF       = 7,
497             SO_SNDLOWAT     = 19,
498             SO_SNDTIMEO     = 21,
499             SO_TYPE         = 3
500         }
501     }
502     else
503         static assert(0, "unimplemented");
504 
505     version (CRuntime_Glibc)
506     {
507         enum
508         {
509             SOMAXCONN   = 4096
510         }
511     }
512     else
513     {
514         enum
515         {
516             SOMAXCONN   = 128
517         }
518     }
519 
520     enum : uint
521     {
522         MSG_CTRUNC      = 0x08,
523         MSG_DONTROUTE   = 0x04,
524         MSG_EOR         = 0x80,
525         MSG_OOB         = 0x01,
526         MSG_PEEK        = 0x02,
527         MSG_TRUNC       = 0x20,
528         MSG_WAITALL     = 0x100,
529         MSG_NOSIGNAL    = 0x4000
530     }
531 
532     enum
533     {
534         AF_APPLETALK    = 5,
535         AF_INET         = 2,
536         AF_IPX          = 4,
537         AF_UNIX         = 1,
538         AF_UNSPEC       = 0,
539         PF_APPLETALK    = AF_APPLETALK,
540         PF_IPX          = AF_IPX
541     }
542 
543     enum int SOCK_RDM   = 4;
544 
545     enum
546     {
547         SHUT_RD,
548         SHUT_WR,
549         SHUT_RDWR
550     }
551 }
552 else version (Darwin)
553 {
554     alias uint   socklen_t;
555     alias ubyte  sa_family_t;
556 
557     struct sockaddr
558     {
559         ubyte       sa_len;
560         sa_family_t sa_family;
561         byte[14]    sa_data;
562     }
563 
564     private enum : size_t
565     {
566         _SS_PAD1    = long.sizeof - ubyte.sizeof - sa_family_t.sizeof,
567         _SS_PAD2    = 128 - ubyte.sizeof - sa_family_t.sizeof - _SS_PAD1 - long.sizeof
568     }
569 
570     struct sockaddr_storage
571     {
572          ubyte          ss_len;
573          sa_family_t    ss_family;
574          byte[_SS_PAD1] __ss_pad1;
575          long           __ss_align;
576          byte[_SS_PAD2] __ss_pad2;
577     }
578 
579     struct msghdr
580     {
581         void*     msg_name;
582         socklen_t msg_namelen;
583         iovec*    msg_iov;
584         int       msg_iovlen;
585         void*     msg_control;
586         socklen_t msg_controllen;
587         int       msg_flags;
588     }
589 
590     struct cmsghdr
591     {
592          socklen_t cmsg_len;
593          int       cmsg_level;
594          int       cmsg_type;
595     }
596 
597     enum : uint
598     {
599         SCM_RIGHTS = 0x01
600     }
601 
602     /+
603     CMSG_DATA(cmsg)     ((unsigned char *)(cmsg) + \
604                          ALIGN(sizeof(struct cmsghdr)))
605     CMSG_NXTHDR(mhdr, cmsg) \
606                         (((unsigned char *)(cmsg) + ALIGN((cmsg)->cmsg_len) + \
607                          ALIGN(sizeof(struct cmsghdr)) > \
608                          (unsigned char *)(mhdr)->msg_control +(mhdr)->msg_controllen) ? \
609                          (struct cmsghdr *)0 /* NULL */ : \
610                          (struct cmsghdr *)((unsigned char *)(cmsg) + ALIGN((cmsg)->cmsg_len)))
611     CMSG_FIRSTHDR(mhdr) ((struct cmsghdr *)(mhdr)->msg_control)
612     +/
613 
614     struct linger
615     {
616         int l_onoff;
617         int l_linger;
618     }
619 
620     enum
621     {
622         SOCK_DGRAM      = 2,
623         SOCK_RDM        = 4,
624         SOCK_SEQPACKET  = 5,
625         SOCK_STREAM     = 1
626     }
627 
628     enum : uint
629     {
630         SOL_SOCKET      = 0xffff
631     }
632 
633     enum : uint
634     {
635         SO_ACCEPTCONN   = 0x0002,
636         SO_BROADCAST    = 0x0020,
637         SO_DEBUG        = 0x0001,
638         SO_DONTROUTE    = 0x0010,
639         SO_ERROR        = 0x1007,
640         SO_KEEPALIVE    = 0x0008,
641         SO_LINGER       = 0x1080,
642         SO_NOSIGPIPE    = 0x1022, // non-standard
643         SO_OOBINLINE    = 0x0100,
644         SO_RCVBUF       = 0x1002,
645         SO_RCVLOWAT     = 0x1004,
646         SO_RCVTIMEO     = 0x1006,
647         SO_REUSEADDR    = 0x0004,
648         SO_REUSEPORT    = 0x0200,
649         SO_SNDBUF       = 0x1001,
650         SO_SNDLOWAT     = 0x1003,
651         SO_SNDTIMEO     = 0x1005,
652         SO_TYPE         = 0x1008
653     }
654 
655     enum
656     {
657         SOMAXCONN       = 128
658     }
659 
660     enum : uint
661     {
662         MSG_CTRUNC      = 0x20,
663         MSG_DONTROUTE   = 0x4,
664         MSG_EOR         = 0x8,
665         MSG_OOB         = 0x1,
666         MSG_PEEK        = 0x2,
667         MSG_TRUNC       = 0x10,
668         MSG_WAITALL     = 0x40
669     }
670 
671     enum
672     {
673         AF_APPLETALK    = 16,
674         AF_INET         = 2,
675         AF_IPX          = 23,
676         AF_UNIX         = 1,
677         AF_UNSPEC       = 0,
678         PF_APPLETALK    = AF_APPLETALK,
679         PF_IPX          = AF_IPX
680     }
681 
682     enum
683     {
684         SHUT_RD,
685         SHUT_WR,
686         SHUT_RDWR
687     }
688 }
689 else version (FreeBSD)
690 {
691     alias uint   socklen_t;
692     alias ubyte  sa_family_t;
693 
694     struct sockaddr
695     {
696         ubyte       sa_len;
697         sa_family_t sa_family;
698         byte[14]    sa_data;
699     }
700 
701     private
702     {
703         enum _SS_ALIGNSIZE  = long.sizeof;
704         enum _SS_MAXSIZE    = 128;
705         enum _SS_PAD1SIZE   = _SS_ALIGNSIZE - ubyte.sizeof - sa_family_t.sizeof;
706         enum _SS_PAD2SIZE   = _SS_MAXSIZE - ubyte.sizeof - sa_family_t.sizeof - _SS_PAD1SIZE - _SS_ALIGNSIZE;
707     }
708 
709     struct sockaddr_storage
710     {
711          ubyte              ss_len;
712          sa_family_t        ss_family;
713          byte[_SS_PAD1SIZE] __ss_pad1;
714          long               __ss_align;
715          byte[_SS_PAD2SIZE] __ss_pad2;
716     }
717 
718     struct msghdr
719     {
720         void*     msg_name;
721         socklen_t msg_namelen;
722         iovec*    msg_iov;
723         int       msg_iovlen;
724         void*     msg_control;
725         socklen_t msg_controllen;
726         int       msg_flags;
727     }
728 
729     struct cmsghdr
730     {
731          socklen_t cmsg_len;
732          int       cmsg_level;
733          int       cmsg_type;
734     }
735 
736     enum : uint
737     {
738         SCM_RIGHTS = 0x01
739     }
740 
741     private // <machine/param.h>
742     {
743         enum _ALIGNBYTES = /+c_int+/ int.sizeof - 1;
744         extern (D) size_t _ALIGN( size_t p ) { return (p + _ALIGNBYTES) & ~_ALIGNBYTES; }
745     }
746 
747     extern (D) ubyte* CMSG_DATA( cmsghdr* cmsg )
748     {
749         return cast(ubyte*) cmsg + _ALIGN( cmsghdr.sizeof );
750     }
751 
752     extern (D) cmsghdr* CMSG_NXTHDR( msghdr* mhdr, cmsghdr* cmsg )
753     {
754         if ( cmsg == null )
755         {
756            return CMSG_FIRSTHDR( mhdr );
757         }
758         else
759         {
760             if ( cast(ubyte*) cmsg + _ALIGN( cmsg.cmsg_len ) + _ALIGN( cmsghdr.sizeof ) >
761                     cast(ubyte*) mhdr.msg_control + mhdr.msg_controllen )
762                 return null;
763             else
764                 return cast(cmsghdr*) (cast(ubyte*) cmsg + _ALIGN( cmsg.cmsg_len ));
765         }
766     }
767 
768     extern (D) cmsghdr* CMSG_FIRSTHDR( msghdr* mhdr )
769     {
770         return mhdr.msg_controllen >= cmsghdr.sizeof ? cast(cmsghdr*) mhdr.msg_control : null;
771     }
772 
773     struct linger
774     {
775         int l_onoff;
776         int l_linger;
777     }
778 
779     enum
780     {
781         SOCK_DGRAM      = 2,
782         SOCK_RDM        = 4,
783         SOCK_SEQPACKET  = 5,
784         SOCK_STREAM     = 1
785     }
786 
787     enum : uint
788     {
789         SOL_SOCKET      = 0xffff
790     }
791 
792     enum : uint
793     {
794         SO_ACCEPTCONN   = 0x0002,
795         SO_BROADCAST    = 0x0020,
796         SO_DEBUG        = 0x0001,
797         SO_DONTROUTE    = 0x0010,
798         SO_ERROR        = 0x1007,
799         SO_KEEPALIVE    = 0x0008,
800         SO_LINGER       = 0x0080,
801         SO_NOSIGPIPE    = 0x0800, // non-standard
802         SO_OOBINLINE    = 0x0100,
803         SO_RCVBUF       = 0x1002,
804         SO_RCVLOWAT     = 0x1004,
805         SO_RCVTIMEO     = 0x1006,
806         SO_REUSEADDR    = 0x0004,
807         SO_REUSEPORT    = 0x0200,
808         SO_SNDBUF       = 0x1001,
809         SO_SNDLOWAT     = 0x1003,
810         SO_SNDTIMEO     = 0x1005,
811         SO_TYPE         = 0x1008
812     }
813 
814     enum
815     {
816         SOMAXCONN       = 128
817     }
818 
819     enum : uint
820     {
821         MSG_CTRUNC      = 0x20,
822         MSG_DONTROUTE   = 0x4,
823         MSG_EOR         = 0x8,
824         MSG_OOB         = 0x1,
825         MSG_PEEK        = 0x2,
826         MSG_TRUNC       = 0x10,
827         MSG_WAITALL     = 0x40,
828         MSG_NOSIGNAL    = 0x20000
829     }
830 
831     enum
832     {
833         AF_APPLETALK    = 16,
834         AF_INET         = 2,
835         AF_IPX          = 23,
836         AF_UNIX         = 1,
837         AF_UNSPEC       = 0
838     }
839 
840     enum
841     {
842         SHUT_RD = 0,
843         SHUT_WR = 1,
844         SHUT_RDWR = 2
845     }
846 }
847 else version (NetBSD)
848 {
849     alias uint   socklen_t;
850     alias ubyte  sa_family_t;
851 
852     struct sockaddr
853     {
854         ubyte       sa_len;
855         sa_family_t sa_family;
856         byte[14]    sa_data;
857     }
858 
859     private
860     {
861         enum _SS_ALIGNSIZE  = long.sizeof;
862         enum _SS_MAXSIZE    = 128;
863         enum _SS_PAD1SIZE   = _SS_ALIGNSIZE - ubyte.sizeof - sa_family_t.sizeof;
864         enum _SS_PAD2SIZE   = _SS_MAXSIZE - ubyte.sizeof - sa_family_t.sizeof - _SS_PAD1SIZE - _SS_ALIGNSIZE;
865     }
866 
867     struct sockaddr_storage
868     {
869          ubyte              ss_len;
870          sa_family_t        ss_family;
871          byte[_SS_PAD1SIZE] __ss_pad1;
872          long               __ss_align;
873          byte[_SS_PAD2SIZE] __ss_pad2;
874     }
875 
876     struct msghdr
877     {
878         void*     msg_name;
879         socklen_t msg_namelen;
880         iovec*    msg_iov;
881         int       msg_iovlen;
882         void*     msg_control;
883         socklen_t msg_controllen;
884         int       msg_flags;
885     }
886 
887     struct cmsghdr
888     {
889          socklen_t cmsg_len;
890          int       cmsg_level;
891          int       cmsg_type;
892     }
893 
894     enum : uint
895     {
896         SCM_RIGHTS = 0x01
897     }
898 
899     private // <machine/param.h>
900     {
901         enum _ALIGNBYTES = /+c_int+/ int.sizeof - 1;
902         extern (D) size_t _ALIGN( size_t p ) { return (p + _ALIGNBYTES) & ~_ALIGNBYTES; }
903     }
904 
905     extern (D) ubyte* CMSG_DATA( cmsghdr* cmsg )
906     {
907         return cast(ubyte*) cmsg + _ALIGN( cmsghdr.sizeof );
908     }
909 
910     extern (D) cmsghdr* CMSG_NXTHDR( msghdr* mhdr, cmsghdr* cmsg )
911     {
912         if ( cmsg == null )
913         {
914            return CMSG_FIRSTHDR( mhdr );
915         }
916         else
917         {
918             if ( cast(ubyte*) cmsg + _ALIGN( cmsg.cmsg_len ) + _ALIGN( cmsghdr.sizeof ) >
919                     cast(ubyte*) mhdr.msg_control + mhdr.msg_controllen )
920                 return null;
921             else
922                 return cast(cmsghdr*) (cast(ubyte*) cmsg + _ALIGN( cmsg.cmsg_len ));
923         }
924     }
925 
926     extern (D) cmsghdr* CMSG_FIRSTHDR( msghdr* mhdr )
927     {
928         return mhdr.msg_controllen >= cmsghdr.sizeof ? cast(cmsghdr*) mhdr.msg_control : null;
929     }
930 
931     struct linger
932     {
933         int l_onoff;
934         int l_linger;
935     }
936 
937     enum
938     {
939         SOCK_DGRAM      = 2,
940         SOCK_RDM        = 4,
941         SOCK_SEQPACKET  = 5,
942         SOCK_STREAM     = 1
943     }
944 
945     enum : uint
946     {
947         SOL_SOCKET      = 0xffff
948     }
949 
950     enum : uint
951     {
952          SO_DEBUG        = 0x0001,          /* turn on debugging info recording */
953          SO_ACCEPTCONN   = 0x0002,          /* socket has had listen() */
954          SO_REUSEADDR    = 0x0004,          /* allow local address reuse */
955          SO_KEEPALIVE    = 0x0008,          /* keep connections alive */
956          SO_DONTROUTE    = 0x0010,          /* just use interface addresses */
957          SO_BROADCAST    = 0x0020,          /* permit sending of broadcast msgs */
958          SO_USELOOPBACK  = 0x0040,          /* bypass hardware when possible */
959          SO_LINGER       = 0x0080,          /* linger on close if data present */
960          SO_OOBINLINE    = 0x0100,          /* leave received OOB data in line */
961          SO_REUSEPORT    = 0x0200,          /* allow local address & port reuse */
962         /*      SO_OTIMESTAMP   0x0400          */
963          SO_NOSIGPIPE    = 0x0800,          /* no SIGPIPE from EPIPE */
964          SO_ACCEPTFILTER = 0x1000,          /* there is an accept filter */
965          SO_TIMESTAMP    = 0x2000,          /* timestamp received dgram traffic */
966 
967         /*
968          * Additional options, not kept in so_options.
969          */
970          SO_SNDBUF       = 0x1001,          /* send buffer size */
971          SO_RCVBUF       = 0x1002,          /* receive buffer size */
972          SO_SNDLOWAT     = 0x1003,          /* send low-water mark */
973          SO_RCVLOWAT     = 0x1004,          /* receive low-water mark */
974         /* SO_OSNDTIMEO         0x1005 */
975         /* SO_ORCVTIMEO         0x1006 */
976          SO_ERROR        = 0x1007,          /* get error status and clear */
977          SO_TYPE         = 0x1008,          /* get socket type */
978          SO_OVERFLOWED   = 0x1009,          /* datagrams: return packets dropped */
979 
980          SO_NOHEADER     = 0x100a,          /* user supplies no header to kernel;
981                                                  * kernel removes header and supplies
982                                                  * payload
983                                                  */
984          SO_SNDTIMEO     = 0x100b,          /* send timeout */
985          SO_RCVTIMEO     = 0x100c          /* receive timeout */
986 
987     }
988 
989     enum
990     {
991         SOMAXCONN       = 128
992     }
993 
994     enum : uint
995     {
996          MSG_OOB         = 0x0001,          /* process out-of-band data */
997          MSG_PEEK        = 0x0002,          /* peek at incoming message */
998          MSG_DONTROUTE   = 0x0004,          /* send without using routing tables */
999          MSG_EOR         = 0x0008,          /* data completes record */
1000          MSG_TRUNC       = 0x0010,          /* data discarded before delivery */
1001          MSG_CTRUNC      = 0x0020,          /* control data lost before delivery */
1002          MSG_WAITALL     = 0x0040,          /* wait for full request or error */
1003          MSG_DONTWAIT    = 0x0080,          /* this message should be nonblocking */
1004          MSG_BCAST       = 0x0100,          /* this message was rcvd using link-level brdcst */
1005          MSG_MCAST       = 0x0200,          /* this message was rcvd using link-level mcast */
1006          MSG_NOSIGNAL    = 0x0400          /* do not generate SIGPIPE on EOF */
1007     }
1008 
1009     enum
1010     {
1011         AF_APPLETALK    = 16,
1012         AF_INET         = 2,
1013         AF_IPX          = 23,
1014         AF_UNIX         = 1,
1015         AF_UNSPEC       = 0
1016     }
1017 
1018     enum
1019     {
1020         SHUT_RD = 0,
1021         SHUT_WR = 1,
1022         SHUT_RDWR = 2
1023     }
1024 }
1025 else version (OpenBSD)
1026 {
1027     alias uint   socklen_t;
1028     alias ubyte  sa_family_t;
1029 
1030     struct sockaddr
1031     {
1032         ubyte       sa_len;
1033         sa_family_t sa_family;
1034         byte[14]    sa_data;
1035     }
1036 
1037     struct sockaddr_storage
1038     {
1039          ubyte       ss_len;
1040          sa_family_t ss_family;
1041          ubyte[6]    __ss_pad1;
1042          long        __ss_align;
1043          ubyte[240]  __ss_pad2;
1044     }
1045 
1046     struct msghdr
1047     {
1048         void*     msg_name;
1049         socklen_t msg_namelen;
1050         iovec*    msg_iov;
1051         uint      msg_iovlen;
1052         void*     msg_control;
1053         socklen_t msg_controllen;
1054         int       msg_flags;
1055     }
1056 
1057     struct cmsghdr
1058     {
1059          socklen_t cmsg_len;
1060          int       cmsg_level;
1061          int       cmsg_type;
1062     }
1063 
1064     enum : uint
1065     {
1066         SCM_RIGHTS    = 0x01,
1067         SCM_TIMESTAMP = 0x04
1068     }
1069 
1070     private // <sys/_types.h>
1071     {
1072         enum _ALIGNBYTES = c_long.sizeof - 1;
1073         extern (D) size_t _ALIGN(size_t p) pure nothrow @nogc
1074         {
1075             return (p + _ALIGNBYTES) & ~_ALIGNBYTES;
1076         }
1077     }
1078 
1079     extern (D) ubyte* CMSG_DATA(cmsghdr* cmsg) pure nothrow @nogc
1080     {
1081         return cast(ubyte*) cmsg + _ALIGN(cmsghdr.sizeof);
1082     }
1083 
1084     extern (D) cmsghdr* CMSG_NXTHDR(msghdr* mhdr, cmsghdr* cmsg) pure nothrow @nogc
1085     {
1086         if (cast(ubyte*) cmsg + _ALIGN(cmsg.cmsg_len) + _ALIGN(cmsghdr.sizeof) >
1087                 cast(ubyte*) mhdr.msg_control + mhdr.msg_controllen)
1088             return null;
1089         else
1090             return cast(cmsghdr*) (cast(ubyte*) cmsg + _ALIGN(cmsg.cmsg_len));
1091     }
1092 
1093     extern (D) cmsghdr* CMSG_FIRSTHDR(msghdr* mhdr) pure nothrow @nogc
1094     {
1095         return mhdr.msg_controllen >= cmsghdr.sizeof ? cast(cmsghdr*) mhdr.msg_control : null;
1096     }
1097 
1098     extern (D)
1099     {
1100         size_t CMSG_LEN(size_t len) pure nothrow @nogc
1101         {
1102             return _ALIGN(cmsghdr.sizeof) + len;
1103         }
1104     }
1105 
1106     extern (D) size_t CMSG_SPACE(size_t len) pure nothrow @nogc
1107     {
1108         return _ALIGN(cmsghdr.sizeof) + _ALIGN(len);
1109     }
1110 
1111     struct linger
1112     {
1113         int l_onoff;
1114         int l_linger;
1115     }
1116 
1117     enum
1118     {
1119         SOCK_DGRAM      = 2,
1120         SOCK_RDM        = 4,
1121         SOCK_SEQPACKET  = 5,
1122         SOCK_STREAM     = 1
1123     }
1124 
1125     enum : uint
1126     {
1127         SOL_SOCKET      = 0xffff
1128     }
1129 
1130     enum : uint
1131     {
1132          SO_DEBUG        = 0x0001,
1133          SO_ACCEPTCONN   = 0x0002,
1134          SO_REUSEADDR    = 0x0004,
1135          SO_KEEPALIVE    = 0x0008,
1136          SO_DONTROUTE    = 0x0010,
1137          SO_BROADCAST    = 0x0020,
1138          SO_USELOOPBACK  = 0x0040,
1139          SO_LINGER       = 0x0080,
1140          SO_OOBINLINE    = 0x0100,
1141          SO_REUSEPORT    = 0x0200,
1142          SO_TIMESTAMP    = 0x0800,
1143          SO_BINDANY      = 0x1000,
1144          SO_ZEROSIZE     = 0x2000,
1145 
1146          SO_SNDBUF       = 0x1001,
1147          SO_RCVBUF       = 0x1002,
1148          SO_SNDLOWAT     = 0x1003,
1149          SO_RCVLOWAT     = 0x1004,
1150          SO_SNDTIMEO     = 0x1005,
1151          SO_RCVTIMEO     = 0x1006,
1152          SO_ERROR        = 0x1007,
1153          SO_TYPE         = 0x1008,
1154          SO_NETPROC      = 0x1020,
1155          SO_RTABLE       = 0x1021,
1156          SO_PEERCRED     = 0x1022,
1157          SO_SPLICE       = 0x1023,
1158     }
1159 
1160     enum
1161     {
1162         SOMAXCONN       = 128
1163     }
1164 
1165     enum : uint
1166     {
1167          MSG_OOB          = 0x001,
1168          MSG_PEEK         = 0x002,
1169          MSG_DONTROUTE    = 0x004,
1170          MSG_EOR          = 0x008,
1171          MSG_TRUNC        = 0x010,
1172          MSG_CTRUNC       = 0x020,
1173          MSG_WAITALL      = 0x040,
1174          MSG_DONTWAIT     = 0x080,
1175          MSG_BCAST        = 0x100,
1176          MSG_MCAST        = 0x200,
1177          MSG_NOSIGNAL     = 0x400,
1178          MSG_CMSG_CLOEXEC = 0x800,
1179     }
1180 
1181     enum
1182     {
1183         AF_APPLETALK    = 16,
1184         AF_INET         = 2,
1185         AF_IPX          = 23,
1186         AF_UNIX         = 1,
1187         AF_UNSPEC       = 0
1188     }
1189 
1190     enum
1191     {
1192         SHUT_RD = 0,
1193         SHUT_WR = 1,
1194         SHUT_RDWR = 2
1195     }
1196 }
1197 else version (DragonFlyBSD)
1198 {
1199     alias uint   socklen_t;
1200     alias ubyte  sa_family_t;
1201 
1202     enum
1203     {
1204         SOCK_STREAM         = 1,
1205         SOCK_DGRAM          = 2,
1206         //SOCK_RAW          = 3,      // defined below
1207         SOCK_RDM            = 4,
1208         SOCK_SEQPACKET      = 5,
1209     }
1210 
1211     enum SOCK_CLOEXEC       = 0x10000000;
1212     enum SOCK_NONBLOCK      = 0x20000000;
1213 
1214     enum : uint
1215     {
1216         SO_DEBUG            = 0x0001,
1217         SO_ACCEPTCONN       = 0x0002,
1218         SO_REUSEADDR        = 0x0004,
1219         SO_KEEPALIVE        = 0x0008,
1220         SO_DONTROUTE        = 0x0010,
1221         SO_BROADCAST        = 0x0020,
1222         SO_USELOOPBACK      = 0x0040,
1223         SO_LINGER           = 0x0080,
1224         SO_OOBINLINE        = 0x0100,
1225         SO_REUSEPORT        = 0x0200,
1226         SO_TIMESTAMP        = 0x0400,
1227         SO_NOSIGPIPE        = 0x0800, // non-standard
1228         SO_ACCEPTFILTER     = 0x1000,
1229 
1230         SO_SNDBUF           = 0x1001,
1231         SO_RCVBUF           = 0x1002,
1232         SO_SNDLOWAT         = 0x1003,
1233         SO_RCVLOWAT         = 0x1004,
1234         SO_SNDTIMEO         = 0x1005,
1235         SO_RCVTIMEO         = 0x1006,
1236         SO_ERROR            = 0x1007,
1237         SO_TYPE             = 0x1008,
1238         SO_SNDSPACE         = 0x100a, // get appr. send buffer free space
1239         SO_CPUHINT          = 0x1030, // get socket's owner cpuid hint
1240     }
1241 
1242     struct linger
1243     {
1244         int l_onoff;
1245         int l_linger;
1246     }
1247 
1248     struct  accept_filter_arg {
1249         byte[16] af_name;
1250         byte[256-16] af_arg;
1251     }
1252 
1253     enum : uint
1254     {
1255         SOL_SOCKET          = 0xffff
1256     }
1257 
1258     enum
1259     {
1260         AF_UNSPEC           = 0,
1261         AF_LOCAL            = 1,
1262         AF_UNIX             = AF_LOCAL,
1263         AF_INET             = 2,
1264         AF_APPLETALK        = 16,
1265         AF_IPX              = 23,
1266     }
1267 
1268     struct sockaddr
1269     {
1270         ubyte               sa_len;
1271         sa_family_t         sa_family;
1272         byte[14]            sa_data;
1273     }
1274 
1275     enum SOCK_MAXADDRLEN = 255;
1276 
1277     struct sockproto {
1278         ushort              sp_family;
1279         ushort              sp_protocol;
1280     }
1281 
1282     private
1283     {
1284         enum _SS_ALIGNSIZE  = long.sizeof;
1285         enum _SS_MAXSIZE    = 128;
1286         enum _SS_PAD1SIZE   = _SS_ALIGNSIZE - ubyte.sizeof - sa_family_t.sizeof;
1287         enum _SS_PAD2SIZE   = _SS_MAXSIZE - ubyte.sizeof - sa_family_t.sizeof - _SS_PAD1SIZE - _SS_ALIGNSIZE;
1288     }
1289 
1290     struct sockaddr_storage
1291     {
1292         ubyte              ss_len;
1293         sa_family_t        ss_family;
1294         byte[_SS_PAD1SIZE] __ss_pad1;
1295         long               __ss_align;
1296         byte[_SS_PAD2SIZE] __ss_pad2;
1297     }
1298 
1299     struct msghdr
1300     {
1301         void*               msg_name;
1302         socklen_t           msg_namelen;
1303         iovec*              msg_iov;
1304         int                 msg_iovlen;
1305         void*               msg_control;
1306         socklen_t           msg_controllen;
1307         int                 msg_flags;
1308     }
1309 
1310     enum SOMAXCONN          = 128;
1311     enum SOMAXOPT_SIZE      = 65536;
1312     enum SOMAXOPT_SIZE0     = (32 * 1024 * 1024);
1313 
1314     enum : uint
1315     {
1316         MSG_OOB             = 0x00000001,
1317         MSG_PEEK            = 0x00000002,
1318         MSG_DONTROUTE       = 0x00000004,
1319         MSG_EOR             = 0x00000008,
1320         MSG_TRUNC           = 0x00000010,
1321         MSG_CTRUNC          = 0x00000020,
1322         MSG_WAITALL         = 0x00000040,
1323         MSG_DONTWAIT        = 0x00000080,
1324         MSG_EOF             = 0x00000100,
1325         MSG_UNUSED09        = 0x00000200,
1326         MSG_NOSIGNAL        = 0x00000400,
1327         MSG_SYNC            = 0x00000800,
1328         MSG_CMSG_CLOEXEC    = 0x00001000,
1329         /* These override FIONBIO.  MSG_FNONBLOCKING is functionally equivalent to MSG_DONTWAIT.*/
1330         MSG_FBLOCKING       = 0x00010000,
1331         MSG_FNONBLOCKING    = 0x00020000,
1332         MSG_FMASK           = 0xFFFF0000,
1333     }
1334 
1335     struct cmsghdr
1336     {
1337          socklen_t          cmsg_len;
1338          int                cmsg_level;
1339          int                cmsg_type;
1340     }
1341 
1342     enum CMGROUP_MAX        = 16;
1343 
1344     struct cmsgcred {
1345             pid_t           cmcred_pid;
1346             uid_t           cmcred_uid;
1347             uid_t           cmcred_euid;
1348             gid_t           cmcred_gid;
1349             short           cmcred_ngroups;
1350             gid_t[CMGROUP_MAX] cmcred_groups;
1351     }
1352 
1353     enum : uint
1354     {
1355         SCM_RIGHTS = 0x01
1356     }
1357 
1358     private // <machine/param.h>
1359     {
1360         enum _ALIGNBYTES = /+c_int+/ int.sizeof - 1;
1361         extern (D) size_t _ALIGN( size_t p ) { return (p + _ALIGNBYTES) & ~_ALIGNBYTES; }
1362     }
1363 
1364     extern (D) ubyte* CMSG_DATA( cmsghdr* cmsg )
1365     {
1366         return cast(ubyte*) cmsg + _ALIGN( cmsghdr.sizeof );
1367     }
1368 
1369     extern (D) cmsghdr* CMSG_NXTHDR( msghdr* mhdr, cmsghdr* cmsg )
1370     {
1371         if ( cmsg == null )
1372         {
1373            return CMSG_FIRSTHDR( mhdr );
1374         }
1375         else
1376         {
1377             if ( cast(ubyte*) cmsg + _ALIGN( cmsg.cmsg_len ) + _ALIGN( cmsghdr.sizeof ) >
1378                     cast(ubyte*) mhdr.msg_control + mhdr.msg_controllen )
1379                 return null;
1380             else
1381                 return cast(cmsghdr*) (cast(ubyte*) cmsg + _ALIGN( cmsg.cmsg_len ));
1382         }
1383     }
1384 
1385     extern (D) cmsghdr* CMSG_FIRSTHDR( msghdr* mhdr )
1386     {
1387         return mhdr.msg_controllen >= cmsghdr.sizeof ? cast(cmsghdr*) mhdr.msg_control : null;
1388     }
1389 
1390     enum
1391     {
1392         SHUT_RD             = 0,
1393         SHUT_WR             = 1,
1394         SHUT_RDWR           = 2
1395     }
1396 }
1397 else version (Solaris)
1398 {
1399     alias uint socklen_t;
1400     alias ushort sa_family_t;
1401 
1402     struct sockaddr
1403     {
1404         sa_family_t sa_family;
1405         char[14] sa_data = 0;
1406     }
1407 
1408     alias double sockaddr_maxalign_t;
1409 
1410     private
1411     {
1412         enum _SS_ALIGNSIZE  = sockaddr_maxalign_t.sizeof;
1413         enum _SS_MAXSIZE    = 256;
1414         enum _SS_PAD1SIZE   = _SS_ALIGNSIZE - sa_family_t.sizeof;
1415         enum _SS_PAD2SIZE   = _SS_MAXSIZE - sa_family_t.sizeof + _SS_PAD1SIZE + _SS_ALIGNSIZE;
1416     }
1417 
1418     struct sockaddr_storage
1419     {
1420          sa_family_t ss_family;
1421          char[_SS_PAD1SIZE] _ss_pad1 = void;
1422          sockaddr_maxalign_t _ss_align;
1423          char[_SS_PAD2SIZE] _ss_pad2 = void;
1424     }
1425 
1426     struct msghdr
1427     {
1428         void* msg_name;
1429         socklen_t msg_namelen;
1430         iovec* msg_iov;
1431         int msg_iovlen;
1432         void* msg_control;
1433         socklen_t msg_controllen;
1434         int msg_flags;
1435     }
1436 
1437     struct cmsghdr
1438     {
1439          socklen_t cmsg_len;
1440          int cmsg_level;
1441          int cmsg_type;
1442     }
1443 
1444     enum : uint
1445     {
1446         SCM_RIGHTS = 0x1010
1447     }
1448 
1449     // FIXME: CMSG_DATA, CMSG_NXTHDR, CMSG_FIRSTHDR missing
1450 
1451     struct linger
1452     {
1453         int l_onoff;
1454         int l_linger;
1455     }
1456 
1457     enum
1458     {
1459         SOCK_STREAM = 2,
1460         SOCK_DGRAM = 1,
1461         SOCK_RDM = 5,
1462         SOCK_SEQPACKET = 6,
1463     }
1464 
1465     enum : uint
1466     {
1467         SOL_SOCKET      = 0xffff
1468     }
1469 
1470     enum : uint
1471     {
1472         SO_ACCEPTCONN   = 0x0002,
1473         SO_BROADCAST    = 0x0020,
1474         SO_DEBUG        = 0x0001,
1475         SO_DONTROUTE    = 0x0010,
1476         SO_ERROR        = 0x1007,
1477         SO_KEEPALIVE    = 0x0008,
1478         SO_LINGER       = 0x0080,
1479         SO_OOBINLINE    = 0x0100,
1480         SO_RCVBUF       = 0x1002,
1481         SO_RCVLOWAT     = 0x1004,
1482         SO_RCVTIMEO     = 0x1006,
1483         SO_REUSEADDR    = 0x0004,
1484         SO_SNDBUF       = 0x1001,
1485         SO_SNDLOWAT     = 0x1003,
1486         SO_SNDTIMEO     = 0x1005,
1487         SO_TYPE         = 0x1008,
1488 
1489         SO_USELOOPBACK  = 0x0040, // non-standard
1490         SO_DGRAM_ERRIND = 0x0200, // non-standard
1491         SO_RECVUCRED    = 0x0400, // non-standard
1492     }
1493 
1494     enum
1495     {
1496         SOMAXCONN = 128
1497     }
1498 
1499     enum : uint
1500     {
1501         MSG_CTRUNC      = 0x10,
1502         MSG_DONTROUTE   = 0x4,
1503         MSG_EOR         = 0x8,
1504         MSG_OOB         = 0x1,
1505         MSG_PEEK        = 0x2,
1506         MSG_TRUNC       = 0x20,
1507         MSG_WAITALL     = 0x40
1508     }
1509 
1510     enum
1511     {
1512         AF_IPX          = 23,
1513         AF_APPLETALK    = 16,
1514         AF_INET         = 2,
1515         AF_UNIX         = 1,
1516         AF_UNSPEC       = 0
1517     }
1518 
1519     enum
1520     {
1521         SHUT_RD,
1522         SHUT_WR,
1523         SHUT_RDWR
1524     }
1525 }
1526 else
1527 {
1528     static assert(false, "Unsupported platform");
1529 }
1530 
1531 /*
1532 int     accept(int, sockaddr*, socklen_t*);
1533 int     bind(int, const scope sockaddr*, socklen_t);
1534 int     connect(int, const scope sockaddr*, socklen_t);
1535 int     getpeername(int, sockaddr*, socklen_t*);
1536 int     getsockname(int, sockaddr*, socklen_t*);
1537 int     getsockopt(int, int, int, void*, socklen_t*);
1538 int     listen(int, int);
1539 ssize_t recv(int, void*, size_t, int);
1540 ssize_t recvfrom(int, void*, size_t, int, sockaddr*, socklen_t*);
1541 ssize_t recvmsg(int, msghdr*, int);
1542 ssize_t send(int, const scope void*, size_t, int);
1543 ssize_t sendmsg(int, const scope msghdr*, int);
1544 ssize_t sendto(int, const scope void*, size_t, int, const scope sockaddr*, socklen_t);
1545 int     setsockopt(int, int, int, const scope void*, socklen_t);
1546 int     shutdown(int, int);
1547 int     socket(int, int, int);
1548 int     sockatmark(int);
1549 int     socketpair(int, int, int, ref int[2]);
1550 */
1551 
1552 version (CRuntime_Glibc)
1553 {
1554     int     accept(int, scope sockaddr*, scope socklen_t*);
1555     int     bind(int, const scope sockaddr*, socklen_t);
1556     int     connect(int, const scope sockaddr*, socklen_t);
1557     int     getpeername(int, scope sockaddr*, scope socklen_t*);
1558     int     getsockname(int, scope sockaddr*, scope socklen_t*);
1559     int     getsockopt(int, int, int, scope void*, scope socklen_t*);
1560     int     listen(int, int) @safe;
1561     ssize_t recv(int, scope void*, size_t, int);
1562     ssize_t recvfrom(int, scope void*, size_t, int, scope sockaddr*, scope socklen_t*);
1563     ssize_t recvmsg(int, scope msghdr*, int);
1564     ssize_t send(int, const scope void*, size_t, int);
1565     ssize_t sendmsg(int, const scope msghdr*, int);
1566     ssize_t sendto(int, const scope void*, size_t, int, const scope sockaddr*, socklen_t);
1567     int     setsockopt(int, int, int, const scope void*, socklen_t);
1568     int     shutdown(int, int) @safe;
1569     int     socket(int, int, int) @safe;
1570     int     sockatmark(int) @safe;
1571     int     socketpair(int, int, int, ref int[2]) @safe;
1572 }
1573 else version (Darwin)
1574 {
1575     int     accept(int, scope sockaddr*, scope socklen_t*);
1576     int     bind(int, const scope sockaddr*, socklen_t);
1577     int     connect(int, const scope sockaddr*, socklen_t);
1578     int     getpeername(int, scope sockaddr*, scope socklen_t*);
1579     int     getsockname(int, scope sockaddr*, scope socklen_t*);
1580     int     getsockopt(int, int, int, scope void*, scope socklen_t*);
1581     int     listen(int, int) @safe;
1582     ssize_t recv(int, scope void*, size_t, int);
1583     ssize_t recvfrom(int, scope void*, size_t, int, scope sockaddr*, scope socklen_t*);
1584     ssize_t recvmsg(int, scope msghdr*, int);
1585     ssize_t send(int, const scope void*, size_t, int);
1586     ssize_t sendmsg(int, const scope msghdr*, int);
1587     ssize_t sendto(int, const scope void*, size_t, int, const scope sockaddr*, socklen_t);
1588     int     setsockopt(int, int, int, const scope void*, socklen_t);
1589     int     shutdown(int, int) @safe;
1590     int     socket(int, int, int) @safe;
1591     int     sockatmark(int) @safe;
1592     int     socketpair(int, int, int, ref int[2]) @safe;
1593 }
1594 else version (FreeBSD)
1595 {
1596     int     accept(int, scope sockaddr*, scope socklen_t*);
1597     int     bind(int, const scope sockaddr*, socklen_t);
1598     int     connect(int, const scope sockaddr*, socklen_t);
1599     int     getpeername(int, scope sockaddr*, scope socklen_t*);
1600     int     getsockname(int, scope sockaddr*, scope socklen_t*);
1601     int     getsockopt(int, int, int, scope void*, scope socklen_t*);
1602     int     listen(int, int) @safe;
1603     ssize_t recv(int, scope void*, size_t, int);
1604     ssize_t recvfrom(int, scope void*, size_t, int, scope sockaddr*, scope socklen_t*);
1605     ssize_t recvmsg(int, scope msghdr*, int);
1606     ssize_t send(int, const scope void*, size_t, int);
1607     ssize_t sendmsg(int, const scope msghdr*, int);
1608     ssize_t sendto(int, const scope void*, size_t, int, const scope sockaddr*, socklen_t);
1609     int     setsockopt(int, int, int, const scope void*, socklen_t);
1610     int     shutdown(int, int) @safe;
1611     int     socket(int, int, int) @safe;
1612     int     sockatmark(int) @safe;
1613     int     socketpair(int, int, int, ref int[2]) @safe;
1614 }
1615 else version (NetBSD)
1616 {
1617     int     accept(int, scope sockaddr*, scope socklen_t*);
1618     int     bind(int, const scope sockaddr*, socklen_t);
1619     int     connect(int, const scope sockaddr*, socklen_t);
1620     int     getpeername(int, scope sockaddr*, scope socklen_t*);
1621     int     getsockname(int, scope sockaddr*, scope socklen_t*);
1622     int     getsockopt(int, int, int, scope void*, scope socklen_t*);
1623     int     listen(int, int) @safe;
1624     ssize_t recv(int, scope void*, size_t, int);
1625     ssize_t recvfrom(int, scope void*, size_t, int, scope sockaddr*, scope socklen_t*);
1626     ssize_t recvmsg(int, scope msghdr*, int);
1627     ssize_t send(int, const scope void*, size_t, int);
1628     ssize_t sendmsg(int, const scope msghdr*, int);
1629     ssize_t sendto(int, const scope void*, size_t, int, const scope sockaddr*, socklen_t);
1630     int     setsockopt(int, int, int, const scope void*, socklen_t);
1631     int     shutdown(int, int) @safe;
1632     int     socket(int, int, int) @safe;
1633     int     sockatmark(int) @safe;
1634     int     socketpair(int, int, int, ref int[2]) @safe;
1635 }
1636 else version (OpenBSD)
1637 {
1638     int     accept(int, scope sockaddr*, scope socklen_t*);
1639     int     bind(int, const scope sockaddr*, socklen_t);
1640     int     connect(int, const scope sockaddr*, socklen_t);
1641     int     getpeername(int, scope sockaddr*, scope socklen_t*);
1642     int     getsockname(int, scope sockaddr*, scope socklen_t*);
1643     int     getsockopt(int, int, int, scope void*, scope socklen_t*);
1644     int     listen(int, int) @safe;
1645     ssize_t recv(int, scope void*, size_t, int);
1646     ssize_t recvfrom(int, scope void*, size_t, int, scope sockaddr*, scope socklen_t*);
1647     ssize_t recvmsg(int, scope msghdr*, int);
1648     ssize_t send(int, const scope void*, size_t, int);
1649     ssize_t sendmsg(int, const scope msghdr*, int);
1650     ssize_t sendto(int, const scope void*, size_t, int, const scope sockaddr*, socklen_t);
1651     int     setsockopt(int, int, int, const scope void*, socklen_t);
1652     int     shutdown(int, int) @safe;
1653     int     socket(int, int, int) @safe;
1654     int     sockatmark(int) @safe;
1655     int     socketpair(int, int, int, ref int[2]) @safe;
1656 }
1657 else version (DragonFlyBSD)
1658 {
1659     int     accept(int, sockaddr*, socklen_t*);
1660 //    int     accept4(int, sockaddr*, socklen_t*, int);
1661     int     bind(int, const scope sockaddr*, socklen_t);
1662     int     connect(int, const scope sockaddr*, socklen_t);
1663 //    int     extconnect(int, int, sockaddr*, socklen_t);
1664     int     getpeername(int, sockaddr*, socklen_t*);
1665     int     getsockname(int, sockaddr*, socklen_t*);
1666     int     getsockopt(int, int, int, void*, socklen_t*);
1667     int     listen(int, int);
1668     ssize_t recv(int, void*, size_t, int);
1669     ssize_t recvfrom(int, void*, size_t, int, sockaddr*, socklen_t*);
1670     ssize_t recvmsg(int, msghdr*, int);
1671     ssize_t send(int, const scope void*, size_t, int);
1672     ssize_t sendto(int, const scope void*, size_t, int, const scope sockaddr*, socklen_t);
1673     ssize_t sendmsg(int, const scope msghdr*, int);
1674 //    int     sendfile(int, int, off_t, size_t, sf_hdtr *, off_t *, int);
1675     int     setsockopt(int, int, int, const scope void*, socklen_t);
1676     int     shutdown(int, int);
1677     int     sockatmark(int);
1678     int     socket(int, int, int);
1679     int     socketpair(int, int, int, ref int[2]);
1680 //  void    pfctlinput(int, struct sockaddr *);
1681 }
1682 else version (Solaris)
1683 {
1684     int     accept(int, scope sockaddr*, scope socklen_t*);
1685     int     bind(int, const scope sockaddr*, socklen_t);
1686     int     connect(int, const scope sockaddr*, socklen_t);
1687     int     getpeername(int, scope sockaddr*, scope socklen_t*);
1688     int     getsockname(int, scope sockaddr*, scope socklen_t*);
1689     int     getsockopt(int, int, int, scope void*, scope socklen_t*);
1690     int     listen(int, int) @safe;
1691     ssize_t recv(int, scope void*, size_t, int);
1692     ssize_t recvfrom(int, scope void*, size_t, int, scope sockaddr*, scope socklen_t*);
1693     ssize_t recvmsg(int, scope msghdr*, int);
1694     ssize_t send(int, const scope void*, size_t, int);
1695     ssize_t sendmsg(int, const scope msghdr*, int);
1696     ssize_t sendto(int, const scope void*, size_t, int, const scope sockaddr*, socklen_t);
1697     int     setsockopt(int, int, int, const scope void*, socklen_t);
1698     int     shutdown(int, int) @safe;
1699     int     socket(int, int, int) @safe;
1700     int     sockatmark(int) @safe;
1701     int     socketpair(int, int, int, ref int[2]) @safe;
1702 }
1703 else version (CRuntime_Bionic)
1704 {
1705     int     accept(int, scope sockaddr*, scope socklen_t*);
1706     int     bind(int, const scope sockaddr*, socklen_t);
1707     int     connect(int, const scope sockaddr*, socklen_t);
1708     int     getpeername(int, scope sockaddr*, scope socklen_t*);
1709     int     getsockname(int, scope sockaddr*, scope socklen_t*);
1710     int     getsockopt(int, int, int, scope void*, scope socklen_t*);
1711     int     listen(int, int) @safe;
1712     ssize_t recv(int, scope void*, size_t, int);
1713     ssize_t recvfrom(int, scope void*, size_t, int, scope sockaddr*, scope socklen_t*);
1714     int     recvmsg(int, scope msghdr*, int);
1715     ssize_t send(int, const scope void*, size_t, int);
1716     int     sendmsg(int, const scope msghdr*, int);
1717     ssize_t sendto(int, const scope void*, size_t, int, const scope sockaddr*, socklen_t);
1718     int     setsockopt(int, int, int, const scope void*, socklen_t);
1719     int     shutdown(int, int) @safe;
1720     int     socket(int, int, int) @safe;
1721     int     sockatmark(int) @safe;
1722     int     socketpair(int, int, int, ref int[2]) @safe;
1723 }
1724 else version (CRuntime_Musl)
1725 {
1726     int     accept(int, sockaddr*, socklen_t*);
1727     int     bind(int, const scope sockaddr*, socklen_t);
1728     int     connect(int, const scope sockaddr*, socklen_t);
1729     int     getpeername(int, sockaddr*, socklen_t*);
1730     int     getsockname(int, sockaddr*, socklen_t*);
1731     int     getsockopt(int, int, int, void*, socklen_t*);
1732     int     listen(int, int);
1733     ssize_t recv(int, void*, size_t, int);
1734     ssize_t recvfrom(int, void*, size_t, int, sockaddr*, socklen_t*);
1735     ssize_t recvmsg(int, msghdr*, int);
1736     ssize_t send(int, const scope void*, size_t, int);
1737     ssize_t sendmsg(int, const scope msghdr*, int);
1738     ssize_t sendto(int, const scope void*, size_t, int, const scope sockaddr*, socklen_t);
1739     int     setsockopt(int, int, int, const scope void*, socklen_t);
1740     int     shutdown(int, int);
1741     int     socket(int, int, int);
1742     int     sockatmark(int);
1743     int     socketpair(int, int, int, ref int[2]);
1744 }
1745 else version (CRuntime_UClibc)
1746 {
1747     int     accept(int, sockaddr*, socklen_t*);
1748     int     bind(int, const scope sockaddr*, socklen_t);
1749     int     connect(int, const scope sockaddr*, socklen_t);
1750     int     getpeername(int, sockaddr*, socklen_t*);
1751     int     getsockname(int, sockaddr*, socklen_t*);
1752     int     getsockopt(int, int, int, void*, socklen_t*);
1753     int     listen(int, int);
1754     ssize_t recv(int, void*, size_t, int);
1755     ssize_t recvfrom(int, void*, size_t, int, sockaddr*, socklen_t*);
1756     ssize_t recvmsg(int, msghdr*, int);
1757     ssize_t send(int, const scope void*, size_t, int);
1758     ssize_t sendmsg(int, const scope msghdr*, int);
1759     ssize_t sendto(int, const scope void*, size_t, int, const scope sockaddr*, socklen_t);
1760     int     setsockopt(int, int, int, const scope void*, socklen_t);
1761     int     shutdown(int, int);
1762     int     socket(int, int, int);
1763     int     sockatmark(int);
1764     int     socketpair(int, int, int, ref int[2]);
1765 }
1766 else
1767 {
1768     static assert(false, "Unsupported platform");
1769 }
1770 
1771 //
1772 // IPV6 (IP6)
1773 //
1774 /*
1775 AF_INET6
1776 */
1777 
1778 version (linux)
1779 {
1780     enum
1781     {
1782         AF_INET6    = 10
1783     }
1784 }
1785 else version (Darwin)
1786 {
1787     enum
1788     {
1789         AF_INET6    = 30
1790     }
1791 }
1792 else version (FreeBSD)
1793 {
1794     enum
1795     {
1796         AF_INET6    = 28
1797     }
1798 }
1799 else version (NetBSD)
1800 {
1801     enum
1802     {
1803         AF_INET6    = 24
1804     }
1805 }
1806 else version (OpenBSD)
1807 {
1808     enum
1809     {
1810         AF_INET6    = 24
1811     }
1812 }
1813 else version (DragonFlyBSD)
1814 {
1815     enum
1816     {
1817         AF_INET6    = 28
1818     }
1819 }
1820 else version (Solaris)
1821 {
1822     enum
1823     {
1824         AF_INET6 = 26,
1825     }
1826 }
1827 else
1828 {
1829     static assert(false, "Unsupported platform");
1830 }
1831 
1832 //
1833 // Raw Sockets (RS)
1834 //
1835 /*
1836 SOCK_RAW
1837 */
1838 
1839 version (linux)
1840 {
1841     enum
1842     {
1843         SOCK_RAW    = 3
1844     }
1845 }
1846 else version (Darwin)
1847 {
1848     enum
1849     {
1850         SOCK_RAW    = 3
1851     }
1852 }
1853 else version (FreeBSD)
1854 {
1855     enum
1856     {
1857         SOCK_RAW    = 3
1858     }
1859 }
1860 else version (NetBSD)
1861 {
1862     enum
1863     {
1864         SOCK_RAW    = 3
1865     }
1866 }
1867 else version (OpenBSD)
1868 {
1869     enum
1870     {
1871         SOCK_RAW    = 3
1872     }
1873 }
1874 else version (DragonFlyBSD)
1875 {
1876     enum
1877     {
1878         SOCK_RAW    = 3
1879     }
1880 }
1881 else version (Solaris)
1882 {
1883     enum
1884     {
1885         SOCK_RAW = 4,
1886     }
1887 }
1888 else
1889 {
1890     static assert(false, "Unsupported platform");
1891 }
1892