Fix access to user's home directory on Unix

Today in several places we get a user's home directory by accessing the HOME environment variable.  This is the right place to check first, but in certain cases it may not be set, such as in initialization scripts.

This commit implements a fallback, such that if HOME doesn't have a path, we consult the pw_dir path from a call to getpwuid_r for the current user.

As long as I was adding getpwuid_r to the native shim, I also moved our existing geteuid and getegid imports to the shims.

Author: stephentoub

src/Common/src/Interop/Unix/libc/Interop.getegid.cs renamed to src/Common/src/Interop/Unix/System.Native/Interop.GetEGid.cs

@@ -6,9 +6,9 @@
 
 internal static partial class Interop
 {
-    internal static partial class libc
+    internal static partial class Sys
     {
-        [DllImport(Libraries.Libc)]
-        internal static extern int getegid();
+        [DllImport(Libraries.SystemNative)]
+        internal static extern int GetEGid();
     }
 }

src/Common/src/Interop/Unix/libc/Interop.geteuid.cs renamed to src/Common/src/Interop/Unix/System.Native/Interop.GetEUid.cs

@@ -6,9 +6,9 @@
 
 internal static partial class Interop
 {
-    internal static partial class libc
+    internal static partial class Sys
     {
-        [DllImport(Libraries.Libc)]
-        internal static extern int geteuid();
+        [DllImport(Libraries.SystemNative)]
+        internal static extern int GetEUid();
     }
 }

src/Common/src/Interop/Unix/System.Native/Interop.GetPwUid.cs

@@ -0,0 +1,25 @@
+// 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;
+
+internal static partial class Interop
+{
+    internal static partial class Sys
+    {
+        internal unsafe struct Passwd
+        {
+            internal byte* Name;
+            internal byte* Password;
+            internal int   UserId;
+            internal int   GroupId;
+            internal byte* UserInfo;
+            internal byte* HomeDirectory;
+            internal byte* Shell;
+        };
+
+        [DllImport(Libraries.SystemNative, SetLastError = true)]
+        internal static extern unsafe int GetPwUid(int uid, out Passwd pwd, byte* buf, long bufLen, out IntPtr result);
+    }
+}

src/Common/src/System/IO/PersistedFiles.Unix.cs

