cabriolet 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d301c701aa57d4033c110e9610d76f11e26ae3b8debd3a52d8a3df5ccb725905
-  data.tar.gz: d009c4741e7885ec25ad6766dd79158d1955b80ffc16e9acb0c5a0c1a813b9d0
+  metadata.gz: 9d2875b9afed58332c6e9823f3f383a60d802bac8514cb2015fdbd6a7f1559dc
+  data.tar.gz: 6979ce57ad3d47867bed19330d70b5db483bc33ac8920ee2986faa35828d6cbc
 SHA512:
-  metadata.gz: fd0314bf6196cad4749d2497ee639b7a355eab2a93a4a5e4967878e64cabd6413c08bbfab99aa767e67d1a13a0a3e7e428801819192c6506dba2dbf30f653b3d
-  data.tar.gz: dd1bb57af42a9cc7fa8556bd05632ce79b3b2a994d8276bee8349db7f10428e9d61f254ea8f928583dc8e7f0eca8e2bdd326fd137912fe5afc74c1b0b3f684da
+  metadata.gz: edd7b1345bee36e75fb5796a3840f087a9dfa51e41c599fa767938e8d64ab0abc985e563b9fb246fc86fc4798eb3f98539f774023eaf613f50a1c9e4a2a6d518
+  data.tar.gz: c5cfc76ae8dc5239efa9e90d0956d2518eab56c669d4b7e4087debc4955f509cc97440296c53084152cb30059b25044b6231cd9a84ee94e85f446a20f3306e08

data/lib/cabriolet/cab/extractor.rb

@@ -34,25 +34,7 @@ module Cabriolet
       def extract_file(file, output_path, **options)
         salvage = options[:salvage] || @decompressor.salvage
         folder = file.folder
-
-        # Validate file
-        raise Cabriolet::ArgumentError, "File has no folder" unless folder
-
-        if file.offset > Constants::LENGTH_MAX
-          raise DecompressionError,
-                "File offset beyond 2GB limit"
-        end
-
-        # Check file length
-        filelen = file.length
-        if filelen > (Constants::LENGTH_MAX - file.offset)
-          unless salvage
-            raise DecompressionError,
-                  "File length exceeds 2GB limit"
-          end
-
-          filelen = Constants::LENGTH_MAX - file.offset
-        end
+        filelen = validate_file_for_extraction(file, folder, salvage)
 
         # Check for merge requirements
         if folder.needs_prev_merge?
@@ -60,81 +42,22 @@ module Cabriolet
                 "File requires previous cabinet, cabinet set is incomplete"
         end
 
-        # Check file fits within folder
-        unless salvage
-          max_len = folder.num_blocks * Constants::BLOCK_MAX
-          if file.offset > max_len || filelen > (max_len - file.offset)
-            raise DecompressionError, "File extends beyond folder data"
-          end
-        end
+        validate_file_in_folder(folder, file.offset, filelen, salvage)
 
         # Create output directory if needed
         output_dir = ::File.dirname(output_path)
         FileUtils.mkdir_p(output_dir) unless ::File.directory?(output_dir)
 
-        # Check if we need to change folder or reset (libmspack lines 1076-1078)
-        if ENV["DEBUG_BLOCK"]
-          warn "DEBUG extract_file: Checking reset condition for file #{file.filename} (offset=#{file.offset}, length=#{file.length})"
-          warn "  @current_folder == folder: #{@current_folder == folder} (current=#{@current_folder.object_id}, new=#{folder.object_id})"
-          warn "  @current_offset (#{@current_offset}) > file.offset (#{file.offset}): #{@current_offset > file.offset}"
-          warn "  @current_decomp.nil?: #{@current_decomp.nil?}"
-          warn "  Reset needed?: #{@current_folder != folder || @current_offset > file.offset || !@current_decomp}"
-        end
-
-        if @current_folder != folder || @current_offset > file.offset || !@current_decomp
-          if ENV["DEBUG_BLOCK"]
-            warn "DEBUG extract_file: RESETTING state (creating new BlockReader)"
-          end
-
-          # Reset state
-          @current_input&.close
-          @current_input = nil
-          @current_decomp = nil
-
-          # Create new input (libmspack lines 1092-1095)
-          # This BlockReader will be REUSED across all files in this folder
-          @current_input = BlockReader.new(@io_system, folder.data,
-                                           folder.num_blocks, salvage)
-          @current_folder = folder
-          @current_offset = 0
-
-          # Create decompressor ONCE and reuse it (this is the key fix!)
-          # The decompressor maintains bitstream state across files
-          @current_decomp = @decompressor.create_decompressor(folder,
-                                                              @current_input, nil)
-        elsif ENV["DEBUG_BLOCK"]
-          warn "DEBUG extract_file: NOT resetting (reusing existing BlockReader and decompressor)"
-        end
-
-        # Skip ahead if needed (libmspack lines 1130-1134)
-        if file.offset > @current_offset
-          skip_bytes = file.offset - @current_offset
-
-          # Decompress with NULL output to skip (libmspack line 1130: self->d->outfh = NULL)
-          null_output = System::MemoryHandle.new("", Constants::MODE_WRITE)
-
-          # Reuse existing decompressor, change output to NULL
-          @current_decomp.instance_variable_set(:@output, null_output)
-
-          # Set output length for LZX frame limiting
-          @current_decomp.set_output_length(skip_bytes) if @current_decomp.respond_to?(:set_output_length)
-
-          @current_decomp.decompress(skip_bytes)
-          @current_offset += skip_bytes
-        end
+        setup_decompressor_for_folder(folder, salvage, file.offset)
+        skip_to_file_offset(file.offset, salvage, file.filename)
 
         # Extract actual file (libmspack lines 1137-1141)
         output_fh = @io_system.open(output_path, Constants::MODE_WRITE)
 
         begin
