omnizip 0.4.7-x86_64-linux

data/lib/omnizip/parity/models/main_packet.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Parity
+    module Models
+      # PAR2 Main packet
+      #
+      # Contains recovery set metadata including block size and file IDs.
+      #
+      # Body structure:
+      # - block_size (8 bytes, Q<): Size of each data block
+      # - file_ids (16 bytes each): List of file IDs in the recovery set
+      #
+      # Note: In current Par2Creator implementation, the body includes
+      # additional fields after block_size that are not part of the
+      # standard PAR2 spec. This model follows the actual PAR2 spec.
+      class MainPacket < Packet
+        # Packet type identifier
+        PACKET_TYPE = "PAR 2.0\x00Main\x00\x00\x00\x00"
+
+        # Block size in bytes
+        attribute :block_size, :integer
+
+        # Array of 16-byte file IDs
+        attribute :file_ids, :string, collection: true, default: -> { [] }
+
+        # Initialize main packet
+        #
+        # @param attributes [Hash] Packet attributes
+        def initialize(**attributes)
+          super
+          self.type = PACKET_TYPE
+        end
+
+        # Parse body data into attributes
+        #
+        # Body format (PAR2 spec):
+        # - block_size: 8 bytes (Q<)
+        # - file_ids: 16 bytes each, until end of body
+        #
+        # par2cmdline variant also includes:
+        # - file_count: 4 bytes (L<) after block_size
+        # - then file_ids: 16 bytes each
+        #
+        # This method detects which format is used.
+        def parse_body
+          return if body_data.nil? || body_data.empty?
+
+          pos = 0
+
+          # Read block_size (8 bytes, little-endian unsigned 64-bit)
+          self.block_size = body_data[pos, 8].unpack1("Q<")
+          pos += 8
+
+          # Detect format: check if next 4 bytes are a file_count
+          remaining = body_data.bytesize - pos
+
+          if remaining >= 4
+            # Try to read potential file_count
+            potential_count = body_data[pos, 4].unpack1("L<")
+            expected_size = potential_count * 16
+
+            # Check if this looks like par2cmdline format:
+            # - Remaining bytes should be: 4 (count) + count * 16 (file_ids)
+            # - Count should be reasonable (> 0, < 10000 for sanity)
+            if remaining == (4 + expected_size) &&
+                potential_count.positive? &&
+                potential_count < 10_000
+              # par2cmdline format detected
+              pos += 4 # Skip the file_count field
+            end
+          end
+
+          # Read file IDs (16 bytes each) until end of body
+          self.file_ids = []
+          while pos < body_data.bytesize
+            file_id = body_data[pos, 16]
+            break if file_id.nil? || file_id.bytesize < 16
+
+            file_ids << file_id
+            pos += 16
+          end
+        end
+
+        # Build body data from attributes
+        #
+        # Constructs binary body data from block_size and file_ids
+        #
+        # @return [String] Binary body data
+        def build_body
+          data = +""
+
+          # Write block_size (8 bytes, little-endian)
+          data << [block_size].pack("Q<")
+
+          # Write file IDs (16 bytes each)
+          file_ids.each do |file_id|
+            # Ensure file_id is exactly 16 bytes
+            if file_id.bytesize != 16
+              raise ArgumentError,
+                    "File ID must be 16 bytes, got #{file_id.bytesize}"
+            end
+            data << file_id
+          end
+
+          self.body_data = data
+        end
+
+        # Get number of files in recovery set
+        #
+        # @return [Integer] File count
+        def file_count
+          file_ids.size
+        end
+
+        # Check if packet contains specific file ID
+        #
+        # @param file_id [String] 16-byte file ID to check
+        # @return [Boolean] true if file ID is present
+        def includes_file?(file_id)
+          file_ids.include?(file_id)
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/parity/models/packet.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+begin
+  require "lutaml/model"
+rescue LoadError, ArgumentError
+  # lutaml-model not available, using simple classes
+end
+
+require "digest"
+
+module Omnizip
+  module Parity
+    module Models
+      # Base class for PAR2 packets
+      #
+      # All PAR2 packets share a common 64-byte header structure:
+      # - magic (8 bytes): "PAR2\0PKT"
+      # - length (8 bytes): Total packet length including header (Q<)
+      # - packet_hash (16 bytes): MD5 hash of (set_id + type + data)
+      # - set_id (16 bytes): Recovery set identifier
+      # - type (16 bytes): Packet type identifier
+      #
+      # The packet body follows the header and varies by packet type.
+      class Packet < Lutaml::Model::Serializable
+        # PAR2 packet signature
+        PACKET_SIGNATURE = "PAR2\x00PKT".b.freeze
+
+        # Common header fields (64 bytes total)
+        attribute :magic, :string, default: -> { PACKET_SIGNATURE }
+        attribute :length, :integer # Total packet length (header + body)
+        attribute :packet_hash, :string # MD5 hash (16 bytes)
+        attribute :set_id, :string # Recovery set ID (16 bytes)
+        attribute :type, :string # Packet type (16 bytes)
+
+        # Packet body data (variable length, subclass-specific)
+        # NOT a lutaml-model attribute because it contains raw binary data
+        # that can include null bytes and invalid UTF-8 sequences
+        attr_accessor :body_data
+
+        # Initialize packet
+        #
+        # @param attributes [Hash] Packet attributes
+        def initialize(**attributes)
+          @body_data = "" # Initialize body_data with empty binary string
+          super
+        end
+
+        # Read packet from IO stream
+        #
+        # @param io [IO] Input stream
+        # @return [Packet, nil] Parsed packet or nil if EOF/invalid
+        def self.read_from(io)
+          # Read header (64 bytes total)
+          magic = io.read(8)
+          return nil unless magic == PACKET_SIGNATURE
+
+          length = io.read(8).unpack1("Q<")
+          packet_hash = io.read(16)
+          set_id = io.read(16)
+          type = io.read(16)
+
+          # Read body data
+          data_length = length - 64
+          body_data = io.read(data_length)
+
+          # Create instance
+          packet = new(
+            magic: magic,
+            length: length,
+            packet_hash: packet_hash,
+            set_id: set_id,
+            type: type,
+          )
+
+          # Set body_data directly to avoid lutaml-model attribute
+          # corruption of binary data
+          packet.body_data = body_data
+
+          # Verify packet hash
+          # NOTE: Hash validation temporarily disabled for par2cmdline compatibility testing
+          # unless packet.valid_hash?
+          #   warn "Invalid packet hash detected"
+          # end
+
+          packet
+        end
+
+        # Write packet to IO stream
+        #
+        # @param io [IO] Output stream
+        def write_to(io)
+          # Calculate total length
+          self.length = 64 + body_data.bytesize
+
+          # Calculate packet hash (MD5 of set_id + type + body_data)
+          self.packet_hash = calculate_hash
+
+          # Write header
+          io.write(magic)
+          io.write([length].pack("Q<"))
+          io.write(packet_hash)
+          io.write(set_id)
+          io.write(type)
+
+          # Write body
+          io.write(body_data)
+        end
+
+        # Calculate MD5 hash of packet body
+        #
+        # Hash is computed over: set_id + type + body_data
+        #
+        # @return [String] 16-byte MD5 digest
+        def calculate_hash
+          data = +""
+          data << set_id
+          data << type
+          data << body_data
+          Digest::MD5.digest(data)
+        end
+
+        # Verify packet hash is correct
+        #
+        # @return [Boolean] true if hash matches
+        def valid_hash?
+          calculate_hash == packet_hash
+        end
+
+        # Get packet type identifier
+        #
+        # @return [String] 16-byte type identifier
+        def packet_type
+          type
+        end
+
+        # Parse body data into structured attributes
+        #
+        # Subclasses must implement this to parse body_data
+        # into their specific attributes.
+        def parse_body
+          raise NotImplementedError,
+                "#{self.class} must implement parse_body"
+        end
+
+        # Build body data from structured attributes
+        #
+        # Subclasses must implement this to build body_data
+        # from their specific attributes.
+        def build_body
+          raise NotImplementedError,
+                "#{self.class} must implement build_body"
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/parity/models/packet_registry.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Parity
+    module Models
+      # Registry for PAR2 packet types
+      #
+      # Maps 16-byte packet type identifiers to their corresponding
+      # packet class implementations. Enables polymorphic packet
+      # parsing based on type field.
+      class PacketRegistry
+        @registry = {}
+
+        class << self
+          # Register a packet type
+          #
+          # @param type_id [String] 16-byte type identifier
+          # @param klass [Class] Packet class
+          def register(type_id, klass)
+            unless type_id.bytesize == 16
+              raise ArgumentError,
+                    "Type ID must be 16 bytes, got #{type_id.bytesize}"
+            end
+
+            @registry[type_id] = klass
+          end
+
+          # Get packet class for type identifier
+          #
+          # @param type_id [String] 16-byte type identifier
+          # @return [Class, nil] Packet class or nil if not registered
+          def get(type_id)
+            @registry[type_id]
+          end
+
+          # Check if type is registered
+          #
+          # @param type_id [String] 16-byte type identifier
+          # @return [Boolean] true if type is registered
+          def registered?(type_id)
+            @registry.key?(type_id)
+          end
+
+          # Get all registered packet types
+          #
+          # @return [Array<String>] Array of 16-byte type identifiers
+          def types
+            @registry.keys
+          end
+
+          # Parse packet from IO and return appropriate subclass
+          #
+          # Reads a packet header, determines the type, and returns
+          # an instance of the appropriate packet subclass.
+          #
+          # @param io [IO] Input stream
+          # @return [Packet, nil] Parsed packet or nil if EOF/unknown type
+          def read_packet(io)
+            # Read base packet
+            packet = Packet.read_from(io)
+            return nil unless packet
+
+            # Look up packet class for this type
+            packet_class = get(packet.type)
+
+            # If unknown type, return base Packet
+            return packet unless packet_class
+
+            # Create specific packet type
+            specific_packet = packet_class.new(
+              magic: packet.magic,
+              length: packet.length,
+              packet_hash: packet.packet_hash,
+              set_id: packet.set_id,
+              type: packet.type,
+            )
+
+            # Set body_data directly (not a lutaml attribute)
+            specific_packet.body_data = packet.body_data
+
+            # Parse body into structured fields
+            specific_packet.parse_body
+
+            specific_packet
+          end
+
+          # Clear all registrations (primarily for testing)
+          def clear!
+            @registry.clear
+          end
+        end
+
+        # Register all standard PAR2 packet types
+        register(MainPacket::PACKET_TYPE, MainPacket)
+        register(FileDescriptionPacket::PACKET_TYPE, FileDescriptionPacket)
+        register(IfscPacket::PACKET_TYPE, IfscPacket)
+        register(RecoverySlicePacket::PACKET_TYPE, RecoverySlicePacket)
+        register(CreatorPacket::PACKET_TYPE, CreatorPacket)
+      end
+    end
+  end
+end

