support/fcntl.c

   1 /*
   2  * <fcntl.h> wrapper functions.
   3  *
   4  * Authors:
   5  *   Jonathan Pryor (jonpryor@vt.edu)
   6  *
   7  * Copyright (C) 2004 Jonathan Pryor
   8  */
   9
  10 #ifndef _GNU_SOURCE
  11 #define _GNU_SOURCE
  12 #endif
  13
  14 #include <sys/types.h>
  15 #include <sys/stat.h>
  16 #include <unistd.h>
  17 #include <fcntl.h>
  18 #include <errno.h>
  19
  20 #include "map.h"
  21 #include "mph.h"
  22
  23 G_BEGIN_DECLS
  24
  25 struct Mono_Posix_Flock {
  26         gint16    l_type;
  27         gint16    l_whence;
  28         mph_off_t l_start;
  29         mph_off_t l_len;
  30         mph_pid_t l_pid;
  31 };
  32
  33 gint32
  34 Mono_Posix_Syscall_fcntl (gint32 fd, gint32 cmd)
  35 {
  36         if (Mono_Posix_FromFcntlCommand (cmd, &cmd) == -1)
  37                 return -1;
  38         return fcntl (fd, cmd);
  39 }
  40
  41 gint32
  42 Mono_Posix_Syscall_fcntl_arg (gint32 fd, gint32 cmd, gint64 arg)
  43 {
  44         long _arg;
  45         gint32 _cmd;
  46
  47         mph_return_if_long_overflow (arg);
  48
  49 #ifdef F_NOTIFY
  50         if (cmd == F_NOTIFY) {
  51                 int _argi;
  52                 if (Mono_Posix_FromDirectoryNotifyFlags (arg, &_argi) == -1) {
  53                         return -1;
  54                 }
  55                 _arg = _argi;
  56         }
  57         else
  58 #endif
  59                 _arg = (long) arg;
  60
  61         if (Mono_Posix_FromFcntlCommand (cmd, &_cmd) == -1)
  62                 return -1;
  63         return fcntl (fd, cmd, _arg);
  64 }
  65
  66 gint32
  67 Mono_Posix_Syscall_fcntl_lock (gint32 fd, gint32 cmd, struct Mono_Posix_Flock *lock)
  68 {
  69 #ifdef MPH_USE_64_API
  70         struct flock64 _lock;
  71 #else
  72         struct flock _lock;
  73 #endif
  74         int r;
  75
  76         if (lock == NULL) {
  77                 errno = EFAULT;
  78                 return -1;
  79         }
  80
  81         mph_return_if_off_t_overflow (lock->l_start);
  82         mph_return_if_off_t_overflow (lock->l_len);
  83
  84         if (Mono_Posix_FromLockType (lock->l_type, &lock->l_type) == -1)
  85                 return -1;
  86         _lock.l_type   = lock->l_type;
  87         _lock.l_whence = lock->l_whence;
  88         _lock.l_start  = lock->l_start;
  89         _lock.l_len    = lock->l_len;
  90         _lock.l_pid    = lock->l_pid;
  91
  92         r = fcntl (fd, cmd, &_lock);
  93
  94         if (Mono_Posix_ToLockType (_lock.l_type, &_lock.l_type) == -1)
  95                 r = -1;
  96         lock->l_type   = _lock.l_type;
  97         lock->l_whence = _lock.l_whence;
  98         lock->l_start  = _lock.l_start;
  99         lock->l_len    = _lock.l_len;
 100         lock->l_pid    = _lock.l_pid;
 101
 102         return r;
 103 }
 104
 105 gint32
 106 Mono_Posix_Syscall_open (const char *pathname, gint32 flags)
 107 {
 108         if (Mono_Posix_FromOpenFlags (flags, &flags) == -1)
 109                 return -1;
 110 #ifdef MPH_USE_64_API
 111         return open64 (pathname, flags);
 112 #else
 113         return open (pathname, flags);
 114 #endif
 115 }
 116
 117 gint32
 118 Mono_Posix_Syscall_open_mode (const char *pathname, gint32 flags, guint32 mode)
 119 {
 120         if (Mono_Posix_FromOpenFlags (flags, &flags) == -1)
 121                 return -1;
 122         if (Mono_Posix_FromFilePermissions (mode, &mode) == -1)
 123                 return -1;
 124 #ifdef MPH_USE_64_API
 125         return open64 (pathname, flags, mode);
 126 #else
 127         return open (pathname, flags, mode);
 128 #endif
 129 }
 130
 131 gint32
 132 Mono_Posix_Syscall_creat (const char *pathname, guint32 mode)
 133 {
 134         if (Mono_Posix_FromFilePermissions (mode, &mode) == -1)
 135                 return -1;
 136 #ifdef MPH_USE_64_API
 137         return creat64 (pathname, mode);
 138 #else
 139         return creat (pathname, mode);
 140 #endif
 141 }
 142
 143 #ifdef HAVE_POSIX_FADVISE
 144 gint32
 145 Mono_Posix_Syscall_posix_fadvise (gint32 fd, mph_off_t offset, mph_off_t len,
 146         gint32 advice)
 147 {
 148         mph_return_if_off_t_overflow (offset);
 149         mph_return_if_off_t_overflow (len);
 150
 151         if (Mono_Posix_FromPosixFadviseAdvice (advice, &advice) == -1)
 152                 return -1;
 153
 154 #ifdef MPH_USE_64_API
 155         return posix_fadvise64 (fd, offset, len, advice);
 156 #else
 157         return posix_fadvise (fd, (off_t) offset, (off_t) len, advice);
 158 #endif
 159 }
 160 #endif /* ndef HAVE_POSIX_FADVISE */
 161
 162 #ifdef HAVE_POSIX_FALLOCATE
 163 gint32
 164 Mono_Posix_Syscall_posix_fallocate (gint32 fd, mph_off_t offset, mph_size_t len)
 165 {
 166         mph_return_if_off_t_overflow (offset);
 167         mph_return_if_size_t_overflow (len);
 168
 169 #ifdef MPH_USE_64_API
 170         return posix_fallocate64 (fd, offset, len);
 171 #else
 172         return posix_fadvise (fd, (off_t) offset, (size_t) len);
 173 #endif
 174 }
 175 #endif /* ndef HAVE_POSIX_FALLOCATE */
 176
 177 G_END_DECLS
 178
 179 /*
 180  * vim: noexpandtab
 181  */