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