Merge pull request #2248 from stephentoub/path_unix

Implement System.IO.Path on Unix

Author: stephentoub

src/Common/src/Interop/Unix/libc/Interop.getcwd.cs

@@ -10,7 +10,66 @@ internal static partial class Interop
 {
     internal static partial class libc
     {
+        internal static unsafe string getcwd()
+        {
+            const int StackLimit = 256;
+
+            // First try to get the path into a buffer on the stack
+            byte* stackBuf = stackalloc byte[StackLimit];
+            string result = getcwd(stackBuf, StackLimit);
+            if (result != null)
+            {
+                return result;
+            }
+
+            // If that was too small, try increasing large buffer sizes
+            // until we get one that works or until we hit MaxPath.
+            int maxPath = Interop.libc.MaxPath;
+            if (StackLimit < maxPath)
+            {
+                int bufferSize = StackLimit;
+                do
+                {
+                    checked { bufferSize *= 2; }
+                    var buf = new byte[Math.Min(bufferSize, maxPath)];
+                    fixed (byte* ptr = buf)
+                    {
+                        result = getcwd(ptr, buf.Length);
+                        if (result != null)
+                        {
+                            return result;
+                        }
+                    }
+                }
+                while (bufferSize < maxPath);
+            }
+
+            // If we couldn't get the cwd with a MaxPath-sized buffer, something's wrong.
+            throw Interop.GetExceptionForIoErrno(Interop.Errors.ENAMETOOLONG);
+        }
+
+        private static unsafe string getcwd(byte* ptr, int bufferSize)
+        {
+            // Call the real getcwd
+            byte* result = getcwd(ptr, (size_t)bufferSize);
+
+            // If it returned non-null, the null-terminated path is in the buffer
+            if (result != null)
+            {
+                return Marshal.PtrToStringAnsi((IntPtr)ptr);
+            }
+
+            // Otherwise, if it failed due to the buffer being too small, return null;
+            // for anything else, throw.
+            int errno = Marshal.GetLastWin32Error();
+            if (errno == Interop.Errors.ERANGE)
+            {
+               return null;
+            }
+            throw Interop.GetExceptionForIoErrno(errno);
+        }
+
         [DllImport(Libraries.Libc, SetLastError = true)]
-        internal static extern unsafe byte* getcwd(byte* buf, size_t bufSize);
+        private static extern unsafe byte* getcwd(byte* buf, size_t bufSize);
     }
 }

src/Common/src/Interop/Unix/libc/Interop.mkstemps.cs

@@ -0,0 +1,13 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System.Runtime.InteropServices;
+
+internal static partial class Interop
+{
+    internal static partial class libc
+    {
+        [DllImport(Libraries.Libc, SetLastError = true)]
+        internal static extern int mkstemps(byte[] template, int suffixlen);
+    }
+}

src/Common/src/Interop/Unix/libc/Interop.pathconf.cs

