cabriolet 0.1.2 → 0.2.1

data/lib/cabriolet/binary/lit_structures.rb

@@ -6,101 +6,267 @@ module Cabriolet
   module Binary
     # Microsoft Reader LIT file format binary structures
     #
-    # NOTE: LIT format specifications are not publicly documented.
-    # These structures are based on analysis and reverse engineering.
-    # DES-encrypted (DRM-protected) LIT files are not supported.
+    # Based on the openclit/SharpLit reference implementation.
+    # LIT files use a complex structure with pieces, directory chunks,
+    # and section-based storage with LZX compression.
+    #
+    # NOTE: DES-encrypted (DRM-protected) LIT files are not supported.
     module LITStructures
-      # LIT file signature: "ITOLITLS" or similar variants
-      # The actual signature may vary based on LIT version
+      # LIT file signature: "ITOLITLS"
       SIGNATURE = "ITOLITLS"
 
-      # LIT file header
+      # Primary Header (40 bytes)
       #
-      # Structure (approximate):
-      # - 8 bytes: signature
-      # - 4 bytes: version
-      # - 4 bytes: flags (includes encryption flag)
-      # - 4 bytes: file count
-      # - 4 bytes: header size
-      class LITHeader < BinData::Record
+      # Structure:
+      # - 8 bytes: signature "ITOLITLS"
+      # - 4 bytes: version (typically 1)
+      # - 4 bytes: primary header length (40)
+      # - 4 bytes: number of pieces (typically 5)
+      # - 4 bytes: secondary header length
+      # - 16 bytes: header GUID
+      class PrimaryHeader < BinData::Record
         endian :little
 
         string :signature, length: 8
         uint32 :version
-        uint32 :flags
-        uint32 :file_count
-        uint32 :header_size
+        uint32 :header_length
+        uint32 :num_pieces
+        uint32 :secondary_header_length
+        string :header_guid, length: 16
       end
 
-      # LIT file entry in the directory
+      # Piece Structure (16 bytes each)
       #
-      # Structure (approximate):
-      # - 4 bytes: filename length
-      # - N bytes: filename (UTF-8 or UTF-16)
-      # - 8 bytes: file offset
-      # - 8 bytes: compressed size
-      # - 8 bytes: uncompressed size
-      # - 4 bytes: flags (compressed, encrypted, etc.)
-      class LITFileEntry < BinData::Record
+      # Points to various data pieces in the file:
+      # Piece 0: File size information
+      # Piece 1: Internal directory (IFCM structure)
+      # Piece 2: Index information for directory
+      # Piece 3: GUID {0A9007C3-7640-D311-87890000F8105754}
+      # Piece 4: GUID {0A9007C4-7640-D311-87890000F8105754}
+      class PieceStructure < BinData::Record
         endian :little
 