-          # Reuse existing decompressor, change output to real file
-          @current_decomp.instance_variable_set(:@output, output_fh)
-
-          # Set output length for LZX frame limiting
-          @current_decomp.set_output_length(filelen) if @current_decomp.respond_to?(:set_output_length)
-
-          @current_decomp.decompress(filelen)
-          @current_offset += filelen
+          write_file_data(output_fh, filelen)
+        rescue DecompressionError
+          handle_extraction_error(output_fh, output_path, file.filename, salvage, filelen)
         ensure
           output_fh.close
         end
@@ -142,6 +65,15 @@ module Cabriolet
         filelen
       end
 
+      # Reset extraction state (used in salvage mode to recover from errors)
+      def reset_state
+        @current_input&.close
+        @current_input = nil
+        @current_decomp = nil
+        @current_folder = nil
+        @current_offset = 0
+      end
+
       # Extract all files from a cabinet
       #
       # @param cabinet [Models::Cabinet] Cabinet to extract from
@@ -150,16 +82,19 @@ module Cabriolet
       # @option options [Boolean] :preserve_paths Preserve directory structure (default: true)
       # @option options [Boolean] :set_timestamps Set file modification times (default: true)
       # @option options [Proc] :progress Progress callback
+      # @option options [Boolean] :salvage Skip files that fail to extract (default: false)
       # @return [Integer] Number of files extracted
       def extract_all(cabinet, output_dir, **options)
         preserve_paths = options.fetch(:preserve_paths, true)
         set_timestamps = options.fetch(:set_timestamps, true)
         progress = options[:progress]
+        salvage = options[:salvage] || false
 
         # Create output directory
         FileUtils.mkdir_p(output_dir) unless ::File.directory?(output_dir)
 
         count = 0
+        failed_count = 0
         cabinet.files.each do |file|
           # Determine output path
           output_path = if preserve_paths
@@ -169,8 +104,18 @@ module Cabriolet
                                       ::File.basename(file.filename))
                         end
 
-          # Extract file
-          extract_file(file, output_path, **options)
+          # Extract file (skip if salvage mode and extraction fails)
+          begin
+            extract_file(file, output_path, **options)
+          rescue DecompressionError => e
+            if salvage
+              warn "Salvage: skipping #{file.filename}: #{e.message}"
+              failed_count += 1
+              next
+            else
+              raise
+            end
+          end
 
           # Set timestamp if requested
           if set_timestamps && file.modification_time
@@ -185,11 +130,148 @@ module Cabriolet
           progress&.call(file, count, cabinet.files.size)
         end
 
+        warn "Salvage: #{failed_count} file(s) skipped due to extraction errors" if failed_count.positive?
+
         count
       end
 
       private
 
