Add various methods and flags to Syscall

    * Add OpenFlags.O_CLOEXEC and OpenFlags.O_PATH

    * Add AtFlags for AT_* values

    * Add fdopendir, mkdtemp, futimens

    * Add readv, writev, preadv, pwritev

    * Add *at methods: openat, renameat, fchmodat, fstatat, utimensat,
      mkdirat, mknodat, mkfifoat, faccessat, fchownat, linkat, readlinkat,
      symlinkat, unlinkat

    * Add constants AT_FDCWD, UTIME_NOW, UTIME_OMIT

2 files changed, 334 insertions, 1 deletions

diff --git a/mcs/class/Mono.Posix/Mono.Unix.Native/NativeConvert.generated.cs b/mcs/class/Mono.Posix/Mono.Unix.Native/NativeConvert.generated.cs
index be846a892c1..e5e41cc3b0c 100644
--- a/mcs/class/Mono.Posix/Mono.Unix.Native/NativeConvert.generated.cs
+++ b/mcs/class/Mono.Posix/Mono.Unix.Native/NativeConvert.generated.cs
@@ -54,6 +54,38 @@ namespace Mono.Unix.Native {
 			return rval;
 		}
 
+		[DllImport (LIB, EntryPoint="Mono_Posix_FromAtFlags")]
+		private static extern int FromAtFlags (AtFlags value, out Int32 rval);
+
+		public static bool TryFromAtFlags (AtFlags value, out Int32 rval)
+		{
+			return FromAtFlags (value, out rval) == 0;
+		}
+
+		public static Int32 FromAtFlags (AtFlags value)
+		{
+			Int32 rval;
+			if (FromAtFlags (value, out rval) == -1)
+				ThrowArgumentException (value);
+			return rval;
+		}
+
+		[DllImport (LIB, EntryPoint="Mono_Posix_ToAtFlags")]
+		private static extern int ToAtFlags (Int32 value, out AtFlags rval);
+
+		public static bool TryToAtFlags (Int32 value, out AtFlags rval)
+		{
+			return ToAtFlags (value, out rval) == 0;
+		}
+
+		public static AtFlags ToAtFlags (Int32 value)
+		{
+			AtFlags rval;
+			if (ToAtFlags (value, out rval) == -1)
+				ThrowArgumentException (value);
+			return rval;
+		}
+
 		[DllImport (LIB, EntryPoint="Mono_Posix_FromConfstrName")]
 		private static extern int FromConfstrName (ConfstrName value, out Int32 rval);
 
@@ -294,6 +326,22 @@ namespace Mono.Unix.Native {
 			return ToFlock (source, out destination) == 0;
 		}
 
+		[DllImport (LIB, EntryPoint="Mono_Posix_FromIovec")]
+		private static extern int FromIovec (ref Iovec source, IntPtr destination);
+
+		public static bool TryCopy (ref Iovec source, IntPtr destination)
+		{
+			return FromIovec (ref source, destination) == 0;
+		}
+
+		[DllImport (LIB, EntryPoint="Mono_Posix_ToIovec")]
+		private static extern int ToIovec (IntPtr source, out Iovec destination);
+
+		public static bool TryCopy (IntPtr source, out Iovec destination)
+		{
+			return ToIovec (source, out destination) == 0;
+		}
+
 		[DllImport (LIB, EntryPoint="Mono_Posix_FromLockType")]
 		private static extern int FromLockType (LockType value, out Int16 rval);
 
diff --git a/mcs/class/Mono.Posix/Mono.Unix.Native/Syscall.cs b/mcs/class/Mono.Posix/Mono.Unix.Native/Syscall.cs
index e5ef6c7a93b..083fb6c4093 100644
--- a/mcs/class/Mono.Posix/Mono.Unix.Native/Syscall.cs
+++ b/mcs/class/Mono.Posix/Mono.Unix.Native/Syscall.cs
@@ -149,7 +149,19 @@ namespace Mono.Unix.Native {
 		O_DIRECTORY = 0x00010000,
 		O_DIRECT    = 0x00004000,
 		O_ASYNC     = 0x00002000,
-		O_LARGEFILE = 0x00008000
+		O_LARGEFILE = 0x00008000,
+		O_CLOEXEC   = 0x00080000,
+		O_PATH      = 0x00200000
+	}
+	
+	[Map][Flags]
+	[CLSCompliant (false)]
+	public enum AtFlags : int {
+		AT_SYMLINK_NOFOLLOW = 0x00000100,
+		AT_REMOVEDIR        = 0x00000200,
+		AT_SYMLINK_FOLLOW   = 0x00000400,
+		AT_NO_AUTOMOUNT     = 0x00000800,
+		AT_EMPTY_PATH       = 0x00001000
 	}
 	
 	// mode_t
