Merge branch 'develop'

.github/workflows/ctest.yml

@@ -0,0 +1,138 @@
+# This starter workflow is for a CMake project running on multiple platforms. There is a different starter workflow if you just want a single platform.
+# See: https://github.com/actions/starter-workflows/blob/main/ci/cmake-single-platform.yml
+name: Test bit7z on multiple configurations
+on: [pull_request, push]
+
+jobs:
+  build:
+    runs-on: ${{ matrix.os }}
+    if: |
+      github.event_name == 'pull_request'
+      || contains(github.event.head_commit.message, '[test]')
+      || startsWith(github.ref, 'refs/tags/v')
+
+    strategy:
+      # Set fail-fast to false to ensure that feedback is delivered for all matrix combinations. Consider changing this to true when your workflow is stable.
+      fail-fast: false
+
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+        build_type: [Debug, Release]
+        c_compiler: [gcc, clang, cl]
+        bit7z_auto_format: [OFF, ON]
+        bit7z_regex_matching: [OFF, ON]
+        bit7z_link_libcpp: [OFF, ON]
+        bit7z_use_native_string: [OFF, ON]
+        bit7z_auto_prefix_long_paths: [OFF, ON]
+        bit7z_use_system_codepage: [OFF, ON]
+        bit7z_path_sanitization: [OFF, ON]
+        include:
+          - os: windows-latest
+            c_compiler: cl
+            cpp_compiler: cl
+            use_system_7zip: ON
+          - os: ubuntu-latest
+            c_compiler: gcc
+            cpp_compiler: g++
+            use_system_7zip: OFF
+          - os: ubuntu-latest
+            c_compiler: clang
+            cpp_compiler: clang++
+            use_system_7zip: OFF
+          - os: macos-latest
+            c_compiler: clang
+            cpp_compiler: clang++
+            use_system_7zip: OFF
+        exclude:
+          - os: windows-latest
+            c_compiler: gcc
+          - os: windows-latest
+            c_compiler: clang
+          - os: windows-latest
+            bit7z_link_libcpp: ON
+          - os: ubuntu-latest
+            c_compiler: cl
+          - os: ubuntu-latest
+            c_compiler: gcc
+            bit7z_link_libcpp: ON
+          - os: ubuntu-latest
+            bit7z_use_native_string: ON
+          - os: ubuntu-latest
+            bit7z_auto_prefix_long_paths: ON
+          - os: ubuntu-latest
+            bit7z_use_system_codepage: ON
+          - os: ubuntu-latest
+            bit7z_path_sanitization: ON
+          - os: macos-latest
+            c_compiler: cl
+          - os: macos-latest
+            c_compiler: gcc
+          - os: macos-latest
+            bit7z_use_native_string: ON
+          - os: macos-latest
+            bit7z_auto_prefix_long_paths: ON
+          - os: macos-latest
+            bit7z_use_system_codepage: ON
+          - os: macos-latest
+            bit7z_path_sanitization: ON
+
+    steps:
+    - uses: actions/checkout@v3
+
+    - name: Set reusable strings
+      # Turn repeated input strings (such as the build output directory) into step outputs. These step outputs can be used throughout the workflow file.
+      id: strings
+      shell: bash
+      run: |
+        echo "build-output-dir=${{ github.workspace }}/build" >> "$GITHUB_OUTPUT"
+
+    - name: Configure CMake
+      # Configure CMake in a 'build' subdirectory. `CMAKE_BUILD_TYPE` is only required if you are using a single-configuration generator such as make.
+      # See https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html?highlight=cmake_build_type
+      run: >
+        cmake -B ${{ steps.strings.outputs.build-output-dir }}
+        -DCMAKE_CXX_COMPILER=${{ matrix.cpp_compiler }}
+        -DCMAKE_C_COMPILER=${{ matrix.c_compiler }}
+        -DCMAKE_BUILD_TYPE=${{ matrix.build_type }}
+        -DBIT7Z_BUILD_TESTS=ON
+        -DBIT7Z_ENABLE_SANITIZERS=ON
+        -DBIT7Z_TESTS_USE_SYSTEM_7ZIP=${{ matrix.use_system_7zip }}
+        -DBIT7Z_AUTO_FORMAT=${{ matrix.bit7z_auto_format }}
+        -DBIT7Z_REGEX_MATCHING=${{ matrix.bit7z_regex_matching }}
+        -DBIT7Z_USE_NATIVE_STRING=${{ matrix.bit7z_use_native_string }}
+        -DBIT7Z_LINK_LIBCPP=${{ matrix.bit7z_link_libcpp }}
+        -DBIT7Z_AUTO_PREFIX_LONG_PATHS=${{ matrix.bit7z_auto_prefix_long_paths }}
+        -DBIT7Z_USE_SYSTEM_CODEPAGE=${{ matrix.bit7z_use_system_codepage }}
+        -DBIT7Z_PATH_SANITIZATION=${{ matrix.bit7z_path_sanitization }}
+        -S ${{ github.workspace }}
+
+    - name: Build bit7z
+      # Build your program with the given configuration. Note that --config is needed because the default Windows generator is a multi-config generator (Visual Studio generator).
+      run: cmake --build ${{ steps.strings.outputs.build-output-dir }} --config ${{ matrix.build_type }} --parallel
+
+    - name: Build 7z.so for tests (Ubuntu)
+      shell: bash
+      if: matrix.os == 'ubuntu-latest'
+      run: |
+        git clone --depth 1 https://github.com/rikyoz/7-Zip ${{ github.workspace }}/../7-zip
+        cd ${{ github.workspace }}/../7-zip/CPP/7zip/Bundles/Format7zF/
+        make -j -f ../../cmpl_gcc.mak
+        cp b/g/7z.so ${{ github.workspace }}/bin/x64/7z.so
+        
+    - name: Build 7z.so for tests (macOS)
+      shell: bash
+      if: matrix.os == 'macos-latest'
+      run: |
+        git clone --depth 1 https://github.com/rikyoz/7-Zip ${{ github.workspace }}/../7-zip
+        cd ${{ github.workspace }}/../7-zip/CPP/7zip/Bundles/Format7zF/
+        make -j -f ../../cmpl_mac_x64.mak
+        cp b/m_x64/7z.so ${{ github.workspace }}/bin/x64/7z.so
+
+    - name: Test bit7z
+      working-directory: ${{ steps.strings.outputs.build-output-dir }}
+      # Disabling alloc_dealloc_mismatch for address sanitizer until https://github.com/llvm/llvm-project/issues/52771 is fixed
+      env:
+        ASAN_OPTIONS: alloc_dealloc_mismatch=0
+      # Execute tests defined by the CMake configuration. Note that --build-config is needed because the default Windows generator is a multi-config generator (Visual Studio generator).
+      # See https://cmake.org/cmake/help/latest/manual/ctest.1.html for more detail
+      run: ctest --build-target bit7z-tests --build-config ${{ matrix.build_type }} --output-on-failure

