Log error when pipe creation fails

Read subprocesses' pipes until they're empty
Switch to new subprocess lib in type 0 plugins, mk. 3
2026-07-10 12:18:44 -07:00 · 2020-10-05 22:31:16 +02:00 · 2020-09-22 13:04:23 +02:00 · 2020-09-04 18:02:40 +02:00 · 2020-08-31 08:39:43 +02:00 · 2020-08-31 06:30:06 +02:00
78 changed files with 3656 additions and 1022 deletions
@@ -1,3 +1,5 @@
 cmake-build-*/
 *build*/
 .idea/
+squashfs-root/
+*.AppImage
@@ -1,12 +1,6 @@
-[submodule "lib/cpp-subprocess"]
-	path = lib/cpp-subprocess
-	url = https://github.com/arun11299/cpp-subprocess.git
 [submodule "lib/args"]
 	path = lib/args
 	url = https://github.com/Taywee/args.git
-[submodule "lib/cpp-feather-ini-parser"]
-	path = lib/cpp-feather-ini-parser
-	url = https://github.com/Turbine1991/cpp-feather-ini-parser.git
 [submodule "lib/boost-filesystem"]
 	path = lib/boost-filesystem
 	url = https://github.com/boostorg/filesystem.git
@@ -73,3 +67,15 @@
 [submodule "lib/boost-integer"]
 	path = lib/boost-integer
 	url = https://github.com/boostorg/integer.git
+[submodule "lib/CImg"]
+	path = lib/CImg
+	url = https://github.com/dtschump/CImg.git
+[submodule "lib/googletest"]
+	path = lib/googletest
+	url = https://github.com/google/googletest
+[submodule "lib/boost-container"]
+	path = lib/boost-container
+	url = https://github.com/boostorg/container
+[submodule "lib/linuxdeploy-desktopfile"]
+	path = lib/linuxdeploy-desktopfile
+	url = https://github.com/linuxdeploy/linuxdeploy-desktopfile
@@ -1,33 +1,78 @@
 language: cpp
-sudo: required

