rubyzip 0.9.1 → 2.3.2

data/lib/zip/entry_set.rb

@@ -0,0 +1,88 @@
+module Zip
+  class EntrySet #:nodoc:all
+    include Enumerable
+    attr_accessor :entry_set, :entry_order
+
+    def initialize(an_enumerable = [])
+      super()
+      @entry_set = {}
+      an_enumerable.each { |o| push(o) }
+    end
+
+    def include?(entry)
+      @entry_set.include?(to_key(entry))
+    end
+
+    def find_entry(entry)
+      @entry_set[to_key(entry)]
+    end
+
+    def <<(entry)
+      @entry_set[to_key(entry)] = entry if entry
+    end
+
+    alias push <<
+
+    def size
+      @entry_set.size
+    end
+
+    alias length size
+
+    def delete(entry)
+      entry if @entry_set.delete(to_key(entry))
+    end
+
+    def each
+      @entry_set = sorted_entries.dup.each do |_, value|
+        yield(value)
+      end
+    end
+
+    def entries
+      sorted_entries.values
+    end
+
+    # deep clone
+    def dup
+      EntrySet.new(@entry_set.values.map(&:dup))
+    end
+
+    def ==(other)
+      return false unless other.kind_of?(EntrySet)
+
+      @entry_set.values == other.entry_set.values
+    end
+
+    def parent(entry)
+      @entry_set[to_key(entry.parent_as_string)]
+    end
+
+    def glob(pattern, flags = ::File::FNM_PATHNAME | ::File::FNM_DOTMATCH | ::File::FNM_EXTGLOB)
+      entries.map do |entry|
+        next nil unless ::File.fnmatch(pattern, entry.name.chomp('/'), flags)
+
+        yield(entry) if block_given?
+        entry
+      end.compact
+    end
+
+    protected
+
+    def sorted_entries
+      ::Zip.sort_entries ? Hash[@entry_set.sort] : @entry_set
+    end
+
+    private
+
+    def to_key(entry)
+      k = entry.to_s.chomp('/')
+      k.downcase! if ::Zip.case_insensitive_match
+      k
+    end
+  end
+end
+
+# 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.

data/lib/zip/errors.rb

@@ -0,0 +1,19 @@
+module Zip
+  class Error < StandardError; end
+  class EntryExistsError < Error; end
+  class DestinationFileExistsError < Error; end
+  class CompressionMethodError < Error; end
+  class EntryNameError < Error; end
+  class EntrySizeError < Error; end
+  class InternalError < Error; end
+  class GPFBit3Error < Error; end
+  class DecompressionError < Error; end
+
+  # Backwards compatibility with v1 (delete in v2)
+  ZipError = Error
+  ZipEntryExistsError = EntryExistsError
+  ZipDestinationFileExistsError = DestinationFileExistsError
+  ZipCompressionMethodError = CompressionMethodError
+  ZipEntryNameError = EntryNameError
+  ZipInternalError = InternalError
+end

data/lib/zip/extra_field/generic.rb

@@ -0,0 +1,44 @@
+module Zip
+  class ExtraField::Generic
+    def self.register_map
+      return unless const_defined?(:HEADER_ID)
+
+      ::Zip::ExtraField::ID_MAP[const_get(:HEADER_ID)] = self
+    end
+
+    def self.name
+      @name ||= to_s.split('::')[-1]
+    end
+
+    # return field [size, content] or false
+    def initial_parse(binstr)
+      return false unless binstr
+
+      if binstr[0, 2] != self.class.const_get(:HEADER_ID)
+        warn 'WARNING: weird extra field header ID. Skip parsing it.'
+        return false
+      end
+
+      [binstr[2, 2].unpack1('v'), binstr[4..-1]]
+    end
+
+    def ==(other)
+      return false if self.class != other.class
+
+      each do |k, v|
+        return false if v != other[k]
+      end
+      true
+    end
+
+    def to_local_bin
+      s = pack_for_local
+      self.class.const_get(:HEADER_ID) + [s.bytesize].pack('v') << s
+    end
+
+    def to_c_dir_bin
+      s = pack_for_c_dir
+      self.class.const_get(:HEADER_ID) + [s.bytesize].pack('v') << s
+    end
+  end
+end

data/lib/zip/extra_field/ntfs.rb

