rubyzip 1.0.0 → 2.4.1

data/lib/zip/entry_set.rb

@@ -5,8 +5,7 @@ module Zip
 
     def initialize(an_enumerable = [])
       super()
-      @entry_set   = {}
-      @entry_order = []
+      @entry_set = {}
       an_enumerable.each { |o| push(o) }
     end
 
@@ -19,54 +18,50 @@ module Zip
     end
 
     def <<(entry)
-      @entry_order.delete(to_key(entry))
-      @entry_order << to_key(entry)
-      @entry_set[to_key(entry)] = entry
+      @entry_set[to_key(entry)] = entry if entry
     end
 
-    alias :push :<<
+    alias push <<
 
     def size
       @entry_set.size
     end
 
-    alias :length :size
+    alias length size
 
     def delete(entry)
-      if @entry_order.delete(to_key(entry)) && @entry_set.delete(to_key(entry))
-        entry
-      else
-        nil
-      end
+      entry if @entry_set.delete(to_key(entry))
     end
 
-    def each(&block)
-      @entry_order.each do |key|
-        block.call @entry_set[key]
+    def each
+      @entry_set = sorted_entries.dup.each do |_, value|
+        yield(value)
       end
     end
 
     def entries
-      @entry_order.map { |key| @entry_set[key] }
+      sorted_entries.values
     end
 
     # deep clone
     def dup
-      EntrySet.new(@entry_order.map { |key| @entry_set[key].dup })
+      EntrySet.new(@entry_set.values.map(&:dup))
     end
 
     def ==(other)
       return false unless other.kind_of?(EntrySet)
-      @entry_set == other.entry_set && @entry_order == other.entry_order
+
+      @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)
+    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
@@ -74,9 +69,16 @@ module Zip
 
     protected
 
+    def sorted_entries
+      ::Zip.sort_entries ? Hash[@entry_set.sort] : @entry_set
+    end
+
     private
+
     def to_key(entry)
-      entry.to_s.sub(/\/$/, '')
+      k = entry.to_s.chomp('/')
+      k.downcase! if ::Zip.case_insensitive_match
+      k
     end
   end
 end

data/lib/zip/errors.rb

@@ -1,8 +1,19 @@
 module Zip
-  class ZipError < StandardError; end
-  class ZipEntryExistsError < ZipError; end
-  class ZipDestinationFileExistsError < ZipError; end
-  class ZipCompressionMethodError < ZipError; end
-  class ZipEntryNameError < ZipError; end
-  class ZipInternalError < ZipError; end
+  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

@@ -1,43 +1,44 @@
 module Zip
   class ExtraField::Generic
     def self.register_map
-      if self.const_defined?(:HEADER_ID)
-        ::Zip::ExtraField::ID_MAP[self.const_get(:HEADER_ID)] = self
-      end
+      return unless const_defined?(:HEADER_ID)
+
+      ::Zip::ExtraField::ID_MAP[const_get(:HEADER_ID)] = self
     end
 
     def self.name
-      self.to_s.split("::")[-1]
+      @name ||= to_s.split('::')[-1]
     end
 
     # return field [size, content] or false
     def initial_parse(binstr)
-      if !binstr
-        # If nil, start with empty.
-        return false
-      elsif binstr[0, 2] != self.class.const_get(:HEADER_ID)
-        $stderr.puts "Warning: weired extra feild header ID. skip parsing"
+      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].unpack("v")[0], binstr[4..-1]]
+
+      [binstr[2, 2].unpack1('v'), binstr[4..-1]]
     end
 
     def ==(other)
       return false if self.class != other.class
+
       each do |k, v|
-        v != other[k] and return false
+        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
+      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
+      self.class.const_get(:HEADER_ID) + [s.bytesize].pack('v') << s
     end
   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 = ''.b
+      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

@@ -1,27 +1,57 @@
 module Zip
   # Info-ZIP Additional timestamp field
   class ExtraField::UniversalTime < ExtraField::Generic
-    HEADER_ID = "UT"
+    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  = nil
-      binstr and merge(binstr)
+      @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
 
-    attr_accessor :atime, :ctime, :mtime, :flag
+    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)
-      size or return
-      @flag, mtime, atime, ctime = content.unpack("CVVV")
-      mtime and @mtime ||= ::Zip::DOSTime.at(mtime)
-      atime and @atime ||= ::Zip::DOSTime.at(atime)
-      ctime and @ctime ||= ::Zip::DOSTime.at(ctime)
+      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)
@@ -31,17 +61,17 @@ module Zip
     end
 
     def pack_for_local