+      # Validate file for extraction
+      #
+      # @param file [Models::File] File to validate
+      # @param folder [Models::Folder] Folder containing the file
+      # @param salvage [Boolean] Salvage mode flag
+      # @return [Integer] Validated file length
+      def validate_file_for_extraction(file, folder, salvage)
+        raise Cabriolet::ArgumentError, "File has no folder" unless folder
+
+        if file.offset > Constants::LENGTH_MAX
+          raise DecompressionError,
+                "File offset beyond 2GB limit"
+        end
+
+        filelen = file.length
+        if filelen > (Constants::LENGTH_MAX - file.offset)
+          unless salvage
+            raise DecompressionError,
+                  "File length exceeds 2GB limit"
+          end
+
+          filelen = Constants::LENGTH_MAX - file.offset
+        end
+
+        filelen
+      end
+
+      # Validate file fits within folder
+      #
+      # @param folder [Models::Folder] Folder to check
+      # @param file_offset [Integer] File offset
+      # @param filelen [Integer] File length
+      # @param salvage [Boolean] Salvage mode flag
+      def validate_file_in_folder(folder, file_offset, filelen, salvage)
+        return if salvage
+
+        max_len = folder.num_blocks * Constants::BLOCK_MAX
+        return unless file_offset > max_len || filelen > (max_len - file_offset)
+
+        raise DecompressionError, "File extends beyond folder data"
+      end
+
+      # Setup decompressor for folder
+      #
+      # @param folder [Models::Folder] Folder to setup for
+      # @param salvage [Boolean] Salvage mode flag
+      # @param file_offset [Integer] File offset for reset condition check
+      def setup_decompressor_for_folder(folder, salvage, file_offset)
+        if ENV["DEBUG_BLOCK"]
+          warn "DEBUG extract_file: Checking reset condition"
+          warn "  @current_folder == folder: #{@current_folder == folder}"
+          warn "  @current_offset (#{@current_offset}) > file_offset (#{file_offset})"
+          warn "  @current_decomp.nil?: #{@current_decomp.nil?}"
+        end
+
+        if @current_folder != folder || @current_offset > file_offset || !@current_decomp
+          if ENV["DEBUG_BLOCK"]
+            warn "DEBUG extract_file: RESETTING state (creating new BlockReader)"
+          end
+
+          # Reset state
+          @current_input&.close
+          @current_input = nil
+          @current_decomp = nil
+
+          # Create new input (libmspack lines 1092-1095)
+          @current_input = BlockReader.new(@io_system, folder.data,
+                                           folder.num_blocks, salvage)
+          @current_folder = folder
+          @current_offset = 0
+
+          # Create decompressor ONCE and reuse it
+          @current_decomp = @decompressor.create_decompressor(folder,
+                                                              @current_input, nil)
+        elsif ENV["DEBUG_BLOCK"]
+          warn "DEBUG extract_file: NOT resetting (reusing existing BlockReader)"
+        end
+      end
+
+      # Skip to file offset
+      #
+      # @param file_offset [Integer] Target offset
+      # @param salvage [Boolean] Salvage mode flag
+      # @param filename [String] Filename for error messages
+      def skip_to_file_offset(file_offset, salvage, filename)
+        return unless file_offset > @current_offset
+
+        skip_bytes = file_offset - @current_offset
+        null_output = System::MemoryHandle.new("", Constants::MODE_WRITE)
+
+        @current_decomp.instance_variable_set(:@output, null_output)
+        @current_decomp.set_output_length(skip_bytes) if @current_decomp.respond_to?(:set_output_length)
+
+        begin
+          @current_decomp.decompress(skip_bytes)
+        rescue DecompressionError
+          if salvage
+            warn "Salvage: unable to skip to file #{filename}, resetting state"
+            reset_state
+          else
+            raise
+          end
+        end
+        @current_offset += skip_bytes
+      end
+
+      # Write file data using decompressor
+      #
+      # @param output_fh [System::FileHandle] Output file handle
+      # @param filelen [Integer] Number of bytes to write
+      def write_file_data(output_fh, filelen)
+        @current_decomp.instance_variable_set(:@output, output_fh)
+        @current_decomp.set_output_length(filelen) if @current_decomp.respond_to?(:set_output_length)
+        @current_decomp.decompress(filelen)
+        @current_offset += filelen
+      end
+
+      # Handle extraction error
+      #
+      # @param output_fh [System::FileHandle] Output file handle
+      # @param output_path [String] Output file path
+      # @param filename [String] Filename for error messages
+      # @param salvage [Boolean] Salvage mode flag
+      # @raise [DecompressionError] If not in salvage mode
+      def handle_extraction_error(output_fh, output_path, filename, salvage, _filelen)
+        output_fh.close
+        if salvage
+          ::File.write(output_path, "", mode: "wb")
+          warn "Salvage: created empty file for #{filename} due to decompression error"
+          reset_state
+        else
+          raise
+        end
+      end
+
       # Set file attributes based on CAB attributes
       #
       # @param path [String] File path

data/lib/cabriolet/decompressors/lzx.rb

@@ -105,6 +105,9 @@ module Cabriolet
                      reset_interval: 0, output_length: 0, is_delta: false, salvage: false, **_kwargs)
         super(io_system, input, output, buffer_size)
 
