libphobos/libdruntime/core/sys/posix/sys/select.d

   1 /**
   2  * D header file for POSIX.
   3  *
   4  * Copyright: Copyright Sean Kelly 2005 - 2016.
   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 module core.sys.posix.sys.select;
  10
  11 import core.sys.posix.config;
  12 public import core.stdc.time;           // for timespec
  13 public import core.sys.posix.sys.time;  // for timeval
  14 public import core.sys.posix.sys.types; // for time_t
  15 public import core.sys.posix.signal;    // for sigset_t
  16
  17 //debug=select;  // uncomment to turn on debugging printf's
  18
  19 version (OSX)
  20     version = Darwin;
  21 else version (iOS)
  22     version = Darwin;
  23 else version (TVOS)
  24     version = Darwin;
  25 else version (WatchOS)
  26     version = Darwin;
  27
  28 version (Posix):
  29 extern (C) nothrow @nogc:
  30
  31 //
  32 // Required
  33 //
  34 /*
  35 NOTE: This module requires timeval from core.sys.posix.sys.time, but timeval
  36       is supposedly an XOpen extension.  As a result, this header will not
  37       compile on platforms that are not XSI-compliant.  This must be resolved
  38       on a per-platform basis.
  39
  40 fd_set
  41
  42 void FD_CLR(int fd, fd_set* fdset);
  43 int FD_ISSET(int fd, const(fd_set)* fdset);
  44 void FD_SET(int fd, fd_set* fdset);
  45 void FD_ZERO(fd_set* fdset);
  46
  47 FD_SETSIZE
  48
  49 int  pselect(int, fd_set*, fd_set*, fd_set*, const scope timespec*, const scope sigset_t*);
  50 int  select(int, fd_set*, fd_set*, fd_set*, timeval*);
  51 */
  52
  53 version (CRuntime_Glibc)
  54 {
  55     private
  56     {
  57         alias c_long __fd_mask;
  58         enum uint __NFDBITS = 8 * __fd_mask.sizeof;
  59
  60         extern (D) auto __FDELT( int d ) pure
  61         {
  62             return d / __NFDBITS;
  63         }
  64
  65         extern (D) auto __FDMASK( int d ) pure
  66         {
  67             return cast(__fd_mask) 1 << ( d % __NFDBITS );
  68         }
  69     }
  70
  71     enum FD_SETSIZE = 1024;
  72
  73     struct fd_set
  74     {
  75         __fd_mask[FD_SETSIZE / __NFDBITS] fds_bits;
  76     }
  77
  78     extern (D) void FD_CLR( int fd, fd_set* fdset ) pure
  79     {
  80         fdset.fds_bits[__FDELT( fd )] &= ~__FDMASK( fd );
  81     }
  82
  83     extern (D) bool FD_ISSET( int fd, const(fd_set)* fdset ) pure
  84     {
  85         return (fdset.fds_bits[__FDELT( fd )] & __FDMASK( fd )) != 0;
  86     }
  87
  88     extern (D) void FD_SET( int fd, fd_set* fdset ) pure
  89     {
  90         fdset.fds_bits[__FDELT( fd )] |= __FDMASK( fd );
  91     }
  92
  93     extern (D) void FD_ZERO( fd_set* fdset ) pure
  94     {
  95         fdset.fds_bits[0 .. $] = 0;
  96     }
  97
  98     /+
  99      + GNU ASM Implementation
 100      +
 101     # define __FD_ZERO(fdsp)                                \
 102       do {                                                  \
 103         int __d0, __d1;                                     \
 104         __asm__ __volatile__ ("cld; rep; stosl"             \
 105                   : "=c" (__d0), "=D" (__d1)                \
 106                   : "a" (0), "0" (sizeof (fd_set)           \
 107                           / sizeof (__fd_mask)),            \
 108                     "1" (&__FDS_BITS (fdsp)[0])             \
 109                   : "memory");                              \
 110       } while (0)
 111
 112     # define __FD_SET(fd, fdsp)                             \
 113       __asm__ __volatile__ ("btsl %1,%0"                    \
 114                 : "=m" (__FDS_BITS (fdsp)[__FDELT (fd)])    \
 115                 : "r" (((int) (fd)) % __NFDBITS)            \
 116                 : "cc","memory")
 117     # define __FD_CLR(fd, fdsp)                             \
 118       __asm__ __volatile__ ("btrl %1,%0"                    \
 119                 : "=m" (__FDS_BITS (fdsp)[__FDELT (fd)])    \
 120                 : "r" (((int) (fd)) % __NFDBITS)            \
 121                 : "cc","memory")
 122     # define __FD_ISSET(fd, fdsp)                           \
 123       (__extension__                                        \
 124        ({register char __result;                            \
 125          __asm__ __volatile__ ("btl %1,%2 ; setcb %b0"      \
 126                    : "=q" (__result)                        \
 127                    : "r" (((int) (fd)) % __NFDBITS),        \
 128                      "m" (__FDS_BITS (fdsp)[__FDELT (fd)])  \
 129                    : "cc");                                 \
 130          __result; }))
 131      +/
 132
 133     int pselect(int, fd_set*, fd_set*, fd_set*, const scope timespec*, const scope sigset_t*);
 134     int select(int, fd_set*, fd_set*, fd_set*, timeval*);
 135 }
 136 else version (Darwin)
 137 {
 138     private
 139     {
 140         enum uint __DARWIN_NBBY    = 8;                            /* bits in a byte */
 141         enum uint __DARWIN_NFDBITS = (int.sizeof * __DARWIN_NBBY); /* bits per mask */
 142     }
 143
 144     enum FD_SETSIZE = 1024;
 145
 146     struct fd_set
 147     {
 148         int[(FD_SETSIZE + (__DARWIN_NFDBITS - 1)) / __DARWIN_NFDBITS] fds_bits;
 149     }
 150
 151     extern (D) void FD_CLR( int fd, fd_set* fdset ) pure
 152     {
 153         fdset.fds_bits[fd / __DARWIN_NFDBITS] &= ~(1 << (fd % __DARWIN_NFDBITS));
 154     }
 155
 156     extern (D) bool FD_ISSET( int fd, const(fd_set)* fdset ) pure
 157     {
 158         return (fdset.fds_bits[fd / __DARWIN_NFDBITS] & (1 << (fd % __DARWIN_NFDBITS))) != 0;
 159     }
 160
 161     extern (D) void FD_SET( int fd, fd_set* fdset ) pure
 162     {
 163         fdset.fds_bits[fd / __DARWIN_NFDBITS] |= 1 << (fd % __DARWIN_NFDBITS);
 164     }
 165
 166     extern (D) void FD_ZERO( fd_set* fdset ) pure
 167     {
 168         fdset.fds_bits[0 .. $] = 0;
 169     }
 170
 171     int pselect(int, fd_set*, fd_set*, fd_set*, const scope timespec*, const scope sigset_t*);
 172     int select(int, fd_set*, fd_set*, fd_set*, timeval*);
 173 }
 174 else version (FreeBSD)
 175 {
 176     private
 177     {
 178         alias c_ulong __fd_mask;
 179         enum _NFDBITS = __fd_mask.sizeof * 8;
 180     }
 181
 182     enum uint FD_SETSIZE = 1024;
 183
 184     struct fd_set
 185     {
 186         __fd_mask[(FD_SETSIZE + (_NFDBITS - 1)) / _NFDBITS] __fds_bits;
 187     }
 188
 189     extern (D) __fd_mask __fdset_mask(uint n) pure
 190     {
 191         return cast(__fd_mask) 1 << (n % _NFDBITS);
 192     }
 193
 194     extern (D) void FD_CLR( int n, fd_set* p ) pure
 195     {
 196         p.__fds_bits[n / _NFDBITS] &= ~__fdset_mask(n);
 197     }
 198
 199     extern (D) bool FD_ISSET( int n, const(fd_set)* p ) pure
 200     {
 201         return (p.__fds_bits[n / _NFDBITS] & __fdset_mask(n)) != 0;
 202     }
 203
 204     extern (D) void FD_SET( int n, fd_set* p ) pure
 205     {
 206         p.__fds_bits[n / _NFDBITS] |= __fdset_mask(n);
 207     }
 208
 209     extern (D) void FD_ZERO( fd_set* p ) pure
 210     {
 211         fd_set *_p;
 212         size_t _n;
 213
 214         _p = p;
 215         _n = (FD_SETSIZE + (_NFDBITS - 1)) / _NFDBITS;
 216         while (_n > 0)
 217             _p.__fds_bits[--_n] = 0;
 218     }
 219
 220     int pselect(int, fd_set*, fd_set*, fd_set*, const scope timespec*, const scope sigset_t*);
 221     int select(int, fd_set*, fd_set*, fd_set*, timeval*);
 222 }
 223 else version (NetBSD)
 224 {
 225     private
 226     {
 227         alias c_ulong __fd_mask;
 228         enum _NFDBITS = __fd_mask.sizeof * 8;
 229     }
 230
 231     enum uint FD_SETSIZE = 256;
 232
 233     struct fd_set
 234     {
 235         __fd_mask[(FD_SETSIZE + (_NFDBITS - 1)) / _NFDBITS] __fds_bits;
 236     }
 237
 238     extern (D) __fd_mask __fdset_mask(uint n) pure
 239     {
 240         return cast(__fd_mask) 1 << (n % _NFDBITS);
 241     }
 242
 243     extern (D) void FD_CLR( int n, fd_set* p ) pure
 244     {
 245         p.__fds_bits[n / _NFDBITS] &= ~__fdset_mask(n);
 246     }
 247
 248     extern (D) bool FD_ISSET( int n, const(fd_set)* p ) pure
 249     {
 250         return (p.__fds_bits[n / _NFDBITS] & __fdset_mask(n)) != 0;
 251     }
 252
 253     extern (D) void FD_SET( int n, fd_set* p ) pure
 254     {
 255         p.__fds_bits[n / _NFDBITS] |= __fdset_mask(n);
 256     }
 257
 258     extern (D) void FD_ZERO( fd_set* p ) pure
 259     {
 260         fd_set *_p;
 261         size_t _n;
 262
 263         _p = p;
 264         _n = (FD_SETSIZE + (_NFDBITS - 1)) / _NFDBITS;
 265         while (_n > 0)
 266             _p.__fds_bits[--_n] = 0;
 267     }
 268
 269     int pselect(int, fd_set*, fd_set*, fd_set*, const scope timespec*, const scope sigset_t*);
 270     int select(int, fd_set*, fd_set*, fd_set*, timeval*);
 271 }
 272 else version (OpenBSD)
 273 {
 274     private
 275     {
 276         alias uint __fd_mask;
 277         enum _NFDBITS = __fd_mask.sizeof * 8;
 278     }
 279
 280     enum uint FD_SETSIZE = 1024;
 281
 282     struct fd_set
 283     {
 284         __fd_mask[(FD_SETSIZE + (_NFDBITS - 1)) / _NFDBITS] __fds_bits;
 285     }
 286
 287     extern (D) __fd_mask __fdset_mask(uint n) pure
 288     {
 289         return cast(__fd_mask) 1 << (n % _NFDBITS);
 290     }
 291
 292     extern (D) void FD_CLR(int n, fd_set* p) pure
 293     {
 294         p.__fds_bits[n / _NFDBITS] &= ~__fdset_mask(n);
 295     }
 296
 297     extern (D) bool FD_ISSET(int n, const(fd_set)* p) pure
 298     {
 299         return (p.__fds_bits[n / _NFDBITS] & __fdset_mask(n)) != 0;
 300     }
 301
 302     extern (D) void FD_SET(int n, fd_set* p) pure
 303     {
 304         p.__fds_bits[n / _NFDBITS] |= __fdset_mask(n);
 305     }
 306
 307     extern (D) void FD_ZERO(fd_set* p) pure
 308     {
 309         fd_set *_p = p;
 310         size_t _n = (FD_SETSIZE + (_NFDBITS - 1)) / _NFDBITS;
 311
 312         while (_n > 0)
 313             _p.__fds_bits[--_n] = 0;
 314     }
 315
 316     int pselect(int, fd_set*, fd_set*, fd_set*, const scope timespec*, const scope sigset_t*);
 317     int select(int, fd_set*, fd_set*, fd_set*, timeval*);
 318 }
 319 else version (DragonFlyBSD)
 320 {
 321     private
 322     {
 323         alias c_ulong __fd_mask;
 324         enum _NFDBITS = __fd_mask.sizeof * 8;
 325     }
 326
 327     enum uint FD_SETSIZE = 1024;
 328
 329     struct fd_set
 330     {
 331         __fd_mask[(FD_SETSIZE + (_NFDBITS - 1)) / _NFDBITS] __fds_bits;
 332     }
 333
 334     extern (D) __fd_mask __fdset_mask(uint n) pure
 335     {
 336         return cast(__fd_mask) 1 << (n % _NFDBITS);
 337     }
 338
 339     extern (D) void FD_CLR( int n, fd_set* p ) pure
 340     {
 341         p.__fds_bits[n / _NFDBITS] &= ~__fdset_mask(n);
 342     }
 343
 344     extern (D) bool FD_ISSET( int n, const(fd_set)* p ) pure
 345     {
 346         return (p.__fds_bits[n / _NFDBITS] & __fdset_mask(n)) != 0;
 347     }
 348
 349     extern (D) void FD_SET( int n, fd_set* p ) pure
 350     {
 351         p.__fds_bits[n / _NFDBITS] |= __fdset_mask(n);
 352     }
 353
 354     extern (D) void FD_ZERO( fd_set* p ) pure
 355     {
 356         fd_set *_p;
 357         size_t _n;
 358
 359         _p = p;
 360         _n = (FD_SETSIZE + (_NFDBITS - 1)) / _NFDBITS;
 361         while (_n > 0)
 362             _p.__fds_bits[--_n] = 0;
 363     }
 364
 365     int pselect(int, fd_set*, fd_set*, fd_set*, const scope timespec*, const scope sigset_t*);
 366     int select(int, fd_set*, fd_set*, fd_set*, timeval*);
 367 }
 368 else version (Solaris)
 369 {
 370     private
 371     {
 372         alias c_long fds_mask;
 373
 374         enum _NBBY = 8;
 375         enum FD_NFDBITS = fds_mask.sizeof * _NBBY;
 376     }
 377
 378     version (D_LP64)
 379         enum uint FD_SETSIZE = 65536;
 380     else
 381         enum uint FD_SETSIZE = 1024;
 382
 383     struct fd_set
 384     {
 385         c_long[(FD_SETSIZE + (FD_NFDBITS - 1)) / FD_NFDBITS] fds_bits;
 386     }
 387
 388     extern (D) void FD_SET(int __n, fd_set* __p) pure
 389     {
 390         __p.fds_bits[__n / FD_NFDBITS] |= 1UL << (__n % FD_NFDBITS);
 391     }
 392
 393     extern (D) void FD_CLR(int __n, fd_set* __p) pure
 394     {
 395         __p.fds_bits[__n / FD_NFDBITS] &= ~(1UL << (__n % FD_NFDBITS));
 396     }
 397
 398     extern (D) bool FD_ISSET(int __n, const(fd_set)* __p) pure
 399     {
 400         return (__p.fds_bits[__n / FD_NFDBITS] & (1UL << (__n % FD_NFDBITS))) != 0;
 401     }
 402
 403     extern (D) void FD_ZERO(fd_set* __p) pure
 404     {
 405         __p.fds_bits[0 .. $] = 0;
 406     }
 407
 408     int select(int, fd_set*, fd_set*, fd_set*, timeval*);
 409     int pselect(int, fd_set*, fd_set*, fd_set*, const scope timespec*, const scope sigset_t*);
 410 }
 411 else version (CRuntime_Bionic)
 412 {
 413     private
 414     {
 415         alias c_ulong __fd_mask;
 416         enum uint __NFDBITS = 8 * __fd_mask.sizeof;
 417
 418         extern (D) auto __FDELT( int d ) pure
 419         {
 420             return d / __NFDBITS;
 421         }
 422
 423         extern (D) auto __FDMASK( int d ) pure
 424         {
 425             return cast(__fd_mask) 1 << ( d % __NFDBITS );
 426         }
 427     }
 428
 429     enum FD_SETSIZE = 1024;
 430
 431     struct fd_set
 432     {
 433         __fd_mask[FD_SETSIZE / __NFDBITS] fds_bits;
 434     }
 435
 436     // These functions are generated in assembly in bionic.
 437     extern (D) void FD_CLR( int fd, fd_set* fdset ) pure
 438     {
 439         fdset.fds_bits[__FDELT( fd )] &= ~__FDMASK( fd );
 440     }
 441
 442     extern (D) bool FD_ISSET( int fd, const(fd_set)* fdset ) pure
 443     {
 444         return (fdset.fds_bits[__FDELT( fd )] & __FDMASK( fd )) != 0;
 445     }
 446
 447     extern (D) void FD_SET( int fd, fd_set* fdset ) pure
 448     {
 449         fdset.fds_bits[__FDELT( fd )] |= __FDMASK( fd );
 450     }
 451
 452     extern (D) void FD_ZERO( fd_set* fdset ) pure
 453     {
 454         fdset.fds_bits[0 .. $] = 0;
 455     }
 456
 457     int pselect(int, fd_set*, fd_set*, fd_set*, const scope timespec*, const scope sigset_t*);
 458     int select(int, fd_set*, fd_set*, fd_set*, timeval*);
 459 }
 460 else version (CRuntime_Musl)
 461 {
 462     enum FD_SETSIZE = 1024;
 463
 464     alias ulong fd_mask;
 465
 466     private
 467     {
 468         enum uint __NFDBITS = 8 * fd_mask.sizeof;
 469
 470         extern (D) auto __FDELT( int d ) pure
 471         {
 472             return d / __NFDBITS;
 473         }
 474
 475         extern (D) auto __FDMASK( int d ) pure
 476         {
 477             return cast(fd_mask) 1 << ( d % __NFDBITS );
 478         }
 479     }
 480
 481     struct fd_set {
 482         ulong[FD_SETSIZE / 8 / long.sizeof] fds_bits;
 483     }
 484
 485     extern (D) void FD_CLR( int fd, fd_set* fdset ) pure
 486     {
 487         fdset.fds_bits[__FDELT( fd )] &= ~__FDMASK( fd );
 488     }
 489
 490     extern (D) bool FD_ISSET( int fd, const(fd_set)* fdset ) pure
 491     {
 492         return (fdset.fds_bits[__FDELT( fd )] & __FDMASK( fd )) != 0;
 493     }
 494
 495     extern (D) void FD_SET( int fd, fd_set* fdset ) pure
 496     {
 497         fdset.fds_bits[__FDELT( fd )] |= __FDMASK( fd );
 498     }
 499
 500     extern (D) void FD_ZERO( fd_set* fdset ) pure
 501     {
 502         fdset.fds_bits[0 .. $] = 0;
 503     }
 504     pragma(mangle, muslRedirTime64Mangle!("pselect", "__pselect_time64"))
 505     int pselect(int, fd_set*, fd_set*, fd_set*, const scope timespec*, const scope sigset_t*);
 506     pragma(mangle, muslRedirTime64Mangle!("select", "__select_time64"))
 507     int select(int, fd_set*, fd_set*, fd_set*, timeval*);
 508 }
 509 else version (CRuntime_UClibc)
 510 {
 511     private
 512     {
 513         alias c_long __fd_mask;
 514         enum uint __NFDBITS = 8 * __fd_mask.sizeof;
 515
 516         extern (D) auto __FDELT( int d ) pure
 517         {
 518             return d / __NFDBITS;
 519         }
 520
 521         extern (D) auto __FDMASK( int d ) pure
 522         {
 523             return cast(__fd_mask) 1 << ( d % __NFDBITS );
 524         }
 525     }
 526
 527     enum FD_SETSIZE = 1024;
 528
 529     struct fd_set
 530     {
 531         __fd_mask[FD_SETSIZE / __NFDBITS] fds_bits;
 532     }
 533
 534     extern (D) void FD_CLR( int fd, fd_set* fdset ) pure
 535     {
 536         fdset.fds_bits[__FDELT( fd )] &= ~__FDMASK( fd );
 537     }
 538
 539     extern (D) bool FD_ISSET( int fd, const(fd_set)* fdset ) pure
 540     {
 541         return (fdset.fds_bits[__FDELT( fd )] & __FDMASK( fd )) != 0;
 542     }
 543
 544     extern (D) void FD_SET( int fd, fd_set* fdset ) pure
 545     {
 546         fdset.fds_bits[__FDELT( fd )] |= __FDMASK( fd );
 547     }
 548
 549     extern (D) void FD_ZERO( fd_set* fdset ) pure
 550     {
 551         fdset.fds_bits[0 .. $] = 0;
 552     }
 553
 554     int pselect(int, fd_set*, fd_set*, fd_set*, const scope timespec*, const scope sigset_t*);
 555     int select(int, fd_set*, fd_set*, fd_set*, timeval*);
 556 }
 557 else
 558 {
 559     static assert(false, "Unsupported platform");
 560 }
 561
 562 pure unittest
 563 {
 564     import core.stdc.stdio: printf;
 565
 566     debug(select) printf("core.sys.posix.sys.select unittest\n");
 567
 568     fd_set fd;
 569
 570     for (auto i = 0; i < FD_SETSIZE; i++)
 571     {
 572         assert(!FD_ISSET(i, &fd));
 573     }
 574
 575     for (auto i = 0; i < FD_SETSIZE; i++)
 576     {
 577         if ((i & -i) == i)
 578             FD_SET(i, &fd);
 579     }
 580
 581     for (auto i = 0; i < FD_SETSIZE; i++)
 582     {
 583         if ((i & -i) == i)
 584             assert(FD_ISSET(i, &fd));
 585         else
 586             assert(!FD_ISSET(i, &fd));
 587     }
 588
 589     for (auto i = 0; i < FD_SETSIZE; i++)
 590     {
 591         if ((i & -i) == i)
 592             FD_CLR(i, &fd);
 593         else
 594             FD_SET(i, &fd);
 595     }
 596
 597     for (auto i = 0; i < FD_SETSIZE; i++)
 598     {
 599         if ((i & -i) == i)
 600             assert(!FD_ISSET(i, &fd));
 601         else
 602             assert(FD_ISSET(i, &fd));
 603     }
 604
 605     FD_ZERO(&fd);
 606
 607     for (auto i = 0; i < FD_SETSIZE; i++)
 608     {
 609         assert(!FD_ISSET(i, &fd));
 610     }
 611 }