argv0: fix implementation of getting native argv[0]

Our previous implementation of getting the native argv[0] was flawed on
Linux and Mac. The Mac `_NSArgv` and Linux `/proc/self/cmdline`
function/proc-file return the raw argv[0] which may not be an absolute
or rooted path, but we expected this to be the same.

Additionally, the logic of appending the CWD to the argv[0] value when
the latter wasn't rooted was also just wrong!

Update to now use `_NSExecutablePath` on macOS, which always returns the
full absolute path, and add correct handling of unrooted argv[0] on
Linux.

Furthermore, on Linux, if we are unable to handle the value from
/proc/self/cmdline, we fall back to resolving the /proc/self/exe symlink
instead.

Author: mjcheetham

src/shared/Core/ApplicationBase.cs

@@ -84,7 +84,7 @@ public Task<int> RunAsync(string[] args)
 
         public static string GetEntryApplicationPath()
         {
-            return PlatformUtils.GetNativeArgv0() ??
+            return PlatformUtils.GetNativeEntryPath() ??
                    Process.GetCurrentProcess().MainModule?.FileName ??
                    Environment.GetCommandLineArgs()[0];
         }

src/shared/Core/Interop/MacOS/Native/LibC.cs

@@ -8,9 +8,6 @@ public static class LibC
         private const string LibCLib = "libc";
 
         [DllImport(LibCLib, CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
-        public static extern IntPtr _NSGetArgv();
-
-        [DllImport(LibCLib, CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
-        public static extern IntPtr _NSGetProgname();
+        public static extern int _NSGetExecutablePath(IntPtr buf, out int bufsize);
     }
 }

src/shared/Core/Interop/Posix/Native/Unistd.cs

@@ -1,5 +1,4 @@
 using System.Runtime.InteropServices;
-using System.Text;
 
 namespace GitCredentialManager.Interop.Posix.Native
 {

src/shared/Core/PlatformUtils.cs

@@ -176,52 +176,113 @@ public static bool IsElevatedUser()
             return false;
         }
 
-        #region Platform argv[0] Utils
+        #region Platform Entry Path Utils
 
-        public static string GetNativeArgv0()
+        /// <summary>
+        /// Get the native entry executable absolute path.
+        /// </summary>
+        /// <returns>Entry absolute path or null if there was an error.</returns>
+        public static string GetNativeEntryPath()
         {
             try
             {
                 if (IsWindows())
                 {
-                    return GetWindowsArgv0();
+                    return GetWindowsEntryPath();
                 }
 
                 if (IsMacOS())
                 {
-                    return GetMacOSArgv0();
+                    return GetMacOSEntryPath();
                 }
 
                 if (IsLinux())
                 {
-                    return GetLinuxArgv0();
+                    return GetLinuxEntryPath();
                 }
             }
             catch
             {
-                // If there are any issues getting the native argv[0]
+                // If there are any issues getting the native entry path
                 // we should not throw, and certainly not crash!
                 // Just return null instead.
             }
 
             return null;
         }
 
-        private static string GetLinuxArgv0()
+        private static string GetLinuxEntryPath()
         {
+            // Try to extract our native argv[0] from the original cmdline
             string cmdline = File.ReadAllText("/proc/self/cmdline");
-            return cmdline.Split('\0')[0];
+            string argv0 = cmdline.Split('\0')[0];
+
+            // argv[0] is an absolute file path
+            if (Path.IsPathRooted(argv0))
+            {
+                return argv0;
+            }
+
+            string path = Path.GetFullPath(
+                Path.Combine(Environment.CurrentDirectory, argv0)
+            );
+
+            // argv[0] is relative to current directory (./app) or a relative
+            // name resolved from the current directory (subdir/app).
+            // Note that we do NOT want to consider the case when it is just
+            // a simple filename (argv[0] == "app") because that would actually
+            // have been resolved from the $PATH instead (handled below)!
+            if ((argv0.StartsWith("./") || argv0.IndexOf('/') > 0) && File.Exists(path))
+            {
+                return path;
+            }
+
+            // argv[0] is a name that was resolved from the $PATH
+            string pathVar = Environment.GetEnvironmentVariable("PATH");
+            if (pathVar != null)
+            {
+                string[] paths = pathVar.Split(':');
+                foreach (string pathBase in paths)
+                {
+                    path = Path.Combine(pathBase, argv0);
+                    if (File.Exists(path))
+                    {
+                        return path;
+                    }
+                }
+            }
+
+#if NETFRAMEWORK
+            return null;
+#else
+            //
+            // We cannot determine the absolute file path from argv[0]
+            // (how we were launched), so let's now try to extract the
+            // fully resolved executable path from /proc/self/exe.
+            // Note that this means we may miss if we've been invoked
+            // via a symlink, but it's better than nothing at this point!
+            //
+            FileSystemInfo fsi = File.ResolveLinkTarget("/proc/self/exe", returnFinalTarget: false);
+            return fsi?.FullName;
+#endif
         }
 
-        private static string GetMacOSArgv0()
+        private static string GetMacOSEntryPath()
         {
-            IntPtr ptr = Interop.MacOS.Native.LibC._NSGetArgv();
-            IntPtr argvPtr = Marshal.ReadIntPtr(ptr);
-            IntPtr argv0Ptr = Marshal.ReadIntPtr(argvPtr);
-            return Marshal.PtrToStringAnsi(argv0Ptr);
+            // Determine buffer size by passing NULL initially
+            Interop.MacOS.Native.LibC._NSGetExecutablePath(IntPtr.Zero, out int size);
+
+            IntPtr bufPtr = Marshal.AllocHGlobal(size);
+            int result = Interop.MacOS.Native.LibC._NSGetExecutablePath(bufPtr, out size);
+
+            // buf is null-byte terminated
+            string name = result == 0 ? Marshal.PtrToStringAuto(bufPtr) : null;
+            Marshal.FreeHGlobal(bufPtr);
+
+            return name;
         }
 
-        private static string GetWindowsArgv0()
+        private static string GetWindowsEntryPath()
         {
             IntPtr argvPtr = Interop.Windows.Native.Shell32.CommandLineToArgvW(
                 Interop.Windows.Native.Kernel32.GetCommandLine(), out _);