ziperu 0.1.1-arm-linux-musl

data/lib/ziperu/extra_field/zip64.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+# Ported verbatim from rubyzip (Copyright (C) 2002-2026 the rubyzip authors).
+
+module Ziperu
+  # Info-ZIP Extra for Zip64 size
+  class ExtraField::Zip64 < ExtraField::Generic # :nodoc:
+    attr_accessor :compressed_size, :disk_start_number,
+                  :original_size, :relative_header_offset
+
+    HEADER_ID = ['0100'].pack('H*')
+    register_map
+
+    def initialize(binstr = nil)
+      # unparsed binary; we don't actually know what this contains
+      # without looking for FFs in the associated file header
+      # call parse after initializing with a binary string
+      @content                = nil
+      @original_size          = nil
+      @compressed_size        = nil
+      @relative_header_offset = nil
+      @disk_start_number      = nil
+      binstr && merge(binstr)
+    end
+
+    def ==(other)
+      other.original_size == @original_size &&
+        other.compressed_size == @compressed_size &&
+        other.relative_header_offset == @relative_header_offset &&
+        other.disk_start_number == @disk_start_number
+    end
+
+    def merge(binstr)
+      return if binstr.empty?
+
+      _, @content = initial_parse(binstr)
+    end
+
+    # pass the values from the base entry (if applicable)
+    # wider values are only present in the extra field for base values set to all FFs
+    # returns the final values for the four attributes (from the base or zip64 extra record)
+    def parse(original_size, compressed_size, relative_header_offset = nil, disk_start_number = nil)
+      @original_size = extract(8, 'Q<') if original_size == 0xFFFFFFFF
+      @compressed_size = extract(8, 'Q<') if compressed_size == 0xFFFFFFFF
+      if relative_header_offset && relative_header_offset == 0xFFFFFFFF
+        @relative_header_offset = extract(8, 'Q<')
+      end
+      @disk_start_number = extract(4, 'V') if disk_start_number && disk_start_number == 0xFFFF
+      @content = nil
+      [@original_size || original_size,
+       @compressed_size || compressed_size,
+       @relative_header_offset || relative_header_offset,
+       @disk_start_number || disk_start_number]
+    end
+
+    def extract(size, format)
+      @content.slice!(0, size).unpack1(format)
+    end
+    private :extract
+
+    # We can suppress the zip64 extra field unless we know the size is large or
+    # the relative header offset is large (for central directory entries).
+    def suppress?
+      !((@original_size && @original_size >= 0xFFFFFFFF) ||
+        (@relative_header_offset && @relative_header_offset >= 0xFFFFFFFF))
+    end
+
+    def pack_for_local
+      # Local header entries must contain original size and compressed size;
+      # other fields do not apply.
+      return '' unless @original_size && @compressed_size
+
+      [@original_size, @compressed_size].pack('Q<Q<')
+    end
+
+    def pack_for_c_dir
+      # central directory entries contain only fields that didn't fit in the main entry part
+      packed = (+'').force_encoding('BINARY')
+      packed << [@original_size].pack('Q<') if @original_size
+      packed << [@compressed_size].pack('Q<') if @compressed_size
+      packed << [@relative_header_offset].pack('Q<') if @relative_header_offset
+      packed << [@disk_start_number].pack('V') if @disk_start_number
+      packed
+    end
+  end
+end

data/lib/ziperu/extra_field.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+# Ported verbatim from rubyzip (Copyright (C) 2002-2026 the rubyzip authors).
+
+module Ziperu
+  class ExtraField < Hash # :nodoc:all
+    ID_MAP = {}
+
+    def initialize(binstr = nil, local: false)
+      merge(binstr, local: local) if binstr
+    end
+
+    def extra_field_type_exist(binstr, id, len, index)
+      field_name = ID_MAP[id].name
+      if member?(field_name)
+        self[field_name].merge(binstr[index, len + 4])
+      else
+        field_obj        = ID_MAP[id].new(binstr[index, len + 4])
+        self[field_name] = field_obj
+      end
+    end
+
+    def extra_field_type_unknown(binstr, len, index, local)
+      self[:unknown] ||= Unknown.new
+
+      if !len || len + 4 > binstr[index..].bytesize
+        self[:unknown].merge(binstr[index..], local: local)
+        return
+      end
+
+      self[:unknown].merge(binstr[index, len + 4], local: local)
+    end
+
+    def merge(binstr, local: false)
+      return if binstr.empty?
+
+      i = 0
+      while i < binstr.bytesize
+        id  = binstr[i, 2]
+        len = binstr[i + 2, 2].to_s.unpack1('v')
+        if id && ID_MAP.member?(id)
+          break if len.nil? # a known header cut off before its length
+
+          extra_field_type_exist(binstr, id, len, i)
+        elsif id
+          break unless extra_field_type_unknown(binstr, len, i, local)
+        end
+        i += len + 4
+      end
+    end
+
+    def create(name)
+      unless (field_class = ID_MAP.values.find { |k| k.name == name })
+        raise Error, "Unknown extra field '#{name}'"
+      end
+
+      self[name] = field_class.new
+    end
+
+    # Place Unknown last, so "extra" data that is missing the proper
+    # signature/size does not prevent known fields from being read back in.
+    def ordered_values
+      result = []
+      each { |k, v| k == :unknown ? result.push(v) : result.unshift(v) }
+      result
+    end
+
+    # Remove any extra fields that indicate they can be safely suppressed.
+    def suppress_fields!(fields)
+      reject! do |k, v|
+        v.suppress? if fields == true || [*fields].include?(k)
+      end
+    end
+
+    def to_local_bin
+      ordered_values.map! { |v| v.to_local_bin.force_encoding('BINARY') }.join
+    end
+
+    alias to_s to_local_bin
+
+    def to_c_dir_bin
+      ordered_values.map! { |v| v.to_c_dir_bin.force_encoding('BINARY') }.join
+    end
+
+    def c_dir_size
+      to_c_dir_bin.bytesize
+    end
+
+    def local_size
+      to_local_bin.bytesize
+    end
+
+    alias length local_size
+    alias size local_size
+  end
+end
+
+require 'ziperu/extra_field/unknown'
+require 'ziperu/extra_field/generic'
+require 'ziperu/extra_field/universal_time'
+require 'ziperu/extra_field/old_unix'
+require 'ziperu/extra_field/unix'
+require 'ziperu/extra_field/zip64'
+require 'ziperu/extra_field/ntfs'
+require 'ziperu/extra_field/aes'
+
+# Copyright (C) 2002, 2003 Thomas Sondergaard
+# rubyzip is free software; you can redistribute it and/or
+# modify it under the terms of the ruby license.