omnizip 0.3.1

data/lib/omnizip/formats/zip/end_of_central_directory.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require_relative "constants"
+
+module Omnizip
+  module Formats
+    module Zip
+      # ZIP End of Central Directory Record
+      class EndOfCentralDirectory
+        include Constants
+
+        attr_accessor :signature, :disk_number, :disk_number_with_cd,
+                      :total_entries_this_disk, :total_entries,
+                      :central_directory_size, :central_directory_offset,
+                      :comment_length, :comment
+
+        def initialize(
+          signature: END_OF_CENTRAL_DIRECTORY_SIGNATURE,
+          disk_number: 0,
+          disk_number_with_cd: 0,
+          total_entries_this_disk: 0,
+          total_entries: 0,
+          central_directory_size: 0,
+          central_directory_offset: 0,
+          comment_length: 0,
+          comment: ""
+        )
+          @signature = signature
+          @disk_number = disk_number
+          @disk_number_with_cd = disk_number_with_cd
+          @total_entries_this_disk = total_entries_this_disk
+          @total_entries = total_entries
+          @central_directory_size = central_directory_size
+          @central_directory_offset = central_directory_offset
+          @comment_length = comment_length
+          @comment = comment
+        end
+
+        # Check if ZIP64 format is needed
+        def zip64?
+          total_entries == 0xFFFF ||
+            central_directory_size == ZIP64_LIMIT ||
+            central_directory_offset == ZIP64_LIMIT ||
+            disk_number == 0xFFFF ||
+            disk_number_with_cd == 0xFFFF
+        end
+
+        # Serialize to binary format
+        def to_binary
+          @comment_length = comment.bytesize
+
+          [
+            signature,
+            disk_number,
+            disk_number_with_cd,
+            total_entries_this_disk,
+            total_entries,
+            central_directory_size,
+            central_directory_offset,
+            comment_length,
+          ].pack("VvvvvVVv") +
+            comment.b
+        end
+
+        # Parse from binary data
+        def self.from_binary(data)
+          signature, disk_number, disk_number_with_cd,
+          total_entries_this_disk, total_entries,
+          central_directory_size, central_directory_offset,
+          comment_length = data.unpack("VvvvvVVv")
+
+          unless signature == END_OF_CENTRAL_DIRECTORY_SIGNATURE
+            raise Omnizip::FormatError,
+                  "Invalid EOCD signature"
+          end
+
+          comment = data[22, comment_length].to_s.force_encoding("UTF-8")
+
+          new(
+            signature: signature,
+            disk_number: disk_number,
+            disk_number_with_cd: disk_number_with_cd,
+            total_entries_this_disk: total_entries_this_disk,
+            total_entries: total_entries,
+            central_directory_size: central_directory_size,
+            central_directory_offset: central_directory_offset,
+            comment_length: comment_length,
+            comment: comment,
+          )
+        end
+
+        # Size of the record in bytes
+        def record_size
+          22 + comment_length
+        end
+
+        # Find EOCD record by scanning backwards from end of file
+        def self.find_in_file(io)
+          # Start from the end and work backwards
+          # EOCD is at least 22 bytes, can be up to 22 + MAX_COMMENT_LENGTH
+          io.seek(0, ::IO::SEEK_END)
+          file_size = io.pos
+
+          # Start searching from the end
+          max_comment_size = [file_size - 22, MAX_COMMENT_LENGTH].min
+          search_start = [file_size - 22 - max_comment_size, 0].max
+
+          io.seek(search_start, ::IO::SEEK_SET)
+          buffer = io.read(file_size - search_start)
+
+          # Search for EOCD signature from the end
+          signature_bytes = [END_OF_CENTRAL_DIRECTORY_SIGNATURE].pack("V")
+
+          (buffer.size - 22).downto(0) do |i|
+            if buffer[i, 4] == signature_bytes
+              # Found potential EOCD
+              eocd_data = buffer[i..]
+              comment_length = eocd_data[20, 2].unpack1("v")
+
+              # Verify this is the actual EOCD by checking if comment length matches
+              if i + 22 + comment_length == buffer.size
+                return from_binary(eocd_data)
+              end
+            end
+          end
+
+          raise Omnizip::FormatError,
+                "Could not find End of Central Directory record"
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/zip/local_file_header.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require_relative "constants"
+
+module Omnizip
+  module Formats
+    module Zip
+      # ZIP Local File Header
+      class LocalFileHeader
+        include Constants
+
+        attr_accessor :signature, :version_needed, :flags, :compression_method,
+                      :last_mod_time, :last_mod_date, :crc32,
+                      :compressed_size, :uncompressed_size,
+                      :filename_length, :extra_field_length,
+                      :filename, :extra_field
+
+        def initialize(
+          signature: LOCAL_FILE_HEADER_SIGNATURE,
+          version_needed: VERSION_DEFAULT,
+          flags: 0,
+          compression_method: COMPRESSION_STORE,
+          last_mod_time: 0,
+          last_mod_date: 0,
+          crc32: 0,
+          compressed_size: 0,
+          uncompressed_size: 0,
+          filename_length: 0,
+          extra_field_length: 0,
+          filename: "",
+          extra_field: ""
+        )
+          @signature = signature
+          @version_needed = version_needed
+          @flags = flags
+          @compression_method = compression_method
+          @last_mod_time = last_mod_time
+          @last_mod_date = last_mod_date
+          @crc32 = crc32
+          @compressed_size = compressed_size
+          @uncompressed_size = uncompressed_size
+          @filename_length = filename_length
+          @extra_field_length = extra_field_length
+          @filename = filename
+          @extra_field = extra_field
+        end
+
+        # Check if this is a directory entry
+        def directory?
+          filename.end_with?("/")
+        end
+
+        # Check if ZIP64 format is needed
+        def zip64?
+          compressed_size == ZIP64_LIMIT ||
+            uncompressed_size == ZIP64_LIMIT
+        end
+
+        # Check if entry is encrypted
+        def encrypted?
+          flags.anybits?(FLAG_ENCRYPTED)
+        end
+
+        # Check if data descriptor follows
+        def has_data_descriptor?
+          flags.anybits?(FLAG_DATA_DESCRIPTOR)
+        end
+
+        # Check if UTF-8 encoding is used
+        def utf8?
+          flags.anybits?(FLAG_UTF8)
+        end
+
+        # Serialize to binary format
+        def to_binary
+          @filename_length = filename.bytesize
+          @extra_field_length = extra_field.bytesize
+
+          [
+            signature,
+            version_needed,
+            flags,
+            compression_method,
+            last_mod_time,
+            last_mod_date,
+            crc32,
+            compressed_size,
+            uncompressed_size,
+            filename_length,
+            extra_field_length,
+          ].pack("VvvvvvVVVvv") +
+            filename.b +
+            extra_field.b
+        end
+
+        # Parse from binary data
+        def self.from_binary(data)
+          signature, version_needed, flags, compression_method,
+          last_mod_time, last_mod_date, crc32,
+          compressed_size, uncompressed_size,
+          filename_length, extra_field_length = data.unpack("VvvvvvVVVvv")
+
+          unless signature == LOCAL_FILE_HEADER_SIGNATURE
+            raise Omnizip::FormatError,
+                  "Invalid local file header signature"
+          end
+
+          offset = 30
+          filename = data[offset, filename_length].force_encoding("UTF-8")
+          offset += filename_length
+
+          extra_field = data[offset, extra_field_length]
+
+          new(
+            signature: signature,
+            version_needed: version_needed,
+            flags: flags,
+            compression_method: compression_method,
+            last_mod_time: last_mod_time,
+            last_mod_date: last_mod_date,
+            crc32: crc32,
+            compressed_size: compressed_size,
+            uncompressed_size: uncompressed_size,
+            filename_length: filename_length,
+            extra_field_length: extra_field_length,
+            filename: filename,
+            extra_field: extra_field,
+          )
+        end
+
+        # Size of the header in bytes
+        def header_size
+          30 + filename_length + extra_field_length
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/zip/reader.rb