@@ -1137,6 +1149,14 @@ namespace Mono.Unix.Native {
 		}
 	}
 
+	[Map ("struct iovec")]
+	public struct Iovec
+	{
+		public IntPtr   iov_base; // Starting address
+		[CLSCompliant (false)]
+		public ulong    iov_len;  // Number of bytes to transfer
+	}
+
 	[Flags][Map]
 	public enum EpollFlags {
 		EPOLL_CLOEXEC = 02000000,
@@ -2005,6 +2025,9 @@ namespace Mono.Unix.Native {
 
 		[DllImport (LIBC, SetLastError=true)]
 		public static extern int dirfd (IntPtr dir);
+
+		[DllImport (LIBC, SetLastError=true)]
+		public static extern IntPtr fdopendir (int fd);
 		#endregion
 
 		#region <fcntl.h> Declarations
@@ -2068,6 +2091,40 @@ namespace Mono.Unix.Native {
 		[DllImport (MPH, SetLastError=true, 
 				EntryPoint="Mono_Posix_Syscall_posix_fallocate")]
 		public static extern int posix_fallocate (int fd, long offset, ulong len);
+
+		[DllImport (LIBC, SetLastError=true, 
+				EntryPoint="openat")]
+		private static extern int sys_openat (int dirfd,
+				[MarshalAs (UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(FileNameMarshaler))]
+				string pathname, int flags);
+
+		// openat(2)
+		//    int openat(int dirfd, const char *pathname, int flags, mode_t mode);
+		[DllImport (LIBC, SetLastError=true, 
+				EntryPoint="openat")]
+		private static extern int sys_openat (int dirfd,
+				[MarshalAs (UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(FileNameMarshaler))]
+				string pathname, int flags, uint mode);
+
+		public static int openat (int dirfd, string pathname, OpenFlags flags)
+		{
+			int _flags = NativeConvert.FromOpenFlags (flags);
+			return sys_openat (dirfd, pathname, _flags);
+		}
+
+		public static int openat (int dirfd, string pathname, OpenFlags flags, FilePermissions mode)
+		{
+			int _flags = NativeConvert.FromOpenFlags (flags);
+			uint _mode = NativeConvert.FromFilePermissions (mode);
+			return sys_openat (dirfd, pathname, _flags, _mode);
+		}
+
+		[DllImport (MPH, SetLastError=true, 
+				EntryPoint="Mono_Posix_Syscall_get_at_fdcwd")]
+		private static extern int get_at_fdcwd ();
+
+		public static readonly int AT_FDCWD = get_at_fdcwd ();
+
 		#endregion
 
 		#region <fstab.h> Declarations
@@ -2664,6 +2721,12 @@ namespace Mono.Unix.Native {
 			}
 		}
 
+		[DllImport (LIBC, SetLastError=true)]
+		public static extern int renameat (int olddirfd,
+				[MarshalAs (UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(FileNameMarshaler))]
+				string oldpath, int newdirfd,
+				[MarshalAs (UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(FileNameMarshaler))]
+				string newpath);
 		#endregion
 
 		#region <stdlib.h> Declarations
@@ -2673,6 +2736,16 @@ namespace Mono.Unix.Native {
 		[DllImport (LIBC, SetLastError=true)]
 		public static extern int mkstemp (StringBuilder template);
 
+		[DllImport (LIBC, SetLastError=true, EntryPoint="mkdtemp")]
+		private static extern IntPtr sys_mkdtemp (StringBuilder template);
+
+		public static StringBuilder mkdtemp (StringBuilder template)
+		{
+			if (sys_mkdtemp (template) == IntPtr.Zero)
+				return null;
+			return template;
+		}
+
 		[DllImport (LIBC, SetLastError=true)]
 		public static extern int ttyslot ();
 
@@ -2980,6 +3053,100 @@ namespace Mono.Unix.Native {
 			return sys_mkfifo (pathname, _mode);
 		}
 
+		// fchmodat(2)
+		//    int fchmodat(int dirfd, const char *pathname, mode_t mode, int flags);
+		[DllImport (LIBC, SetLastError=true, EntryPoint="fchmodat")]
+		private static extern int sys_fchmodat (int dirfd,
+				[MarshalAs (UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(FileNameMarshaler))]
+				string pathname, uint mode, int flags);
+
+		public static int fchmodat (int dirfd, string pathname, FilePermissions mode, AtFlags flags)
+		{
+			uint _mode = NativeConvert.FromFilePermissions (mode);
+			int _flags = NativeConvert.FromAtFlags (flags);
+			return sys_fchmodat (dirfd, pathname, _mode, _flags);
+		}
+
+		[DllImport (MPH, SetLastError=true, 
+				EntryPoint="Mono_Posix_Syscall_fstatat")]
+		public static extern int fstatat (int dirfd,
+				[MarshalAs (UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(FileNameMarshaler))]
+				string file_name, out Stat buf, AtFlags flags);
+
+		[DllImport (MPH, SetLastError=true, 
+				EntryPoint="Mono_Posix_Syscall_get_utime_now")]
+		private static extern long get_utime_now ();
+
+		[DllImport (MPH, SetLastError=true, 
+				EntryPoint="Mono_Posix_Syscall_get_utime_omit")]
+		private static extern long get_utime_omit ();
+
+		public static readonly long UTIME_NOW = get_utime_now ();
+
+		public static readonly long UTIME_OMIT = get_utime_omit ();
+
+		[DllImport (MPH, SetLastError=true, 
+				EntryPoint="Mono_Posix_Syscall_futimens")]
+		private static extern int sys_futimens (int fd, Timespec[] times);
+
+		public static int futimens (int fd, Timespec[] times)
+		{
+			if (times != null && times.Length != 2) {
+				SetLastError (Errno.EINVAL);
+				return -1;
+			}
+			return sys_futimens (fd, times);
+		}
+
+		[DllImport (MPH, SetLastError=true, 
+				EntryPoint="Mono_Posix_Syscall_utimensat")]
+		private static extern int sys_utimensat (int dirfd,
+				[MarshalAs (UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(FileNameMarshaler))]
+				string pathname, Timespec[] times, int flags);
+
+		public static int utimensat (int dirfd, string pathname, Timespec[] times, AtFlags flags)
+		{
+			if (times != null && times.Length != 2) {
+				SetLastError (Errno.EINVAL);
+				return -1;
+			}
+			int _flags = NativeConvert.FromAtFlags (flags);
+			return sys_utimensat (dirfd, pathname, times, _flags);
+		}
+
+		// mkdirat(2)
+		//    int mkdirat(int dirfd, const char *pathname, mode_t mode);
+		[DllImport (LIBC, SetLastError=true, EntryPoint="mkdirat")]
+		private static extern int sys_mkdirat (int dirfd,
+				[MarshalAs (UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(FileNameMarshaler))]
+				string oldpath, uint mode);
+
+		public static int mkdirat (int dirfd, string oldpath, FilePermissions mode)
+		{
+			uint _mode = NativeConvert.FromFilePermissions (mode);
+			return sys_mkdirat (dirfd, oldpath, _mode);
+		}
+
+		// mknodat(2)
+		//    int mknodat (int dirfd, const char *pathname, mode_t mode, dev_t dev);
+		[DllImport (MPH, SetLastError=true,
+				EntryPoint="Mono_Posix_Syscall_mknodat")]
+		public static extern int mknodat (int dirfd,
+				[MarshalAs (UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(FileNameMarshaler))]
+				string pathname, FilePermissions mode, ulong dev);
+
+		// mkfifoat(3)
+		//    int mkfifoat(int dirfd, const char *pathname, mode_t mode);
+		[DllImport (LIBC, SetLastError=true, EntryPoint="mkfifoat")]
+		private static extern int sys_mkfifoat (int dirfd,
+				[MarshalAs (UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(FileNameMarshaler))]
+				string pathname, uint mode);
+
+		public static int mkfifoat (int dirfd, string pathname, FilePermissions mode)
+		{
+			uint _mode = NativeConvert.FromFilePermissions (mode);
+			return sys_mkfifoat (dirfd, pathname, _mode);
+		}
 		#endregion
 
 		#region <sys/stat.h> Declarations
@@ -3978,6 +4145,74 @@ namespace Mono.Unix.Native {
 			swab ((IntPtr) from, (IntPtr) to, n);
 		}
 
+		[DllImport (LIBC, SetLastError=true, EntryPoint="faccessat")]
+		private static extern int sys_faccessat (int dirfd,
+				[MarshalAs (UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(FileNameMarshaler))]
+				string pathname, int mode, int flags);
+
+		public static int faccessat (int dirfd, string pathname, AccessModes mode, AtFlags flags)
+		{
+			int _mode = NativeConvert.FromAccessModes (mode);
+			int _flags = NativeConvert.FromAtFlags (flags);
+			return sys_faccessat (dirfd, pathname, _mode, _flags);
+		}
+
+		// fchownat(2)
+		//    int fchownat(int dirfd, const char *path, uid_t owner, gid_t group, int flags);
+		[DllImport (LIBC, SetLastError=true, EntryPoint="fchownat")]
+		private static extern int sys_fchownat (int dirfd,
+				[MarshalAs (UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(FileNameMarshaler))]
+				string pathname, uint owner, uint group, int flags);
+
+		public static int fchownat (int dirfd, string pathname, uint owner, uint group, AtFlags flags)
+		{
+			int _flags = NativeConvert.FromAtFlags (flags);
+			return sys_fchownat (dirfd, pathname, owner, group, _flags);
+		}
+
+		[DllImport (LIBC, SetLastError=true, EntryPoint="linkat")]
+		private static extern int sys_linkat (int olddirfd,
+				[MarshalAs (UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(FileNameMarshaler))]
+				string oldpath, int newdirfd,
+				[MarshalAs (UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(FileNameMarshaler))]
+				string newpath, int flags);
+
+		public static int linkat (int olddirfd, string oldpath, int newdirfd, string newpath, AtFlags flags)
+		{
+			int _flags = NativeConvert.FromAtFlags (flags);
+			return sys_linkat (olddirfd, oldpath, newdirfd, newpath, _flags);
+		}
+
+		// readlinkat(2)
+		//    int readlinkat(int dirfd, const char *pathname, char *buf, size_t bufsize);
+		[DllImport (MPH, SetLastError=true,
+				EntryPoint="Mono_Posix_Syscall_readlinkat")]
+		public static extern int readlinkat (int dirfd,
+				[MarshalAs (UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(FileNameMarshaler))]
+				string pathname, [Out] StringBuilder buf, ulong bufsiz);
+
+		public static int readlinkat (int dirfd, string pathname, [Out] StringBuilder buf)
+		{
+			return readlinkat (dirfd, pathname, buf, (ulong) buf.Capacity);
+		}
+
+		[DllImport (LIBC, SetLastError=true)]
+		public static extern int symlinkat (
+				[MarshalAs (UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(FileNameMarshaler))]
+				string oldpath, int dirfd,
+				[MarshalAs (UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(FileNameMarshaler))]
+				string newpath);
+
+		[DllImport (LIBC, SetLastError=true, EntryPoint="unlinkat")]
+		private static extern int sys_unlinkat (int dirfd,
+				[MarshalAs (UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(FileNameMarshaler))]
+				string pathname, int flags);
+
+		public static int unlinkat (int dirfd, string pathname, AtFlags flags)
+		{
+			int _flags = NativeConvert.FromAtFlags (flags);
+			return sys_unlinkat (dirfd, pathname, _flags);
+		}
 		#endregion
 
 		#region <utime.h> Declarations
@@ -4002,6 +4237,56 @@ namespace Mono.Unix.Native {
 			return sys_utime (filename, ref buf, 0);
 		}
 		#endregion
+
+		#region <sys/uio.h> Declarations
+		//
+		// <sys/uio.h> -- COMPLETE
+		//
+
+		// readv(2)
+		//    ssize_t readv(int fd, const struct iovec *iov, int iovcnt);
+		[DllImport (MPH, SetLastError=true,
+				EntryPoint="Mono_Posix_Syscall_readv")]
+		private static extern long sys_readv (int fd, Iovec[] iov, int iovcnt);
+
+		public static long readv (int fd, Iovec[] iov)
+		{
+			return sys_readv (fd, iov, iov.Length);
+		}
+
+		// writev(2)
+		//    ssize_t writev(int fd, const struct iovec *iov, int iovcnt);
+		[DllImport (MPH, SetLastError=true,
+				EntryPoint="Mono_Posix_Syscall_writev")]
+		private static extern long sys_writev (int fd, Iovec[] iov, int iovcnt);
+
+		public static long writev (int fd, Iovec[] iov)
+		{
+			return sys_writev (fd, iov, iov.Length);
+		}
+
+		// preadv(2)
+		//    ssize_t preadv(int fd, const struct iovec *iov, int iovcnt, off_t offset);
+		[DllImport (MPH, SetLastError=true,
+				EntryPoint="Mono_Posix_Syscall_preadv")]
+		private static extern long sys_preadv (int fd, Iovec[] iov, int iovcnt, long offset);
+
+		public static long preadv (int fd, Iovec[] iov, long offset)
+		{
+			return sys_preadv (fd, iov, iov.Length, offset);
+		}
+
+		// pwritev(2)
+		//    ssize_t pwritev(int fd, const struct iovec *iov, int iovcnt, off_t offset);
+		[DllImport (MPH, SetLastError=true,
+				EntryPoint="Mono_Posix_Syscall_pwritev")]
+		private static extern long sys_pwritev (int fd, Iovec[] iov, int iovcnt, long offset);
+
+		public static long pwritev (int fd, Iovec[] iov, long offset)
+		{
+			return sys_pwritev (fd, iov, iov.Length, offset);
+		}
+		#endregion
 	}
 
 	#endregion