-addons:
-  apt:
-    update: true
-    packages:
-      - libmagic-dev
-      - cimg-dev
-      - automake  # required for patchelf
+matrix:
+  include:
+    - name: Ubuntu bionic x86_64 release build
+      env: ARCH=x86_64
+      dist: bionic
+      addons:
+        apt:
+          update: true
+          packages:
+            - libmagic-dev
+            - libjpeg-dev
+            - libpng-dev
+            - cimg-dev
+      script: travis/build.sh
+      after_success:
+        - if [ "$TRAVIS_BRANCH" != "$TRAVIS_TAG" ] && [ "$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-"$ARCH".AppImage*

-install:
-  - git clone https://github.com/NixOS/patchelf.git
-  - cd patchelf
-  - ./bootstrap.sh
-  - ./configure --prefix=/usr
-  - make -j$(nproc)
-  - sudo make install
-  - cd ..
-  - rm -rf patchelf
+    - name: Ubuntu bionic i386 build
+      env: ARCH=i386
+      dist: bionic
+      addons:
+        apt:
+          update: true
+          packages:
+            - libmagic-dev:i386
+            - libjpeg-dev:i386
+            - libpng-dev:i386
+            - gcc-multilib
+            - g++-multilib
+            - libfuse2:i386
+            - libcairo2:i386
+      script: travis/build.sh
+      after_success:
+        - if [ "$TRAVIS_BRANCH" != "$TRAVIS_TAG" ] && [ "$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-"$ARCH".AppImage*

-script:
-  - travis/build.sh
+    - name: Ubuntu xenial x86_64 coverage build (no binaries uploaded)
+      env: ARCH=x86_64 BUILD_TYPE=coverage
+      dist: xenial
+      addons:
+        apt:
+          update: true
+          packages:
+            - libmagic-dev
+            - libjpeg-dev
+            - libpng-dev
+            - cimg-dev
+      before_script:
+        - sudo pip install gcovr
+      script: travis/test-coverage.sh
+      after_success: true  # also, we don't intend to upload release binaries

-after_success:
-  - ls -lh
-  # 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*
+    - name: Ubuntu xenial i386 coverage build (no binaries uploaded)
+      env: ARCH=i386 BUILD_TYPE=coverage
+      dist: xenial
+      addons:
+        apt:
+          update: true
+          packages:
+            - libmagic-dev:i386
+            - libjpeg-dev:i386
+            - libpng-dev:i386
+            - gcc-multilib
+            - g++-multilib
+            - libfuse2:i386
+            - libcairo2:i386
+      before_script:
+        - sudo pip install gcovr
+      script: travis/test-coverage.sh
+      after_success: true  # also, we don't intend to upload release binaries

 branches:
  except:
@@ -5,13 +5,49 @@ 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")
+set(USE_SYSTEM_CIMG ON CACHE BOOL "Set to OFF to use CImg library bundled in lib directory")
+
+# support for ccache
+# call CMake with -DUSE_CCACHE=ON to make use of it
+set(USE_CCACHE ON CACHE BOOL "")
+if(USE_CCACHE)
+    find_program(CCACHE ccache)
+    if(CCACHE)
+        message(STATUS "Using ccache")
+        set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ${CCACHE})
+        set_property(GLOBAL PROPERTY RULE_LAUNCH_LINK ${CCACHE})
+    else()
+        message(WARNING "USE_CCACHE set, but could not find ccache")
+    endif()
+endif()
+
+set(ENABLE_COVERAGE OFF CACHE BOOL "Enable coverage measurements")
+if(ENABLE_COVERAGE)
+    include(CodeCoverage)
+    message(WARNING "Enabling code coverage measurements -> disables optimizations and embeds debug information!")
+
+    append_coverage_compiler_flags()
+
+    set(COVERAGE_GCOVR_EXCLUDES ${PROJECT_SOURCE_DIR}/lib ${PROJECT_BINARY_DIR})
+
+    include(ProcessorCount)
+    ProcessorCount(processor_count)
+
+    set(command cmake --build . --target all -- -j ${processor_count} && ctest -V)
+
+    setup_target_for_coverage_gcovr_html(NAME coverage EXECUTABLE "${command}")
+    setup_target_for_coverage_gcovr_xml(NAME coverage_xml EXECUTABLE "${command}")
+    setup_target_for_coverage_gcovr_text(NAME coverage_text EXECUTABLE "${command}")
+endif()

 add_subdirectory(lib)

 add_subdirectory(src)
+
+include(CTest)
+if(BUILD_TESTING)
+    add_subdirectory(tests)
+endif()
@@ -2,4 +2,70 @@

 AppDir creation and maintenance tool.

-**More info will follow soon!**
+
+## About
+
+AppImages are a well known and quite popular format for distributing applications from developers to end users.
+
+[appimagetool](https://github.com/AppImage/AppImageKit), the tool creating AppImages, expects directories in a specific format that will then be converted into the final AppImage. This format is called [AppDir](https://github.com/TheAssassin/linuxdeploy/wiki/AppDir-specification). It is not very difficult to understand, but creating AppDirs for arbitrary applications tends to be a very repetitive task. Also, bundling all the dependencies properly can be a quite difficult task. It seems like there is a need for tools which simplify these tasks.
+
+linuxdeploy is designed to be an AppDir maintenance tool. It provides extensive functionalities to create and bundle AppDirs for applications. It features a plugin system that allows for easy bundling of frameworks and creating output bundles such as AppImages with little effort.
+
+linuxdeploy was greatly influenced by [linuxdeployqt](https://github.com/probonopd/linuxdeployqt), and while it employs stricter rules on AppDirs, it's more flexible in use. If you use linuxdeployqt at the moment, consider switching to linuxdeploy today!
+
+
+## User guides and examples
+
+Please see the [linuxdeploy user guide](https://docs.appimage.org/packaging-guide/from-source/linuxdeploy-user-guide.html) and the [native binaries packaging guide](https://docs.appimage.org/packaging-guide/from-source/native-binaries.html) in the [AppImage documentation](https://docs.appimage.org). There's also an [examples section](https://docs.appimage.org/packaging-guide/from-source/native-binaries.html#examples).
+
+
+## Projects using linuxdeploy
+
+This is an incomplete list of projects using linuxdeploy. You might want to read their build scripts to see how they use linuxdeploy.
+
+- [Pext](https://github.com/Pext/Pext)
+- [AppImageLauncher](https://github.com/TheAssassin/AppImageLauncher)
+- [OpenRCT2](https://github.com/OpenRCT2/OpenRCT2)
+- [AppImageUpdate](https://github.com/AppImage/AppImageUpdate)
+- [appimaged](https://github.com/AppImage/appimaged)
+- [MediaElch](https://github.com/Komet/MediaElch/)
+- [CPU-X](https://github.com/X0rg/CPU-X) (details available [here](https://github.com/AppImage/AppImageKit/wiki/Bundling-GTK3-apps#fully-automated-deployment-from-sources-with-github-actions-cpu-x))
+
+
+## Plugins
+
+linuxdeploy features a plugin system. Plugins are separate executables which implement a CLI-based plugin interface ([specification](https://github.com/TheAssassin/linuxdeploy/wiki/Plugin-system)).
+
+There are two types of plugins: bundling and output plugins. Bundling plugins can be used to add resources to the AppDir. Output plugins turn the AppDir in actual bundles, e.g., AppImages.
+
+linuxdeploy looks for plugins in the following places:
+
+  - the directory containing the linuxdeploy binary
+  - when using the AppImage: the directory containing the AppImage
+  - the directories in the user's `$PATH`
+
+You can use `./linuxdeploy*.AppImage --list-plugins` to get a list of all the plugins linuxdeploy has detected on your system.
+
+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>`.
+
+**A list of official and community plugins can be found in the [awesome-linuxdeploy](http://github.com/linuxdeploy/awesome-linuxdeploy) project.**
+
+**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).
+
+
+## Troubleshooting
+
+> I bundled additional resources, but when I try to run them, either the system binary is called or the file is not found.
+
+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.
+
+To report problems, please [create an issue](https://github.com/TheAssassin/linuxdeploy/issues/new) on GitHub.
+
+Contributions welcome! Please feel free to fork this repository and send us a pull request. Even small changes, e.g., in this README, are highly appreciated!
@@ -0,0 +1,362 @@
+# Copyright (c) 2012 - 2017, Lars Bilke
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+#    list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors
+#    may be used to endorse or promote products derived from this software without
+#    specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+# CHANGES:
+#
+# 2012-01-31, Lars Bilke
+# - Enable Code Coverage
+#
+# 2013-09-17, Joakim Söderberg
+# - Added support for Clang.
+# - Some additional usage instructions.
+#
+# 2016-02-03, Lars Bilke
+# - Refactored functions to use named parameters
+#
+# 2017-06-02, Lars Bilke
+# - Merged with modified version from github.com/ufz/ogs
+#
+#
+# USAGE:
+#
+# 1. Copy this file into your cmake modules path.
+#
+# 2. Add the following line to your CMakeLists.txt:
+#      include(CodeCoverage)
+#
+# 3. Append necessary compiler flags:
+#      APPEND_COVERAGE_COMPILER_FLAGS()
+#
+# 4. If you need to exclude additional directories from the report, specify them
+#    using the COVERAGE_LCOV_EXCLUDES variable before calling SETUP_TARGET_FOR_COVERAGE_LCOV.
+#    Example:
+#      set(COVERAGE_LCOV_EXCLUDES 'dir1/*' 'dir2/*')
+#
+# 5. Use the functions described below to create a custom make target which
+#    runs your test executable and produces a code coverage report.
+#
+# 6. Build a Debug build:
+#      cmake -DCMAKE_BUILD_TYPE=Debug ..
+#      make
+#      make my_coverage_target
+#
+
+include(CMakeParseArguments)
+
+# Check prereqs
+find_program( GCOV_PATH gcov )
+find_program( LCOV_PATH  NAMES lcov lcov.bat lcov.exe lcov.perl)
+find_program( GENHTML_PATH NAMES genhtml genhtml.perl genhtml.bat )
+find_program( GCOVR_PATH gcovr PATHS ${CMAKE_SOURCE_DIR}/scripts/test)
+find_program( SIMPLE_PYTHON_EXECUTABLE python )
+
+if(NOT GCOV_PATH)
+    message(FATAL_ERROR "gcov not found! Aborting...")
+endif() # NOT GCOV_PATH
+
+if("${CMAKE_CXX_COMPILER_ID}" MATCHES "(Apple)?[Cc]lang")
+    if("${CMAKE_CXX_COMPILER_VERSION}" VERSION_LESS 3)
+        message(FATAL_ERROR "Clang version must be 3.0.0 or greater! Aborting...")
+    endif()
+elseif(NOT CMAKE_COMPILER_IS_GNUCXX)
+    message(FATAL_ERROR "Compiler is not GNU gcc! Aborting...")
+endif()
+
+set(COVERAGE_COMPILER_FLAGS "-g -O0 --coverage -fprofile-arcs -ftest-coverage"
+    CACHE INTERNAL "")
+
+set(CMAKE_CXX_FLAGS_COVERAGE
+    ${COVERAGE_COMPILER_FLAGS}
+    CACHE STRING "Flags used by the C++ compiler during coverage builds."
+    FORCE )
+set(CMAKE_C_FLAGS_COVERAGE
+    ${COVERAGE_COMPILER_FLAGS}
+    CACHE STRING "Flags used by the C compiler during coverage builds."
+    FORCE )
+set(CMAKE_EXE_LINKER_FLAGS_COVERAGE
+    ""
+    CACHE STRING "Flags used for linking binaries during coverage builds."
+    FORCE )
+set(CMAKE_SHARED_LINKER_FLAGS_COVERAGE
+    ""
+    CACHE STRING "Flags used by the shared libraries linker during coverage builds."
+    FORCE )
+mark_as_advanced(
+    CMAKE_CXX_FLAGS_COVERAGE
+    CMAKE_C_FLAGS_COVERAGE
+    CMAKE_EXE_LINKER_FLAGS_COVERAGE
+    CMAKE_SHARED_LINKER_FLAGS_COVERAGE )
+
+if(NOT CMAKE_BUILD_TYPE STREQUAL "Debug")
+    message(WARNING "Code coverage results with an optimised (non-Debug) build may be misleading")
+endif() # NOT CMAKE_BUILD_TYPE STREQUAL "Debug"
+
+if(CMAKE_C_COMPILER_ID STREQUAL "GNU")
+    link_libraries(gcov)
+else()
+    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} --coverage")
+endif()
+
+# Defines a target for running and collection code coverage information
+# Builds dependencies, runs the given executable and outputs reports.
+# NOTE! The executable should always have a ZERO as exit code otherwise
+# the coverage generation will not complete.
+#
+# SETUP_TARGET_FOR_COVERAGE_LCOV(
+#     NAME testrunner_coverage                    # New target name
+#     EXECUTABLE testrunner -j ${PROCESSOR_COUNT} # Executable in PROJECT_BINARY_DIR
+#     DEPENDENCIES testrunner                     # Dependencies to build first
+# )
+function(SETUP_TARGET_FOR_COVERAGE_LCOV)
+
+    set(options NONE)
+    set(oneValueArgs NAME)
+    set(multiValueArgs EXECUTABLE EXECUTABLE_ARGS DEPENDENCIES LCOV_ARGS GENHTML_ARGS)
+    cmake_parse_arguments(Coverage "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+
+    if(NOT LCOV_PATH)
+        message(FATAL_ERROR "lcov not found! Aborting...")
+    endif() # NOT LCOV_PATH
+
+    if(NOT GENHTML_PATH)
+        message(FATAL_ERROR "genhtml not found! Aborting...")
+    endif() # NOT GENHTML_PATH
+
+    # Setup target
+    add_custom_target(${Coverage_NAME}
+
+        # Cleanup lcov
+        COMMAND ${LCOV_PATH} ${Coverage_LCOV_ARGS} --gcov-tool ${GCOV_PATH} -directory . --zerocounters
+        # Create baseline to make sure untouched files show up in the report
+        COMMAND ${LCOV_PATH} ${Coverage_LCOV_ARGS} --gcov-tool ${GCOV_PATH} -c -i -d . -o ${Coverage_NAME}.base
+
+        # Run tests
+        COMMAND ${Coverage_EXECUTABLE} ${Coverage_EXECUTABLE_ARGS}
+
+        # Capturing lcov counters and generating report
+        COMMAND ${LCOV_PATH} ${Coverage_LCOV_ARGS} --gcov-tool ${GCOV_PATH} --directory . --capture --output-file ${Coverage_NAME}.info
+        # add baseline counters
+        COMMAND ${LCOV_PATH} ${Coverage_LCOV_ARGS} --gcov-tool ${GCOV_PATH} -a ${Coverage_NAME}.base -a ${Coverage_NAME}.info --output-file ${Coverage_NAME}.total
+        COMMAND ${LCOV_PATH} ${Coverage_LCOV_ARGS} --gcov-tool ${GCOV_PATH} --remove ${Coverage_NAME}.total ${COVERAGE_LCOV_EXCLUDES} --output-file ${PROJECT_BINARY_DIR}/${Coverage_NAME}.info.cleaned
+        COMMAND ${GENHTML_PATH} ${Coverage_GENHTML_ARGS} -o ${Coverage_NAME} ${PROJECT_BINARY_DIR}/${Coverage_NAME}.info.cleaned
+        COMMAND ${CMAKE_COMMAND} -E remove ${Coverage_NAME}.base ${Coverage_NAME}.total ${PROJECT_BINARY_DIR}/${Coverage_NAME}.info.cleaned
+
+        WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
+        DEPENDS ${Coverage_DEPENDENCIES}
+        COMMENT "Resetting code coverage counters to zero.\nProcessing code coverage counters and generating report."
+    )
+
+    # Show where to find the lcov info report
+    add_custom_command(TARGET ${Coverage_NAME} POST_BUILD
+        COMMAND ;
+        COMMENT "Lcov code coverage info report saved in ${Coverage_NAME}.info."
+    )
+
+    # Show info where to find the report
+    add_custom_command(TARGET ${Coverage_NAME} POST_BUILD
+        COMMAND ;
+        COMMENT "Open ./${Coverage_NAME}/index.html in your browser to view the coverage report."
+    )
+
+endfunction() # SETUP_TARGET_FOR_COVERAGE_LCOV
+
+# Defines a target for running and collection code coverage information
+# Builds dependencies, runs the given executable and outputs reports.
+# NOTE! The executable should always have a ZERO as exit code otherwise
+# the coverage generation will not complete.
+#
+# SETUP_TARGET_FOR_COVERAGE_GCOVR_XML(
+#     NAME ctest_coverage                    # New target name
+#     EXECUTABLE ctest -j ${PROCESSOR_COUNT} # Executable in PROJECT_BINARY_DIR
+#     DEPENDENCIES executable_target         # Dependencies to build first
+# )
+function(SETUP_TARGET_FOR_COVERAGE_GCOVR_XML)
+
+    set(options NONE)
+    set(oneValueArgs NAME)
+    set(multiValueArgs EXECUTABLE EXECUTABLE_ARGS DEPENDENCIES)
+    cmake_parse_arguments(Coverage "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+
+    if(NOT SIMPLE_PYTHON_EXECUTABLE)
+        message(FATAL_ERROR "python not found! Aborting...")
+    endif() # NOT SIMPLE_PYTHON_EXECUTABLE
+
+    if(NOT GCOVR_PATH)
+        message(FATAL_ERROR "gcovr not found! Aborting...")
+    endif() # NOT GCOVR_PATH
+
+    # Combine excludes to several -e arguments
+    set(GCOVR_EXCLUDES "")
+    foreach(EXCLUDE ${COVERAGE_GCOVR_EXCLUDES})
+        list(APPEND GCOVR_EXCLUDES "-e")
+        list(APPEND GCOVR_EXCLUDES "${EXCLUDE}")
+    endforeach()
+
+    add_custom_target(${Coverage_NAME}
+        # Clean old coverage data
+        COMMAND find ${PROJECT_BINARY_DIR} -type f -iname '*.gcno' -delete
+
+        # Run tests
+        COMMAND ${Coverage_EXECUTABLE} ${Coverage_EXECUTABLE_ARGS}
+
+        # Running gcovr
+        COMMAND ${GCOVR_PATH} --xml
+            -r ${PROJECT_SOURCE_DIR} ${GCOVR_EXCLUDES}
+            --object-directory=${PROJECT_BINARY_DIR}
+            -o ${Coverage_NAME}.xml
+        WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
+        DEPENDS ${Coverage_DEPENDENCIES}
+        COMMENT "Running gcovr to produce Cobertura code coverage report."
+    )
+
+    # Show info where to find the report
+    add_custom_command(TARGET ${Coverage_NAME} POST_BUILD
+        COMMAND ;
+        COMMENT "Cobertura code coverage report saved in ${Coverage_NAME}.xml."
+    )
+
+endfunction() # SETUP_TARGET_FOR_COVERAGE_GCOVR_XML
+
+# Defines a target for running and collection code coverage information
+# Builds dependencies, runs the given executable and outputs reports.
+# NOTE! The executable should always have a ZERO as exit code otherwise
+# the coverage generation will not complete.
+#
+# SETUP_TARGET_FOR_COVERAGE_GCOVR_HTML(
+#     NAME ctest_coverage                    # New target name
+#     EXECUTABLE ctest -j ${PROCESSOR_COUNT} # Executable in PROJECT_BINARY_DIR
+#     DEPENDENCIES executable_target         # Dependencies to build first
+# )
+function(SETUP_TARGET_FOR_COVERAGE_GCOVR_HTML)
+
+    set(options NONE)
+    set(oneValueArgs NAME)
+    set(multiValueArgs EXECUTABLE EXECUTABLE_ARGS DEPENDENCIES)
+    cmake_parse_arguments(Coverage "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+
+    if(NOT SIMPLE_PYTHON_EXECUTABLE)
+        message(FATAL_ERROR "python not found! Aborting...")
+    endif() # NOT SIMPLE_PYTHON_EXECUTABLE
+
+    if(NOT GCOVR_PATH)
+        message(FATAL_ERROR "gcovr not found! Aborting...")
+    endif() # NOT GCOVR_PATH
+
+    # Combine excludes to several -e arguments
+    set(GCOVR_EXCLUDES "")
+    foreach(EXCLUDE ${COVERAGE_GCOVR_EXCLUDES})
+        list(APPEND GCOVR_EXCLUDES "-e")
+        list(APPEND GCOVR_EXCLUDES "${EXCLUDE}")
+    endforeach()
+
+    add_custom_target(${Coverage_NAME}
+        # Clean old coverage data
+        COMMAND find ${PROJECT_BINARY_DIR} -type f -iname '*.gcno' -delete
+
+        # Run tests
+        COMMAND ${Coverage_EXECUTABLE} ${Coverage_EXECUTABLE_ARGS}
+
+        # Create folder
+        COMMAND ${CMAKE_COMMAND} -E make_directory ${PROJECT_BINARY_DIR}/${Coverage_NAME}
+
+        # Running gcovr
+        COMMAND ${GCOVR_PATH} --html --html-details
+            -r ${PROJECT_SOURCE_DIR} ${GCOVR_EXCLUDES}
+            --object-directory=${PROJECT_BINARY_DIR}
+            -o ${Coverage_NAME}/index.html
+        WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
+        DEPENDS ${Coverage_DEPENDENCIES}
+        COMMENT "Running gcovr to produce HTML code coverage report."
+    )
+
+    # Show info where to find the report
+    add_custom_command(TARGET ${Coverage_NAME} POST_BUILD
+        COMMAND ;
+        COMMENT "Open ./${Coverage_NAME}/index.html in your browser to view the coverage report."
+    )
+
+endfunction() # SETUP_TARGET_FOR_COVERAGE_GCOVR_HTML
+
+# Defines a target for running and collection code coverage information
+# Builds dependencies, runs the given executable and outputs reports.
+# NOTE! The executable should always have a ZERO as exit code otherwise
+# the coverage generation will not complete.
+#
+# SETUP_TARGET_FOR_COVERAGE_GCOVR_TEXT(
+#     NAME ctest_coverage                    # New target name
+#     EXECUTABLE ctest -j ${PROCESSOR_COUNT} # Executable in PROJECT_BINARY_DIR
+#     DEPENDENCIES executable_target         # Dependencies to build first
+# )
+function(SETUP_TARGET_FOR_COVERAGE_GCOVR_TEXT)
+
+    set(options NONE)
+    set(oneValueArgs NAME)
+    set(multiValueArgs EXECUTABLE EXECUTABLE_ARGS DEPENDENCIES)
+    cmake_parse_arguments(Coverage "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+
+    if(NOT SIMPLE_PYTHON_EXECUTABLE)
+        message(FATAL_ERROR "python not found! Aborting...")
+    endif() # NOT SIMPLE_PYTHON_EXECUTABLE
+
+    if(NOT GCOVR_PATH)
+        message(FATAL_ERROR "gcovr not found! Aborting...")
+    endif() # NOT GCOVR_PATH
+
+    # Combine excludes to several -e arguments
+    set(GCOVR_EXCLUDES "")
+    foreach(EXCLUDE ${COVERAGE_GCOVR_EXCLUDES})
+        list(APPEND GCOVR_EXCLUDES "-e")
+        list(APPEND GCOVR_EXCLUDES "${EXCLUDE}")
+    endforeach()
+
+    add_custom_target(${Coverage_NAME}
+        # Clean old coverage data
+        COMMAND find ${PROJECT_BINARY_DIR} -type f -iname '*.gcno' -delete
+
+        # Run tests
+        COMMAND ${Coverage_EXECUTABLE} ${Coverage_EXECUTABLE_ARGS}
+
+        # Create folder
+        COMMAND ${CMAKE_COMMAND} -E make_directory ${PROJECT_BINARY_DIR}/${Coverage_NAME}
+
+        # Running gcovr
+        COMMAND ${GCOVR_PATH}
+            -r ${PROJECT_SOURCE_DIR} ${GCOVR_EXCLUDES}
+            --object-directory=${PROJECT_BINARY_DIR}
+        WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
+        DEPENDS ${Coverage_DEPENDENCIES}
+        COMMENT "Running gcovr to produce HTML code coverage report."
+    )
+
+endfunction() # SETUP_TARGET_FOR_COVERAGE_GCOVR_TEXT
+
+function(APPEND_COVERAGE_COMPILER_FLAGS)
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${COVERAGE_COMPILER_FLAGS}" PARENT_SCOPE)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${COVERAGE_COMPILER_FLAGS}" PARENT_SCOPE)
+    message(STATUS "Appending code coverage compiler flags: ${COVERAGE_COMPILER_FLAGS}")
+endfunction() # APPEND_COVERAGE_COMPILER_FLAGS
@@ -1,22 +1,64 @@
 # required for PNG imported target
-cmake_minimum_required(VERSION 3.5)
+cmake_minimum_required(VERSION 3.6)

-message(STATUS "Searching for CImg")
+find_package(PkgConfig)
+pkg_check_modules(libpng REQUIRED IMPORTED_TARGET libpng)

-find_path(CIMG_H_DIR
-    NAMES CImg.h
-    HINTS ${CMAKE_INSTALL_PREFIX}
-    PATH_SUFFIXES include include/linux
-)
+# build custom static version of libjpeg for static builds
+if(STATIC_BUILD)
+    include(ExternalProject)

-if(NOT CIMG_H_DIR)
-    message(FATAL_ERROR "CImg.h not found")
+    if($ENV{ARCH} MATCHES "i[356]86")
+        set(configure_command_prefix env CFLAGS=-m32 CXXFLAGS=-m32)
+    endif()
+
+    ExternalProject_Add(libjpeg_static_extproj
+        URL https://www.ijg.org/files/jpegsrc.v9d.tar.gz
+        URL_HASH SHA256=99cb50e48a4556bc571dadd27931955ff458aae32f68c4d9c39d624693f69c32
+        BUILD_IN_SOURCE ON
+        EXCLUDE_FROM_ALL ON
+        CONFIGURE_COMMAND ${configure_command_prefix} ./configure --prefix=/usr
+        INSTALL_COMMAND ""
+    )
+
+    ExternalProject_Get_property(libjpeg_static_extproj SOURCE_DIR)
+    add_library(libjpeg_static INTERFACE IMPORTED)
+    set_property(TARGET libjpeg_static PROPERTY INTERFACE_LINK_LIBRARIES ${SOURCE_DIR}/.libs/libjpeg.a)
+    add_dependencies(libjpeg_static libjpeg_static_extproj)
+
+    set(JPEG_LIBRARIES libjpeg_static)
+else()
+    find_package(JPEG REQUIRED)
 endif()

-find_package(PNG REQUIRED)
-find_package(JPEG REQUIRED)
+if(NOT USE_SYSTEM_CIMG)
+    message(STATUS "Using bundled CImg library")

-add_library(CImg INTERFACE IMPORTED)
-set_property(TARGET CImg PROPERTY INTERFACE_INCLUDE_DIRECTORIES "${CIMG_H_DIR};${JPEG_INCLUDE_DIR}")
-set_property(TARGET CImg PROPERTY INTERFACE_LINK_LIBRARIES "PNG::PNG;${JPEG_LIBRARIES}")
+    set(CIMG_H_DIR "${PROJECT_SOURCE_DIR}/lib/CImg/")
+else()
+    message(STATUS "Searching for CImg")
+
+    find_path(CIMG_H_DIR
+        NAMES CImg.h
+        HINTS ${CMAKE_INSTALL_PREFIX}
+        PATH_SUFFIXES include include/linux
+    )
+
+    if(NOT CIMG_H_DIR)
+        message(FATAL_ERROR "CImg.h not found")
+    endif()
+endif()
+
+set(PNG_INCLUDE_DIR ${libpng_INCLUDE_DIRS})
+if(NOT STATIC_BUILD)
+    set(PNG_LIBRARY ${libpng_LIBRARIES})
+else()
+    set(PNG_LIBRARY ${libpng_STATIC_LIBRARIES})
+endif()
+
+#message(FATAL_ERROR "${PNG_LIBRARY}")
+
+add_library(CImg INTERFACE)
+set_property(TARGET CImg PROPERTY INTERFACE_INCLUDE_DIRECTORIES "${CIMG_H_DIR};${PNG_INCLUDE_DIR};${JPEG_INCLUDE_DIR}")
+set_property(TARGET CImg PROPERTY INTERFACE_LINK_LIBRARIES "${PNG_LIBRARY};${JPEG_LIBRARIES}")
 set_property(TARGET CImg PROPERTY INTERFACE_COMPILE_DEFINITIONS "cimg_display=0;cimg_use_png=1;cimg_use_jpeg=1")
@@ -1,27 +0,0 @@
-# required for zlib imported target
-cmake_minimum_required(VERSION 3.3)
-
-message(STATUS "Searching for libmagic")
-
-# on Debian-ish systems, libmagic depends on zlib
-find_package(ZLIB REQUIRED)
-
-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()
-
-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)
@@ -0,0 +1,8 @@
+set(CMAKE_SYSTEM_NAME Linux CACHE STRING "" FORCE)
+set(CMAKE_SYSTEM_PROCESSOR i386 CACHE STRING "" FORCE)
+
+set(CMAKE_C_FLAGS "-m32" CACHE STRING "" FORCE)
+set(CMAKE_CXX_FLAGS "-m32" CACHE STRING "" FORCE)
+
+# https://gitlab.kitware.com/cmake/cmake/issues/16920#note_299077
+set(THREADS_PTHREAD_ARG "2" CACHE STRING "Forcibly set by CMakeLists.txt" FORCE)
@@ -1,11 +1,12 @@
 // system includes
+#include <memory>
 #include <string>

 // library includes
 #include <boost/filesystem.hpp>

 // local includes
-#include "linuxdeploy/core/desktopfile.h"
+#include "linuxdeploy/desktopfile/desktopfile.h"

 #pragma once

@@ -19,7 +20,7 @@ namespace linuxdeploy {
                private:
                    // private data class pattern
                    class PrivateData;
-                    PrivateData* d;
+                    std::shared_ptr<PrivateData> d;

                public:
                    // default constructor
@@ -27,14 +28,18 @@ namespace linuxdeploy {
                    // the directory will be created if it doesn't exist
                    explicit AppDir(const boost::filesystem::path& path);

-                    ~AppDir();
+                    // we don't want any copy/move(-assignment) behavior, therefore we delete those operators/constructors
+                    AppDir(const AppDir&) = delete;
+                    AppDir(AppDir&&) = delete;
+                    void operator=(const AppDir&) = delete;
+                    void operator=(AppDir&&) = delete;

                    // alternative constructor
                    // shortcut for using a normal string instead of a path
                    explicit AppDir(const std::string& path);

                    // creates basic directory structure of an AppDir in "FHS" mode
-                    bool createBasicStructure();
+                    bool createBasicStructure() const;

                    // deploy shared library
                    //
@@ -42,54 +47,72 @@ 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 = "");

+                    // deploy dependencies for ELF file in AppDir, without copying it into the library dir
+                    //
+                    // the dependencies end up in the regular location
+                    bool deployDependenciesOnlyForElfFile(const boost::filesystem::path& elfFilePath, bool failSilentForNonElfFile = false);
+
                    // deploy desktop file
                    bool deployDesktopFile(const desktopfile::DesktopFile& desktopFile);

                    // deploy icon
                    bool deployIcon(const boost::filesystem::path& path);

+                    // deploy icon, changing its name to <target filename>.<ext>
+                    bool deployIcon(const boost::filesystem::path& path, const std::string& targetFilename);
+
                    // deploy arbitrary file
-                    void deployFile(const boost::filesystem::path& from, const boost::filesystem::path& to);
+                    boost::filesystem::path deployFile(const boost::filesystem::path& from, const boost::filesystem::path& to);
+
+                    // copy arbitrary file (immediately)
+                    bool copyFile(const boost::filesystem::path& from, const boost::filesystem::path& to, bool overwrite = false) const;
+
+                    // create an <AppDir> relative symlink to <target> at <symlink>.
+                    bool createRelativeSymlink(const boost::filesystem::path& target, const boost::filesystem::path& symlink) const;

                    // execute deferred copy operations
                    bool executeDeferredOperations();

                    // return path to AppDir
-                    boost::filesystem::path path();
+                    boost::filesystem::path path() const;

                    // create a list of all icon paths in the AppDir
-                    std::vector<boost::filesystem::path> deployedIconPaths();
+                    std::vector<boost::filesystem::path> deployedIconPaths() const;

                    // create a list of all executable paths in the AppDir
-                    std::vector<boost::filesystem::path> deployedExecutablePaths();
+                    std::vector<boost::filesystem::path> deployedExecutablePaths() const;

                    // create a list of all desktop file paths in the AppDir
-                    std::vector<desktopfile::DesktopFile> deployedDesktopFiles();
+                    std::vector<desktopfile::DesktopFile> deployedDesktopFiles() const;

                    // 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);
+                    bool setUpAppDirRoot(const desktopfile::DesktopFile& desktopFile, boost::filesystem::path customAppRunPath = "");

                    // 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();
+                    std::vector<boost::filesystem::path> listExecutables() const;

                    // list all shared libraries in <AppDir>/usr/lib
                    // this function recursively searches the entire lib directory for shared libraries
-                    std::vector<boost::filesystem::path> listSharedLibraries();
+                    std::vector<boost::filesystem::path> listSharedLibraries() const;

                    // search for executables and libraries and deploy their dependencies
                    // calling this function can turn sure file trees created by make install commands into working
                    // AppDirs
-                    bool deployDependenciesForExistingFiles();
+                    bool deployDependenciesForExistingFiles() const;
+
+                    // disable deployment of copyright files for this instance
+                    void setDisableCopyrightFilesDeployment(bool disable);
            };
        }
    }
@@ -1,71 +0,0 @@
-// system includes
-
-// library includes
-#include <boost/filesystem.hpp>
-
-#pragma once
-
-namespace linuxdeploy {
-    namespace core {
-        namespace desktopfile {
-            /*
-             * Parse and read desktop files.
-             */
-            class DesktopFile {
-                private:
-                    // private data class pattern
-                    class PrivateData;
-                    PrivateData* d;
-
-                public:
-                    // default constructor
-                    DesktopFile();
-
-                    // construct from existing desktop file
-                    // file must exist
-                    explicit DesktopFile(const boost::filesystem::path& path);
-
-                    // read desktop file
-                    // sets path associated with this file
-                    bool read(const boost::filesystem::path& path);
-
-                    // get path associated with this file
-                    boost::filesystem::path path() const;
-
-                    // sets the path associated with this desktop file
-                    // used to e.g., save the desktop file
-                    void setPath(const boost::filesystem::path& path);
-
-                    // clear contents of desktop file
-                    void clear();
-
-                    // save desktop file
-                    bool save() const;
-
-                    // save desktop file to path
-                    // does not change path associated with desktop file
-                    bool save(const boost::filesystem::path& path) const;
-
-                    // check if entry exists in given section and key
-                    bool entryExists(const std::string& section, const std::string& key) const;
-
-                    // get key from desktop file
-                    // an std::string passed as value parameter will be populated with the contents
-                    // returns true (and populates value) if the key exists, false otherwise
-                    bool getEntry(const std::string& section, const std::string& key, std::string& value) const;
-
-                    // add key to section in desktop file
-                    // the section will be created if it doesn't exist already
-                    // returns true if an existing key was overwritten, false otherwise
-                    bool setEntry(const std::string& section, const std::string& key, const std::string& value);
-
-                    // create common application entries in desktop file
-                    // returns false if one of the keys exists and was left unmodified
-                    bool addDefaultKeys(const std::string& executableFileName);
-
-                    // validate desktop file
-                    bool validate() const;
-            };
-        }
-    }
-}
@@ -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();
            };
        }
    }
@@ -65,6 +65,8 @@ namespace linuxdeploy {
                    ldLog operator<<(stdEndlType strm);
                    ldLog operator<<(const LD_LOGLEVEL logLevel);
                    ldLog operator<<(const LD_STREAM_CONTROL streamControl);
+
+                    void write(const char* s, const size_t n);
            };
        }
    }
@@ -2,14 +2,19 @@
 #include <set>
 #include <string>
 #include <vector>
+#include <fcntl.h>
+#include <poll.h>

 // library headers
 #include <boost/filesystem.hpp>
 #include <fnmatch.h>
-#include <subprocess.hpp>
+#include <thread>

 // local headers
 #include "linuxdeploy/core/log.h"
+#include "linuxdeploy/util/util.h"
+#include "linuxdeploy/subprocess/process.h"
+#include "linuxdeploy/plugin/plugin_process_handler.h"

 #pragma once

@@ -18,10 +23,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,17 +41,28 @@ namespace linuxdeploy {

                        apiLevel = getApiLevelFromExecutable();
                        pluginType = getPluginTypeFromExecutable();
+
+                        boost::cmatch res;
+                        boost::regex_match(path.filename().c_str(), res, PLUGIN_EXPR);
+                        name = res[1].str();
                    };

                private:
                    int getApiLevelFromExecutable() {
-                        auto output = subprocess::check_output({pluginPath.c_str(), "--plugin-api-version"});
-                        std::string stdoutOutput = output.buf.data();
+                        const auto arg =  "--plugin-api-version";
+
+                        const subprocess::subprocess proc({pluginPath.string(), arg});
+                        const auto stdoutOutput = proc.check_output();
+
+                        if (stdoutOutput.empty()) {
+                            ldLog() << LD_WARNING << "received empty response from plugin" << pluginPath << "while trying to fetch data for" <<  "--plugin-api-version" << std::endl;
+                            return -1;
+                        }

                        try {
                            auto apiLevel = std::stoi(stdoutOutput);
                            return apiLevel;
-                        } catch (const std::invalid_argument&) {
+                        } catch (const std::exception&) {
                            return -1;
                        }
                    }
@@ -54,9 +73,8 @@ namespace linuxdeploy {

                        // check whether plugin implements --plugin-type
                        try {
-                            auto output = subprocess::check_output({pluginPath.c_str(), "--plugin-type"});
-
-                            std::string stdoutOutput = output.buf.data();
+                            const subprocess::subprocess proc({pluginPath.c_str(), "--plugin-type"});
+                            const auto stdoutOutput = proc.check_output();

                            // the specification requires a single line, but we'll silently accept more than that, too
                            if (std::count(stdoutOutput.begin(), stdoutOutput.end(), '\n') >= 1) {
@@ -67,7 +85,7 @@ namespace linuxdeploy {
                                else if (firstLine == "output")
                                    type = OUTPUT_TYPE;
                            }
-                        } catch (const subprocess::CalledProcessError&) {}
+                        } catch (const std::logic_error&) {}

                        return type;
                    }
@@ -118,20 +136,8 @@ namespace linuxdeploy {

            template<int API_LEVEL>
            int PluginBase<API_LEVEL>::run(const boost::filesystem::path& appDirPath) {
-                auto pluginPath = path();
-                auto args = {pluginPath.c_str(), "--appdir", appDirPath.string().c_str()};
-
-                auto log = linuxdeploy::core::log::ldLog();
-                log << "Running process:";
-                for (const auto& arg : args) {
-                    log << "" << arg;
-                }
-                log << std::endl;
-
-                auto process = subprocess::Popen(args);
-
-                auto retcode = process.wait();
-                return retcode;
+                plugin_process_handler handler(d->name, path());
+                return handler.run(appDirPath);
            }
        }
    }
@@ -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.
         */
@@ -0,0 +1,19 @@
+#pragma once
+
+// library headers
+#include <boost/filesystem/path.hpp>
+
+namespace linuxdeploy {
+    namespace plugin {
+        class plugin_process_handler {
+        private:
+            std::string name_;
+            boost::filesystem::path path_;
+
+        public:
+            plugin_process_handler(std::string name, boost::filesystem::path path);
+
+            int run(const boost::filesystem::path& appDir) const;
+        };
+    }
+}
@@ -0,0 +1,36 @@
+#pragma once
+
+#include <string>
+#include <set>
+#include <vector>
+#include <poll.h>
+
+/**
+ * Reads from a pipe when data is available, and hands data to registered callbacks.
+ */
+class pipe_reader {
+private:
+    const int pipe_fd_;
+
+public:
+    /**
+     * Construct new instance from pipe file descriptor.
+     * @param pipe_fd file descriptor for pipe we will read from (e.g., a subprocess's stdout, stderr pipes)
+     */
+    explicit pipe_reader(int pipe_fd);
+
+    /**
+     * Read from pipe file descriptor and store data in buffer.
+     * This method is non-blocking, i.e., if there is no data to read, it returns immediately.
+     * Otherwise, it will read until either of the following conditions is met:
+     *
+     *     - no more data left in the pipe to be read
+     *     - buffer is completely filled
+     *
+     * On errors, a subprocess_error is thrown.
+     *
+     * @param buffer buffer to store read data into
+     * @returns amount of characters read from the pipe
+     */
+    size_t read(std::vector<std::string::value_type>& buffer) const;
+};
@@ -0,0 +1,86 @@
+// system headers
+#include <unordered_map>
+#include <vector>
+#include <signal.h>
+
+// local headers
+#include "linuxdeploy/subprocess/subprocess.h"
+
+namespace linuxdeploy {
+    namespace subprocess {
+        class process {
+        private:
+            // child process ID
+            int child_pid_ = -1;
+
+            // pipes to child process's stdout/stderr
+            int stdout_fd_ = -1;
+            int stderr_fd_ = -1;
+
+            // process exited
+            bool exited_ = false;
+            // exit code -- will be initialized by close()
+            int exit_code_ = -1;
+
+            // these constants help make the pipe code more readable
+            static constexpr int READ_END_ = 0, WRITE_END_ = 1;
+
+            static std::vector<char*> make_args_vector_(const std::vector<std::string>& args);
+
+            static std::vector<char*> make_env_vector_(const subprocess_env_map_t& env);
+
+            static int check_waitpid_status_(int status);
+
+        public:
+            /**
+             * Create a child process.
+             * @param args parameters for process
+             * @param env additional environment variables (current environment will be copied)
+             */
+            process(std::initializer_list<std::string> args, const subprocess_env_map_t& env);
+
+            /**
+             * Create a child process.
+             * @param args parameters for process
+             * @param env additional environment variables (current environment will be copied)
+             */
+            process(const std::vector<std::string>& args, const subprocess_env_map_t& env);
+
+            ~process();
+
+            /**
+             * @return child process's ID
+             */
+            int pid() const;
+
+            /**
+             * @return child process's stdout file descriptor ID
+             */
+            int stdout_fd() const;
+
+
+            /**
+             * @return child process's stderr file descriptor ID
+             */
+            int stderr_fd() const;
+
+            /**
+             * Close all pipes and wait for process to exit.
+             * If process is not running any more, just returns exit code.
+             * @return child process's exit code
+             */
+            int close();
+
+            /**
+             * Kill underlying process with given signal. By default, SIGTERM is used to end the process.
+             */
+            void kill(int signal = SIGTERM) const;
+
+            /**
+             * Check whether process is still alive. Use close() to fetch exit code.
+             * @return true while process is alive, false otherwise
+             */
+            bool is_running();
+        };
+    }
+}
@@ -0,0 +1,32 @@
+#pragma once
+
+// system headers
+#include <cstdio>
+#include <unordered_map>
+#include <string>
+#include <utility>
+#include <vector>
+
+// local headers
+#include "subprocess_result.h"
+
+namespace linuxdeploy {
+    namespace subprocess {
+        typedef std::unordered_map<std::string, std::string> subprocess_env_map_t;
+
+        class subprocess {
+        private:
+            std::vector<std::string> args_{};
+            std::unordered_map<std::string, std::string> env_{};
+
+        public:
+            subprocess(std::initializer_list<std::string> args, subprocess_env_map_t env = {});
+
+            explicit subprocess(std::vector<std::string> args, subprocess_env_map_t env = {});
+
+            subprocess_result run() const;
+
+            std::string check_output() const;
+        };
+    }
+}
@@ -0,0 +1,37 @@
+#pragma once
+
+// system headers
+#include <cstdlib>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace linuxdeploy {
+    namespace subprocess {
+        typedef std::vector<std::string::value_type> subprocess_result_buffer_t;
+
+        /**
+         * Result of subprocess execution. Follows Value Object design pattern.
+         */
+        class subprocess_result {
+        private:
+            int exit_code_;
+            subprocess_result_buffer_t stdout_contents_;
+            subprocess_result_buffer_t stderr_contents_;
+
+        public:
+            subprocess_result(int exit_code, subprocess_result_buffer_t stdout_contents,
+                              subprocess_result_buffer_t stderr_contents);
+
+            int exit_code() const;
+
+            const subprocess_result_buffer_t& stdout_contents() const;
+
+            std::string stdout_string() const;
+
+            const subprocess_result_buffer_t& stderr_contents() const;
+
+            std::string stderr_string() const;
+        };
+    }
+}
--- a/Show More
+++ b/Show More