omnizip 0.3.1

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require_relative "packet"
+
+module Omnizip
+  module Parity
+    module Models
+      # PAR2 Creator packet
+      #
+      # Contains information about the tool that created the PAR2 file.
+      # This packet is optional but recommended for identification.
+      #
+      # Body structure:
+      # - creator_string (variable): Null-terminated string identifying the tool
+      class CreatorPacket < Packet
+        # Packet type identifier
+        PACKET_TYPE = "PAR 2.0\x00Creator\x00"
+
+        # Creator identification string (without null terminator)
+        attribute :creator_string, :string, default: -> { "Omnizip PAR2" }
+
+        # Initialize creator packet
+        #
+        # @param attributes [Hash] Packet attributes
+        def initialize(**attributes)
+          super
+          self.type = PACKET_TYPE
+        end
+
+        # Parse body data into attributes
+        #
+        # Body format:
+        # - creator_string: null-terminated string
+        def parse_body
+          return if body_data.nil? || body_data.empty?
+
+          # Read creator string (null-terminated)
+          self.creator_string = body_data.unpack1("Z*")
+        end
+
+        # Build body data from attributes
+        #
+        # Constructs binary body data with null terminator
+        #
+        # @return [String] Binary body data
+        def build_body
+          data = +""
+
+          # Write creator string (null-terminated)
+          data << creator_string
+          data << "\x00"
+
+          self.body_data = data
+        end
+
+        # Get creator tool name
+        #
+        # @return [String] Creator tool name
+        def tool_name
+          creator_string.split.first || creator_string
+        end
+
+        # Get creator version if available
+        #
+        # @return [String, nil] Version string or nil
+        def version
+          parts = creator_string.split
+          parts.size > 1 ? parts[1..].join(" ") : nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require_relative "packet"
+
+module Omnizip
+  module Parity
+    module Models
+      # PAR2 File Description packet
+      #
+      # Contains metadata about a protected file including hashes and filename.
+      #
+      # Body structure:
+      # - file_id (16 bytes): MD5 hash identifying the file
+      # - file_hash (16 bytes): MD5 hash of complete file content
+      # - file_hash_16k (16 bytes): MD5 hash of first 16KB
+      # - length (8 bytes, Q<): File size in bytes
+      # - filename (variable): Null-terminated filename, padded to multiple of 4
+      class FileDescriptionPacket < Packet
+        # Packet type identifier
+        PACKET_TYPE = "PAR 2.0\x00FileDesc"
+
+        # File identifier (16 bytes MD5)
+        attribute :file_id, :string
+
+        # Full file hash (16 bytes MD5)
+        attribute :file_hash, :string
+
+        # First 16KB hash (16 bytes MD5)
+        attribute :file_hash_16k, :string
+
+        # File length in bytes
+        attribute :length, :integer
+
+        # Filename (without null terminator or padding)
+        attribute :filename, :string
+
+        # Initialize file description packet
+        #
+        # @param attributes [Hash] Packet attributes
+        def initialize(**attributes)
+          super
+          self.type = PACKET_TYPE
+        end
+
+        # Parse body data into attributes
+        #
+        # Body format:
+        # - file_id: 16 bytes
+        # - file_hash: 16 bytes
+        # - file_hash_16k: 16 bytes
+        # - length: 8 bytes (Q<)
+        # - filename: null-terminated, padded to multiple of 4
+        def parse_body
+          return if body_data.nil? || body_data.empty?
+
+          # Validate minimum size (16+16+16+8 = 56 bytes minimum)
+          if body_data.bytesize < 56
+            warn "FileDescriptionPacket body too short: #{body_data.bytesize} bytes"
+            return
+          end
+
+          pos = 0
+
+          # Read file_id (16 bytes)
+          self.file_id = body_data[pos, 16]
+          pos += 16
+
+          # Read file_hash (16 bytes)
+          self.file_hash = body_data[pos, 16]
+          pos += 16
+
+          # Read file_hash_16k (16 bytes)
+          self.file_hash_16k = body_data[pos, 16]
+          pos += 16
+
+          # Read length (8 bytes, little-endian unsigned 64-bit)
+          length_data = body_data[pos, 8]
+          return if length_data.nil? || length_data.bytesize < 8
+
+          self.length = length_data.unpack1("Q<")
+          pos += 8
+
+          # Read filename (null-terminated, remaining bytes)
+          filename_data = body_data[pos..]
+          self.filename = filename_data&.unpack1("Z*") || ""
+        end
+
+        # Build body data from attributes
+        #
+        # Constructs binary body data with proper padding
+        #
+        # @return [String] Binary body data
+        def build_body
+          data = +""
+
+          # Validate file_id, file_hash, file_hash_16k are 16 bytes
+          [file_id, file_hash, file_hash_16k].each_with_index do |hash, idx|
+            field_name = %w[file_id file_hash file_hash_16k][idx]
+            if hash.bytesize != 16
+              raise ArgumentError,
+                    "#{field_name} must be 16 bytes, got #{hash.bytesize}"
+            end
+          end
+
+          # Write hashes
+          data << file_id
+          data << file_hash
+          data << file_hash_16k
+
+          # Write length (8 bytes, little-endian)
+          data << [length].pack("Q<")
+
+          # Write filename (null-terminated, padded to multiple of 4)
+          data << filename
+          data << "\x00"
+
+          # Add padding to make total length multiple of 4
+          padding = (4 - ((filename.bytesize + 1) % 4)) % 4
+          data << ("\x00" * padding) if padding.positive?
+
+          self.body_data = data
+        end
+
+        # Get basename of file
+        #
+        # @return [String] File basename
+        def basename
+          File.basename(filename)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require_relative "packet"
+
+module Omnizip
+  module Parity
+    module Models
+      # PAR2 IFSC (Input File Slice Checksum) packet
+      #
+      # Contains checksums for individual data blocks of a file.
+      # One IFSC packet contains checksums for ALL blocks of a file.
+      #
+      # Body structure:
+      # - file_id (16 bytes): File identifier
+      # - For each block:
+      #   - block_hash (16 bytes): MD5 hash of block data
+      #   - block_crc32 (4 bytes, L<): CRC32 of block data
+      class IfscPacket < Packet
+        # Packet type identifier
+        PACKET_TYPE = "PAR 2.0\x00IFSC\x00\x00\x00\x00"
+
+        # File identifier (16 bytes)
+        attribute :file_id, :string
+
+        # Array of block hashes (16 bytes MD5 each)
+        attribute :block_hashes, :string, collection: true, default: -> { [] }
+
+        # Array of block CRC32s (4 bytes each)
+        attribute :block_crc32s, :integer, collection: true, default: -> { [] }
+
+        # Initialize IFSC packet
+        #
+        # @param attributes [Hash] Packet attributes
+        def initialize(**attributes)
+          super
+          self.type = PACKET_TYPE
+          self.block_hashes = [] if block_hashes.nil?
+          self.block_crc32s = [] if block_crc32s.nil?
+        end
+
+        # Parse body data into attributes
+        #
+        # Body format:
+        # - file_id: 16 bytes
+        # - For each block:
+        #   - block_hash: 16 bytes
+        #   - block_crc32: 4 bytes (L<)
+        def parse_body
+          return if body_data.nil? || body_data.empty?
+          return if body_data.bytesize < 16
+
+          pos = 0
+
+          # Read file_id (16 bytes)
+          self.file_id = body_data[pos, 16]
+          pos += 16
+
+          # Read all blocks (each is 16 bytes hash + 4 bytes CRC = 20 bytes)
+          self.block_hashes = []
+          self.block_crc32s = []
+
+          while pos + 20 <= body_data.bytesize
+            # Read block_hash (16 bytes)
+            block_hash = body_data[pos, 16]
+            pos += 16
+
+            # Read block_crc32 (4 bytes, little-endian unsigned 32-bit)
+            block_crc32 = body_data[pos, 4].unpack1("L<")
+            pos += 4
+
+            block_hashes << block_hash
+            block_crc32s << block_crc32
+          end
+        end
+
+        # Build body data from attributes
+        #
+        # Constructs binary body data
+        #
+        # @return [String] Binary body data
+        def build_body
+          data = +""
+
+          # Validate file_id is 16 bytes
+          if file_id.bytesize != 16
+            raise ArgumentError,
+                  "file_id must be 16 bytes, got #{file_id.bytesize}"
+          end
+
+          # Write file_id
+          data << file_id
+
+          # Write all blocks
+          block_hashes.each_with_index do |block_hash, i|
+            # Validate block_hash is 16 bytes
+            if block_hash.bytesize != 16
+              raise ArgumentError,
+                    "block_hash must be 16 bytes, got #{block_hash.bytesize}"
+            end
+
+            # Write block_hash
+            data << block_hash
+
+            # Write block_crc32 (4 bytes, little-endian)
+            data << [block_crc32s[i]].pack("L<")
+          end
+
+          self.body_data = data
+        end
+
+        # Deprecated: for backward compatibility
+        def block_hash
+          block_hashes.first
+        end
+
+        # Deprecated: for backward compatibility
+        def block_crc32
+          block_crc32s.first
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require_relative "packet"
+
+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