[Mono.Posix] Support OS X ENOATTR

Fixes: https://bugzilla.xamarin.com/show_bug.cgi?id=19991

The original Mono.Unix.Native.Errno design used the Linux <errno.h>
constants and values...largely because it was easy.

As it turns out, this is also incomplete. The getxattr(2) defines
ENOATTR as a possible error code. On Linux, ENOATTR is an alias for
ENODATA [0]. On OS X, ENOATTR is _not_ an alias. Furthermore, since
ENOATTR is not a Linux errno value (it's an alias!),
Mono_Posix_ToErrno() couldn't check for the native ENOATTR value, so a
Syscall.GetLastError() call after a failing Syscall.getxattr() would
fail with a System.ArgumentOutOfRangeException:

	$ csharp -r:Mono.Posix.dll
	Mono C# Shell, type "help;" for help

	Enter statements below.
	csharp> using Mono.Unix.Native;
	csharp> byte[] value;
	csharp> Syscall.getxattr(".", "test", out value);
	-1
	csharp> Syscall.GetLastError();
	System.ArgumentOutOfRangeException: Current platform doesn't support this value.
	Parameter name: value
	93
		at Mono.Unix.Native.NativeConvert.ThrowArgumentException (System.Object value) [0x00000] in <filename unknown>:0
		at Mono.Unix.Native.NativeConvert.ToErrno (Int32 value) [0x00000] in <filename unknown>:0
		at Mono.Unix.Native.Stdlib.GetLastError () [0x00000] in <filename unknown>:0

The fix is to add an Errno.ENOATTR field [1].

The complication is one of what enum value to use: at present, the
Errno values are based on the Linux values. In the case of ENOATTR
(and others), there is no Linux value. Meanwhile, there is the
possibility of additional Linux error values; how do we future proof
ourselves?

This isn't a perfect solution, but it should punt the problem down the
road a bit: Errno is an `int` enum, and thus has large range. To
support the OS X values, we add 1000 to the OS X error value.

	/* OS X: <errno.h> */
	#define ENOATTR		93		/* Attribute not found */

	// C# Errno enum:
	public enum Errno : int {
		// ...
		ENOATTR = 1093,
	}

This gives us 0..1000 for POSIX+Linux error codes, 1000..2000 for OS X
specific error codes, and as new platforms require additional support
they can all start at multiples of 1000.

Hopefully no single *nix platform will add more than 1000 error codes...

[0]: http://linux.die.net/man/2/getxattr
[1]: Related part of the fix: add all the OTHER <errno.h> values that
     OS X includes but weren't included in the Errno enum.

diff --git a/mcs/class/Mono.Posix/Mono.Unix.Native/Stdlib.cs b/mcs/class/Mono.Posix/Mono.Unix.Native/Stdlib.cs
index 5ec4a3a93d73eab8563d8896af7d97d13cb2a529..55101caa0f3440a55ee785d05082717235e0b177 100644 (file)
--- a/mcs/class/Mono.Posix/Mono.Unix.Native/Stdlib.cs
+++ b/mcs/class/Mono.Posix/Mono.Unix.Native/Stdlib.cs
@@ -169,6 +169,34 @@ namespace Mono.Unix.Native {
 
                ENOMEDIUM       = 123, // No medium found 
                EMEDIUMTYPE     = 124, // Wrong medium type 
+
+               ECANCELED       = 125,
+               ENOKEY          = 126,
+               EKEYEXPIRED     = 127,
+               EKEYREVOKED     = 128,
+               EKEYREJECTED    = 129,
+
+               EOWNERDEAD      = 130,
+               ENOTRECOVERABLE = 131,
+
+               // OS X-specific values: OS X value + 1000
+               EPROCLIM        = 1067, // Too many processes
+               EBADRPC         = 1072, // RPC struct is bad
+               ERPCMISMATCH    = 1073, // RPC version wrong
+               EPROGUNAVAIL    = 1074, // RPC prog. not avail
+               EPROGMISMATCH   = 1075, // Program version wrong
+               EPROCUNAVAIL    = 1076, // Bad procedure for program
+               EFTYPE          = 1079, // Inappropriate file type or format
+               EAUTH           = 1080, // Authentication error
+               ENEEDAUTH       = 1081, // Need authenticator
+               EPWROFF         = 1082, // Device power is off
+               EDEVERR         = 1083, // Device error, e.g. paper out
+               EBADEXEC        = 1085, // Bad executable
+               EBADARCH        = 1086, // Bad CPU type in executable
+               ESHLIBVERS      = 1087, // Shared library version mismatch
+               EBADMACHO       = 1088, // Malformed Macho file
+               ENOATTR         = 1093, // Attribute not found
+               ENOPOLICY       = 1103, // No such policy registered
        }
 
        #endregion

diff --git a/support/map.c b/support/map.c
index 42fdf7cfaadfbfe04b825b13b538ac9427f8b02e..9049e3cc931aeb1082c95c99e3793b1c69582cf9 100644 (file)
--- a/support/map.c
+++ b/support/map.c
@@ -1136,12 +1136,30 @@ int Mono_Posix_FromErrno (int x, int *r)
 #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;}
@@ -1154,6 +1172,12 @@ int Mono_Posix_FromErrno (int x, int *r)
 #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;}
@@ -1166,6 +1190,12 @@ int Mono_Posix_FromErrno (int x, int *r)
 #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;}
@@ -1190,6 +1220,12 @@ int Mono_Posix_FromErrno (int x, int *r)
 #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;}
@@ -1244,6 +1280,12 @@ int Mono_Posix_FromErrno (int x, int *r)
 #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;}
@@ -1280,6 +1322,12 @@ int Mono_Posix_FromErrno (int x, int *r)
 #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;}
@@ -1346,6 +1394,24 @@ int Mono_Posix_FromErrno (int x, int *r)
 #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;}
@@ -1454,6 +1520,12 @@ int Mono_Posix_FromErrno (int x, int *r)
 #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;}
@@ -1484,6 +1556,12 @@ int Mono_Posix_FromErrno (int x, int *r)
 #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;}
@@ -1520,6 +1598,12 @@ int Mono_Posix_FromErrno (int x, int *r)
 #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;}
@@ -1562,6 +1646,12 @@ int Mono_Posix_FromErrno (int x, int *r)
 #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;}
@@ -1622,6 +1712,12 @@ int Mono_Posix_FromErrno (int x, int *r)
 #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;}
@@ -1658,6 +1754,12 @@ int Mono_Posix_FromErrno (int x, int *r)
 #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;}
@@ -1676,6 +1778,30 @@ int Mono_Posix_FromErrno (int x, int *r)
 #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;}
@@ -1694,6 +1820,12 @@ int Mono_Posix_FromErrno (int x, int *r)
 #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;}
@@ -1730,6 +1862,18 @@ int Mono_Posix_FromErrno (int x, int *r)
 #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;}
@@ -1874,10 +2018,22 @@ int Mono_Posix_ToErrno (int x, int *r)
        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;}