@@ -8,6 +8,21 @@ internal static partial class Interop
 {
     internal static partial class libc
     {
+        /// <summary>The maximum path length for the system.  -1 if it hasn't yet been initialized.</summary>
+        private static int s_maxPath = -1;
+        /// <summary>The maximum name length for the system.  -1 if it hasn't yet been initialized.</summary>
+        private static int s_maxName = -1;
+
+        internal static int MaxPath
+        {
+            get { return Interop.libc.GetPathConfValue(ref s_maxPath, Interop.libc.PathConfNames._PC_PATH_MAX, Interop.libc.DEFAULT_PC_PATH_MAX); }
+        }
+
+        internal static int MaxName
+        {
+            get { return Interop.libc.GetPathConfValue(ref s_maxName, Interop.libc.PathConfNames._PC_NAME_MAX, Interop.libc.DEFAULT_PC_NAME_MAX); }
+        }
+
         /// <summary>
         /// Gets a pathconf value by name.  If the cached value is less than zero (meaning not yet initialized),
         /// pathconf is used to retrieve the value, which is then stored into the field.
@@ -16,13 +31,14 @@ internal static partial class libc
         /// <param name="cachedValue">The field used to cache the pathconf value.</param>
         /// <param name="pathConfName">The name of the pathconf value.</param>
         /// <param name="defaultValue">The default value to use in case pathconf fails.</param>
-        internal static void GetPathConfValue(ref int cachedValue, int pathConfName, int defaultValue)
+        private static int GetPathConfValue(ref int cachedValue, int pathConfName, int defaultValue)
         {
             if (cachedValue < 0) // benign race condition on cached value
             {
                 int result = Interop.libc.pathconf("/", pathConfName);
                 cachedValue = result >= 0 ? result : defaultValue;
             }
+            return cachedValue;
         }
 
         [DllImport(Libraries.Libc, SetLastError = true)]

src/Common/src/Interop/Unix/libcrypto/Interop.Initialization.cs

@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
+using System;
 using System.Runtime.InteropServices;
 using System.Security.Cryptography;
 
@@ -15,7 +16,13 @@ static libcrypto()
         {
             if (Interop.libcoreclr.EnsureOpenSslInitialized() != 0)
             {
-                throw new CryptographicException();
+                // Ideally this would be a CryptographicException, but we use
+                // OpenSSL in libraries lower than System.Security.Cryptography.
+                // It's not a big deal, though: this will already be wrapped in a
+                // TypeLoadException, and this failing means something is very
+                // wrong with the system's configuration and any code using
+                // these libraries will be unable to operate correctly.
+                throw new InvalidOperationException();
             }
 
             // Load the SHA-2 hash algorithms, and anything else not in the default

src/Common/tests/System/Diagnostics/AssertWithCallerAttributes.cs

@@ -578,17 +578,20 @@ public static async Task<T> ThrowsAsync<T>(string paramName, Func<Task> testCode
         catch (Exception e) { throw WrapException(e, path, line); }
     }
 
-    public static void True(bool condition,
+    public static void True(bool condition, string userMessage = null,
         [CallerFilePath] string path = null, [CallerLineNumber] int line = 0)
     {
-        try { Xunit.Assert.True(condition); }
-        catch (Exception e) { throw WrapException(e, path, line); }
-    }
-
-    public static void True(bool condition, string userMessage,
-        [CallerFilePath] string path = null, [CallerLineNumber] int line = 0)
-    {
-        try { Xunit.Assert.True(condition, userMessage); }
+        try
+        {
+            if (userMessage == null)
+            {
+                Xunit.Assert.True(condition);
+            }
+            else
+            {
+                Xunit.Assert.True(condition, userMessage);
+            }
+        }
         catch (Exception e) { throw WrapException(e, path, line); }
     }
 

src/System.Console/src/Resources/Strings.resx

@@ -160,7 +160,7 @@
     <value>Could not find a part of the path '{0}'.</value>
   </data>
   <data name="IO_PathTooLong" xml:space="preserve">
-    <value>The specified path, file name, or both are too long. The fully qualified file name must be less than 260 characters, and the directory name must be less than 248 characters.</value>
+    <value>The specified file name or path is too long, or a component of the specified path is too long.</value>
   </data>
   <data name="UnauthorizedAccess_IODenied_NoPathName" xml:space="preserve">
     <value>Access to the path is denied.</value>

src/System.Diagnostics.Debug/src/Resources/Strings.resx

@@ -166,6 +166,6 @@
     <value>The file '{0}' already exists.</value>
   </data>
   <data name="IO_PathTooLong" xml:space="preserve">
-    <value>The specified path, file name, or both are too long. The fully qualified file name must be less than 260 characters, and the directory name must be less than 248 characters.</value>
+    <value>The specified file name or path is too long, or a component of the specified path is too long.</value>
   </data>
 </root>

src/System.Diagnostics.Process/src/System/Diagnostics/Process.Linux.cs

@@ -146,8 +146,7 @@ private void SetWorkingSetLimitsCore(IntPtr? newMin, IntPtr? newMax, out IntPtr
         private static string GetExePath()
         {
             // Determine the maximum size of a path
-            int maxPath = -1;
-            Interop.libc.GetPathConfValue(ref maxPath, Interop.libc.PathConfNames._PC_PATH_MAX, Interop.libc.DEFAULT_PC_PATH_MAX);
+            int maxPath = Interop.libc.MaxPath;
 
             // Start small with a buffer allocation, and grow only up to the max path
             for (int pathLen = 256; pathLen < maxPath; pathLen *= 2)

src/System.IO.FileSystem.DriveInfo/src/Resources/Strings.resx

@@ -157,7 +157,7 @@
     <value>Could not find a part of the path '{0}'.</value>
   </data>
   <data name="IO_PathTooLong" xml:space="preserve">
-    <value>The specified path, file name, or both are too long. The fully qualified file name must be less than 260 characters, and the directory name must be less than 248 characters.</value>
+    <value>The specified file name or path is too long, or a component of the specified path is too long.</value>
   </data>
   <data name="IO_SharingViolation_File" xml:space="preserve">
     <value>The process cannot access the file '{0}' because it is being used by another process.</value>

src/System.IO.FileSystem.Watcher/src/Resources/Strings.resx

@@ -142,7 +142,7 @@
     <value>Specified file length was too large for the file system.</value>
   </data>
   <data name="IO_PathTooLong" xml:space="preserve">
-    <value>The specified path, file name, or both are too long. The fully qualified file name must be less than 260 characters, and the directory name must be less than 248 characters.</value>
+    <value>The specified file name or path is too long, or a component of the specified path is too long.</value>
   </data>
   <data name="IO_PathNotFound_NoPathName" xml:space="preserve">
     <value>Could not find a part of the path.</value>