CMakeLists.txt

@@ -5,7 +5,7 @@
 cmake_minimum_required( VERSION 3.11 )
 
 project( bit7z
-         VERSION 4.0.3
+         VERSION 4.0.4
          DESCRIPTION "A C++ static library offering a clean and simple interface to the 7-zip/p7zip shared libraries"
          HOMEPAGE_URL "https://github.com/rikyoz/bit7z/" )
 set( CMAKE_VERBOSE_MAKEFILE ON CACHE BOOL "ON" )
@@ -95,6 +95,7 @@ set( HEADERS
      src/internal/stdinputitem.hpp
      src/internal/streamextractcallback.hpp
      src/internal/streamutil.hpp
+     src/internal/stringutil.hpp
      src/internal/updatecallback.hpp
      src/internal/util.hpp
      src/internal/windows.hpp )
@@ -156,8 +157,8 @@ set( SOURCES
      src/internal/renameditem.cpp
      src/internal/stdinputitem.cpp
      src/internal/streamextractcallback.cpp
+     src/internal/stringutil.cpp
      src/internal/updatecallback.cpp
-     src/internal/util.cpp
      src/internal/windows.cpp )
 
 # library output file name options
@@ -228,6 +229,9 @@ if( UNIX )
     target_link_libraries( ${LIB_TARGET} PUBLIC ${CMAKE_DL_LIBS} )
 endif()
 
