fix(launcher): resolve executable paths for app origin detection

#3975

Author: Ly-sec

src/system/desktop_entry.cpp

@@ -26,6 +26,36 @@ namespace {
 
   constexpr Logger kLog("desktop_entry");
 
+  fs::path resolveExecutable(std::string_view executable) {
+    const fs::path path(executable);
+    if (path.has_parent_path()) {
+      return path;
+    }
+
+    const char* pathEnv = std::getenv("PATH");
+    if (pathEnv == nullptr || pathEnv[0] == '\0') {
+      return {};
+    }
+
+    const std::string_view searchPath(pathEnv);
+    std::size_t start = 0;
+    while (start <= searchPath.size()) {
+      const std::size_t end = searchPath.find(':', start);
+      const std::string_view directory =
+          end == std::string_view::npos ? searchPath.substr(start) : searchPath.substr(start, end - start);
+      const fs::path candidate = directory.empty() ? path : fs::path(directory) / path;
+      std::error_code ec;
+      if (::access(candidate.c_str(), X_OK) == 0 && fs::is_regular_file(candidate, ec)) {
+        return candidate;
+      }
+      if (end == std::string_view::npos) {
+        break;
+      }
+      start = end + 1;
+    }
+    return {};
+  }
+
   bool executableIsAppImage(std::string_view exec) {
     const auto start = exec.find_first_not_of(' ');
     if (start == std::string_view::npos) {
@@ -44,7 +74,7 @@ namespace {
       return true;
     }
 
-    std::ifstream file(executable, std::ios::binary);
+    std::ifstream file(resolveExecutable(executable.string()), std::ios::binary);
     std::array<char, 10> header{};
     if (!file.read(header.data(), static_cast<std::streamsize>(header.size()))) {
       return false;

tests/app_identity_test.cpp

@@ -9,6 +9,7 @@
 #include <optional>
 #include <string>
 #include <string_view>
+#include <sys/stat.h>
 #include <unistd.h>
 #include <vector>
 
@@ -96,7 +97,11 @@ namespace {
     const fs::path root = fs::temp_directory_path() / ("noctalia-appimage-origin-" + std::to_string(getpid()));
     const fs::path applications = root / "data/applications";
     const fs::path executable = root / "PortableApp";
+    const fs::path bin = root / "bin";
+    const fs::path workingDirectory = root / "cwd";
     fs::create_directories(applications);
+    fs::create_directories(bin);
+    fs::create_directories(workingDirectory);
     {
       std::ofstream binary(executable, std::ios::binary);
       binary.write(
@@ -120,15 +125,36 @@ namespace {
       std::ofstream entry(applications / "suffix.desktop");
       entry << "[Desktop Entry]\nType=Application\nName=Suffixed AppImage\nExec=/opt/Suffixed.AppImage\n";
     }
+    {
+      std::ofstream binary(bin / "native-app");
+      binary << "#!/bin/sh\nexit 0\n";
+      chmod((bin / "native-app").c_str(), 0700);
+      fs::create_symlink(executable, bin / "path-appimage");
+      fs::create_symlink(executable, workingDirectory / "native-app");
+    }
+    {
+      std::ofstream entry(applications / "native.desktop");
+      entry << "[Desktop Entry]\nType=Application\nName=Native App\nExec=native-app\n";
+    }
+    {
+      std::ofstream entry(applications / "path.desktop");
+      entry << "[Desktop Entry]\nType=Application\nName=PATH AppImage\nExec=path-appimage\n";
+    }
 
     const char* oldDataHome = std::getenv("XDG_DATA_HOME");
     const char* oldDataDirs = std::getenv("XDG_DATA_DIRS");
+    const char* oldPath = std::getenv("PATH");
     const std::optional<std::string> savedDataHome =
         oldDataHome == nullptr ? std::nullopt : std::optional<std::string>(oldDataHome);
     const std::optional<std::string> savedDataDirs =
         oldDataDirs == nullptr ? std::nullopt : std::optional<std::string>(oldDataDirs);
+    const std::optional<std::string> savedPath =
+        oldPath == nullptr ? std::nullopt : std::optional<std::string>(oldPath);
+    const fs::path savedWorkingDirectory = fs::current_path();
     setenv("XDG_DATA_HOME", (root / "data").c_str(), 1);
     setenv("XDG_DATA_DIRS", (root / "empty").c_str(), 1);
+    setenv("PATH", bin.c_str(), 1);
+    fs::current_path(workingDirectory);
 
     const auto entries = scanDesktopEntries();
     const auto findOrigin = [&](std::string_view id) {
@@ -138,6 +164,10 @@ namespace {
     TEST_CHECK(findOrigin("metadata") == DesktopEntryOrigin::AppImage);
     TEST_CHECK(findOrigin("portable") == DesktopEntryOrigin::AppImage);
     TEST_CHECK(findOrigin("suffix") == DesktopEntryOrigin::AppImage);
+    TEST_CHECK(findOrigin("native") == DesktopEntryOrigin::System);
+    TEST_CHECK(findOrigin("path") == DesktopEntryOrigin::AppImage);
+
+    fs::current_path(savedWorkingDirectory);
 
     if (savedDataHome.has_value()) {
       setenv("XDG_DATA_HOME", savedDataHome->c_str(), 1);
@@ -149,6 +179,11 @@ namespace {
     } else {
       unsetenv("XDG_DATA_DIRS");
     }
+    if (savedPath.has_value()) {
+      setenv("PATH", savedPath->c_str(), 1);
+    } else {
+      unsetenv("PATH");
+    }
     fs::remove_all(root);
   }