cabriolet 0.1.0

data/lib/cabriolet/cab/extractor.rb

@@ -0,0 +1,357 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Cabriolet
+  module CAB
+    # Extractor handles the extraction of files from cabinets
+    class Extractor
+      attr_reader :io_system, :decompressor
+
+      # Initialize a new extractor
+      #
+      # @param io_system [System::IOSystem] I/O system
+      # @param decompressor [CAB::Decompressor] Parent decompressor
+      def initialize(io_system, decompressor)
+        @io_system = io_system
+        @decompressor = decompressor
+      end
+
+      # Extract a single file from the cabinet
+      #
+      # @param file [Models::File] File to extract
+      # @param output_path [String] Where to write the file
+      # @param options [Hash] Extraction options
+      # @option options [Boolean] :salvage Enable salvage mode
+      # @return [Integer] Number of bytes extracted
+      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
+
+        # Check for merge requirements
+        if folder.needs_prev_merge?
+          raise DecompressionError,
+                "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
+
+        # Create output directory if needed
+        output_dir = ::File.dirname(output_path)
+        FileUtils.mkdir_p(output_dir) unless ::File.directory?(output_dir)
+
+        # Create input wrapper that reads CFDATA blocks across cabinets
+        input_handle = BlockReader.new(@io_system, folder.data,
+                                       folder.num_blocks, salvage)
+
+        begin
+          # Create output file
+          output_fh = @io_system.open(output_path, Constants::MODE_WRITE)
+
+          begin
+            # Create decompressor
+            decomp = @decompressor.create_decompressor(folder, input_handle,
+                                                       output_fh)
+
+            # Skip to file offset if needed
+            if file.offset.positive?
+              # Decompress and discard bytes before file start
+              temp_output = System::MemoryHandle.new("", Constants::MODE_WRITE)
+              temp_decomp = @decompressor.create_decompressor(folder,
+                                                              input_handle, temp_output)
+              temp_decomp.decompress(file.offset)
+            end
+
+            # Decompress the file
+            decomp.decompress(filelen)
+
+            filelen
+          ensure
+            output_fh.close
+          end
+        ensure
+          input_handle.close
+        end
+      end
+
+      # Extract all files from a cabinet
+      #
+      # @param cabinet [Models::Cabinet] Cabinet to extract from
+      # @param output_dir [String] Directory to extract to
+      # @param options [Hash] Extraction options
+      # @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
+      # @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]
+
+        # Create output directory
+        FileUtils.mkdir_p(output_dir) unless ::File.directory?(output_dir)
+
+        count = 0
+        cabinet.files.each do |file|
+          # Determine output path
+          output_path = if preserve_paths
+                          ::File.join(output_dir, file.filename)
+                        else
+                          ::File.join(output_dir,
+                                      ::File.basename(file.filename))
+                        end
+
+          # Extract file
+          extract_file(file, output_path, **options)
+
+          # Set timestamp if requested
+          if set_timestamps && file.modification_time
+            ::File.utime(file.modification_time, file.modification_time,
+                         output_path)
+          end
+
+          # Set file permissions based on attributes
+          set_file_attributes(output_path, file)
+
+          count += 1
+          progress&.call(file, count, cabinet.files.size)
+        end
+
+        count
+      end
+
+      private
+
+      # Set file attributes based on CAB attributes
+      #
+      # @param path [String] File path
+      # @param file [Models::File] CAB file
+      def set_file_attributes(path, file)
+        # On Unix systems, set read-only if appropriate
+        return unless ::File.exist?(path)
+
+        if file.readonly?
+          # Make file read-only
+          ::File.chmod(0o444, path)
+        elsif file.executable?
+          # Make file executable
+          ::File.chmod(0o755, path)
+        else
+          # Default permissions
+          ::File.chmod(0o644, path)
+        end
+      rescue StandardError
+        # Ignore errors setting attributes
+        nil
+      end
+
+      # BlockReader wraps cabinet file handles and reads CFDATA blocks
+      # Handles multi-part cabinets by following the FolderData chain
+      class BlockReader
+        attr_reader :io_system, :current_data, :num_blocks, :salvage,
+                    :current_block
+
+        def initialize(io_system, folder_data, num_blocks, salvage)
+          @io_system = io_system
+          @current_data = folder_data
+          @num_blocks = num_blocks
+          @salvage = salvage
+          @current_block = 0
+          @buffer = ""
+          @buffer_pos = 0
+          @cab_handle = nil
+
+          # Open first cabinet and seek to data offset
+          open_current_cabinet
+        end
+
+        def read(bytes)
+          result = +""
+
+          while result.bytesize < bytes
+            # Read more data if buffer is empty
+            break if (@buffer_pos >= @buffer.bytesize) && !read_next_block
+
+            # Copy from buffer
+            available = @buffer.bytesize - @buffer_pos
+            to_copy = [available, bytes - result.bytesize].min
+
+            result << @buffer[@buffer_pos, to_copy]
+            @buffer_pos += to_copy
+          end
+
+          result
+        end
+
+        def seek(_offset, _whence)
+          # Not implemented for block reader
+          0
+        end
+
+        def tell
+          0
+        end
+
+        def close
+          @cab_handle&.close
+          @cab_handle = nil
+        end
+
+        private
+
+        def read_next_block
+          return false if @current_block >= @num_blocks
+
+          # Read blocks, potentially spanning multiple cabinets
+          accumulated_data = +""
+
+          loop do
+            # Read CFDATA header
+            header_data = @cab_handle.read(Constants::CFDATA_SIZE)
+            return false if header_data.bytesize != Constants::CFDATA_SIZE
+
+            cfdata = Binary::CFData.read(header_data)
+
+            # Skip reserved block data if present
+            if @current_data.cabinet.block_resv.positive?
+              @cab_handle.seek(@current_data.cabinet.block_resv, Constants::SEEK_CUR)
+            end
+
+            # Validate block sizes
+            unless @salvage
+              total_size = accumulated_data.bytesize + cfdata.compressed_size
+              if total_size > Constants::INPUT_MAX
+                raise DecompressionError,
+                      "Compressed block size exceeds maximum"
+              end
+
+              if cfdata.uncompressed_size > Constants::BLOCK_MAX
+                raise DecompressionError,
+                      "Uncompressed block size exceeds maximum"
+              end
+            end
+
+            # Read compressed data
+            compressed_data = @cab_handle.read(cfdata.compressed_size)
+            return false if compressed_data.bytesize != cfdata.compressed_size
+
+            # Verify checksum if present and not in salvage mode
+            if cfdata.checksum.positive? && !@salvage
+              # Calculate checksum of data
+              data_cksum = calculate_checksum(compressed_data)
+              # Calculate checksum of header fields (4 bytes starting at offset 4)
+              header_cksum = calculate_checksum(header_data[4, 4], data_cksum)
+
+              if header_cksum != cfdata.checksum
+                raise ChecksumError,
+                      "Block checksum mismatch"
+              end
+            end
+
+            # Accumulate data
+            accumulated_data << compressed_data
+
+            # If uncompressed_size is 0, this block continues in the next cabinet
+            break unless cfdata.uncompressed_size.zero?
+
+            # Move to next cabinet in the chain
+            unless advance_to_next_cabinet
+              raise DecompressionError,
+                    "Block continues but no next cabinet available"
+            end
+            # Continue reading the next part of the block
+
+            # This is the final part of the block
+          end
+
+          # Store in buffer
+          @buffer = accumulated_data
+          @buffer_pos = 0
+          @current_block += 1
+
+          true
+        end
+
+        def open_current_cabinet
+          @cab_handle&.close
+          @cab_handle = @io_system.open(@current_data.cabinet.filename, Constants::MODE_READ)
+          @cab_handle.seek(@current_data.offset, Constants::SEEK_START)
+        end
+
+        def advance_to_next_cabinet
+          # Move to next data segment
+          @current_data = @current_data.next_data
+          return false unless @current_data
+
+          # Open new cabinet file
+          open_current_cabinet
+          true
+        end
+
+        def calculate_checksum(data, initial = 0)
+          cksum = initial
+          bytes = data.bytes
+
+          # Process 4-byte chunks
+          (bytes.size / 4).times do |i|
+            offset = i * 4
+            value = bytes[offset] |
+              (bytes[offset + 1] << 8) |
+              (bytes[offset + 2] << 16) |
+              (bytes[offset + 3] << 24)
+            cksum ^= value
+          end
+
+          # Process remaining bytes
+          remainder = bytes.size % 4
+          if remainder.positive?
+            ul = 0
+            offset = bytes.size - remainder
+
+            case remainder
+            when 3
+              ul |= bytes[offset + 2] << 16
+              ul |= bytes[offset + 1] << 8
+              ul |= bytes[offset]
+            when 2
+              ul |= bytes[offset + 1] << 8
+              ul |= bytes[offset]
+            when 1
+              ul |= bytes[offset]
+            end
+
+            cksum ^= ul
+          end
+
+          cksum & 0xFFFFFFFF
+        end
+      end
+    end
+  end
+end