@@ -0,0 +1,250 @@
+# frozen_string_literal: true
+
+require_relative "constants"
+require_relative "local_file_header"
+require_relative "central_directory_header"
+require_relative "end_of_central_directory"
+require_relative "unix_extra_field"
+require_relative "../../link_handler"
+
+module Omnizip
+  module Formats
+    module Zip
+      # ZIP archive reader
+      class Reader
+        include Constants
+
+        attr_reader :file_path, :entries
+
+        def initialize(file_path)
+          @file_path = file_path
+          @entries = []
+          @central_directory = []
+        end
+
+        # Read and parse the ZIP archive
+        def read
+          File.open(file_path, "rb") do |io|
+            read_from_io(io)
+          end
+          self
+        end
+
+        # Read from an IO object
+        def read_from_io(io)
+          # Find and read End of Central Directory
+          eocd = EndOfCentralDirectory.find_in_file(io)
+
+          # Read Central Directory
+          read_central_directory(io, eocd)
+
+          self
+        end
+
+        # Extract all files to a directory
+        def extract_all(output_dir, preserve_links: true,
+dereference_links: false)
+          entries.each do |entry|
+            extract_entry(entry, output_dir, preserve_links: preserve_links,
+                                             dereference_links: dereference_links)
+          end
+        end
+
+        # Extract a specific entry
+        def extract_entry(entry, output_dir, preserve_links: true,
+dereference_links: false)
+          output_path = File.join(output_dir, entry.filename)
+
+          if entry.directory?
+            FileUtils.mkdir_p(output_path)
+          elsif preserve_links && !dereference_links && entry.symlink?
+            extract_symlink(entry, output_dir)
+          else
+            FileUtils.mkdir_p(File.dirname(output_path))
+
+            File.open(file_path, "rb") do |io|
+              # Seek to local file header
+              io.seek(entry.local_header_offset, ::IO::SEEK_SET)
+
+              # Read fixed part of local file header (30 bytes)
+              fixed_header = io.read(30)
+
+              # Extract variable lengths from fixed header
+              _signature, _version, _flags, _method, _time, _date, _crc32,
+              _comp_size, _uncomp_size, filename_length, extra_length = fixed_header.unpack("VvvvvvVVVvv")
+
+              # Read variable parts
+              variable_data = io.read(filename_length + extra_length)
+
+              # Parse complete local file header
+              LocalFileHeader.from_binary(fixed_header + variable_data)
+
+              # Now we're positioned right after the local file header, read compressed data
+              compressed_data = io.read(entry.compressed_size)
+
+              # Decompress data
+              decompressed_data = decompress_data(
+                compressed_data,
+                entry.compression_method,
+                entry.uncompressed_size,
+              )
+
+              # Verify CRC
+              calculated_crc = Omnizip::Checksums::Crc32.new.tap do |c|
+                c.update(decompressed_data)
+              end.finalize
+              if calculated_crc != entry.crc32
+                raise Omnizip::ChecksumError,
+                      "CRC mismatch for #{entry.filename}"
+              end
+
+              # Write decompressed data
+              File.binwrite(output_path, decompressed_data)
+
+              # Set file permissions if Unix
+              if entry.unix_permissions.positive?
+                File.chmod(entry.unix_permissions & 0o777, output_path)
+              end
+            end
+          end
+        end
+
+        # Extract a symbolic link
+        def extract_symlink(entry, output_dir)
+          output_path = File.join(output_dir, entry.filename)
+
+          unless LinkHandler.symlink_supported?
+            warn "Warning: Symbolic links not supported on #{RUBY_PLATFORM}, extracting as regular file"
+            extract_entry(entry, output_dir, preserve_links: false)
+            return
+          end
+
+          target = entry.link_target
+          unless target
+            warn "Warning: No link target found for #{entry.filename}, skipping"
+            return
+          end
+
+          FileUtils.mkdir_p(File.dirname(output_path))
+
+          # Remove existing file/link if present
+          FileUtils.rm_f(output_path) if File.exist?(output_path) || File.symlink?(output_path)
+
+          LinkHandler.create_symlink(target, output_path)
+        end
+
+        # List all entries in the archive
+        def list_entries(show_links: false)
+          entries.map do |entry|
+            info = {
+              filename: entry.filename,
+              compressed_size: entry.compressed_size,
+              uncompressed_size: entry.uncompressed_size,
+              compression_method: compression_method_name(entry.compression_method),
+              crc32: entry.crc32,
+              directory: entry.directory?,
+            }
+
+            if show_links && entry.symlink?
+              info[:symlink] = true
+              info[:link_target] = entry.link_target
+            end
+
+            info
+          end
+        end
+
+        private
+
+        # Read central directory entries
+        def read_central_directory(io, eocd)
+          io.seek(eocd.central_directory_offset, ::IO::SEEK_SET)
+
+          eocd.total_entries.times do
+            header_data = io.read(46)
+            break unless header_data && header_data.size == 46
+
+            # Get dynamic field lengths
+            _, _, _, _, _, _, _, _, _, _,
+            filename_length, extra_field_length, comment_length = header_data.unpack("VvvvvvvVVVvvv")
+
+            # Read complete header
+            complete_data = header_data + io.read(filename_length + extra_field_length + comment_length)
+            entry = CentralDirectoryHeader.from_binary(complete_data)
+
+            @entries << entry
+            @central_directory << entry
+          end
+        end
+
+        # Decompress data based on compression method
+        def decompress_data(compressed_data, method, uncompressed_size)
+          case method
+          when COMPRESSION_STORE
+            compressed_data
+          when COMPRESSION_DEFLATE
+            decompress_deflate(compressed_data)
+          when COMPRESSION_BZIP2
+            decompress_bzip2(compressed_data)
+          when COMPRESSION_LZMA
+            decompress_lzma(compressed_data, uncompressed_size)
+          when COMPRESSION_ZSTANDARD
+            decompress_zstandard(compressed_data)
+          else
+            raise Omnizip::UnsupportedFormatError,
+                  "Unsupported compression method: #{method}"
+          end
+        end
+
+        # Decompress using Deflate
+        def decompress_deflate(data)
+          require "zlib"
+          # ZIP uses raw deflate without zlib wrapper
+          Zlib::Inflate.new(-Zlib::MAX_WBITS).inflate(data)
+        rescue StandardError => e
+          raise Omnizip::DecompressionError,
+                "Deflate decompression failed: #{e.message}"
+        end
+
+        # Decompress using BZip2
+        def decompress_bzip2(data)
+          algorithm = AlgorithmRegistry.get(:bzip2)
+          algorithm.decompress(data)
+        rescue StandardError => e
+          raise Omnizip::DecompressionError,
+                "BZip2 decompression failed: #{e.message}"
+        end
+
+        # Decompress using LZMA
+        def decompress_lzma(data, uncompressed_size)
+          algorithm = AlgorithmRegistry.get(:lzma)
+          algorithm.decompress(data, uncompressed_size: uncompressed_size)
+        rescue StandardError => e
+          raise Omnizip::DecompressionError,
+                "LZMA decompression failed: #{e.message}"
+        end
+
+        # Decompress using Zstandard
+        def decompress_zstandard(data)
+          algorithm = AlgorithmRegistry.get(:zstandard)
+          algorithm.decompress(data)
+        rescue StandardError => e
+          raise Omnizip::DecompressionError,
+                "Zstandard decompression failed: #{e.message}"
+        end
+
+        # Get human-readable compression method name
+        def compression_method_name(method)
+          case method
+          when COMPRESSION_STORE then "Store"
+          when COMPRESSION_DEFLATE then "Deflate"
+          when COMPRESSION_BZIP2 then "BZip2"
+          when COMPRESSION_LZMA then "LZMA"
+          when COMPRESSION_ZSTANDARD then "Zstandard"
+          else "Unknown (#{method})"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/zip/unix_extra_field.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module Zip
+      # Info-ZIP Unix extra field (tag 0x7875)
+      # Stores Unix-specific metadata including symbolic link targets
+      class UnixExtraField
+        UNIX_EXTRA_FIELD_TAG = 0x7875
+
+        attr_accessor :version, :uid_size, :uid, :gid_size, :gid, :link_target
+
+        def initialize(
+          version: 1,
+          uid: nil,
+          gid: nil,
+          link_target: nil
+        )
+          @version = version
+          @uid = uid
+          @gid = gid
+          @link_target = link_target
+
+          # Calculate sizes
+          @uid_size = uid ? [uid].pack("V").bytesize : 0
+          @gid_size = gid ? [gid].pack("V").bytesize : 0
+        end
+
+        # Check if this field contains a symbolic link target
+        def symlink?
+          !@link_target.nil? && !@link_target.empty?
+        end
+
+        # Serialize to binary format
+        def to_binary
+          data = [version].pack("C")
+
+          # Add UID if present
+          if @uid
+            data << [@uid_size].pack("C")
+            data << [@uid].pack("V")[0, @uid_size]
+          else
+            data << [0].pack("C")
+          end
+
+          # Add GID if present
+          if @gid
+            data << [@gid_size].pack("C")
+            data << [@gid].pack("V")[0, @gid_size]
+          else
+            data << [0].pack("C")
+          end
+
+          # Add link target if present (for symbolic links)
+          data << @link_target.b if @link_target
+
+          # Return with tag and size
+          [
+            UNIX_EXTRA_FIELD_TAG,
+            data.bytesize,
+          ].pack("vv") + data
+        end
+
+        # Parse from binary data
+        def self.from_binary(data)
+          return nil if data.nil? || data.bytesize < 3
+
+          version = data.unpack1("C")
+          offset = 1
+
+          # Read UID
+          uid_size = data[offset].unpack1("C")
+          offset += 1
+          uid = (data[offset, uid_size].unpack1("V") if uid_size.positive?)
+          offset += uid_size
+
+          # Read GID
+          gid_size = data[offset].unpack1("C")
+          offset += 1
+          gid = (data[offset, gid_size].unpack1("V") if gid_size.positive?)
+          offset += gid_size
+
+          # Read link target if present
+          link_target = if offset < data.bytesize
+                          data[offset..].force_encoding("UTF-8")
+                        end
+
+          new(
+            version: version,
+            uid: uid,
+            gid: gid,
+            link_target: link_target,
+          )
+        end
+
+        # Parse extra field from complete extra field data
+        def self.find_in_extra_field(extra_field_data)
+          return nil if extra_field_data.nil? || extra_field_data.empty?
+
+          offset = 0
+          while offset < extra_field_data.bytesize - 4
+            tag, size = extra_field_data[offset, 4].unpack("vv")
+
+            if tag == UNIX_EXTRA_FIELD_TAG
+              field_data = extra_field_data[offset + 4, size]
+              return from_binary(field_data)
+            end
+
+            offset += 4 + size
+          end
+
+          nil
+        end
+
+        # Create a Unix extra field for a symbolic link
+        def self.for_symlink(target, uid: nil, gid: nil)
+          new(
+            version: 1,
+            uid: uid,
+            gid: gid,
+            link_target: target,
+          )
+        end
+
+        # Create a Unix extra field for a hard link
+        def self.for_hardlink(uid: nil, gid: nil)
+          new(
+            version: 1,
+            uid: uid,
+            gid: gid,
+            link_target: nil,
+          )
+        end
+
+        # Get the size of this extra field in bytes
+        def size
+          to_binary.bytesize
+        end
+
+        # Convert to hash representation
+        def to_h
+          {
+            tag: UNIX_EXTRA_FIELD_TAG,
+            version: @version,
+            uid: @uid,
+            gid: @gid,
+            link_target: @link_target,
+          }
+        end
+      end
+    end
+  end
+end