Create a symlink instead of copying the file when deployFile is requested with source and target paths inside the AppDir

Deploy 32-bit and 64-bit libraries into separate directories

.travis.yml

@@ -25,12 +25,14 @@ matrix:
             - g++-multilib
             - automake  # required for patchelf
             - libfuse2:i386
+            - libcairo2:i386
 
 install:
-  - git clone https://github.com/NixOS/patchelf.git
+  - git clone https://github.com/NixOS/patchelf.git -b 0.8
   - cd patchelf
   - ./bootstrap.sh
-  - ./configure --prefix=/usr
+  - if [ "$ARCH" == "i386" ]; then ./configure --prefix=/usr --build=i686-pc-linux-gnu CFLAGS=-m32 CXXFLAGS=-m32 LDFLAGS=-m32; fi
+  - if [ "$ARCH" == "x86_64" ]; then ./configure --prefix=/usr; fi
   - make -j$(nproc)
   - sudo make install
   - cd ..
@@ -44,7 +46,7 @@ after_success:
   # make sure only pushes to rewrite create a new release, otherwise pretend PR and upload to transfer.sh
   - if [ "$TRAVIS_BRANCH" != "master" ]; then export TRAVIS_EVENT_TYPE=pull_request; fi
   - wget -c https://github.com/probonopd/uploadtool/raw/master/upload.sh
-  - bash upload.sh linuxdeploy*.AppImage*
+  - bash upload.sh linuxdeploy-"$ARCH".AppImage*
 
 branches:
   except:

CMakeLists.txt

@@ -5,9 +5,6 @@ project(linuxdeploy C CXX)
 set(CMAKE_CXX_STANDARD 11)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
-set(LINUXDEPLOY_VERSION 0.1-alpha-1)
-add_definitions(-DLINUXDEPLOY_VERSION="${LINUXDEPLOY_VERSION}")
-
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${PROJECT_SOURCE_DIR}/cmake/Modules/")
 
 set(USE_SYSTEM_BOOST OFF CACHE BOOL "Set to ON to use system boost libraries instead of building up to date boost libraries from source")

README.md

@@ -2,6 +2,7 @@
 
 AppDir creation and maintenance tool.
 
+
 ## About
 
 AppImages are a well known and quite popular format for distributing applications from developers to end users.
@@ -58,12 +59,12 @@ If your build system cannot produce such install trees or you prefer to bundle e
 An example run could look like this:
 
 ```bash
-./linuxdeploy*.AppImage --app-name myapp --appdir AppDir --init-appdir -e myapp -d myapp.desktop -i myapp_64x64.png
+./linuxdeploy*.AppImage --appdir AppDir -e myapp -d myapp.desktop -i myapp_64x64.png
 ```
 
 Of course both approaches can be combined, e.g., you can bundle additional executables with your main app.
 
