| 1 | 
         1325 | 
         phoenix | 
         /* Copyright (C) 1991,92,94,95,96,97,98,99,2000,2001 Free Software Foundation, Inc.
  | 
      
      
         | 2 | 
          | 
          | 
            This file is part of the GNU C Library.
  | 
      
      
         | 3 | 
          | 
          | 
          
  | 
      
      
         | 4 | 
          | 
          | 
            The GNU C Library is free software; you can redistribute it and/or
  | 
      
      
         | 5 | 
          | 
          | 
            modify it under the terms of the GNU Lesser General Public
  | 
      
      
         | 6 | 
          | 
          | 
            License as published by the Free Software Foundation; either
  | 
      
      
         | 7 | 
          | 
          | 
            version 2.1 of the License, or (at your option) any later version.
  | 
      
      
         | 8 | 
          | 
          | 
          
  | 
      
      
         | 9 | 
          | 
          | 
            The GNU C Library is distributed in the hope that it will be useful,
  | 
      
      
         | 10 | 
          | 
          | 
            but WITHOUT ANY WARRANTY; without even the implied warranty of
  | 
      
      
         | 11 | 
          | 
          | 
            MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  | 
      
      
         | 12 | 
          | 
          | 
            Lesser General Public License for more details.
  | 
      
      
         | 13 | 
          | 
          | 
          
  | 
      
      
         | 14 | 
          | 
          | 
            You should have received a copy of the GNU Lesser General Public
  | 
      
      
         | 15 | 
          | 
          | 
            License along with the GNU C Library; if not, write to the Free
  | 
      
      
         | 16 | 
          | 
          | 
            Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  | 
      
      
         | 17 | 
          | 
          | 
            02111-1307 USA.  */
  | 
      
      
         | 18 | 
          | 
          | 
          
  | 
      
      
         | 19 | 
          | 
          | 
         /*
  | 
      
      
         | 20 | 
          | 
          | 
          *      POSIX Standard: 6.5 File Control Operations     <fcntl.h>
  | 
      
      
         | 21 | 
          | 
          | 
          */
  | 
      
      
         | 22 | 
          | 
          | 
          
  | 
      
      
         | 23 | 
          | 
          | 
         #ifndef _FCNTL_H
  | 
      
      
         | 24 | 
          | 
          | 
         #define _FCNTL_H        1
  | 
      
      
         | 25 | 
          | 
          | 
          
  | 
      
      
         | 26 | 
          | 
          | 
         #include <features.h>
  | 
      
      
         | 27 | 
          | 
          | 
          
  | 
      
      
         | 28 | 
          | 
          | 
         /* This must be early so <bits/fcntl.h> can define types winningly.  */
  | 
      
      
         | 29 | 
          | 
          | 
         __BEGIN_DECLS
  | 
      
      
         | 30 | 
          | 
          | 
          
  | 
      
      
         | 31 | 
          | 
          | 
         /* Get the definitions of O_*, F_*, FD_*: all the
  | 
      
      
         | 32 | 
          | 
          | 
            numbers and flag bits for `open', `fcntl', et al.  */
  | 
      
      
         | 33 | 
          | 
          | 
         #include <bits/fcntl.h>
  | 
      
      
         | 34 | 
          | 
          | 
          
  | 
      
      
         | 35 | 
          | 
          | 
         /* For XPG all symbols from <sys/stat.h> should also be available.  */
  | 
      
      
         | 36 | 
          | 
          | 
         #ifdef __USE_XOPEN
  | 
      
      
         | 37 | 
          | 
          | 
         # include <sys/stat.h>
  | 
      
      
         | 38 | 
          | 
          | 
         #endif
  | 
      
      
         | 39 | 
          | 
          | 
          
  | 
      
      
         | 40 | 
          | 
          | 
         #ifdef  __USE_MISC
  | 
      
      
         | 41 | 
          | 
          | 
         # ifndef R_OK                   /* Verbatim from <unistd.h>.  Ugh.  */
  | 
      
      
         | 42 | 
          | 
          | 
         /* Values for the second argument to access.
  | 
      
      
         | 43 | 
          | 
          | 
            These may be OR'd together.  */
  | 
      
      
         | 44 | 
          | 
          | 
         #  define R_OK  4               /* Test for read permission.  */
  | 
      
      
         | 45 | 
          | 
          | 
         #  define W_OK  2               /* Test for write permission.  */
  | 
      
      
         | 46 | 
          | 
          | 
         #  define X_OK  1               /* Test for execute permission.  */
  | 
      
      
         | 47 | 
          | 
          | 
         #  define F_OK  0                /* Test for existence.  */
  | 
      
      
         | 48 | 
          | 
          | 
         # endif
  | 
      
      
         | 49 | 
          | 
          | 
         #endif /* Use misc.  */
  | 
      
      
         | 50 | 
          | 
          | 
          
  | 
      
      
         | 51 | 
          | 
          | 
         /* XPG wants the following symbols.  */
  | 
      
      
         | 52 | 
          | 
          | 
         #ifdef __USE_XOPEN              /* <stdio.h> has the same definitions.  */
  | 
      
      
         | 53 | 
          | 
          | 
         # define SEEK_SET       0        /* Seek from beginning of file.  */
  | 
      
      
         | 54 | 
          | 
          | 
         # define SEEK_CUR       1       /* Seek from current position.  */
  | 
      
      
         | 55 | 
          | 
          | 
         # define SEEK_END       2       /* Seek from end of file.  */
  | 
      
      
         | 56 | 
          | 
          | 
         #endif  /* XPG */
  | 
      
      
         | 57 | 
          | 
          | 
          
  | 
      
      
         | 58 | 
          | 
          | 
         /* Do the file control operation described by CMD on FD.
  | 
      
      
         | 59 | 
          | 
          | 
            The remaining arguments are interpreted depending on CMD.  */
  | 
      
      
         | 60 | 
          | 
          | 
         #ifndef __USE_FILE_OFFSET64
  | 
      
      
         | 61 | 
          | 
          | 
         extern int fcntl (int __fd, int __cmd, ...) __THROW;
  | 
      
      
         | 62 | 
          | 
          | 
         #else
  | 
      
      
         | 63 | 
          | 
          | 
         # ifdef __REDIRECT
  | 
      
      
         | 64 | 
          | 
          | 
         extern int __REDIRECT (fcntl, (int __fd, int __cmd, ...) __THROW,
  | 
      
      
         | 65 | 
          | 
          | 
                                fcntl64);
  | 
      
      
         | 66 | 
          | 
          | 
         # else
  | 
      
      
         | 67 | 
          | 
          | 
         #  define fcntl fcntl64
  | 
      
      
         | 68 | 
          | 
          | 
         # endif
  | 
      
      
         | 69 | 
          | 
          | 
         #endif
  | 
      
      
         | 70 | 
          | 
          | 
          
  | 
      
      
         | 71 | 
          | 
          | 
         /* Open FILE and return a new file descriptor for it, or -1 on error.
  | 
      
      
         | 72 | 
          | 
          | 
            OFLAG determines the type of access used.  If O_CREAT is on OFLAG,
  | 
      
      
         | 73 | 
          | 
          | 
            the third argument is taken as a `mode_t', the mode of the created file.  */
  | 
      
      
         | 74 | 
          | 
          | 
         #ifndef __USE_FILE_OFFSET64
  | 
      
      
         | 75 | 
          | 
          | 
         extern int open (__const char *__file, int __oflag, ...) __THROW;
  | 
      
      
         | 76 | 
          | 
          | 
         #else
  | 
      
      
         | 77 | 
          | 
          | 
         # ifdef __REDIRECT
  | 
      
      
         | 78 | 
          | 
          | 
         extern int __REDIRECT (open, (__const char *__file, int __oflag, ...) __THROW,
  | 
      
      
         | 79 | 
          | 
          | 
                                open64);
  | 
      
      
         | 80 | 
          | 
          | 
         # else
  | 
      
      
         | 81 | 
          | 
          | 
         #  define open open64
  | 
      
      
         | 82 | 
          | 
          | 
         # endif
  | 
      
      
         | 83 | 
          | 
          | 
         #endif
  | 
      
      
         | 84 | 
          | 
          | 
         #ifdef __USE_LARGEFILE64
  | 
      
      
         | 85 | 
          | 
          | 
         extern int open64 (__const char *__file, int __oflag, ...) __THROW;
  | 
      
      
         | 86 | 
          | 
          | 
         #endif
  | 
      
      
         | 87 | 
          | 
          | 
          
  | 
      
      
         | 88 | 
          | 
          | 
         /* Create and open FILE, with mode MODE.
  | 
      
      
         | 89 | 
          | 
          | 
            This takes an `int' MODE argument because that is
  | 
      
      
         | 90 | 
          | 
          | 
            what `mode_t' will be widened to.  */
  | 
      
      
         | 91 | 
          | 
          | 
         #ifndef __USE_FILE_OFFSET64
  | 
      
      
         | 92 | 
          | 
          | 
         extern int creat (__const char *__file, __mode_t __mode) __THROW;
  | 
      
      
         | 93 | 
          | 
          | 
         #else
  | 
      
      
         | 94 | 
          | 
          | 
         # ifdef __REDIRECT
  | 
      
      
         | 95 | 
          | 
          | 
         extern int __REDIRECT (creat, (__const char *__file, __mode_t __mode) __THROW,
  | 
      
      
         | 96 | 
          | 
          | 
                                creat64);
  | 
      
      
         | 97 | 
          | 
          | 
         # else
  | 
      
      
         | 98 | 
          | 
          | 
         #  define creat creat64
  | 
      
      
         | 99 | 
          | 
          | 
         # endif
  | 
      
      
         | 100 | 
          | 
          | 
         #endif
  | 
      
      
         | 101 | 
          | 
          | 
         #ifdef __USE_LARGEFILE64
  | 
      
      
         | 102 | 
          | 
          | 
         extern int creat64 (__const char *__file, __mode_t __mode) __THROW;
  | 
      
      
         | 103 | 
          | 
          | 
         #endif
  | 
      
      
         | 104 | 
          | 
          | 
          
  | 
      
      
         | 105 | 
          | 
          | 
         #if !defined F_LOCK && (defined __USE_MISC || (defined __USE_XOPEN_EXTENDED \
  | 
      
      
         | 106 | 
          | 
          | 
                                                        && !defined __USE_POSIX))
  | 
      
      
         | 107 | 
          | 
          | 
         /* NOTE: These declarations also appear in <unistd.h>; be sure to keep both
  | 
      
      
         | 108 | 
          | 
          | 
            files consistent.  Some systems have them there and some here, and some
  | 
      
      
         | 109 | 
          | 
          | 
            software depends on the macros being defined without including both.  */
  | 
      
      
         | 110 | 
          | 
          | 
          
  | 
      
      
         | 111 | 
          | 
          | 
         /* `lockf' is a simpler interface to the locking facilities of `fcntl'.
  | 
      
      
         | 112 | 
          | 
          | 
            LEN is always relative to the current file position.
  | 
      
      
         | 113 | 
          | 
          | 
            The CMD argument is one of the following.  */
  | 
      
      
         | 114 | 
          | 
          | 
          
  | 
      
      
         | 115 | 
          | 
          | 
         # define F_ULOCK 0      /* Unlock a previously locked region.  */
  | 
      
      
         | 116 | 
          | 
          | 
         # define F_LOCK  1      /* Lock a region for exclusive use.  */
  | 
      
      
         | 117 | 
          | 
          | 
         # define F_TLOCK 2      /* Test and lock a region for exclusive use.  */
  | 
      
      
         | 118 | 
          | 
          | 
         # define F_TEST  3      /* Test a region for other processes locks.  */
  | 
      
      
         | 119 | 
          | 
          | 
          
  | 
      
      
         | 120 | 
          | 
          | 
         # ifndef __USE_FILE_OFFSET64
  | 
      
      
         | 121 | 
          | 
          | 
         extern int lockf (int __fd, int __cmd, __off_t __len) __THROW;
  | 
      
      
         | 122 | 
          | 
          | 
         # else
  | 
      
      
         | 123 | 
          | 
          | 
         # ifdef __REDIRECT
  | 
      
      
         | 124 | 
          | 
          | 
         extern int __REDIRECT (lockf, (int __fd, int __cmd, __off64_t __len) __THROW,
  | 
      
      
         | 125 | 
          | 
          | 
                                lockf64);
  | 
      
      
         | 126 | 
          | 
          | 
         # else
  | 
      
      
         | 127 | 
          | 
          | 
         #  define lockf lockf64
  | 
      
      
         | 128 | 
          | 
          | 
         # endif
  | 
      
      
         | 129 | 
          | 
          | 
         # endif
  | 
      
      
         | 130 | 
          | 
          | 
         # ifdef __USE_LARGEFILE64
  | 
      
      
         | 131 | 
          | 
          | 
         extern int lockf64 (int __fd, int __cmd, __off64_t __len) __THROW;
  | 
      
      
         | 132 | 
          | 
          | 
         # endif
  | 
      
      
         | 133 | 
          | 
          | 
         #endif
  | 
      
      
         | 134 | 
          | 
          | 
          
  | 
      
      
         | 135 | 
          | 
          | 
         #ifdef __USE_XOPEN2K
  | 
      
      
         | 136 | 
          | 
          | 
         /* Advice the system about the expected behaviour of the application with
  | 
      
      
         | 137 | 
          | 
          | 
            respect to the file associated with FD.  */
  | 
      
      
         | 138 | 
          | 
          | 
         # ifndef __USE_FILE_OFFSET64
  | 
      
      
         | 139 | 
          | 
          | 
         extern int posix_fadvise (int __fd, __off_t __offset, size_t __len,
  | 
      
      
         | 140 | 
          | 
          | 
                                   int __advise) __THROW;
  | 
      
      
         | 141 | 
          | 
          | 
         # else
  | 
      
      
         | 142 | 
          | 
          | 
         # ifdef __REDIRECT
  | 
      
      
         | 143 | 
          | 
          | 
         extern int __REDIRECT (posix_fadvise, (int __fd, __off64_t __offset,
  | 
      
      
         | 144 | 
          | 
          | 
                                                size_t __len, int __advise) __THROW,
  | 
      
      
         | 145 | 
          | 
          | 
                                posix_fadvise64);
  | 
      
      
         | 146 | 
          | 
          | 
         # else
  | 
      
      
         | 147 | 
          | 
          | 
         #  define posix_fadvise posix_fadvise64
  | 
      
      
         | 148 | 
          | 
          | 
         # endif
  | 
      
      
         | 149 | 
          | 
          | 
         # endif
  | 
      
      
         | 150 | 
          | 
          | 
         # ifdef __USE_LARGEFILE64
  | 
      
      
         | 151 | 
          | 
          | 
         extern int posix_fadvise64 (int __fd, __off64_t __offset, size_t __len,
  | 
      
      
         | 152 | 
          | 
          | 
                                     int __advise) __THROW;
  | 
      
      
         | 153 | 
          | 
          | 
         # endif
  | 
      
      
         | 154 | 
          | 
          | 
          
  | 
      
      
         | 155 | 
          | 
          | 
          
  | 
      
      
         | 156 | 
          | 
          | 
         /* Reserve storage for the data of the file associated with FD.  */
  | 
      
      
         | 157 | 
          | 
          | 
         # ifndef __USE_FILE_OFFSET64
  | 
      
      
         | 158 | 
          | 
          | 
         extern int posix_fallocate (int __fd, __off_t __offset, size_t __len) __THROW;
  | 
      
      
         | 159 | 
          | 
          | 
         # else
  | 
      
      
         | 160 | 
          | 
          | 
         # ifdef __REDIRECT
  | 
      
      
         | 161 | 
          | 
          | 
         extern int __REDIRECT (posix_fallocate, (int __fd, __off64_t __offset,
  | 
      
      
         | 162 | 
          | 
          | 
                                                  size_t __len) __THROW,
  | 
      
      
         | 163 | 
          | 
          | 
                                posix_fallocate64);
  | 
      
      
         | 164 | 
          | 
          | 
         # else
  | 
      
      
         | 165 | 
          | 
          | 
         #  define posix_fallocate posix_fallocate64
  | 
      
      
         | 166 | 
          | 
          | 
         # endif
  | 
      
      
         | 167 | 
          | 
          | 
         # endif
  | 
      
      
         | 168 | 
          | 
          | 
         # ifdef __USE_LARGEFILE64
  | 
      
      
         | 169 | 
          | 
          | 
         extern int posix_fallocate64 (int __fd, __off64_t __offset, size_t __len)
  | 
      
      
         | 170 | 
          | 
          | 
              __THROW;
  | 
      
      
         | 171 | 
          | 
          | 
         # endif
  | 
      
      
         | 172 | 
          | 
          | 
         #endif
  | 
      
      
         | 173 | 
          | 
          | 
          
  | 
      
      
         | 174 | 
          | 
          | 
         __END_DECLS
  | 
      
      
         | 175 | 
          | 
          | 
          
  | 
      
      
         | 176 | 
          | 
          | 
         #endif /* fcntl.h  */
  |