@@ -2,6 +2,7 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 using System.Diagnostics;
+using System.Runtime.InteropServices;
 
 namespace System.IO
 {
@@ -81,8 +82,7 @@ internal static string GetUserFeatureDirectory(params string[] featurePathParts)
 
         private static void EnsureUserDirectories()
         {
-            // TODO (2820): Use getpwuid_r(geteuid(), ...) instead of the HOME environment variable
-            string userHomeDirectory = Environment.GetEnvironmentVariable("HOME");
+            string userHomeDirectory = GetHomeDirectory();
 
             if (string.IsNullOrEmpty(userHomeDirectory))
             {
@@ -94,5 +94,95 @@ private static void EnsureUserDirectories()
                 TopLevelHiddenDirectory,
                 SecondLevelDirectory);
         }
+
+        /// <summary>Gets the current user's home directory.</summary>
+        /// <returns>The path to the home directory, or null if it could not be determined.</returns>
+        internal static string GetHomeDirectory()
+        {
+            // First try to get the user's home directory from the HOME environment variable.
+            // This should work in most cases.
+            string userHomeDirectory = Environment.GetEnvironmentVariable("HOME");
+            if (!string.IsNullOrEmpty(userHomeDirectory))
+                return userHomeDirectory;
+
+            // In initialization conditions, however, the "HOME" enviroment variable may 
+            // not yet be set. For such cases, consult with the password entry.
+            unsafe
+            {
+                // First try with a buffer that should suffice for 99% of cases.
+                // Note that, theoretically, userHomeDirectory may be null in the success case 
+                // if we simply couldn't find a home directory for the current user.
+                // In that case, we pass back the null value and let the caller decide
+                // what to do.
+                const int BufLen = 1024;
+                byte* stackBuf = stackalloc byte[BufLen];
+                if (TryGetHomeDirectoryFromPasswd(stackBuf, BufLen, out userHomeDirectory))
+                    return userHomeDirectory;
+
+                // Fallback to heap allocations if necessary, growing the buffer until
+                // we succeed.  TryGetHomeDirectory will throw if there's an unexpected error.
+                int lastBufLen = BufLen;
+                while (true)
+                {
+                    lastBufLen *= 2;
+                    byte[] heapBuf = new byte[lastBufLen];
+                    fixed (byte* buf = heapBuf)
+                    {
+                        if (TryGetHomeDirectoryFromPasswd(buf, heapBuf.Length, out userHomeDirectory))
+                            return userHomeDirectory;
+                    }
+                }
+            }
+        }
+
+        /// <summary>Wrapper for getpwuid_r.</summary>
+        /// <param name="buf">The scratch buffer to pass into getpwuid_r.</param>
+        /// <param name="bufLen">The length of <paramref name="buf"/>.</param>
+        /// <param name="path">The resulting path; null if the user didn't have an entry.</param>
+        /// <returns>true if the call was successful (path may still be null); false is a larger buffer is needed.</returns>
+        private static unsafe bool TryGetHomeDirectoryFromPasswd(byte* buf, int bufLen, out string path)
+        {
+            while (true)
+            {
+                // Call getpwuid_r to get the passwd struct
+                Interop.Sys.Passwd passwd;
+                IntPtr result;
+                int rv = Interop.Sys.GetPwUid(Interop.Sys.GetEUid(), out passwd, buf, bufLen, out result);
+
+                // If the call succeeds, give back the home directory path retrieved
+                if (rv == 0)
+                {
+                    if (result == IntPtr.Zero)
+                    {
+                        // Current user's entry could not be found
+                        path = null; // we'll still return true, as false indicates the buffer was too small
+                    }
+                    else
+                    {
+                        Debug.Assert(result == (IntPtr)(&passwd));
+                        Debug.Assert(passwd.HomeDirectory != null);
+                        path = Marshal.PtrToStringAnsi((IntPtr)passwd.HomeDirectory);
+                    }
+                    return true;
+                }
+
+                // If the call failed because it was interrupted, try again.
+                Interop.ErrorInfo errorInfo = Interop.Sys.GetLastErrorInfo();
+                if (errorInfo.Error == Interop.Error.EINTR)
+                    continue;
+
+                // If the call failed because the buffer was too small, return false to 
+                // indicate the caller should try again with a larger buffer.
+                if (errorInfo.Error == Interop.Error.ERANGE)
+                {
+                    path = null;
+                    return false;
+                }
+
+                // Otherwise, fail.
+                throw new IOException(errorInfo.GetErrorMessage(), errorInfo.RawErrno);
+            }
+        }
+
     }
 }

src/Native/System.Native/CMakeLists.txt