-      s = [@flag].pack("C")
-      @flag & 1 != 0 and s << [@mtime.to_i].pack("V")
-      @flag & 2 != 0 and s << [@atime.to_i].pack("V")
-      @flag & 4 != 0 and s << [@ctime.to_i].pack("V")
+      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")
-      @flag & 1 == 1 and s << [@mtime.to_i].pack("V")
+      s = [@flag].pack('C')
+      s << [@mtime.to_i].pack('l<') unless @flag & MTIME_MASK == 0
       s
     end
   end
-end
+end

data/lib/zip/extra_field/unix.rb

@@ -1,25 +1,27 @@
 module Zip
   # Info-ZIP Extra for UNIX uid/gid
   class ExtraField::IUnix < ExtraField::Generic
-    HEADER_ID = "Ux"
+    HEADER_ID = 'Ux'
     register_map
 
     def initialize(binstr = nil)
       @uid = 0
       @gid = 0
-      binstr and merge(binstr)
+      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
+      return if !size || size == 0
+
+      uid, gid = content.unpack('vv')
+      @uid ||= uid
+      @gid ||= gid # rubocop:disable Naming/MemoizedInstanceVariableName
     end
 
     def ==(other)
@@ -27,12 +29,11 @@ module Zip
     end
 
     def pack_for_local
-      [@uid, @gid].pack("vv")
+      [@uid, @gid].pack('vv')
     end
 
     def pack_for_c_dir
       ''
     end
   end
-
-end
+end

data/lib/zip/extra_field/zip64.rb

@@ -2,29 +2,69 @@ 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 = "\001\000"
+    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 and merge(binstr)
+      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?
-      id, size, @original_size, @compressed_size, @relative_header_offset, @disk_start_number = binstr.to_s.unpack("vvQQQV")
+
+      _, @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
-      return '' unless @original_size && @compressed_sie && @relative_header_offset && @disk_start_number
-      [1, 16, @original_size, @compressed_size, @relative_header_offset, @disk_start_number].pack("vvQQQV")
+      # 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
-      pack_for_local
+      # central directory entries contain only fields that didn't fit in the main entry part
+      packed = ''.b
+      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

@@ -3,30 +3,30 @@ module Zip
     ID_MAP = {}
 
     def initialize(binstr = nil)
-      binstr and merge(binstr)
+      merge(binstr) if binstr
     end
 
-    def extra_field_type_exist(binstr, id, len, i)
+    def extra_field_type_exist(binstr, id, len, index)
       field_name = ID_MAP[id].name
-      if self.member?(field_name)
-        self[field_name].merge(binstr[i, len + 4])
+      if member?(field_name)
+        self[field_name].merge(binstr[index, len + 4])
       else
-        field_obj        = ID_MAP[id].new(binstr[i, len + 4])
+        field_obj        = ID_MAP[id].new(binstr[index, len + 4])
         self[field_name] = field_obj
       end
     end
 
-    def extra_field_type_unknown(binstr, len, i)
+    def extra_field_type_unknown(binstr, len, index)
       create_unknown_item unless self['Unknown']
-      if !len || len + 4 > binstr[i..-1].bytesize
-        self['Unknown'] << binstr[i..-1]
+      if !len || len + 4 > binstr[index..-1].bytesize
+        self['Unknown'] << binstr[index..-1]
         return
       end
-      self['Unknown'] << binstr[i, len + 4]
+      self['Unknown'] << binstr[index, len + 4]
     end
 
     def create_unknown_item
-      s = ''
+      s = +''
       class << s
         alias_method :to_c_dir_bin, :to_s
         alias_method :to_local_bin, :to_s
@@ -36,10 +36,11 @@ module Zip
 
     def merge(binstr)
       return if binstr.empty?
+
       i = 0
       while i < binstr.bytesize
         id  = binstr[i, 2]
-        len = binstr[i + 2, 2].to_s.unpack('v').first
+        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
@@ -51,20 +52,29 @@ module Zip
     end
 
     def create(name)
-      unless field_class = ID_MAP.values.find { |k| k.name == name }
-        raise ZipError, "Unknown extra field '#{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
-      self.map { |_, v| v.to_local_bin }.join
+      ordered_values.map! { |v| v.to_local_bin.force_encoding('BINARY') }.join
     end
 
-    alias :to_s :to_local_bin
+    alias to_s to_local_bin
 
     def to_c_dir_bin
-      self.map { |_, v| v.to_c_dir_bin }.join
+      ordered_values.map! { |v| v.to_c_dir_bin.force_encoding('BINARY') }.join
     end
 
     def c_dir_size
@@ -75,14 +85,18 @@ module Zip
       to_local_bin.bytesize
     end
 
-    alias :length :local_size
-    alias :size :local_size
+    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