archive-zip 0.3.0 → 0.4.0

data/lib/archive/zip/data_descriptor.rb

@@ -1,7 +1,9 @@
+# encoding: UTF-8
+
 module Archive; class Zip
-  # Archive::Zip::Entry::DataDescriptor is a convenience class which bundles
-  # imporant information concerning the compressed data in a ZIP archive entry
-  # and allows easy comparisons between instances of itself.
+  # Archive::Zip::DataDescriptor is a convenience class which bundles important
+  # information concerning the compressed data in a ZIP archive entry and allows
+  # easy comparisons between instances of itself.
   class DataDescriptor
     # Create a new instance of this class where <em>crc32</em>,
     # _compressed_size_, and _uncompressed_size_ are all integers representing a
@@ -41,7 +43,7 @@ module Archive; class Zip
     end
 
     # Writes the data wrapped in this object to _io_ which must be a writable,
-    # IO-like object prividing a _write_ method.  Returns the number of bytes
+    # IO-like object providing a _write_ method.  Returns the number of bytes
     # written.
     def dump(io)
       io.write(

data/lib/archive/zip/entry.rb

@@ -1,3 +1,7 @@
+# encoding: UTF-8
+
+require 'archive/support/ioextensions'
+require 'archive/support/binary_stringio'
 require 'archive/zip/codec/deflate'
 require 'archive/zip/codec/null_encryption'
 require 'archive/zip/codec/store'
@@ -197,33 +201,26 @@ module Archive; class Zip
     end
 
     # Creates and returns a new entry object by parsing from the current
-    # position of _io_.  _io_ must be a readable, IO-like object which provides
-    # a _readbytes_ method, and it must be positioned at the start of a central
-    # file record following the signature for that record.
+    # position of _io_.  _io_ must be a readable, IO-like object which is
+    # positioned at the start of a central file record following the signature
+    # for that record.
     #
-    # <b>NOTE:</b> For now _io_ MUST be seekable and report such by returning
-    # +true+ from its <i>seekable?</i> method.  See IO#seekable?.
+    # <b>NOTE:</b> For now _io_ MUST be seekable.
     #
     # Currently, the only entry objects returned are instances of
     # Archive::Zip::Entry::File, Archive::Zip::Entry::Directory, and
     # Archive::Zip::Entry::Symlink.  Any other kind of entry will be mapped into
     # an instance of Archive::Zip::Entry::File.
     #
-    # Raises Archive::Zip::IOError if _io_ is not seekable.  Raises
-    # Archive::Zip::EntryError for any other errors related to processing the
-    # entry.
+    # Raises Archive::Zip::EntryError for any other errors related to processing
+    # the entry.
     def self.parse(io)
-      # Error out if the IO object is not confirmed seekable.
-      unless io.respond_to?(:seekable?) and io.seekable? then
-        raise Zip::IOError, 'non-seekable IO object given'
-      end
-
       # Parse the central file record and then use the information found there
       # to locate and parse the corresponding local file record.
       cfr = parse_central_file_record(io)
       next_record_position = io.pos
       io.seek(cfr.local_header_position)
-      unless io.readbytes(4) == LFH_SIGNATURE then
+      unless IOExtensions.read_exactly(io, 4) == LFH_SIGNATURE then
         raise Zip::EntryError, 'bad local file header signature'
       end
       lfr = parse_local_file_record(io, cfr.compressed_size)
@@ -275,8 +272,6 @@ module Archive; class Zip
 
       # Set the expected data descriptor so that extraction can be verified.
       entry.expected_data_descriptor = expected_data_descriptor
-      # Record the raw file data for the entry.
-      entry.raw_data = IOWindow.new(io, io.pos, cfr.compressed_size)
       # Record the compression codec.
       entry.compression_codec = compression_codec
       # Record the encryption codec.
@@ -301,9 +296,9 @@ module Archive; class Zip
     private
 
     # Parses a central file record and returns a CFHRecord instance containing
-    # the parsed data.  _io_ must be a readable, IO-like object which provides a
-    # _readbytes_ method, and it must be positioned at the start of a central
-    # file record following the signature for that record.
+    # the parsed data.  _io_ must be a readable, IO-like object which is
+    # positioned at the start of a central file record following the signature
+    # for that record.
     def self.parse_central_file_record(io)
       cfr = CFHRecord.new
 
@@ -321,24 +316,27 @@ module Archive; class Zip
       cfr.disk_number_start,
       cfr.internal_file_attributes,
       cfr.external_file_attributes,
-      cfr.local_header_position = io.readbytes(42).unpack('vvvvVVVVvvvvvVV')
+      cfr.local_header_position =
+        IOExtensions.read_exactly(io, 42).unpack('vvvvVVVVvvvvvVV')
 
-      cfr.zip_path = io.readbytes(file_name_length)
-      cfr.extra_fields = parse_extra_fields(io.readbytes(extra_fields_length))
-      cfr.comment = io.readbytes(comment_length)
+      cfr.zip_path = IOExtensions.read_exactly(io, file_name_length)
+      cfr.extra_fields = parse_central_extra_fields(
+        IOExtensions.read_exactly(io, extra_fields_length)
+      )
+      cfr.comment = IOExtensions.read_exactly(io, comment_length)
 
       # Convert from MSDOS time to Unix time.
       cfr.mtime = DOSTime.new(dos_mtime).to_time
 
       cfr
-    rescue EOFError, TruncatedDataError
+    rescue EOFError
       raise Zip::EntryError, 'unexpected end of file'
     end
 
     # Parses a local file record and returns a LFHRecord instance containing the
-    # parsed data.  _io_ must be a readable, IO-like object which provides a
-    # readbytes method, and it must be positioned at the start of a local file
-    # record following the signature for that record.
+    # parsed data.  _io_ must be a readable, IO-like object which is positioned
+    # at the start of a local file record following the signature for that
+    # record.
     #
     # If the record to be parsed is flagged to have a trailing data descriptor
     # record, _expected_compressed_size_ must be set to an integer counting the
@@ -356,10 +354,13 @@ module Archive; class Zip
       lfr.compressed_size,
       lfr.uncompressed_size,
       file_name_length,
-      extra_fields_length = io.readbytes(26).unpack('vvvVVVVvv')
+      extra_fields_length =
+        IOExtensions.read_exactly(io, 26).unpack('vvvVVVVvv')
 
-      lfr.zip_path = io.readbytes(file_name_length)
-      lfr.extra_fields = parse_extra_fields(io.readbytes(extra_fields_length))
+      lfr.zip_path = IOExtensions.read_exactly(io, file_name_length)
+      lfr.extra_fields = parse_local_extra_fields(
+        IOExtensions.read_exactly(io, extra_fields_length)
+      )
 
       # Convert from MSDOS time to Unix time.
       lfr.mtime = DOSTime.new(dos_mtime).to_time
@@ -371,35 +372,60 @@ module Archive; class Zip
         # libraries create trailing data descriptor records with a preceding
         # signature while others do not.
         # This handles both cases.
-        possible_signature = io.readbytes(4)
+        possible_signature = IOExtensions.read_exactly(io, 4)
         if possible_signature == DD_SIGNATURE then
           lfr.crc32,
           lfr.compressed_size,
-          lfr.uncompressed_size = io.readbytes(12).unpack('VVV')
+          lfr.uncompressed_size =
+            IOExtensions.read_exactly(io, 12).unpack('VVV')
         else
           lfr.crc32 = possible_signature.unpack('V')[0]
           lfr.compressed_size,
-          lfr.uncompressed_size = io.readbytes(8).unpack('VV')
+          lfr.uncompressed_size = IOExtensions.read_exactly(io, 8).unpack('VV')
         end
         io.pos = saved_pos
       end
 
       lfr
-    rescue EOFError, TruncatedDataError
+    rescue EOFError
       raise Zip::EntryError, 'unexpected end of file'
     end
 
-    # Parses the extra fields for local and central file records and returns an
-    # array of extra field objects.  _bytes_ must be a String containing all of
-    # the extra field data to be parsed.
-    def self.parse_extra_fields(bytes)
-      StringIO.open(bytes) do |io|
+    # Parses the extra fields for central file records and returns an array of
+    # extra field objects.  _bytes_ must be a String containing all of the extra
+    # field data to be parsed.
+    def self.parse_central_extra_fields(bytes)
+      BinaryStringIO.open(bytes) do |io|
         extra_fields = []
         while ! io.eof? do
-          header_id, data_size = io.readbytes(4).unpack('vv')
-          data = io.readbytes(data_size)
+          begin
+            header_id, data_size = IOExtensions.read_exactly(io, 4).unpack('vv')
+            data = IOExtensions.read_exactly(io, data_size)
+          rescue ::EOFError
+            raise EntryError, 'insufficient data available'
+          end
+
+          extra_fields << ExtraField.parse_central(header_id, data)
+        end
+        extra_fields
+      end
+    end
+
+    # Parses the extra fields for local file records and returns an array of
+    # extra field objects.  _bytes_ must be a String containing all of the extra
+    # field data to be parsed.
+    def self.parse_local_extra_fields(bytes)
+      BinaryStringIO.open(bytes) do |io|
+        extra_fields = []
+        while ! io.eof? do
+          begin
+            header_id, data_size = IOExtensions.read_exactly(io, 4).unpack('vv')
+            data = IOExtensions.read_exactly(io, data_size)
+          rescue ::EOFError
+            raise EntryError, 'insufficient data available'
+          end
 
-          extra_fields << ExtraField.parse(header_id, data)
+          extra_fields << ExtraField.parse_local(header_id, data)
         end
         extra_fields
       end
@@ -474,10 +500,10 @@ module Archive; class Zip
     attr_accessor :mode
     # The comment associated with this entry.
     attr_accessor :comment
-    # An Archive::Zip::Entry::DataDescriptor instance which should contain the
-    # expected CRC32 checksum, compressed size, and uncompressed size for the
-    # file data.  When not +nil+, this is used by #extract to confirm that the
-    # data extraction was successful.
+    # An Archive::Zip::DataDescriptor instance which should contain the expected
+    # CRC32 checksum, compressed size, and uncompressed size for the file data.
+    # When not +nil+, this is used by #extract to confirm that the data
+    # extraction was successful.
     attr_accessor :expected_data_descriptor
     # The selected compression codec.
     attr_accessor :compression_codec
@@ -521,24 +547,37 @@ module Archive; class Zip
       false
     end
 
-    # Adds _extra_field_ as an extra field specification to this entry.  If
-    # _extra_field_ is an instance of
+    # Adds _extra_field_ as an extra field specification to *both* the central
+    # file record and the local file record of this entry.
+    #
+    # If _extra_field_ is an instance of
     # Archive::Zip::Entry::ExtraField::ExtendedTimestamp, the values of that
     # field are used to set mtime and atime for this entry.  If _extra_field_ is
     # an instance of Archive::Zip::Entry::ExtraField::Unix, the values of that
     # field are used to set mtime, atime, uid, and gid for this entry.
     def add_extra_field(extra_field)
-      @extra_field_data = nil
-      @extra_fields << extra_field
+      # Try to find an extra field with the same header ID already in the list
+      # and merge the new one with that if one exists; otherwise, add the new
+      # one to the list.
+      existing_extra_field = @extra_fields.find do |ef|
+        ef.header_id == extra_field.header_id
+      end
+      if existing_extra_field.nil? then
+        @extra_fields << extra_field
+      else
+        extra_field = existing_extra_field.merge(extra_field)
+      end
 
+      # Set some attributes of this entry based on the settings in select types
+      # of extra fields.
       if extra_field.kind_of?(ExtraField::ExtendedTimestamp) then
-        self.mtime = extra_field.mtime
-        self.atime = extra_field.atime
+        self.mtime = extra_field.mtime unless extra_field.mtime.nil?
+        self.atime = extra_field.atime unless extra_field.atime.nil?
       elsif extra_field.kind_of?(ExtraField::Unix) then
-        self.mtime = extra_field.mtime
-        self.atime = extra_field.atime
-        self.uid   = extra_field.uid
-        self.gid   = extra_field.gid
+        self.mtime = extra_field.mtime unless extra_field.mtime.nil?
+        self.atime = extra_field.atime unless extra_field.atime.nil?
+        self.uid   = extra_field.uid unless extra_field.uid.nil?
+        self.gid   = extra_field.gid unless extra_field.uid.nil?
       end
       self
     end
@@ -554,21 +593,34 @@ module Archive; class Zip
       @local_file_record_position = local_file_record_position
       bytes_written = 0
 
+      # Assume that no trailing data descriptor will be necessary.
+      need_trailing_data_descriptor = false
+      begin
+        io.pos
+      rescue Errno::ESPIPE
+        # A trailing data descriptor is required for non-seekable IO.
+        need_trailing_data_descriptor = true
+      end
+      if encryption_codec.class == Codec::TraditionalEncryption then
+        # HACK:
+        # According to the ZIP specification, a trailing data descriptor should
+        # only be required when writing to non-seekable IO , but InfoZIP
+        # *always* does this when using traditional encryption even though it
+        # will also write the data descriptor in the usual place if possible.
+        # Failure to emulate InfoZIP in this behavior will prevent InfoZIP
+        # compatibility with traditionally encrypted entries.
+        need_trailing_data_descriptor = true
+        # HACK:
+        # The InfoZIP implementation of traditional encryption requires that the
+        # the last modified file time be used as part of the encryption header.
+        # This is a deviation from the ZIP specification.
+        encryption_codec.mtime = mtime
+      end
+
+      # Set the general purpose flags.
       general_purpose_flags  = compression_codec.general_purpose_flags
       general_purpose_flags |= encryption_codec.general_purpose_flags
-
-      if ! io.seekable? ||
-         encryption_codec.class == Codec::TraditionalEncryption then
-        # Flag that the data descriptor record will follow the compressed file
-        # data of this entry.
-        #
-        # HACK:
-        # According to the ZIP specification, this should only be done if the IO
-        # object cannot be accessed randomly, but InfoZIP *always* sets this
-        # flag when using traditional encryption even though it will also write
-        # the data descriptor in the usual place if possible.  Failure to
-        # emulate InfoZIP in this behavior will prevent InfoZIP compatibility
-        # with traditionally encrypted entries.
+      if need_trailing_data_descriptor then
         general_purpose_flags |= FLAG_DATA_DESCRIPTOR_FOLLOWS
       end
 
@@ -579,7 +631,9 @@ module Archive; class Zip
         version_needed_to_extract = encryption_codec.version_needed_to_extract
       end
 
+      # Write the data.
       bytes_written += io.write(LFH_SIGNATURE)
+      extra_field_data = local_extra_field_data
       bytes_written += io.write(
         [
           version_needed_to_extract,
@@ -596,15 +650,6 @@ module Archive; class Zip
       bytes_written += io.write(zip_path)
       bytes_written += io.write(extra_field_data)
 
-      if encryption_codec.class == Codec::TraditionalEncryption then
-        # HACK:
-        # Traditional encryption requires that the last 2 bytes of the header it
-        # uses are the 2 low order bytes of the last modified file time in DOS
-        # format.  This is different than stated in the ZIP specification and
-        # rather comes from the InfoZIP implementation.
-        encryption_codec.mtime = mtime
-      end
-
       # Pipeline a compressor into an encryptor, write all the file data to the
       # compressor, and get a data descriptor from it.
       encryption_codec.encryptor(io, password) do |e|
@@ -619,31 +664,23 @@ module Archive; class Zip
         end
         e.close(false)
       end
-
       bytes_written += @data_descriptor.compressed_size
-      if io.seekable? then
+
+      # Write the trailing data descriptor if necessary.
+      if need_trailing_data_descriptor then
+        bytes_written += io.write(DD_SIGNATURE)
+        bytes_written += @data_descriptor.dump(io)
+      end
+
+      begin
         # Update the data descriptor located before the compressed data for the
         # entry.
         saved_position = io.pos
         io.pos = @local_file_record_position + 14
         @data_descriptor.dump(io)
         io.pos = saved_position
-      end
-
-      if ! io.seekable? ||
-         encryption_codec.class == Codec::TraditionalEncryption then
-        # Write the data descriptor after the compressed file data for the
-        # entry.
-        #
-        # HACK:
-        # According to the ZIP specification, this should only be done if the IO
-        # object cannot be accessed randomly, but InfoZIP *always* does this
-        # when using traditional encryption even though it will also write the
-        # data descriptor in the usual place if possible.  Failure to emulate
-        # InfoZIP in this behavior will prevent InfoZIP compatibility with
-        # traditionally encrypted entries.
-        bytes_written += io.write(DD_SIGNATURE)
-        bytes_written += @data_descriptor.dump(io)
+      rescue Errno::ESPIPE
+        # Ignore a failed attempt to update the data descriptor.
       end
 
       bytes_written
@@ -657,21 +694,29 @@ module Archive; class Zip
     def dump_central_file_record(io)
       bytes_written = 0
 
+      # Assume that no trailing data descriptor will be necessary.
+      need_trailing_data_descriptor = false
+      begin
+        io.pos
+      rescue Errno::ESPIPE
+        # A trailing data descriptor is required for non-seekable IO.
+        need_trailing_data_descriptor = true
+      end
+      if encryption_codec.class == Codec::TraditionalEncryption then
+        # HACK:
+        # According to the ZIP specification, a trailing data descriptor should
+        # only be required when writing to non-seekable IO , but InfoZIP
+        # *always* does this when using traditional encryption even though it
+        # will also write the data descriptor in the usual place if possible.
+        # Failure to emulate InfoZIP in this behavior will prevent InfoZIP
+        # compatibility with traditionally encrypted entries.
+        need_trailing_data_descriptor = true
+      end
+
+      # Set the general purpose flags.
       general_purpose_flags  = compression_codec.general_purpose_flags
       general_purpose_flags |= encryption_codec.general_purpose_flags
-
-      if ! io.seekable? ||
-         encryption_codec.class == Codec::TraditionalEncryption then
-        # Flag that the data descriptor record will follow the compressed file
-        # data of this entry.
-        #
-        # HACK:
-        # According to the ZIP specification, this should only be done if the IO
-        # object cannot be accessed randomly, but InfoZIP *always* sets this
-        # flag when using traditional encryption even though it will also write
-        # the data descriptor in the usual place if possible.  Failure to
-        # emulate InfoZIP in this behavior will prevent InfoZIP compatibility
-        # with encrypted entries.
+      if need_trailing_data_descriptor then
         general_purpose_flags |= FLAG_DATA_DESCRIPTOR_FOLLOWS
       end
 
@@ -682,6 +727,7 @@ module Archive; class Zip
         version_needed_to_extract = encryption_codec.version_needed_to_extract
       end
 
+      # Write the data.
       bytes_written += io.write(CFH_SIGNATURE)
       bytes_written += io.write(
         [
@@ -693,6 +739,7 @@ module Archive; class Zip
         ].pack('vvvvV')
       )
       bytes_written += @data_descriptor.dump(io)
+      extra_field_data = central_extra_field_data
       bytes_written += io.write(
         [
           zip_path.length,
@@ -717,19 +764,31 @@ module Archive; class Zip
       0x0314
     end
 
-    def extra_field_data
-      return @extra_field_data unless @extra_field_data.nil?
+    def central_extra_field_data
+      @central_extra_field_data = @extra_fields.collect do |extra_field|
+        extra_field.dump_central
+      end.join
+    end
 
-      @extra_field_data = @extra_fields.collect do |extra_field|
-        unless extra_field.kind_of?(ExtraField::ExtendedTimestamp) ||
-               extra_field.kind_of?(ExtraField::Unix) then
-          extra_field.dump
-        else
-          ''
-        end
-      end.join +
-        ExtraField::ExtendedTimestamp.new(mtime, atime, nil).dump +
-        ExtraField::Unix.new(mtime, atime, uid, gid).dump
+    def dummy
+      # Add fields for time data if available.
+      unless mtime.nil? && atime.nil? then
+        @central_extra_field_data +=
+          ExtraField::ExtendedTimestamp.new(mtime, atime, nil).dump_central
+      end
+
+      # Add fields for user and group ownerships if available.
+      unless uid.nil? || gid.nil? || mtime.nil? || atime.nil? then
+        @central_extra_field_data += ExtraField::Unix.new(
+          mtime, atime, uid, gid
+        ).dump_central
+      end
+    end
+
+    def local_extra_field_data
+      @local_extra_field_data = @extra_fields.collect do |extra_field|
+        extra_field.dump_local
+      end.join
     end
 
     def internal_file_attributes
@@ -1012,7 +1071,7 @@ module Archive; class Zip; module Entry
         )
       else
         if @file_path.nil? then
-          simulated_raw_data = StringIO.new
+          simulated_raw_data = BinaryStringIO.new
         else
           simulated_raw_data = ::File.new(@file_path, 'rb')
         end
@@ -1023,22 +1082,15 @@ module Archive; class Zip; module Entry
       @file_data
     end
 
-    # Sets the +file_data+ attribute of this object to _file_data_.  If
-    # _file_data_ is a String, it will be wrapped in a StringIO instance;
-    # otherwise, _file_data_ must be a readable, IO-like object.  _file_data_ is
-    # then wrapped inside an Archive::Zip::Codec::Store::Unstore instance before
-    # finally setting the +file_data+ attribute.
+    # Sets the +file_data+ attribute of this object to _file_data_.  _file_data_
+    # must be a readable, IO-like object.
     #
     # <b>NOTE:</b> As a side effect, the +file_path+ and +raw_data+ attributes
     # for this object will be set to +nil+.
     def file_data=(file_data)
       @file_path = nil
       self.raw_data = nil
-      if file_data.kind_of?(String)
-        @file_data = StringIO.new(file_data)
-      else
-        @file_data = file_data
-      end
+      @file_data = file_data
       # Ensure that the IO-like object can return CRC32 and data size
       # information so that it's possible to verify extraction later if desired.
       unless @file_data.respond_to?(:data_descriptor) then