@@ -1886,6 +2042,10 @@ int Mono_Posix_ToErrno (int x, int *r)
        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;}
@@ -1894,6 +2054,10 @@ int Mono_Posix_ToErrno (int x, int *r)
        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;}
@@ -1910,6 +2074,10 @@ int Mono_Posix_ToErrno (int x, int *r)
        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;}
@@ -1946,6 +2114,10 @@ int Mono_Posix_ToErrno (int x, int *r)
        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;}
@@ -1970,6 +2142,10 @@ int Mono_Posix_ToErrno (int x, int *r)
        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;}
@@ -2014,6 +2190,18 @@ int Mono_Posix_ToErrno (int x, int *r)
        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;}
@@ -2086,6 +2274,10 @@ int Mono_Posix_ToErrno (int x, int *r)
        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;}
@@ -2106,6 +2298,10 @@ int Mono_Posix_ToErrno (int x, int *r)
        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;}
@@ -2130,6 +2326,10 @@ int Mono_Posix_ToErrno (int x, int *r)
        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;}
@@ -2158,6 +2358,10 @@ int Mono_Posix_ToErrno (int x, int *r)
        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;}
@@ -2198,6 +2402,10 @@ int Mono_Posix_ToErrno (int x, int *r)
        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;}
@@ -2222,6 +2430,10 @@ int Mono_Posix_ToErrno (int x, int *r)
        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;}
