cabriolet 0.1.0

data/lib/cabriolet/oab/compressor.rb

@@ -0,0 +1,353 @@
+# frozen_string_literal: true
+
+require "zlib"
+
+module Cabriolet
+  module OAB
+    # Compressor for OAB (Outlook Offline Address Book) files
+    #
+    # OAB files use LZX compression. This compressor can create:
+    # - Full files (version 3.1): Complete address book data
+    # - Incremental patches (version 3.2): Binary patches (simplified)
+    #
+    # NOTE: This implementation is based on the OAB format specification
+    # derived from libmspack's decompressor. The original libmspack does not
+    # implement OAB compression. This is a best-effort implementation that
+    # may not produce files identical to Microsoft's OAB generator.
+    class Compressor
+      attr_reader :io_system
+      attr_accessor :buffer_size, :block_size
+
+      # Default buffer size for I/O operations
+      DEFAULT_BUFFER_SIZE = 4096
+
+      # Default block size (use 32KB like LZX frames)
+      DEFAULT_BLOCK_SIZE = 32_768
+
+      # OAB version numbers
+      VERSION_HI = 3
+      VERSION_LO_FULL = 1
+      VERSION_LO_PATCH = 2
+
+      # Initialize OAB compressor
+      #
+      # @param io_system [System::IOSystem, nil] I/O system or nil for default
+      def initialize(io_system = nil)
+        @io_system = io_system || System::IOSystem.new
+        @buffer_size = DEFAULT_BUFFER_SIZE
+        @block_size = DEFAULT_BLOCK_SIZE
+      end
+
+      # Compress a full OAB file
+      #
+      # @param input_file [String] Input file path
+      # @param output_file [String] Compressed OAB output path
+      # @param options [Hash] Compression options
+      # @option options [Integer] :block_size Block size (default: 32KB)
+      # @return [Integer] Bytes written
+      # @raise [Error] if compression fails
+      def compress(input_file, output_file, **options)
+        block_size = options.fetch(:block_size, @block_size)
+
+        input_handle = @io_system.open(input_file, Constants::MODE_READ)
+        output_handle = @io_system.open(output_file, Constants::MODE_WRITE)
+
+        begin
+          # Get input size
+          input_size = @io_system.seek(input_handle, 0, Constants::SEEK_END)
+          @io_system.seek(input_handle, 0, Constants::SEEK_START)
+
+          # Write header
+          header = Binary::OABStructures::FullHeader.new
+          header.version_hi = VERSION_HI
+          header.version_lo = VERSION_LO_FULL
+          header.block_max = block_size
+          header.target_size = input_size
+
+          header_data = header.to_binary_s
+          bytes_written = @io_system.write(output_handle, header_data)
+
+          # Compress data in blocks
+          remaining = input_size
+          while remaining.positive?
+            block_bytes = compress_block(
+              input_handle, output_handle, block_size, remaining
+            )
+            bytes_written += block_bytes
+            remaining -= [block_size, remaining].min
+          end
+
+          bytes_written
+        ensure
+          @io_system.close(input_handle) if input_handle
+          @io_system.close(output_handle) if output_handle
+        end
+      end
+
+      # Compress data from memory to OAB format
+      #
+      # @param data [String] Input data to compress
+      # @param output_file [String] Compressed OAB output path
+      # @param options [Hash] Compression options
+      # @option options [Integer] :block_size Block size (default: 32KB)
+      # @return [Integer] Bytes written
+      # @raise [Error] if compression fails
+      def compress_data(data, output_file, **options)
+        block_size = options.fetch(:block_size, @block_size)
+
+        input_handle = System::MemoryHandle.new(data, Constants::MODE_READ)
+        output_handle = @io_system.open(output_file, Constants::MODE_WRITE)
+
+        begin
+          # Write header
+          header = Binary::OABStructures::FullHeader.new
+          header.version_hi = VERSION_HI
+          header.version_lo = VERSION_LO_FULL
+          header.block_max = block_size
+          header.target_size = data.bytesize
+
+          header_data = header.to_binary_s
+          bytes_written = @io_system.write(output_handle, header_data)
+
+          # Compress data in blocks
+          remaining = data.bytesize
+          while remaining.positive?
+            block_bytes = compress_block(
+              input_handle, output_handle, block_size, remaining
+            )
+            bytes_written += block_bytes
+            remaining -= [block_size, remaining].min
+          end
+
+          bytes_written
+        ensure
+          @io_system.close(output_handle) if output_handle
+        end
+      end
+
+      # Create an incremental patch (simplified implementation)
+      #
+      # This is a simplified patch format that just stores the new data
+      # compressed. A full implementation would generate binary diffs.
+      #
+      # @param input_file [String] New version file path
+      # @param base_file [String] Base version file path
+      # @param output_file [String] Patch output path
+      # @param options [Hash] Compression options
+      # @option options [Integer] :block_size Block size (default: 32KB)
+      # @return [Integer] Bytes written
+      # @raise [Error] if compression fails
+      def compress_incremental(input_file, base_file, output_file, **options)
+        block_size = options.fetch(:block_size, @block_size)
+
+        # For now, just compress the new file with patch header
+        # A full implementation would generate binary diffs
+        input_handle = @io_system.open(input_file, Constants::MODE_READ)
+        base_handle = @io_system.open(base_file, Constants::MODE_READ)
+        output_handle = @io_system.open(output_file, Constants::MODE_WRITE)
+
+        begin
+          # Get file sizes
+          input_size = @io_system.seek(input_handle, 0, Constants::SEEK_END)
+          @io_system.seek(input_handle, 0, Constants::SEEK_START)
+
+          base_size = @io_system.seek(base_handle, 0, Constants::SEEK_END)
+          @io_system.seek(base_handle, 0, Constants::SEEK_START)
+
+          # Read base data for CRC
+          base_data = @io_system.read(base_handle, base_size)
+          base_crc = Zlib.crc32(base_data)
+
+          # Read target data for CRC
+          target_data = @io_system.read(input_handle, input_size)
+          @io_system.seek(input_handle, 0, Constants::SEEK_START)
+          target_crc = Zlib.crc32(target_data)
+
+          # Write patch header
+          header = Binary::OABStructures::PatchHeader.new
+          header.version_hi = VERSION_HI
+          header.version_lo = VERSION_LO_PATCH
+          header.block_max = [block_size, 16].max
+          header.source_size = base_size
+          header.target_size = input_size
+          header.source_crc = base_crc
+          header.target_crc = target_crc
+
+          header_data = header.to_binary_s
+          bytes_written = @io_system.write(output_handle, header_data)
+
+          # Compress data in blocks (simplified - not true patches)
+          remaining = input_size
+          while remaining.positive?
+            block_bytes = compress_patch_block(
+              input_handle, output_handle, block_size, remaining, 0
+            )
+            bytes_written += block_bytes
+            remaining -= [block_size, remaining].min
+          end
+
+          bytes_written
+        ensure
+          @io_system.close(input_handle) if input_handle
+          @io_system.close(base_handle) if base_handle
+          @io_system.close(output_handle) if output_handle
+        end
+      end
+
+      private
+
+      # Compress a single block
+      #
+      # @param input_handle [System::FileHandle] Input file handle
+      # @param output_handle [System::FileHandle] Output file handle
+      # @param block_max [Integer] Maximum block size
+      # @param remaining [Integer] Remaining bytes
+      # @return [Integer] Bytes written
+      def compress_block(input_handle, output_handle, block_max, remaining)
+        # Read block data
+        block_size = [block_max, remaining].min
+        block_data = @io_system.read(input_handle, block_size)
+
+        if block_data.length < block_size
+          raise Error,
+                "Failed to read block data"
+        end
+
+        # Try LZX compression
+        compressed_data = compress_with_lzx(block_data)
+
+        # Use uncompressed if compression doesn't help
+        if compressed_data.nil? || compressed_data.bytesize >= block_data.bytesize
+          # Write uncompressed block
+          write_uncompressed_block(output_handle, block_data)
+        else
+          # Write compressed block
+          write_compressed_block(output_handle, block_data, compressed_data)
+        end
+      end
+
+      # Compress a single patch block (simplified)
+      #
+      # @param input_handle [System::FileHandle] Input file handle
+      # @param output_handle [System::FileHandle] Output file handle
+      # @param block_max [Integer] Maximum block size
+      # @param remaining [Integer] Remaining bytes
+      # @param source_size [Integer] Source block size (0 for simplified)
+      # @return [Integer] Bytes written
+      def compress_patch_block(input_handle, output_handle, block_max,
+                               remaining, source_size)
+        # Read block data
+        block_size = [block_max, remaining].min
+        block_data = @io_system.read(input_handle, block_size)
+
+        if block_data.length < block_size
+          raise Error,
+                "Failed to read patch block data"
+        end
+
+        # Try LZX compression
+        compressed_data = compress_with_lzx(block_data)
+
+        # Use compressed data (or original if compression fails)
+        patch_data = compressed_data && compressed_data.bytesize < block_data.bytesize ? compressed_data : block_data
+        patch_size = patch_data.bytesize
+
+        # Calculate CRC
+        crc = Zlib.crc32(block_data)
+
+        # Write patch block header
+        block_header = Binary::OABStructures::PatchBlockHeader.new
+        block_header.patch_size = patch_size
+        block_header.target_size = block_size
+        block_header.source_size = source_size
+        block_header.crc = crc
+
+        header_data = block_header.to_binary_s
+        bytes_written = @io_system.write(output_handle, header_data)
+
+        # Write patch data
+        bytes_written += @io_system.write(output_handle, patch_data)
+
+        bytes_written
+      end
+
+      # Compress data using LZX
+      #
+      # @param data [String] Data to compress
+      # @return [String, nil] Compressed data or nil if compression failed
+      def compress_with_lzx(data)
+        return nil if data.empty?
+
+        # Calculate window bits for this block
+        window_bits = 17
+        window_bits += 1 while window_bits < 25 && (1 << window_bits) < data.bytesize
+
+        # Create memory handles
+        input_mem = System::MemoryHandle.new(data, Constants::MODE_READ)
+        output_mem = System::MemoryHandle.new("", Constants::MODE_WRITE)
+
+        # Compress with LZX
+        compressor = Compressors::LZX.new(
+          @io_system, input_mem, output_mem, @buffer_size,
+          window_bits: window_bits
+        )
+
+        compressor.compress
+
+        output_mem.data
+      rescue StandardError => e
+        warn "[Cabriolet] LZX compression failed: #{e.message}" if Cabriolet.verbose
+        nil
+      end
+
+      # Write uncompressed block
+      #
+      # @param output_handle [System::FileHandle] Output file handle
+      # @param block_data [String] Block data
+      # @return [Integer] Bytes written
+      def write_uncompressed_block(output_handle, block_data)
+        crc = Zlib.crc32(block_data)
+
+        # Write block header
+        block_header = Binary::OABStructures::BlockHeader.new
+        block_header.flags = 0 # Uncompressed
+        block_header.compressed_size = block_data.bytesize
+        block_header.uncompressed_size = block_data.bytesize
+        block_header.crc = crc
+
+        header_data = block_header.to_binary_s
+        bytes_written = @io_system.write(output_handle, header_data)
+
+        # Write block data
+        bytes_written += @io_system.write(output_handle, block_data)
+
+        bytes_written
+      end
+
+      # Write compressed block
+      #
+      # @param output_handle [System::FileHandle] Output file handle
+      # @param original_data [String] Original uncompressed data
+      # @param compressed_data [String] Compressed data
+      # @return [Integer] Bytes written
+      def write_compressed_block(output_handle, original_data, compressed_data)
+        crc = Zlib.crc32(original_data)
+
+        # Write block header
+        block_header = Binary::OABStructures::BlockHeader.new
+        block_header.flags = 1 # LZX compressed
+        block_header.compressed_size = compressed_data.bytesize
+        block_header.uncompressed_size = original_data.bytesize
+        block_header.crc = crc
+
+        header_data = block_header.to_binary_s
+        bytes_written = @io_system.write(output_handle, header_data)
+
+        # Write compressed data
+        bytes_written += @io_system.write(output_handle, compressed_data)
+
+        bytes_written
+      end
+    end
+  end
+end

