Add support for static runtimes

Author: TheAssassin

src/binfmt-bypass/CMakeLists.txt

@@ -120,14 +120,14 @@ target_link_libraries(${bypass_lib} PUBLIC dl)
 # we need to include the preload lib headers (see below) from the binary dir
 target_include_directories(${bypass_lib} PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
 target_compile_options(${bypass_lib}
-    PRIVATE -DPRELOAD_LIB_PATH="${CMAKE_INSTALL_PREFIX}/${_private_libdir}/$<TARGET_FILE_NAME:${preload_lib}>"
+    PRIVATE -DPRELOAD_LIB_NAME="$<TARGET_FILE_NAME:${preload_lib}>"
     PUBLIC -D_GNU_SOURCE
     # obviously needs to be private, otherwise the value leaks into users of this lib
     PRIVATE -DCOMPONENT_NAME="lib"
 )
 if(build_32bit_preload_library)
     target_compile_options(${bypass_lib}
-        PRIVATE -DPRELOAD_LIB_PATH_32BIT="${CMAKE_INSTALL_PREFIX}/${_private_libdir}/$<TARGET_FILE_NAME:${preload_lib_32bit}>"
+        PRIVATE -DPRELOAD_LIB_NAME_32BIT="$<TARGET_FILE_NAME:${preload_lib_32bit}>"
     )
     target_sources(${bypass_lib} PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/${preload_lib_32bit}.h)
 endif()

src/binfmt-bypass/lib.cpp

@@ -9,14 +9,15 @@
 #include <memory>
 #include <stdexcept>
 #include <cassert>
+#include <filesystem>
 
 // own headers
 #include "elf.h"
 #include "logging.h"
 #include "lib.h"
 #include "binfmt-bypass-preload.h"
 
-#ifdef PRELOAD_LIB_PATH_32BIT
+#ifdef PRELOAD_LIB_NAME_32BIT
     #include "binfmt-bypass-preload_32bit.h"
 #endif
 
@@ -122,23 +123,28 @@ int create_shm_fd_with_patched_runtime(const char* const appimage_filename, cons
 
 #endif
 
-std::string find_preload_library(bool is_32bit) {
+std::filesystem::path find_preload_library(bool is_32bit) {
+    // packaging is now done using ld-p-native_packages which does not make guarantees about the install path
+    // therefore, we need to look up the path of the preload library in relation to the current binary's path
     // since we use the F (fix binary) binfmt mode nowadays to enable the use of the interpreter in different cgroups,
-    // namespaces or changeroots, we can no longer rely on the path to the interpreter to find the preload libs
-    // also, we compile in the absolute path to AppImageLauncher anyway
-    // therefore, we can just compile in the paths to the libs as well
-    // since we also compile in the contents of the preload libraries, this is merely just an optimization so we do not
-    // have to write and maintain the library files in the majority of all cases (that is, using AppImages regularly
-    // on some desktop or generally a host system)
-    // our workflow is: check whether the (right) preload lib exists on the system, otherwise return an empty string
-    // the creation of a library file needs to be handled by the caller then
-#ifdef PRELOAD_LIB_PATH_32BIT
+    // namespaces or changeroots, we may not find the library there, but we'll at least try
+
+    // we expect the library to be placed next to this binary
+    const auto own_binary_path = std::filesystem::read_symlink("/proc/self/exe");
+    log_error("proc self exe %s\n", own_binary_path.string().c_str());
+    const auto dir_path = own_binary_path.parent_path();
+
+    std::filesystem::path rv = dir_path;
+
+#ifdef PRELOAD_LIB_NAME_32BIT
     if (is_32bit) {
-        return PRELOAD_LIB_PATH_32BIT;
+        rv /= PRELOAD_LIB_NAME_32BIT;
+        return rv;
     }
 #endif
 
-    return PRELOAD_LIB_PATH;
+    rv /= PRELOAD_LIB_NAME;
+    return rv;
 }
 
 /**
@@ -174,7 +180,7 @@ class TemporaryPreloadLibFile {
 
 private:
     int _fd;
-    std::string _path;
+    std::filesystem::path _path;
 };
 
 // need to keep track of the subprocess pid in a global variable, as signal handlers in C(++) are simple interrupt
@@ -231,15 +237,15 @@ int bypassBinfmtAndRunAppImage(const std::string& appimage_path, const std::vect
         new_argv.push_back(nullptr);
 
         // preload our library
-        std::string preload_lib_path = find_preload_library(is_32bit_elf(appimage_path));
+        auto preload_lib_path = find_preload_library(is_32bit_elf(appimage_path));
 
         // may or may not be used, but must survive until this application terminates
         std::unique_ptr<TemporaryPreloadLibFile> temporaryPreloadLibFile;
 
-        if (access(preload_lib_path.c_str(), F_OK) != 0) {
+        if (!std::filesystem::exists(preload_lib_path)) {
             log_warning("could not find preload library path, creating new temporary file for it\n");
 
-#ifdef PRELOAD_LIB_PATH_32BIT
+#ifdef PRELOAD_LIB_NAME_32BIT
             if (is_32bit_elf(appimage_path)) {
                 temporaryPreloadLibFile = std::make_unique<TemporaryPreloadLibFile>(
                     libbinfmt_bypass_preload_32bit_so,
@@ -260,14 +266,16 @@ int bypassBinfmtAndRunAppImage(const std::string& appimage_path, const std::vect
             preload_lib_path = temporaryPreloadLibFile->path();
         }
 
-        log_debug("library to preload: %s\n", preload_lib_path.c_str());
+        log_debug("library to preload: %s\n", preload_lib_path.string().c_str());
 
         setenv("LD_PRELOAD", preload_lib_path.c_str(), true);
 
         // calculate absolute path to AppImage, for use in the preloaded lib
         char* abs_appimage_path = realpath(appimage_path.c_str(), nullptr);
         log_debug("absolute AppImage path: %s\n", abs_appimage_path);
+        // TARGET_APPIMAGE is further needed for static runtimes which do not make any use of LD_PRELOAD
         setenv("REDIRECT_APPIMAGE", abs_appimage_path, true);
+        setenv("TARGET_APPIMAGE", abs_appimage_path, true);
 
         // launch memfd directly, no path needed
         log_debug("fexecve(...)\n");

src/binfmt-bypass/preload.c

@@ -61,7 +61,7 @@ void __init() {
 char* __abs_appimage_path() {
     __init();
 
-    static const char env_var_name[] = "REDIRECT_APPIMAGE";
+    static const char env_var_name[] = "TARGET_APPIMAGE";
 
     char* appimage_var = getenv(env_var_name);