X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;ds=sidebyside;f=support%2Fmap.c;h=0fc5255640b4655b3d5928221ed767ecb24520fa;hb=60b4cff5271ccef9d359c3b52aa5273f2051a3a6;hp=a8563a7f7a98a91193474ae3528420b9db6b8111;hpb=181685972733a2109a12e24f75558b16ae32cbf8;p=mono.git diff --git a/support/map.c b/support/map.c index a8563a7f7a9..0fc5255640b 100644 --- a/support/map.c +++ b/support/map.c @@ -27,7 +27,9 @@ */ #include #include +#ifdef HAVE_SYS_TIME_H #include +#endif /* ndef HAVE_SYS_TIME_H */ #ifdef HAVE_SYS_POLL_H #include #endif /* ndef HAVE_SYS_POLL_H */ @@ -43,7 +45,9 @@ #ifdef HAVE_SYS_MMAN_H #include #endif /* ndef HAVE_SYS_MMAN_H */ +#ifdef HAVE_UNISTD_H #include +#endif /* ndef HAVE_UNISTD_H */ #include #include #ifdef HAVE_POLL_H @@ -56,8 +60,13 @@ #ifdef HAVE_SYSLOG_H #include #endif /* ndef HAVE_SYSLOG_H */ +#ifdef HAVE_DIRENT_H #include +#endif /* ndef HAVE_DIRENT_H */ +#ifdef HAVE_UTIME_H #include +#endif /* ndef HAVE_UTIME_H */ +#include #include "mph.h" #include "map.h" @@ -65,16 +74,89 @@ #include /* errno, EOVERFLOW */ #include /* g* types, g_assert_not_reached() */ +#if defined (G_MININT8) +#define CNM_MININT8 G_MININT8 +#else +#define CNM_MININT8 (-128) +#endif + +#if defined (G_MAXINT8) +#define CNM_MAXINT8 G_MAXINT8 +#else +#define CNM_MAXINT8 (127) +#endif + +#if defined (G_MAXUINT8) +#define CNM_MAXUINT8 G_MAXUINT8 +#else +#define CNM_MAXUINT8 (255) +#endif + +#if defined (G_MININT16) +#define CNM_MININT16 G_MININT16 +#else +#define CNM_MININT16 (-32768) +#endif + +#if defined (G_MAXINT16) +#define CNM_MAXINT16 G_MAXINT16 +#else +#define CNM_MAXINT16 (32767) +#endif + +#if defined (G_MAXUINT16) +#define CNM_MAXUINT16 G_MAXUINT16 +#else +#define CNM_MAXUINT16 (65535) +#endif + +#if defined (G_MININT32) +#define CNM_MININT32 G_MININT32 +#else +#define CNM_MININT32 (-2147483648) +#endif + +#if defined (G_MAXINT32) +#define CNM_MAXINT32 G_MAXINT32 +#else +#define CNM_MAXINT32 (2147483647) +#endif + +#if defined (G_MAXUINT32) +#define CNM_MAXUINT32 G_MAXUINT32 +#else +#define CNM_MAXUINT32 (4294967295U) +#endif + +#if defined (G_MININT64) +#define CNM_MININT64 G_MININT64 +#else +#define CNM_MININT64 (-9223372036854775808LL) +#endif + +#if defined (G_MAXINT64) +#define CNM_MAXINT64 G_MAXINT64 +#else +#define CNM_MAXINT64 (9223372036854775807LL) +#endif + +#if defined (G_MAXUINT64) +#define CNM_MAXUINT64 G_MAXUINT64 +#else +#define CNM_MAXUINT64 (18446744073709551615ULL) +#endif + + /* returns TRUE if @type is an unsigned type */ #define _cnm_integral_type_is_unsigned(type) \ (sizeof(type) == sizeof(gint8) \ - ? (((type)-1) > G_MAXINT8) \ + ? (((type)-1) > CNM_MAXINT8) \ : sizeof(type) == sizeof(gint16) \ - ? (((type)-1) > G_MAXINT16) \ + ? (((type)-1) > CNM_MAXINT16) \ : sizeof(type) == sizeof(gint32) \ - ? (((type)-1) > G_MAXINT32) \ + ? (((type)-1) > CNM_MAXINT32) \ : sizeof(type) == sizeof(gint64) \ - ? (((type)-1) > G_MAXINT64) \ + ? (((type)-1) > CNM_MAXINT64) \ : (g_assert_not_reached (), 0)) /* returns the minimum value of @type as a gint64 */ @@ -82,63 +164,77 @@ (_cnm_integral_type_is_unsigned (type) \ ? 0 \ : sizeof(type) == sizeof(gint8) \ - ? G_MININT8 \ + ? CNM_MININT8 \ : sizeof(type) == sizeof(gint16) \ - ? G_MININT16 \ + ? CNM_MININT16 \ : sizeof(type) == sizeof(gint32) \ - ? G_MININT32 \ + ? CNM_MININT32 \ : sizeof(type) == sizeof(gint64) \ - ? G_MININT64 \ + ? CNM_MININT64 \ : (g_assert_not_reached (), 0)) /* returns the maximum value of @type as a guint64 */ #define _cnm_integral_type_max(type) \ (_cnm_integral_type_is_unsigned (type) \ ? sizeof(type) == sizeof(gint8) \ - ? G_MAXUINT8 \ + ? CNM_MAXUINT8 \ : sizeof(type) == sizeof(gint16) \ - ? G_MAXUINT16 \ + ? CNM_MAXUINT16 \ : sizeof(type) == sizeof(gint32) \ - ? G_MAXUINT32 \ + ? CNM_MAXUINT32 \ : sizeof(type) == sizeof(gint64) \ - ? G_MAXUINT64 \ + ? CNM_MAXUINT64 \ : (g_assert_not_reached (), 0) \ : sizeof(type) == sizeof(gint8) \ - ? G_MAXINT8 \ + ? CNM_MAXINT8 \ : sizeof(type) == sizeof(gint16) \ - ? G_MAXINT16 \ + ? CNM_MAXINT16 \ : sizeof(type) == sizeof(gint32) \ - ? G_MAXINT32 \ + ? CNM_MAXINT32 \ : sizeof(type) == sizeof(gint64) \ - ? G_MAXINT64 \ + ? 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 { \ - if (!(_cnm_integral_type_min(to_t) <= from && \ - ((from < 0) || (from <= _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) { @@ -2167,45 +2263,45 @@ int Mono_Posix_FromFilePermissions (unsigned int x, unsigned int *r) #ifdef ACCESSPERMS *r |= ACCESSPERMS; #else /* def ACCESSPERMS */ - {errno = EINVAL; return -1;} + {/* Ignoring Mono_Posix_FilePermissions_ACCESSPERMS, as it is constructed from other values */} #endif /* ndef ACCESSPERMS */ if ((x & Mono_Posix_FilePermissions_ALLPERMS) == Mono_Posix_FilePermissions_ALLPERMS) #ifdef ALLPERMS *r |= ALLPERMS; #else /* def ALLPERMS */ - {errno = EINVAL; return -1;} + {/* Ignoring Mono_Posix_FilePermissions_ALLPERMS, as it is constructed from other values */} #endif /* ndef ALLPERMS */ if ((x & Mono_Posix_FilePermissions_DEFFILEMODE) == Mono_Posix_FilePermissions_DEFFILEMODE) #ifdef DEFFILEMODE *r |= DEFFILEMODE; #else /* def DEFFILEMODE */ - {errno = EINVAL; return -1;} + {/* Ignoring Mono_Posix_FilePermissions_DEFFILEMODE, as it is constructed from other values */} #endif /* ndef DEFFILEMODE */ - if ((x & Mono_Posix_FilePermissions_S_IFBLK) == Mono_Posix_FilePermissions_S_IFBLK) + if ((x & Mono_Posix_FilePermissions_S_IFMT) == Mono_Posix_FilePermissions_S_IFBLK) #ifdef S_IFBLK *r |= S_IFBLK; #else /* def S_IFBLK */ {errno = EINVAL; return -1;} #endif /* ndef S_IFBLK */ - if ((x & Mono_Posix_FilePermissions_S_IFCHR) == Mono_Posix_FilePermissions_S_IFCHR) + if ((x & Mono_Posix_FilePermissions_S_IFMT) == Mono_Posix_FilePermissions_S_IFCHR) #ifdef S_IFCHR *r |= S_IFCHR; #else /* def S_IFCHR */ {errno = EINVAL; return -1;} #endif /* ndef S_IFCHR */ - if ((x & Mono_Posix_FilePermissions_S_IFDIR) == Mono_Posix_FilePermissions_S_IFDIR) + if ((x & Mono_Posix_FilePermissions_S_IFMT) == Mono_Posix_FilePermissions_S_IFDIR) #ifdef S_IFDIR *r |= S_IFDIR; #else /* def S_IFDIR */ {errno = EINVAL; return -1;} #endif /* ndef S_IFDIR */ - if ((x & Mono_Posix_FilePermissions_S_IFIFO) == Mono_Posix_FilePermissions_S_IFIFO) + if ((x & Mono_Posix_FilePermissions_S_IFMT) == Mono_Posix_FilePermissions_S_IFIFO) #ifdef S_IFIFO *r |= S_IFIFO; #else /* def S_IFIFO */ {errno = EINVAL; return -1;} #endif /* ndef S_IFIFO */ - if ((x & Mono_Posix_FilePermissions_S_IFLNK) == Mono_Posix_FilePermissions_S_IFLNK) + if ((x & Mono_Posix_FilePermissions_S_IFMT) == Mono_Posix_FilePermissions_S_IFLNK) #ifdef S_IFLNK *r |= S_IFLNK; #else /* def S_IFLNK */ @@ -2215,15 +2311,15 @@ int Mono_Posix_FromFilePermissions (unsigned int x, unsigned int *r) #ifdef S_IFMT *r |= S_IFMT; #else /* def S_IFMT */ - {errno = EINVAL; return -1;} + {/* Ignoring Mono_Posix_FilePermissions_S_IFMT, as it is constructed from other values */} #endif /* ndef S_IFMT */ - if ((x & Mono_Posix_FilePermissions_S_IFREG) == Mono_Posix_FilePermissions_S_IFREG) + if ((x & Mono_Posix_FilePermissions_S_IFMT) == Mono_Posix_FilePermissions_S_IFREG) #ifdef S_IFREG *r |= S_IFREG; #else /* def S_IFREG */ {errno = EINVAL; return -1;} #endif /* ndef S_IFREG */ - if ((x & Mono_Posix_FilePermissions_S_IFSOCK) == Mono_Posix_FilePermissions_S_IFSOCK) + if ((x & Mono_Posix_FilePermissions_S_IFMT) == Mono_Posix_FilePermissions_S_IFSOCK) #ifdef S_IFSOCK *r |= S_IFSOCK; #else /* def S_IFSOCK */ @@ -2251,19 +2347,19 @@ int Mono_Posix_FromFilePermissions (unsigned int x, unsigned int *r) #ifdef S_IRWXG *r |= S_IRWXG; #else /* def S_IRWXG */ - {errno = EINVAL; return -1;} + {/* Ignoring Mono_Posix_FilePermissions_S_IRWXG, as it is constructed from other values */} #endif /* ndef S_IRWXG */ if ((x & Mono_Posix_FilePermissions_S_IRWXO) == Mono_Posix_FilePermissions_S_IRWXO) #ifdef S_IRWXO *r |= S_IRWXO; #else /* def S_IRWXO */ - {errno = EINVAL; return -1;} + {/* Ignoring Mono_Posix_FilePermissions_S_IRWXO, as it is constructed from other values */} #endif /* ndef S_IRWXO */ if ((x & Mono_Posix_FilePermissions_S_IRWXU) == Mono_Posix_FilePermissions_S_IRWXU) #ifdef S_IRWXU *r |= S_IRWXU; #else /* def S_IRWXU */ - {errno = EINVAL; return -1;} + {/* Ignoring Mono_Posix_FilePermissions_S_IRWXU, as it is constructed from other values */} #endif /* ndef S_IRWXU */ if ((x & Mono_Posix_FilePermissions_S_ISGID) == Mono_Posix_FilePermissions_S_ISGID) #ifdef S_ISGID @@ -2342,23 +2438,23 @@ int Mono_Posix_ToFilePermissions (unsigned int x, unsigned int *r) *r |= Mono_Posix_FilePermissions_DEFFILEMODE; #endif /* ndef DEFFILEMODE */ #ifdef S_IFBLK - if ((x & S_IFBLK) == S_IFBLK) + if ((x & S_IFMT) == S_IFBLK) *r |= Mono_Posix_FilePermissions_S_IFBLK; #endif /* ndef S_IFBLK */ #ifdef S_IFCHR - if ((x & S_IFCHR) == S_IFCHR) + if ((x & S_IFMT) == S_IFCHR) *r |= Mono_Posix_FilePermissions_S_IFCHR; #endif /* ndef S_IFCHR */ #ifdef S_IFDIR - if ((x & S_IFDIR) == S_IFDIR) + if ((x & S_IFMT) == S_IFDIR) *r |= Mono_Posix_FilePermissions_S_IFDIR; #endif /* ndef S_IFDIR */ #ifdef S_IFIFO - if ((x & S_IFIFO) == S_IFIFO) + if ((x & S_IFMT) == S_IFIFO) *r |= Mono_Posix_FilePermissions_S_IFIFO; #endif /* ndef S_IFIFO */ #ifdef S_IFLNK - if ((x & S_IFLNK) == S_IFLNK) + if ((x & S_IFMT) == S_IFLNK) *r |= Mono_Posix_FilePermissions_S_IFLNK; #endif /* ndef S_IFLNK */ #ifdef S_IFMT @@ -2366,11 +2462,11 @@ int Mono_Posix_ToFilePermissions (unsigned int x, unsigned int *r) *r |= Mono_Posix_FilePermissions_S_IFMT; #endif /* ndef S_IFMT */ #ifdef S_IFREG - if ((x & S_IFREG) == S_IFREG) + if ((x & S_IFMT) == S_IFREG) *r |= Mono_Posix_FilePermissions_S_IFREG; #endif /* ndef S_IFREG */ #ifdef S_IFSOCK - if ((x & S_IFSOCK) == S_IFSOCK) + if ((x & S_IFMT) == S_IFSOCK) *r |= Mono_Posix_FilePermissions_S_IFSOCK; #endif /* ndef S_IFSOCK */ #ifdef S_IRGRP @@ -2436,6 +2532,56 @@ int Mono_Posix_ToFilePermissions (unsigned int x, unsigned int *r) 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 */ + + int Mono_Posix_FromLockType (short x, short *r) { *r = 0; @@ -2815,6 +2961,12 @@ int Mono_Posix_FromMountFlags (guint64 x, guint64 *r) #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; @@ -2845,6 +2997,12 @@ int Mono_Posix_FromMountFlags (guint64 x, guint64 *r) #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; @@ -2857,6 +3015,12 @@ int Mono_Posix_FromMountFlags (guint64 x, guint64 *r) #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; @@ -2883,6 +3047,10 @@ int Mono_Posix_ToMountFlags (guint64 x, guint64 *r) 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; @@ -2903,6 +3071,10 @@ int Mono_Posix_ToMountFlags (guint64 x, guint64 *r) 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; @@ -2911,6 +3083,10 @@ int Mono_Posix_ToMountFlags (guint64 x, guint64 *r) 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; @@ -3502,6 +3678,7 @@ int Mono_Posix_ToPollEvents (short x, short *r) return 0; } +#ifdef HAVE_STRUCT_POLLFD int Mono_Posix_FromPollfd (struct Mono_Posix_Pollfd *from, struct pollfd *to) { @@ -3519,8 +3696,10 @@ Mono_Posix_FromPollfd (struct Mono_Posix_Pollfd *from, struct pollfd *to) return 0; } +#endif /* ndef HAVE_STRUCT_POLLFD */ +#ifdef HAVE_STRUCT_POLLFD int Mono_Posix_ToPollfd (struct pollfd *from, struct Mono_Posix_Pollfd *to) { @@ -3538,6 +3717,7 @@ Mono_Posix_ToPollfd (struct pollfd *from, struct Mono_Posix_Pollfd *to) return 0; } +#endif /* ndef HAVE_STRUCT_POLLFD */ int Mono_Posix_FromPosixFadviseAdvice (int x, int *r) @@ -4124,6 +4304,7 @@ int Mono_Posix_ToSignum (int x, int *r) errno = EINVAL; return -1; } +#ifdef HAVE_STRUCT_STAT int Mono_Posix_FromStat (struct Mono_Posix_Stat *from, struct stat *to) { @@ -4160,8 +4341,10 @@ Mono_Posix_FromStat (struct Mono_Posix_Stat *from, struct stat *to) return 0; } +#endif /* ndef HAVE_STRUCT_STAT */ +#ifdef HAVE_STRUCT_STAT int Mono_Posix_ToStat (struct stat *from, struct Mono_Posix_Stat *to) { @@ -4198,6 +4381,7 @@ Mono_Posix_ToStat (struct stat *from, struct Mono_Posix_Stat *to) return 0; } +#endif /* ndef HAVE_STRUCT_STAT */ int Mono_Posix_FromSysconfName (int x, int *r) @@ -6614,6 +6798,41 @@ int Mono_Posix_ToSyslogOptions (int x, int *r) 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) { @@ -6627,8 +6846,10 @@ Mono_Posix_FromTimeval (struct Mono_Posix_Timeval *from, struct timeval *to) return 0; } +#endif /* ndef HAVE_STRUCT_TIMEVAL */ +#ifdef HAVE_STRUCT_TIMEVAL int Mono_Posix_ToTimeval (struct timeval *from, struct Mono_Posix_Timeval *to) { @@ -6642,8 +6863,10 @@ Mono_Posix_ToTimeval (struct timeval *from, struct Mono_Posix_Timeval *to) return 0; } +#endif /* ndef HAVE_STRUCT_TIMEVAL */ +#ifdef HAVE_STRUCT_TIMEZONE int Mono_Posix_FromTimezone (struct Mono_Posix_Timezone *from, struct timezone *to) { @@ -6657,8 +6880,10 @@ Mono_Posix_FromTimezone (struct Mono_Posix_Timezone *from, struct timezone *to) return 0; } +#endif /* ndef HAVE_STRUCT_TIMEZONE */ +#ifdef HAVE_STRUCT_TIMEZONE int Mono_Posix_ToTimezone (struct timezone *from, struct Mono_Posix_Timezone *to) { @@ -6672,6 +6897,41 @@ Mono_Posix_ToTimezone (struct timezone *from, struct Mono_Posix_Timezone *to) return 0; } +#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)