+        # Store salvage flag for error handling
+        @salvage = salvage
+
         # Validate window_bits
         if is_delta
           unless (17..25).cover?(window_bits)
@@ -195,7 +198,17 @@ module Cabriolet
           frame_size = calculate_frame_size
 
           # Decode blocks until frame is complete
-          decode_frame(frame_size)
+          begin
+            decode_frame(frame_size)
+          rescue DecompressionError => e
+            # In salvage mode, if decompression fails, return what we have so far
+            if @salvage
+              warn "Salvage: LZX decompression failed at frame #{@frame}: #{e.message}"
+              return total_written
+            else
+              raise
+            end
+          end
 
           # Apply Intel E8 transformation if needed
           frame_data = if should_apply_e8_transform?(frame_size)
@@ -391,6 +404,35 @@ module Cabriolet
         @maintree = Huffman::Tree.new(@maintree_lengths, @maintree_maxsymbols,
                                       bit_order: :msb)
         unless @maintree.build_table(LENGTH_TABLEBITS)
+          # In salvage mode, try to build with a default distribution
+          if @salvage
+            # For a valid Huffman tree with @maintree_maxsymbols symbols and LENGTH_TABLEBITS=12,
+            # we need sum(2^(12-len)) = 4096 (for complete tree) or <= 4096 (for partial).
+            # For @maintree_maxsymbols = 784, we need to distribute symbols across lengths 8-10:
+            # Using: 128 at len8 (2048 slots) + 384 at len9 (768 slots) + 272 at len10 (256 slots)
+            # Total: 2048 + 768 + 256 = 3072 slots, leaving 1024 for longer codes
+            # Simpler: use lengths that sum to exactly 4096
+            # 784 symbols: distribute as 192 at len9, 592 at len10 = 384 + 592 = 976 (not enough)
+            # 784 symbols: distribute as 64 at len8, 576 at len9, 144 at len10 = 128 + 1152 + 144 = 1424
+            # Final: 784 symbols across lengths 8-11 to fill 4096 slots
+            # Verify: 64*128 + 384*64 + 256*32 + 80*16 = 8192 + 24576 + 8192 + 1280 = 42240 (wrong)
+
+            # Recalculate: 2^(12-len) slots needed per symbol
+            # len8: 16 slots/symbol, len9: 8 slots/symbol, len10: 4 slots/symbol, len11: 2 slots/symbol
+            # Total slots = sum(2^(12-len) for each symbol) must <= 4096
+            # Simple valid distribution for 784 symbols:
+            # 256 at len10 = 256*4 = 1024
+            # 528 at len12 = 528*1 = 528
+            # Total = 1552 (valid but incomplete tree)
+
+            default_main_lengths = []
+            256.times { default_main_lengths << 10 }
+            528.times { default_main_lengths << 12 }
+            @maintree_lengths = default_main_lengths
+            @maintree = Huffman::Tree.new(default_main_lengths, @maintree_maxsymbols,
+                                          bit_order: :msb)
+            return if @maintree.build_table(LENGTH_TABLEBITS)
+          end
           raise DecompressionError,
                 "Failed to build main tree"
         end
@@ -428,6 +470,22 @@ module Cabriolet
                                      bit_order: :msb)
         return if @pretree.build_table(PRETREE_TABLEBITS)
 
+        # In salvage mode, try to continue with a valid default tree
+        if @salvage
+          # For a valid Huffman tree with table_bits=6, we need exactly 64 slots.
+          # With 8 symbols at length 3: 8 * 2^(6-3) = 8 * 8 = 64 slots (complete)
+          # For simplicity: 8 at length 3 fills direct table (64 slots)
+          default_lengths = [
+            3, 3, 3, 3, 3, 3, 3, 3,  # 8 at length 3: fills 64 slots
+            7, 7, 7, 7, 7, 7, 7, 7,  # 8 at length 7: extended table
+            7, 7, 7, 7               # 4 at length 7: extended table
+          ]
+          @pretree_lengths = default_lengths
+          @pretree = Huffman::Tree.new(default_lengths, PRETREE_MAXSYMBOLS,
+                                       bit_order: :msb)
+          return if @pretree.build_table(PRETREE_TABLEBITS)
+        end
+
         raise DecompressionError, "Failed to build pretree"
       end
 

data/lib/cabriolet/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Cabriolet
-  VERSION = "0.2.1"
+  VERSION = "0.2.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cabriolet
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-01-17 00:00:00.000000000 Z
+date: 2026-02-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bindata