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         struct flock _lock;
  70         int r;
  71
  72         if (lock == NULL) {
  73                 errno = EFAULT;
  74                 return -1;
  75         }
  76
  77         mph_return_if_off_t_overflow (lock->l_start);
  78         mph_return_if_off_t_overflow (lock->l_len);
  79
  80         if (Mono_Posix_FromLockType (lock->l_type, &lock->l_type) == -1)
  81                 return -1;
  82         _lock.l_type   = lock->l_type;
  83         _lock.l_whence = lock->l_whence;
  84         _lock.l_start  = lock->l_start;
  85         _lock.l_len    = lock->l_len;
  86         _lock.l_pid    = lock->l_pid;
  87
  88         r = fcntl (fd, cmd, &_lock);
  89
  90         if (Mono_Posix_ToLockType (_lock.l_type, &_lock.l_type) == -1)
  91                 r = -1;
  92         lock->l_type   = _lock.l_type;
  93         lock->l_whence = _lock.l_whence;
  94         lock->l_start  = _lock.l_start;
  95         lock->l_len    = _lock.l_len;
  96         lock->l_pid    = _lock.l_pid;
  97
  98         return r;
  99 }
 100
 101 gint32
 102 Mono_Posix_Syscall_open (const char *pathname, gint32 flags)
 103 {
 104         if (Mono_Posix_FromOpenFlags (flags, &flags) == -1)
 105                 return -1;
 106
 107         return open (pathname, flags);
 108 }
 109
 110 gint32
 111 Mono_Posix_Syscall_open_mode (const char *pathname, gint32 flags, guint32 mode)
 112 {
 113         if (Mono_Posix_FromOpenFlags (flags, &flags) == -1)
 114                 return -1;
 115         if (Mono_Posix_FromFilePermissions (mode, &mode) == -1)
 116                 return -1;
 117
 118         return open (pathname, flags, mode);
 119 }
 120
 121 gint32
 122 Mono_Posix_Syscall_creat (const char *pathname, guint32 mode)
 123 {
 124         if (Mono_Posix_FromFilePermissions (mode, &mode) == -1)
 125                 return -1;
 126
 127         return creat (pathname, mode);
 128 }
 129
 130 #ifdef HAVE_POSIX_FADVISE
 131 gint32
 132 Mono_Posix_Syscall_posix_fadvise (gint32 fd, mph_off_t offset, mph_off_t len,
 133         gint32 advice)
 134 {
 135         mph_return_if_off_t_overflow (offset);
 136         mph_return_if_off_t_overflow (len);
 137
 138         if (Mono_Posix_FromPosixFadviseAdvice (advice, &advice) == -1)
 139                 return -1;
 140
 141         return posix_fadvise (fd, (off_t) offset, (off_t) len, advice);
 142 }
 143 #endif /* ndef HAVE_POSIX_FADVISE */
 144
 145 #ifdef HAVE_POSIX_FALLOCATE
 146 gint32
 147 Mono_Posix_Syscall_posix_fallocate (gint32 fd, mph_off_t offset, mph_size_t len)
 148 {
 149         mph_return_if_off_t_overflow (offset);
 150         mph_return_if_size_t_overflow (len);
 151
 152         return posix_fallocate (fd, (off_t) offset, (size_t) len);
 153 }
 154 #endif /* ndef HAVE_POSIX_FALLOCATE */
 155
 156 G_END_DECLS
 157
 158 /*
 159  * vim: noexpandtab
 160  */