/*
- * This file was automatically generated by create-native-map from ../../mcs/class/lib/net_2_0/Mono.Posix.dll.
+ * This file was automatically generated by create-native-map from /cvs/mono/mcs/class/lib/net_4_5/Mono.Posix.dll.
*
* DO NOT MODIFY.
*/
*/
#include <sys/types.h>
#include <sys/stat.h>
+#ifdef HAVE_SYS_TIME_H
#include <sys/time.h>
+#endif /* ndef HAVE_SYS_TIME_H */
#ifdef HAVE_SYS_POLL_H
#include <sys/poll.h>
#endif /* ndef HAVE_SYS_POLL_H */
#ifdef HAVE_SYS_MMAN_H
#include <sys/mman.h>
#endif /* ndef HAVE_SYS_MMAN_H */
+#ifdef HAVE_SYS_UIO_H
+#include <sys/uio.h>
+#endif /* ndef HAVE_SYS_UIO_H */
+#ifdef HAVE_UNISTD_H
#include <unistd.h>
+#endif /* ndef HAVE_UNISTD_H */
#include <fcntl.h>
#include <signal.h>
#ifdef HAVE_POLL_H
#ifdef HAVE_SYSLOG_H
#include <syslog.h>
#endif /* ndef HAVE_SYSLOG_H */
+#ifdef HAVE_DIRENT_H
#include <dirent.h>
+#endif /* ndef HAVE_DIRENT_H */
+#ifdef HAVE_UTIME_H
#include <utime.h>
+#endif /* ndef HAVE_UTIME_H */
+#include <time.h>
#include "mph.h"
#include "map.h"
? CNM_MAXINT64 \
: (g_assert_not_reached (), 0))
-#ifdef DEBUG
-#define _cnm_dump_(to_t,from) \
- printf ("# %s -> %s: min=%llx; max=%llx; value=%llx; lt=%i; l0=%i; gt=%i; e=%i\n", \
+#ifdef _CNM_DUMP
+#define _cnm_dump(to_t,from) \
+ printf ("# %s -> %s: uns=%i; min=%llx; max=%llx; value=%llx; lt=%i; l0=%i; gt=%i; e=%i\n", \
#from, #to_t, \
- (gint64) (_cnm_integral_type_min(to_t)), \
+ (int) _cnm_integral_type_is_unsigned (to_t), \
+ (gint64) (_cnm_integral_type_min (to_t)), \
(gint64) (_cnm_integral_type_max (to_t)), \
(gint64) (from), \
- (_cnm_integral_type_min (to_t) <= from), \
+ (((gint64) _cnm_integral_type_min (to_t)) <= (gint64) from), \
(from < 0), \
- /* (_cnm_integral_type_max (to_t) >= from) */ \
- (from <= _cnm_integral_type_max (to_t)), \
- ((_cnm_integral_type_min(to_t) >= from) && \
- ((from < 0) ? 1 : (from <= _cnm_integral_type_max(to_t)))) \
+ (((guint64) from) <= (guint64) _cnm_integral_type_max (to_t)), \
+ !((int) _cnm_integral_type_is_unsigned (to_t) \
+ ? ((0 <= from) && \
+ ((guint64) from <= (guint64) _cnm_integral_type_max (to_t))) \
+ : ((gint64) _cnm_integral_type_min(to_t) <= (gint64) from && \
+ (guint64) from <= (guint64) _cnm_integral_type_max (to_t))) \
)
-#else
-#define _cnm_dump_(to_t, from) do {} while (0)
-#endif
+#else /* ndef _CNM_DUMP */
+#define _cnm_dump(to_t, from) do {} while (0)
+#endif /* def _CNM_DUMP */
+#ifdef DEBUG
#define _cnm_return_val_if_overflow(to_t,from,val) G_STMT_START { \
- gint64 sf = (gint64) from; \
- guint64 uf = (guint64) from; \
- if (!(_cnm_integral_type_min(to_t) <= sf && \
- ((from < 0) || (uf <= _cnm_integral_type_max(to_t))))) { \
- _cnm_dump_(to_t, from); \
+ int uns = _cnm_integral_type_is_unsigned (to_t); \
+ gint64 min = (gint64) _cnm_integral_type_min (to_t); \
+ guint64 max = (guint64) _cnm_integral_type_max (to_t); \
+ gint64 sf = (gint64) from; \
+ guint64 uf = (guint64) from; \
+ if (!(uns ? ((0 <= from) && (uf <= max)) \
+ : (min <= sf && (from < 0 || uf <= max)))) { \
+ _cnm_dump(to_t, from); \
errno = EOVERFLOW; \
return (val); \
} \
} G_STMT_END
+#else /* !def DEBUG */
+/* don't do any overflow checking */
+#define _cnm_return_val_if_overflow(to_t,from,val) G_STMT_START { \
+ } G_STMT_END
+#endif /* def DEBUG */
int Mono_Posix_FromAccessModes (int x, int *r)
{
return 0;
}
+int Mono_Posix_FromAtFlags (int x, int *r)
+{
+ *r = 0;
+ if ((x & Mono_Posix_AtFlags_AT_EMPTY_PATH) == Mono_Posix_AtFlags_AT_EMPTY_PATH)
+#ifdef AT_EMPTY_PATH
+ *r |= AT_EMPTY_PATH;
+#else /* def AT_EMPTY_PATH */
+ {errno = EINVAL; return -1;}
+#endif /* ndef AT_EMPTY_PATH */
+ if ((x & Mono_Posix_AtFlags_AT_NO_AUTOMOUNT) == Mono_Posix_AtFlags_AT_NO_AUTOMOUNT)
+#ifdef AT_NO_AUTOMOUNT
+ *r |= AT_NO_AUTOMOUNT;
+#else /* def AT_NO_AUTOMOUNT */
+ {errno = EINVAL; return -1;}
+#endif /* ndef AT_NO_AUTOMOUNT */
+ if ((x & Mono_Posix_AtFlags_AT_REMOVEDIR) == Mono_Posix_AtFlags_AT_REMOVEDIR)
+#ifdef AT_REMOVEDIR
+ *r |= AT_REMOVEDIR;
+#else /* def AT_REMOVEDIR */
+ {errno = EINVAL; return -1;}
+#endif /* ndef AT_REMOVEDIR */
+ if ((x & Mono_Posix_AtFlags_AT_SYMLINK_FOLLOW) == Mono_Posix_AtFlags_AT_SYMLINK_FOLLOW)
+#ifdef AT_SYMLINK_FOLLOW
+ *r |= AT_SYMLINK_FOLLOW;
+#else /* def AT_SYMLINK_FOLLOW */
+ {errno = EINVAL; return -1;}
+#endif /* ndef AT_SYMLINK_FOLLOW */
+ if ((x & Mono_Posix_AtFlags_AT_SYMLINK_NOFOLLOW) == Mono_Posix_AtFlags_AT_SYMLINK_NOFOLLOW)
+#ifdef AT_SYMLINK_NOFOLLOW
+ *r |= AT_SYMLINK_NOFOLLOW;
+#else /* def AT_SYMLINK_NOFOLLOW */
+ {errno = EINVAL; return -1;}
+#endif /* ndef AT_SYMLINK_NOFOLLOW */
+ if (x == 0)
+ return 0;
+ return 0;
+}
+
+int Mono_Posix_ToAtFlags (int x, int *r)
+{
+ *r = 0;
+ if (x == 0)
+ return 0;
+#ifdef AT_EMPTY_PATH
+ if ((x & AT_EMPTY_PATH) == AT_EMPTY_PATH)
+ *r |= Mono_Posix_AtFlags_AT_EMPTY_PATH;
+#endif /* ndef AT_EMPTY_PATH */
+#ifdef AT_NO_AUTOMOUNT
+ if ((x & AT_NO_AUTOMOUNT) == AT_NO_AUTOMOUNT)
+ *r |= Mono_Posix_AtFlags_AT_NO_AUTOMOUNT;
+#endif /* ndef AT_NO_AUTOMOUNT */
+#ifdef AT_REMOVEDIR
+ if ((x & AT_REMOVEDIR) == AT_REMOVEDIR)
+ *r |= Mono_Posix_AtFlags_AT_REMOVEDIR;
+#endif /* ndef AT_REMOVEDIR */
+#ifdef AT_SYMLINK_FOLLOW
+ if ((x & AT_SYMLINK_FOLLOW) == AT_SYMLINK_FOLLOW)
+ *r |= Mono_Posix_AtFlags_AT_SYMLINK_FOLLOW;
+#endif /* ndef AT_SYMLINK_FOLLOW */
+#ifdef AT_SYMLINK_NOFOLLOW
+ if ((x & AT_SYMLINK_NOFOLLOW) == AT_SYMLINK_NOFOLLOW)
+ *r |= Mono_Posix_AtFlags_AT_SYMLINK_NOFOLLOW;
+#endif /* ndef AT_SYMLINK_NOFOLLOW */
+ return 0;
+}
+
int Mono_Posix_FromConfstrName (int x, int *r)
{
*r = 0;
return 0;
}
+int Mono_Posix_FromEpollEvents (unsigned int x, unsigned int *r)
+{
+ *r = 0;
+ if ((x & Mono_Posix_EpollEvents_EPOLLERR) == Mono_Posix_EpollEvents_EPOLLERR)
+#ifdef EPOLLERR
+ *r |= EPOLLERR;
+#else /* def EPOLLERR */
+ {errno = EINVAL; return -1;}
+#endif /* ndef EPOLLERR */
+ if ((x & Mono_Posix_EpollEvents_EPOLLET) == Mono_Posix_EpollEvents_EPOLLET)
+#ifdef EPOLLET
+ *r |= EPOLLET;
+#else /* def EPOLLET */
+ {errno = EINVAL; return -1;}
+#endif /* ndef EPOLLET */
+ if ((x & Mono_Posix_EpollEvents_EPOLLHUP) == Mono_Posix_EpollEvents_EPOLLHUP)
+#ifdef EPOLLHUP
+ *r |= EPOLLHUP;
+#else /* def EPOLLHUP */
+ {errno = EINVAL; return -1;}
+#endif /* ndef EPOLLHUP */
+ if ((x & Mono_Posix_EpollEvents_EPOLLIN) == Mono_Posix_EpollEvents_EPOLLIN)
+#ifdef EPOLLIN
+ *r |= EPOLLIN;
+#else /* def EPOLLIN */
+ {errno = EINVAL; return -1;}
+#endif /* ndef EPOLLIN */
+ if ((x & Mono_Posix_EpollEvents_EPOLLMSG) == Mono_Posix_EpollEvents_EPOLLMSG)
+#ifdef EPOLLMSG
+ *r |= EPOLLMSG;
+#else /* def EPOLLMSG */
+ {errno = EINVAL; return -1;}
+#endif /* ndef EPOLLMSG */
+ if ((x & Mono_Posix_EpollEvents_EPOLLONESHOT) == Mono_Posix_EpollEvents_EPOLLONESHOT)
+#ifdef EPOLLONESHOT
+ *r |= EPOLLONESHOT;
+#else /* def EPOLLONESHOT */
+ {errno = EINVAL; return -1;}
+#endif /* ndef EPOLLONESHOT */
+ if ((x & Mono_Posix_EpollEvents_EPOLLOUT) == Mono_Posix_EpollEvents_EPOLLOUT)
+#ifdef EPOLLOUT
+ *r |= EPOLLOUT;
+#else /* def EPOLLOUT */
+ {errno = EINVAL; return -1;}
+#endif /* ndef EPOLLOUT */
+ if ((x & Mono_Posix_EpollEvents_EPOLLPRI) == Mono_Posix_EpollEvents_EPOLLPRI)
+#ifdef EPOLLPRI
+ *r |= EPOLLPRI;
+#else /* def EPOLLPRI */
+ {errno = EINVAL; return -1;}
+#endif /* ndef EPOLLPRI */
+ if ((x & Mono_Posix_EpollEvents_EPOLLRDBAND) == Mono_Posix_EpollEvents_EPOLLRDBAND)
+#ifdef EPOLLRDBAND
+ *r |= EPOLLRDBAND;
+#else /* def EPOLLRDBAND */
+ {errno = EINVAL; return -1;}
+#endif /* ndef EPOLLRDBAND */
+ if ((x & Mono_Posix_EpollEvents_EPOLLRDHUP) == Mono_Posix_EpollEvents_EPOLLRDHUP)
+#ifdef EPOLLRDHUP
+ *r |= EPOLLRDHUP;
+#else /* def EPOLLRDHUP */
+ {errno = EINVAL; return -1;}
+#endif /* ndef EPOLLRDHUP */
+ if ((x & Mono_Posix_EpollEvents_EPOLLRDNORM) == Mono_Posix_EpollEvents_EPOLLRDNORM)
+#ifdef EPOLLRDNORM
+ *r |= EPOLLRDNORM;
+#else /* def EPOLLRDNORM */
+ {errno = EINVAL; return -1;}
+#endif /* ndef EPOLLRDNORM */
+ if ((x & Mono_Posix_EpollEvents_EPOLLWRBAND) == Mono_Posix_EpollEvents_EPOLLWRBAND)
+#ifdef EPOLLWRBAND
+ *r |= EPOLLWRBAND;
+#else /* def EPOLLWRBAND */
+ {errno = EINVAL; return -1;}
+#endif /* ndef EPOLLWRBAND */
+ if ((x & Mono_Posix_EpollEvents_EPOLLWRNORM) == Mono_Posix_EpollEvents_EPOLLWRNORM)
+#ifdef EPOLLWRNORM
+ *r |= EPOLLWRNORM;
+#else /* def EPOLLWRNORM */
+ {errno = EINVAL; return -1;}
+#endif /* ndef EPOLLWRNORM */
+ if (x == 0)
+ return 0;
+ return 0;
+}
+
+int Mono_Posix_ToEpollEvents (unsigned int x, unsigned int *r)
+{
+ *r = 0;
+ if (x == 0)
+ return 0;
+#ifdef EPOLLERR
+ if ((x & EPOLLERR) == EPOLLERR)
+ *r |= Mono_Posix_EpollEvents_EPOLLERR;
+#endif /* ndef EPOLLERR */
+#ifdef EPOLLET
+ if ((x & EPOLLET) == EPOLLET)
+ *r |= Mono_Posix_EpollEvents_EPOLLET;
+#endif /* ndef EPOLLET */
+#ifdef EPOLLHUP
+ if ((x & EPOLLHUP) == EPOLLHUP)
+ *r |= Mono_Posix_EpollEvents_EPOLLHUP;
+#endif /* ndef EPOLLHUP */
+#ifdef EPOLLIN
+ if ((x & EPOLLIN) == EPOLLIN)
+ *r |= Mono_Posix_EpollEvents_EPOLLIN;
+#endif /* ndef EPOLLIN */
+#ifdef EPOLLMSG
+ if ((x & EPOLLMSG) == EPOLLMSG)
+ *r |= Mono_Posix_EpollEvents_EPOLLMSG;
+#endif /* ndef EPOLLMSG */
+#ifdef EPOLLONESHOT
+ if ((x & EPOLLONESHOT) == EPOLLONESHOT)
+ *r |= Mono_Posix_EpollEvents_EPOLLONESHOT;
+#endif /* ndef EPOLLONESHOT */
+#ifdef EPOLLOUT
+ if ((x & EPOLLOUT) == EPOLLOUT)
+ *r |= Mono_Posix_EpollEvents_EPOLLOUT;
+#endif /* ndef EPOLLOUT */
+#ifdef EPOLLPRI
+ if ((x & EPOLLPRI) == EPOLLPRI)
+ *r |= Mono_Posix_EpollEvents_EPOLLPRI;
+#endif /* ndef EPOLLPRI */
+#ifdef EPOLLRDBAND
+ if ((x & EPOLLRDBAND) == EPOLLRDBAND)
+ *r |= Mono_Posix_EpollEvents_EPOLLRDBAND;
+#endif /* ndef EPOLLRDBAND */
+#ifdef EPOLLRDHUP
+ if ((x & EPOLLRDHUP) == EPOLLRDHUP)
+ *r |= Mono_Posix_EpollEvents_EPOLLRDHUP;
+#endif /* ndef EPOLLRDHUP */
+#ifdef EPOLLRDNORM
+ if ((x & EPOLLRDNORM) == EPOLLRDNORM)
+ *r |= Mono_Posix_EpollEvents_EPOLLRDNORM;
+#endif /* ndef EPOLLRDNORM */
+#ifdef EPOLLWRBAND
+ if ((x & EPOLLWRBAND) == EPOLLWRBAND)
+ *r |= Mono_Posix_EpollEvents_EPOLLWRBAND;
+#endif /* ndef EPOLLWRBAND */
+#ifdef EPOLLWRNORM
+ if ((x & EPOLLWRNORM) == EPOLLWRNORM)
+ *r |= Mono_Posix_EpollEvents_EPOLLWRNORM;
+#endif /* ndef EPOLLWRNORM */
+ return 0;
+}
+
+int Mono_Posix_FromEpollFlags (int x, int *r)
+{
+ *r = 0;
+ if ((x & Mono_Posix_EpollFlags_EPOLL_CLOEXEC) == Mono_Posix_EpollFlags_EPOLL_CLOEXEC)
+#ifdef EPOLL_CLOEXEC
+ *r |= EPOLL_CLOEXEC;
+#else /* def EPOLL_CLOEXEC */
+ {errno = EINVAL; return -1;}
+#endif /* ndef EPOLL_CLOEXEC */
+ if ((x & Mono_Posix_EpollFlags_EPOLL_NONBLOCK) == Mono_Posix_EpollFlags_EPOLL_NONBLOCK)
+#ifdef EPOLL_NONBLOCK
+ *r |= EPOLL_NONBLOCK;
+#else /* def EPOLL_NONBLOCK */
+ {errno = EINVAL; return -1;}
+#endif /* ndef EPOLL_NONBLOCK */
+ if (x == 0)
+ return 0;
+ return 0;
+}
+
+int Mono_Posix_ToEpollFlags (int x, int *r)
+{
+ *r = 0;
+ if (x == 0)
+ return 0;
+#ifdef EPOLL_CLOEXEC
+ if ((x & EPOLL_CLOEXEC) == EPOLL_CLOEXEC)
+ *r |= Mono_Posix_EpollFlags_EPOLL_CLOEXEC;
+#endif /* ndef EPOLL_CLOEXEC */
+#ifdef EPOLL_NONBLOCK
+ if ((x & EPOLL_NONBLOCK) == EPOLL_NONBLOCK)
+ *r |= Mono_Posix_EpollFlags_EPOLL_NONBLOCK;
+#endif /* ndef EPOLL_NONBLOCK */
+ return 0;
+}
+
int Mono_Posix_FromErrno (int x, int *r)
{
*r = 0;
#else /* def EALREADY */
{errno = EINVAL; return -1;}
#endif /* ndef EALREADY */
+ if (x == Mono_Posix_Errno_EAUTH)
+#ifdef EAUTH
+ {*r = EAUTH; return 0;}
+#else /* def EAUTH */
+ {errno = EINVAL; return -1;}
+#endif /* ndef EAUTH */
+ if (x == Mono_Posix_Errno_EBADARCH)
+#ifdef EBADARCH
+ {*r = EBADARCH; return 0;}
+#else /* def EBADARCH */
+ {errno = EINVAL; return -1;}
+#endif /* ndef EBADARCH */
if (x == Mono_Posix_Errno_EBADE)
#ifdef EBADE
{*r = EBADE; return 0;}
#else /* def EBADE */
{errno = EINVAL; return -1;}
#endif /* ndef EBADE */
+ if (x == Mono_Posix_Errno_EBADEXEC)
+#ifdef EBADEXEC
+ {*r = EBADEXEC; return 0;}
+#else /* def EBADEXEC */
+ {errno = EINVAL; return -1;}
+#endif /* ndef EBADEXEC */
if (x == Mono_Posix_Errno_EBADF)
#ifdef EBADF
{*r = EBADF; return 0;}
#else /* def EBADFD */
{errno = EINVAL; return -1;}
#endif /* ndef EBADFD */
+ if (x == Mono_Posix_Errno_EBADMACHO)
+#ifdef EBADMACHO
+ {*r = EBADMACHO; return 0;}
+#else /* def EBADMACHO */
+ {errno = EINVAL; return -1;}
+#endif /* ndef EBADMACHO */
if (x == Mono_Posix_Errno_EBADMSG)
#ifdef EBADMSG
{*r = EBADMSG; return 0;}
#else /* def EBADR */
{errno = EINVAL; return -1;}
#endif /* ndef EBADR */
+ if (x == Mono_Posix_Errno_EBADRPC)
+#ifdef EBADRPC
+ {*r = EBADRPC; return 0;}
+#else /* def EBADRPC */
+ {errno = EINVAL; return -1;}
+#endif /* ndef EBADRPC */
if (x == Mono_Posix_Errno_EBADRQC)
#ifdef EBADRQC
{*r = EBADRQC; return 0;}
#else /* def EBUSY */
{errno = EINVAL; return -1;}
#endif /* ndef EBUSY */
+ if (x == Mono_Posix_Errno_ECANCELED)
+#ifdef ECANCELED
+ {*r = ECANCELED; return 0;}
+#else /* def ECANCELED */
+ {errno = EINVAL; return -1;}
+#endif /* ndef ECANCELED */
if (x == Mono_Posix_Errno_ECHILD)
#ifdef ECHILD
{*r = ECHILD; return 0;}
#else /* def EDESTADDRREQ */
{errno = EINVAL; return -1;}
#endif /* ndef EDESTADDRREQ */
+ if (x == Mono_Posix_Errno_EDEVERR)
+#ifdef EDEVERR
+ {*r = EDEVERR; return 0;}
+#else /* def EDEVERR */
+ {errno = EINVAL; return -1;}
+#endif /* ndef EDEVERR */
if (x == Mono_Posix_Errno_EDOM)
#ifdef EDOM
{*r = EDOM; return 0;}
#else /* def EFBIG */
{errno = EINVAL; return -1;}
#endif /* ndef EFBIG */
+ if (x == Mono_Posix_Errno_EFTYPE)
+#ifdef EFTYPE
+ {*r = EFTYPE; return 0;}
+#else /* def EFTYPE */
+ {errno = EINVAL; return -1;}
+#endif /* ndef EFTYPE */
if (x == Mono_Posix_Errno_EHOSTDOWN)
#ifdef EHOSTDOWN
{*r = EHOSTDOWN; return 0;}
#else /* def EISNAM */
{errno = EINVAL; return -1;}
#endif /* ndef EISNAM */
+ if (x == Mono_Posix_Errno_EKEYEXPIRED)
+#ifdef EKEYEXPIRED
+ {*r = EKEYEXPIRED; return 0;}
+#else /* def EKEYEXPIRED */
+ {errno = EINVAL; return -1;}
+#endif /* ndef EKEYEXPIRED */
+ if (x == Mono_Posix_Errno_EKEYREJECTED)
+#ifdef EKEYREJECTED
+ {*r = EKEYREJECTED; return 0;}
+#else /* def EKEYREJECTED */
+ {errno = EINVAL; return -1;}
+#endif /* ndef EKEYREJECTED */
+ if (x == Mono_Posix_Errno_EKEYREVOKED)
+#ifdef EKEYREVOKED
+ {*r = EKEYREVOKED; return 0;}
+#else /* def EKEYREVOKED */
+ {errno = EINVAL; return -1;}
+#endif /* ndef EKEYREVOKED */
if (x == Mono_Posix_Errno_EL2HLT)
#ifdef EL2HLT
{*r = EL2HLT; return 0;}
#else /* def ENAVAIL */
{errno = EINVAL; return -1;}
#endif /* ndef ENAVAIL */
+ if (x == Mono_Posix_Errno_ENEEDAUTH)
+#ifdef ENEEDAUTH
+ {*r = ENEEDAUTH; return 0;}
+#else /* def ENEEDAUTH */
+ {errno = EINVAL; return -1;}
+#endif /* ndef ENEEDAUTH */
if (x == Mono_Posix_Errno_ENETDOWN)
#ifdef ENETDOWN
{*r = ENETDOWN; return 0;}
#else /* def ENOANO */
{errno = EINVAL; return -1;}
#endif /* ndef ENOANO */
+ if (x == Mono_Posix_Errno_ENOATTR)
+#ifdef ENOATTR
+ {*r = ENOATTR; return 0;}
+#else /* def ENOATTR */
+ {errno = EINVAL; return -1;}
+#endif /* ndef ENOATTR */
if (x == Mono_Posix_Errno_ENOBUFS)
#ifdef ENOBUFS
{*r = ENOBUFS; return 0;}
#else /* def ENOEXEC */
{errno = EINVAL; return -1;}
#endif /* ndef ENOEXEC */
+ if (x == Mono_Posix_Errno_ENOKEY)
+#ifdef ENOKEY
+ {*r = ENOKEY; return 0;}
+#else /* def ENOKEY */
+ {errno = EINVAL; return -1;}
+#endif /* ndef ENOKEY */
if (x == Mono_Posix_Errno_ENOLCK)
#ifdef ENOLCK
{*r = ENOLCK; return 0;}
#else /* def ENOPKG */
{errno = EINVAL; return -1;}
#endif /* ndef ENOPKG */
+ if (x == Mono_Posix_Errno_ENOPOLICY)
+#ifdef ENOPOLICY
+ {*r = ENOPOLICY; return 0;}
+#else /* def ENOPOLICY */
+ {errno = EINVAL; return -1;}
+#endif /* ndef ENOPOLICY */
if (x == Mono_Posix_Errno_ENOPROTOOPT)
#ifdef ENOPROTOOPT
{*r = ENOPROTOOPT; return 0;}
#else /* def ENOTNAM */
{errno = EINVAL; return -1;}
#endif /* ndef ENOTNAM */
+ if (x == Mono_Posix_Errno_ENOTRECOVERABLE)
+#ifdef ENOTRECOVERABLE
+ {*r = ENOTRECOVERABLE; return 0;}
+#else /* def ENOTRECOVERABLE */
+ {errno = EINVAL; return -1;}
+#endif /* ndef ENOTRECOVERABLE */
if (x == Mono_Posix_Errno_ENOTSOCK)
#ifdef ENOTSOCK
{*r = ENOTSOCK; return 0;}
#else /* def EOVERFLOW */
{errno = EINVAL; return -1;}
#endif /* ndef EOVERFLOW */
+ if (x == Mono_Posix_Errno_EOWNERDEAD)
+#ifdef EOWNERDEAD
+ {*r = EOWNERDEAD; return 0;}
+#else /* def EOWNERDEAD */
+ {errno = EINVAL; return -1;}
+#endif /* ndef EOWNERDEAD */
if (x == Mono_Posix_Errno_EPERM)
#ifdef EPERM
{*r = EPERM; return 0;}
#else /* def EPIPE */
{errno = EINVAL; return -1;}
#endif /* ndef EPIPE */
+ if (x == Mono_Posix_Errno_EPROCLIM)
+#ifdef EPROCLIM
+ {*r = EPROCLIM; return 0;}
+#else /* def EPROCLIM */
+ {errno = EINVAL; return -1;}
+#endif /* ndef EPROCLIM */
+ if (x == Mono_Posix_Errno_EPROCUNAVAIL)
+#ifdef EPROCUNAVAIL
+ {*r = EPROCUNAVAIL; return 0;}
+#else /* def EPROCUNAVAIL */
+ {errno = EINVAL; return -1;}
+#endif /* ndef EPROCUNAVAIL */
+ if (x == Mono_Posix_Errno_EPROGMISMATCH)
+#ifdef EPROGMISMATCH
+ {*r = EPROGMISMATCH; return 0;}
+#else /* def EPROGMISMATCH */
+ {errno = EINVAL; return -1;}
+#endif /* ndef EPROGMISMATCH */
+ if (x == Mono_Posix_Errno_EPROGUNAVAIL)
+#ifdef EPROGUNAVAIL
+ {*r = EPROGUNAVAIL; return 0;}
+#else /* def EPROGUNAVAIL */
+ {errno = EINVAL; return -1;}
+#endif /* ndef EPROGUNAVAIL */
if (x == Mono_Posix_Errno_EPROTO)
#ifdef EPROTO
{*r = EPROTO; return 0;}
#else /* def EPROTOTYPE */
{errno = EINVAL; return -1;}
#endif /* ndef EPROTOTYPE */
+ if (x == Mono_Posix_Errno_EPWROFF)
+#ifdef EPWROFF
+ {*r = EPWROFF; return 0;}
+#else /* def EPWROFF */
+ {errno = EINVAL; return -1;}
+#endif /* ndef EPWROFF */
if (x == Mono_Posix_Errno_ERANGE)
#ifdef ERANGE
{*r = ERANGE; return 0;}
#else /* def EROFS */
{errno = EINVAL; return -1;}
#endif /* ndef EROFS */
+ if (x == Mono_Posix_Errno_ERPCMISMATCH)
+#ifdef ERPCMISMATCH
+ {*r = ERPCMISMATCH; return 0;}
+#else /* def ERPCMISMATCH */
+ {errno = EINVAL; return -1;}
+#endif /* ndef ERPCMISMATCH */
+ if (x == Mono_Posix_Errno_ESHLIBVERS)
+#ifdef ESHLIBVERS
+ {*r = ESHLIBVERS; return 0;}
+#else /* def ESHLIBVERS */
+ {errno = EINVAL; return -1;}
+#endif /* ndef ESHLIBVERS */
if (x == Mono_Posix_Errno_ESHUTDOWN)
#ifdef ESHUTDOWN
{*r = ESHUTDOWN; return 0;}
if (x == EALREADY)
{*r = Mono_Posix_Errno_EALREADY; return 0;}
#endif /* ndef EALREADY */
+#ifdef EAUTH
+ if (x == EAUTH)
+ {*r = Mono_Posix_Errno_EAUTH; return 0;}
+#endif /* ndef EAUTH */
+#ifdef EBADARCH
+ if (x == EBADARCH)
+ {*r = Mono_Posix_Errno_EBADARCH; return 0;}
+#endif /* ndef EBADARCH */
#ifdef EBADE
if (x == EBADE)
{*r = Mono_Posix_Errno_EBADE; return 0;}
#endif /* ndef EBADE */
+#ifdef EBADEXEC
+ if (x == EBADEXEC)
+ {*r = Mono_Posix_Errno_EBADEXEC; return 0;}
+#endif /* ndef EBADEXEC */
#ifdef EBADF
if (x == EBADF)
{*r = Mono_Posix_Errno_EBADF; return 0;}
if (x == EBADFD)
{*r = Mono_Posix_Errno_EBADFD; return 0;}
#endif /* ndef EBADFD */
+#ifdef EBADMACHO
+ if (x == EBADMACHO)
+ {*r = Mono_Posix_Errno_EBADMACHO; return 0;}
+#endif /* ndef EBADMACHO */
#ifdef EBADMSG
if (x == EBADMSG)
{*r = Mono_Posix_Errno_EBADMSG; return 0;}
if (x == EBADR)
{*r = Mono_Posix_Errno_EBADR; return 0;}
#endif /* ndef EBADR */
+#ifdef EBADRPC
+ if (x == EBADRPC)
+ {*r = Mono_Posix_Errno_EBADRPC; return 0;}
+#endif /* ndef EBADRPC */
#ifdef EBADRQC
if (x == EBADRQC)
{*r = Mono_Posix_Errno_EBADRQC; return 0;}
if (x == EBUSY)
{*r = Mono_Posix_Errno_EBUSY; return 0;}
#endif /* ndef EBUSY */
+#ifdef ECANCELED
+ if (x == ECANCELED)
+ {*r = Mono_Posix_Errno_ECANCELED; return 0;}
+#endif /* ndef ECANCELED */
#ifdef ECHILD
if (x == ECHILD)
{*r = Mono_Posix_Errno_ECHILD; return 0;}
if (x == EDESTADDRREQ)
{*r = Mono_Posix_Errno_EDESTADDRREQ; return 0;}
#endif /* ndef EDESTADDRREQ */
+#ifdef EDEVERR
+ if (x == EDEVERR)
+ {*r = Mono_Posix_Errno_EDEVERR; return 0;}
+#endif /* ndef EDEVERR */
#ifdef EDOM
if (x == EDOM)
{*r = Mono_Posix_Errno_EDOM; return 0;}
if (x == EFBIG)
{*r = Mono_Posix_Errno_EFBIG; return 0;}
#endif /* ndef EFBIG */
+#ifdef EFTYPE
+ if (x == EFTYPE)
+ {*r = Mono_Posix_Errno_EFTYPE; return 0;}
+#endif /* ndef EFTYPE */
#ifdef EHOSTDOWN
if (x == EHOSTDOWN)
{*r = Mono_Posix_Errno_EHOSTDOWN; return 0;}
if (x == EISNAM)
{*r = Mono_Posix_Errno_EISNAM; return 0;}
#endif /* ndef EISNAM */
+#ifdef EKEYEXPIRED
+ if (x == EKEYEXPIRED)
+ {*r = Mono_Posix_Errno_EKEYEXPIRED; return 0;}
+#endif /* ndef EKEYEXPIRED */
+#ifdef EKEYREJECTED
+ if (x == EKEYREJECTED)
+ {*r = Mono_Posix_Errno_EKEYREJECTED; return 0;}
+#endif /* ndef EKEYREJECTED */
+#ifdef EKEYREVOKED
+ if (x == EKEYREVOKED)
+ {*r = Mono_Posix_Errno_EKEYREVOKED; return 0;}
+#endif /* ndef EKEYREVOKED */
#ifdef EL2HLT
if (x == EL2HLT)
{*r = Mono_Posix_Errno_EL2HLT; return 0;}
if (x == ENAVAIL)
{*r = Mono_Posix_Errno_ENAVAIL; return 0;}
#endif /* ndef ENAVAIL */
+#ifdef ENEEDAUTH
+ if (x == ENEEDAUTH)
+ {*r = Mono_Posix_Errno_ENEEDAUTH; return 0;}
+#endif /* ndef ENEEDAUTH */
#ifdef ENETDOWN
if (x == ENETDOWN)
{*r = Mono_Posix_Errno_ENETDOWN; return 0;}
if (x == ENOANO)
{*r = Mono_Posix_Errno_ENOANO; return 0;}
#endif /* ndef ENOANO */
+#ifdef ENOATTR
+ if (x == ENOATTR)
+ {*r = Mono_Posix_Errno_ENOATTR; return 0;}
+#endif /* ndef ENOATTR */
#ifdef ENOBUFS
if (x == ENOBUFS)
{*r = Mono_Posix_Errno_ENOBUFS; return 0;}
if (x == ENOEXEC)
{*r = Mono_Posix_Errno_ENOEXEC; return 0;}
#endif /* ndef ENOEXEC */
+#ifdef ENOKEY
+ if (x == ENOKEY)
+ {*r = Mono_Posix_Errno_ENOKEY; return 0;}
+#endif /* ndef ENOKEY */
#ifdef ENOLCK
if (x == ENOLCK)
{*r = Mono_Posix_Errno_ENOLCK; return 0;}
if (x == ENOPKG)
{*r = Mono_Posix_Errno_ENOPKG; return 0;}
#endif /* ndef ENOPKG */
+#ifdef ENOPOLICY
+ if (x == ENOPOLICY)
+ {*r = Mono_Posix_Errno_ENOPOLICY; return 0;}
+#endif /* ndef ENOPOLICY */
#ifdef ENOPROTOOPT
if (x == ENOPROTOOPT)
{*r = Mono_Posix_Errno_ENOPROTOOPT; return 0;}
if (x == ENOTNAM)
{*r = Mono_Posix_Errno_ENOTNAM; return 0;}
#endif /* ndef ENOTNAM */
+#ifdef ENOTRECOVERABLE
+ if (x == ENOTRECOVERABLE)
+ {*r = Mono_Posix_Errno_ENOTRECOVERABLE; return 0;}
+#endif /* ndef ENOTRECOVERABLE */
#ifdef ENOTSOCK
if (x == ENOTSOCK)
{*r = Mono_Posix_Errno_ENOTSOCK; return 0;}
if (x == EOVERFLOW)
{*r = Mono_Posix_Errno_EOVERFLOW; return 0;}
#endif /* ndef EOVERFLOW */
+#ifdef EOWNERDEAD
+ if (x == EOWNERDEAD)
+ {*r = Mono_Posix_Errno_EOWNERDEAD; return 0;}
+#endif /* ndef EOWNERDEAD */
#ifdef EPERM
if (x == EPERM)
{*r = Mono_Posix_Errno_EPERM; return 0;}
if (x == EPIPE)
{*r = Mono_Posix_Errno_EPIPE; return 0;}
#endif /* ndef EPIPE */
+#ifdef EPROCLIM
+ if (x == EPROCLIM)
+ {*r = Mono_Posix_Errno_EPROCLIM; return 0;}
+#endif /* ndef EPROCLIM */
+#ifdef EPROCUNAVAIL
+ if (x == EPROCUNAVAIL)
+ {*r = Mono_Posix_Errno_EPROCUNAVAIL; return 0;}
+#endif /* ndef EPROCUNAVAIL */
+#ifdef EPROGMISMATCH
+ if (x == EPROGMISMATCH)
+ {*r = Mono_Posix_Errno_EPROGMISMATCH; return 0;}
+#endif /* ndef EPROGMISMATCH */
+#ifdef EPROGUNAVAIL
+ if (x == EPROGUNAVAIL)
+ {*r = Mono_Posix_Errno_EPROGUNAVAIL; return 0;}
+#endif /* ndef EPROGUNAVAIL */
#ifdef EPROTO
if (x == EPROTO)
{*r = Mono_Posix_Errno_EPROTO; return 0;}
if (x == EPROTOTYPE)
{*r = Mono_Posix_Errno_EPROTOTYPE; return 0;}
#endif /* ndef EPROTOTYPE */
+#ifdef EPWROFF
+ if (x == EPWROFF)
+ {*r = Mono_Posix_Errno_EPWROFF; return 0;}
+#endif /* ndef EPWROFF */
#ifdef ERANGE
if (x == ERANGE)
{*r = Mono_Posix_Errno_ERANGE; return 0;}
if (x == EROFS)
{*r = Mono_Posix_Errno_EROFS; return 0;}
#endif /* ndef EROFS */
+#ifdef ERPCMISMATCH
+ if (x == ERPCMISMATCH)
+ {*r = Mono_Posix_Errno_ERPCMISMATCH; return 0;}
+#endif /* ndef ERPCMISMATCH */
+#ifdef ESHLIBVERS
+ if (x == ESHLIBVERS)
+ {*r = Mono_Posix_Errno_ESHLIBVERS; return 0;}
+#endif /* ndef ESHLIBVERS */
#ifdef ESHUTDOWN
if (x == ESHUTDOWN)
{*r = Mono_Posix_Errno_ESHUTDOWN; return 0;}
#else /* def F_GETSIG */
{errno = EINVAL; return -1;}
#endif /* ndef F_GETSIG */
+ if (x == Mono_Posix_FcntlCommand_F_NOCACHE)
+#ifdef F_NOCACHE
+ {*r = F_NOCACHE; return 0;}
+#else /* def F_NOCACHE */
+ {errno = EINVAL; return -1;}
+#endif /* ndef F_NOCACHE */
if (x == Mono_Posix_FcntlCommand_F_NOTIFY)
#ifdef F_NOTIFY
{*r = F_NOTIFY; return 0;}
if (x == F_GETSIG)
{*r = Mono_Posix_FcntlCommand_F_GETSIG; return 0;}
#endif /* ndef F_GETSIG */
+#ifdef F_NOCACHE
+ if (x == F_NOCACHE)
+ {*r = Mono_Posix_FcntlCommand_F_NOCACHE; return 0;}
+#endif /* ndef F_NOCACHE */
#ifdef F_NOTIFY
if (x == F_NOTIFY)
{*r = Mono_Posix_FcntlCommand_F_NOTIFY; return 0;}
#endif /* ndef DEFFILEMODE */
if ((x & Mono_Posix_FilePermissions_S_IFMT) == Mono_Posix_FilePermissions_S_IFBLK)
#ifdef S_IFBLK
- {*r = S_IFBLK; return 0;}
+ *r |= S_IFBLK;
#else /* def S_IFBLK */
{errno = EINVAL; return -1;}
#endif /* ndef S_IFBLK */
if ((x & Mono_Posix_FilePermissions_S_IFMT) == Mono_Posix_FilePermissions_S_IFCHR)
#ifdef S_IFCHR
- {*r = S_IFCHR; return 0;}
+ *r |= S_IFCHR;
#else /* def S_IFCHR */
{errno = EINVAL; return -1;}
#endif /* ndef S_IFCHR */
if ((x & Mono_Posix_FilePermissions_S_IFMT) == Mono_Posix_FilePermissions_S_IFDIR)
#ifdef S_IFDIR
- {*r = S_IFDIR; return 0;}
+ *r |= S_IFDIR;
#else /* def S_IFDIR */
{errno = EINVAL; return -1;}
#endif /* ndef S_IFDIR */
if ((x & Mono_Posix_FilePermissions_S_IFMT) == Mono_Posix_FilePermissions_S_IFIFO)
#ifdef S_IFIFO
- {*r = S_IFIFO; return 0;}
+ *r |= S_IFIFO;
#else /* def S_IFIFO */
{errno = EINVAL; return -1;}
#endif /* ndef S_IFIFO */
if ((x & Mono_Posix_FilePermissions_S_IFMT) == Mono_Posix_FilePermissions_S_IFLNK)
#ifdef S_IFLNK
- {*r = S_IFLNK; return 0;}
+ *r |= S_IFLNK;
#else /* def S_IFLNK */
{errno = EINVAL; return -1;}
#endif /* ndef S_IFLNK */
#endif /* ndef S_IFMT */
if ((x & Mono_Posix_FilePermissions_S_IFMT) == Mono_Posix_FilePermissions_S_IFREG)
#ifdef S_IFREG
- {*r = S_IFREG; return 0;}
+ *r |= S_IFREG;
#else /* def S_IFREG */
{errno = EINVAL; return -1;}
#endif /* ndef S_IFREG */
if ((x & Mono_Posix_FilePermissions_S_IFMT) == Mono_Posix_FilePermissions_S_IFSOCK)
#ifdef S_IFSOCK
- {*r = S_IFSOCK; return 0;}
+ *r |= S_IFSOCK;
#else /* def S_IFSOCK */
{errno = EINVAL; return -1;}
#endif /* ndef S_IFSOCK */
return 0;
}
+#ifdef HAVE_STRUCT_FLOCK
+int
+Mono_Posix_FromFlock (struct Mono_Posix_Flock *from, struct flock *to)
+{
+ _cnm_return_val_if_overflow (off_t, from->l_start, -1);
+ _cnm_return_val_if_overflow (off_t, from->l_len, -1);
+ _cnm_return_val_if_overflow (pid_t, from->l_pid, -1);
+
+ memset (to, 0, sizeof(*to));
+
+ if (Mono_Posix_FromLockType (from->l_type, &to->l_type) != 0) {
+ return -1;
+ }
+ if (Mono_Posix_FromSeekFlags (from->l_whence, &to->l_whence) != 0) {
+ return -1;
+ }
+ to->l_start = from->l_start;
+ to->l_len = from->l_len;
+ to->l_pid = from->l_pid;
+
+ return 0;
+}
+#endif /* ndef HAVE_STRUCT_FLOCK */
+
+
+#ifdef HAVE_STRUCT_FLOCK
+int
+Mono_Posix_ToFlock (struct flock *from, struct Mono_Posix_Flock *to)
+{
+ _cnm_return_val_if_overflow (gint64, from->l_start, -1);
+ _cnm_return_val_if_overflow (gint64, from->l_len, -1);
+ _cnm_return_val_if_overflow (int, from->l_pid, -1);
+
+ memset (to, 0, sizeof(*to));
+
+ if (Mono_Posix_ToLockType (from->l_type, &to->l_type) != 0) {
+ return -1;
+ }
+ if (Mono_Posix_ToSeekFlags (from->l_whence, &to->l_whence) != 0) {
+ return -1;
+ }
+ to->l_start = from->l_start;
+ to->l_len = from->l_len;
+ to->l_pid = from->l_pid;
+
+ return 0;
+}
+#endif /* ndef HAVE_STRUCT_FLOCK */
+
+
+#ifdef HAVE_STRUCT_IOVEC
+int
+Mono_Posix_FromIovec (struct Mono_Posix_Iovec *from, struct iovec *to)
+{
+ _cnm_return_val_if_overflow (guint64, from->iov_len, -1);
+
+ memset (to, 0, sizeof(*to));
+
+ to->iov_base = from->iov_base;
+ to->iov_len = from->iov_len;
+
+ return 0;
+}
+#endif /* ndef HAVE_STRUCT_IOVEC */
+
+
+#ifdef HAVE_STRUCT_IOVEC
+int
+Mono_Posix_ToIovec (struct iovec *from, struct Mono_Posix_Iovec *to)
+{
+ _cnm_return_val_if_overflow (guint64, from->iov_len, -1);
+
+ memset (to, 0, sizeof(*to));
+
+ to->iov_base = from->iov_base;
+ to->iov_len = from->iov_len;
+
+ return 0;
+}
+#endif /* ndef HAVE_STRUCT_IOVEC */
+
+
int Mono_Posix_FromLockType (short x, short *r)
{
*r = 0;
#else /* def ST_APPEND */
{errno = EINVAL; return -1;}
#endif /* ndef ST_APPEND */
+ if ((x & Mono_Posix_MountFlags_ST_BIND) == Mono_Posix_MountFlags_ST_BIND)
+#ifdef ST_BIND
+ *r |= ST_BIND;
+#else /* def ST_BIND */
+ {errno = EINVAL; return -1;}
+#endif /* ndef ST_BIND */
if ((x & Mono_Posix_MountFlags_ST_IMMUTABLE) == Mono_Posix_MountFlags_ST_IMMUTABLE)
#ifdef ST_IMMUTABLE
*r |= ST_IMMUTABLE;
#else /* def ST_NODIRATIME */
{errno = EINVAL; return -1;}
#endif /* ndef ST_NODIRATIME */
+ if ((x & Mono_Posix_MountFlags_ST_NOEXEC) == Mono_Posix_MountFlags_ST_NOEXEC)
+#ifdef ST_NOEXEC
+ *r |= ST_NOEXEC;
+#else /* def ST_NOEXEC */
+ {errno = EINVAL; return -1;}
+#endif /* ndef ST_NOEXEC */
if ((x & Mono_Posix_MountFlags_ST_NOSUID) == Mono_Posix_MountFlags_ST_NOSUID)
#ifdef ST_NOSUID
*r |= ST_NOSUID;
#else /* def ST_RDONLY */
{errno = EINVAL; return -1;}
#endif /* ndef ST_RDONLY */
+ if ((x & Mono_Posix_MountFlags_ST_REMOUNT) == Mono_Posix_MountFlags_ST_REMOUNT)
+#ifdef ST_REMOUNT
+ *r |= ST_REMOUNT;
+#else /* def ST_REMOUNT */
+ {errno = EINVAL; return -1;}
+#endif /* ndef ST_REMOUNT */
if ((x & Mono_Posix_MountFlags_ST_SYNCHRONOUS) == Mono_Posix_MountFlags_ST_SYNCHRONOUS)
#ifdef ST_SYNCHRONOUS
*r |= ST_SYNCHRONOUS;
if ((x & ST_APPEND) == ST_APPEND)
*r |= Mono_Posix_MountFlags_ST_APPEND;
#endif /* ndef ST_APPEND */
+#ifdef ST_BIND
+ if ((x & ST_BIND) == ST_BIND)
+ *r |= Mono_Posix_MountFlags_ST_BIND;
+#endif /* ndef ST_BIND */
#ifdef ST_IMMUTABLE
if ((x & ST_IMMUTABLE) == ST_IMMUTABLE)
*r |= Mono_Posix_MountFlags_ST_IMMUTABLE;
if ((x & ST_NODIRATIME) == ST_NODIRATIME)
*r |= Mono_Posix_MountFlags_ST_NODIRATIME;
#endif /* ndef ST_NODIRATIME */
+#ifdef ST_NOEXEC
+ if ((x & ST_NOEXEC) == ST_NOEXEC)
+ *r |= Mono_Posix_MountFlags_ST_NOEXEC;
+#endif /* ndef ST_NOEXEC */
#ifdef ST_NOSUID
if ((x & ST_NOSUID) == ST_NOSUID)
*r |= Mono_Posix_MountFlags_ST_NOSUID;
if ((x & ST_RDONLY) == ST_RDONLY)
*r |= Mono_Posix_MountFlags_ST_RDONLY;
#endif /* ndef ST_RDONLY */
+#ifdef ST_REMOUNT
+ if ((x & ST_REMOUNT) == ST_REMOUNT)
+ *r |= Mono_Posix_MountFlags_ST_REMOUNT;
+#endif /* ndef ST_REMOUNT */
#ifdef ST_SYNCHRONOUS
if ((x & ST_SYNCHRONOUS) == ST_SYNCHRONOUS)
*r |= Mono_Posix_MountFlags_ST_SYNCHRONOUS;
#else /* def O_ASYNC */
{errno = EINVAL; return -1;}
#endif /* ndef O_ASYNC */
+ if ((x & Mono_Posix_OpenFlags_O_CLOEXEC) == Mono_Posix_OpenFlags_O_CLOEXEC)
+#ifdef O_CLOEXEC
+ *r |= O_CLOEXEC;
+#else /* def O_CLOEXEC */
+ {errno = EINVAL; return -1;}
+#endif /* ndef O_CLOEXEC */
if ((x & Mono_Posix_OpenFlags_O_CREAT) == Mono_Posix_OpenFlags_O_CREAT)
#ifdef O_CREAT
*r |= O_CREAT;
#else /* def O_NONBLOCK */
{errno = EINVAL; return -1;}
#endif /* ndef O_NONBLOCK */
+ if ((x & Mono_Posix_OpenFlags_O_PATH) == Mono_Posix_OpenFlags_O_PATH)
+#ifdef O_PATH
+ *r |= O_PATH;
+#else /* def O_PATH */
+ {errno = EINVAL; return -1;}
+#endif /* ndef O_PATH */
if ((x & Mono_Posix_OpenFlags_O_RDONLY) == Mono_Posix_OpenFlags_O_RDONLY)
#ifdef O_RDONLY
*r |= O_RDONLY;
if ((x & O_ASYNC) == O_ASYNC)
*r |= Mono_Posix_OpenFlags_O_ASYNC;
#endif /* ndef O_ASYNC */
+#ifdef O_CLOEXEC
+ if ((x & O_CLOEXEC) == O_CLOEXEC)
+ *r |= Mono_Posix_OpenFlags_O_CLOEXEC;
+#endif /* ndef O_CLOEXEC */
#ifdef O_CREAT
if ((x & O_CREAT) == O_CREAT)
*r |= Mono_Posix_OpenFlags_O_CREAT;
if ((x & O_NONBLOCK) == O_NONBLOCK)
*r |= Mono_Posix_OpenFlags_O_NONBLOCK;
#endif /* ndef O_NONBLOCK */
+#ifdef O_PATH
+ if ((x & O_PATH) == O_PATH)
+ *r |= Mono_Posix_OpenFlags_O_PATH;
+#endif /* ndef O_PATH */
#ifdef O_RDONLY
if ((x & O_RDONLY) == O_RDONLY)
*r |= Mono_Posix_OpenFlags_O_RDONLY;
errno = EINVAL; return -1;
}
-#ifdef HAVE_STRUCT_STAT
-int
-Mono_Posix_FromStat (struct Mono_Posix_Stat *from, struct stat *to)
-{
- _cnm_return_val_if_overflow (dev_t, from->st_dev, -1);
- _cnm_return_val_if_overflow (ino_t, from->st_ino, -1);
- _cnm_return_val_if_overflow (nlink_t, from->st_nlink, -1);
- _cnm_return_val_if_overflow (uid_t, from->st_uid, -1);
- _cnm_return_val_if_overflow (gid_t, from->st_gid, -1);
- _cnm_return_val_if_overflow (dev_t, from->st_rdev, -1);
- _cnm_return_val_if_overflow (off_t, from->st_size, -1);
- _cnm_return_val_if_overflow (blksize_t, from->st_blksize, -1);
- _cnm_return_val_if_overflow (blkcnt_t, from->st_blocks, -1);
- _cnm_return_val_if_overflow (time_t, from->st_atime_, -1);
- _cnm_return_val_if_overflow (time_t, from->st_mtime_, -1);
- _cnm_return_val_if_overflow (time_t, from->st_ctime_, -1);
-
- memset (to, 0, sizeof(*to));
-
- to->st_dev = from->st_dev;
- to->st_ino = from->st_ino;
- if (Mono_Posix_FromFilePermissions (from->st_mode, &to->st_mode) != 0) {
- return -1;
- }
- to->st_nlink = from->st_nlink;
- to->st_uid = from->st_uid;
- to->st_gid = from->st_gid;
- to->st_rdev = from->st_rdev;
- to->st_size = from->st_size;
- to->st_blksize = from->st_blksize;
- to->st_blocks = from->st_blocks;
- to->st_atime = from->st_atime_;
- to->st_mtime = from->st_mtime_;
- to->st_ctime = from->st_ctime_;
-
- return 0;
-}
-#endif /* ndef HAVE_STRUCT_STAT */
-
-
-#ifdef HAVE_STRUCT_STAT
-int
-Mono_Posix_ToStat (struct stat *from, struct Mono_Posix_Stat *to)
-{
- _cnm_return_val_if_overflow (guint64, from->st_dev, -1);
- _cnm_return_val_if_overflow (guint64, from->st_ino, -1);
- _cnm_return_val_if_overflow (guint64, from->st_nlink, -1);
- _cnm_return_val_if_overflow (unsigned int, from->st_uid, -1);
- _cnm_return_val_if_overflow (unsigned int, from->st_gid, -1);
- _cnm_return_val_if_overflow (guint64, from->st_rdev, -1);
- _cnm_return_val_if_overflow (gint64, from->st_size, -1);
- _cnm_return_val_if_overflow (gint64, from->st_blksize, -1);
- _cnm_return_val_if_overflow (gint64, from->st_blocks, -1);
- _cnm_return_val_if_overflow (gint64, from->st_atime, -1);
- _cnm_return_val_if_overflow (gint64, from->st_mtime, -1);
- _cnm_return_val_if_overflow (gint64, from->st_ctime, -1);
-
- memset (to, 0, sizeof(*to));
-
- to->st_dev = from->st_dev;
- to->st_ino = from->st_ino;
- if (Mono_Posix_ToFilePermissions (from->st_mode, &to->st_mode) != 0) {
- return -1;
- }
- to->st_nlink = from->st_nlink;
- to->st_uid = from->st_uid;
- to->st_gid = from->st_gid;
- to->st_rdev = from->st_rdev;
- to->st_size = from->st_size;
- to->st_blksize = from->st_blksize;
- to->st_blocks = from->st_blocks;
- to->st_atime_ = from->st_atime;
- to->st_mtime_ = from->st_mtime;
- to->st_ctime_ = from->st_ctime;
-
- return 0;
-}
-#endif /* ndef HAVE_STRUCT_STAT */
-
-
int Mono_Posix_FromSysconfName (int x, int *r)
{
*r = 0;
return 0;
}
+#ifdef HAVE_STRUCT_TIMESPEC
+int
+Mono_Posix_FromTimespec (struct Mono_Posix_Timespec *from, struct timespec *to)
+{
+ _cnm_return_val_if_overflow (time_t, from->tv_sec, -1);
+ _cnm_return_val_if_overflow (gint64, from->tv_nsec, -1);
+
+ memset (to, 0, sizeof(*to));
+
+ to->tv_sec = from->tv_sec;
+ to->tv_nsec = from->tv_nsec;
+
+ return 0;
+}
+#endif /* ndef HAVE_STRUCT_TIMESPEC */
+
+
+#ifdef HAVE_STRUCT_TIMESPEC
+int
+Mono_Posix_ToTimespec (struct timespec *from, struct Mono_Posix_Timespec *to)
+{
+ _cnm_return_val_if_overflow (gint64, from->tv_sec, -1);
+ _cnm_return_val_if_overflow (gint64, from->tv_nsec, -1);
+
+ memset (to, 0, sizeof(*to));
+
+ to->tv_sec = from->tv_sec;
+ to->tv_nsec = from->tv_nsec;
+
+ return 0;
+}
+#endif /* ndef HAVE_STRUCT_TIMESPEC */
+
+
#ifdef HAVE_STRUCT_TIMEVAL
int
Mono_Posix_FromTimeval (struct Mono_Posix_Timeval *from, struct timeval *to)
#endif /* ndef HAVE_STRUCT_TIMEZONE */
+#ifdef HAVE_STRUCT_UTIMBUF
+int
+Mono_Posix_FromUtimbuf (struct Mono_Posix_Utimbuf *from, struct utimbuf *to)
+{
+ _cnm_return_val_if_overflow (time_t, from->actime, -1);
+ _cnm_return_val_if_overflow (time_t, from->modtime, -1);
+
+ memset (to, 0, sizeof(*to));
+
+ to->actime = from->actime;
+ to->modtime = from->modtime;
+
+ return 0;
+}
+#endif /* ndef HAVE_STRUCT_UTIMBUF */
+
+
+#ifdef HAVE_STRUCT_UTIMBUF
+int
+Mono_Posix_ToUtimbuf (struct utimbuf *from, struct Mono_Posix_Utimbuf *to)
+{
+ _cnm_return_val_if_overflow (gint64, from->actime, -1);
+ _cnm_return_val_if_overflow (gint64, from->modtime, -1);
+
+ memset (to, 0, sizeof(*to));
+
+ to->actime = from->actime;
+ to->modtime = from->modtime;
+
+ return 0;
+}
+#endif /* ndef HAVE_STRUCT_UTIMBUF */
+
+
int Mono_Posix_FromWaitOptions (int x, int *r)
{
*r = 0;
projects / mono.git / blobdiff