@@ -2234,6 +2446,22 @@ int Mono_Posix_ToErrno (int x, int *r)
        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;}
@@ -2246,6 +2474,10 @@ int Mono_Posix_ToErrno (int x, int *r)
        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;}
@@ -2270,6 +2502,14 @@ int Mono_Posix_ToErrno (int x, int *r)
        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;}

diff --git a/support/map.h b/support/map.h
index 233c2b113148075a1a03e3ebf5dc99a4d3723801..fa6786f0a771059db47f1979445223dc63db8f1d 100644 (file)
--- a/support/map.h
+++ b/support/map.h
@@ -219,16 +219,26 @@ enum Mono_Posix_Errno {
        #define Mono_Posix_Errno_EAGAIN          Mono_Posix_Errno_EAGAIN
        Mono_Posix_Errno_EALREADY              = 0x00000072,
        #define Mono_Posix_Errno_EALREADY        Mono_Posix_Errno_EALREADY
+       Mono_Posix_Errno_EAUTH                 = 0x00000438,
+       #define Mono_Posix_Errno_EAUTH           Mono_Posix_Errno_EAUTH
+       Mono_Posix_Errno_EBADARCH              = 0x0000043e,
+       #define Mono_Posix_Errno_EBADARCH        Mono_Posix_Errno_EBADARCH
        Mono_Posix_Errno_EBADE                 = 0x00000034,
        #define Mono_Posix_Errno_EBADE           Mono_Posix_Errno_EBADE
+       Mono_Posix_Errno_EBADEXEC              = 0x0000043d,
+       #define Mono_Posix_Errno_EBADEXEC        Mono_Posix_Errno_EBADEXEC
        Mono_Posix_Errno_EBADF                 = 0x00000009,
        #define Mono_Posix_Errno_EBADF           Mono_Posix_Errno_EBADF
        Mono_Posix_Errno_EBADFD                = 0x0000004d,
        #define Mono_Posix_Errno_EBADFD          Mono_Posix_Errno_EBADFD
+       Mono_Posix_Errno_EBADMACHO             = 0x00000440,
+       #define Mono_Posix_Errno_EBADMACHO       Mono_Posix_Errno_EBADMACHO
        Mono_Posix_Errno_EBADMSG               = 0x0000004a,
        #define Mono_Posix_Errno_EBADMSG         Mono_Posix_Errno_EBADMSG
        Mono_Posix_Errno_EBADR                 = 0x00000035,
        #define Mono_Posix_Errno_EBADR           Mono_Posix_Errno_EBADR
+       Mono_Posix_Errno_EBADRPC               = 0x00000430,
+       #define Mono_Posix_Errno_EBADRPC         Mono_Posix_Errno_EBADRPC
        Mono_Posix_Errno_EBADRQC               = 0x00000038,
        #define Mono_Posix_Errno_EBADRQC         Mono_Posix_Errno_EBADRQC
        Mono_Posix_Errno_EBADSLT               = 0x00000039,
@@ -237,6 +247,8 @@ enum Mono_Posix_Errno {
        #define Mono_Posix_Errno_EBFONT          Mono_Posix_Errno_EBFONT
        Mono_Posix_Errno_EBUSY                 = 0x00000010,
        #define Mono_Posix_Errno_EBUSY           Mono_Posix_Errno_EBUSY
+       Mono_Posix_Errno_ECANCELED             = 0x0000007d,
+       #define Mono_Posix_Errno_ECANCELED       Mono_Posix_Errno_ECANCELED
        Mono_Posix_Errno_ECHILD                = 0x0000000a,
        #define Mono_Posix_Errno_ECHILD          Mono_Posix_Errno_ECHILD
        Mono_Posix_Errno_ECHRNG                = 0x0000002c,
@@ -255,6 +267,8 @@ enum Mono_Posix_Errno {
        #define Mono_Posix_Errno_EDEADLOCK       Mono_Posix_Errno_EDEADLOCK
        Mono_Posix_Errno_EDESTADDRREQ          = 0x00000059,
        #define Mono_Posix_Errno_EDESTADDRREQ    Mono_Posix_Errno_EDESTADDRREQ
+       Mono_Posix_Errno_EDEVERR               = 0x0000043b,
+       #define Mono_Posix_Errno_EDEVERR         Mono_Posix_Errno_EDEVERR
        Mono_Posix_Errno_EDOM                  = 0x00000021,
        #define Mono_Posix_Errno_EDOM            Mono_Posix_Errno_EDOM
        Mono_Posix_Errno_EDOTDOT               = 0x00000049,
@@ -267,6 +281,8 @@ enum Mono_Posix_Errno {
        #define Mono_Posix_Errno_EFAULT          Mono_Posix_Errno_EFAULT
        Mono_Posix_Errno_EFBIG                 = 0x0000001b,
        #define Mono_Posix_Errno_EFBIG           Mono_Posix_Errno_EFBIG
+       Mono_Posix_Errno_EFTYPE                = 0x00000437,
+       #define Mono_Posix_Errno_EFTYPE          Mono_Posix_Errno_EFTYPE
        Mono_Posix_Errno_EHOSTDOWN             = 0x00000070,
        #define Mono_Posix_Errno_EHOSTDOWN       Mono_Posix_Errno_EHOSTDOWN
        Mono_Posix_Errno_EHOSTUNREACH          = 0x00000071,
@@ -289,6 +305,12 @@ enum Mono_Posix_Errno {
        #define Mono_Posix_Errno_EISDIR          Mono_Posix_Errno_EISDIR
        Mono_Posix_Errno_EISNAM                = 0x00000078,
        #define Mono_Posix_Errno_EISNAM          Mono_Posix_Errno_EISNAM
+       Mono_Posix_Errno_EKEYEXPIRED           = 0x0000007f,
+       #define Mono_Posix_Errno_EKEYEXPIRED     Mono_Posix_Errno_EKEYEXPIRED
+       Mono_Posix_Errno_EKEYREJECTED          = 0x00000081,
+       #define Mono_Posix_Errno_EKEYREJECTED    Mono_Posix_Errno_EKEYREJECTED
+       Mono_Posix_Errno_EKEYREVOKED           = 0x00000080,
+       #define Mono_Posix_Errno_EKEYREVOKED     Mono_Posix_Errno_EKEYREVOKED
        Mono_Posix_Errno_EL2HLT                = 0x00000033,
        #define Mono_Posix_Errno_EL2HLT          Mono_Posix_Errno_EL2HLT
        Mono_Posix_Errno_EL2NSYNC              = 0x0000002d,
@@ -325,6 +347,8 @@ enum Mono_Posix_Errno {
        #define Mono_Posix_Errno_ENAMETOOLONG    Mono_Posix_Errno_ENAMETOOLONG
        Mono_Posix_Errno_ENAVAIL               = 0x00000077,
        #define Mono_Posix_Errno_ENAVAIL         Mono_Posix_Errno_ENAVAIL
+       Mono_Posix_Errno_ENEEDAUTH             = 0x00000439,
+       #define Mono_Posix_Errno_ENEEDAUTH       Mono_Posix_Errno_ENEEDAUTH
        Mono_Posix_Errno_ENETDOWN              = 0x00000064,
        #define Mono_Posix_Errno_ENETDOWN        Mono_Posix_Errno_ENETDOWN
        Mono_Posix_Errno_ENETRESET             = 0x00000066,
@@ -335,6 +359,8 @@ enum Mono_Posix_Errno {
        #define Mono_Posix_Errno_ENFILE          Mono_Posix_Errno_ENFILE
        Mono_Posix_Errno_ENOANO                = 0x00000037,
        #define Mono_Posix_Errno_ENOANO          Mono_Posix_Errno_ENOANO
+       Mono_Posix_Errno_ENOATTR               = 0x00000445,
+       #define Mono_Posix_Errno_ENOATTR         Mono_Posix_Errno_ENOATTR
        Mono_Posix_Errno_ENOBUFS               = 0x00000069,
        #define Mono_Posix_Errno_ENOBUFS         Mono_Posix_Errno_ENOBUFS
        Mono_Posix_Errno_ENOCSI                = 0x00000032,
@@ -347,6 +373,8 @@ enum Mono_Posix_Errno {
        #define Mono_Posix_Errno_ENOENT          Mono_Posix_Errno_ENOENT
        Mono_Posix_Errno_ENOEXEC               = 0x00000008,
        #define Mono_Posix_Errno_ENOEXEC         Mono_Posix_Errno_ENOEXEC
+       Mono_Posix_Errno_ENOKEY                = 0x0000007e,
+       #define Mono_Posix_Errno_ENOKEY          Mono_Posix_Errno_ENOKEY
        Mono_Posix_Errno_ENOLCK                = 0x00000025,
        #define Mono_Posix_Errno_ENOLCK          Mono_Posix_Errno_ENOLCK
        Mono_Posix_Errno_ENOLINK               = 0x00000043,
@@ -361,6 +389,8 @@ enum Mono_Posix_Errno {
        #define Mono_Posix_Errno_ENONET          Mono_Posix_Errno_ENONET
        Mono_Posix_Errno_ENOPKG                = 0x00000041,
        #define Mono_Posix_Errno_ENOPKG          Mono_Posix_Errno_ENOPKG
+       Mono_Posix_Errno_ENOPOLICY             = 0x0000044f,
+       #define Mono_Posix_Errno_ENOPOLICY       Mono_Posix_Errno_ENOPOLICY
        Mono_Posix_Errno_ENOPROTOOPT           = 0x0000005c,
        #define Mono_Posix_Errno_ENOPROTOOPT     Mono_Posix_Errno_ENOPROTOOPT
        Mono_Posix_Errno_ENOSPC                = 0x0000001c,
@@ -381,6 +411,8 @@ enum Mono_Posix_Errno {
        #define Mono_Posix_Errno_ENOTEMPTY       Mono_Posix_Errno_ENOTEMPTY
        Mono_Posix_Errno_ENOTNAM               = 0x00000076,
        #define Mono_Posix_Errno_ENOTNAM         Mono_Posix_Errno_ENOTNAM
+       Mono_Posix_Errno_ENOTRECOVERABLE       = 0x00000083,
+       #define Mono_Posix_Errno_ENOTRECOVERABLE Mono_Posix_Errno_ENOTRECOVERABLE
        Mono_Posix_Errno_ENOTSOCK              = 0x00000058,
        #define Mono_Posix_Errno_ENOTSOCK        Mono_Posix_Errno_ENOTSOCK
        Mono_Posix_Errno_ENOTTY                = 0x00000019,
@@ -393,18 +425,30 @@ enum Mono_Posix_Errno {
        #define Mono_Posix_Errno_EOPNOTSUPP      Mono_Posix_Errno_EOPNOTSUPP
        Mono_Posix_Errno_EOVERFLOW             = 0x0000004b,
        #define Mono_Posix_Errno_EOVERFLOW       Mono_Posix_Errno_EOVERFLOW
+       Mono_Posix_Errno_EOWNERDEAD            = 0x00000082,
+       #define Mono_Posix_Errno_EOWNERDEAD      Mono_Posix_Errno_EOWNERDEAD
        Mono_Posix_Errno_EPERM                 = 0x00000001,
        #define Mono_Posix_Errno_EPERM           Mono_Posix_Errno_EPERM
        Mono_Posix_Errno_EPFNOSUPPORT          = 0x00000060,
        #define Mono_Posix_Errno_EPFNOSUPPORT    Mono_Posix_Errno_EPFNOSUPPORT
        Mono_Posix_Errno_EPIPE                 = 0x00000020,
        #define Mono_Posix_Errno_EPIPE           Mono_Posix_Errno_EPIPE
+       Mono_Posix_Errno_EPROCLIM              = 0x0000042b,
+       #define Mono_Posix_Errno_EPROCLIM        Mono_Posix_Errno_EPROCLIM
+       Mono_Posix_Errno_EPROCUNAVAIL          = 0x00000434,
+       #define Mono_Posix_Errno_EPROCUNAVAIL    Mono_Posix_Errno_EPROCUNAVAIL
+       Mono_Posix_Errno_EPROGMISMATCH         = 0x00000433,
+       #define Mono_Posix_Errno_EPROGMISMATCH   Mono_Posix_Errno_EPROGMISMATCH
+       Mono_Posix_Errno_EPROGUNAVAIL          = 0x00000432,
+       #define Mono_Posix_Errno_EPROGUNAVAIL    Mono_Posix_Errno_EPROGUNAVAIL
        Mono_Posix_Errno_EPROTO                = 0x00000047,
        #define Mono_Posix_Errno_EPROTO          Mono_Posix_Errno_EPROTO
        Mono_Posix_Errno_EPROTONOSUPPORT       = 0x0000005d,
        #define Mono_Posix_Errno_EPROTONOSUPPORT Mono_Posix_Errno_EPROTONOSUPPORT
        Mono_Posix_Errno_EPROTOTYPE            = 0x0000005b,
        #define Mono_Posix_Errno_EPROTOTYPE      Mono_Posix_Errno_EPROTOTYPE
+       Mono_Posix_Errno_EPWROFF               = 0x0000043a,
+       #define Mono_Posix_Errno_EPWROFF         Mono_Posix_Errno_EPWROFF
        Mono_Posix_Errno_ERANGE                = 0x00000022,
        #define Mono_Posix_Errno_ERANGE          Mono_Posix_Errno_ERANGE
        Mono_Posix_Errno_EREMCHG               = 0x0000004e,
@@ -417,6 +461,10 @@ enum Mono_Posix_Errno {
        #define Mono_Posix_Errno_ERESTART        Mono_Posix_Errno_ERESTART
        Mono_Posix_Errno_EROFS                 = 0x0000001e,
        #define Mono_Posix_Errno_EROFS           Mono_Posix_Errno_EROFS
+       Mono_Posix_Errno_ERPCMISMATCH          = 0x00000431,
+       #define Mono_Posix_Errno_ERPCMISMATCH    Mono_Posix_Errno_ERPCMISMATCH
+       Mono_Posix_Errno_ESHLIBVERS            = 0x0000043f,
+       #define Mono_Posix_Errno_ESHLIBVERS      Mono_Posix_Errno_ESHLIBVERS
        Mono_Posix_Errno_ESHUTDOWN             = 0x0000006c,
        #define Mono_Posix_Errno_ESHUTDOWN       Mono_Posix_Errno_ESHUTDOWN
        Mono_Posix_Errno_ESOCKTNOSUPPORT       = 0x0000005e,