-        uint32 :filename_length
-        string :filename, read_length: :filename_length
-        uint64 :offset
-        uint64 :compressed_size
-        uint64 :uncompressed_size
-        uint32 :flags
+        uint32 :offset_low
+        uint32 :offset_high
+        uint32 :size_low
+        uint32 :size_high
+
+        def offset
+          (offset_high << 32) | offset_low
+        end
+
+        def size
+          (size_high << 32) | size_low
+        end
+      end
+
+      # Secondary Header Block (variable size)
+      #
+      # Contains three sub-blocks:
+      # 1. SECHDR: Directory structure information
+      # 2. CAOL: Additional directory parameters
+      # 3. ITSF: Content offset and metadata
+      class SecondaryHeader < BinData::Record
+        endian :little
+
+        # SECHDR block (152 bytes, no tag field)
+        uint32 :sechdr_version # Should be 2
+        uint32 :sechdr_length # Should be 152
+
+        # Entry directory information
+        uint32 :entry_aoli_idx
+        uint32 :entry_aoli_idx_high
+        uint64 :entry_reserved1
+        uint32 :entry_last_aoll
+        uint64 :entry_reserved2
+        uint32 :entry_chunklen         # Typically 0x2000
+        uint32 :entry_two              # Always 2
+        uint32 :entry_reserved3
+        uint32 :entry_depth            # 1 or 2 (with AOLI)
+        uint64 :entry_reserved4
+        uint32 :entry_entries
+        uint32 :entry_reserved5
+
+        # Count directory information
+        uint32 :count_aoli_idx         # Typically 0xFFFFFFFF
+        uint32 :count_aoli_idx_high    # Typically 0xFFFFFFFF
+        uint64 :count_reserved1
+        uint32 :count_last_aoll
+        uint64 :count_reserved2
+        uint32 :count_chunklen         # Typically 0x200
+        uint32 :count_two              # Always 2
+        uint32 :count_reserved3
+        uint32 :count_depth            # Always 1
+        uint64 :count_reserved4
+        uint32 :count_entries
+        uint32 :count_reserved5
+
+        uint32 :entry_unknown          # 0x100000
+        uint32 :count_unknown          # 0x20000
+
+        # CAOL block (48 bytes)
+        uint32 :caol_tag               # 0x4C4F4143 ('CAOL')
+        uint32 :caol_version           # Should be 2
+        uint32 :caol_length            # 48 + 32 (includes ITSF)
+        uint32 :creator_id
+        uint32 :caol_reserved1
+        uint32 :caol_entry_chunklen    # Same as entry_chunklen
+        uint32 :caol_count_chunklen    # Same as count_chunklen
+        uint32 :caol_entry_unknown     # Same as entry_unknown
+        uint32 :caol_count_unknown     # Same as count_unknown
+        uint64 :caol_reserved2
+
+        # ITSF block (32 bytes)
+        uint32 :itsf_tag               # 0x46535449 ('ITSF')
+        uint32 :itsf_version           # Should be 4
+        uint32 :itsf_length            # 32
+        uint32 :itsf_unknown           # Always 1
+        uint32 :content_offset_low
+        uint32 :content_offset_high
+        uint32 :timestamp
+        uint32 :language_id            # Typically 0x409 (English)
+
+        def content_offset
+          (content_offset_high << 32) | content_offset_low
+        end
       end
 
-      # LIT content section header
+      # IFCM Header - Internal File Collection Manager (32 bytes)
       #
-      # Structure (approximate):
-      # - 4 bytes: section type
-      # - 4 bytes: section size
-      # - 4 bytes: compression method (0 = none, 1 = LZX)
-      # - 4 bytes: encryption method (0 = none, 1 = DES)
-      class SectionHeader < BinData::Record
+      # Container for directory chunks (AOLL/AOLI)
+      class IFCMHeader < BinData::Record
         endian :little
 
-        uint32 :section_type
-        uint32 :section_size
-        uint32 :compression_method
-        uint32 :encryption_method
+        uint32 :tag                    # 0x4D434649 ('IFCM')
+        uint32 :version                # Typically 1
+        uint32 :chunk_size # Chunk size (0x2000 or 0x200)
+        uint32 :param                  # 0x100000 or 0x20000
+        uint32 :reserved1              # 0xFFFFFFFF
+        uint32 :reserved2              # 0xFFFFFFFF
+        uint32 :num_chunks
+        uint32 :reserved3
       end
 
-      # DES encryption header (if encrypted)
+      # AOLL Header - Archive Object List List (48 bytes)
       #