data/lib/cabriolet/cab/parser.rb

@@ -0,0 +1,264 @@
+# frozen_string_literal: true
+
+module Cabriolet
+  module CAB
+    # Parser reads and parses CAB file headers
+    class Parser
+      attr_reader :io_system
+
+      # Initialize a new parser
+      #
+      # @param io_system [System::IOSystem] I/O system for reading
+      def initialize(io_system)
+        @io_system = io_system
+      end
+
+      # Parse a CAB file and return a Cabinet model
+      #
+      # @param filename [String] Path to the CAB file
+      # @return [Models::Cabinet] Parsed cabinet
+      # @raise [ParseError] if the file is not a valid CAB
+      def parse(filename)
+        handle = @io_system.open(filename, Constants::MODE_READ)
+        cabinet = parse_handle(handle, filename)
+        @io_system.close(handle)
+        cabinet
+      end
+
+      # Parse a CAB from an already-open handle
+      #
+      # @param handle [System::FileHandle, System::MemoryHandle] Open handle
+      # @param filename [String] Filename for reference
+      # @param offset [Integer] Offset in file where cabinet starts
+      # @param salvage [Boolean] Enable salvage mode for corrupted files
+      # @param quiet [Boolean] Suppress error messages
+      # @return [Models::Cabinet] Parsed cabinet
+      # @raise [ParseError] if not a valid CAB
+      def parse_handle(handle, filename, offset = 0, salvage = false,
+quiet = false)
+        @salvage = salvage
+        @quiet = quiet
+
+        cabinet = Models::Cabinet.new(filename)
+        cabinet.base_offset = offset
+
+        # Seek to cabinet start
+        @io_system.seek(handle, offset, Constants::SEEK_START)
+
+        # Read and validate header
+        header, folder_resv = read_header(handle, cabinet)
+        validate_header(header)
+        populate_cabinet_from_header(handle, cabinet, header)
+
+        # Read folders
+        read_folders(handle, cabinet, header, folder_resv)
+
+        # Read files
+        read_files(handle, cabinet, header, salvage)
+
+        cabinet
+      end
+
+      private
+
+      def read_header(handle, cabinet)
+        header_data = @io_system.read(handle, Constants::CFHEADER_SIZE)
+        raise ParseError, "Cannot read CAB header" if header_data.bytesize < Constants::CFHEADER_SIZE
+
+        header = Binary::CFHeader.read(header_data)
+
+        folder_resv = 0
+
+        # Read reserved header if present
+        if header.flags.anybits?(Constants::FLAG_RESERVE_PRESENT)
+          resv_data = @io_system.read(handle, Constants::CFHEADER_EXT_SIZE)
+          if resv_data.bytesize < Constants::CFHEADER_EXT_SIZE
+            raise ParseError,
+                  "Cannot read reserved header"
+          end
+
+          # Parse reserved sizes
+          header_resv = resv_data.unpack1("v") # uint16 header_reserved
+          folder_resv = resv_data[2].ord # uint8 folder_reserved
+          data_resv = resv_data[3].ord # uint8 data_reserved
+
+          # Store reserved data size in cabinet
+          cabinet.set_blocks_info(0, data_resv)
+
+          # Skip reserved header data
+          if header_resv.positive?
+            @io_system.seek(handle, header_resv,
+                            Constants::SEEK_CUR)
+          end
+        end
+
+        [header, folder_resv]
+      end
+
+      def validate_header(header)
+        unless header.signature == "MSCF"
+          raise ParseError,
+                "Invalid CAB signature"
+        end
+
+        if !(header.major_version == 1 && header.minor_version == 3) && !@quiet
+          @io_system.message(nil, "WARNING; cabinet version is not 1.3")
+        end
+
+        if header.num_folders.zero?
+          @io_system.message(nil, "no folders in cabinet.") unless @quiet
+          raise ParseError, "No folders in cabinet"
+        end
+
+        return unless header.num_files.zero?
+
+        @io_system.message(nil, "no files in cabinet.") unless @quiet
+        raise ParseError, "No files in cabinet"
+      end
+
+      def populate_cabinet_from_header(handle, cabinet, header)
+        cabinet.length = header.cabinet_size
+        cabinet.set_id = header.set_id
+        cabinet.set_index = header.cabinet_index
+        cabinet.flags = header.flags
+
+        # Read previous cabinet metadata if present
+        if header.flags.anybits?(Constants::FLAG_PREV_CABINET)
+          cabinet.prevname = read_string(handle, false)
+          cabinet.previnfo = read_string(handle, true)
+        end
+
+        # Read next cabinet metadata if present
+        return unless header.flags.anybits?(Constants::FLAG_NEXT_CABINET)
+
+        cabinet.nextname = read_string(handle, false)
+        cabinet.nextinfo = read_string(handle, true)
+      end
+
+      def read_folders(handle, cabinet, header, folder_resv)
+        header.num_folders.times do
+          # Read folder structure
+          folder_data = @io_system.read(handle, Constants::CFFOLDER_SIZE)
+          if folder_data.bytesize < Constants::CFFOLDER_SIZE
+            raise ParseError,
+                  "Cannot read folder entry"
+          end
+
+          cf_folder = Binary::CFFolder.read(folder_data)
+
+          # Skip folder reserved space if present
+          if folder_resv.positive?
+            @io_system.seek(handle, folder_resv,
+                            Constants::SEEK_CUR)
+          end
+
+          # Create folder model with cabinet and offset
+          data_offset = cabinet.base_offset + cf_folder.data_offset
+          folder = Models::Folder.new(cabinet, data_offset)
+          folder.comp_type = cf_folder.comp_type
+          folder.num_blocks = cf_folder.num_blocks
+
+          # Add to cabinet
+          cabinet.folders << folder
+        end
+      end
+
+      def read_files(handle, cabinet, header, salvage = false)
+        header.num_files.times do
+          # Read file structure
+          file_data = @io_system.read(handle, Constants::CFFILE_SIZE)
+          raise ParseError, "Cannot read file entry" if file_data.bytesize < Constants::CFFILE_SIZE
+
+          cf_file = Binary::CFFile.read(file_data)
+
+          # Create file model
+          file = Models::File.new
+          file.length = cf_file.uncompressed_size
+          file.offset = cf_file.folder_offset
+          file.folder_index = cf_file.folder_index
+          file.attribs = cf_file.attribs
+
+          # Parse date and time
+          file.parse_datetime(cf_file.date, cf_file.time)
+
+          # Read filename
+          begin
+            file.filename = read_string(handle, false)
+          rescue ParseError
+            # In salvage mode, skip bad files
+            next if salvage
+
+            raise
+          end
+
+          # Link file to folder
+          begin
+            link_file_to_folder(file, cabinet, cf_file.folder_index,
+                                header.num_folders)
+          rescue ParseError
+            # In salvage mode, skip files with bad folder indices
+            next if salvage
+
+            raise
+          end
+
+          # Skip if folder linkage failed in salvage mode
+          next if file.folder.nil? && salvage
+
+          # Add to cabinet
+          cabinet.files << file
+        end
+
+        # Ensure we got at least some files
+        return unless cabinet.files.empty?
+
+        raise ParseError, "No valid files found in cabinet"
+      end
+
+      def link_file_to_folder(file, cabinet, folder_index, num_folders)
+        if folder_index < Constants::FOLDER_CONTINUED_FROM_PREV
+          # Normal folder index
+          unless folder_index < num_folders
+            raise ParseError,
+                  "Invalid folder index: #{folder_index}"
+          end
+
+          file.folder = cabinet.folders[folder_index]
+
+        elsif [Constants::FOLDER_CONTINUED_TO_NEXT, Constants::FOLDER_CONTINUED_PREV_AND_NEXT].include?(folder_index)
+          # File continues to next cabinet - use last folder
+          file.folder = cabinet.folders.last
+        elsif folder_index == Constants::FOLDER_CONTINUED_FROM_PREV
+          # File continues from previous cabinet - use first folder
+          file.folder = cabinet.folders.first
+        end
+      end
+
+      def read_string(handle, permit_empty)
+        # Save current position before reading
+        base_pos = @io_system.tell(handle)
+
+        # Read up to 256 bytes to find null terminator
+        buffer = @io_system.read(handle, 256)
+        raise ParseError, "Cannot read string" if buffer.nil? || buffer.empty?
+
+        # Find null terminator
+        null_pos = buffer.index("\x00")
+        raise ParseError, "String not null-terminated" if null_pos.nil?
+
+        if null_pos.zero? && !permit_empty
+          raise ParseError,
+                "Empty string not permitted"
+        end
+
+        # Extract string (without null terminator)
+        string = buffer[0...null_pos]
+
+        # Seek to position after null terminator (base_pos + null_pos + 1)
+        @io_system.seek(handle, base_pos + null_pos + 1, Constants::SEEK_START)
+
+        string
+      end
+    end
+  end
+end