-linuxdeploy doesn't mind being run on an AppDir more than once, as it recognize previous runs, and should not break files within the AppDir. This is to allow you debug issues allows you to run linuxdeploy after resolving an issue that it reports.
+linuxdeploy doesn't mind being run on an AppDir more than once, as it recognize previous runs, and should not break files within the AppDir. This is called an "iterative workflow". In case of errors, you can simply fix them, and re-run linuxdeploy afterwards.
 If you ever encounter issues when running linuxdeploy on an existing AppDir, please let us know by [creating an issue](https://github.com/TheAssassin/linuxdeploy/issues/new).
 
 
@@ -81,10 +82,17 @@ linuxdeploy looks for plugins in the following places:
 
 You can use `./linuxdeploy*.AppImage --list-plugins` to get a list of all the plugins linuxdeploy has detected on your system.
 
-linuxdeploy ships with some plugins
+linuxdeploy currently ships with some plugins. These are likely out of date. In case of issues, please download the latest version, which will take precendence over the bundled plugin.
 
 If you want to use a plugin to bundle additional resources, please add `./linuxdeploy*.AppImage --plugin <name>` to your linuxdeploy command. Output plugins can be activated using `./linuxdeploy*.AppImage --output <name>`.
 
+**Note:** If you want to suggest a plugin for a specific framework, language etc., please feel free to [create a new issue](https://github.com/linuxdeploy/linuxdeploy/issues/new). Current plugin requests can be found [here](https://github.com/linuxdeploy/linuxdeploy/issues?utf8=%E2%9C%93&q=label%3A%22plugin+request%22).
+
+
+## User guides and examples
+
+Please see the [linuxdeploy user guide](https://docs.appimage.org/packaging-guide/linuxdeploy-user-guide.html) and the [native binaries packaging guide](https://docs.appimage.org/packaging-guide/native-binaries.html) in the [AppImage documentation](https://docs.appimage.org). There's also an [examples section](https://docs.appimage.org/packaging-guide/native-binaries.html#Examples).
+
 
 ## Troubleshooting
 
@@ -92,6 +100,7 @@ If you want to use a plugin to bundle additional resources, please add `./linuxd
 
 linuxdeploy does not change any environment variables such as `$PATH`. Your application **must** search for additional resources such as icon files or executables relative to the main binary.
 
+
 ## Contact
 
 The easiest way to get in touch with the developers is to join the IRC chatroom [#AppImage](https://webchat.freenode.net/?channels=appimage) on FreeNode. This is the preferred way for general feedback or questions how to use this application.

cmake/Modules/FindLibMagic.cmake

@@ -1,27 +0,0 @@
-# required for zlib imported target
-cmake_minimum_required(VERSION 3.3)
-
-message(STATUS "Searching for libmagic")
-
-find_library(LIBMAGIC_A libmagic.a)
-
-if(NOT LIBMAGIC_A)
-    message(FATAL_ERROR "libmagic.a not found")
-endif()
-
-find_path(LIBMAGIC_MAGIC_H_DIR
-    NAMES magic.h
-    HINTS ${CMAKE_INSTALL_PREFIX}
-    PATH_SUFFIXES include include/linux
-)
-
-if(NOT LIBMAGIC_MAGIC_H_DIR)
-    message(FATAL_ERROR "magic.h not found")
-endif()
-
-# on Debian-ish systems, libmagic depends on zlib
-find_package(ZLIB REQUIRED)
-
-add_library(libmagic_static INTERFACE IMPORTED)
-set_property(TARGET libmagic_static PROPERTY INTERFACE_INCLUDE_DIRECTORIES ${LIBMAGIC_MAGIC_H_DIR})
-set_property(TARGET libmagic_static PROPERTY INTERFACE_LINK_LIBRARIES ${LIBMAGIC_A};ZLIB::ZLIB)

include/linuxdeploy/core/appdir.h

@@ -42,6 +42,13 @@ namespace linuxdeploy {
                     // the dependencies are copied to the normal destination, though
                     bool deployLibrary(const boost::filesystem::path& path, const boost::filesystem::path& destination = "");
 
+                    // force deploy shared library
+                    //
+                    // works like deployLibrary, except that it doesn't check the excludelist
+                    // this is useful to deploy libraries and their dependencies that are blacklisted and would otherwise not be deployed
+                    // the excludelist check is only disabled for the current library, and will be enabled for the dependencies again
+                    bool forceDeployLibrary(const boost::filesystem::path& path, const boost::filesystem::path& destination = "");
+
                     // deploy executable
                     bool deployExecutable(const boost::filesystem::path& path, const boost::filesystem::path& destination = "");
 
@@ -72,12 +79,6 @@ namespace linuxdeploy {
                     // create symlinks for AppRun, desktop file and icon in the AppDir root directory
                     bool createLinksInAppDirRoot(const desktopfile::DesktopFile& desktopFile, boost::filesystem::path customAppRunPath = "");
 
-                    // set application name of primary "entry point" application
-                    // icons and other resources will then automatically be renamed using this value in order to
-                    // make the deployment easier by not requiring special filenames
-                    // resources' filenames should be prefixed with this value (example: linuxdeploy_48x48.png)
-                    void setAppName(const std::string& appName);
-
                     // list all executables in <AppDir>/usr/bin
                     // this function does not perform a recursive search, but only searches the bin directory
                     std::vector<boost::filesystem::path> listExecutables();

include/linuxdeploy/core/elf.h

@@ -1,6 +1,8 @@
 // system includes
 #include <vector>
 #include <string>
+// including system elf header, which allows for interpretation of the return values of the methods
+#include <elf.h>
 
 // library includes
 #include <boost/filesystem.hpp>
@@ -16,6 +18,12 @@ namespace linuxdeploy {
                     explicit ElfFileParseError(const std::string& msg) : std::runtime_error(msg) {}
             };
 
+            // thrown by traceDynamicDependencies() if a dependency is missing
+            class DependencyNotFoundError : public std::runtime_error {
+                public:
+                    explicit DependencyNotFoundError(const std::string& msg) : std::runtime_error(msg) {}
+            };
+
             class ElfFile {
                 private:
                     class PrivateData;
@@ -25,6 +33,16 @@ namespace linuxdeploy {
                     explicit ElfFile(const boost::filesystem::path& path);
                     ~ElfFile();
 
+                public:
+                    // return system ELF OS ABI
+                    static uint8_t getSystemElfABI();
+
+                    // return system ELF class (32-bit or 64-bit)
+                    static uint8_t getSystemElfClass();
+
+                    // return system (ELF) endianness
+                    static uint8_t getSystemElfEndianness();
+
                 public:
                     // recursively trace dynamic library dependencies of a given ELF file
                     // this works for both libraries and executables
@@ -40,6 +58,12 @@ namespace linuxdeploy {
                     // set rpath in ELF file
                     // returns true on success, false otherwise
                     bool setRPath(const std::string& value);
+
+                    // return ELF class
+                    uint8_t getElfClass();
+
+                    // return OS ABI
+                    uint8_t getElfABI();
             };
         }
     }

include/linuxdeploy/plugin/base_impl.h

@@ -2,6 +2,7 @@
 #include <set>
 #include <string>
 #include <vector>
+#include <poll.h>
 
 // library headers
 #include <boost/filesystem.hpp>
@@ -18,10 +19,13 @@
 namespace linuxdeploy {
     namespace plugin {
         namespace base {
+            using namespace linuxdeploy::core::log;
+
             template<int API_LEVEL>
             class PluginBase<API_LEVEL>::PrivateData {
                 public:
                     const boost::filesystem::path pluginPath;
+                    std::string name;
                     int apiLevel;
                     PLUGIN_TYPE pluginType;
 
@@ -33,6 +37,10 @@ namespace linuxdeploy {
 
                         apiLevel = getApiLevelFromExecutable();
                         pluginType = getPluginTypeFromExecutable();
+
+                        boost::cmatch res;
+                        boost::regex_match(path.filename().c_str(), res, PLUGIN_EXPR);
+                        name = res[1].str();
                     };
 
                 private:
@@ -121,17 +129,87 @@ namespace linuxdeploy {
                 auto pluginPath = path();
                 auto args = {pluginPath.c_str(), "--appdir", appDirPath.string().c_str()};
 
-                auto log = linuxdeploy::core::log::ldLog();
+                auto log = ldLog();
                 log << "Running process:";
                 for (const auto& arg : args) {
                     log << "" << arg;
                 }
                 log << std::endl;
 
-                auto process = subprocess::Popen(args);
+                auto process = subprocess::Popen(args, subprocess::output{subprocess::PIPE}, subprocess::error{subprocess::PIPE});
 
-                auto retcode = process.wait();
-                return retcode;
+
+                std::vector<pollfd> pfds(2);
+                auto* opfd = &pfds[0];
+                auto* epfd = &pfds[1];
+
+                opfd->fd = fileno(process.output());
+                opfd->events = POLLIN;
+
+                epfd->fd = fileno(process.error());
+                epfd->events = POLLIN;
+
+                for (const auto& fd : {process.output(), process.error()}) {
+                    auto flags = fcntl(fileno(fd), F_GETFL, 0);
+                    flags |= O_NONBLOCK;
+                    fcntl(fileno(fd), F_SETFL, flags);
+                }
+
+                auto printOutput = [&pfds, opfd, epfd, this, &process]() {
+                    poll(pfds.data(), pfds.size(), -1);
+
+                    if (opfd->revents & POLLIN) {
+                        std::vector<char> lineBuf(16384);
+                        fgets(lineBuf.data(), static_cast<int>(lineBuf.size()), process.output());
+
+                        std::stringstream ss;
+                        ss << lineBuf.data();
+                        lineBuf.clear();
+
+                        std::string currentLine;
+
+                        std::ostringstream oss;
+                        while (std::getline(ss, currentLine)) {
+                            oss << "[" << d->name << "/stdout] " << currentLine << std::endl;
+                        }
+                        linuxdeploy::core::log::ldLog() << oss.str();
+                    }
+
+                    if (epfd->revents & POLLIN) {
+                        std::vector<char> lineBuf(16384);
+                        fgets(lineBuf.data(), static_cast<int>(lineBuf.size()), process.error());
+
+                        std::stringstream ss;
+                        ss << lineBuf.data();
+                        lineBuf.clear();
+
+                        std::string currentLine;
+
+                        std::ostringstream oss;
+                        while (std::getline(ss, currentLine)) {
+                            oss << "[" << d->name << "/stderr] " << currentLine << std::endl;
+                        }
+                        linuxdeploy::core::log::ldLog() << oss.str();
+                    }
+
+                    return true;
+                };
+
+                do {
+                    if (!printOutput()) {
+                        ldLog() << LD_ERROR << "Failed to communicate with process" << std::endl;
+                        process.kill();
+                        return -1;
+                    }
+                } while (process.poll() < 0);
+
+                if (!printOutput()) {
+                    ldLog() << LD_ERROR << "Failed to communicate with process" << std::endl;
+                    process.kill();
+                    return -1;
+                }
+
+                return process.retcode();
             }
         }
     }

include/linuxdeploy/plugin/plugin.h

@@ -4,6 +4,7 @@
 
 // library includes
 #include <boost/filesystem.hpp>
+#include <boost/regex.hpp>
 
 // local includes
 #include "linuxdeploy/core/log.h"
@@ -18,6 +19,11 @@ namespace linuxdeploy {
             OUTPUT_TYPE,
         };
 
+        /*
+         * Official regular expression to check filenames for plugins
+         */
+        static const boost::regex PLUGIN_EXPR(R"(^linuxdeploy-plugin-([^\s\.-]+)(?:-[^\.]+)?(?:\..+)?$)");
+
         /*
          * Plugin interface.
          */

include/linuxdeploy/util/misc.h

@@ -6,10 +6,33 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <boost/filesystem.hpp>
 
 namespace linuxdeploy {
     namespace util {
         namespace misc {
+            static bool path_contains_file(boost::filesystem::path dir, boost::filesystem::path file) {
+                // If dir ends with "/" and isn't the root directory, then the final
+                // component returned by iterators will include "." and will interfere
+                // with the std::equal check below, so we strip it before proceeding.
+                if (dir.filename() == ".")
+                    dir.remove_filename();
+                // We're also not interested in the file's name.
+                assert(file.has_filename());
+                file.remove_filename();
+
+                // If dir has more components than file, then file can't possibly
+                // reside in dir.
+                auto dir_len = std::distance(dir.begin(), dir.end());
+                auto file_len = std::distance(file.begin(), file.end());
+                if (dir_len > file_len)
+                    return false;
+
+                // This stops checking when it reaches dir.end(), so it's OK if file
+                // has more directory components afterward. They won't be checked.
+                return std::equal(dir.begin(), dir.end(), file.begin());
+            };
+
             static inline bool ltrim(std::string& s, char to_trim = ' ') {
                 // TODO: find more efficient way to check whether elements have been removed
                 size_t initialLength = s.length();
@@ -64,6 +87,14 @@ namespace linuxdeploy {
                 return strncmp(string.c_str(), prefix.c_str(), prefix.size()) == 0;
             }
 
+            static bool stringEndsWith(const std::string& string, const std::string& suffix) {
+                // sanity check
+                if (string.size() < suffix.size())
+                    return false;
+
+                return strcmp(string.c_str() + (string.size() - suffix.size()), suffix.c_str()) == 0;
+            }
+
             static bool stringContains(const std::string& string, const std::string& part) {
                 return string.find(part) != std::string::npos;
             }

include/linuxdeploy/util/util.h

@@ -1,5 +1,4 @@
 // local includes
-#include "magicwrapper.h"
 #include "misc.h"
 
 // import functions from misc module for convenience

lib/CMakeLists.txt

@@ -1,6 +1,7 @@
 add_library(subprocess INTERFACE)
 target_sources(subprocess INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/cpp-subprocess/subprocess.hpp)
 target_include_directories(subprocess INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/cpp-subprocess)
+target_compile_options(subprocess INTERFACE "-Wno-deprecated")
 
 add_library(args INTERFACE)
 target_sources(args INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/args/args.hxx)

src/CMakeLists.txt

@@ -1,3 +1,6 @@
+# 3.5 is required for imported boost targets
+cmake_minimum_required(VERSION 3.5)
+
 # globally include own includes
 include_directories(${PROJECT_SOURCE_DIR}/include)
 
@@ -10,6 +13,34 @@ else()
     set(BOOST_LIBS boost_system boost_filesystem boost_regex)
 endif()
 
+
+
+# read Git revision ID
+# WARNING: this value will be stored in the CMake cache
+# to update it, you will have to reset the CMake cache
+# (doesn't matter for CI builds like Travis for instance, where there's no permanent CMake cache)
+execute_process(
+    COMMAND git rev-parse --short HEAD
+    WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
+    OUTPUT_VARIABLE GIT_COMMIT
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+)
+
+# set version and build number
+set(VERSION 1-alpha)
+if("$ENV{TRAVIS_BUILD_NUMBER}" STREQUAL "")
+    set(BUILD_NUMBER "<local dev build>")
+else()
+    set(BUILD_NUMBER "Travis build $ENV{TRAVIS_BUILD_NUMBER}")
+endif()
+
+# get current date
+execute_process(
+    COMMAND env LC_ALL=C date -u "+%Y-%m-%d %H:%M:%S %Z"
+    OUTPUT_VARIABLE DATE
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+)
+
 add_subdirectory(util)
 add_subdirectory(plugin)
 add_subdirectory(core)
@@ -18,6 +49,11 @@ add_executable(linuxdeploy main.cpp)
 target_link_libraries(linuxdeploy linuxdeploy_core args)
 set_target_properties(linuxdeploy PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/bin")
 
+target_compile_definitions(linuxdeploy PRIVATE -DLD_GIT_COMMIT="${GIT_COMMIT}")
+target_compile_definitions(linuxdeploy PRIVATE -DLD_VERSION="${VERSION}")
+target_compile_definitions(linuxdeploy PRIVATE -DLD_BUILD_NUMBER="${BUILD_NUMBER}")
+target_compile_definitions(linuxdeploy PRIVATE -DLD_BUILD_DATE="${DATE}")
+
 add_executable(plugin_test plugin_test_main.cpp)
 target_link_libraries(plugin_test linuxdeploy_plugin)
 set_target_properties(plugin_test PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/bin")

src/core/CMakeLists.txt

@@ -1,14 +1,10 @@
-# 3.5 is required for imported boost targets
-# 3.6 is required for the PkgConfig module's IMPORTED_TARGET library feature
-cmake_minimum_required(VERSION 3.6)
+cmake_minimum_required(VERSION 2.8)
 
 # include headers to make CLion happy
 file(GLOB HEADERS ${PROJECT_SOURCE_DIR}/include/linuxdeploy/core/*.h)
 
 find_package(Threads)
 
-find_package(LibMagic REQUIRED)
-
 find_package(CImg REQUIRED)
 
 message(STATUS "Generating excludelist")
@@ -17,8 +13,12 @@ execute_process(
     WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
 )
 
-add_library(linuxdeploy_core STATIC elf.cpp log.cpp  appdir.cpp desktopfile.cpp ${HEADERS})
-target_link_libraries(linuxdeploy_core PUBLIC linuxdeploy_plugin linuxdeploy_util ${BOOST_LIBS} subprocess cpp-feather-ini-parser CImg libmagic_static ${CMAKE_THREAD_LIBS_INIT})
+add_library(linuxdeploy_core_copyright STATIC copyright.cpp copyright.h copyright_dpkgquery.cpp copyright_dpkgquery.h)
+target_link_libraries(linuxdeploy_core_copyright PUBLIC subprocess ${BOOST_LIBS})
+
+add_library(linuxdeploy_core STATIC elf.cpp log.cpp appdir.cpp desktopfile.cpp ${HEADERS})
+target_link_libraries(linuxdeploy_core PUBLIC linuxdeploy_plugin linuxdeploy_util ${BOOST_LIBS} subprocess cpp-feather-ini-parser CImg ${CMAKE_THREAD_LIBS_INIT})
+target_link_libraries(linuxdeploy_core PRIVATE linuxdeploy_core_copyright)
 target_include_directories(linuxdeploy_core PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
 target_include_directories(linuxdeploy_core PUBLIC ${PROJECT_SOURCE_DIR}/include)
 target_compile_definitions(linuxdeploy_core PUBLIC -DBOOST_NO_CXX11_SCOPED_ENUMS)

src/core/appdir.cpp

@@ -13,10 +13,14 @@
 #include "linuxdeploy/core/appdir.h"
 #include "linuxdeploy/core/elf.h"
 #include "linuxdeploy/core/log.h"
-#include "util.h"
+#include "linuxdeploy/util/util.h"
+#include "copyright.h"
+
+// auto-generated headers
 #include "excludelist.h"
 
 using namespace linuxdeploy::core;
+using namespace linuxdeploy::util::misc;
 using namespace linuxdeploy::core::log;
 
 using namespace cimg_library;
@@ -44,10 +48,31 @@ namespace linuxdeploy {
                     // used to automatically rename resources to improve the UX, e.g. icons
                     std::string appName;
 
-                public:
-                    PrivateData() : copyOperations(), stripOperations(), setElfRPathOperations(), visitedFiles(), appDirPath(), appName() {};
+                    std::shared_ptr<copyright::ICopyrightFilesManager> copyrightFilesManager;
 
                 public:
+                    PrivateData() : copyOperations(), stripOperations(), setElfRPathOperations(), visitedFiles(), appDirPath(), appName() {
+                        copyrightFilesManager = copyright::ICopyrightFilesManager::getInstance();
+                    };
+
+                public:
+                    // calculate library directory name for given ELF file, taking system architecture into account
+                    static std::string getLibraryDirName(const bf::path& path) {
+                        const auto systemElfClass = elf::ElfFile::getSystemElfClass();
+                        const auto elfClass = elf::ElfFile(path).getElfClass();
+
+                        std::string libDirName = "lib";
+
+                        if (systemElfClass != elfClass) {
+                            if (elfClass == ELFCLASS32)
+                                libDirName += "32";
+                            else
+                                libDirName += "64";
+                        }
+
+                         return libDirName;
+                    }
+
                     // actually copy file
                     // mimics cp command behavior
                     bool copyFile(const bf::path& from, bf::path to, bool overwrite = false) {
@@ -135,8 +160,10 @@ namespace linuxdeploy {
                             const auto& from = pair.first;
                             const auto& to = pair.second;
 
-                            if (!copyFile(from, to))
-                                success = false;
+                            if (path_contains_file(appDirPath, from)) {
+                                success = bf::exists(to) || symlinkFile(from, to, true); // create a symbolic link
+                            } else
+                                success = copyFile(from, to); // copy the file
 
                             copyOperations.erase(copyOperations.begin());
                         }
@@ -144,34 +171,42 @@ namespace linuxdeploy {
                         if (!success)
                             return false;
 
-                        while (!stripOperations.empty()) {
-                            const auto& filePath = *(stripOperations.begin());
+                        if (getenv("NO_STRIP") != nullptr) {
+                            ldLog() << LD_WARNING << "$NO_STRIP environment variable detected, not stripping binaries" << std::endl;
+                            stripOperations.clear();
+                        } else {
+                            const auto stripPath = getStripPath();
 
-                            if (util::stringStartsWith(elf::ElfFile(filePath).getRPath(), "$")) {
-                                ldLog() << LD_WARNING << "Not calling strip on binary" << filePath << LD_NO_SPACE << ": rpath starts with $" << std::endl;
-                            } else {
-                                ldLog() << "Calling strip on library" << filePath << std::endl;
+                            while (!stripOperations.empty()) {
+                                const auto& filePath = *(stripOperations.begin());
 
-                                std::map<std::string, std::string> env;
-                                env.insert(std::make_pair(std::string("LC_ALL"), std::string("C")));
+                                if (util::stringStartsWith(elf::ElfFile(filePath).getRPath(), "$")) {
+                                    ldLog() << LD_WARNING << "Not calling strip on binary" << filePath << LD_NO_SPACE
+                                            << ": rpath starts with $" << std::endl;
+                                } else {
+                                    ldLog() << "Calling strip on library" << filePath << std::endl;
 
-                                subprocess::Popen proc(
-                                    {getStripPath().c_str(), filePath.c_str()},
-                                    subprocess::output(subprocess::PIPE),
-                                    subprocess::error(subprocess::PIPE),
-                                    subprocess::environment(env)
-                                );
+                                    std::map<std::string, std::string> env;
+                                    env.insert(std::make_pair(std::string("LC_ALL"), std::string("C")));
 
-                                std::string err = proc.communicate().second.buf.data();
+                                    subprocess::Popen proc(
+                                        {stripPath.c_str(), filePath.c_str()},
+                                        subprocess::output(subprocess::PIPE),
+                                        subprocess::error(subprocess::PIPE),
+                                        subprocess::environment(env)
+                                    );
 
-                                if (proc.retcode() != 0 &&
-                                    !util::stringContains(err, "Not enough room for program headers")) {
-                                    ldLog() << LD_ERROR << "Strip call failed:" << err << std::endl;
-                                    success = false;
+                                    std::string err = proc.communicate().second.buf.data();
+
+                                    if (proc.retcode() != 0 &&
+                                        !util::stringContains(err, "Not enough room for program headers")) {
+                                        ldLog() << LD_ERROR << "Strip call failed:" << err << std::endl;
+                                        success = false;
+                                    }
                                 }
-                            }
 
-                            stripOperations.erase(stripOperations.begin());
+                                stripOperations.erase(stripOperations.begin());
+                            }
                         }
 
                         if (!success)
@@ -194,72 +229,14 @@ namespace linuxdeploy {
                         return true;
                     }
 
-                    // search for copyright file related to given file
-                    // this function utilizes distribution tools like dpkg-query to determine the paths of copyright
-                    // files
-                    std::vector<bf::path> searchForCopyrightFiles(const bf::path& from) {
-                        auto check_command = [](const std::string& command) {
-                            auto p = subprocess::Popen(
-                                command,
-                                subprocess::output(subprocess::PIPE),
-                                subprocess::error(subprocess::PIPE)
-                            );
-
-                            return p.wait();
-                        };
-
-                        // cannot deploy copyright files for files in AppDir
-                        if (!util::stringStartsWith(bf::absolute(from).string(), bf::absolute(appDirPath).string())) {
-                            if (check_command("which dpkg-query") == 0) {
-                                ldLog() << LD_DEBUG << "Using dpkg-query to search for copyright files" << std::endl;
-
-                                auto call = [](const std::initializer_list<const char*>& args) {
-                                    auto proc = subprocess::Popen(
-                                        args,
-                                        subprocess::output(subprocess::PIPE),
-                                        subprocess::error(subprocess::PIPE)
-                                    );
-
-                                    auto output = proc.communicate();
-                                    return std::make_pair(proc.retcode(), output.first);
-                                };
-
-                                auto dpkgQueryPackages = call({"dpkg-query", "-S", from.c_str()});
-
-                                if (dpkgQueryPackages.first != 0
-                                    || dpkgQueryPackages.second.buf.empty()
-                                    || dpkgQueryPackages.second.buf.front() == '\0') {
-                                    ldLog() << LD_WARNING << "Could not find copyright files for file" << from << "using dpkg-query" << std::endl;
-                                    return {};
-                                }
-
-                                auto packageName = util::split(util::splitLines(dpkgQueryPackages.second.buf.data())[0], ':')[0];
-
-                                if (!packageName.empty()) {
-
-                                    auto copyrightFilePath = bf::path("/usr/share/doc") / packageName / "copyright";
-
-                                    if (bf::is_regular_file(copyrightFilePath)) {
-                                        return {copyrightFilePath};
-                                    }
-                                } else {
-                                    ldLog() << LD_WARNING << "Could not find copyright files for file" << from << "using dpkg-query" << std::endl;
-                                }
-                            }
-                        } else {
-                            ldLog() << LD_DEBUG << "Cannot deploy copyright files for files in AppDir:" << from << std::endl;
-                        }
-
-                        ldLog() << LD_DEBUG << "Could not find suitable tool for copyright files deployment, skipping" << from << std::endl;
-
-                        return {};
-                    }
-
                     // search for copyright file for file and deploy it to AppDir
                     bool deployCopyrightFiles(const bf::path& from, const std::string& logPrefix = "") {
                         ldLog() << logPrefix << LD_NO_SPACE << "Deploying copyright files for file" << from << std::endl;
 
-                        auto copyrightFiles = searchForCopyrightFiles(from);
+                        if (copyrightFilesManager == nullptr)
+                            return false;
+
+                        auto copyrightFiles = copyrightFilesManager->getCopyrightFilesForPath(from);
 
                         if (copyrightFiles.empty())
                             return false;
@@ -302,39 +279,44 @@ namespace linuxdeploy {
                         auto logPrefix = getLogPrefix(recursionLevel);
 
                         ldLog() << logPrefix << LD_NO_SPACE << "Deploying dependencies for ELF file" << path << std::endl;
-                        
-                        for (const auto& dependencyPath : elf::ElfFile(path).traceDynamicDependencies()) {
-                            if (!deployLibrary(dependencyPath, recursionLevel + 1))
-                                return false;
+                        try {
+                            for (const auto &dependencyPath : elf::ElfFile(path).traceDynamicDependencies()) {
+                                if (!deployLibrary(dependencyPath, recursionLevel + 1))
+                                    return false;
+                            }
+                        } catch (const elf::DependencyNotFoundError& e) {
+                            ldLog() << LD_ERROR << e.what() << std::endl;
+                            return false;
                         }
-                        
+
                         return true;
                     }
 
                     static std::string getStripPath() {
-                        // by default, try to use a patchelf next to the linuxdeploy binary
-                        // if that isn't available, fall back to searching for patchelf in the PATH
-                        std::string patchelfPath = "strip";
+                        // by default, try to use a strip next to the linuxdeploy binary
+                        // if that isn't available, fall back to searching for strip in the PATH
+                        std::string stripPath = "strip";
 
-                        auto binDirPath = bf::path(util::getOwnExecutablePath());
-                        auto localStripPath = binDirPath.parent_path() / "strip";
+                        auto binDirPath = bf::path(util::getOwnExecutablePath()).parent_path();
+                        auto localStripPath = binDirPath / "strip";
 
                         if (bf::exists(localStripPath))
-                            patchelfPath = localStripPath.string();
+                            stripPath = localStripPath.string();
 
-                        ldLog() << LD_DEBUG << "Using strip:" << patchelfPath << std::endl;
+                        ldLog() << LD_DEBUG << "Using strip:" << stripPath << std::endl;
 
-                        return patchelfPath;
+                        return stripPath;
                     }
 
-                    bool deployLibrary(const bf::path& path, int recursionLevel = 0, const bf::path& destination = "") {
+                    bool deployLibrary(const bf::path& path, int recursionLevel = 0, bool forceDeploy = false,const bf::path &destination = bf::path()) {
                         auto logPrefix = getLogPrefix(recursionLevel);
 
-                        if (hasBeenVisitedAlready(path)) {
+                        if (!forceDeploy && hasBeenVisitedAlready(path)) {
                             ldLog() << LD_DEBUG << logPrefix << LD_NO_SPACE << "File has been visited already:" << path << std::endl;
                             return true;
                         }
 
+
                         static auto isInExcludelist = [&logPrefix](const bf::path& fileName) {
                             for (const auto& excludePattern : generatedExcludelist) {
                                 // simple string match is faster than using fnmatch
@@ -356,7 +338,7 @@ namespace linuxdeploy {
                             return false;
                         };
 
-                        if (isInExcludelist(path.filename())) {
+                        if (!forceDeploy && isInExcludelist(path.filename())) {
                             ldLog() << logPrefix << LD_NO_SPACE << "Skipping deployment of blacklisted library" << path << std::endl;
 
                             // mark file as visited
@@ -365,12 +347,21 @@ namespace linuxdeploy {
                             return true;
                         }
 
+                        // note for self: make sure to have a trailing slash in libraryDir, otherwise copyFile won't
+                        // create a directory
+                        bf::path libraryDir = appDirPath / "usr" / (getLibraryDirName(path) + "/");
+
                         ldLog() << logPrefix << LD_NO_SPACE << "Deploying shared library" << path;
                         if (!destination.empty())
                             ldLog() << " (destination:" << destination << LD_NO_SPACE << ")";
                         ldLog() << std::endl;
 
-                        auto destinationPath = destination.empty() ? appDirPath / "usr/lib/" : destination;
+                        auto destinationPath = destination.empty() ? libraryDir : destination;
+
+                        // not sure whether this is 100% bullet proof, but it simulates the cp command behavior
+                        if (destinationPath.string().back() == '/' || bf::is_directory(destinationPath)) {
+                            destinationPath /= path.filename();
+                        }
 
                         deployFile(path, destinationPath);
                         deployCopyrightFiles(path, logPrefix);
@@ -389,12 +380,13 @@ namespace linuxdeploy {
                                 rpathDestination = destination.parent_path().string();
                             }
 
-                            auto relPath = bf::relative(bf::absolute(appDirPath) / "usr/lib", bf::absolute(rpathDestination));
+                            auto relPath = bf::relative(bf::absolute(libraryDir), bf::absolute(rpathDestination));
                             rpath = "$ORIGIN/" + relPath.string() + ":$ORIGIN";
                         }
 
-                        setElfRPathOperations[destinationPath / path.filename()] = rpath;
-                        stripOperations.insert(destinationPath / path.filename());
+
+                        setElfRPathOperations[destinationPath] = rpath;
+                        stripOperations.insert(destinationPath);
 
                         if (!deployElfDependencies(path, recursionLevel))
                             return false;
@@ -417,7 +409,7 @@ namespace linuxdeploy {
                         deployFile(path, destinationPath);
                         deployCopyrightFiles(path);
 
-                        std::string rpath = "$ORIGIN/../lib";
+                        std::string rpath = "$ORIGIN/../" + getLibraryDirName(path);
 
                         if (!destination.empty()) {
                             std::string rpathDestination = destination.string();
@@ -431,7 +423,7 @@ namespace linuxdeploy {
                                 rpathDestination = destination.parent_path().string();
                             }
 
-                            auto relPath = bf::relative(bf::absolute(appDirPath) / "usr/lib", bf::absolute(rpathDestination));
+                            auto relPath = bf::relative(bf::absolute(appDirPath) / "usr" / getLibraryDirName(path), bf::absolute(rpathDestination));
                             rpath = "$ORIGIN/" + relPath.string();
                         }
 
@@ -578,7 +570,11 @@ namespace linuxdeploy {
             }
 
             bool AppDir::deployLibrary(const bf::path& path, const bf::path& destination) {
-                return d->deployLibrary(path, 0, destination);
+                return d->deployLibrary(path, 0, false, destination);
+            }
+
+            bool AppDir::forceDeployLibrary(const bf::path& path, const bf::path& destination) {
+                return d->deployLibrary(path, 0, true, destination);
             }
 
             bool AppDir::deployExecutable(const bf::path& path, const boost::filesystem::path& destination) {
@@ -683,7 +679,13 @@ namespace linuxdeploy {
                 for (const auto& iconPath : foundIconPaths) {
                     ldLog() << LD_DEBUG << "Icon found:" << iconPath << std::endl;
 
-                    if (iconPath.stem() == iconName) {
+                    const bool matchesFilenameWithExtension = iconPath.filename() == iconName;
+
+                    if (iconPath.stem() == iconName || matchesFilenameWithExtension) {
+                        if (matchesFilenameWithExtension) {
+                            ldLog() << LD_WARNING << "Icon= entry filename contains extension" << std::endl;
+                        }
+
                         ldLog() << "Deploying icon to AppDir root:" << iconPath << std::endl;
 
                         if (!d->symlinkFile(iconPath, path())) {
@@ -768,20 +770,10 @@ namespace linuxdeploy {
                 return d->deployFile(from, to, true);
             }
 
-            void AppDir::setAppName(const std::string& appName) {
-                d->appName = appName;
-            }
-
             std::vector<bf::path> AppDir::listExecutables() {
-                util::magic::Magic magic;
-
                 std::vector<bf::path> executables;
 
                 for (const auto& file : listFilesInDirectory(path() / "usr" / "bin", false)) {
-                    auto fileType = magic.fileType(bf::absolute(file).string());
-
-                    ldLog() << LD_DEBUG << "Type of file" << file << LD_NO_SPACE << ":" << fileType << std::endl;
-
                     // make sure it's an ELF file
                     try {
                         elf::ElfFile elfFile(file);
@@ -790,23 +782,16 @@ namespace linuxdeploy {
                         continue;
                     }
 
-//                    if (util::stringStartsWith(fileType, "application/x-executable"))
-                        executables.push_back(file);
+                    executables.push_back(file);
                 }
 
                 return executables;
             }
 
             std::vector<bf::path> AppDir::listSharedLibraries() {
-                util::magic::Magic magic;
-
                 std::vector<bf::path> sharedLibraries;
 
                 for (const auto& file : listFilesInDirectory(path() / "usr" / "lib", true)) {
-                    auto fileType = magic.fileType(bf::absolute(file).string());
-
-                    ldLog() << LD_DEBUG << "Type of file" << file << LD_NO_SPACE << ":" << fileType << std::endl;
-
                     // make sure it's an ELF file
                     try {
                         elf::ElfFile elfFile(file);
@@ -815,8 +800,7 @@ namespace linuxdeploy {
                         continue;
                     }
 
-//                    if (util::stringStartsWith(fileType, "application/x-sharedlib"))
-                        sharedLibraries.push_back(file);
+                    sharedLibraries.push_back(file);
                 }
 
                 return sharedLibraries;
@@ -824,13 +808,21 @@ namespace linuxdeploy {
 
             bool AppDir::deployDependenciesForExistingFiles() {
                 for (const auto& executable : listExecutables()) {
+                    if (bf::is_symlink(executable))
+                        continue;
+
                     if (!d->deployElfDependencies(executable))
                         return false;
 
-                    d->setElfRPathOperations[executable] = "$ORIGIN/../lib";
+                    std::string rpath = "$ORIGIN/../" + PrivateData::getLibraryDirName(executable);
+
+                    d->setElfRPathOperations[executable] = rpath;
                 }
 
                 for (const auto& sharedLibrary : listSharedLibraries()) {
+                    if (bf::is_symlink(sharedLibrary))
+                        continue;
+
                     if (!d->deployElfDependencies(sharedLibrary))
                         return false;
 

src/core/copyright.cpp

@@ -0,0 +1,34 @@
+// local includes
+#include "linuxdeploy/core/log.h"
+#include "copyright.h"
+
+// specializations
+#include "copyright_dpkgquery.h"
+
+namespace linuxdeploy {
+    namespace core {
+        namespace copyright {
+            using namespace log;
+
+            std::shared_ptr<ICopyrightFilesManager> ICopyrightFilesManager::getInstance() {
+                auto check_command = [](const std::string& command) {
+                    auto p = subprocess::Popen(
+                        command,
+                        subprocess::output(subprocess::PIPE),
+                        subprocess::error(subprocess::PIPE)
+                    );
+
+                    return p.wait();
+                };
+
+                if (check_command("which dpkg-query") == 0) {
+                    ldLog() << LD_DEBUG << "Using dpkg-query to search for copyright files" << std::endl;
+                    return std::make_shared<DpkgQueryCopyrightFilesManager>();
+                }
+
+                ldLog() << LD_DEBUG << "No usable copyright files manager implementation found" << std::endl;
+                return nullptr;
+            }
+        }
+    }
+}

src/core/copyright.h

@@ -0,0 +1,26 @@
+// system includes
+#include <memory>
+#include <vector>
+
+// library includes
+#include <boost/filesystem.hpp>
+
+#pragma once
+
+namespace linuxdeploy {
+    namespace core {
+        namespace copyright {
+            class CopyrightFilesManagerError : public std::runtime_error {
+                explicit CopyrightFilesManagerError(const std::string& msg) : std::runtime_error(msg) {}
+            };
+
+            class ICopyrightFilesManager {
+                public:
+                    static std::shared_ptr<ICopyrightFilesManager> getInstance();
+
+                public:
+                    virtual std::vector<boost::filesystem::path> getCopyrightFilesForPath(const boost::filesystem::path& path) = 0;
+            };
+        }
+    }
+}

src/core/copyright_dpkgquery.cpp

@@ -0,0 +1,48 @@
+// local includes
+#include "copyright_dpkgquery.h"
+#include "linuxdeploy/core/log.h"
+#include "linuxdeploy/util/util.h"
+
+namespace linuxdeploy {
+    namespace core {
+        namespace copyright {
+            using namespace log;
+
+            std::vector<bf::path> DpkgQueryCopyrightFilesManager::getCopyrightFilesForPath(const bf::path& path) {
+                auto call = [](const std::initializer_list<const char*>& args) {
+                    auto proc = subprocess::Popen(
+                        args,
+                        subprocess::output(subprocess::PIPE),
+                        subprocess::error(subprocess::PIPE)
+                    );
+
+                    auto output = proc.communicate();
+                    return std::make_pair(proc.retcode(), output.first);
+                };
+
+                auto dpkgQueryPackages = call({"dpkg-query", "-S", path.c_str()});
+
+                if (dpkgQueryPackages.first != 0
+                    || dpkgQueryPackages.second.buf.empty()
+                    || dpkgQueryPackages.second.buf.front() == '\0') {
+                    ldLog() << LD_WARNING << "Could not find copyright files for file" << path << "using dpkg-query" << std::endl;
+                    return {};
+                }
+
+                auto packageName = util::split(util::splitLines(dpkgQueryPackages.second.buf.data())[0], ':')[0];
+
+                if (!packageName.empty()) {
+                    auto copyrightFilePath = bf::path("/usr/share/doc") / packageName / "copyright";
+
+                    if (bf::is_regular_file(copyrightFilePath)) {
+                        return {copyrightFilePath};
+                    }
+                } else {
+                    ldLog() << LD_WARNING << "Could not find copyright files for file" << path << "using dpkg-query" << std::endl;
+                }
+
+                return {};
+            }
+        }
+    }
+}

src/core/copyright_dpkgquery.h

@@ -0,0 +1,23 @@
+// library includes
+#include <subprocess.hpp>
+
+// local includes
+#include "copyright.h"
+
+#pragma once
+
+namespace bf = boost::filesystem;
+
+namespace linuxdeploy {
+    namespace core {
+        namespace copyright {
+            class DpkgQueryCopyrightFilesManager : public ICopyrightFilesManager {
+                private:
+                    class PrivateData;
+
+                public:
+                    std::vector<bf::path> getCopyrightFilesForPath(const bf::path& path) override;
+            };
+        }
+    }
+}

src/core/elf.cpp

@@ -1,14 +1,17 @@
 // system includes
 #include <fstream>
+#include <memory>
+#include <utility>
 
 // library includes
 #include <boost/regex.hpp>
 #include <subprocess.hpp>
+#include <sys/mman.h>
 
 // local headers
 #include "linuxdeploy/core/elf.h"
 #include "linuxdeploy/core/log.h"
-#include "util.h"
+#include "linuxdeploy/util/util.h"
 
 using namespace linuxdeploy::core::log;
 
@@ -20,9 +23,11 @@ namespace linuxdeploy {
             class ElfFile::PrivateData {
                 public:
                     const bf::path path;
+                    uint8_t elfClass = ELFCLASSNONE;
+                    uint8_t elfABI = 0;
 
                 public:
-                    explicit PrivateData(const bf::path& path) : path(path) {}
+                    explicit PrivateData(bf::path path) : path(std::move(path)) {}
 
                 public:
                     static std::string getPatchelfPath() {
@@ -40,6 +45,50 @@ namespace linuxdeploy {
 
                         return patchelfPath;
                     }
+
+                public:
+
+                    void readDataUsingElfAPI() {
+                        int fd = open(path.c_str(), O_RDONLY);
+                        auto map_size = static_cast<size_t>(lseek(fd, 0, SEEK_END));
+
+                        std::shared_ptr<uint8_t> data(
+                            static_cast<uint8_t*>(mmap(nullptr, map_size, PROT_READ, MAP_SHARED, fd, 0)),
+                            [map_size](uint8_t* p) {
+                                if (munmap(static_cast<void*>(p), map_size) != 0) {
+                                    int error = errno;
+                                    throw ElfFileParseError(std::string("Failed to call munmap(): ") + strerror(error));
+                                }
+                                p = nullptr;
+                            }
+                        );
+                        close(fd);
+
+                        // check which ELF "class" (32-bit or 64-bit) to use
+                        // the "class" is available at a specific constant offset in the section e_ident, which
+                        // happens to be the first section, so just reading one byte at EI_CLASS yields the data we're
+                        // looking for
+                        elfClass = data.get()[EI_CLASS];
+
+                        switch (elfClass) {
+                            case ELFCLASS32: {
+                                    auto* ehdr = reinterpret_cast<Elf32_Ehdr*>(data.get());
+                                    auto* shdr = reinterpret_cast<Elf32_Shdr*>(data.get() + ehdr->e_shoff);
+
+                                    elfABI = ehdr->e_ident[EI_OSABI];
+                                }
+                                break;
+                            case ELFCLASS64: {
+                                    auto* ehdr = reinterpret_cast<Elf32_Ehdr*>(data.get());
+                                    auto* shdr = reinterpret_cast<Elf32_Shdr*>(data.get() + ehdr->e_shoff);
+
+                                    elfABI = ehdr->e_ident[EI_OSABI];
+                                }
+                                break;
+                            default:
+                                throw ElfFileParseError("Unknown ELF class: " + std::to_string(elfClass));
+                        }
+                    }
             };
 
             ElfFile::ElfFile(const boost::filesystem::path& path) {
@@ -59,6 +108,7 @@ namespace linuxdeploy {
                     throw ElfFileParseError("Invalid magic bytes in file header");
 
                 d = new PrivateData(path);
+                d->readDataUsingElfAPI();
             }
 
             ElfFile::~ElfFile() {
@@ -99,7 +149,16 @@ namespace linuxdeploy {
                         util::trim(libraryPath);
                         paths.push_back(bf::absolute(libraryPath));
                     } else {
-                        ldLog() << LD_DEBUG << "Invalid ldd output: " << line << std::endl;
+                        if (util::stringContains(line, "not found")) {
+                            auto missingLib = line;
+                            static const std::string pattern = "=> not found";
+                            missingLib.erase(missingLib.find(pattern), pattern.size());
+                            util::trim(missingLib);
+                            util::trim(missingLib, '\t');
+                            throw DependencyNotFoundError("Could not find dependency: " + missingLib);
+                        } else {
+                            ldLog() << LD_DEBUG << "Invalid ldd output: " << line << std::endl;
+                        }
                     }
                 }
 
@@ -109,7 +168,7 @@ namespace linuxdeploy {
             std::string ElfFile::getRPath() {
                 try {
                     subprocess::Popen patchelfProc(
-                        {d->getPatchelfPath().c_str(), "--print-rpath", d->path.c_str()},
+                        {PrivateData::getPatchelfPath().c_str(), "--print-rpath", d->path.c_str()},
                         subprocess::output(subprocess::PIPE),
                         subprocess::error(subprocess::PIPE)
                     );
@@ -144,7 +203,7 @@ namespace linuxdeploy {
             bool ElfFile::setRPath(const std::string& value) {
                 try {
                     subprocess::Popen patchelfProc(
-                        {d->getPatchelfPath().c_str(), "--set-rpath", value.c_str(), d->path.c_str()},
+                        {PrivateData::getPatchelfPath().c_str(), "--set-rpath", value.c_str(), d->path.c_str()},
                         subprocess::output(subprocess::PIPE),
                         subprocess::error(subprocess::PIPE)
                     );
@@ -163,6 +222,58 @@ namespace linuxdeploy {
 
                 return true;
             }
+
+            uint8_t ElfFile::getSystemElfABI() {
+                // the only way to get the system's ELF ABI is to read the own executable using the ELF header,
+                // and get the ELFOSABI flag
+                auto self = std::shared_ptr<char>(realpath("/proc/self/exe", nullptr), [](char* p) { free(p); });
+
+                if (self == nullptr)
+                    throw ElfFileParseError("Could not read /proc/self/exe");
+
+                std::ifstream ifs(self.get());
+
+                if (!ifs)
+                    throw ElfFileParseError("Could not open file: " + std::string(self.get()));
+
+                // the "class" is available at a specific constant offset in the section e_ident, which
+                // happens to be the first section, so just reading one byte at EI_CLASS yields the data we're
+                // looking for
+                ifs.seekg(EI_OSABI);
+
+                char buf;
+                ifs.read(&buf, 1);
+
+                return static_cast<uint8_t>(buf);
+            }
+
+            uint8_t ElfFile::getSystemElfClass() {
+                #if __SIZEOF_POINTER__ == 4
+                return ELFCLASS32;
+                #elif __SIZEOF_POINTER__ == 8
+                return ELFCLASS64;
+                #else
+                #error "Invalid address size"
+                #endif
+            }
+
+            uint8_t ElfFile::getSystemElfEndianness() {
+                #if __BYTE_ORDER == __LITTLE_ENDIAN
+                return ELFDATA2LSB;
+                #elif __BYTE_ORDER == __BIG_ENDIAN
+                return ELFDATA2MSB;
+                #else
+                #error "Unknown machine endianness"
+                #endif
+            }
+
+            uint8_t ElfFile::getElfClass()  {
+                return d->elfClass;
+            }
+
+            uint8_t ElfFile::getElfABI() {
+                return d->elfABI;
+            }
         }
     }
 }

src/main.cpp

@@ -11,9 +11,11 @@
 #include "linuxdeploy/core/elf.h"
 #include "linuxdeploy/core/log.h"
 #include "linuxdeploy/plugin/plugin.h"
+#include "linuxdeploy/util/util.h"
 
 using namespace linuxdeploy::core;
 using namespace linuxdeploy::core::log;
+using namespace linuxdeploy::util;
 
 namespace bf = boost::filesystem;
 
@@ -26,11 +28,10 @@ int main(int argc, char** argv) {
     args::Flag showVersion(parser, "", "Print version and exit", {'V', "version"});
     args::ValueFlag<int> verbosity(parser, "verbosity", "Verbosity of log output (0 = debug, 1 = info (default), 2 = warning, 3 = error)", {'v', "verbosity"});
 
-    args::Flag initAppDir(parser, "", "Create basic AppDir structure", {"init-appdir"});
     args::ValueFlag<std::string> appDirPath(parser, "appdir", "Path to target AppDir", {"appdir"});
-    args::ValueFlag<std::string> appName(parser, "app-name", "Application name (used to initialize desktop file and name icons etc.)", {'n', "app-name"});
+    args::ValueFlag<std::string> appName(parser, "app-name", "deprecated, please don't use it any more", {'n', "app-name"});
 
-    args::ValueFlagList<std::string> sharedLibraryPaths(parser, "library", "Shared library to deploy", {'l', "lib", "library"});
+    args::ValueFlagList<std::string> sharedLibraryPaths(parser, "library", "Shared library to deploy", {'l', "library"});
 
     args::ValueFlagList<std::string> executablePaths(parser, "executable", "Executable to deploy", {'e', "executable"});
 
@@ -57,16 +58,19 @@ int main(int argc, char** argv) {
     }
 
     // always show version statement
-    std::cerr << "linuxdeploy version " << LINUXDEPLOY_VERSION << std::endl;
+    std::cerr << "linuxdeploy version " << LD_VERSION
+              << " (git commit ID " << LD_GIT_COMMIT << "), "
+              << LD_BUILD_NUMBER << " built on " << LD_BUILD_DATE << std::endl;
+
+    // if only the version should be shown, we can exit now
+    if (showVersion)
+        return 0;
 
     // set verbosity
     if (verbosity) {
         ldLog::setVerbosity((LD_LOGLEVEL) verbosity.Get());
     }
 
-    if (showVersion)
-        return 0;
-
     auto foundPlugins = linuxdeploy::plugin::findPlugins();
 
     if (listPlugins) {
@@ -89,16 +93,14 @@ int main(int argc, char** argv) {
     appdir::AppDir appDir(appDirPath.Get());
 
     if (appName) {
-        ldLog() << std::endl << "-- Deploying application \"" << LD_NO_SPACE << appName.Get() << LD_NO_SPACE << "\" --" << std::endl;
-        appDir.setAppName(appName.Get());
+        ldLog() << LD_WARNING << "--app-name parameter is deprecated, please don't use it any more" << std::endl;
     }
 
-    // initialize AppDir with common directories on request
-    if (initAppDir) {
-        ldLog() << std::endl << "-- Creating basic AppDir structure --" << std::endl;
-
-        if (!appDir.createBasicStructure())
-            return 1;
+    // initialize AppDir with common directories
+    ldLog() << std::endl << "-- Creating basic AppDir structure --" << std::endl;
+    if (!appDir.createBasicStructure()) {
+        ldLog() << LD_ERROR << "Failed to create basic AppDir structure" << std::endl;
+        return 1;
     }
 
     ldLog() << std::endl << "-- Deploying dependencies for existing files in AppDir --" << std::endl;
@@ -117,7 +119,7 @@ int main(int argc, char** argv) {
                 return 1;
             }
 
-            if (!appDir.deployLibrary(libraryPath)) {
+            if (!appDir.forceDeployLibrary(libraryPath)) {
                 std::cerr << "Failed to deploy library: " << libraryPath << std::endl;
                 return 1;
             }
@@ -141,6 +143,40 @@ int main(int argc, char** argv) {
         }
     }
 
+    // run input plugins before deploying icons and desktop files
+    // the input plugins might even fetch these resources somewhere into the AppDir, and this way, the user can make use of that
+    if (inputPlugins) {
+        for (const auto& pluginName : inputPlugins.Get()) {
+            auto it = foundPlugins.find(std::string(pluginName));
+
+            ldLog() << std::endl << "-- Running input plugin:" << pluginName << "--" << std::endl;
+
+            if (it == foundPlugins.end()) {
+                ldLog() << LD_ERROR << "Could not find plugin:" << pluginName;
+                return 1;
+            }
+
+            auto plugin = it->second;
+
+            if (plugin->pluginType() != linuxdeploy::plugin::INPUT_TYPE) {
+                if (plugin->pluginType() == linuxdeploy::plugin::OUTPUT_TYPE) {
+                    ldLog() << LD_ERROR << "Plugin" << pluginName << "is an output plugin, please use like --output" << pluginName << std::endl;
+                } else {
+                    ldLog() << LD_ERROR << "Plugin" << pluginName << "has unkown type:" << plugin->pluginType() << std::endl;
+                }
+                return 1;
+            }
+
+            auto retcode = plugin->run(appDir.path());
+
+            if (retcode != 0) {
+                ldLog() << LD_ERROR << "Failed to run plugin:" << pluginName << std::endl;
+                ldLog() << LD_DEBUG << "Exited with return code:" << retcode << std::endl;
+                return 1;
+            }
+        }
+    }
+
     if (iconPaths) {
         ldLog() << std::endl << "-- Deploying icons --" << std::endl;
 
@@ -211,44 +247,38 @@ int main(int argc, char** argv) {
         }
     }
 
-    if (inputPlugins) {
-        for (const auto& pluginName : inputPlugins.Get()) {
-            auto it = foundPlugins.find(std::string(pluginName));
-
-            if (it == foundPlugins.end()) {
-                ldLog() << LD_ERROR << "Could not find plugin:" << pluginName;
-                return 1;
-            }
-
-            auto plugin = it->second;
-
-            if (plugin->pluginType() != linuxdeploy::plugin::INPUT_TYPE) {
-                ldLog() << LD_ERROR << "Plugin" << pluginName << "has wrong type:" << plugin->pluginType() << std::endl;
-                return 1;
-            }
-
-            ldLog() << std::endl << "-- Running input plugin:" << pluginName << "--" << std::endl;
-
-            auto retcode = plugin->run(appDir.path());
-
-            if (retcode != 0) {
-                ldLog() << LD_ERROR << "Failed to run plugin:" << pluginName << std::endl;
-                ldLog() << LD_DEBUG << "Exited with return code:" << retcode << std::endl;
-                return 1;
-            }
-        }
-    }
-
     // search for desktop file and deploy it to AppDir root
     {
         ldLog() << std::endl << "-- Deploying files into AppDir root directory --" << std::endl;
 
         auto deployedDesktopFiles = appDir.deployedDesktopFiles();
 
+        desktopfile::DesktopFile desktopFile;
+
         if (deployedDesktopFiles.empty()) {
             ldLog() << LD_WARNING << "Could not find desktop file in AppDir, cannot create links for AppRun, desktop file and icon in AppDir root" << std::endl;
         } else {
-            auto& desktopFile = deployedDesktopFiles[0];
+            if (!appName.Get().empty()) {
+                auto desktopFileMatchingName = std::find_if(
+                    deployedDesktopFiles.begin(),
+                    deployedDesktopFiles.end(),
+                    [&appName](const desktopfile::DesktopFile& desktopFile) {
+                        auto fileName = desktopFile.path().filename().string();
+                        return stringStartsWith(fileName, appName.Get()) && stringEndsWith(fileName, ".desktop");
+                    }
+                );
+
+                if (desktopFileMatchingName != deployedDesktopFiles.end()) {
+                    desktopFile = *desktopFileMatchingName;
+                    ldLog() << "Found desktop file matching app name:" << desktopFile.path() << std::endl;
+                } else {
+                    desktopFile = deployedDesktopFiles[0];
+                    ldLog() << LD_WARNING << "Could not find suitable desktop file for given app name" << appName << LD_NO_SPACE << ", using first desktop file found:" << desktopFile.path() << std::endl;
+                }
+            } else {
+                desktopFile = deployedDesktopFiles[0];
+                ldLog() << LD_WARNING << "App name not specified, using first desktop file found:" << desktopFile.path() << std::endl;
+            }
 
             ldLog() << "Deploying desktop file:" << desktopFile.path() << std::endl;
 
@@ -269,6 +299,8 @@ int main(int argc, char** argv) {
         for (const auto& pluginName : outputPlugins.Get()) {
             auto it = foundPlugins.find(std::string(pluginName));
 
+            ldLog() << std::endl << "-- Running output plugin:" << pluginName << "--" << std::endl;
+
             if (it == foundPlugins.end()) {
                 ldLog() << LD_ERROR << "Could not find plugin:" << pluginName;
                 return 1;
@@ -277,12 +309,14 @@ int main(int argc, char** argv) {
             auto plugin = it->second;
 
             if (plugin->pluginType() != linuxdeploy::plugin::OUTPUT_TYPE) {
-                ldLog() << LD_ERROR << "Plugin" << pluginName << "has wrong type:" << plugin->pluginType() << std::endl;
+                if (plugin->pluginType() == linuxdeploy::plugin::INPUT_TYPE) {
+                    ldLog() << LD_ERROR << "Plugin" << pluginName << "is an input plugin, please use like --plugin" << pluginName << std::endl;
+                } else {
+                    ldLog() << LD_ERROR << "Plugin" << pluginName << "has unknown type:" << plugin->pluginType() << std::endl;
+                }
                 return 1;
             }
 
-            ldLog() << std::endl << "-- Running output plugin:" << pluginName << "--" << std::endl;
-
             auto retcode = plugin->run(appDir.path());
 
             if (retcode != 0) {