@@ -4,6 +4,7 @@ set(NATIVE_SOURCES
     pal_errno.cpp
     pal_exec.cpp
     pal_stat.cpp
+    pal_uid.cpp
 )
 
 add_library(System.Native

src/Native/System.Native/pal_uid.cpp

@@ -0,0 +1,74 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+#include "../config.h"
+#include "pal_uid.h"
+
+#include <assert.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <pwd.h>
+
+/**
+* Gets a password structure for the given uid.
+* Implemented as shim to getpwuid_r(3).
+*
+* Returns 0 for success, -1 for failure. Sets errno on failure.
+*/
+extern "C"
+int32_t GetPwUid(
+	int32_t  uid,
+	Passwd*  pwd,
+	char*    buf,
+	int64_t  buflen,
+	Passwd** result)
+{
+	assert(pwd != nullptr);
+	assert(buf != nullptr);
+	assert(buflen >= 0);
+	assert(result != nullptr);
+
+	struct passwd nativePwd;
+	struct passwd* nativePwdResultPtr;
+	int rv = getpwuid_r(uid, &nativePwd, buf, buflen, &nativePwdResultPtr);
+
+	// If successful, the result will be null if the user couldn't be found,
+	// or it'll contain the address of the provided pwd structure, into
+	// which the results are stored.
+	if (rv == 0 && nativePwdResultPtr != nullptr)
+	{
+		assert(nativePwdResultPtr == &nativePwd);
+		
+		pwd->Name = nativePwd.pw_name;
+		pwd->Password = nativePwd.pw_passwd;
+		pwd->UserId = nativePwd.pw_uid;
+		pwd->GroupId = nativePwd.pw_gid;
+		pwd->UserInfo = nativePwd.pw_gecos;
+		pwd->HomeDirectory = nativePwd.pw_dir;
+		pwd->Shell = nativePwd.pw_shell;
+		*result = pwd;
+	}
+	else
+	{
+		// Make sure we zero out the results fields, as the managed
+		// caller could be using out variables and expect them to be initialized
+		// after the call.
+		*pwd = { };
+		*result = nullptr;
+	}
+
+	return rv;
+}
+
+extern "C"
+int32_t GetEUid()
+{
+	return geteuid();
+}
+
+extern "C"
+int32_t GetEGid()
+{
+	return getegid();
+}

src/Native/System.Native/pal_uid.h

@@ -0,0 +1,51 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+#pragma once
+
+#include <stdint.h>
+
+/**
+* Passwd struct 
+*/
+struct Passwd {
+	char*   Name;
+	char*   Password; 
+	int32_t UserId;
+	int32_t GroupId;
+	char*   UserInfo;
+	char*   HomeDirectory;
+	char*   Shell;
+};
+
+/**
+* Gets a password structure for the given uid. 
+* Implemented as shim to getpwuid_r(3).
+*
+* Returns 0 for success, -1 for failure. Sets errno on failure.
+*/
+extern "C"
+int32_t GetPwUid(
+	int32_t  uid,
+	Passwd*  pwd,
+	char*    buf,
+	int64_t  buflen,
+	Passwd** result);
+
+/**
+* Gets and returns the effective user's identity.
+* Implemented as shim to geteuid(2).
+*
+* Always succeeds.
+*/
+extern "C"
+int32_t GetEUid();
+
+/**
+* Gets and returns the effective group's identity.
+* Implemented as shim to getegid(2).
+*
+* Always succeeds.
+*/
+extern "C"
+int32_t GetEGid();

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

@@ -198,4 +198,7 @@
   <data name="PlatformNotSupported_GettingColor" xml:space="preserve">
     <value>This platform does not support getting the current color.</value>
   </data>
+  <data name="PersistedFiles_NoHomeDirectory" xml:space="preserve">
+    <value>The home directory of the current user could not be determined.</value>
+  </data>
 </root>

src/System.Console/src/System.Console.csproj

@@ -96,6 +96,12 @@
     <Compile Include="$(CommonPath)\Microsoft\Win32\SafeHandles\SafeFileHandle.Unix.cs">
       <Link>Common\Microsoft\Win32\SafeHandles\SafeFileHandle.Unix.cs</Link>
     </Compile>
+    <Compile Include="$(CommonPath)\System\IO\PersistedFiles.Unix.cs">
+      <Link>Common\System\IO\PersistedFiles.Unix.cs</Link>
+    </Compile>
+    <Compile Include="$(CommonPath)\System\IO\PersistedFiles.Names.Unix.cs">
+      <Link>Common\System\IO\PersistedFiles.Names.Unix.cs</Link>
+    </Compile>
     <Compile Include="$(CommonPath)\System\IO\StringBuilderCache.cs">
       <Link>Common\System\IO\StringBuilderCache.cs</Link>
     </Compile>
@@ -132,6 +138,12 @@
     <Compile Include="$(CommonPath)\Interop\Unix\libc\Interop.snprintf.cs">
       <Link>Common\Interop\Unix\Interop.snprintf.cs</Link>
     </Compile>
+    <Compile Include="$(CommonPath)\Interop\Unix\System.Native\Interop.GetEUid.cs">
+      <Link>Common\Interop\Unix\Interop.GetEUid.cs</Link>
+    </Compile>
+    <Compile Include="$(CommonPath)\Interop\Unix\System.Native\Interop.GetPwUid.cs">
+      <Link>Common\Interop\Unix\Interop.GetPwUid.cs</Link>
+    </Compile>
     <Compile Include="$(CommonPath)\Interop\Unix\System.Native\Interop.Stat.cs">
       <Link>Common\Interop\Unix\Interop.Stat.cs</Link>
     </Compile>

src/System.Console/src/System/ConsolePal.Unix.cs

@@ -490,7 +490,7 @@ private static Database ReadDatabase(string term)
                     }
 
                     // Then try in the user's home directory.
-                    string home = Environment.GetEnvironmentVariable("HOME");
+                    string home = PersistedFiles.GetHomeDirectory();
                     if (!string.IsNullOrWhiteSpace(home) && (db = ReadDatabase(term, home + "/.terminfo")) != null)
                     {
                         return db;