From d2b527948437307f5077b8904ad6e3fb1905c2bd Mon Sep 17 00:00:00 2001 From: Jonathan Pryor Date: Fri, 23 May 2014 13:26:52 -0400 Subject: [PATCH] [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 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 :0 at Mono.Unix.Native.NativeConvert.ToErrno (Int32 value) [0x00000] in :0 at Mono.Unix.Native.Stdlib.GetLastError () [0x00000] in :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: */ #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 values that OS X includes but weren't included in the Errno enum. --- .../Mono.Posix/Mono.Unix.Native/Stdlib.cs | 28 ++ support/map.c | 240 ++++++++++++++++++ support/map.h | 48 ++++ 3 files changed, 316 insertions(+) diff --git a/mcs/class/Mono.Posix/Mono.Unix.Native/Stdlib.cs b/mcs/class/Mono.Posix/Mono.Unix.Native/Stdlib.cs index 5ec4a3a93d7..55101caa0f3 100644 --- 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 42fdf7cfaad..9049e3cc931 100644 --- 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 233c2b11314..fa6786f0a77 100644 --- 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, -- 2.25.1