+# sanitizers
+include( cmake/Sanitizers.cmake )
+
 # tests
 if( BIT7Z_BUILD_TESTS )
     enable_testing()

cmake/CompilerOptions.cmake

@@ -68,7 +68,7 @@ if( MSVC )
         endforeach()
     endif()
 else()
-    target_compile_options( ${LIB_TARGET} PRIVATE -Wall -Wextra -Werror )
+    target_compile_options( ${LIB_TARGET} PRIVATE -Wall -Wextra -Werror -Wconversion -Wsign-conversion )
 endif()
 
 # Extra warning flags for Clang
@@ -122,6 +122,6 @@ if( CMAKE_CXX_COMPILER_ID MATCHES "GNU" )
     endif()
     if( CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 7.0 )
         # Extra warning flags for GCC 7.0+
-        target_compile_options( ${LIB_TARGET} PRIVATE -Wduplicated-branches )
+        target_compile_options( ${LIB_TARGET} PRIVATE -Wduplicated-branches -Wrestrict )
     endif()
 endif()

cmake/Dependencies.cmake

@@ -1,11 +1,14 @@
 # Downloading the CPM.cmake package manager
-set( CPM_DOWNLOAD_VERSION 0.38.5 )
+set( CPM_DOWNLOAD_VERSION 0.38.6 )
+set( CPM_DOWNLOAD_HASH 11c3fa5f1ba14f15d31c2fb63dbc8628ee133d81c8d764caad9a8db9e0bacb07 )
 set( CPM_DOWNLOAD_LOCATION "${CMAKE_BINARY_DIR}/cmake/CPM_${CPM_DOWNLOAD_VERSION}.cmake" )
-if( NOT ( EXISTS ${CPM_DOWNLOAD_LOCATION} ))
+if( NOT ( EXISTS ${CPM_DOWNLOAD_LOCATION} ) )
     message( STATUS "Downloading CPM.cmake to ${CPM_DOWNLOAD_LOCATION}" )
     file( DOWNLOAD
           https://github.com/cpm-cmake/CPM.cmake/releases/download/v${CPM_DOWNLOAD_VERSION}/CPM.cmake
           ${CPM_DOWNLOAD_LOCATION}
+          SHOW_PROGRESS
+          EXPECTED_HASH SHA256=${CPM_DOWNLOAD_HASH}
     )
 endif()
 include( ${CPM_DOWNLOAD_LOCATION} )

cmake/Sanitizers.cmake

