@ai-ecoverse/wasix-ruby 3.4.11-1

package/lib/ruby/3.4.11/rubygems/package/tar_header.rb

@@ -0,0 +1,277 @@
+# frozen_string_literal: true
+
+# rubocop:disable Style/AsciiComments
+
+# Copyright (C) 2004 Mauricio Julio Fernández Pradier
+# See LICENSE.txt for additional licensing information.
+
+# rubocop:enable Style/AsciiComments
+
+##
+#--
+# struct tarfile_entry_posix {
+#   char name[100];     # ASCII + (Z unless filled)
+#   char mode[8];       # 0 padded, octal, null
+#   char uid[8];        # ditto
+#   char gid[8];        # ditto
+#   char size[12];      # 0 padded, octal, null
+#   char mtime[12];     # 0 padded, octal, null
+#   char checksum[8];   # 0 padded, octal, null, space
+#   char typeflag[1];   # file: "0"  dir: "5"
+#   char linkname[100]; # ASCII + (Z unless filled)
+#   char magic[6];      # "ustar\0"
+#   char version[2];    # "00"
+#   char uname[32];     # ASCIIZ
+#   char gname[32];     # ASCIIZ
+#   char devmajor[8];   # 0 padded, octal, null
+#   char devminor[8];   # o padded, octal, null
+#   char prefix[155];   # ASCII + (Z unless filled)
+# };
+#++
+# A header for a tar file
+
+class Gem::Package::TarHeader
+  ##
+  # Fields in the tar header
+
+  FIELDS = [
+    :checksum,
+    :devmajor,
+    :devminor,
+    :gid,
+    :gname,
+    :linkname,
+    :magic,
+    :mode,
+    :mtime,
+    :name,
+    :prefix,
+    :size,
+    :typeflag,
+    :uid,
+    :uname,
+    :version,
+  ].freeze
+
+  ##
+  # Pack format for a tar header
+
+  PACK_FORMAT = "a100" + # name
+                "a8"   + # mode
+                "a8"   + # uid
+                "a8"   + # gid
+                "a12"  + # size
+                "a12"  + # mtime
+                "a7a"  + # chksum
+                "a"    + # typeflag
+                "a100" + # linkname
+                "a6"   + # magic
+                "a2"   + # version
+                "a32"  + # uname
+                "a32"  + # gname
+                "a8"   + # devmajor
+                "a8"   + # devminor
+                "a155"   # prefix
+
+  ##
+  # Unpack format for a tar header
+
+  UNPACK_FORMAT = "A100" + # name
+                  "A8"   + # mode
+                  "A8"   + # uid
+                  "A8"   + # gid
+                  "A12"  + # size
+                  "A12"  + # mtime
+                  "A8"   + # checksum
+                  "A"    + # typeflag
+                  "A100" + # linkname
+                  "A6"   + # magic
+                  "A2"   + # version
+                  "A32"  + # uname
+                  "A32"  + # gname
+                  "A8"   + # devmajor
+                  "A8"   + # devminor
+                  "A155"   # prefix
+
+  attr_reader(*FIELDS)
+
+  EMPTY_HEADER = ("\0" * 512).b.freeze # :nodoc:
+
+  ##
+  # Creates a tar header from IO +stream+
+
+  def self.from(stream)
+    header = stream.read 512
+    return EMPTY if header == EMPTY_HEADER
+
+    fields = header.unpack UNPACK_FORMAT
+
+    new name: fields.shift,
+        mode: strict_oct(fields.shift),
+        uid: oct_or_256based(fields.shift),
+        gid: oct_or_256based(fields.shift),
+        size: strict_oct(fields.shift),
+        mtime: strict_oct(fields.shift),
+        checksum: strict_oct(fields.shift),
+        typeflag: fields.shift,
+        linkname: fields.shift,
+        magic: fields.shift,
+        version: strict_oct(fields.shift),
+        uname: fields.shift,
+        gname: fields.shift,
+        devmajor: strict_oct(fields.shift),
+        devminor: strict_oct(fields.shift),
+        prefix: fields.shift,
+
+        empty: false
+  end
+
+  def self.strict_oct(str)
+    str.strip!
+    return str.oct if /\A[0-7]*\z/.match?(str)
+
+    raise ArgumentError, "#{str.inspect} is not an octal string"
+  end
+
+  def self.oct_or_256based(str)
+    # \x80 flags a positive 256-based number
+    # \ff flags a negative 256-based number
+    # In case we have a match, parse it as a signed binary value
+    # in big-endian order, except that the high-order bit is ignored.
+
+    return str.unpack1("@4N") if /\A[\x80\xff]/n.match?(str)
+    strict_oct(str)
+  end
+
+  ##
+  # Creates a new TarHeader using +vals+
+
+  def initialize(vals)
+    unless vals[:name] && vals[:size] && vals[:prefix] && vals[:mode]
+      raise ArgumentError, ":name, :size, :prefix and :mode required"
+    end
+
+    @checksum = vals[:checksum] || ""
+    @devmajor = vals[:devmajor] || 0
+    @devminor = vals[:devminor] || 0
+    @gid = vals[:gid] || 0
+    @gname = vals[:gname] || "wheel"
+    @linkname = vals[:linkname]
+    @magic = vals[:magic] || "ustar"
+    @mode = vals[:mode]
+    @mtime = vals[:mtime] || 0
+    @name = vals[:name]
+    @prefix = vals[:prefix]
+    @size = vals[:size]
+    @typeflag = vals[:typeflag]
+    @typeflag = "0" if @typeflag.nil? || @typeflag.empty?
+    @uid = vals[:uid] || 0
+    @uname = vals[:uname] || "wheel"
+    @version = vals[:version] || "00"
+
+    @empty = vals[:empty]
+  end
+
+  EMPTY = new({ # :nodoc:
+    checksum: 0,
+    gname: "",
+    linkname: "",
+    magic: "",
+    mode: 0,
+    name: "",
+    prefix: "",
+    size: 0,
+    uname: "",
+    version: 0,
+
+    empty: true,
+  }).freeze
+  private_constant :EMPTY
+
+  ##
+  # Is the tar entry empty?
+
+  def empty?
+    @empty
+  end
+
+  def ==(other) # :nodoc:
+    self.class === other &&
+      @checksum == other.checksum &&
+      @devmajor == other.devmajor &&
+      @devminor == other.devminor &&
+      @gid      == other.gid      &&
+      @gname    == other.gname    &&
+      @linkname == other.linkname &&
+      @magic    == other.magic    &&
+      @mode     == other.mode     &&
+      @mtime    == other.mtime    &&
+      @name     == other.name     &&
+      @prefix   == other.prefix   &&
+      @size     == other.size     &&
+      @typeflag == other.typeflag &&
+      @uid      == other.uid      &&
+      @uname    == other.uname    &&
+      @version  == other.version
+  end
+
+  def to_s # :nodoc:
+    update_checksum
+    header
+  end
+
+  ##
+  # Updates the TarHeader's checksum
+
+  def update_checksum
+    header = header " " * 8
+    @checksum = oct calculate_checksum(header), 6
+  end
+
+  ##
+  # Header's full name, including prefix
+
+  def full_name
+    if prefix != ""
+      File.join prefix, name
+    else
+      name
+    end
+  end
+
+  private
+
+  def calculate_checksum(header)
+    header.sum(0)
+  end
+
+  def header(checksum = @checksum)
+    header = [
+      name,
+      oct(mode, 7),
+      oct(uid, 7),
+      oct(gid, 7),
+      oct(size, 11),
+      oct(mtime, 11),
+      checksum,
+      " ",
+      typeflag,
+      linkname,
+      magic,
+      oct(version, 2),
+      uname,
+      gname,
+      oct(devmajor, 7),
+      oct(devminor, 7),
+      prefix,
+    ]
+
+    header = header.pack PACK_FORMAT
+
+    header.ljust 512, "\0"
+  end
+
+  def oct(num, len)
+    format("%0#{len}o", num)
+  end
+end

