* map-icalls.h: Added; auto-generated file which contains Mono_Posix_*

    declarations for DllImport functions in Mono.Posix.dll.  This ensure
    consistency between Mono.Posix.dll and MonoPosixHelper.so.
  * mph.h: Add include for map-icalls.h, to ensure that all MonoPosixHelper
    exports have correct prototypes.
  * dirent.c, grp.c, macros.c, pwd.c, signal.c, stdio.c, sys-stat.c,
    sys-time.c, utime.c: Correct prototypes to match map-icalls.h.  Alas, this
    "loses" information -- FILE* becomes void*, etc. -- but no semantics or
    ABI should be changed (except for Mono_Posix_Syscall_utime).  Some
    structure names also changed to match the generated names; since the
    structures are private, this shouldn't break anything.
  * errno.c: Remove Mono_Posix_Syscall_SetLastError so we don't get a warning
    about a missing prototype.  This was never in a stable release.
  * old-map.c: Include mph.h for prototype checking.
  * unistd.c: SeekFlags conversion is now done in managed code so that a short
    isn't passed as a parameter; Correct prototypes to match map-icalls.h.
  * sys-xattr.c: fix lsetxattr/fsetxattr confusion; Correct prototypes to
    match map-icalls.h.
  * sys-sendfile.c: Move mph.h include so that HAVE_SYS_SENDFILE_H is used.
  * sys-wait.c: Include mph.h so that prototypes are checked.

svn path=/trunk/mono/; revision=44702

18 files changed, 328 insertions, 94 deletions

diff --git a/support/ChangeLog b/support/ChangeLog
index 8efaa6900d1..697012885ad 100644
--- a/support/ChangeLog
+++ b/support/ChangeLog
@@ -1,3 +1,26 @@
+2005-05-18  Jonathan Pryor  <jonpryor@vt.edu>
+
+	* map-icalls.h: Added; auto-generated file which contains Mono_Posix_*
+	  declarations for DllImport functions in Mono.Posix.dll.  This ensure
+	  consistency between Mono.Posix.dll and MonoPosixHelper.so.
+	* mph.h: Add include for map-icalls.h, to ensure that all MonoPosixHelper
+	  exports have correct prototypes.
+	* dirent.c, grp.c, macros.c, pwd.c, signal.c, stdio.c, sys-stat.c, 
+	  sys-time.c, utime.c: Correct prototypes to match map-icalls.h.  Alas, this
+	  "loses" information -- FILE* becomes void*, etc. -- but no semantics or
+	  ABI should be changed (except for Mono_Posix_Syscall_utime).  Some
+	  structure names also changed to match the generated names; since the
+	  structures are private, this shouldn't break anything.
+	* errno.c: Remove Mono_Posix_Syscall_SetLastError so we don't get a warning
+	  about a missing prototype.  This was never in a stable release.
+	* old-map.c: Include mph.h for prototype checking.
+	* unistd.c: SeekFlags conversion is now done in managed code so that a short
+	  isn't passed as a parameter; Correct prototypes to match map-icalls.h.
+	* sys-xattr.c: fix lsetxattr/fsetxattr confusion; Correct prototypes to 
+	  match map-icalls.h.
+	* sys-sendfile.c: Move mph.h include so that HAVE_SYS_SENDFILE_H is used.
+	* sys-wait.c: Include mph.h so that prototypes are checked.
+
 2005-05-16  Jonathan Pryor  <jonpryor@vt.edu>
 
 	* sys-statvfs.c: Include "map.h" for Mono_Posix_ToMountFlags prototype.
diff --git a/support/dirent.c b/support/dirent.c
index 4b4277a1e5f..11138f53c68 100644
--- a/support/dirent.c
+++ b/support/dirent.c
@@ -26,21 +26,21 @@ struct Mono_Posix_Syscall__Dirent {
 };
 
 gint32
-Mono_Posix_Syscall_seekdir (DIR *dir, mph_off_t offset)
+Mono_Posix_Syscall_seekdir (void *dir, mph_off_t offset)
 {
 	mph_return_if_off_t_overflow (offset);
 
 	errno = 0;
 
-	seekdir (dir, (off_t) offset);
+	seekdir ((DIR*) dir, (off_t) offset);
 
 	return errno != 0;
 }
 
 mph_off_t
-Mono_Posix_Syscall_telldir (DIR *dir)
+Mono_Posix_Syscall_telldir (void *dir)
 {
-	return telldir (dir);
+	return telldir ((DIR*) dir);
 }
 
 static void
@@ -63,7 +63,7 @@ copy_dirent (struct Mono_Posix_Syscall__Dirent *to, struct dirent *from)
 }
 
 gint32
-Mono_Posix_Syscall_readdir (DIR *dirp, struct Mono_Posix_Syscall__Dirent *entry)
+Mono_Posix_Syscall_readdir (void *dirp, struct Mono_Posix_Syscall__Dirent *entry)
 {
 	struct dirent *d;
 
@@ -84,7 +84,7 @@ Mono_Posix_Syscall_readdir (DIR *dirp, struct Mono_Posix_Syscall__Dirent *entry)
 }
 
 gint32
