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

   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.fcntl;
  16
  17 private import core.sys.posix.config;
  18 private import core.stdc.stdint;
  19 public import core.sys.posix.sys.types; // for off_t, mode_t
  20 public import core.sys.posix.sys.stat;  // for S_IFMT, etc.
  21
  22 version (OSX)
  23     version = Darwin;
  24 else version (iOS)
  25     version = Darwin;
  26 else version (TVOS)
  27     version = Darwin;
  28 else version (WatchOS)
  29     version = Darwin;
  30
  31 version (Posix):
  32 extern (C):
  33
  34 nothrow:
  35 @nogc:
  36
  37 //
  38 // Required
  39 //
  40 /*
  41 F_DUPFD
  42 F_GETFD
  43 F_SETFD
  44 F_GETFL
  45 F_SETFL
  46 F_GETLK
  47 F_SETLK
  48 F_SETLKW
  49 F_GETOWN
  50 F_SETOWN
  51
  52 FD_CLOEXEC
  53
  54 F_RDLCK
  55 F_UNLCK
  56 F_WRLCK
  57
  58 O_CREAT
  59 O_EXCL
  60 O_NOCTTY
  61 O_TRUNC
  62
  63 O_APPEND
  64 O_DSYNC
  65 O_NONBLOCK
  66 O_RSYNC
  67 O_SYNC
  68
  69 O_ACCMODE
  70 O_RDONLY
  71 O_RDWR
  72 O_WRONLY
  73
  74 struct flock
  75 {
  76     short   l_type;
  77     short   l_whence;
  78     off_t   l_start;
  79     off_t   l_len;
  80     pid_t   l_pid;
  81 }
  82
  83 int creat(in char*, mode_t);
  84 int fcntl(int, int, ...);
  85 int open(in char*, int, ...);
  86 */
  87 version (CRuntime_Glibc)
  88 {
  89     enum F_DUPFD        = 0;
  90     enum F_GETFD        = 1;
  91     enum F_SETFD        = 2;
  92     enum F_GETFL        = 3;
  93     enum F_SETFL        = 4;
  94   version (X86_64)
  95   {
  96     static assert(off_t.sizeof == 8);
  97     enum F_GETLK        = 5;
  98     enum F_SETLK        = 6;
  99     enum F_SETLKW       = 7;
 100   }
 101   else version (AArch64)
 102   {
 103     enum F_GETLK        = 5;
 104     enum F_SETLK        = 6;
 105     enum F_SETLKW       = 7;
 106   }
 107   else
 108   static if ( __USE_FILE_OFFSET64 )
 109   {
 110     enum F_GETLK        = 12;
 111     enum F_SETLK        = 13;
 112     enum F_SETLKW       = 14;
 113   }
 114   else
 115   {
 116     enum F_GETLK        = 5;
 117     enum F_SETLK        = 6;
 118     enum F_SETLKW       = 7;
 119   }
 120     enum F_GETOWN       = 9;
 121     enum F_SETOWN       = 8;
 122
 123     enum FD_CLOEXEC     = 1;
 124
 125     enum F_RDLCK        = 0;
 126     enum F_UNLCK        = 2;
 127     enum F_WRLCK        = 1;
 128
 129     version (X86)
 130     {
 131         enum O_CREAT        = 0x40;     // octal     0100
 132         enum O_EXCL         = 0x80;     // octal     0200
 133         enum O_NOCTTY       = 0x100;    // octal     0400
 134         enum O_TRUNC        = 0x200;    // octal    01000
 135
 136         enum O_APPEND       = 0x400;    // octal    02000
 137         enum O_NONBLOCK     = 0x800;    // octal    04000
 138         enum O_SYNC         = 0x101000; // octal 04010000
 139         enum O_DSYNC        = 0x1000;   // octal   010000
 140         enum O_RSYNC        = O_SYNC;
 141     }
 142     else version (X86_64)
 143     {
 144         enum O_CREAT        = 0x40;     // octal     0100
 145         enum O_EXCL         = 0x80;     // octal     0200
 146         enum O_NOCTTY       = 0x100;    // octal     0400
 147         enum O_TRUNC        = 0x200;    // octal    01000
 148
 149         enum O_APPEND       = 0x400;    // octal    02000
 150         enum O_NONBLOCK     = 0x800;    // octal    04000
 151         enum O_SYNC         = 0x101000; // octal 04010000
 152         enum O_DSYNC        = 0x1000;   // octal   010000
 153         enum O_RSYNC        = O_SYNC;
 154     }
 155     else version (MIPS32)
 156     {
 157         enum O_CREAT        = 0x0100;
 158         enum O_EXCL         = 0x0400;
 159         enum O_NOCTTY       = 0x0800;
 160         enum O_TRUNC        = 0x0200;
 161
 162         enum O_APPEND       = 0x0008;
 163         enum O_DSYNC        = O_SYNC;
 164         enum O_NONBLOCK     = 0x0080;
 165         enum O_RSYNC        = O_SYNC;
 166         enum O_SYNC         = 0x0010;
 167     }
 168     else version (MIPS64)
 169     {
 170         enum O_CREAT        = 0x0100;
 171         enum O_EXCL         = 0x0400;
 172         enum O_NOCTTY       = 0x0800;
 173         enum O_TRUNC        = 0x0200;
 174
 175         enum O_APPEND       = 0x0008;
 176         enum O_DSYNC        = 0x0010;
 177         enum O_NONBLOCK     = 0x0080;
 178         enum O_RSYNC        = O_SYNC;
 179         enum O_SYNC         = 0x4010;
 180     }
 181     else version (PPC)
 182     {
 183         enum O_CREAT        = 0x40;     // octal     0100
 184         enum O_EXCL         = 0x80;     // octal     0200
 185         enum O_NOCTTY       = 0x100;    // octal     0400
 186         enum O_TRUNC        = 0x200;    // octal    01000
 187
 188         enum O_APPEND       = 0x400;    // octal    02000
 189         enum O_NONBLOCK     = 0x800;    // octal    04000
 190         enum O_SYNC         = 0x101000; // octal 04010000
 191         enum O_DSYNC        = 0x1000;   // octal   010000
 192         enum O_RSYNC        = O_SYNC;
 193     }
 194     else version (PPC64)
 195     {
 196         enum O_CREAT        = 0x40;     // octal     0100
 197         enum O_EXCL         = 0x80;     // octal     0200
 198         enum O_NOCTTY       = 0x100;    // octal     0400
 199         enum O_TRUNC        = 0x200;    // octal    01000
 200
 201         enum O_APPEND       = 0x400;    // octal    02000
 202         enum O_NONBLOCK     = 0x800;    // octal    04000
 203         enum O_SYNC         = 0x101000; // octal 04010000
 204         enum O_DSYNC        = 0x1000;   // octal   010000
 205         enum O_RSYNC        = O_SYNC;
 206     }
 207     else version (ARM)
 208     {
 209         enum O_CREAT        = 0x40;     // octal     0100
 210         enum O_EXCL         = 0x80;     // octal     0200
 211         enum O_NOCTTY       = 0x100;    // octal     0400
 212         enum O_TRUNC        = 0x200;    // octal    01000
 213
 214         enum O_APPEND       = 0x400;    // octal    02000
 215         enum O_NONBLOCK     = 0x800;    // octal    04000
 216         enum O_SYNC         = 0x101000; // octal 04010000
 217         enum O_DSYNC        = 0x1000;   // octal   010000
 218         enum O_RSYNC        = O_SYNC;
 219     }
 220     else version (AArch64)
 221     {
 222         enum O_CREAT        = 0x40;     // octal     0100
 223         enum O_EXCL         = 0x80;     // octal     0200
 224         enum O_NOCTTY       = 0x100;    // octal     0400
 225         enum O_TRUNC        = 0x200;    // octal    01000
 226
 227         enum O_APPEND       = 0x400;    // octal    02000
 228         enum O_NONBLOCK     = 0x800;    // octal    04000
 229         enum O_SYNC         = 0x101000; // octal 04010000
 230         enum O_DSYNC        = 0x1000;   // octal   010000
 231         enum O_RSYNC        = O_SYNC;
 232     }
 233     else version (SPARC64)
 234     {
 235         enum O_CREAT        = 0x200;
 236         enum O_EXCL         = 0x800;
 237         enum O_NOCTTY       = 0x8000;
 238         enum O_TRUNC        = 0x400;
 239
 240         enum O_APPEND       = 0x8;
 241         enum O_NONBLOCK     = 0x4000;
 242         enum O_SYNC         = 0x802000;
 243         enum O_DSYNC        = 0x2000;
 244         enum O_RSYNC        = O_SYNC;
 245     }
 246     else version (SystemZ)
 247     {
 248         enum O_CREAT        = 0x40;     // octal     0100
 249         enum O_EXCL         = 0x80;     // octal     0200
 250         enum O_NOCTTY       = 0x100;    // octal     0400
 251         enum O_TRUNC        = 0x200;    // octal    01000
 252
 253         enum O_APPEND       = 0x400;    // octal    02000
 254         enum O_NONBLOCK     = 0x800;    // octal    04000
 255         enum O_SYNC         = 0x101000; // octal 04010000
 256         enum O_DSYNC        = 0x1000;   // octal   010000
 257         enum O_RSYNC        = O_SYNC;
 258     }
 259     else
 260         static assert(0, "unimplemented");
 261
 262     enum O_ACCMODE      = 0x3;
 263     enum O_RDONLY       = 0x0;
 264     enum O_WRONLY       = 0x1;
 265     enum O_RDWR         = 0x2;
 266
 267     struct flock
 268     {
 269         short   l_type;
 270         short   l_whence;
 271         off_t   l_start;
 272         off_t   l_len;
 273         pid_t   l_pid;
 274     }
 275
 276     static if ( __USE_FILE_OFFSET64 )
 277     {
 278         int   creat64(in char*, mode_t);
 279         alias creat64 creat;
 280
 281         int   open64(in char*, int, ...);
 282         alias open64 open;
 283     }
 284     else
 285     {
 286         int   creat(in char*, mode_t);
 287         int   open(in char*, int, ...);
 288     }
 289
 290     enum AT_SYMLINK_NOFOLLOW = 0x100;
 291     enum AT_FDCWD = -100;
 292 }
 293 else version (Darwin)
 294 {
 295     enum F_DUPFD        = 0;
 296     enum F_GETFD        = 1;
 297     enum F_SETFD        = 2;
 298     enum F_GETFL        = 3;
 299     enum F_SETFL        = 4;
 300     enum F_GETOWN       = 5;
 301     enum F_SETOWN       = 6;
 302     enum F_GETLK        = 7;
 303     enum F_SETLK        = 8;
 304     enum F_SETLKW       = 9;
 305
 306     enum FD_CLOEXEC     = 1;
 307
 308     enum F_RDLCK        = 1;
 309     enum F_UNLCK        = 2;
 310     enum F_WRLCK        = 3;
 311
 312     enum O_CREAT        = 0x0200;
 313     enum O_EXCL         = 0x0800;
 314     enum O_NOCTTY       = 0;
 315     enum O_TRUNC        = 0x0400;
 316
 317     enum O_RDONLY       = 0x0000;
 318     enum O_WRONLY       = 0x0001;
 319     enum O_RDWR         = 0x0002;
 320     enum O_ACCMODE      = 0x0003;
 321
 322     enum O_NONBLOCK     = 0x0004;
 323     enum O_APPEND       = 0x0008;
 324     enum O_SYNC         = 0x0080;
 325     //enum O_DSYNC
 326     //enum O_RSYNC
 327
 328     struct flock
 329     {
 330         off_t   l_start;
 331         off_t   l_len;
 332         pid_t   l_pid;
 333         short   l_type;
 334         short   l_whence;
 335     }
 336
 337     int creat(in char*, mode_t);
 338     int open(in char*, int, ...);
 339 }
 340 else version (FreeBSD)
 341 {
 342     enum F_DUPFD        = 0;
 343     enum F_GETFD        = 1;
 344     enum F_SETFD        = 2;
 345     enum F_GETFL        = 3;
 346     enum F_SETFL        = 4;
 347     enum F_GETOWN       = 5;
 348     enum F_SETOWN       = 6;
 349     enum F_GETLK        = 11;
 350     enum F_SETLK        = 12;
 351     enum F_SETLKW       = 13;
 352     enum F_OGETLK       = 7;
 353     enum F_OSETLK       = 8;
 354     enum F_OSETLKW      = 9;
 355     enum F_DUP2FD       = 10;
 356
 357     enum FD_CLOEXEC     = 1;
 358
 359     enum F_RDLCK        = 1;
 360     enum F_UNLCK        = 2;
 361     enum F_WRLCK        = 3;
 362
 363     enum O_CREAT        = 0x0200;
 364     enum O_EXCL         = 0x0800;
 365     enum O_NOCTTY       = 0x8000;
 366     enum O_TRUNC        = 0x0400;
 367
 368     enum O_RDONLY       = 0x0000;
 369     enum O_WRONLY       = 0x0001;
 370     enum O_RDWR         = 0x0002;
 371     enum O_ACCMODE      = 0x0003;
 372
 373     enum O_NONBLOCK     = 0x0004;
 374     enum O_APPEND       = 0x0008;
 375     enum O_SYNC         = 0x0080;
 376     //enum O_DSYNC
 377     //enum O_RSYNC
 378
 379     struct flock
 380     {
 381         off_t   l_start;
 382         off_t   l_len;
 383         pid_t   l_pid;
 384         short   l_type;
 385         short   l_whence;
 386         int     l_sysid;
 387     }
 388
 389     struct oflock
 390     {
 391         off_t   l_start;
 392         off_t   l_len;
 393         pid_t   l_pid;
 394         short   l_type;
 395         short   l_whence;
 396     }
 397
 398     int creat(in char*, mode_t);
 399     int open(in char*, int, ...);
 400
 401     enum AT_SYMLINK_NOFOLLOW = 0x200;
 402     enum AT_FDCWD = -100;
 403 }
 404 else version (OpenBSD)
 405 {
 406     enum F_DUPFD        = 0;
 407     enum F_GETFD        = 1;
 408     enum F_SETFD        = 2;
 409     enum F_GETFL        = 3;
 410     enum F_SETFL        = 4;
 411     enum F_GETOWN       = 5;
 412     enum F_SETOWN       = 6;
 413     enum F_GETLK        = 7;
 414     enum F_SETLK        = 8;
 415     enum F_SETLKW       = 9;
 416     enum F_DUPFD_CLOEXEC= 10;
 417     enum F_ISATTY       = 11;
 418
 419     enum FD_CLOEXEC     = 1;
 420
 421     enum F_RDLCK        = 1;
 422     enum F_UNLCK        = 2;
 423     enum F_WRLCK        = 3;
 424
 425     enum O_CREAT        = 0x0200;
 426     enum O_EXCL         = 0x0800;
 427     enum O_NOCTTY       = 0x8000;
 428     enum O_TRUNC        = 0x0400;
 429
 430     enum O_RDONLY       = 0x0000;
 431     enum O_WRONLY       = 0x0001;
 432     enum O_RDWR         = 0x0002;
 433     enum O_ACCMODE      = 0x0003;
 434     enum O_SHLOCK       = 0x0010;
 435     enum O_EXLOCK       = 0x0020;
 436     enum O_ASYNC        = 0x0040;
 437     enum O_FSYNC        = 0x0080;
 438     enum O_NOFOLLOW     = 0x0100;
 439
 440     enum O_NONBLOCK     = 0x0004;
 441     enum O_APPEND       = 0x0008;
 442     enum O_SYNC         = 0x0080;
 443     enum O_DSYNC        = O_SYNC;
 444     enum O_RSYNC        = O_SYNC;
 445
 446     enum O_CLOEXEC      = 0x10000;
 447     enum O_DIRECTORY    = 0x20000;
 448
 449     enum LOCK_SH        = 0x01;
 450     enum LOCK_EX        = 0x02;
 451     enum LOCK_NB        = 0x04;
 452     enum LOCK_UN        = 0x08;
 453
 454     struct flock
 455     {
 456         off_t   l_start;
 457         off_t   l_len;
 458         pid_t   l_pid;
 459         short   l_type;
 460         short   l_whence;
 461     }
 462
 463     int creat(in char*, mode_t);
 464     int open(in char*, int, ...);
 465
 466     enum AT_FDCWD            = -100;
 467
 468     enum AT_EACCESS          = 0x01;
 469     enum AT_SYMLINK_NOFOLLOW = 0x02;
 470     enum AT_SYMLINK_FOLLOW   = 0x04;
 471     enum AT_REMOVEDIR        = 0x08;
 472 }
 473 else version (NetBSD)
 474 {
 475     enum F_DUPFD        = 0;
 476     enum F_GETFD        = 1;
 477     enum F_SETFD        = 2;
 478     enum F_GETFL        = 3;
 479     enum F_SETFL        = 4;
 480     enum F_GETOWN       = 5;
 481     enum F_SETOWN       = 6;
 482     enum F_GETLK        = 7;
 483     enum F_SETLK        = 8;
 484     enum F_SETLKW       = 9;
 485     enum F_CLOSEM       = 10;
 486     enum F_MAXFD        = 11;
 487     enum F_DUPFD_CLOEXEC= 12;
 488     enum F_GETNOSIGPIPE = 13;
 489     enum F_SETNOSIGPIPE = 14;
 490
 491     enum FD_CLOEXEC     = 1;
 492
 493     enum F_RDLCK        = 1;
 494     enum F_UNLCK        = 2;
 495     enum F_WRLCK        = 3;
 496
 497     enum O_CREAT        = 0x0200;
 498     enum O_EXCL         = 0x0800;
 499     enum O_NOCTTY       = 0x8000;
 500     enum O_TRUNC        = 0x0400;
 501
 502     enum O_RDONLY       = 0x0000;
 503     enum O_WRONLY       = 0x0001;
 504     enum O_RDWR         = 0x0002;
 505     enum O_ACCMODE      = 0x0003;
 506
 507     enum O_NONBLOCK     = 0x0004;
 508     enum O_APPEND       = 0x0008;
 509     enum O_SYNC         = 0x0080;
 510     //enum O_DSYNC
 511     //enum O_RSYNC
 512
 513     struct flock
 514     {
 515         off_t   l_start;
 516         off_t   l_len;
 517         pid_t   l_pid;
 518         short   l_type;
 519         short   l_whence;
 520     }
 521
 522
 523     int creat(in char*, mode_t);
 524     int open(in char*, int, ...);
 525 }
 526 else version (DragonFlyBSD)
 527 {
 528     enum O_RDONLY       = 0x0000;
 529     enum O_WRONLY       = 0x0001;
 530     enum O_RDWR         = 0x0002;
 531     enum O_ACCMODE      = 0x0003;
 532
 533     enum FREAD          = 0x0001;
 534     enum FWRITE         = 0x0002;
 535     enum O_NONBLOCK     = 0x0000004;
 536     enum O_APPEND       = 0x0000008;
 537     enum O_SHLOCK       = 0x0000010;
 538     enum O_EXLOCK       = 0x0000020;
 539     enum O_ASYNC        = 0x0000040;
 540     enum O_FSYNC        = 0x0000080;
 541     enum O_SYNC         = 0x0000080;
 542     enum O_NOFOLLOW     = 0x0000100;
 543     enum O_CREAT        = 0x0000200;
 544     enum O_TRUNC        = 0x0000400;
 545     enum O_EXCL         = 0x0000800;
 546     enum O_NOCTTY       = 0x0008000;
 547     enum O_DIRECT       = 0x0010000;
 548     enum O_CLOEXEC      = 0x0020000;
 549     enum O_FBLOCKING    = 0x0040000;
 550     enum O_FNONBLOCKING = 0x0080000;
 551     enum O_FAPPEND      = 0x0100000;
 552     enum O_FOFFSET      = 0x0200000;
 553     enum O_FSYNCWRITE   = 0x0400000;
 554     enum O_FASYNCWRITE  = 0x0800000;
 555     enum O_DIRECTORY    = 0x8000000;
 556
 557     enum FAPPEND        = O_APPEND;
 558     enum FASYNC         = O_ASYNC;
 559     enum FFSYNC         = O_FSYNC;
 560     enum FNONBLOCK      = O_NONBLOCK;
 561     enum FNDELAY        = O_NONBLOCK;
 562     enum O_NDELAY       = O_NONBLOCK;
 563     enum FPOSIXSHM      = O_NOFOLLOW;
 564
 565     enum FCNTLFLAGS = (FAPPEND|FASYNC|FFSYNC|FNONBLOCK|FPOSIXSHM|O_DIRECT);
 566
 567     enum F_DUPFD        = 0;
 568     enum F_GETFD        = 1;
 569     enum F_SETFD        = 2;
 570     enum F_GETFL        = 3;
 571     enum F_SETFL        = 4;
 572     enum F_GETOWN       = 5;
 573     enum F_SETOWN       = 6;
 574     enum F_GETLK        = 7;
 575 //    enum F_SETLK        = 8;
 576     enum F_SETLK        = 8;
 577     enum F_SETLKW       = 9;
 578     enum F_OGETLK       = F_GETLK;
 579     enum F_OSETLK       = F_SETLK;
 580     enum F_OSETLKW      = F_SETLKW;
 581     enum F_DUP2FD       = 10;
 582     //enum F_GETLK        = 11;
 583     //enum F_SETLK        = 12;
 584     //enum F_SETLKW       = 13;
 585     enum F_DUPFD_CLOEXEC = 17;
 586     enum F_DUP2FD_CLOEXEC = 18;
 587
 588     enum FD_CLOEXEC     = 1;
 589
 590     enum F_RDLCK        = 1;
 591     enum F_UNLCK        = 2;
 592     enum F_WRLCK        = 3;
 593
 594     enum LOCK_SH        = 0x01;
 595     enum LOCK_EX        = 0x02;
 596     enum LOCK_NB        = 0x04;
 597     enum LOCK_UN        = 0x08;
 598
 599     struct flock
 600     {
 601         off_t   l_start;
 602         off_t   l_len;
 603         pid_t   l_pid;
 604         short   l_type;
 605         short   l_whence;
 606     }
 607
 608     alias oflock = flock;
 609
 610     int creat(in char*, mode_t);
 611     int open(in char*, int, ...);
 612     //int fcntl(int, int, ...);  /*defined below*/
 613     //int flock(int, int);
 614 }
 615 else version (Solaris)
 616 {
 617     enum F_DUPFD = 0;
 618     enum F_GETFD = 1;
 619     enum F_SETFD = 2;
 620     enum F_GETFL = 3;
 621     enum F_SETFL = 4;
 622
 623     version (D_LP64)
 624     {
 625         enum F_GETLK = 14;
 626         enum F_SETLK = 6;
 627         enum F_SETLKW = 7;
 628     }
 629     else
 630     {
 631         static if (__USE_FILE_OFFSET64)
 632         {
 633             enum F_GETLK = 14;
 634             enum F_SETLK = 6;
 635             enum F_SETLKW = 7;
 636         }
 637         else
 638         {
 639             enum F_GETLK = 33;
 640             enum F_SETLK = 34;
 641             enum F_SETLKW = 35;
 642         }
 643     }
 644
 645     enum F_GETOWN = 23;
 646     enum F_SETOWN = 24;
 647
 648     enum FD_CLOEXEC = 1;
 649
 650     enum F_RDLCK = 1;
 651     enum F_UNLCK = 3;
 652     enum F_WRLCK = 2;
 653     enum F_UNCKSYS = 4;
 654
 655     enum O_CREAT = 0x0100;
 656     enum O_EXCL = 0x0400;
 657     enum O_NOCTTY = 0x0800;
 658     enum O_TRUNC = 0x0200;
 659
 660     enum O_APPEND = 0x0008;
 661     enum O_NONBLOCK = 0x0080;
 662     enum O_SYNC = 0x0010;
 663     enum O_DSYNC = 0x0040;
 664     enum O_RSYNC = 0x8000;
 665
 666     enum O_ACCMODE = (O_SEARCH | O_EXEC | 0x3);
 667     enum O_RDONLY = 0;
 668     enum O_WRONLY = 1;
 669     enum O_RDWR = 2;
 670     enum O_SEARCH = 0x200000;
 671     enum O_EXEC = 0x400000;
 672
 673     struct flock
 674     {
 675         short l_type;
 676         short l_whence;
 677         off_t l_start;
 678         off_t l_len;
 679         int l_sysid;
 680         pid_t l_pid;
 681         c_long[4] l_pad;
 682     }
 683
 684     static if (__USE_LARGEFILE64)
 685     {
 686         struct flock64
 687         {
 688             short       l_type;
 689             short       l_whence;
 690             off64_t     l_start;
 691             off64_t     l_len;
 692             int         l_sysid;
 693             pid_t       l_pid;
 694             c_long[4]   l_pad;
 695         }
 696     }
 697
 698     version (D_LP64)
 699     {
 700         int creat(in char*, mode_t);
 701         int open(in char*, int, ...);
 702
 703         static if (__USE_LARGEFILE64)
 704         {
 705             alias creat creat64;
 706             alias open open64;
 707         }
 708     }
 709     else
 710     {
 711         static if (__USE_LARGEFILE64)
 712         {
 713             int creat64(in char*, mode_t);
 714             alias creat64 creat;
 715
 716             int open64(in char*, int, ...);
 717             alias open64 open;
 718         }
 719         else
 720         {
 721             int creat(in char*, mode_t);
 722             int open(in char*, int, ...);
 723         }
 724     }
 725 }
 726 else version (CRuntime_Bionic)
 727 {
 728     // All these except for the two functions open and creat really come from
 729     // the linux kernel and can probably be merged.
 730     enum F_DUPFD        = 0;
 731     enum F_GETFD        = 1;
 732     enum F_SETFD        = 2;
 733     enum F_GETFL        = 3;
 734     enum F_SETFL        = 4;
 735     enum F_GETLK        = 5;
 736     enum F_SETLK        = 6;
 737     enum F_SETLKW       = 7;
 738     enum F_SETOWN       = 8;
 739     enum F_GETOWN       = 9;
 740
 741     enum FD_CLOEXEC     = 1;
 742
 743     enum F_RDLCK        = 0;
 744     enum F_WRLCK        = 1;
 745     enum F_UNLCK        = 2;
 746
 747     version (X86)
 748     {
 749         enum O_CREAT        = 0x40;     // octal     0100
 750         enum O_EXCL         = 0x80;     // octal     0200
 751         enum O_NOCTTY       = 0x100;    // octal     0400
 752         enum O_TRUNC        = 0x200;    // octal    01000
 753
 754         enum O_APPEND       = 0x400;    // octal    02000
 755         enum O_NONBLOCK     = 0x800;    // octal    04000
 756         enum O_SYNC         = 0x1000;   // octal   010000
 757     }
 758     else version (ARM)
 759     {
 760         enum O_CREAT        = 0x40;     // octal     0100
 761         enum O_EXCL         = 0x80;     // octal     0200
 762         enum O_NOCTTY       = 0x100;    // octal     0400
 763         enum O_TRUNC        = 0x200;    // octal    01000
 764
 765         enum O_APPEND       = 0x400;    // octal    02000
 766         enum O_NONBLOCK     = 0x800;    // octal    04000
 767         enum O_SYNC         = 0x1000;   // octal   010000
 768     }
 769     else version (AArch64)
 770     {
 771         enum O_CREAT        = 0x40;     // octal     0100
 772         enum O_EXCL         = 0x80;     // octal     0200
 773         enum O_NOCTTY       = 0x100;    // octal     0400
 774         enum O_TRUNC        = 0x200;    // octal    01000
 775
 776         enum O_APPEND       = 0x400;    // octal    02000
 777         enum O_NONBLOCK     = 0x800;    // octal    04000
 778         enum O_SYNC         = 0x101000; // octal 04010000
 779     }
 780     else
 781     {
 782         static assert(false, "Architecture not supported.");
 783     }
 784
 785     enum O_ACCMODE      = 0x3;
 786     enum O_RDONLY       = 0x0;
 787     enum O_WRONLY       = 0x1;
 788     enum O_RDWR         = 0x2;
 789
 790     struct flock
 791     {
 792         short   l_type;
 793         short   l_whence;
 794         off_t   l_start;
 795         off_t   l_len;
 796         pid_t   l_pid;
 797     }
 798
 799     int   creat(in char*, mode_t);
 800     int   open(in char*, int, ...);
 801
 802     enum AT_FDCWD = -100;
 803 }
 804 else version (CRuntime_Musl)
 805 {
 806     enum {
 807         O_CREAT         = 0x40,     // octal     0100
 808         O_EXCL          = 0x80,     // octal     0200
 809         O_NOCTTY        = 0x100,    // octal     0400
 810         O_TRUNC         = 0x200,    // octal    01000
 811
 812         O_APPEND        = 0x400,    // octal    02000
 813         O_NONBLOCK      = 0x800,    // octal    04000
 814         O_DSYNC         = 0x1000,   // octal   010000
 815         O_SYNC          = 0x101000, // octal 04010000
 816         O_RSYNC         = O_SYNC,
 817         O_DIRECTORY     = 0x10000,
 818         O_NOFOLLOW      = 0x20000,
 819         O_CLOEXEC       = 0x80000,
 820
 821         O_ASYNC         = 0x2000,
 822         O_DIRECT        = 0x4000,
 823         O_LARGEFILE     =      0,
 824         O_NOATIME       = 0x40000,
 825         O_PATH          = 0x200000,
 826         O_TMPFILE       = 0x410000,
 827         O_NDELAY        = O_NONBLOCK,
 828         O_SEARCH        = O_PATH,
 829         O_EXEC          = O_PATH,
 830
 831         O_ACCMODE       = (03|O_SEARCH),
 832         O_RDONLY        = 00,
 833         O_WRONLY        = 01,
 834         O_RDWR          = 02,
 835     }
 836     enum {
 837         F_DUPFD        = 0,
 838         F_GETFD        = 1,
 839         F_SETFD        = 2,
 840         F_GETFL        = 3,
 841         F_SETFL        = 4,
 842         F_GETLK        = 5,
 843         F_SETLK        = 6,
 844         F_SETLKW       = 7,
 845         F_SETOWN       = 8,
 846         F_GETOWN       = 9,
 847     }
 848     enum {
 849         F_RDLCK        = 0,
 850         F_WRLCK        = 1,
 851         F_UNLCK        = 2,
 852     }
 853     struct flock
 854     {
 855         short   l_type;
 856         short   l_whence;
 857         off_t   l_start;
 858         off_t   l_len;
 859         pid_t   l_pid;
 860     }
 861     enum FD_CLOEXEC     = 1;
 862     int open(in char*, int, ...);
 863
 864     enum AT_FDCWD = -100;
 865 }
 866 else version (CRuntime_UClibc)
 867 {
 868     enum F_DUPFD        = 0;
 869     enum F_GETFD        = 1;
 870     enum F_SETFD        = 2;
 871     enum F_GETFL        = 3;
 872     enum F_SETFL        = 4;
 873
 874     version (X86_64)
 875     {
 876         enum F_GETLK        = 5;
 877         enum F_SETLK        = 6;
 878         enum F_SETLKW       = 7;
 879     }
 880     else static if (__USE_FILE_OFFSET64)
 881     {
 882         enum F_GETLK        = 5;
 883         enum F_SETLK        = 6;
 884         enum F_SETLKW       = 7;
 885     }
 886     else
 887     {
 888         enum F_GETLK        = 12;
 889         enum F_SETLK        = 13;
 890         enum F_SETLKW       = 14;
 891     }
 892
 893     enum F_GETOWN       = 9;
 894     enum F_SETOWN       = 8;
 895
 896     enum FD_CLOEXEC     = 1;
 897
 898     enum F_RDLCK        = 0;
 899     enum F_UNLCK        = 2;
 900     enum F_WRLCK        = 1;
 901
 902     version (X86_64)
 903     {
 904         enum O_CREAT        = 0x40;     // octal     0100
 905         enum O_EXCL         = 0x80;     // octal     0200
 906         enum O_NOCTTY       = 0x100;    // octal     0400
 907         enum O_TRUNC        = 0x200;    // octal    01000
 908
 909         enum O_APPEND       = 0x400;    // octal    02000
 910         enum O_NONBLOCK     = 0x800;    // octal    04000
 911         enum O_SYNC         = 0x1000;   // octal    010000
 912         enum O_NDELAY       = O_NONBLOCK;
 913         enum O_FSYNC        = O_SYNC;
 914         enum O_ASYNC        = 0x2000;   // octal    020000
 915     }
 916     else version (MIPS32)
 917     {
 918         enum O_CREAT        = 0x0100;
 919         enum O_EXCL         = 0x0400;
 920         enum O_NOCTTY       = 0x0800;
 921         enum O_TRUNC        = 0x0200;
 922
 923         enum O_APPEND       = 0x0008;
 924         enum O_SYNC         = 0x0010;
 925         enum O_NONBLOCK     = 0x0080;
 926         enum O_NDELAY       = O_NONBLOCK;
 927         enum O_FSYNC        = O_SYNC;
 928         enum O_ASYNC        = 0x1000;
 929     }
 930     else version (ARM)
 931     {
 932         enum O_CREAT        = 0x40;     // octal     0100
 933         enum O_EXCL         = 0x80;     // octal     0200
 934         enum O_NOCTTY       = 0x100;    // octal     0400
 935         enum O_TRUNC        = 0x200;    // octal    01000
 936
 937         enum O_APPEND       = 0x400;    // octal    02000
 938         enum O_NONBLOCK     = 0x800;    // octal    04000
 939         enum O_SYNC         = 0x1000;   // octal    010000
 940         enum O_NDELAY       = O_NONBLOCK;
 941         enum O_FSYNC        = O_SYNC;
 942         enum O_ASYNC        = 0x2000;     // octal 020000
 943     }
 944     else
 945         static assert(0, "unimplemented");
 946
 947     enum O_ACCMODE      = 0x3;
 948     enum O_RDONLY       = 0x0;
 949     enum O_WRONLY       = 0x1;
 950     enum O_RDWR         = 0x2;
 951
 952     struct flock
 953     {
 954         short   l_type;
 955         short   l_whence;
 956         static if (__USE_FILE_OFFSET64)
 957         {
 958             off64_t   l_start;
 959             off64_t   l_len;
 960         }
 961         else
 962         {
 963             off_t   l_start;
 964             off_t   l_len;
 965         }
 966         pid_t   l_pid;
 967     }
 968
 969     static if ( __USE_FILE_OFFSET64 )
 970     {
 971         int   creat64(in char*, mode_t);
 972         alias creat64 creat;
 973
 974         int   open64(in char*, int, ...);
 975         alias open64 open;
 976     }
 977     else
 978     {
 979         int   creat(in char*, mode_t);
 980         int   open(in char*, int, ...);
 981     }
 982
 983     enum AT_SYMLINK_NOFOLLOW    = 0x100;
 984     enum AT_FDCWD               = -100;
 985 }
 986 else
 987 {
 988     static assert(false, "Unsupported platform");
 989 }
 990
 991 //int creat(in char*, mode_t);
 992 int fcntl(int, int, ...);
 993 //int open(in char*, int, ...);
 994
 995 // Generic Posix fallocate
 996 int posix_fallocate(int, off_t, off_t);
 997
 998 //
 999 // Advisory Information (ADV)
1000 //
1001 /*
1002 POSIX_FADV_NORMAL
1003 POSIX_FADV_SEQUENTIAL
1004 POSIX_FADV_RANDOM
1005 POSIX_FADV_WILLNEED
1006 POSIX_FADV_DONTNEED
1007 POSIX_FADV_NOREUSE
1008
1009 int posix_fadvise(int, off_t, off_t, int);
1010 */