omnizip 0.4.7-x86_64-linux

data/lib/omnizip/formats/seven_zip/header_writer.rb

@@ -0,0 +1,425 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module SevenZip
+      # Writes .7z archive header with metadata
+      # Handles variable-length encoding and property sequences
+      class HeaderWriter
+        include Omnizip::Formats::SevenZip::Constants
+
+        attr_reader :buffer
+
+        # Initialize writer
+        def initialize
+          @buffer = String.new(encoding: "BINARY")
+        end
+
+        # Write archive signature and header
+        #
+        # @param next_header_data [String] Encoded next header
+        # @param next_header_offset [Integer] Offset to next header
+        # @return [String] Complete archive header
+        def write_start_header(next_header_data, next_header_offset)
+          header = String.new(encoding: "BINARY")
+
+          # Signature (6 bytes)
+          header << SIGNATURE
+
+          # Version (2 bytes)
+          header << [MAJOR_VERSION, MINOR_VERSION].pack("CC")
+
+          # Calculate CRC for next header info
+          next_header_info = String.new(encoding: "BINARY")
+          next_header_info << [next_header_offset].pack("Q<")
+          next_header_info << [next_header_data.bytesize].pack("Q<")
+
+          crc = Omnizip::Checksums::Crc32.new
+          crc.update(next_header_data)
+          next_header_crc = crc.value
+
+          next_header_info << [next_header_crc].pack("V")
+
+          # Calculate CRC for next header info
+          info_crc = Omnizip::Checksums::Crc32.new
+          info_crc.update(next_header_info)
+
+          # Start header CRC (4 bytes)
+          header << [info_crc.value].pack("V")
+
+          # Next header info (20 bytes)
+          header << next_header_info
+
+          header
+        end
+
+        # Encode variable-length number (7-Zip format)
+        #
+        # @param value [Integer] Number to encode
+        # @return [String] Encoded bytes
+        def write_number(value)
+          return [value].pack("C") if value < 0x80
+
+          # 7-Zip VLI encoding: extra bytes are little-endian per SDK ReadNumberSpec().
+          # Reference: https://py7zr.readthedocs.io/en/latest/archive_format.html
+          result = String.new(encoding: "BINARY")
+
+          # Determine how many extra bytes are needed
+          thresholds = [0x80, 0x4000, 0x20_0000, 0x1000_0000,
+                        0x8_0000_0000, 0x400_0000_0000,
+                        0x2_0000_0000_0000, 0x100_0000_0000_0000]
+          num_extra = thresholds.index { |t| value < t } || 8
+
+          # Build first byte: num_extra leading 1-bits, then 0-bit, then data bits
+          first_byte = 0
+          num_extra.times { |i| first_byte |= (0x80 >> i) }
+          data_bits_shift = 8 * num_extra
+          first_byte |= (value >> data_bits_shift) & ((0x80 >> num_extra) - 1)
+          result << [first_byte].pack("C")
+
+          # Extra bytes in little-endian order (low byte first)
+          num_extra.times do |i|
+            result << [(value >> (8 * i)) & 0xFF].pack("C")
+          end
+
+          result
+        end
+
+        # Write bit vector
+        #
+        # @param bits [Array<Boolean>] Bit values
+        # @return [String] Encoded bit vector
+        def write_bit_vector(bits)
+          return [1].pack("C") if bits.all?
+
+          data = [0].pack("C") # Not all defined
+          num_bytes = (bits.size + 7) / 8
+
+          bytes = Array.new(num_bytes, 0)
+          bits.each_with_index do |bit, i|
+            byte_idx = i / 8
+            bit_idx = 7 - (i % 8)
+            bytes[byte_idx] |= (1 << bit_idx) if bit
+          end
+
+          data << bytes.pack("C*")
+          data
+        end
+
+        # Write pack info section
+        #
+        # @param pack_pos [Integer] Pack position
+        # @param pack_sizes [Array<Integer>] Pack sizes
+        # @param pack_crcs [Array<Integer, nil>] Pack CRCs (optional)
+        # @return [String] Encoded pack info
+        def write_pack_info(pack_pos, pack_sizes, pack_crcs = [])
+          data = String.new(encoding: "BINARY")
+
+          data << [PropertyId::PACK_INFO].pack("C")
+          data << write_number(pack_pos)
+          data << write_number(pack_sizes.size)
+
+          # Sizes
+          data << [PropertyId::SIZE].pack("C")
+          pack_sizes.each do |size|
+            data << write_number(size)
+          end
+
+          # CRCs (optional)
+          unless pack_crcs.empty?
+            data << [PropertyId::CRC].pack("C")
+            defined_bits = pack_crcs.map { |crc| !crc.nil? }
+            data << write_bit_vector(defined_bits)
+            pack_crcs.each do |crc|
+              data << [crc].pack("V") if crc
+            end
+          end
+
+          data << [PropertyId::K_END].pack("C")
+          data
+        end
+
+        # Write coder info
+        #
+        # @param method_id [Integer] Compression method ID
+        # @param properties [String, nil] Coder properties
+        # @return [String] Encoded coder
+        def write_coder(method_id, properties = nil)
+          data = String.new(encoding: "BINARY")
+
+          # Determine ID size
+          id_bytes = []
+          temp_id = method_id
+          while temp_id.positive?
+            id_bytes.unshift(temp_id & 0xFF)
+            temp_id >>= 8
+          end
+          id_bytes = [0] if id_bytes.empty?
+
+          # Main byte
+          main_byte = id_bytes.size
+          main_byte |= 0x20 if properties # Has properties
+
+          data << [main_byte].pack("C")
+          data << id_bytes.pack("C*")
+
+          # Properties
+          if properties
+            data << write_number(properties.bytesize)
+            data << properties
+          end
+
+          data
+        end
+
+        # Write folder definition
+        #
+        # @param method_id [Integer] Compression method
+        # @param properties [String, nil] Properties
+        # @return [String] Encoded folder data
+        def write_folder(method_id, properties)
+          data = String.new(encoding: "BINARY")
+
+          # Number of coders
+          data << write_number(1)
+
+          # Coder info
+          data << write_coder(method_id, properties)
+
+          # For simple case: no bind pairs needed
+          # (single coder with single in/out stream)
+
+          data
+        end
+
+        # Write folders section
+        #
+        # @param folders [Array<Hash>] Folder specs
+        # @return [String] Encoded folders
+        def write_folders(folders)
+          data = String.new(encoding: "BINARY")
+          data << [PropertyId::FOLDER].pack("C")
+          data << write_number(folders.size)
+
+          # Write external flag (0 = inline folders, 1 = external)
+          data << [0].pack("C")
+
+          folders.each do |folder|
+            data << write_folder(
+              folder[:method_id],
+              folder[:properties],
+            )
+          end
+
+          data
+        end
+
+        # Write unpack info section
+        #
+        # @param folders [Array<Hash>] Folder information
+        # @return [String] Encoded unpack info
+        def write_unpack_info(folders)
+          data = String.new(encoding: "BINARY")
+
+          data << [PropertyId::UNPACK_INFO].pack("C")
+          data << write_folders(folders)
+
+          # Coders unpack size
+          data << [PropertyId::CODERS_UNPACK_SIZE].pack("C")
+          folders.each do |folder|
+            data << write_number(folder[:unpack_size])
+          end
+
+          data << [PropertyId::K_END].pack("C")
+          data
+        end
+
+        # Write file names
+        #
+        # @param names [Array<String>] File names
+        # @return [String] Encoded names
+        def write_names(names)
+          data = String.new(encoding: "BINARY")
+
+          # Encode names as UTF-16LE
+          names_data = String.new(encoding: "BINARY")
+          names.each do |name|
+            name.encode("UTF-16LE").each_byte do |byte|
+              names_data << [byte].pack("C")
+            end
+            names_data << [0, 0].pack("CC") # Null terminator
+          end
+
+          data << write_number(names_data.bytesize + 1)
+          data << [0].pack("C") # Not external
+          data << names_data
+
+          data
+        end
+
+        # Write timestamps
+        #
+        # @param prop_id [Integer] Property ID
+        # @param times [Array<Time, nil>] Timestamps
+        # @return [String] Encoded timestamps
+        def write_timestamps(_prop_id, times)
+          data = String.new(encoding: "BINARY")
+
+          defined_bits = times.map { |t| !t.nil? }
+          times_data = String.new(encoding: "BINARY")
+          times_data << write_bit_vector(defined_bits)
+          times_data << [0].pack("C") # Not external
+
+          times.each do |time|
+            next unless time
+
+            # Convert to Windows FILETIME
+            unix_time = time.to_i
+            windows_time = (unix_time + 11_644_473_600) * 10_000_000
+            times_data << [windows_time].pack("Q<")
+          end
+
+          data << write_number(times_data.bytesize)
+          data << times_data
+          data
+        end
+
+        # Write files info section
+        #
+        # @param entries [Array<Models::FileEntry>] File entries
+        # @return [String] Encoded files info
+        def write_files_info(entries)
+          data = String.new(encoding: "BINARY")
+
+          data << [PropertyId::FILES_INFO].pack("C")
+          data << write_number(entries.size)
+
+          # Names
+          data << [PropertyId::NAME].pack("C")
+          data << write_names(entries.map(&:name))
+
+          # Empty stream flags
+          empty_bits = entries.map { |e| !e.has_stream }
+          if empty_bits.any?
+            data << [PropertyId::EMPTY_STREAM].pack("C")
+            empty_data = write_bit_vector(empty_bits)
+            data << write_number(empty_data.bytesize)
+            data << empty_data
+          end
+
+          # Modification times
+          mtimes = entries.map(&:mtime)
+          if mtimes.any?
+            data << [PropertyId::MTIME].pack("C")
+            data << write_timestamps(PropertyId::MTIME, mtimes)
+          end
+
+          # Attributes
+          attrs = entries.map(&:attributes)
+          if attrs.any?
+            data << [PropertyId::WIN_ATTRIB].pack("C")
+            defined_bits = attrs.map { |a| !a.nil? }
+            attrs_data = String.new(encoding: "BINARY")
+            attrs_data << write_bit_vector(defined_bits)
+            attrs_data << [0].pack("C") # Not external
+            attrs.each do |attr|
+              attrs_data << [attr].pack("V") if attr
+            end
+            data << write_number(attrs_data.bytesize)
+            data << attrs_data
+          end
+
+          data << [PropertyId::K_END].pack("C")
+          data
+        end
+
+        # Write main streams info
+        #
+        # @param options [Hash] Stream information
+        # @return [String] Encoded streams info
+        def write_streams_info(options)
+          data = String.new(encoding: "BINARY")
+
+          data << [PropertyId::MAIN_STREAMS_INFO].pack("C")
+          data << write_pack_info(
+            options[:pack_pos],
+            options[:pack_sizes],
+            options[:pack_crcs],
+          )
+          data << write_unpack_info(options[:folders])
+
+          # Substreams info - needed for solid archives with multiple files
+          if options[:digests] && !options[:digests].empty?
+            data << write_substreams_info(
+              options[:unpack_sizes] || [],
+              options[:digests],
+              options[:folders],
+            )
+          end
+
+          data << [PropertyId::K_END].pack("C")
+          data
+        end
+
+        # Write substreams info section
+        #
+        # @param unpack_sizes [Array<Integer>] Unpack sizes per file
+        # @param digests [Array<Integer>] CRC per file
+        # @param folders [Array<Hash>] Folder information
+        # @return [String] Encoded substreams info
+        def write_substreams_info(unpack_sizes, digests, folders)
+          data = String.new(encoding: "BINARY")
+
+          data << [PropertyId::SUBSTREAMS_INFO].pack("C")
+
+          # Write NUM_UNPACK_STREAM if multiple files in folder
+          if digests.size > folders.size
+            data << [PropertyId::NUM_UNPACK_STREAM].pack("C")
+            folders.each do |_folder|
+              # For solid archives, all files are in one folder
+              data << write_number(digests.size)
+            end
+          end
+
+          # Write unpack sizes if we have them and multiple files
+          if unpack_sizes.size > 1
+            data << [PropertyId::SIZE].pack("C")
+            # Write all but last size (last is calculated from folder unpack size)
+            unpack_sizes[0...-1].each do |size|
+              data << write_number(size)
+            end
+          end
+
+          # Write CRCs
+          if digests && !digests.empty?
+            data << [PropertyId::CRC].pack("C")
+            defined_bits = digests.map { |d| !d.nil? }
+            data << write_bit_vector(defined_bits)
+            digests.each do |crc|
+              data << [crc].pack("V") if crc
+            end
+          end
+
+          data << [PropertyId::K_END].pack("C")
+          data
+        end
+
+        # Write complete next header
+        #
+        # @param options [Hash] All header information
+        # @return [String] Encoded next header
+        def write_next_header(options)
+          data = String.new(encoding: "BINARY")
+
+          data << [PropertyId::HEADER].pack("C")
+          data << write_streams_info(options[:streams]) if
+            options[:streams]
+          data << write_files_info(options[:entries]) if options[:entries]
+          data << [PropertyId::K_END].pack("C")
+
+          data
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/seven_zip/models/coder_info.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module SevenZip
+      module Models
+        # Represents a coder (compression algorithm or filter) in .7z format
+        # Each coder has a method ID, properties, and input/output stream info
+        class CoderInfo
+          attr_accessor :method_id, :num_in_streams, :num_out_streams,
+                        :properties
+
+          # Initialize coder info
+          #
+          # @param method_id [Integer] Compression/filter method ID
+          # @param num_in_streams [Integer] Number of input streams
+          # @param num_out_streams [Integer] Number of output streams
+          # @param properties [String] Binary properties data
+          def initialize(method_id: 0, num_in_streams: 1,
+                         num_out_streams: 1, properties: "".b)
+            @method_id = method_id
+            @num_in_streams = num_in_streams
+            @num_out_streams = num_out_streams
+            @properties = properties
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/seven_zip/models/file_entry.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module SevenZip
+      module Models
+        # Represents a file entry in .7z archive
+        # Contains file metadata, attributes, and extraction information
+        class FileEntry
+          include Omnizip::Entry
+
+          attr_accessor :name, :size, :compressed_size, :crc, :is_dir,
+                        :is_empty, :is_anti, :has_stream, :mtime, :atime,
+                        :ctime, :attributes, :folder_index, :file_index,
+                        :source_path, :inline_data, :compression_options
+
+          def entry_name = name
+          def entry_directory? = is_dir
+          def entry_size = size
+          def entry_mtime = mtime
+
+          # Initialize file entry
+          def initialize
+            @name = nil
+            @size = 0
+            @compressed_size = 0
+            @crc = nil
+            @is_dir = false
+            @is_empty = false
+            @is_anti = false
+            @has_stream = true
+            @mtime = nil
+            @atime = nil
+            @ctime = nil
+            @attributes = nil
+            @folder_index = nil
+            @file_index = nil
+            @source_path = nil
+          end
+
+          # Check if entry is a directory
+          #
+          # @return [Boolean] true if directory
+          def directory?
+            @is_dir
+          end
+
+          # Check if entry is a file
+          #
+          # @return [Boolean] true if regular file
+          def file?
+            !@is_dir
+          end
+
+          # Check if entry has data stream
+          #
+          # @return [Boolean] true if has stream
+          def has_stream?
+            @has_stream && !@is_empty
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/seven_zip/models/folder.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module SevenZip
+      module Models
+        # Represents a folder (compression group) in .7z format
+        # Contains coder chain and binding information
+        class Folder
+          attr_accessor :coders, :bind_pairs, :pack_stream_indices,
+                        :unpack_sizes, :unpack_crc
+
+          # Initialize folder
+          #
+          # @param coders [Array<CoderInfo>] Array of coders
+          # @param bind_pairs [Array<Array<Integer>>] Stream bindings
+          # @param pack_stream_indices [Array<Integer>] Pack stream indices
+          def initialize
+            @coders = []
+            @bind_pairs = []
+            @pack_stream_indices = []
+            @unpack_sizes = []
+            @unpack_crc = nil
+          end
+
+          # Get number of coders in folder
+          #
+          # @return [Integer] Coder count
+          def num_coders
+            @coders.size
+          end
+
+          # Get total number of output streams
+          #
+          # @return [Integer] Output stream count
+          def num_out_streams
+            @coders.sum(&:num_out_streams)
+          end
+
+          # Get total number of input streams
+          #
+          # @return [Integer] Input stream count
+          def num_in_streams
+            @coders.sum(&:num_in_streams)
+          end
+
+          # Get uncompressed size of folder's final output stream
+          # Finds the output stream that is not bound as input
+          #
+          # @return [Integer] Uncompressed size
+          def uncompressed_size
+            # Find which output stream is the final one (not bound as input)
+            n = num_out_streams - 1
+            while n >= 0
+              # Check if this output is bound as input
+              bound = @bind_pairs.any? { |pair| pair[1] == n }
+              return @unpack_sizes[n] || 0 unless bound
+
+              n -= 1
+            end
+            0
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/seven_zip/models/stream_info.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module SevenZip
+      module Models
+        # Represents stream information in .7z format
+        # Contains packed streams, folders, and unpacked stream metadata
+        class StreamInfo
+          attr_accessor :pack_pos, :pack_sizes, :pack_crcs, :folders,
+                        :num_unpack_streams_in_folders,
+                        :unpack_sizes, :digests
+
+          # Initialize stream info
+          def initialize
+            @pack_pos = 0
+            @pack_sizes = []
+            @pack_crcs = []
+            @folders = []
+            @num_unpack_streams_in_folders = []
+            @unpack_sizes = []
+            @digests = []
+          end
+
+          # Get total number of folders
+          #
+          # @return [Integer] Folder count
+          def num_folders
+            @folders.size
+          end
+
+          # Get total number of pack streams
+          #
+          # @return [Integer] Pack stream count
+          def num_pack_streams
+            @pack_sizes.size
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/seven_zip/models.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module SevenZip
+      # Models namespace for SevenZip archive data structures
+      module Models
+        def self.autoload!(registry)
+          registry.autoload(:FileEntry,
+                            "omnizip/formats/seven_zip/models/file_entry")
+          registry.autoload(:CoderInfo,
+                            "omnizip/formats/seven_zip/models/coder_info")
+          registry.autoload(:StreamInfo,
+                            "omnizip/formats/seven_zip/models/stream_info")
+          registry.autoload(:Folder, "omnizip/formats/seven_zip/models/folder")
+        end
+      end
+    end
+  end
+end