// // Mono.Unix/Stdlib.cs // // Authors: // Jonathan Pryor (jonpryor@vt.edu) // // (C) 2004-2006 Jonathan Pryor // // Permission is hereby granted, free of charge, to any person obtaining // a copy of this software and associated documentation files (the // "Software"), to deal in the Software without restriction, including // without limitation the rights to use, copy, modify, merge, publish, // distribute, sublicense, and/or sell copies of the Software, and to // permit persons to whom the Software is furnished to do so, subject to // the following conditions: // // The above copyright notice and this permission notice shall be // included in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. // using System; using System.Collections; using System.IO; using System.Runtime.InteropServices; using System.Text; using Mono.Unix.Native; namespace Mono.Unix.Native { #region Enumerations [Map] public enum Errno : int { // errors & their values liberally copied from // FC2 /usr/include/asm/errno.h EPERM = 1, // Operation not permitted ENOENT = 2, // No such file or directory ESRCH = 3, // No such process EINTR = 4, // Interrupted system call EIO = 5, // I/O error ENXIO = 6, // No such device or address E2BIG = 7, // Arg list too long ENOEXEC = 8, // Exec format error EBADF = 9, // Bad file number ECHILD = 10, // No child processes EAGAIN = 11, // Try again ENOMEM = 12, // Out of memory EACCES = 13, // Permission denied EFAULT = 14, // Bad address ENOTBLK = 15, // Block device required EBUSY = 16, // Device or resource busy EEXIST = 17, // File exists EXDEV = 18, // Cross-device link ENODEV = 19, // No such device ENOTDIR = 20, // Not a directory EISDIR = 21, // Is a directory EINVAL = 22, // Invalid argument ENFILE = 23, // File table overflow EMFILE = 24, // Too many open files ENOTTY = 25, // Not a typewriter ETXTBSY = 26, // Text file busy EFBIG = 27, // File too large ENOSPC = 28, // No space left on device ESPIPE = 29, // Illegal seek EROFS = 30, // Read-only file system EMLINK = 31, // Too many links EPIPE = 32, // Broken pipe EDOM = 33, // Math argument out of domain of func ERANGE = 34, // Math result not representable EDEADLK = 35, // Resource deadlock would occur ENAMETOOLONG = 36, // File name too long ENOLCK = 37, // No record locks available ENOSYS = 38, // Function not implemented ENOTEMPTY = 39, // Directory not empty ELOOP = 40, // Too many symbolic links encountered EWOULDBLOCK = EAGAIN, // Operation would block ENOMSG = 42, // No message of desired type EIDRM = 43, // Identifier removed ECHRNG = 44, // Channel number out of range EL2NSYNC = 45, // Level 2 not synchronized EL3HLT = 46, // Level 3 halted EL3RST = 47, // Level 3 reset ELNRNG = 48, // Link number out of range EUNATCH = 49, // Protocol driver not attached ENOCSI = 50, // No CSI structure available EL2HLT = 51, // Level 2 halted EBADE = 52, // Invalid exchange EBADR = 53, // Invalid request descriptor EXFULL = 54, // Exchange full ENOANO = 55, // No anode EBADRQC = 56, // Invalid request code EBADSLT = 57, // Invalid slot EDEADLOCK = EDEADLK, EBFONT = 59, // Bad font file format ENOSTR = 60, // Device not a stream ENODATA = 61, // No data available ETIME = 62, // Timer expired ENOSR = 63, // Out of streams resources ENONET = 64, // Machine is not on the network ENOPKG = 65, // Package not installed EREMOTE = 66, // Object is remote ENOLINK = 67, // Link has been severed EADV = 68, // Advertise error ESRMNT = 69, // Srmount error ECOMM = 70, // Communication error on send EPROTO = 71, // Protocol error EMULTIHOP = 72, // Multihop attempted EDOTDOT = 73, // RFS specific error EBADMSG = 74, // Not a data message EOVERFLOW = 75, // Value too large for defined data type ENOTUNIQ = 76, // Name not unique on network EBADFD = 77, // File descriptor in bad state EREMCHG = 78, // Remote address changed ELIBACC = 79, // Can not access a needed shared library ELIBBAD = 80, // Accessing a corrupted shared library ELIBSCN = 81, // .lib section in a.out corrupted ELIBMAX = 82, // Attempting to link in too many shared libraries ELIBEXEC = 83, // Cannot exec a shared library directly EILSEQ = 84, // Illegal byte sequence ERESTART = 85, // Interrupted system call should be restarted ESTRPIPE = 86, // Streams pipe error EUSERS = 87, // Too many users ENOTSOCK = 88, // Socket operation on non-socket EDESTADDRREQ = 89, // Destination address required EMSGSIZE = 90, // Message too long EPROTOTYPE = 91, // Protocol wrong type for socket ENOPROTOOPT = 92, // Protocol not available EPROTONOSUPPORT = 93, // Protocol not supported ESOCKTNOSUPPORT = 94, // Socket type not supported EOPNOTSUPP = 95, // Operation not supported on transport endpoint EPFNOSUPPORT = 96, // Protocol family not supported EAFNOSUPPORT = 97, // Address family not supported by protocol EADDRINUSE = 98, // Address already in use EADDRNOTAVAIL = 99, // Cannot assign requested address ENETDOWN = 100, // Network is down ENETUNREACH = 101, // Network is unreachable ENETRESET = 102, // Network dropped connection because of reset ECONNABORTED = 103, // Software caused connection abort ECONNRESET = 104, // Connection reset by peer ENOBUFS = 105, // No buffer space available EISCONN = 106, // Transport endpoint is already connected ENOTCONN = 107, // Transport endpoint is not connected ESHUTDOWN = 108, // Cannot send after transport endpoint shutdown ETOOMANYREFS = 109, // Too many references: cannot splice ETIMEDOUT = 110, // Connection timed out ECONNREFUSED = 111, // Connection refused EHOSTDOWN = 112, // Host is down EHOSTUNREACH = 113, // No route to host EALREADY = 114, // Operation already in progress EINPROGRESS = 115, // Operation now in progress ESTALE = 116, // Stale NFS file handle EUCLEAN = 117, // Structure needs cleaning ENOTNAM = 118, // Not a XENIX named type file ENAVAIL = 119, // No XENIX semaphores available EISNAM = 120, // Is a named type file EREMOTEIO = 121, // Remote I/O error EDQUOT = 122, // Quota exceeded 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 #region Classes public sealed class FilePosition : MarshalByRefObject, IDisposable , IEquatable { private static readonly int FilePositionDumpSize = Stdlib.DumpFilePosition (null, new HandleRef (null, IntPtr.Zero), 0); private HandleRef pos; public FilePosition () { IntPtr p = Stdlib.CreateFilePosition (); if (p == IntPtr.Zero) throw new OutOfMemoryException ("Unable to malloc fpos_t!"); pos = new HandleRef (this, p); } internal HandleRef Handle { get {return pos;} } public void Dispose () { Cleanup (); GC.SuppressFinalize (this); } private void Cleanup () { if (pos.Handle != IntPtr.Zero) { Stdlib.free (pos.Handle); pos = new HandleRef (this, IntPtr.Zero); } } public override string ToString () { return "(" + base.ToString () + " " + GetDump () + ")"; } private string GetDump () { if (FilePositionDumpSize <= 0) return "internal error"; StringBuilder buf = new StringBuilder (FilePositionDumpSize+1); if (Stdlib.DumpFilePosition (buf, Handle, FilePositionDumpSize+1) <= 0) return "internal error dumping fpos_t"; return buf.ToString (); } public override bool Equals (object obj) { FilePosition fp = obj as FilePosition; if (obj == null || fp == null) return false; return ToString().Equals (obj.ToString()); } public bool Equals (FilePosition value) { if (object.ReferenceEquals (this, value)) return true; return ToString().Equals (value.ToString()); } public override int GetHashCode () { return ToString ().GetHashCode (); } ~FilePosition () { Cleanup (); } public static bool operator== (FilePosition lhs, FilePosition rhs) { return Object.Equals (lhs, rhs); } public static bool operator!= (FilePosition lhs, FilePosition rhs) { return !Object.Equals (lhs, rhs); } } public enum SignalAction { Default, Ignore, Error } // // Right now using this attribute gives an assert because it // isn't implemented. // #if UNMANAGED_FN_PTR_SUPPORT_FIXED [UnmanagedFunctionPointer (CallingConvention.Cdecl)] #endif public delegate void SignalHandler (int signal); #if !NETSTANDARD2_0 internal class XPrintfFunctions { internal delegate object XPrintf (object[] parameters); internal static XPrintf printf; internal static XPrintf fprintf; internal static XPrintf snprintf; internal static XPrintf syslog; static XPrintfFunctions () { CdeclFunction _printf = new CdeclFunction (Stdlib.LIBC, "printf", typeof(int)); printf = new XPrintf (_printf.Invoke); CdeclFunction _fprintf = new CdeclFunction (Stdlib.LIBC, "fprintf", typeof(int)); fprintf = new XPrintf (_fprintf.Invoke); CdeclFunction _snprintf = new CdeclFunction (Stdlib.MPH, "Mono_Posix_Stdlib_snprintf", typeof(int)); snprintf = new XPrintf (_snprintf.Invoke); CdeclFunction _syslog = new CdeclFunction (Syscall.MPH, "Mono_Posix_Stdlib_syslog2", typeof(int)); syslog = new XPrintf (_syslog.Invoke); } } #endif // // Convention: Functions that are part of the C standard library go here. // // For example, the man page should say something similar to: // // CONFORMING TO // ISO 9899 (''ANSI C'') // // The intent is that members of this class should be portable to any system // supporting the C runtime (read: non-Unix, including Windows). Using // anything from Syscall is non-portable, but restricting yourself to just // Stdlib is intended to be portable. // // The only methods in here should be: // (1) low-level functions (as defined above). // (2) "Trivial" function overloads. For example, if the parameters to a // function are related (e.g. fwrite(3)) // (3) The return type SHOULD NOT be changed. If you want to provide a // convenience function with a nicer return type, place it into one of // the Mono.Unix.Std* wrapper classes, and give it a .NET-styled name. // - EXCEPTION: No public functions should have a `void' return type. // `void' return types should be replaced with `int'. // Rationality: `void'-return functions typically require a // complicated call sequence, such as clear errno, then call, then // check errno to see if any errors occurred. This sequence can't // be done safely in managed code, as errno may change as part of // the P/Invoke mechanism. // Instead, add a MonoPosixHelper export which does: // errno = 0; // INVOKE SYSCALL; // return errno == 0 ? 0 : -1; // This lets managed code check the return value in the usual manner. // (4) Exceptions SHOULD NOT be thrown. EXCEPTIONS: // - If you're wrapping *broken* methods which make assumptions about // input data, such as that an argument refers to N bytes of data. // This is currently limited to cuserid(3) and encrypt(3). // - If you call functions which themselves generate exceptions. // This is the case for using NativeConvert, which will throw an // exception if an invalid/unsupported value is used. // public class Stdlib { #if FORCE_USE_LIBC_NOT_MSVC internal const string LIBC = "c"; #else internal const string LIBC = "msvcrt"; #endif internal const string MPH = "MonoPosixHelper"; // It is possible for Mono.Posix and MonoPosixHelper to get out of sync, // for example if NuGet does something weird. To mitigate this, anyone // editing Mono.Posix needs to observe two rules: // 1. When introducing C-interface changes to MonoPosixHelper, update // the version strings in VersionCheck below and also // Mono_Unix_VersionString in the C sources. // 2. Any class which performs a DllImport on Stdlib.MPH needs to call // Stdlib.VersionCheck in its static constructor. [DllImport (Stdlib.MPH, CallingConvention=CallingConvention.Cdecl, EntryPoint="Mono_Unix_VersionString")] private static extern IntPtr VersionStringPtr (); private static bool versionCheckPerformed = false; internal static void VersionCheck () { if (versionCheckPerformed) return; // This string is arbitrary; it matters only that it is unique. string assemblyVersion = "MonoProject-2015-12-1"; string nativeVersion = Marshal.PtrToStringAnsi (VersionStringPtr ()); if (assemblyVersion != nativeVersion) { throw new Exception ("Mono.Posix assembly loaded with a different version (\"" + assemblyVersion + "\") than MonoPosixHelper (\"" + nativeVersion + "\"). You may need to reinstall Mono.Posix."); } versionCheckPerformed = true; } static Stdlib () { VersionCheck (); } internal Stdlib () {} #region Declarations // // -- COMPLETE // public static Errno GetLastError () { // Always call Marshal.GetLastWin32Error() before the OS check, // even on Windows where we don't use the return value. If we do // the OS check first Environment.OSVersion (if it happens to be // the first ever access) will clobber Marshal.GetLastWin32Error() // and we won't get the desired errno value on non-Windows platforms. int errno = Marshal.GetLastWin32Error (); if (Environment.OSVersion.Platform != PlatformID.Unix) { // On Windows Marshal.GetLastWin32Error() doesn't take errno // into account so we need to call Mono_Posix_Stdlib_GetLastError() // which returns the value of errno in the C runtime // libMonoPosixHelper.dll was linked against. errno = _GetLastError (); } return NativeConvert.ToErrno (errno); } [DllImport (MPH, CallingConvention=CallingConvention.Cdecl, EntryPoint="Mono_Posix_Stdlib_GetLastError")] private static extern int _GetLastError (); [DllImport (MPH, CallingConvention=CallingConvention.Cdecl, EntryPoint="Mono_Posix_Stdlib_SetLastError")] private static extern void SetLastError (int error); protected static void SetLastError (Errno error) { int _error = NativeConvert.FromErrno (error); SetLastError (_error); } #endregion // // // [DllImport (MPH, CallingConvention=CallingConvention.Cdecl, EntryPoint="Mono_Posix_Stdlib_InvokeSignalHandler")] internal static extern void InvokeSignalHandler (int signum, IntPtr handler); [DllImport (MPH, CallingConvention=CallingConvention.Cdecl, EntryPoint="Mono_Posix_Stdlib_SIG_DFL")] private static extern IntPtr GetDefaultSignal (); [DllImport (MPH, CallingConvention=CallingConvention.Cdecl, EntryPoint="Mono_Posix_Stdlib_SIG_ERR")] private static extern IntPtr GetErrorSignal (); [DllImport (MPH, CallingConvention=CallingConvention.Cdecl, EntryPoint="Mono_Posix_Stdlib_SIG_IGN")] private static extern IntPtr GetIgnoreSignal (); private static readonly IntPtr _SIG_DFL = GetDefaultSignal (); private static readonly IntPtr _SIG_ERR = GetErrorSignal (); private static readonly IntPtr _SIG_IGN = GetIgnoreSignal (); private static void _ErrorHandler (int signum) { Console.Error.WriteLine ("Error handler invoked for signum " + signum + ". Don't do that."); } private static void _DefaultHandler (int signum) { Console.Error.WriteLine ("Default handler invoked for signum " + signum + ". Don't do that."); } private static void _IgnoreHandler (int signum) { Console.Error.WriteLine ("Ignore handler invoked for signum " + signum + ". Don't do that."); } [CLSCompliant (false)] public static readonly SignalHandler SIG_DFL = new SignalHandler (_DefaultHandler); [CLSCompliant (false)] public static readonly SignalHandler SIG_ERR = new SignalHandler (_ErrorHandler); [CLSCompliant (false)] public static readonly SignalHandler SIG_IGN = new SignalHandler (_IgnoreHandler); [DllImport (LIBC, CallingConvention=CallingConvention.Cdecl, SetLastError=true, EntryPoint="signal")] private static extern IntPtr sys_signal (int signum, SignalHandler handler); [DllImport (LIBC, CallingConvention=CallingConvention.Cdecl, SetLastError=true, EntryPoint="signal")] private static extern IntPtr sys_signal (int signum, IntPtr handler); [CLSCompliant (false)] [Obsolete ("This is not safe; " + "use Mono.Unix.UnixSignal for signal delivery or SetSignalAction()")] public static SignalHandler signal (Signum signum, SignalHandler handler) { int _sig = NativeConvert.FromSignum (signum); Delegate[] handlers = handler.GetInvocationList (); for (int i = 0; i < handlers.Length; ++i) { Marshal.Prelink (handlers [i].Method); } IntPtr r; if (handler == SIG_DFL) r = sys_signal (_sig, _SIG_DFL); else if (handler == SIG_ERR) r = sys_signal (_sig, _SIG_ERR); else if (handler == SIG_IGN) r = sys_signal (_sig, _SIG_IGN); else r = sys_signal (_sig, handler); return TranslateHandler (r); } private static SignalHandler TranslateHandler (IntPtr handler) { if (handler == _SIG_DFL) return SIG_DFL; if (handler == _SIG_ERR) return SIG_ERR; if (handler == _SIG_IGN) return SIG_IGN; return (SignalHandler) Marshal.GetDelegateForFunctionPointer (handler, typeof(SignalHandler)); } public static int SetSignalAction (Signum signal, SignalAction action) { return SetSignalAction (NativeConvert.FromSignum (signal), action); } public static int SetSignalAction (RealTimeSignum rts, SignalAction action) { return SetSignalAction (NativeConvert.FromRealTimeSignum (rts), action); } private static int SetSignalAction (int signum, SignalAction action) { IntPtr handler = IntPtr.Zero; switch (action) { case SignalAction.Default: handler = _SIG_DFL; break; case SignalAction.Ignore: handler = _SIG_IGN; break; case SignalAction.Error: handler = _SIG_ERR; break; default: throw new ArgumentException ("Invalid action value.", "action"); } IntPtr r = sys_signal (signum, handler); if (r == _SIG_ERR) return -1; return 0; } [DllImport (LIBC, CallingConvention=CallingConvention.Cdecl, EntryPoint="raise")] private static extern int sys_raise (int sig); [CLSCompliant (false)] public static int raise (Signum sig) { return sys_raise (NativeConvert.FromSignum (sig)); } public static int raise (RealTimeSignum rts) { return sys_raise (NativeConvert.FromRealTimeSignum (rts)); } // // -- COMPLETE except for : // - the scanf(3) family . // - vararg functions. // - Horribly unsafe functions (gets(3)). // [DllImport (MPH, CallingConvention=CallingConvention.Cdecl, EntryPoint="Mono_Posix_Stdlib__IOFBF")] private static extern int GetFullyBuffered (); [DllImport (MPH, CallingConvention=CallingConvention.Cdecl, EntryPoint="Mono_Posix_Stdlib__IOLBF")] private static extern int GetLineBuffered (); [DllImport (MPH, CallingConvention=CallingConvention.Cdecl, EntryPoint="Mono_Posix_Stdlib__IONBF")] private static extern int GetNonBuffered (); [DllImport (MPH, CallingConvention=CallingConvention.Cdecl, EntryPoint="Mono_Posix_Stdlib_BUFSIZ")] private static extern int GetBufferSize (); [DllImport (MPH, CallingConvention=CallingConvention.Cdecl, EntryPoint="Mono_Posix_Stdlib_CreateFilePosition")] internal static extern IntPtr CreateFilePosition (); [DllImport (MPH, CallingConvention=CallingConvention.Cdecl, EntryPoint="Mono_Posix_Stdlib_DumpFilePosition")] internal static extern int DumpFilePosition (StringBuilder buf, HandleRef handle, int len); [DllImport (MPH, CallingConvention=CallingConvention.Cdecl, EntryPoint="Mono_Posix_Stdlib_EOF")] private static extern int GetEOF (); [DllImport (MPH, CallingConvention=CallingConvention.Cdecl, EntryPoint="Mono_Posix_Stdlib_FILENAME_MAX")] private static extern int GetFilenameMax (); [DllImport (MPH, CallingConvention=CallingConvention.Cdecl, EntryPoint="Mono_Posix_Stdlib_FOPEN_MAX")] private static extern int GetFopenMax (); [DllImport (MPH, CallingConvention=CallingConvention.Cdecl, EntryPoint="Mono_Posix_Stdlib_L_tmpnam")] private static extern int GetTmpnamLength (); [DllImport (MPH, CallingConvention=CallingConvention.Cdecl, EntryPoint="Mono_Posix_Stdlib_stdin")] private static extern IntPtr GetStandardInput (); [DllImport (MPH, CallingConvention=CallingConvention.Cdecl, EntryPoint="Mono_Posix_Stdlib_stdout")] private static extern IntPtr GetStandardOutput (); [DllImport (MPH, CallingConvention=CallingConvention.Cdecl, EntryPoint="Mono_Posix_Stdlib_stderr")] private static extern IntPtr GetStandardError (); [DllImport (MPH, CallingConvention=CallingConvention.Cdecl, EntryPoint="Mono_Posix_Stdlib_TMP_MAX")] private static extern int GetTmpMax (); [CLSCompliant (false)] public static readonly int _IOFBF = GetFullyBuffered (); [CLSCompliant (false)] public static readonly int _IOLBF = GetLineBuffered (); [CLSCompliant (false)] public static readonly int _IONBF = GetNonBuffered (); [CLSCompliant (false)] public static readonly int BUFSIZ = GetBufferSize (); [CLSCompliant (false)] public static readonly int EOF = GetEOF (); [CLSCompliant (false)] public static readonly int FOPEN_MAX = GetFopenMax (); [CLSCompliant (false)] public static readonly int FILENAME_MAX = GetFilenameMax (); [CLSCompliant (false)] public static readonly int L_tmpnam = GetTmpnamLength (); public static readonly IntPtr stderr = GetStandardError (); public static readonly IntPtr stdin = GetStandardInput (); public static readonly IntPtr stdout = GetStandardOutput (); [CLSCompliant (false)] public static readonly int TMP_MAX = GetTmpMax (); [DllImport (LIBC, CallingConvention=CallingConvention.Cdecl, SetLastError=true)] public static extern int remove ( [MarshalAs (UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(FileNameMarshaler))] string filename); [DllImport (LIBC, CallingConvention=CallingConvention.Cdecl, SetLastError=true)] public static extern int rename ( [MarshalAs (UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(FileNameMarshaler))] string oldpath, [MarshalAs (UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(FileNameMarshaler))] string newpath); [DllImport (MPH, CallingConvention=CallingConvention.Cdecl, SetLastError=true, EntryPoint="Mono_Posix_Stdlib_tmpfile")] public static extern IntPtr tmpfile (); private static object tmpnam_lock = new object (); [DllImport (LIBC, CallingConvention=CallingConvention.Cdecl, SetLastError=true, EntryPoint="tmpnam")] private static extern IntPtr sys_tmpnam (StringBuilder s); [Obsolete ("Syscall.mkstemp() should be preferred.")] public static string tmpnam (StringBuilder s) { if (s != null && s.Capacity < L_tmpnam) throw new ArgumentOutOfRangeException ("s", "s.Capacity < L_tmpnam"); lock (tmpnam_lock) { IntPtr r = sys_tmpnam (s); return UnixMarshal.PtrToString (r); } } [Obsolete ("Syscall.mkstemp() should be preferred.")] public static string tmpnam () { lock (tmpnam_lock) { IntPtr r = sys_tmpnam (null); return UnixMarshal.PtrToString (r); } } [DllImport (MPH, CallingConvention=CallingConvention.Cdecl, SetLastError=true, EntryPoint="Mono_Posix_Stdlib_fclose")] public static extern int fclose (IntPtr stream); [DllImport (MPH, CallingConvention=CallingConvention.Cdecl, SetLastError=true, EntryPoint="Mono_Posix_Stdlib_fflush")] public static extern int fflush (IntPtr stream); [DllImport (MPH, CallingConvention=CallingConvention.Cdecl, SetLastError=true, EntryPoint="Mono_Posix_Stdlib_fopen")] public static extern IntPtr fopen ( [MarshalAs (UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(FileNameMarshaler))] string path, string mode); [DllImport (MPH, CallingConvention=CallingConvention.Cdecl, SetLastError=true, EntryPoint="Mono_Posix_Stdlib_freopen")] public static extern IntPtr freopen ( [MarshalAs (UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(FileNameMarshaler))] string path, string mode, IntPtr stream); [DllImport (MPH, CallingConvention=CallingConvention.Cdecl, SetLastError=true, EntryPoint="Mono_Posix_Stdlib_setbuf")] public static extern int setbuf (IntPtr stream, IntPtr buf); [CLSCompliant (false)] public static unsafe int setbuf (IntPtr stream, byte* buf) { return setbuf (stream, (IntPtr) buf); } [CLSCompliant (false)] [DllImport (MPH, CallingConvention=CallingConvention.Cdecl, SetLastError=true, EntryPoint="Mono_Posix_Stdlib_setvbuf")] public static extern int setvbuf (IntPtr stream, IntPtr buf, int mode, ulong size); [CLSCompliant (false)] public static unsafe int setvbuf (IntPtr stream, byte* buf, int mode, ulong size) { return setvbuf (stream, (IntPtr) buf, mode, size); } [DllImport (MPH, CallingConvention=CallingConvention.Cdecl, EntryPoint="Mono_Posix_Stdlib_fprintf")] private static extern int sys_fprintf (IntPtr stream, string format, string message); public static int fprintf (IntPtr stream, string message) { return sys_fprintf (stream, "%s", message); } #if !NETSTANDARD2_0 [Obsolete ("Not necessarily portable due to cdecl restrictions.\n" + "Use fprintf (IntPtr, string) instead.")] public static int fprintf (IntPtr stream, string format, params object[] parameters) { object[] _parameters = new object[checked(parameters.Length+2)]; _parameters [0] = stream; _parameters [1] = format; Array.Copy (parameters, 0, _parameters, 2, parameters.Length); return (int) XPrintfFunctions.fprintf (_parameters); } #endif /* SKIP: fscanf(3) */ [DllImport (LIBC, CallingConvention=CallingConvention.Cdecl, EntryPoint="printf")] private static extern int sys_printf (string format, string message); public static int printf (string message) { return sys_printf ("%s", message); } #if !NETSTANDARD2_0 [Obsolete ("Not necessarily portable due to cdecl restrictions.\n" + "Use printf (string) instead.")] public static int printf (string format, params object[] parameters) { object[] _parameters = new object[checked(parameters.Length+1)]; _parameters [0] = format; Array.Copy (parameters, 0, _parameters, 1, parameters.Length); return (int) XPrintfFunctions.printf (_parameters); } #endif /* SKIP: scanf(3) */ [DllImport (MPH, CallingConvention=CallingConvention.Cdecl, EntryPoint="Mono_Posix_Stdlib_snprintf")] private static extern int sys_snprintf (StringBuilder s, ulong n, string format, string message); [CLSCompliant (false)] public static int snprintf (StringBuilder s, ulong n, string message) { if (n > (ulong) s.Capacity) throw new ArgumentOutOfRangeException ("n", "n must be <= s.Capacity"); return sys_snprintf (s, n, "%s", message); } public static int snprintf (StringBuilder s, string message) { return sys_snprintf (s, (ulong) s.Capacity, "%s", message); } #if !NETSTANDARD2_0 [CLSCompliant (false)] [Obsolete ("Not necessarily portable due to cdecl restrictions.\n" + "Use snprintf (StringBuilder, string) instead.")] public static int snprintf (StringBuilder s, ulong n, string format, params object[] parameters) { if (n > (ulong) s.Capacity) throw new ArgumentOutOfRangeException ("n", "n must be <= s.Capacity"); object[] _parameters = new object[checked(parameters.Length+3)]; _parameters [0] = s; _parameters [1] = n; _parameters [2] = format; Array.Copy (parameters, 0, _parameters, 3, parameters.Length); return (int) XPrintfFunctions.snprintf (_parameters); } [CLSCompliant (false)] [Obsolete ("Not necessarily portable due to cdecl restrictions.\n" + "Use snprintf (StringBuilder, string) instead.")] public static int snprintf (StringBuilder s, string format, params object[] parameters) { object[] _parameters = new object[checked(parameters.Length+3)]; _parameters [0] = s; _parameters [1] = (ulong) s.Capacity; _parameters [2] = format; Array.Copy (parameters, 0, _parameters, 3, parameters.Length); return (int) XPrintfFunctions.snprintf (_parameters); } #endif /* * SKIP: * sprintf(3) * sscanf(3) * vfprintf(3) * vfscanf(3) * vprintf(3) * vscanf(3) * vsnprintf(3) * vsprint(3) * vsscanf(3) */ [DllImport (MPH, CallingConvention=CallingConvention.Cdecl, SetLastError=true, EntryPoint="Mono_Posix_Stdlib_fgetc")] public static extern int fgetc (IntPtr stream); [DllImport (MPH, CallingConvention=CallingConvention.Cdecl, SetLastError=true, EntryPoint="Mono_Posix_Stdlib_fgets")] private static extern IntPtr sys_fgets (StringBuilder sb, int size, IntPtr stream); public static StringBuilder fgets (StringBuilder sb, int size, IntPtr stream) { IntPtr r = sys_fgets (sb, size, stream); if (r == IntPtr.Zero) return null; return sb; } public static StringBuilder fgets (StringBuilder sb, IntPtr stream) { return fgets (sb, sb.Capacity, stream); } [DllImport (MPH, CallingConvention=CallingConvention.Cdecl, SetLastError=true, EntryPoint="Mono_Posix_Stdlib_fputc")] public static extern int fputc (int c, IntPtr stream); [DllImport (MPH, CallingConvention=CallingConvention.Cdecl, SetLastError=true, EntryPoint="Mono_Posix_Stdlib_fputs")] public static extern int fputs (string s, IntPtr stream); public static int getc (IntPtr stream) { return fgetc (stream); } [DllImport (LIBC, CallingConvention=CallingConvention.Cdecl, SetLastError=true)] public static extern int getchar (); /* SKIP: gets(3) */ public static int putc (int c, IntPtr stream) { return fputc (c, stream); } [DllImport (LIBC, CallingConvention=CallingConvention.Cdecl, SetLastError=true)] public static extern int putchar (int c); [DllImport (LIBC, CallingConvention=CallingConvention.Cdecl, SetLastError=true)] public static extern int puts (string s); [DllImport (MPH, CallingConvention=CallingConvention.Cdecl, SetLastError=true, EntryPoint="Mono_Posix_Stdlib_ungetc")] public static extern int ungetc (int c, IntPtr stream); [CLSCompliant (false)] [DllImport (MPH, CallingConvention=CallingConvention.Cdecl, SetLastError=true, EntryPoint="Mono_Posix_Stdlib_fread")] public static extern ulong fread (IntPtr ptr, ulong size, ulong nmemb, IntPtr stream); [CLSCompliant (false)] public static unsafe ulong fread (void* ptr, ulong size, ulong nmemb, IntPtr stream) { return fread ((IntPtr) ptr, size, nmemb, stream); } [DllImport (MPH, CallingConvention=CallingConvention.Cdecl, SetLastError=true, EntryPoint="Mono_Posix_Stdlib_fread")] private static extern ulong sys_fread ([Out] byte[] ptr, ulong size, ulong nmemb, IntPtr stream); [CLSCompliant (false)] public static ulong fread (byte[] ptr, ulong size, ulong nmemb, IntPtr stream) { if ((size * nmemb) > (ulong) ptr.Length) throw new ArgumentOutOfRangeException ("nmemb"); return sys_fread (ptr, size, nmemb, stream); } [CLSCompliant (false)] public static ulong fread (byte[] ptr, IntPtr stream) { return fread (ptr, 1, (ulong) ptr.Length, stream); } [CLSCompliant (false)] [DllImport (MPH, CallingConvention=CallingConvention.Cdecl, SetLastError=true, EntryPoint="Mono_Posix_Stdlib_fwrite")] public static extern ulong fwrite (IntPtr ptr, ulong size, ulong nmemb, IntPtr stream); [CLSCompliant (false)] public static unsafe ulong fwrite (void* ptr, ulong size, ulong nmemb, IntPtr stream) { return fwrite ((IntPtr) ptr, size, nmemb, stream); } [DllImport (MPH, CallingConvention=CallingConvention.Cdecl, SetLastError=true, EntryPoint="Mono_Posix_Stdlib_fwrite")] private static extern ulong sys_fwrite (byte[] ptr, ulong size, ulong nmemb, IntPtr stream); [CLSCompliant (false)] public static ulong fwrite (byte[] ptr, ulong size, ulong nmemb, IntPtr stream) { if ((size * nmemb) > (ulong) ptr.Length) throw new ArgumentOutOfRangeException ("nmemb"); return sys_fwrite (ptr, size, nmemb, stream); } [CLSCompliant (false)] public static ulong fwrite (byte[] ptr, IntPtr stream) { return fwrite (ptr, 1, (ulong) ptr.Length, stream); } [DllImport (MPH, CallingConvention=CallingConvention.Cdecl, SetLastError=true, EntryPoint="Mono_Posix_Stdlib_fgetpos")] private static extern int sys_fgetpos (IntPtr stream, HandleRef pos); public static int fgetpos (IntPtr stream, FilePosition pos) { return sys_fgetpos (stream, pos.Handle); } [DllImport (MPH, CallingConvention=CallingConvention.Cdecl, SetLastError=true, EntryPoint="Mono_Posix_Stdlib_fseek")] private static extern int sys_fseek (IntPtr stream, long offset, int origin); [CLSCompliant (false)] public static int fseek (IntPtr stream, long offset, SeekFlags origin) { int _origin = NativeConvert.FromSeekFlags (origin); return sys_fseek (stream, offset, _origin); } [DllImport (MPH, CallingConvention=CallingConvention.Cdecl, SetLastError=true, EntryPoint="Mono_Posix_Stdlib_fsetpos")] private static extern int sys_fsetpos (IntPtr stream, HandleRef pos); public static int fsetpos (IntPtr stream, FilePosition pos) { return sys_fsetpos (stream, pos.Handle); } [DllImport (MPH, CallingConvention=CallingConvention.Cdecl, SetLastError=true, EntryPoint="Mono_Posix_Stdlib_ftell")] public static extern long ftell (IntPtr stream); [DllImport (MPH, CallingConvention=CallingConvention.Cdecl, SetLastError=true, EntryPoint="Mono_Posix_Stdlib_rewind")] public static extern int rewind (IntPtr stream); [DllImport (MPH, CallingConvention=CallingConvention.Cdecl, SetLastError=true, EntryPoint="Mono_Posix_Stdlib_clearerr")] public static extern int clearerr (IntPtr stream); [DllImport (MPH, CallingConvention=CallingConvention.Cdecl, SetLastError=true, EntryPoint="Mono_Posix_Stdlib_feof")] public static extern int feof (IntPtr stream); [DllImport (MPH, CallingConvention=CallingConvention.Cdecl, SetLastError=true, EntryPoint="Mono_Posix_Stdlib_ferror")] public static extern int ferror (IntPtr stream); [DllImport (MPH, CallingConvention=CallingConvention.Cdecl, SetLastError=true, EntryPoint="Mono_Posix_Stdlib_perror")] private static extern int perror (string s, int err); public static int perror (string s) { return perror (s, Marshal.GetLastWin32Error ()); } // // // [DllImport (MPH, CallingConvention=CallingConvention.Cdecl, EntryPoint="Mono_Posix_Stdlib_EXIT_FAILURE")] private static extern int GetExitFailure(); [DllImport (MPH, CallingConvention=CallingConvention.Cdecl, EntryPoint="Mono_Posix_Stdlib_EXIT_SUCCESS")] private static extern int GetExitSuccess (); [DllImport (MPH, CallingConvention=CallingConvention.Cdecl, EntryPoint="Mono_Posix_Stdlib_MB_CUR_MAX")] private static extern int GetMbCurMax (); [DllImport (MPH, CallingConvention=CallingConvention.Cdecl, EntryPoint="Mono_Posix_Stdlib_RAND_MAX")] private static extern int GetRandMax (); [CLSCompliant (false)] public static readonly int EXIT_FAILURE = GetExitFailure (); [CLSCompliant (false)] public static readonly int EXIT_SUCCESS = GetExitSuccess (); [CLSCompliant (false)] public static readonly int MB_CUR_MAX = GetMbCurMax (); [CLSCompliant (false)] public static readonly int RAND_MAX = GetRandMax (); [DllImport (LIBC, CallingConvention=CallingConvention.Cdecl)] public static extern int rand (); [CLSCompliant (false)] [DllImport (LIBC, CallingConvention=CallingConvention.Cdecl)] public static extern void srand (uint seed); // calloc(3): // void *calloc (size_t nmemb, size_t size); [CLSCompliant (false)] [DllImport (MPH, CallingConvention=CallingConvention.Cdecl, SetLastError=true, EntryPoint="Mono_Posix_Stdlib_calloc")] public static extern IntPtr calloc (ulong nmemb, ulong size); [DllImport (MPH, CallingConvention=CallingConvention.Cdecl, EntryPoint="Mono_Posix_Stdlib_free")] public static extern void free (IntPtr ptr); // malloc(3): // void *malloc(size_t size); [CLSCompliant (false)] [DllImport (MPH, CallingConvention=CallingConvention.Cdecl, SetLastError=true, EntryPoint="Mono_Posix_Stdlib_malloc")] public static extern IntPtr malloc (ulong size); // realloc(3): // void *realloc(void *ptr, size_t size); [CLSCompliant (false)] [DllImport (MPH, CallingConvention=CallingConvention.Cdecl, SetLastError=true, EntryPoint="Mono_Posix_Stdlib_realloc")] public static extern IntPtr realloc (IntPtr ptr, ulong size); [DllImport (LIBC, CallingConvention=CallingConvention.Cdecl)] public static extern void abort (); /* SKIP: atexit(3) -- the GC should have collected most references by the * time this runs, so no delegates should exist, making it pointless. */ [DllImport (LIBC, CallingConvention=CallingConvention.Cdecl)] public static extern void exit (int status); [CLSCompliant (false)] [DllImport (LIBC, CallingConvention=CallingConvention.Cdecl)] public static extern void _Exit (int status); [DllImport (LIBC, CallingConvention=CallingConvention.Cdecl, EntryPoint="getenv")] private static extern IntPtr sys_getenv (string name); public static string getenv (string name) { IntPtr r = sys_getenv (name); return UnixMarshal.PtrToString (r); } [CLSCompliant (false)] [DllImport (LIBC, CallingConvention=CallingConvention.Cdecl, SetLastError=true)] public static extern int system (string @string); // // // private static object strerror_lock = new object (); [DllImport (LIBC, CallingConvention=CallingConvention.Cdecl, SetLastError=true, EntryPoint="strerror")] private static extern IntPtr sys_strerror (int errnum); [CLSCompliant (false)] public static string strerror (Errno errnum) { int e = NativeConvert.FromErrno (errnum); lock (strerror_lock) { IntPtr r = sys_strerror (e); return UnixMarshal.PtrToString (r); } } // strlen(3): // size_t strlen(const char *s); [CLSCompliant (false)] [DllImport (MPH, CallingConvention=CallingConvention.Cdecl, SetLastError=true, EntryPoint="Mono_Posix_Stdlib_strlen")] public static extern ulong strlen (IntPtr s); } #endregion // Classes } // vim: noexpandtab