@@ -0,0 +1,94 @@
+module Zip
+  # PKWARE NTFS Extra Field (0x000a)
+  # Only Tag 0x0001 is supported
+  class ExtraField::NTFS < ExtraField::Generic
+    HEADER_ID = [0x000A].pack('v')
+    register_map
+
+    WINDOWS_TICK = 10_000_000.0
+    SEC_TO_UNIX_EPOCH = 11_644_473_600
+
+    def initialize(binstr = nil)
+      @ctime = nil
+      @mtime = nil
+      @atime = nil
+      binstr && merge(binstr)
+    end
+
+    attr_accessor :atime, :ctime, :mtime
+
+    def merge(binstr)
+      return if binstr.empty?
+
+      size, content = initial_parse(binstr)
+      (size && content) || return
+
+      content = content[4..-1]
+      tags = parse_tags(content)
+
+      tag1 = tags[1]
+      return unless tag1
+
+      ntfs_mtime, ntfs_atime, ntfs_ctime = tag1.unpack('Q<Q<Q<')
+      ntfs_mtime && @mtime ||= from_ntfs_time(ntfs_mtime)
+      ntfs_atime && @atime ||= from_ntfs_time(ntfs_atime)
+      ntfs_ctime && @ctime ||= from_ntfs_time(ntfs_ctime)
+    end
+
+    def ==(other)
+      @mtime == other.mtime &&
+        @atime == other.atime &&
+        @ctime == other.ctime
+    end
+
+    # Info-ZIP note states this extra field is stored at local header
+    def pack_for_local
+      pack_for_c_dir
+    end
+
+    # But 7-zip for Windows only stores at central dir
+    def pack_for_c_dir
+      # reserved 0 and tag 1
+      s = [0, 1].pack('Vv')
+
+      tag1 = ''.force_encoding(Encoding::BINARY)
+      if @mtime
+        tag1 << [to_ntfs_time(@mtime)].pack('Q<')
+        if @atime
+          tag1 << [to_ntfs_time(@atime)].pack('Q<')
+          tag1 << [to_ntfs_time(@ctime)].pack('Q<') if @ctime
+        end
+      end
+      s << [tag1.bytesize].pack('v') << tag1
+      s
+    end
+
+    private
+
+    def parse_tags(content)
+      return {} if content.nil?
+
+      tags = {}
+      i = 0
+      while i < content.bytesize
+        tag, size = content[i, 4].unpack('vv')
+        i += 4
+        break unless tag && size
+
+        value = content[i, size]
+        i += size
+        tags[tag] = value
+      end
+
+      tags
+    end
+
+    def from_ntfs_time(ntfs_time)
+      ::Zip::DOSTime.at(ntfs_time / WINDOWS_TICK - SEC_TO_UNIX_EPOCH)
+    end
+
+    def to_ntfs_time(time)
+      ((time.to_f + SEC_TO_UNIX_EPOCH) * WINDOWS_TICK).to_i
+    end
+  end
+end

data/lib/zip/extra_field/old_unix.rb

@@ -0,0 +1,46 @@
+module Zip
+  # Olf Info-ZIP Extra for UNIX uid/gid and file timestampes
+  class ExtraField::OldUnix < ExtraField::Generic
+    HEADER_ID = 'UX'
+    register_map
+
+    def initialize(binstr = nil)
+      @uid = 0
+      @gid = 0
+      @atime = nil
+      @mtime = nil
+      binstr && merge(binstr)
+    end
+
+    attr_accessor :uid, :gid, :atime, :mtime
+
+    def merge(binstr)
+      return if binstr.empty?
+
+      size, content = initial_parse(binstr)
+      # size: 0 for central directory. 4 for local header
+      return if !size || size == 0
+
+      atime, mtime, uid, gid = content.unpack('VVvv')
+      @uid ||= uid
+      @gid ||= gid
+      @atime ||= atime
+      @mtime ||= mtime # rubocop:disable Naming/MemoizedInstanceVariableName
+    end
+
+    def ==(other)
+      @uid == other.uid &&
+        @gid == other.gid &&
+        @atime == other.atime &&
+        @mtime == other.mtime
+    end
+
+    def pack_for_local
+      [@atime, @mtime, @uid, @gid].pack('VVvv')
+    end
+
+    def pack_for_c_dir
+      [@atime, @mtime].pack('VV')
+    end
+  end
+end

data/lib/zip/extra_field/universal_time.rb