package/lib/ruby/3.4.11/rubygems/package/tar_reader/entry.rb

@@ -0,0 +1,244 @@
+# frozen_string_literal: true
+
+# rubocop:disable Style/AsciiComments
+
+# Copyright (C) 2004 Mauricio Julio Fernández Pradier
+# See LICENSE.txt for additional licensing information.
+
+# rubocop:enable Style/AsciiComments
+
+##
+# Class for reading entries out of a tar file
+
+class Gem::Package::TarReader::Entry
+  ##
+  # Creates a new tar entry for +header+ that will be read from +io+
+  # If a block is given, the entry is yielded and then closed.
+
+  def self.open(header, io, &block)
+    entry = new header, io
+    return entry unless block_given?
+    begin
+      yield entry
+    ensure
+      entry.close
+    end
+  end
+
+  ##
+  # Header for this tar entry
+
+  attr_reader :header
+
+  ##
+  # Creates a new tar entry for +header+ that will be read from +io+
+
+  def initialize(header, io)
+    @closed = false
+    @header = header
+    @io = io
+    @orig_pos = @io.pos
+    @end_pos = @orig_pos + @header.size
+    @read = 0
+  end
+
+  def check_closed # :nodoc:
+    raise IOError, "closed #{self.class}" if closed?
+  end
+
+  ##
+  # Number of bytes read out of the tar entry
+
+  def bytes_read
+    @read
+  end
+
+  ##
+  # Closes the tar entry
+
+  def close
+    return if closed?
+    # Seek to the end of the entry if it wasn't fully read
+    seek(0, IO::SEEK_END)
+    # discard trailing zeros
+    skip = (512 - (@header.size % 512)) % 512
+    @io.read(skip)
+    @closed = true
+    nil
+  end
+
+  ##
+  # Is the tar entry closed?
+
+  def closed?
+    @closed
+  end
+
+  ##
+  # Are we at the end of the tar entry?
+
+  def eof?
+    check_closed
+
+    @read >= @header.size
+  end
+
+  ##
+  # Full name of the tar entry
+
+  def full_name
+    @header.full_name.force_encoding(Encoding::UTF_8)
+  rescue ArgumentError => e
+    raise unless e.message == "string contains null byte"
+    raise Gem::Package::TarInvalidError,
+          "tar is corrupt, name contains null byte"
+  end
+
+  ##
+  # Read one byte from the tar entry
+
+  def getc
+    return nil if eof?
+
+    ret = @io.getc
+    @read += 1 if ret
+
+    ret
+  end
+
+  ##
+  # Is this tar entry a directory?
+
+  def directory?
+    @header.typeflag == "5"
+  end
+
+  ##
+  # Is this tar entry a file?
+
+  def file?
+    @header.typeflag == "0"
+  end
+
+  ##
+  # Is this tar entry a symlink?
+
+  def symlink?
+    @header.typeflag == "2"
+  end
+
+  ##
+  # The position in the tar entry
+
+  def pos
+    check_closed
+
+    bytes_read
+  end
+
+  ##
+  # Seek to the position in the tar entry
+
+  def pos=(new_pos)
+    seek(new_pos, IO::SEEK_SET)
+  end
+
+  def size
+    @header.size
+  end
+
+  alias_method :length, :size
+
+  ##
+  # Reads +maxlen+ bytes from the tar file entry, or the rest of the entry if nil
+
+  def read(maxlen = nil)
+    if eof?
+      return maxlen.to_i.zero? ? "" : nil
+    end
+
+    max_read = [maxlen, @header.size - @read].compact.min
+
+    ret = @io.read max_read
+    if ret.nil?
+      return maxlen ? nil : "" # IO.read returns nil on EOF with len argument
+    end
+    @read += ret.size
+
+    ret
+  end
+
+  def readpartial(maxlen, outbuf = "".b)
+    if eof? && maxlen > 0
+      raise EOFError, "end of file reached"
+    end
+
+    max_read = [maxlen, @header.size - @read].min
+
+    @io.readpartial(max_read, outbuf)
+    @read += outbuf.size
+
+    outbuf
+  end
+
+  ##
+  # Seeks to +offset+ bytes into the tar file entry
+  # +whence+ can be IO::SEEK_SET, IO::SEEK_CUR, or IO::SEEK_END
+
+  def seek(offset, whence = IO::SEEK_SET)
+    check_closed
+
+    new_pos =
+      case whence
+      when IO::SEEK_SET then @orig_pos + offset
+      when IO::SEEK_CUR then @io.pos + offset
+      when IO::SEEK_END then @end_pos + offset
+      else
+        raise ArgumentError, "invalid whence"
+      end
+
+    if new_pos < @orig_pos
+      new_pos = @orig_pos
+    elsif new_pos > @end_pos
+      new_pos = @end_pos
+    end
+
+    pending = new_pos - @io.pos
+
+    return 0 if pending == 0
+
+    if @io.respond_to?(:seek)
+      begin
+        # avoid reading if the @io supports seeking
+        @io.seek new_pos, IO::SEEK_SET
+        pending = 0
+      rescue Errno::EINVAL
+      end
+    end
+
+    # if seeking isn't supported or failed
+    # negative seek requires that we rewind and read
+    if pending < 0
+      @io.rewind
+      pending = new_pos
+    end
+
+    while pending > 0 do
+      size_read = @io.read([pending, 4096].min)&.size
+      raise(EOFError, "end of file reached") if size_read.nil?
+      pending -= size_read
+    end
+
+    @read = @io.pos - @orig_pos
+
+    0
+  end
+
+  ##
+  # Rewinds to the beginning of the tar file entry
+
+  def rewind
+    check_closed
+    seek(0, IO::SEEK_SET)
+  end
+end

