import/stdc/posix/sys/socket.d

   1 /**
   2  * D header file for POSIX.
   3  *
   4  * Copyright: Public Domain
   5  * License:   Public Domain
   6  * Authors:   Sean Kelly
   7  * Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
   8  */
   9 module stdc.posix.sys.socket;
  10
  11 private import stdc.posix.config;
  12 public import stdc.posix.sys.types; // for ssize_t, size_t
  13 public import stdc.posix.sys.uio;   // for iovec
  14
  15 extern (C):
  16
  17 //
  18 // Required
  19 //
  20 /*
  21 socklen_t
  22 sa_family_t
  23
  24 struct sockaddr
  25 {
  26     sa_family_t sa_family;
  27     char        sa_data[];
  28 }
  29
  30 struct sockaddr_storage
  31 {
  32     sa_family_t ss_family;
  33 }
  34
  35 struct msghdr
  36 {
  37     void*         msg_name;
  38     socklen_t     msg_namelen;
  39     struct iovec* msg_iov;
  40     int           msg_iovlen;
  41     void*         msg_control;
  42     socklen_t     msg_controllen;
  43     int           msg_flags;
  44 }
  45
  46 struct iovec {} // from stdc.posix.sys.uio
  47
  48 struct cmsghdr
  49 {
  50     socklen_t cmsg_len;
  51     int       cmsg_level;
  52     int       cmsg_type;
  53 }
  54
  55 SCM_RIGHTS
  56
  57 CMSG_DATA(cmsg)
  58 CMSG_NXTHDR(mhdr,cmsg)
  59 CMSG_FIRSTHDR(mhdr)
  60
  61 struct linger
  62 {
  63     int l_onoff;
  64     int l_linger;
  65 }
  66
  67 SOCK_DGRAM
  68 SOCK_SEQPACKET
  69 SOCK_STREAM
  70
  71 SOL_SOCKET
  72
  73 SO_ACCEPTCONN
  74 SO_BROADCAST
  75 SO_DEBUG
  76 SO_DONTROUTE
  77 SO_ERROR
  78 SO_KEEPALIVE
  79 SO_LINGER
  80 SO_OOBINLINE
  81 SO_RCVBUF
  82 SO_RCVLOWAT
  83 SO_RCVTIMEO
  84 SO_REUSEADDR
  85 SO_SNDBUF
  86 SO_SNDLOWAT
  87 SO_SNDTIMEO
  88 SO_TYPE
  89
  90 SOMAXCONN
  91
  92 MSG_CTRUNC
  93 MSG_DONTROUTE
  94 MSG_EOR
  95 MSG_OOB
  96 MSG_PEEK
  97 MSG_TRUNC
  98 MSG_WAITALL
  99
 100 AF_INET
 101 AF_UNIX
 102 AF_UNSPEC
 103
 104 SHUT_RD
 105 SHUT_RDWR
 106 SHUT_WR
 107
 108 int     accept(int, sockaddr*, socklen_t*);
 109 int     bind(int, in sockaddr*, socklen_t);
 110 int     connect(int, in sockaddr*, socklen_t);
 111 int     getpeername(int, sockaddr*, socklen_t*);
 112 int     getsockname(int, sockaddr*, socklen_t*);
 113 int     getsockopt(int, int, int, void*, socklen_t*);
 114 int     listen(int, int);
 115 ssize_t recv(int, void*, size_t, int);
 116 ssize_t recvfrom(int, void*, size_t, int, sockaddr*, socklen_t*);
 117 ssize_t recvmsg(int, msghdr*, int);
 118 ssize_t send(int, in void*, size_t, int);
 119 ssize_t sendmsg(int, in msghdr*, int);
 120 ssize_t sendto(int, in void*, size_t, int, in sockaddr*, socklen_t);
 121 int     setsockopt(int, int, int, in void*, socklen_t);
 122 int     shutdown(int, int);
 123 int     socket(int, int, int);
 124 int     sockatmark(int);
 125 int     socketpair(int, int, int, int[2]);
 126 */
 127
 128 version( linux )
 129 {
 130     alias uint   socklen_t;
 131     alias ushort sa_family_t;
 132
 133     struct sockaddr
 134     {
 135         sa_family_t sa_family;
 136         byte[14]    sa_data;
 137     }
 138
 139     private enum : size_t
 140     {
 141         _SS_SIZE    = 128,
 142         _SS_PADSIZE = _SS_SIZE - (c_ulong.sizeof * 2)
 143     }
 144
 145     struct sockaddr_storage
 146     {
 147         sa_family_t ss_family;
 148         c_ulong     __ss_align;
 149         byte[_SS_PADSIZE] __ss_padding;
 150     }
 151
 152     struct msghdr
 153     {
 154         void*     msg_name;
 155         socklen_t msg_namelen;
 156         iovec*    msg_iov;
 157         size_t    msg_iovlen;
 158         void*     msg_control;
 159         size_t    msg_controllen;
 160         int       msg_flags;
 161     }
 162
 163     struct cmsghdr
 164     {
 165         size_t cmsg_len;
 166         int    cmsg_level;
 167         int    cmsg_type;
 168         static if( false /* (!is( __STRICT_ANSI__ ) && __GNUC__ >= 2) || __STDC_VERSION__ >= 199901L */ )
 169         {
 170             ubyte[1] __cmsg_data;
 171         }
 172     }
 173
 174     enum : uint
 175     {
 176         SCM_RIGHTS = 0x01
 177     }
 178
 179     static if( false /* (!is( __STRICT_ANSI__ ) && __GNUC__ >= 2) || __STDC_VERSION__ >= 199901L */ )
 180     {
 181         extern (D) ubyte[1] CMSG_DATA( cmsghdr* cmsg ) { return cmsg.__cmsg_data; }
 182     }
 183     else
 184     {
 185         extern (D) ubyte*   CMSG_DATA( cmsghdr* cmsg ) { return cast(ubyte*)( cmsg + 1 ); }
 186     }
 187
 188     private cmsghdr* __cmsg_nxthdr(msghdr*, cmsghdr*);
 189     alias            __cmsg_nxthdr CMSG_NXTHDR;
 190
 191     extern (D) size_t CMSG_FIRSTHDR( msghdr* mhdr )
 192     {
 193         return cast(size_t)( mhdr.msg_controllen >= cmsghdr.sizeof
 194                              ? cast(cmsghdr*) mhdr.msg_control
 195                              : cast(cmsghdr*) null );
 196     }
 197
 198     struct linger
 199     {
 200         int l_onoff;
 201         int l_linger;
 202     }
 203
 204     enum
 205     {
 206         SOCK_DGRAM      = 2,
 207         SOCK_SEQPACKET  = 5,
 208         SOCK_STREAM     = 1
 209     }
 210
 211     enum
 212     {
 213         SOL_SOCKET      = 1
 214     }
 215
 216     enum
 217     {
 218         SO_ACCEPTCONN   = 30,
 219         SO_BROADCAST    = 6,
 220         SO_DEBUG        = 1,
 221         SO_DONTROUTE    = 5,
 222         SO_ERROR        = 4,
 223         SO_KEEPALIVE    = 9,
 224         SO_LINGER       = 13,
 225         SO_OOBINLINE    = 10,
 226         SO_RCVBUF       = 8,
 227         SO_RCVLOWAT     = 18,
 228         SO_RCVTIMEO     = 20,
 229         SO_REUSEADDR    = 2,
 230         SO_SNDBUF       = 7,
 231         SO_SNDLOWAT     = 19,
 232         SO_SNDTIMEO     = 21,
 233         SO_TYPE         = 3
 234     }
 235
 236     enum
 237     {
 238         SOMAXCONN       = 128
 239     }
 240
 241     enum : uint
 242     {
 243         MSG_CTRUNC      = 0x08,
 244         MSG_DONTROUTE   = 0x04,
 245         MSG_EOR         = 0x80,
 246         MSG_OOB         = 0x01,
 247         MSG_PEEK        = 0x02,
 248         MSG_TRUNC       = 0x20,
 249         MSG_WAITALL     = 0x100
 250     }
 251
 252     enum
 253     {
 254         AF_INET         = 2,
 255         AF_UNIX         = 1,
 256         AF_UNSPEC       = 0
 257     }
 258
 259     enum
 260     {
 261         SHUT_RD,
 262         SHUT_WR,
 263         SHUT_RDWR
 264     }
 265
 266     int     accept(int, sockaddr*, socklen_t*);
 267     int     bind(int, in sockaddr*, socklen_t);
 268     int     connect(int, in sockaddr*, socklen_t);
 269     int     getpeername(int, sockaddr*, socklen_t*);
 270     int     getsockname(int, sockaddr*, socklen_t*);
 271     int     getsockopt(int, int, int, void*, socklen_t*);
 272     int     listen(int, int);
 273     ssize_t recv(int, void*, size_t, int);
 274     ssize_t recvfrom(int, void*, size_t, int, sockaddr*, socklen_t*);
 275     ssize_t recvmsg(int, msghdr*, int);
 276     ssize_t send(int, in void*, size_t, int);
 277     ssize_t sendmsg(int, in msghdr*, int);
 278     ssize_t sendto(int, in void*, size_t, int, in sockaddr*, socklen_t);
 279     int     setsockopt(int, int, int, in void*, socklen_t);
 280     int     shutdown(int, int);
 281     int     socket(int, int, int);
 282     int     sockatmark(int);
 283     int     socketpair(int, int, int, int[2]);
 284 }
 285 else version( darwin )
 286 {
 287     alias uint   socklen_t;
 288     alias ubyte  sa_family_t;
 289
 290     struct sockaddr
 291     {
 292         ubyte       sa_len;
 293         sa_family_t sa_family;
 294         byte[14]    sa_data;
 295     }
 296
 297     private enum : size_t
 298     {
 299         _SS_PAD1    = long.sizeof - ubyte.sizeof - sa_family_t.sizeof,
 300         _SS_PAD2    = 128 - ubyte.sizeof - sa_family_t.sizeof - _SS_PAD1 - long.sizeof
 301     }
 302
 303     struct sockaddr_storage
 304     {
 305          ubyte          ss_len;
 306          sa_family_t    ss_family;
 307          byte[_SS_PAD1] __ss_pad1;
 308          long           __ss_align;
 309          byte[_SS_PAD2] __ss_pad2;
 310     }
 311
 312     struct msghdr
 313     {
 314         void*     msg_name;
 315         socklen_t msg_namelen;
 316         iovec*    msg_iov;
 317         int       msg_iovlen;
 318         void*     msg_control;
 319         socklen_t msg_controllen;
 320         int       msg_flags;
 321     }
 322
 323     struct cmsghdr
 324     {
 325          socklen_t cmsg_len;
 326          int       cmsg_level;
 327          int       cmsg_type;
 328     }
 329
 330     enum : uint
 331     {
 332         SCM_RIGHTS = 0x01
 333     }
 334
 335     /+
 336     CMSG_DATA(cmsg)     ((unsigned char *)(cmsg) + \
 337                          ALIGN(sizeof(struct cmsghdr)))
 338     CMSG_NXTHDR(mhdr, cmsg) \
 339                         (((unsigned char *)(cmsg) + ALIGN((cmsg)->cmsg_len) + \
 340                          ALIGN(sizeof(struct cmsghdr)) > \
 341                          (unsigned char *)(mhdr)->msg_control +(mhdr)->msg_controllen) ? \
 342                          (struct cmsghdr *)0 /* NULL */ : \
 343                          (struct cmsghdr *)((unsigned char *)(cmsg) + ALIGN((cmsg)->cmsg_len)))
 344     CMSG_FIRSTHDR(mhdr) ((struct cmsghdr *)(mhdr)->msg_control)
 345     +/
 346
 347     struct linger
 348     {
 349         int l_onoff;
 350         int l_linger;
 351     }
 352
 353     enum
 354     {
 355         SOCK_DGRAM      = 2,
 356         SOCK_SEQPACKET  = 5,
 357         SOCK_STREAM     = 1
 358     }
 359
 360     enum : uint
 361     {
 362         SOL_SOCKET      = 0xffff
 363     }
 364
 365     enum : uint
 366     {
 367         SO_ACCEPTCONN   = 0x0002,
 368         SO_BROADCAST    = 0x0020,
 369         SO_DEBUG        = 0x0001,
 370         SO_DONTROUTE    = 0x0010,
 371         SO_ERROR        = 0x1007,
 372         SO_KEEPALIVE    = 0x0008,
 373         SO_LINGER       = 0x1080,
 374         SO_OOBINLINE    = 0x0100,
 375         SO_RCVBUF       = 0x1002,
 376         SO_RCVLOWAT     = 0x1004,
 377         SO_RCVTIMEO     = 0x1006,
 378         SO_REUSEADDR    = 0x1006,
 379         SO_SNDBUF       = 0x1001,
 380         SO_SNDLOWAT     = 0x1003,
 381         SO_SNDTIMEO     = 0x1005,
 382         SO_TYPE         = 0x1008
 383     }
 384
 385     enum
 386     {
 387         SOMAXCONN       = 128
 388     }
 389
 390     enum : uint
 391     {
 392         MSG_CTRUNC      = 0x20,
 393         MSG_DONTROUTE   = 0x4,
 394         MSG_EOR         = 0x8,
 395         MSG_OOB         = 0x1,
 396         MSG_PEEK        = 0x2,
 397         MSG_TRUNC       = 0x10,
 398         MSG_WAITALL     = 0x40
 399     }
 400
 401     enum
 402     {
 403         AF_INET         = 2,
 404         AF_UNIX         = 1,
 405         AF_UNSPEC       = 0
 406     }
 407
 408     enum
 409     {
 410         SHUT_RD,
 411         SHUT_WR,
 412         SHUT_RDWR
 413     }
 414
 415     int     accept(int, sockaddr*, socklen_t*);
 416     int     bind(int, in sockaddr*, socklen_t);
 417     int     connect(int, in sockaddr*, socklen_t);
 418     int     getpeername(int, sockaddr*, socklen_t*);
 419     int     getsockname(int, sockaddr*, socklen_t*);
 420     int     getsockopt(int, int, int, void*, socklen_t*);
 421     int     listen(int, int);
 422     ssize_t recv(int, void*, size_t, int);
 423     ssize_t recvfrom(int, void*, size_t, int, sockaddr*, socklen_t*);
 424     ssize_t recvmsg(int, msghdr*, int);
 425     ssize_t send(int, in void*, size_t, int);
 426     ssize_t sendmsg(int, in msghdr*, int);
 427     ssize_t sendto(int, in void*, size_t, int, in sockaddr*, socklen_t);
 428     int     setsockopt(int, int, int, in void*, socklen_t);
 429     int     shutdown(int, int);
 430     int     socket(int, int, int);
 431     int     sockatmark(int);
 432     int     socketpair(int, int, int, int[2]);
 433 }
 434 else version( freebsd )
 435 {
 436     alias uint   socklen_t;
 437     alias ubyte  sa_family_t;
 438
 439     struct sockaddr
 440     {
 441         ubyte       sa_len;
 442         sa_family_t sa_family;
 443         byte[14]    sa_data;
 444     }
 445
 446     private
 447     {
 448         const _SS_ALIGNSIZE = long.sizeof;
 449         const uint _SS_MAXSIZE = 128;
 450         const _SS_PAD1SIZE = _SS_ALIGNSIZE - ubyte.sizeof - sa_family_t.sizeof;
 451         const _SS_PAD2SIZE = _SS_MAXSIZE - ubyte.sizeof - sa_family_t.sizeof - _SS_PAD1SIZE - _SS_ALIGNSIZE;
 452     }
 453
 454     struct sockaddr_storage
 455     {
 456          ubyte          ss_len;
 457          sa_family_t    ss_family;
 458          byte[_SS_PAD1SIZE] __ss_pad1;
 459          long           __ss_align;
 460          byte[_SS_PAD2SIZE] __ss_pad2;
 461     }
 462
 463     struct msghdr
 464     {
 465         void*     msg_name;
 466         socklen_t msg_namelen;
 467         iovec*    msg_iov;
 468         int       msg_iovlen;
 469         void*     msg_control;
 470         socklen_t msg_controllen;
 471         int       msg_flags;
 472     }
 473
 474     struct cmsghdr
 475     {
 476          socklen_t cmsg_len;
 477          int       cmsg_level;
 478          int       cmsg_type;
 479     }
 480
 481     enum : uint
 482     {
 483         SCM_RIGHTS = 0x01
 484     }
 485
 486     /+
 487     CMSG_DATA(cmsg)     ((unsigned char *)(cmsg) + \
 488                          ALIGN(sizeof(struct cmsghdr)))
 489     CMSG_NXTHDR(mhdr, cmsg) \
 490                         (((unsigned char *)(cmsg) + ALIGN((cmsg)->cmsg_len) + \
 491                          ALIGN(sizeof(struct cmsghdr)) > \
 492                          (unsigned char *)(mhdr)->msg_control +(mhdr)->msg_controllen) ? \
 493                          (struct cmsghdr *)0 /* NULL */ : \
 494                          (struct cmsghdr *)((unsigned char *)(cmsg) + ALIGN((cmsg)->cmsg_len)))
 495     CMSG_FIRSTHDR(mhdr) ((struct cmsghdr *)(mhdr)->msg_control)
 496     +/
 497
 498     struct linger
 499     {
 500         int l_onoff;
 501         int l_linger;
 502     }
 503
 504     enum
 505     {
 506         SOCK_DGRAM      = 2,
 507         SOCK_SEQPACKET  = 5,
 508         SOCK_STREAM     = 1
 509     }
 510
 511     enum : uint
 512     {
 513         SOL_SOCKET      = 0xffff
 514     }
 515
 516     enum : uint
 517     {
 518         SO_ACCEPTCONN   = 0x0002,
 519         SO_BROADCAST    = 0x0020,
 520         SO_DEBUG        = 0x0001,
 521         SO_DONTROUTE    = 0x0010,
 522         SO_ERROR        = 0x1007,
 523         SO_KEEPALIVE    = 0x0008,
 524         SO_LINGER       = 0x1080,
 525         SO_OOBINLINE    = 0x0100,
 526         SO_RCVBUF       = 0x1002,
 527         SO_RCVLOWAT     = 0x1004,
 528         SO_RCVTIMEO     = 0x1006,
 529         SO_REUSEADDR    = 0x1006,
 530         SO_SNDBUF       = 0x1001,
 531         SO_SNDLOWAT     = 0x1003,
 532         SO_SNDTIMEO     = 0x1005,
 533         SO_TYPE         = 0x1008
 534     }
 535
 536     enum
 537     {
 538         SOMAXCONN       = 128
 539     }
 540
 541     enum : uint
 542     {
 543         MSG_CTRUNC      = 0x20,
 544         MSG_DONTROUTE   = 0x4,
 545         MSG_EOR         = 0x8,
 546         MSG_OOB         = 0x1,
 547         MSG_PEEK        = 0x2,
 548         MSG_TRUNC       = 0x10,
 549         MSG_WAITALL     = 0x40
 550     }
 551
 552     enum
 553     {
 554         AF_INET         = 2,
 555         AF_UNIX         = 1,
 556         AF_UNSPEC       = 0
 557     }
 558
 559     enum
 560     {
 561         SHUT_RD = 0,
 562         SHUT_WR = 1,
 563         SHUT_RDWR = 2
 564     }
 565
 566     int     accept(int, sockaddr*, socklen_t*);
 567     int     bind(int, in sockaddr*, socklen_t);
 568     int     connect(int, in sockaddr*, socklen_t);
 569     int     getpeername(int, sockaddr*, socklen_t*);
 570     int     getsockname(int, sockaddr*, socklen_t*);
 571     int     getsockopt(int, int, int, void*, socklen_t*);
 572     int     listen(int, int);
 573     ssize_t recv(int, void*, size_t, int);
 574     ssize_t recvfrom(int, void*, size_t, int, sockaddr*, socklen_t*);
 575     ssize_t recvmsg(int, msghdr*, int);
 576     ssize_t send(int, in void*, size_t, int);
 577     ssize_t sendmsg(int, in msghdr*, int);
 578     ssize_t sendto(int, in void*, size_t, int, in sockaddr*, socklen_t);
 579     int     setsockopt(int, int, int, in void*, socklen_t);
 580     int     shutdown(int, int);
 581     int     socket(int, int, int);
 582     int     sockatmark(int);
 583     int     socketpair(int, int, int, int[2]);
 584 }
 585
 586 //
 587 // IPV6 (IP6)
 588 //
 589 /*
 590 AF_INET6
 591 */
 592
 593 version( linux )
 594 {
 595     enum
 596     {
 597         AF_INET6    = 10
 598     }
 599 }
 600 else version( darwin )
 601 {
 602     enum
 603     {
 604         AF_INET6    = 30
 605     }
 606 }
 607 else version( freebsd )
 608 {
 609     enum
 610     {
 611         AF_INET6    = 28
 612     }
 613 }
 614
 615 //
 616 // Raw Sockets (RS)
 617 //
 618 /*
 619 SOCK_RAW
 620 */
 621
 622 version( linux )
 623 {
 624     enum
 625     {
 626         SOCK_RAW    = 3
 627     }
 628 }
 629 else version( darwin )
 630 {
 631     enum
 632     {
 633         SOCK_RAW    = 3
 634     }
 635 }
 636 else version( freebsd )
 637 {
 638     enum
 639     {
 640         SOCK_RAW    = 3
 641     }
 642 }