data/lib/cabriolet/oab/decompressor.rb

@@ -0,0 +1,315 @@
+# frozen_string_literal: true
+
+require "zlib"
+
+module Cabriolet
+  module OAB
+    # Decompressor for OAB (Outlook Offline Address Book) files
+    #
+    # OAB files use LZX compression and come in two formats:
+    # - Full files (version 3.1): Complete address book data
+    # - Incremental patches (version 3.2): Binary patches applied to base file
+    #
+    # This implementation is based on libmspack's oabd.c
+    #
+    # NOTE: This implementation cannot be fully validated due to lack of test
+    # fixtures. OAB files are specialized Outlook data files. Testing relies
+    # on round-trip compression/decompression.
+    class Decompressor
+      attr_reader :io_system
+      attr_accessor :buffer_size
+
+      # Default buffer size for I/O operations
+      DEFAULT_BUFFER_SIZE = 4096
+
+      # Initialize OAB decompressor
+      #
+      # @param io_system [System::IOSystem, nil] I/O system or nil for default
+      def initialize(io_system = nil)
+        @io_system = io_system || System::IOSystem.new
+        @buffer_size = DEFAULT_BUFFER_SIZE
+      end
+
+      # Decompress a full OAB file
+      #
+      # @param input_file [String] Compressed OAB file path
+      # @param output_file [String] Decompressed output path
+      # @return [Integer] Bytes written
+      # @raise [Error] if decompression fails
+      def decompress(input_file, output_file)
+        input_handle = @io_system.open(input_file, Constants::MODE_READ)
+        output_handle = @io_system.open(output_file, Constants::MODE_WRITE)
+
+        begin
+          # Read and validate header
+          header_data = @io_system.read(input_handle, 16)
+          raise Error, "Failed to read OAB header" if header_data.length < 16
+
+          header = Binary::OABStructures::FullHeader.read(header_data)
+          raise Error, "Invalid OAB header" unless header.valid?
+
+          block_max = header.block_max
+          target_size = header.target_size
+          total_written = 0
+
+          # Process blocks until target size reached
+          while target_size.positive?
+            total_written += decompress_block(
+              input_handle, output_handle, block_max, target_size
+            )
+            target_size -= [block_max, target_size].min
+          end
+
+          total_written
+        ensure
+          @io_system.close(input_handle) if input_handle
+          @io_system.close(output_handle) if output_handle
+        end
+      end
+
+      # Decompress an incremental patch file
+      #
+      # @param patch_file [String] Compressed patch file path
+      # @param base_file [String] Base (uncompressed) file path
+      # @param output_file [String] Output file path
+      # @return [Integer] Bytes written
+      # @raise [Error] if decompression fails
+      def decompress_incremental(patch_file, base_file, output_file)
+        patch_handle = @io_system.open(patch_file, Constants::MODE_READ)
+        base_handle = @io_system.open(base_file, Constants::MODE_READ)
+        output_handle = @io_system.open(output_file, Constants::MODE_WRITE)
+
+        begin
+          # Read and validate patch header
+          header_data = @io_system.read(patch_handle, 28)
+          if header_data.length < 28
+            raise Error,
+                  "Failed to read OAB patch header"
+          end
+
+          header = Binary::OABStructures::PatchHeader.read(header_data)
+          raise Error, "Invalid OAB patch header" unless header.valid?
+
+          block_max = [header.block_max, 16].max # At least 16 for header
+          target_size = header.target_size
+          total_written = 0
+
+          # Process patch blocks until target size reached
+          while target_size.positive?
+            total_written += decompress_patch_block(
+              patch_handle, base_handle, output_handle, block_max, target_size
+            )
+            target_size = header.target_size - total_written
+          end
+
+          total_written
+        ensure
+          @io_system.close(patch_handle) if patch_handle
+          @io_system.close(base_handle) if base_handle
+          @io_system.close(output_handle) if output_handle
+        end
+      end
+
+      private
+
+      # Decompress a single OAB block (full file)
+      #
+      # @param input_handle [System::FileHandle] Input file handle
+      # @param output_handle [System::FileHandle] Output file handle
+      # @param block_max [Integer] Maximum block size
+      # @param target_remaining [Integer] Remaining bytes to decompress
+      # @return [Integer] Bytes written
+      def decompress_block(input_handle, output_handle, block_max,
+target_remaining)
+        # Read block header
+        block_data = @io_system.read(input_handle, 16)
+        raise Error, "Failed to read block header" if block_data.length < 16
+
+        block_header = Binary::OABStructures::BlockHeader.read(block_data)
+
+        # Validate block
+        if block_header.uncompressed_size > block_max ||
+            block_header.uncompressed_size > target_remaining ||
+            block_header.flags > 1
+          raise Error, "Invalid block header"
+        end
+
+        if block_header.uncompressed?
+          # Uncompressed block
+          if block_header.uncompressed_size != block_header.compressed_size
+            raise Error, "Uncompressed block size mismatch"
+          end
+
+          decompress_uncompressed_block(
+            input_handle, output_handle, block_header.uncompressed_size
+          )
+        else
+          # LZX compressed block
+          decompress_lzx_block(
+            input_handle, output_handle, block_header
+          )
+        end
+      end
+
+      # Decompress a single patch block (incremental)
+      #
+      # @param patch_handle [System::FileHandle] Patch file handle
+      # @param base_handle [System::FileHandle] Base file handle
+      # @param output_handle [System::FileHandle] Output file handle
+      # @param block_max [Integer] Maximum block size
+      # @param target_remaining [Integer] Remaining bytes to decompress
+      # @return [Integer] Bytes written
+      def decompress_patch_block(patch_handle, base_handle, output_handle,
+                                 block_max, target_remaining)
+        # Read patch block header
+        block_data = @io_system.read(patch_handle, 16)
+        if block_data.length < 16
+          raise Error,
+                "Failed to read patch block header"
+        end
+
+        block_header = Binary::OABStructures::PatchBlockHeader.read(block_data)
+
+        # Validate block
+        if block_header.target_size > block_max ||
+            block_header.target_size > target_remaining ||
+            block_header.source_size > block_max
+          raise Error, "Invalid patch block header"
+        end
+
+        # Calculate window size for LZX
+        window_size = ((block_header.source_size + 32_767) & ~32_767) +
+          block_header.target_size
+        window_bits = 17
+
+        window_bits += 1 while window_bits < 25 && (1 << window_bits) < window_size
+
+        # Read reference data from base file
+        reference_data = @io_system.read(base_handle, block_header.source_size)
+
+        # Decompress patch with LZX using reference data
+        decompress_lzx_patch_block(
+          patch_handle, output_handle, block_header, window_bits, reference_data
+        )
+      end
+
+      # Decompress uncompressed block
+      #
+      # @param input_handle [System::FileHandle] Input file handle
+      # @param output_handle [System::FileHandle] Output file handle
+      # @param size [Integer] Block size
+      # @return [Integer] Bytes written
+      def decompress_uncompressed_block(input_handle, output_handle, size)
+        bytes_written = 0
+
+        while size.positive?
+          chunk_size = [@buffer_size, size].min
+          data = @io_system.read(input_handle, chunk_size)
+
+          if data.length < chunk_size
+            raise Error,
+                  "Failed to read uncompressed data"
+          end
+
+          @io_system.write(output_handle, data)
+          bytes_written += chunk_size
+          size -= chunk_size
+        end
+
+        bytes_written
+      end
+
+      # Decompress LZX compressed block
+      #
+      # @param input_handle [System::FileHandle] Input file handle
+      # @param output_handle [System::FileHandle] Output file handle
+      # @param block_header [Binary::OABStructures::BlockHeader] Block header
+      # @return [Integer] Bytes written
+      def decompress_lzx_block(input_handle, output_handle, block_header)
+        # Calculate window bits for LZX
+        window_bits = 17
+        block_size = block_header.uncompressed_size
+
+        window_bits += 1 while window_bits < 25 && (1 << window_bits) < block_size
+
+        # Read compressed data
+        compressed_data = @io_system.read(input_handle,
+                                          block_header.compressed_size)
+        if compressed_data.length < block_header.compressed_size
+          raise Error,
+                "Failed to read compressed data"
+        end
+
+        # Create memory handles for LZX decompression
+        input_mem = System::MemoryHandle.new(compressed_data, Constants::MODE_READ)
+        output_mem = System::MemoryHandle.new("", Constants::MODE_WRITE)
+
+        # Decompress with LZX
+        lzx = Decompressors::LZX.new(
+          @io_system, input_mem, output_mem, @buffer_size,
+          window_bits: window_bits,
+          reset_interval: 0,
+          output_length: block_size,
+          is_delta: false
+        )
+
+        bytes_decompressed = lzx.decompress(block_size)
+
+        # Verify CRC
+        actual_crc = Zlib.crc32(output_mem.data)
+        raise Error, "CRC mismatch in block" if actual_crc != block_header.crc
+
+        # Write decompressed data
+        @io_system.write(output_handle, output_mem.data)
+        bytes_decompressed
+      end
+
+      # Decompress LZX patch block with reference data
+      #
+      # @param patch_handle [System::FileHandle] Patch file handle
+      # @param output_handle [System::FileHandle] Output file handle
+      # @param block_header [Binary::OABStructures::PatchBlockHeader] Block header
+      # @param window_bits [Integer] LZX window bits
+      # @param reference_data [String] Reference data from base file
+      # @return [Integer] Bytes written
+      def decompress_lzx_patch_block(patch_handle, output_handle, block_header,
+                                     window_bits, _reference_data)
+        # Read compressed patch data
+        compressed_data = @io_system.read(patch_handle, block_header.patch_size)
+        if compressed_data.length < block_header.patch_size
+          raise Error,
+                "Failed to read patch data"
+        end
+
+        # Create memory handles for LZX decompression
+        input_mem = System::MemoryHandle.new(compressed_data, Constants::MODE_READ)
+        output_mem = System::MemoryHandle.new("", Constants::MODE_WRITE)
+
+        # Decompress with LZX DELTA (includes reference data)
+        lzx = Decompressors::LZX.new(
+          @io_system, input_mem, output_mem, @buffer_size,
+          window_bits: window_bits,
+          reset_interval: 0,
+          output_length: block_header.target_size,
+          is_delta: true
+        )
+
+        # For patches, we'd need to set reference data in the LZX window
+        # This is a simplified implementation - full support would require
+        # extending the LZX decompressor to handle reference data
+        bytes_decompressed = lzx.decompress(block_header.target_size)
+
+        # Verify CRC
+        actual_crc = Zlib.crc32(output_mem.data)
+        if actual_crc != block_header.crc
+          raise Error,
+                "CRC mismatch in patch block"
+        end
+
+        # Write decompressed data
+        @io_system.write(output_handle, output_mem.data)
+        bytes_decompressed
+      end
+    end
+  end
+end