package/lib/ruby/3.4.11/rubygems/package/tar_reader.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+# rubocop:disable Style/AsciiComments
+
+# Copyright (C) 2004 Mauricio Julio Fernández Pradier
+# See LICENSE.txt for additional licensing information.
+
+# rubocop:enable Style/AsciiComments
+
+##
+# TarReader reads tar files and allows iteration over their items
+
+class Gem::Package::TarReader
+  include Enumerable
+
+  ##
+  # Creates a new TarReader on +io+ and yields it to the block, if given.
+
+  def self.new(io)
+    reader = super
+
+    return reader unless block_given?
+
+    begin
+      yield reader
+    ensure
+      reader.close
+    end
+
+    nil
+  end
+
+  ##
+  # Creates a new tar file reader on +io+ which needs to respond to #pos,
+  # #eof?, #read, #getc and #pos=
+
+  def initialize(io)
+    @io = io
+    @init_pos = io.pos
+  end
+
+  ##
+  # Close the tar file
+
+  def close
+  end
+
+  ##
+  # Iterates over files in the tarball yielding each entry
+
+  def each
+    return enum_for __method__ unless block_given?
+
+    until @io.eof? do
+      begin
+        header = Gem::Package::TarHeader.from @io
+      rescue ArgumentError => e
+        # Specialize only exceptions from Gem::Package::TarHeader.strict_oct
+        raise e unless e.message.match?(/ is not an octal string$/)
+        raise Gem::Package::TarInvalidError, e.message
+      end
+
+      return if header.empty?
+      entry = Gem::Package::TarReader::Entry.new header, @io
+      yield entry
+      entry.close
+    end
+  end
+
+  alias_method :each_entry, :each
+
+  ##
+  # NOTE: Do not call #rewind during #each
+
+  def rewind
+    if @init_pos == 0
+      @io.rewind
+    else
+      @io.pos = @init_pos
+    end
+  end
+
+  ##
+  # Seeks through the tar file until it finds the +entry+ with +name+ and
+  # yields it.  Rewinds the tar file to the beginning when the block
+  # terminates.
+
+  def seek(name) # :yields: entry
+    found = find do |entry|
+      entry.full_name == name
+    end
+
+    return unless found
+
+    yield found
+  ensure
+    rewind
+  end
+end
+
+require_relative "tar_reader/entry"