@@ -0,0 +1,77 @@
+module Zip
+  # Info-ZIP Additional timestamp field
+  class ExtraField::UniversalTime < ExtraField::Generic
+    HEADER_ID = 'UT'
+    register_map
+
+    ATIME_MASK = 0b010
+    CTIME_MASK = 0b100
+    MTIME_MASK = 0b001
+
+    def initialize(binstr = nil)
+      @ctime = nil
+      @mtime = nil
+      @atime = nil
+      @flag  = 0
+
+      merge(binstr) unless binstr.nil?
+    end
+
+    attr_reader :atime, :ctime, :mtime, :flag
+
+    def atime=(time)
+      @flag = time.nil? ? @flag & ~ATIME_MASK : @flag | ATIME_MASK
+      @atime = time
+    end
+
+    def ctime=(time)
+      @flag = time.nil? ? @flag & ~CTIME_MASK : @flag | CTIME_MASK
+      @ctime = time
+    end
+
+    def mtime=(time)
+      @flag = time.nil? ? @flag & ~MTIME_MASK : @flag | MTIME_MASK
+      @mtime = time
+    end
+
+    def merge(binstr)
+      return if binstr.empty?
+
+      size, content = initial_parse(binstr)
+      return if !size || size <= 0
+
+      @flag, *times = content.unpack('Cl<l<l<')
+
+      # Parse the timestamps, in order, based on which flags are set.
+      return if times[0].nil?
+
+      @mtime ||= ::Zip::DOSTime.at(times.shift) unless @flag & MTIME_MASK == 0
+      return if times[0].nil?
+
+      @atime ||= ::Zip::DOSTime.at(times.shift) unless @flag & ATIME_MASK == 0
+      return if times[0].nil?
+
+      @ctime ||= ::Zip::DOSTime.at(times.shift) unless @flag & CTIME_MASK == 0
+    end
+
+    def ==(other)
+      @mtime == other.mtime &&
+        @atime == other.atime &&
+        @ctime == other.ctime
+    end
+
+    def pack_for_local
+      s = [@flag].pack('C')
+      s << [@mtime.to_i].pack('l<') unless @flag & MTIME_MASK == 0
+      s << [@atime.to_i].pack('l<') unless @flag & ATIME_MASK == 0
+      s << [@ctime.to_i].pack('l<') unless @flag & CTIME_MASK == 0
+      s
+    end
+
+    def pack_for_c_dir
+      s = [@flag].pack('C')
+      s << [@mtime.to_i].pack('l<') unless @flag & MTIME_MASK == 0
+      s
+    end
+  end
+end

data/lib/zip/extra_field/unix.rb

@@ -0,0 +1,39 @@
+module Zip
+  # Info-ZIP Extra for UNIX uid/gid
+  class ExtraField::IUnix < ExtraField::Generic
+    HEADER_ID = 'Ux'
+    register_map
+
+    def initialize(binstr = nil)
+      @uid = 0
+      @gid = 0
+      binstr && merge(binstr)
+    end
+
+    attr_accessor :uid, :gid
+
+    def merge(binstr)
+      return if binstr.empty?
+
+      size, content = initial_parse(binstr)
+      # size: 0 for central directory. 4 for local header
+      return if !size || size == 0
+
+      uid, gid = content.unpack('vv')
+      @uid ||= uid
+      @gid ||= gid # rubocop:disable Naming/MemoizedInstanceVariableName
+    end
+
+    def ==(other)
+      @uid == other.uid && @gid == other.gid
+    end
+
+    def pack_for_local
+      [@uid, @gid].pack('vv')
+    end
+
+    def pack_for_c_dir
+      ''
+    end
+  end
+end

data/lib/zip/extra_field/zip64.rb

@@ -0,0 +1,70 @@
+module Zip
+  # Info-ZIP Extra for Zip64 size
+  class ExtraField::Zip64 < ExtraField::Generic
+    attr_accessor :original_size, :compressed_size, :relative_header_offset, :disk_start_number
+    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
+      @relative_header_offset = extract(8, 'Q<') if relative_header_offset && relative_header_offset == 0xFFFFFFFF
+      @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
+
+    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/zip/extra_field/zip64_placeholder.rb

@@ -0,0 +1,15 @@
+module Zip
+  # placeholder to reserve space for a Zip64 extra information record, for the
+  # local file header only, that we won't know if we'll need until after
+  # we write the file data
+  class ExtraField::Zip64Placeholder < ExtraField::Generic
+    HEADER_ID = ['9999'].pack('H*') # this ID is used by other libraries such as .NET's Ionic.zip
+    register_map
+
+    def initialize(_binstr = nil); end
+
+    def pack_for_local
+      "\x00" * 16
+    end
+  end
+end

data/lib/zip/extra_field.rb

@@ -0,0 +1,103 @@
+module Zip
+  class ExtraField < Hash
+    ID_MAP = {}
+
+    def initialize(binstr = nil)
+      merge(binstr) 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)
+      create_unknown_item unless self['Unknown']
+      if !len || len + 4 > binstr[index..-1].bytesize
+        self['Unknown'] << binstr[index..-1]
+        return
+      end
+      self['Unknown'] << binstr[index, len + 4]
+    end
+
+    def create_unknown_item
+      s = +''
+      class << s
+        alias_method :to_c_dir_bin, :to_s
+        alias_method :to_local_bin, :to_s
+      end
+      self['Unknown'] = s
+    end
+
+    def merge(binstr)
+      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)
+          extra_field_type_exist(binstr, id, len, i)
+        elsif id
+          create_unknown_item unless self['Unknown']
+          break unless extra_field_type_unknown(binstr, len, i)
+        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
+
+    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 'zip/extra_field/generic'
+require 'zip/extra_field/universal_time'
+require 'zip/extra_field/old_unix'
+require 'zip/extra_field/unix'
+require 'zip/extra_field/zip64'
+require 'zip/extra_field/zip64_placeholder'
+require 'zip/extra_field/ntfs'
+
+# 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.