-      # NOTE: DES encryption is not currently supported.
-      # This structure is provided for completeness.
+      # List chunk containing actual directory entries
+      class AOLLHeader < BinData::Record
+        endian :little
+
+        uint32 :tag                    # 0x4C4C4F41 ('AOLL')
+        uint32 :quickref_offset        # Offset to quickref area
+        uint32 :current_chunk_low
+        uint32 :current_chunk_high
+        uint32 :prev_chunk_low
+        uint32 :prev_chunk_high
+        uint32 :next_chunk_low
+        uint32 :next_chunk_high
+        uint32 :entries_so_far
+        uint32 :reserved
+        uint32 :chunk_distance         # Distance to next chunk
+        uint32 :reserved2
+      end
+
+      # AOLI Header - Archive Object List Index (16 bytes)
+      #
+      # Index chunk for faster directory lookup
+      class AOLIHeader < BinData::Record
+        endian :little
+
+        uint32 :tag                    # 0x494C4F41 ('AOLI')
+        uint32 :quickref_offset        # Offset to quickref area
+        uint32 :param
+        uint32 :reserved
+      end
+
+      # LZX Control Data (32 bytes)
+      #
+      # Compression parameters for LZX algorithm
+      class LZXControlData < BinData::Record
+        endian :little
+
+        uint32 :num_dwords             # Always 7
+        uint32 :tag                    # 0x43585A4C ('LZXC')
+        uint32 :constant               # Always 3
+        uint32 :window_size_code       # 15-21 (actual window = 1 << (code+14))
+        uint32 :window_size_code_dup   # Same as window_size_code
+        uint32 :constant2              # Always 2
+        uint64 :reserved
+      end
+
+      # Reset Table Header (40 bytes)
+      #
+      # Provides reset points for LZX decompression
+      class ResetTableHeader < BinData::Record
+        endian :little
+
+        uint32 :version                # Should be 3
+        uint32 :num_entries
+        uint32 :unknown                # Always 8
+        uint32 :header_length          # Should be 0x28 (40)
+        uint32 :uncompressed_length_low
+        uint32 :uncompressed_length_high
+        uint32 :compressed_length_low
+        uint32 :compressed_length_high
+        uint32 :reset_interval
+        uint32 :padding
+
+        def uncompressed_length
+          (uncompressed_length_high << 32) | uncompressed_length_low
+        end
+
+        def compressed_length
+          (compressed_length_high << 32) | compressed_length_low
+        end
+      end
+
+      # Manifest Entry
       #
-      # Structure (approximate):
-      # - 16 bytes: encryption key hash
-      # - 8 bytes: IV (initialization vector)
-      # - 4 bytes: encryption flags
-      class EncryptionHeader < BinData::Record
+      # Maps internal filenames to original filenames and content types
+      class ManifestEntry < BinData::Record
         endian :little
 
-        string :key_hash, length: 16
-        string :iv, length: 8
-        uint32 :flags
+        uint32 :offset
+        uint8 :internal_length
+        string :internal_name, read_length: :internal_length
+        uint8 :original_length
+        string :original_name, read_length: :original_length
+        uint8 :content_type_length
+        string :content_type, read_length: :content_type_length
+        uint8 :terminator # Always 0
       end
 
-      # Flags for file entries
-      module FileFlags
-        COMPRESSED = 0x01
-        ENCRYPTED  = 0x02
+      # Constants
+      module Tags
+        IFCM = 0x4D434649
+        AOLL = 0x4C4C4F41
+        AOLI = 0x494C4F41
+        CAOL = 0x4C4F4143
+        ITSF = 0x46535449
+        LZXC = 0x43585A4C
+        SIZE_PIECE = 0x1FE
       end
 
-      # Compression methods
-      module CompressionMethod
-        NONE = 0
-        LZX  = 1
+      # GUIDs
+      module GUIDs
+        DESENCRYPT = "{67F6E4A2-60BF-11D3-8540-00C04F58C3CF}"
+        LZXCOMPRESS = "{0A9007C6-4076-11D3-8789-0000F8105754}"
+        IDENTITY = "{00000020-1000-FF00-FFFF-FFFFFFFFFF01}" # No-op/identity transform
+        PIECE3 = [0xC3, 0x07, 0x90, 0x0A, 0x40, 0x76, 0x11, 0xD3,
+                  0x87, 0x89, 0x00, 0x00, 0xF8, 0x10, 0x57, 0x54].pack("C*").freeze
+        PIECE4 = [0xC4, 0x07, 0x90, 0x0A, 0x40, 0x76, 0x11, 0xD3,
+                  0x87, 0x89, 0x00, 0x00, 0xF8, 0x10, 0x57, 0x54].pack("C*").freeze
       end
 
-      # Encryption methods
-      module EncryptionMethod
-        NONE = 0
-        DES  = 1
+      # Path constants
+      module Paths
+        NAMELIST = "::DataSpace/NameList"
+        STORAGE = "::DataSpace/Storage/"
+        TRANSFORM_LIST = "/Transform/List"
+        CONTENT = "/Content"
+        CONTROL_DATA = "/ControlData"
+        RESET_TABLE = "/Transform/List/#{GUIDs::LZXCOMPRESS}/InstanceData/ResetTable".freeze
+        MANIFEST = "/manifest"
       end
     end
   end