data/lib/omnizip/parity/models/recovery_slice_packet.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Parity
+    module Models
+      # PAR2 Recovery Slice packet
+      #
+      # Contains Reed-Solomon encoded recovery data for error correction.
+      #
+      # Body structure:
+      # - exponent (4 bytes, L<): Recovery block exponent/index
+      # - recovery_data (variable): Reed-Solomon encoded block data
+      class RecoverySlicePacket < Packet
+        # Packet type identifier
+        PACKET_TYPE = "PAR 2.0\x00RecvSlic"
+
+        # Recovery block exponent (4 bytes)
+        attribute :exponent, :integer
+
+        # Recovery data (variable length)
+        attribute :recovery_data, :string, default: -> { "" }
+
+        # Initialize recovery slice packet
+        #
+        # @param attributes [Hash] Packet attributes
+        def initialize(**attributes)
+          super
+          self.type = PACKET_TYPE
+        end
+
+        # Parse body data into attributes
+        #
+        # Body format:
+        # - exponent: 4 bytes (L<)
+        # - recovery_data: remainder
+        def parse_body
+          return if body_data.nil? || body_data.empty?
+          return if body_data.bytesize < 4
+
+          pos = 0
+
+          # Read exponent (4 bytes, little-endian unsigned 32-bit)
+          self.exponent = body_data[pos, 4].unpack1("L<")
+          pos += 4
+
+          # Read recovery data (remainder)
+          self.recovery_data = body_data[pos..] || ""
+        end
+
+        # Build body data from attributes
+        #
+        # Constructs binary body data
+        #
+        # @return [String] Binary body data
+        def build_body
+          data = +""
+
+          # Write exponent (4 bytes, little-endian)
+          data << [exponent].pack("L<")
+
+          # Write recovery data
+          data << recovery_data
+
+          self.body_data = data
+        end
+
+        # Get size of recovery data
+        #
+        # @return [Integer] Recovery data size in bytes
+        def data_size
+          recovery_data.bytesize
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/parity/models.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Parity
+    # PAR2 packet models for serialization and parsing
+    #
+    # Contains model classes for all PAR2 packet types:
+    # - Packet: Base class for all packets
+    # - MainPacket: Recovery set metadata
+    # - FileDescriptionPacket: Protected file metadata
+    # - IfscPacket: Input File Slice Checksums
+    # - RecoverySlicePacket: Reed-Solomon recovery data
+    # - CreatorPacket: Creator identification
+    # - PacketRegistry: Registry for packet type dispatch
+    module Models
+      autoload :Packet, "omnizip/parity/models/packet"
+      autoload :CreatorPacket, "omnizip/parity/models/creator_packet"
+      autoload :FileDescriptionPacket,
+               "omnizip/parity/models/file_description_packet"
+      autoload :IfscPacket, "omnizip/parity/models/ifsc_packet"
+      autoload :MainPacket, "omnizip/parity/models/main_packet"
+      autoload :RecoverySlicePacket,
+               "omnizip/parity/models/recovery_slice_packet"
+      autoload :PacketRegistry, "omnizip/parity/models/packet_registry"
+    end
+  end
+end