-Mono_Posix_Syscall_readdir_r (DIR *dirp, struct Mono_Posix_Syscall__Dirent *entry, void **result)
+Mono_Posix_Syscall_readdir_r (void *dirp, struct Mono_Posix_Syscall__Dirent *entry, void **result)
 {
 	struct dirent _entry;
 	int r;
diff --git a/support/errno.c b/support/errno.c
index a28425e03b8..878e9560eb6 100644
--- a/support/errno.c
+++ b/support/errno.c
@@ -9,13 +9,6 @@
 
 G_BEGIN_DECLS
 
-/* DEPRECATED: Use the Stdlib version instead */
-void
-Mono_Posix_Syscall_SetLastError (int error_number)
-{
-	errno = error_number;
-}
-
 void
 Mono_Posix_Stdlib_SetLastError (int error_number)
 {
diff --git a/support/grp.c b/support/grp.c
index 99ef795c139..9fa70b93c92 100644
--- a/support/grp.c
+++ b/support/grp.c
@@ -152,7 +152,7 @@ Mono_Posix_Syscall_getgrgid (mph_gid_t gid, struct Mono_Posix_Syscall__Group *gb
 gint32
 Mono_Posix_Syscall_getgrnam_r (const char *name, 
 	struct Mono_Posix_Syscall__Group *gbuf,
-	struct group **gbufp)
+	void **gbufp)
 {
 	char *buf, *buf2;
 	size_t buflen;
@@ -176,7 +176,7 @@ Mono_Posix_Syscall_getgrnam_r (const char *name,
 		}
 		buf = buf2;
 		errno = 0;
-	} while ((r = getgrnam_r (name, &_grbuf, buf, buflen, gbufp)) && 
+	} while ((r = getgrnam_r (name, &_grbuf, buf, buflen, (struct group**) gbufp)) && 
 			recheck_range (r));
 
 	/* On Solaris, this function returns 0 even if the entry was not found */
@@ -195,7 +195,7 @@ Mono_Posix_Syscall_getgrnam_r (const char *name,
 gint32
 Mono_Posix_Syscall_getgrgid_r (mph_gid_t gid,
 	struct Mono_Posix_Syscall__Group *gbuf,
-	struct group **gbufp)
+	void **gbufp)
 {
 	char *buf, *buf2;
 	size_t buflen;
@@ -219,7 +219,7 @@ Mono_Posix_Syscall_getgrgid_r (mph_gid_t gid,
 		}
 		buf = buf2;
 		errno = 0;
-	} while ((r = getgrgid_r (gid, &_grbuf, buf, buflen, gbufp)) && 
+	} while ((r = getgrgid_r (gid, &_grbuf, buf, buflen, (struct group**) gbufp)) && 
 			recheck_range (r));
 
 	/* On Solaris, this function returns 0 even if the entry was not found */
@@ -258,7 +258,7 @@ Mono_Posix_Syscall_getgrent (struct Mono_Posix_Syscall__Group *grbuf)
 
 #ifdef HAVE_FGETGRENT
 gint32
-Mono_Posix_Syscall_fgetgrent (FILE *stream, struct Mono_Posix_Syscall__Group *grbuf)
+Mono_Posix_Syscall_fgetgrent (void *stream, struct Mono_Posix_Syscall__Group *grbuf)
 {
 	struct group *gr;
 
@@ -268,7 +268,7 @@ Mono_Posix_Syscall_fgetgrent (FILE *stream, struct Mono_Posix_Syscall__Group *gr
 	}
 
 	errno = 0;
-	gr = fgetgrent (stream);
+	gr = fgetgrent ((FILE*) stream);
 	if (gr == NULL)
 		return -1;
 
diff --git a/support/macros.c b/support/macros.c
index a26864bf483..802f0631942 100644
--- a/support/macros.c
+++ b/support/macros.c
@@ -1,3 +1,4 @@
+#include "mph.h"
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <sys/stat.h>
@@ -39,7 +40,7 @@ int wstopsig (int status)
 	return WSTOPSIG (status);
 }
 
-int helper_Mono_Posix_Stat(char *filename, int dereference, 
+int helper_Mono_Posix_Stat(const char *filename, int dereference, 
 	int *device,
 	int *inode,
 	int *mode,
@@ -80,19 +81,19 @@ int helper_Mono_Posix_Stat(char *filename, int dereference,
 	return 0;
 }
 
-char *helper_Mono_Posix_GetUserName(int uid) {
+const char *helper_Mono_Posix_GetUserName(int uid) {
 	struct passwd *p = getpwuid(uid);
 	if (p == NULL) return NULL;
 	return strdup (p->pw_name);
 }
-char *helper_Mono_Posix_GetGroupName(int gid) {
+const char *helper_Mono_Posix_GetGroupName(int gid) {
 	struct group *p = getgrgid(gid);
 	if (p == NULL) return NULL;
 	return strdup (p->gr_name);
 }
 
-char *helper_Mono_Posix_readdir(DIR *dir) {
-	struct dirent* e = readdir(dir);
+const char *helper_Mono_Posix_readdir(void *dir) {
+	struct dirent* e = readdir((DIR*) dir);
 	if (e == NULL) return NULL;
 	return strdup (e->d_name);
 }
diff --git a/support/map-icalls.h b/support/map-icalls.h
new file mode 100644
index 00000000000..318151e75c9
--- /dev/null
+++ b/support/map-icalls.h
@@ -0,0 +1,213 @@
+/*
+ * This file was automatically generated by make-map from Mono.Posix.dll.
+ *
+ * DO NOT MODIFY.
+ */
+#include <config.h>
+
+#ifndef INC_Mono_Posix_map_ICALLS_H
+#define INC_Mono_Posix_map_ICALLS_H
+
+#include <glib/gtypes.h>
+
+G_BEGIN_DECLS
+
+/*
+ * Structure Declarations
+ */
+struct Mono_Posix_Flock;
+struct Mono_Posix_Stat;
+struct Mono_Posix_Statvfs;
+struct Mono_Posix_Syscall__Dirent;
+struct Mono_Posix_Syscall__Fstab;
+struct Mono_Posix_Syscall__Group;
+struct Mono_Posix_Syscall__Passwd;
+struct Mono_Posix_Timeval;
+struct Mono_Posix_Timezone;
+struct Mono_Posix_Utimbuf;
+
+/*
+ * Function Declarations
+ */
+int Mono_Posix_FromAccessMode (int value, int* rval);
+int Mono_Posix_FromConfStr (int value, int* rval);
+int Mono_Posix_FromDirectoryNotifyFlags (int value, int* rval);
+int Mono_Posix_FromError (int value, int* rval);
+int Mono_Posix_FromFcntlCommand (int value, int* rval);
+int Mono_Posix_FromFilePermissions (unsigned int value, unsigned int* rval);
+int Mono_Posix_FromLockFlags (int value, int* rval);
+int Mono_Posix_FromLockType (short value, short* rval);
+int Mono_Posix_FromMountFlags (guint64 value, guint64* rval);
+int Mono_Posix_FromOpenFlags (int value, int* rval);
+int Mono_Posix_FromPathConf (int value, int* rval);
+int Mono_Posix_FromPollEvents (short value, short* rval);
+int Mono_Posix_FromPosixFadviseAdvice (int value, int* rval);
+int Mono_Posix_FromPosixMadviseAdvice (int value, int* rval);
+int Mono_Posix_FromSeekFlags (short value, short* rval);
+int Mono_Posix_FromSignum (int value, int* rval);
+int Mono_Posix_FromSysConf (int value, int* rval);
+int Mono_Posix_FromSyslogFacility (int value, int* rval);
+int Mono_Posix_FromSyslogLevel (int value, int* rval);
+int Mono_Posix_FromSyslogOptions (int value, int* rval);
+int Mono_Posix_FromWaitOptions (int value, int* rval);
+int Mono_Posix_FromXattrFlags (int value, int* rval);
+int Mono_Posix_Stdlib_BUFSIZ (void);
+void* Mono_Posix_Stdlib_CreateFilePosition (void);
+int Mono_Posix_Stdlib_DumpFilePosition (char* buf, void* handle, int len);
+int Mono_Posix_Stdlib_EOF (void);
+int Mono_Posix_Stdlib_EXIT_FAILURE (void);
+int Mono_Posix_Stdlib_EXIT_SUCCESS (void);
+int Mono_Posix_Stdlib_FILENAME_MAX (void);
+int Mono_Posix_Stdlib_FOPEN_MAX (void);
+void Mono_Posix_Stdlib_InvokeSignalHandler (int signum, void* handler);
+int Mono_Posix_Stdlib_L_tmpnam (void);
+int Mono_Posix_Stdlib_MB_CUR_MAX (void);
+int Mono_Posix_Stdlib_RAND_MAX (void);
+void* Mono_Posix_Stdlib_SIG_DFL (void);
+void* Mono_Posix_Stdlib_SIG_ERR (void);
+void* Mono_Posix_Stdlib_SIG_IGN (void);
+void Mono_Posix_Stdlib_SetLastError (int error);
+int Mono_Posix_Stdlib_TMP_MAX (void);
+int Mono_Posix_Stdlib__IOFBF (void);
+int Mono_Posix_Stdlib__IOLBF (void);
+int Mono_Posix_Stdlib__IONBF (void);
+void* Mono_Posix_Stdlib_calloc (guint64 nmemb, guint64 size);
+int Mono_Posix_Stdlib_fgetpos (void* stream, void* pos);
+guint64 Mono_Posix_Stdlib_fread (void* ptr, guint64 size, guint64 nmemb, void* stream);
+int Mono_Posix_Stdlib_fseek (void* stream, gint64 offset, int origin);
+int Mono_Posix_Stdlib_fsetpos (void* stream, void* pos);
+gint64 Mono_Posix_Stdlib_ftell (void* stream);
+guint64 Mono_Posix_Stdlib_fwrite (void* ptr, guint64 size, guint64 nmemb, void* stream);
+void* Mono_Posix_Stdlib_malloc (guint64 size);
+void* Mono_Posix_Stdlib_realloc (void* ptr, guint64 size);
+int Mono_Posix_Stdlib_setvbuf (void* stream, void* buf, int mode, guint64 size);
+void* Mono_Posix_Stdlib_stderr (void);
+void* Mono_Posix_Stdlib_stdin (void);
+void* Mono_Posix_Stdlib_stdout (void);
+int Mono_Posix_Syscall_L_ctermid (void);
+int Mono_Posix_Syscall_L_cuserid (void);
+int Mono_Posix_Syscall_WEXITSTATUS (int status);
+int Mono_Posix_Syscall_WIFEXITED (int status);
+int Mono_Posix_Syscall_WIFSIGNALED (int status);
+int Mono_Posix_Syscall_WIFSTOPPED (int status);
+int Mono_Posix_Syscall_WSTOPSIG (int status);
+int Mono_Posix_Syscall_WTERMSIG (int status);
+guint64 Mono_Posix_Syscall_confstr (int name, char* buf, guint64 len);
+int Mono_Posix_Syscall_creat (const char* pathname, unsigned int mode);
+void Mono_Posix_Syscall_endfsent (void);
+int Mono_Posix_Syscall_fcntl (int fd, int cmd);
+int Mono_Posix_Syscall_fcntl_arg (int fd, int cmd, gint64 arg);
+int Mono_Posix_Syscall_fcntl_lock (int fd, int cmd, struct Mono_Posix_Flock* lock);
+int Mono_Posix_Syscall_fgetgrent (void* stream, struct Mono_Posix_Syscall__Group* grbuf);
+int Mono_Posix_Syscall_fgetpwent (void* stream, struct Mono_Posix_Syscall__Passwd* pwbuf);
+gint64 Mono_Posix_Syscall_fgetxattr (int fd, const char* name, void* value, guint64 size);
+gint64 Mono_Posix_Syscall_flistxattr (int fd, void* list, guint64 size);
+gint64 Mono_Posix_Syscall_fpathconf (int filedes, int name);
+int Mono_Posix_Syscall_fsetxattr (int fd, const char* name, void* value, guint64 size, int flags);
+int Mono_Posix_Syscall_fstat (int filedes, struct Mono_Posix_Stat* buf);
+int Mono_Posix_Syscall_fstatvfs (int fd, struct Mono_Posix_Statvfs* buf);
+int Mono_Posix_Syscall_ftruncate (int fd, gint64 length);
+void* Mono_Posix_Syscall_getcwd (char* buf, guint64 size);
+int Mono_Posix_Syscall_getdomainname (char* name, guint64 len);
+int Mono_Posix_Syscall_getfsent (struct Mono_Posix_Syscall__Fstab* fs);
+int Mono_Posix_Syscall_getfsfile (const char* mount_point, struct Mono_Posix_Syscall__Fstab* fs);
+int Mono_Posix_Syscall_getfsspec (const char* special_file, struct Mono_Posix_Syscall__Fstab* fs);
+int Mono_Posix_Syscall_getgrent (struct Mono_Posix_Syscall__Group* grbuf);
+int Mono_Posix_Syscall_getgrgid (unsigned int uid, struct Mono_Posix_Syscall__Group* group);
+int Mono_Posix_Syscall_getgrgid_r (unsigned int uid, struct Mono_Posix_Syscall__Group* grbuf, void** grbufp);
+int Mono_Posix_Syscall_getgrnam (const char* name, struct Mono_Posix_Syscall__Group* group);
+int Mono_Posix_Syscall_getgrnam_r (const char* name, struct Mono_Posix_Syscall__Group* grbuf, void** grbufp);
+gint64 Mono_Posix_Syscall_gethostid (void);
+int Mono_Posix_Syscall_gethostname (char* name, guint64 len);
+int Mono_Posix_Syscall_getlogin_r (char* name, guint64 bufsize);
+int Mono_Posix_Syscall_getpwent (struct Mono_Posix_Syscall__Passwd* pwbuf);
+int Mono_Posix_Syscall_getpwnam (const char* name, struct Mono_Posix_Syscall__Passwd* passwd);
+int Mono_Posix_Syscall_getpwnam_r (const char* name, struct Mono_Posix_Syscall__Passwd* pwbuf, void** pwbufp);
+int Mono_Posix_Syscall_getpwuid (unsigned int uid, struct Mono_Posix_Syscall__Passwd* passwd);
+int Mono_Posix_Syscall_getpwuid_r (unsigned int uid, struct Mono_Posix_Syscall__Passwd* pwbuf, void** pwbufp);
+int Mono_Posix_Syscall_gettimeofday (struct Mono_Posix_Timeval* tv, void* ignore);
+gint64 Mono_Posix_Syscall_getxattr (const char* path, const char* name, void* value, guint64 size);
+gint64 Mono_Posix_Syscall_lgetxattr (const char* path, const char* name, void* value, guint64 size);
+gint64 Mono_Posix_Syscall_listxattr (const char* path, void* list, guint64 size);
+gint64 Mono_Posix_Syscall_llistxattr (const char* path, void* list, guint64 size);
+int Mono_Posix_Syscall_lockf (int fd, int cmd, gint64 len);
+gint64 Mono_Posix_Syscall_lseek (int fd, gint64 offset, int whence);
+int Mono_Posix_Syscall_lsetxattr (const char* path, const char* name, void* value, guint64 size, int flags);
+int Mono_Posix_Syscall_lstat (const char* file_name, struct Mono_Posix_Stat* buf);
+int Mono_Posix_Syscall_mknod (const char* pathname, unsigned int mode, guint64 dev);
+int Mono_Posix_Syscall_open (const char* pathname, int flags);
+int Mono_Posix_Syscall_open_mode (const char* pathname, int flags, unsigned int mode);
+gint64 Mono_Posix_Syscall_pathconf (const char* path, int name);
+int Mono_Posix_Syscall_pipe (int* reading, int* writing);
+int Mono_Posix_Syscall_posix_fadvise (int fd, gint64 offset, gint64 len, int advice);
+int Mono_Posix_Syscall_posix_fallocate (int fd, gint64 offset, guint64 len);
+int Mono_Posix_Syscall_posix_madvise (void* addr, guint64 len, int advice);
+gint64 Mono_Posix_Syscall_pread (int fd, void* buf, guint64 count, gint64 offset);
+gint64 Mono_Posix_Syscall_pwrite (int fd, void* buf, guint64 count, gint64 offset);
+gint64 Mono_Posix_Syscall_read (int fd, void* buf, guint64 count);
+int Mono_Posix_Syscall_readdir (void* dir, struct Mono_Posix_Syscall__Dirent* dentry);
+int Mono_Posix_Syscall_readdir_r (void* dirp, struct Mono_Posix_Syscall__Dirent* entry, void** result);
+int Mono_Posix_Syscall_readlink (const char* path, char* buf, guint64 bufsiz);
+int Mono_Posix_Syscall_seekdir (void* dir, gint64 offset);
+gint64 Mono_Posix_Syscall_sendfile (int out_fd, int in_fd, gint64* offset, guint64 count);
+int Mono_Posix_Syscall_setdomainname (const char* name, guint64 len);
+int Mono_Posix_Syscall_setfsent (void);
+int Mono_Posix_Syscall_setgroups (guint64 size, unsigned int* list);
+int Mono_Posix_Syscall_sethostid (gint64 hostid);
+int Mono_Posix_Syscall_sethostname (const char* name, guint64 len);
+int Mono_Posix_Syscall_settimeofday (struct Mono_Posix_Timeval* tv, struct Mono_Posix_Timezone* tz);
+int Mono_Posix_Syscall_setxattr (const char* path, const char* name, void* value, guint64 size, int flags);
+int Mono_Posix_Syscall_stat (const char* file_name, struct Mono_Posix_Stat* buf);
+int Mono_Posix_Syscall_statvfs (const char* path, struct Mono_Posix_Statvfs* buf);
+int Mono_Posix_Syscall_stime (gint64* t);
+int Mono_Posix_Syscall_strerror_r (int errnum, char* buf, guint64 n);
+void Mono_Posix_Syscall_swab (void* from, void* to, gint64 n);
+gint64 Mono_Posix_Syscall_sysconf (int name);
+gint64 Mono_Posix_Syscall_telldir (void* dir);
+gint64 Mono_Posix_Syscall_time (gint64* t);
+int Mono_Posix_Syscall_truncate (const char* path, gint64 length);
+int Mono_Posix_Syscall_ttyname_r (int fd, char* buf, guint64 buflen);
+int Mono_Posix_Syscall_utime (const char* filename, struct Mono_Posix_Utimbuf* buf, int use_buf);
+int Mono_Posix_Syscall_utimes (const char* filename, struct Mono_Posix_Timeval* tvp);
+gint64 Mono_Posix_Syscall_write (int fd, void* buf, guint64 count);
+int Mono_Posix_ToAccessMode (int value, int* rval);
+int Mono_Posix_ToConfStr (int value, int* rval);
+int Mono_Posix_ToDirectoryNotifyFlags (int value, int* rval);
+int Mono_Posix_ToError (int value, int* rval);
+int Mono_Posix_ToFcntlCommand (int value, int* rval);
+int Mono_Posix_ToFilePermissions (unsigned int value, unsigned int* rval);
+int Mono_Posix_ToLockFlags (int value, int* rval);
+int Mono_Posix_ToLockType (short value, short* rval);
+int Mono_Posix_ToMountFlags (guint64 value, guint64* rval);
+int Mono_Posix_ToOpenFlags (int value, int* rval);
+int Mono_Posix_ToPathConf (int value, int* rval);
+int Mono_Posix_ToPollEvents (short value, short* rval);
+int Mono_Posix_ToPosixFadviseAdvice (int value, int* rval);
+int Mono_Posix_ToPosixMadviseAdvice (int value, int* rval);
+int Mono_Posix_ToSeekFlags (short value, short* rval);
+int Mono_Posix_ToSignum (int value, int* rval);
+int Mono_Posix_ToSysConf (int value, int* rval);
+int Mono_Posix_ToSyslogFacility (int value, int* rval);
+int Mono_Posix_ToSyslogLevel (int value, int* rval);
+int Mono_Posix_ToSyslogOptions (int value, int* rval);
+int Mono_Posix_ToWaitOptions (int value, int* rval);
+int Mono_Posix_ToXattrFlags (int value, int* rval);
+const char* helper_Mono_Posix_GetGroupName (int gid);
+const char* helper_Mono_Posix_GetUserName (int uid);
+int helper_Mono_Posix_Stat (const char* filename, int dereference, int* device, int* inode, int* mode, int* nlinks, int* uid, int* gid, int* rdev, gint64* size, gint64* blksize, gint64* blocks, gint64* atime, gint64* mtime, gint64* ctime);
+const char* helper_Mono_Posix_readdir (void* dir);
+int map_Mono_Posix_AccessMode (int mode);
+int map_Mono_Posix_FileMode (int mode);
+int map_Mono_Posix_OpenFlags (int flags);
+int map_Mono_Posix_WaitOptions (int wait_options);
+int wexitstatus (int status);
+int wifexited (int status);
+int wifsignaled (int status);
+int wifstopped (int status);
+int wstopsig (int status);
+int wtermsig (int status);
+
+G_END_DECLS
+
+#endif /* ndef INC_Mono_Posix_map_ICALLS_H */
+
diff --git a/support/mph.h b/support/mph.h
index c02d9351b5b..6db796d77a9 100644
--- a/support/mph.h
+++ b/support/mph.h
@@ -35,6 +35,8 @@
 #include <stdint.h>             /* for SIZE_MAX */
 #endif
 
+#include "map-icalls.h"
+
 #if __APPLE__ || __BSD__ || __FreeBSD__
 #define MPH_ON_BSD
 #endif
diff --git a/support/old-map.c b/support/old-map.c
index dee52b7d6b6..f35d0d7bacd 100644
--- a/support/old-map.c
+++ b/support/old-map.c
@@ -11,6 +11,7 @@
 #include <fcntl.h>
 #include <signal.h>
 #include <poll.h>
+#include "mph.h"
 #include "old-map.h"
 int map_Mono_Posix_OpenFlags (int x)
 {
diff --git a/support/pwd.c b/support/pwd.c
index 32d8f94fdd1..809934777e2 100644
--- a/support/pwd.c
+++ b/support/pwd.c
@@ -119,7 +119,7 @@ Mono_Posix_Syscall_getpwuid (mph_uid_t uid, struct Mono_Posix_Syscall__Passwd *p
 gint32
 Mono_Posix_Syscall_getpwnam_r (const char *name, 
 	struct Mono_Posix_Syscall__Passwd *pwbuf,
-	struct passwd **pwbufp)
+	void **pwbufp)
 {
 	char *buf, *buf2;
 	size_t buflen;
@@ -143,7 +143,7 @@ Mono_Posix_Syscall_getpwnam_r (const char *name,
 		}
 		buf = buf2;
 		errno = 0;
-	} while ((r = getpwnam_r (name, &_pwbuf, buf, buflen, pwbufp)) && 
+	} while ((r = getpwnam_r (name, &_pwbuf, buf, buflen, (struct passwd**) pwbufp)) && 
 			recheck_range (r));
 
 	if (r == 0 && !(*pwbufp))
@@ -162,7 +162,7 @@ Mono_Posix_Syscall_getpwnam_r (const char *name,
 gint32
 Mono_Posix_Syscall_getpwuid_r (mph_uid_t uid,
 	struct Mono_Posix_Syscall__Passwd *pwbuf,
-	struct passwd **pwbufp)
+	void **pwbufp)
 {
 	char *buf, *buf2;
 	size_t buflen;
@@ -186,7 +186,7 @@ Mono_Posix_Syscall_getpwuid_r (mph_uid_t uid,
 		}
 		buf = buf2;
 		errno = 0;
-	} while ((r = getpwuid_r (uid, &_pwbuf, buf, buflen, pwbufp)) && 
+	} while ((r = getpwuid_r (uid, &_pwbuf, buf, buflen, (struct passwd**) pwbufp)) && 
 			recheck_range (r));
 
 	if (r == 0 && copy_passwd (pwbuf, &_pwbuf) == -1)
@@ -221,7 +221,7 @@ Mono_Posix_Syscall_getpwent (struct Mono_Posix_Syscall__Passwd *pwbuf)
 
 #ifdef HAVE_FGETPWENT
 gint32
-Mono_Posix_Syscall_fgetpwent (FILE *stream, struct Mono_Posix_Syscall__Passwd *pwbuf)
+Mono_Posix_Syscall_fgetpwent (void *stream, struct Mono_Posix_Syscall__Passwd *pwbuf)
 {
 	struct passwd *pw;
 
@@ -231,7 +231,7 @@ Mono_Posix_Syscall_fgetpwent (FILE *stream, struct Mono_Posix_Syscall__Passwd *p
 	}
 
 	errno = 0;
-	pw = fgetpwent (stream);
+	pw = fgetpwent ((FILE*) stream);
 	if (pw == NULL)
 		return -1;
 
diff --git a/support/signal.c b/support/signal.c
index 763019fecbf..d0eaf1df414 100644
--- a/support/signal.c
+++ b/support/signal.c
@@ -10,28 +10,29 @@ G_BEGIN_DECLS
 
 typedef void (*mph_sighandler_t)(int);
 
-mph_sighandler_t
+void*
 Mono_Posix_Stdlib_SIG_DFL (void)
 {
 	return SIG_DFL;
 }
 
-mph_sighandler_t
+void*
 Mono_Posix_Stdlib_SIG_ERR (void)
 {
 	return SIG_ERR;
 }
 
-mph_sighandler_t
+void*
 Mono_Posix_Stdlib_SIG_IGN (void)
 {
 	return SIG_IGN;
 }
 
 void
-Mono_Posix_Stdlib_InvokeSignalHandler (int signum, mph_sighandler_t handler)
+Mono_Posix_Stdlib_InvokeSignalHandler (int signum, void *handler)
 {
-	handler (signum);
+	mph_sighandler_t _h = (mph_sighandler_t) handler;
+	_h (signum);
 }
 
 G_END_DECLS
diff --git a/support/stdio.c b/support/stdio.c
index 6ddf22eadbd..4fe6d26deff 100644
--- a/support/stdio.c
+++ b/support/stdio.c
@@ -30,25 +30,27 @@ Mono_Posix_Syscall_L_cuserid (void)
 #endif /* ndef PLATFORM_WIN32 */
 
 mph_size_t
-Mono_Posix_Stdlib_fread (void *ptr, mph_size_t size, mph_size_t nmemb, FILE *stream)
+Mono_Posix_Stdlib_fread (void *ptr, mph_size_t size, mph_size_t nmemb, void *stream)
 {
 	mph_return_if_size_t_overflow (size);
 	mph_return_if_size_t_overflow (nmemb);
 
-	return fread (ptr, (size_t) size, (size_t) nmemb, stream);
+	return fread (ptr, (size_t) size, (size_t) nmemb, (FILE*) stream);
 }
 
 mph_size_t
-Mono_Posix_Stdlib_fwrite (const void *ptr, mph_size_t size, mph_size_t nmemb, FILE *stream)
+Mono_Posix_Stdlib_fwrite (void *ptr, mph_size_t size, mph_size_t nmemb, void *stream)
 {
 	mph_return_if_size_t_overflow (size);
 	mph_return_if_size_t_overflow (nmemb);
 
-	return fwrite (ptr, (size_t) size, (size_t) nmemb, stream);
+	return fwrite (ptr, (size_t) size, (size_t) nmemb, (FILE*) stream);
 }
 
 #ifdef HAVE_VSNPRINTF
 gint32
+Mono_Posix_Stdlib_snprintf (char *s, mph_size_t n, char *format, ...);
+gint32
 Mono_Posix_Stdlib_snprintf (char *s, mph_size_t n, char *format, ...)
 {
 	va_list ap;
@@ -111,19 +113,19 @@ Mono_Posix_Stdlib_L_tmpnam (void)
 	return L_tmpnam;
 }
 
-FILE*
+void*
 Mono_Posix_Stdlib_stdin (void)
 {
 	return stdin;
 }
 
-FILE*
+void*
 Mono_Posix_Stdlib_stdout (void)
 {
 	return stdout;
 }
 
-FILE*
+void*
 Mono_Posix_Stdlib_stderr (void)
 {
 	return stderr;
@@ -136,14 +138,14 @@ Mono_Posix_Stdlib_TMP_MAX (void)
 }
 
 gint32
-Mono_Posix_Stdlib_setvbuf (FILE *stream, char *buf, int mode, mph_size_t size)
+Mono_Posix_Stdlib_setvbuf (void* stream, void *buf, int mode, mph_size_t size)
 {
 	mph_return_if_size_t_overflow (size);
-	return setvbuf (stream, buf, mode, (size_t) size);
+	return setvbuf (stream, (char *) buf, mode, (size_t) size);
 }
 
 gint32
-Mono_Posix_Stdlib_fseek (FILE* stream, gint64 offset, int origin)
+Mono_Posix_Stdlib_fseek (void* stream, gint64 offset, int origin)
 {
 	mph_return_if_long_overflow (offset);
 
@@ -151,12 +153,12 @@ Mono_Posix_Stdlib_fseek (FILE* stream, gint64 offset, int origin)
 }
 
 gint64
-Mono_Posix_Stdlib_ftell (FILE* stream)
+Mono_Posix_Stdlib_ftell (void* stream)
 {
 	return ftell (stream);
 }
 
-fpos_t*
+void*
 Mono_Posix_Stdlib_CreateFilePosition (void)
 {
 	fpos_t* pos = malloc (sizeof(fpos_t));
@@ -164,25 +166,24 @@ Mono_Posix_Stdlib_CreateFilePosition (void)
 }
 
 gint32
-Mono_Posix_Stdlib_fgetpos (FILE* stream, fpos_t *pos)
+Mono_Posix_Stdlib_fgetpos (void* stream, void *pos)
 {
-	return fgetpos (stream, pos);
+	return fgetpos (stream, (fpos_t*) pos);
 }
 
 gint32
-Mono_Posix_Stdlib_fsetpos (FILE* stream, fpos_t *pos)
+Mono_Posix_Stdlib_fsetpos (void* stream, void *pos)
 {
-	return fsetpos (stream, pos);
+	return fsetpos (stream, (fpos_t*) pos);
 }
 
 #define MPH_FPOS_LENGTH (sizeof(fpos_t)*2)
 
 int
-Mono_Posix_Stdlib_DumpFilePosition (char *dest, fpos_t *pos, gint32 len)
+Mono_Posix_Stdlib_DumpFilePosition (char *dest, void *pos, gint32 len)
 {
 	char *destp;
 	unsigned char *posp, *pose;
-	int i;
 
 	if (dest == NULL)
 		return MPH_FPOS_LENGTH;
@@ -193,7 +194,7 @@ Mono_Posix_Stdlib_DumpFilePosition (char *dest, fpos_t *pos, gint32 len)
 	}
 
 	posp = (unsigned char*) pos;
-	pose = posp + sizeof(*pos);
+	pose = posp + sizeof(fpos_t);
 	destp = dest;
 
 	for ( ; posp < pose && len > 1; destp += 2, ++posp, len -= 2) {
@@ -203,7 +204,7 @@ Mono_Posix_Stdlib_DumpFilePosition (char *dest, fpos_t *pos, gint32 len)
 	if (len)
 		dest[MPH_FPOS_LENGTH] = '\0';
 
-	return dest;
+	return destp - dest;
 }
 
 G_END_DECLS
diff --git a/support/sys-sendfile.c b/support/sys-sendfile.c
index 0a6c7f6d59f..976b01d7870 100644
--- a/support/sys-sendfile.c
+++ b/support/sys-sendfile.c
@@ -10,12 +10,12 @@
 #include <sys/types.h>
 #include <errno.h>
 
+#include "mph.h"
+
 #ifdef HAVE_SYS_SENDFILE_H
 #include <sys/sendfile.h>
 #endif /* ndef HAVE_SYS_SENDFILE_H */
 
-#include "mph.h"
-
 G_BEGIN_DECLS
 
 #ifdef HAVE_SENDFILE
diff --git a/support/sys-stat.c b/support/sys-stat.c
index 49405e51e1d..8ee2dabf9b9 100644
--- a/support/sys-stat.c
+++ b/support/sys-stat.c
@@ -22,7 +22,7 @@
 
 G_BEGIN_DECLS
 
-struct Mono_Posix_Syscall_Stat {
+struct Mono_Posix_Stat {
 	/* dev_t */     mph_dev_t     st_dev;     /* device */
 	/* ino_t */     mph_ino_t     st_ino;     /* inode */
 	/* mode_t */    guint32       st_mode;    /* protection */
@@ -44,7 +44,7 @@ struct Mono_Posix_Syscall_Stat {
 };
 
 static int
-copy_stat (struct Mono_Posix_Syscall_Stat *to, struct stat *from)
+copy_stat (struct Mono_Posix_Stat *to, struct stat *from)
 {
 	if (Mono_Posix_ToFilePermissions (from->st_mode, &to->st_mode) == -1)
 		return -1;
@@ -64,7 +64,7 @@ copy_stat (struct Mono_Posix_Syscall_Stat *to, struct stat *from)
 }
 
 gint32
-Mono_Posix_Syscall_stat (const char *file_name, struct Mono_Posix_Syscall_Stat *buf)
+Mono_Posix_Syscall_stat (const char *file_name, struct Mono_Posix_Stat *buf)
 {
 	int r;
 	struct stat _buf;
@@ -80,7 +80,7 @@ Mono_Posix_Syscall_stat (const char *file_name, struct Mono_Posix_Syscall_Stat *
 }
 
 gint32
-Mono_Posix_Syscall_fstat (int filedes, struct Mono_Posix_Syscall_Stat *buf)
+Mono_Posix_Syscall_fstat (int filedes, struct Mono_Posix_Stat *buf)
 {
 	int r;
 	struct stat _buf;
@@ -96,7 +96,7 @@ Mono_Posix_Syscall_fstat (int filedes, struct Mono_Posix_Syscall_Stat *buf)
 }
 
 gint32
-Mono_Posix_Syscall_lstat (const char *file_name, struct Mono_Posix_Syscall_Stat *buf)
+Mono_Posix_Syscall_lstat (const char *file_name, struct Mono_Posix_Stat *buf)
 {
 	int r;
 	struct stat _buf;
diff --git a/support/sys-time.c b/support/sys-time.c
index 0b41489463f..b81f4657ebd 100644
--- a/support/sys-time.c
+++ b/support/sys-time.c
@@ -16,20 +16,20 @@
 
 G_BEGIN_DECLS
 
-struct Mono_Posix_Syscall_Timeval {
+struct Mono_Posix_Timeval {
 	/* time_t */      mph_time_t  tv_sec;   /* seconds */
 	/* suseconds_t */ gint64      tv_usec;  /* microseconds */
 };
 
-struct Mono_Posix_Syscall_Timezone {
+struct Mono_Posix_Timezone {
 	int tz_minuteswest;  /* minutes W of Greenwich */
 	int tz_dsttime;      /* ignored */
 };
 
 gint32
 Mono_Posix_Syscall_gettimeofday (
-	struct Mono_Posix_Syscall_Timeval *tv,
-	struct Mono_Posix_Syscall_Timezone *tz)
+	struct Mono_Posix_Timeval *tv,
+	void *tz)
 {
 	struct timeval _tv;
 	struct timezone _tz;
@@ -43,8 +43,9 @@ Mono_Posix_Syscall_gettimeofday (
 			tv->tv_usec = _tv.tv_usec;
 		}
 		if (tz) {
-			tz->tz_minuteswest = _tz.tz_minuteswest;
-			tz->tz_dsttime     = 0;
+			struct Mono_Posix_Timezone *tz_ = (struct Mono_Posix_Timezone *) tz;
+			tz_->tz_minuteswest = _tz.tz_minuteswest;
+			tz_->tz_dsttime     = 0;
 		}
 	}
 
@@ -53,8 +54,8 @@ Mono_Posix_Syscall_gettimeofday (
 
 gint32
 Mono_Posix_Syscall_settimeofday (
-	const struct Mono_Posix_Syscall_Timeval *tv,
-	const struct Mono_Posix_Syscall_Timezone *tz)
+	struct Mono_Posix_Timeval *tv,
+	struct Mono_Posix_Timezone *tz)
 {
 	struct timeval _tv   = {0};
 	struct timeval *ptv  = NULL;
@@ -80,7 +81,7 @@ Mono_Posix_Syscall_settimeofday (
 
 gint32
 Mono_Posix_Syscall_utimes (const char *filename,
-	struct Mono_Posix_Syscall_Timeval *tv)
+	struct Mono_Posix_Timeval *tv)
 {
 	struct timeval _tv;
 	struct timeval *ptv = NULL;
diff --git a/support/sys-wait.c b/support/sys-wait.c
index 12a4b1701a7..be2def7bda2 100644
--- a/support/sys-wait.c
+++ b/support/sys-wait.c
@@ -12,6 +12,7 @@
 
 #include <glib/gtypes.h>
 
+#include "mph.h"
 #include "map.h"
 
 G_BEGIN_DECLS
diff --git a/support/sys-xattr.c b/support/sys-xattr.c
index 4462c29ee8a..fd2bf257e43 100644
--- a/support/sys-xattr.c
+++ b/support/sys-xattr.c
@@ -23,7 +23,7 @@
 G_BEGIN_DECLS
 
 gint32
-Mono_Posix_Syscall_setxattr (const char *path, const char *name, char *value, mph_size_t size, gint32 flags)
+Mono_Posix_Syscall_setxattr (const char *path, const char *name, void *value, mph_size_t size, gint32 flags)
 {
 	int _flags;
 	mph_return_if_size_t_overflow (size);
@@ -40,7 +40,7 @@ Mono_Posix_Syscall_setxattr (const char *path, const char *name, char *value, mp
 
 #if !__APPLE__
 gint32
-Mono_Posix_Syscall_lsetxattr (const char *path, const char *name, char *value, mph_size_t size, gint32 flags)
+Mono_Posix_Syscall_lsetxattr (const char *path, const char *name, void *value, mph_size_t size, gint32 flags)
 {
 	int _flags;
 	mph_return_if_size_t_overflow (size);
@@ -53,7 +53,7 @@ Mono_Posix_Syscall_lsetxattr (const char *path, const char *name, char *value, m
 #endif
 
 gint32
-Mono_Posix_Syscall_fsetxattr (int fd, const char *name, char *value, mph_size_t size, gint32 flags)
+Mono_Posix_Syscall_fsetxattr (int fd, const char *name, void *value, mph_size_t size, gint32 flags)
 {
 	int _flags;
 	mph_return_if_size_t_overflow (size);
@@ -64,7 +64,7 @@ Mono_Posix_Syscall_fsetxattr (int fd, const char *name, char *value, mph_size_t
 #if __APPLE__
 	return fsetxattr (fd, name, value, (size_t) size, 0, _flags);
 #else
-	return lsetxattr (fd, name, value, (size_t) size, _flags);
+	return fsetxattr (fd, name, value, (size_t) size, _flags);
 #endif
 
 }
@@ -101,33 +101,33 @@ Mono_Posix_Syscall_fgetxattr (int fd, const char *name, void *value, mph_size_t
 }
 
 mph_ssize_t
-Mono_Posix_Syscall_listxattr (const char *path, char *list, mph_size_t size)
+Mono_Posix_Syscall_listxattr (const char *path, void *list, mph_size_t size)
 {
 	mph_return_if_size_t_overflow (size);
 #if __APPLE__
-	return listxattr (path, list, (size_t) size, 0);
+	return listxattr (path, (char *) list, (size_t) size, 0);
 #else
-	return listxattr (path, list, (size_t) size);
+	return listxattr (path, (char *) list, (size_t) size);
 #endif
 }
 
 #if !__APPLE__
 mph_ssize_t
-Mono_Posix_Syscall_llistxattr (const char *path, char *list, mph_size_t size)
+Mono_Posix_Syscall_llistxattr (const char *path, void *list, mph_size_t size)
 {
 	mph_return_if_size_t_overflow (size);
-	return llistxattr (path, list, (size_t) size);
+	return llistxattr (path, (char *) list, (size_t) size);
 }
 #endif
 
 mph_ssize_t
-Mono_Posix_Syscall_flistxattr (int fd, char *list, mph_size_t size)
+Mono_Posix_Syscall_flistxattr (int fd, void *list, mph_size_t size)
 {
 	mph_return_if_size_t_overflow (size);
 #if __APPLE__
-	return flistxattr (fd, list, (size_t) size, 0);
+	return flistxattr (fd, (char *) list, (size_t) size, 0);
 #else
-	return flistxattr (fd, list, (size_t) size);
+	return flistxattr (fd, (char *) list, (size_t) size);
 #endif
 }
 
diff --git a/support/unistd.c b/support/unistd.c
index c8b71ab74cd..f91596f80c8 100644
--- a/support/unistd.c
+++ b/support/unistd.c
@@ -27,11 +27,7 @@ G_BEGIN_DECLS
 mph_off_t
 Mono_Posix_Syscall_lseek (gint32 fd, mph_off_t offset, gint32 whence)
 {
-	short _whence;
 	mph_return_if_off_t_overflow (offset);
-	if (Mono_Posix_FromSeekFlags (whence, &_whence) == -1)
-		return -1;
-	whence = _whence;
 
 	return lseek (fd, offset, whence);
 }
@@ -44,7 +40,7 @@ Mono_Posix_Syscall_read (gint32 fd, void *buf, mph_size_t count)
 }
 
 mph_ssize_t
-Mono_Posix_Syscall_write (gint32 fd, const void *buf, mph_size_t count)
+Mono_Posix_Syscall_write (gint32 fd, void *buf, mph_size_t count)
 {
 	mph_return_if_size_t_overflow (count);
 	return write (fd, buf, (size_t) count);
@@ -60,7 +56,7 @@ Mono_Posix_Syscall_pread (gint32 fd, void *buf, mph_size_t count, mph_off_t offs
 }
 
 mph_ssize_t
-Mono_Posix_Syscall_pwrite (gint32 fd, const void *buf, mph_size_t count, mph_off_t offset)
+Mono_Posix_Syscall_pwrite (gint32 fd, void *buf, mph_size_t count, mph_off_t offset)
 {
 	mph_return_if_size_t_overflow (count);
 	mph_return_if_off_t_overflow (offset);
@@ -86,7 +82,7 @@ Mono_Posix_Syscall_pipe (gint32 *reading, gint32 *writing)
 	return r;
 }
 
-char*
+void*
 Mono_Posix_Syscall_getcwd (char *buf, mph_size_t size)
 {
 	mph_return_val_if_size_t_overflow (size, NULL);
@@ -102,7 +98,7 @@ Mono_Posix_Syscall_fpathconf (int filedes, int name)
 }
 
 gint64
-Mono_Posix_Syscall_pathconf (char *path, int name)
+Mono_Posix_Syscall_pathconf (const char *path, int name)
 {
 	if (Mono_Posix_FromPathConf (name, &name) == -1)
 		return -1;
@@ -117,7 +113,7 @@ Mono_Posix_Syscall_sysconf (int name)
 	return sysconf (name);
 }
 
-gint64
+mph_size_t
 Mono_Posix_Syscall_confstr (int name, char *buf, mph_size_t len)
 {
 	mph_return_if_size_t_overflow (len);
diff --git a/support/utime.c b/support/utime.c
index 4e40c687e98..dd908c7aba9 100644
--- a/support/utime.c
+++ b/support/utime.c
@@ -20,12 +20,13 @@ struct Mono_Posix_Utimbuf {
 };
 
 gint32
-Mono_Posix_Syscall_utime (const char *filename, struct Mono_Posix_Utimbuf *buf)
+Mono_Posix_Syscall_utime (const char *filename, struct Mono_Posix_Utimbuf *buf, 
+		int use_buf)
 {
 	struct utimbuf _buf;
 	struct utimbuf *pbuf = NULL;
 
-	if (buf) {
+	if (buf && use_buf) {
 		_buf.actime  = buf->actime;
 		_buf.modtime = buf->modtime;
 		pbuf = &_buf;