@@ -0,0 +1,54 @@
+macro( add_sanitizer name )
+    set( CMAKE_REQUIRED_FLAGS "-fsanitize=${name}" )
+    check_cxx_compiler_flag( -fsanitize=${name} COMPILER_SUPPORTS_SANITIZE_${name} )
+    if( COMPILER_SUPPORTS_SANITIZE_${name} )
+        message( STATUS "Supported sanitizer: ${name}" )
+        set( CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fsanitize=${name}" )
+    else()
+        message( STATUS "Unsupported sanitizer: ${name}" )
+    endif()
+    unset( CMAKE_REQUIRED_FLAGS )
+endmacro()
+
+option( BIT7Z_ENABLE_SANITIZERS "Enable or disable compiling with sanitizers" )
+message( STATUS "Enable sanitizers: ${BIT7Z_ENABLE_SANITIZERS}" )
+if ( BIT7Z_ENABLE_SANITIZERS )
+    if( MSVC )
+        set( CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /RTCsu /analyze /guard:cf" )
+    elseif( NOT WIN32 ) # GCC/Clang on Linux/macOS (i.e., not MinGW)
+        set( CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fno-omit-frame-pointer" )
+
+        if( CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "6.0.0" )
+            set( CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -static-libsan" )
+        endif()
+
+        # Use the highest stack protection level supported by the target toolchain.
+        include( CheckCXXCompilerFlag )
+        check_cxx_compiler_flag( -fstack-protector-strong COMPILER_SUPPORT_STRONG_STACK_PROTECTOR )
+        check_cxx_compiler_flag( -fstack-protector COMPILER_SUPPORT_STACK_PROTECTOR )
+        if( COMPILER_SUPPORT_STRONG_STACK_PROTECTOR )
+            set( CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_DEBUG} -fstack-protector-strong" )
+        elseif( COMPILER_SUPPORT_STACK_PROTECTOR )
+            set( CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_DEBUG} -fstack-protector" )
+        endif()
+
+        # For some reasons, the address sanitizer gives a CHECK failed error on versions of Clang before the 3.9
+        # Also, on old versions of GCC the sanitizer give some false positives.
+        if( ( NOT CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "5.0" ) OR
+            ( CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "3.9.0" ) )
+            add_sanitizer( address )
+            check_cxx_compiler_flag( -fsanitize-address-use-after-scope COMPILER_SUPPORT_SANITIZE_USE_AFTER_SCOPE )
+            if( COMPILER_SUPPORT_SANITIZE_USE_AFTER_SCOPE )
+                set( CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fsanitize-address-use-after-scope" )
+            endif()
+        endif()
+
+        add_sanitizer( float-divide-by-zero )
+        add_sanitizer( implicit-conversion )
+        add_sanitizer( integer )
+        add_sanitizer( leak )
+        add_sanitizer( local-bounds )
+        add_sanitizer( nullability )
+        add_sanitizer( undefined )
+    endif()
+endif()

src/bit7zlibrary.cpp

@@ -13,8 +13,9 @@
 #include "bit7zlibrary.hpp"
 #include "bitexception.hpp"
 #include "bitformat.hpp"
+#include "internal/com.hpp"
 #include "internal/guids.hpp"
-#include "internal/util.hpp"
+#include "internal/stringutil.hpp"
 
 #include <7zip/Archive/IArchive.h>
 

src/bitabstractarchivecreator.cpp

@@ -106,7 +106,7 @@ auto method_name( BitCompressionMethod method ) noexcept -> const wchar_t* {
         case BitCompressionMethod::Deflate64:
             return L"Deflate64";
         default:
-            return L"Unknown"; //this should not happen!
+            return L"Unknown"; // This should not happen.
     }
 }
 
@@ -185,7 +185,7 @@ void BitAbstractArchiveCreator::setPassword( const tstring& password ) {
 auto is_ascii( const tstring& str ) -> bool {
     return std::all_of( str.begin(), str.end(), []( tchar character ) -> bool {
         // Note: 7-zip supports the DEL character (code 127), while bit7z doesn't.
-        constexpr auto kFirstAsciiChar = 32; // A
+        constexpr auto kFirstAsciiChar = 32; // Space character
         constexpr auto kLastAsciiChar = 127;
         return character >= kFirstAsciiChar && character < kLastAsciiChar;
     } );
@@ -199,7 +199,7 @@ void BitAbstractArchiveCreator::setPassword( const tstring& password, bool crypt
     }
 #endif
     BitAbstractArchiveHandler::setPassword( password );
-    mCryptHeaders = ( password.length() > 0 ) && cryptHeaders;
+    mCryptHeaders = !password.empty() && cryptHeaders;
 }
 
 void BitAbstractArchiveCreator::setCompressionLevel( BitCompressionLevel level ) noexcept {
@@ -216,7 +216,7 @@ void BitAbstractArchiveCreator::setCompressionMethod( BitCompressionMethod metho
     if ( mFormat.hasFeature( FormatFeatures::MultipleMethods ) ) {
         /* even though the compression method is valid, we set it only if the format supports
          * different methods than the default one (i.e., setting BitCompressionMethod::BZip2
-         * of a BitFormat::BZip2 archive does nothing!) */
+         * of a BitFormat::BZip2 archive does nothing) */
         mCompressionMethod = method;
         mDictionarySize = 0; //reset dictionary size to default value for the method
         mWordSize = 0; //reset word size to default value for the method

src/bitarchiveeditor.cpp

@@ -18,7 +18,7 @@
 #include "internal/fsitem.hpp"
 #include "internal/renameditem.hpp"
 #include "internal/stdinputitem.hpp"
-#include "internal/util.hpp"
+#include "internal/stringutil.hpp"
 
 namespace bit7z {
 
@@ -51,43 +51,43 @@ BitArchiveEditor::~BitArchiveEditor() = default;
 
 void BitArchiveEditor::renameItem( uint32_t index, const tstring& newPath ) {
     checkIndex( index );
-    mEditedItems[ index ] = std::make_unique< RenamedItem >( *inputArchive(), index, newPath );
+    mEditedItems[ index ] = std::make_unique< RenamedItem >( *inputArchive(), index, newPath ); //-V108
 }
 
 void BitArchiveEditor::renameItem( const tstring& oldPath, const tstring& newPath ) {
     auto index = findItem( oldPath );
-    mEditedItems[ index ] = std::make_unique< RenamedItem >( *inputArchive(), index, newPath );
+    mEditedItems[ index ] = std::make_unique< RenamedItem >( *inputArchive(), index, newPath ); //-V108
 }
 
 void BitArchiveEditor::updateItem( uint32_t index, const tstring& inFile ) {
     checkIndex( index );
     auto itemName = inputArchive()->itemProperty( index, BitProperty::Path );
-    mEditedItems[ index ] = std::make_unique< FilesystemItem >( tstring_to_path( inFile ), itemName.getNativeString() );
+    mEditedItems[ index ] = std::make_unique< FilesystemItem >( tstring_to_path( inFile ), itemName.getNativeString() ); //-V108
 }
 
 void BitArchiveEditor::updateItem( uint32_t index, const std::vector< byte_t >& inBuffer ) {
     checkIndex( index );
     auto itemName = inputArchive()->itemProperty( index, BitProperty::Path );
-    mEditedItems[ index ] = std::make_unique< BufferItem >( inBuffer, itemName.getNativeString() );
+    mEditedItems[ index ] = std::make_unique< BufferItem >( inBuffer, itemName.getNativeString() ); //-V108
 }
 
 void BitArchiveEditor::updateItem( uint32_t index, std::istream& inStream ) {
     checkIndex( index );
     auto itemName = inputArchive()->itemProperty( index, BitProperty::Path );
-    mEditedItems[ index ] = std::make_unique< StdInputItem >( inStream, itemName.getNativeString() );
+    mEditedItems[ index ] = std::make_unique< StdInputItem >( inStream, itemName.getNativeString() ); //-V108
 }
 
 void BitArchiveEditor::updateItem( const tstring& itemPath, const tstring& inFile ) {
-    mEditedItems[ findItem( itemPath ) ] = std::make_unique< FilesystemItem >( tstring_to_path( inFile ),
+    mEditedItems[ findItem( itemPath ) ] = std::make_unique< FilesystemItem >( tstring_to_path( inFile ), //-V108
                                                                                tstring_to_path( itemPath ) );
 }
 
 void BitArchiveEditor::updateItem( const tstring& itemPath, const std::vector< byte_t >& inBuffer ) {
-    mEditedItems[ findItem( itemPath ) ] = std::make_unique< BufferItem >( inBuffer, itemPath );
+    mEditedItems[ findItem( itemPath ) ] = std::make_unique< BufferItem >( inBuffer, itemPath ); //-V108
 }
 
 void BitArchiveEditor::updateItem( const tstring& itemPath, std::istream& inStream ) {
-    mEditedItems[ findItem( itemPath ) ] = std::make_unique< StdInputItem >( inStream, itemPath );
+    mEditedItems[ findItem( itemPath ) ] = std::make_unique< StdInputItem >( inStream, itemPath ); //-V108
 }
 
 void BitArchiveEditor::deleteItem( uint32_t index ) {

src/bitarchiveitem.cpp

@@ -12,7 +12,7 @@
 
 #include "bitarchiveitem.hpp"
 #include "internal/fsutil.hpp"
-#include "internal/util.hpp"
+#include "internal/stringutil.hpp"
 
 // For checking posix file attributes
 #include <sys/stat.h>