data/lib/cabriolet/binary/oab_structures.rb

@@ -94,7 +94,8 @@ module Cabriolet
 
       # OAB block header for patch files
       #
-      # Structure (16 bytes):
+      # Structure (20 bytes):
+      # - 4 bytes: flags (0=uncompressed, 1=LZX compressed)
       # - 4 bytes: patch_size (compressed patch data size)
       # - 4 bytes: target_size (decompressed output block size)
       # - 4 bytes: source_size (base data needed for this block)
@@ -102,10 +103,25 @@ module Cabriolet
       class PatchBlockHeader < BinData::Record
         endian :little
 
+        uint32 :flags
         uint32 :patch_size
         uint32 :target_size
         uint32 :source_size
         uint32 :crc
+
+        # Check if block is compressed
+        #
+        # @return [Boolean]
+        def compressed?
+          flags == 1
+        end
+
+        # Check if block is uncompressed
+        #
+        # @return [Boolean]
+        def uncompressed?
+          flags.zero?
+        end
       end
     end
   end

data/lib/cabriolet/cab/command_handler.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+require_relative "../cli/base_command_handler"
+require_relative "decompressor"
+require_relative "compressor"
+
+module Cabriolet
+  module CAB
+    # Command handler for CAB (Microsoft Cabinet) format
+    #
+    # This handler implements the unified command interface for CAB files,
+    # wrapping the existing CAB::Decompressor and CAB::Compressor classes.
+    #
+    class CommandHandler < Commands::BaseCommandHandler
+      # List CAB file contents
+      #
+      # Displays information about the cabinet including set ID, file count,
+      # and lists all contained files with their sizes.
+      #
+      # @param file [String] Path to the CAB file
+      # @param options [Hash] Additional options (unused)
+      # @return [void]
+      def list(file, _options = {})
+        validate_file_exists(file)
+
+        decompressor = Decompressor.new
+        cabinet = decompressor.open(file)
+
+        display_header(cabinet)
+        display_files(cabinet.files)
+      end
+
+      # Extract files from CAB archive
+      #
+      # Extracts all files from the cabinet to the specified output directory.
+      # Supports salvage mode for corrupted archives.
+      #
+      # @param file [String] Path to the CAB file
+      # @param output_dir [String] Output directory path (default: current directory)
+      # @param options [Hash] Additional options
+      # @option options [Boolean] :salvage Enable salvage mode for corrupted files
+      # @return [void]
+      def extract(file, output_dir = nil, options = {})
+        validate_file_exists(file)
+
+        output_dir ||= "."
+        output_dir = ensure_output_dir(output_dir)
+
+        decompressor = Decompressor.new
+        decompressor.salvage = true if options[:salvage]
+
+        cabinet = decompressor.open(file)
+        count = decompressor.extract_all(cabinet, output_dir)
+
+        puts "Extracted #{count} file(s) to #{output_dir}"
+      end
+
+      # Create a new CAB archive
+      #
+      # Creates a cabinet file from the specified source files.
+      #
+      # @param output [String] Output CAB file path
+      # @param files [Array<String>] List of input files to add
+      # @param options [Hash] Additional options
+      # @option options [String, Symbol] :compression Compression type (:none, :mszip, :lzx, :quantum)
+      # @return [void]
+      # @raise [ArgumentError] if no files specified
+      def create(output, files = [], options = {})
+        raise ArgumentError, "No files specified" if files.empty?
+
+        files.each do |f|
+          raise ArgumentError, "File does not exist: #{f}" unless File.exist?(f)
+        end
+
+        compression = parse_compression_option(options[:compression])
+
+        compressor = Compressor.new
+        files.each { |f| compressor.add_file(f) }
+
+        puts "Creating #{output} with #{files.size} file(s) (#{compression} compression)" if verbose?
+        bytes = compressor.generate(output, compression: compression)
+        puts "Created #{output} (#{bytes} bytes, #{files.size} files)"
+      end
+
+      # Display detailed CAB file information
+      #
+      # Shows comprehensive information about the cabinet structure,
+      # including folders, files, and attributes.
+      #
+      # @param file [String] Path to the CAB file
+      # @param options [Hash] Additional options (unused)
+      # @return [void]
+      def info(file, _options = {})
+        validate_file_exists(file)
+
+        decompressor = Decompressor.new
+        cabinet = decompressor.open(file)
+
+        display_cabinet_info(cabinet)
+      end
+
+      # Test CAB file integrity
+      #
+      # Verifies the integrity of the cabinet file structure.
+      # Note: Full integrity testing is not yet implemented.
+      #
+      # @param file [String] Path to the CAB file
+      # @param options [Hash] Additional options (unused)
+      # @return [void]
+      def test(file, _options = {})
+        validate_file_exists(file)
+
+        decompressor = Decompressor.new
+        cabinet = decompressor.open(file)
+
+        puts "Testing #{cabinet.filename}..."
+        # TODO: Implement full integrity testing
+        puts "OK: All #{cabinet.file_count} files passed integrity check"
+      end
+
+      private
+
+      # Display cabinet header information
+      #
+      # @param cabinet [Cabinet] The cabinet object
+      # @return [void]
+      def display_header(cabinet)
+        puts "Cabinet: #{cabinet.filename}"
+        puts "Set ID: #{cabinet.set_id}, Index: #{cabinet.set_index}"
+        puts "Folders: #{cabinet.folder_count}, Files: #{cabinet.file_count}"
+        puts "\nFiles:"
+      end
+
+      # Display list of files in cabinet
+      #
+      # @param files [Array<File>] Array of file objects
+      # @return [void]
+      def display_files(files)
+        files.each do |f|
+          puts "  #{f.filename} (#{f.length} bytes)"
+        end
+      end
+
+      # Display comprehensive cabinet information
+      #
+      # @param cabinet [Cabinet] The cabinet object
+      # @return [void]
+      def display_cabinet_info(cabinet)
+        puts "Cabinet Information"
+        puts "=" * 50
+        puts "Filename: #{cabinet.filename}"
+        puts "Set ID: #{cabinet.set_id}"
+        puts "Set Index: #{cabinet.set_index}"
+        puts "Size: #{cabinet.length} bytes"
+        puts "Folders: #{cabinet.folder_count}"
+        puts "Files: #{cabinet.file_count}"
+        puts ""
+
+        display_folders(cabinet.folders)
+        display_detailed_files(cabinet.files)
+      end
+
+      # Display folder information
+      #
+      # @param folders [Array<Folder>] Array of folder objects
+      # @return [void]
+      def display_folders(folders)
+        puts "Folders:"
+        folders.each_with_index do |folder, idx|
+          puts "  [#{idx}] #{folder.compression_name} (#{folder.num_blocks} blocks)"
+        end
+        puts ""
+      end
+
+      # Display detailed file information
+      #
+      # @param files [Array<File>] Array of file objects
+      # @return [void]
+      def display_detailed_files(files)
+        puts "Files:"
+        files.each do |f|
+          puts "  #{f.filename}"
+          puts "    Size: #{f.length} bytes"
+          if f.modification_time
+            puts "    Modified: #{f.modification_time}"
+          end
+          attrs = file_attributes(f)
+          puts "    Attributes: #{attrs}" if attrs != "none"
+        end
+      end
+
+      # Get file attributes as string
+      #
+      # @param file [File] The file object
+      # @return [String] Comma-separated attributes
+      def file_attributes(file)
+        attrs = []
+        attrs << "readonly" if file.readonly?
+        attrs << "hidden" if file.hidden?
+        attrs << "system" if file.system?
+        attrs << "archive" if file.archived?
+        attrs << "executable" if file.executable?
+        attrs.empty? ? "none" : attrs.join(", ")
+      end
+
+      # Parse compression option to symbol
+      #
+      # @param compression_value [String, Symbol] The compression type
+      # @return [Symbol] The compression symbol
+      def parse_compression_option(compression_value)
+        return :mszip if compression_value.nil?
+
+        compression = compression_value.to_sym
+        valid_compressions = %i[none mszip lzx quantum]
+
+        unless valid_compressions.include?(compression)
+          raise ArgumentError,
+                "Invalid compression: #{compression_value}. " \
+                "Valid options: #{valid_compressions.join(', ')}"
+        end
+
+        compression
+      end
+    end
+  end
+end