minitar 0.5.4 → 0.6

data/lib/minitar.rb

@@ -0,0 +1,12 @@
+# coding: utf-8
+
+require 'archive/tar/minitar'
+
+if defined? ::Minitar
+  warn <<-EOS
+::Minitar is already defined.
+This will conflict with future versions of minitar.
+  EOS
+else
+  ::Minitar = Archive::Tar::Minitar
+end

data/test/minitest_helper.rb

@@ -0,0 +1,11 @@
+# -*- ruby encoding: utf-8 -*-
+
+require 'fileutils'
+require 'minitar'
+
+gem 'minitest'
+require 'minitest/autorun'
+
+Dir.glob(File.join(File.dirname(__FILE__), 'support/*.rb')).each do |support|
+  require support
+end

data/test/support/tar_test_helpers.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module TarTestHelpers
+  Field = Struct.new(:name, :offset, :length)
+  def self.Field(name, length) # rubocop:disable Style/MethodName
+    @offset ||= 0
+    field = Field.new(name, @offset, length)
+    @offset += length
+    FIELDS[name] = field
+    FIELD_ORDER << name
+    field
+  end
+
+  private
+
+  FIELDS = {} # rubocop:disable Style/MutableConstant
+  FIELD_ORDER = [] # rubocop:disable Style/MutableConstant
+
+  Field('name', 100)
+  Field('mode', 8)
+  Field('uid', 8)
+  Field('gid', 8)
+  Field('size', 12)
+  Field('mtime', 12)
+  Field('checksum', 8)
+  Field('typeflag', 1)
+  Field('linkname', 100)
+  Field('magic', 6)
+  Field('version', 2)
+  Field('uname', 32)
+  Field('gname', 32)
+  Field('devmajor', 8)
+  Field('devminor', 8)
+  Field('prefix', 155)
+
+  BLANK_CHECKSUM = ' ' * 8
+  NULL_100 = "\0" * 100
+  USTAR = "ustar\0".freeze
+  DOUBLE_ZERO = '00'.freeze
+
+  def assert_headers_equal(expected, actual)
+    FIELD_ORDER.each do |field|
+      message = if field == 'checksum'
+                  'Header checksums are expected to match.'
+                else
+                  "Header field #{field} is expected to match."
+                end
+
+      offset = FIELDS[field].offset
+      length = FIELDS[field].length
+
+      assert_equal(expected[offset, length], actual[offset, length], message)
+    end
+  end
+
+  def assert_modes_equal(expected, actual, name)
+    return if Minitar.windows?
+
+    assert_equal(
+      mode_string(expected),
+      mode_string(actual),
+      "Mode for #{name} does not match"
+    )
+  end
+
+  def tar_file_header(fname, dname, mode, length)
+    update_checksum(header('0', fname, dname, length, mode))
+  end
+
+  def tar_dir_header(name, prefix, mode)
+    update_checksum(header('5', name, prefix, 0, mode))
+  end
+
+  def header(type, fname, dname, length, mode)
+    arr = [
+      asciiz(fname, 100), z(to_oct(mode, 7)), z(to_oct(nil, 7)),
+      z(to_oct(nil, 7)), z(to_oct(length, 11)), z(to_oct(0, 11)),
+      BLANK_CHECKSUM, type, NULL_100, USTAR, DOUBLE_ZERO, asciiz('', 32),
+      asciiz('', 32), z(to_oct(nil, 7)), z(to_oct(nil, 7)), asciiz(dname, 155)
+    ]
+    h = arr.join.bytes.to_a.pack('C100C8C8C8C12C12C8CC100C6C2C32C32C8C8C155')
+    ret = h + "\0" * (512 - h.size)
+    assert_equal(512, ret.size)
+    ret
+  end
+
+  def update_checksum(header)
+    header[FIELDS['checksum'].offset, FIELDS['checksum'].length] =
+      # inject(:+) was introduced in which version?
+      sp(z(to_oct(header.unpack('C*').inject { |a, e| a + e }, 6)))
+    header
+  end
+
+  def to_oct(n, pad_size)
+    if n.nil?
+      "\0" * pad_size
+    else
+      "%0#{pad_size}o" % n
+    end
+  end
+
+  def asciiz(str, length)
+    str + "\0" * (length - str.length)
+  end
+
+  def sp(s)
+    s + ' '
+  end
+
+  def z(s)
+    s + "\0"
+  end
+
+  def mode_string(value)
+    '%04o' % (value & 0o777)
+  end
+
+  Minitest::Test.send(:include, self)
+end

data/test/test_tar_header.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'minitest_helper'
+
+class TestTarHeader < Minitest::Test
+  def test_arguments_are_checked
+    ph = Archive::Tar::Minitar::PosixHeader
+    assert_raises(ArgumentError) {
+      ph.new(:name => '', :size => '', :mode => '')
+    }
+    assert_raises(ArgumentError) {
+      ph.new(:name => '', :size => '', :prefix => '')
+    }
+    assert_raises(ArgumentError) {
+      ph.new(:name => '', :prefix => '', :mode => '')
+    }
+    assert_raises(ArgumentError) {
+      ph.new(:prefix => '', :size => '', :mode => '')
+    }
+  end
+
+  def test_basic_headers
+    header = {
+      :name => 'bla',
+      :mode => 0o12345,
+      :size => 10,
+      :prefix => '',
+      :typeflag => '0'
+    }
+    assert_headers_equal(tar_file_header('bla', '', 0o12345, 10),
+      Archive::Tar::Minitar::PosixHeader.new(header).to_s)
+
+    header = {
+      :name => 'bla',
+      :mode => 0o12345,
+      :size => 0,
+      :prefix => '',
+      :typeflag => '5'
+    }
+    assert_headers_equal(tar_dir_header('bla', '', 0o12345),
+      Archive::Tar::Minitar::PosixHeader.new(header).to_s)
+  end
+
+  def test_long_name_works
+    header = {
+      :name => 'a' * 100, :mode => 0o12345, :size => 10, :prefix => ''
+    }
+    assert_headers_equal(tar_file_header('a' * 100, '', 0o12345, 10),
+      Archive::Tar::Minitar::PosixHeader.new(header).to_s)
+    header = {
+      :name => 'a' * 100, :mode => 0o12345, :size => 10, :prefix => 'bb' * 60
+    }
+    assert_headers_equal(tar_file_header('a' * 100, 'bb' * 60, 0o12345, 10),
+      Archive::Tar::Minitar::PosixHeader.new(header).to_s)
+  end
+
+  def test_from_stream
+    header = tar_file_header('a' * 100, '', 0o12345, 10)
+    header = StringIO.new(header)
+    h = Archive::Tar::Minitar::PosixHeader.from_stream(header)
+    assert_equal('a' * 100, h.name)
+    assert_equal(0o12345, h.mode)
+    assert_equal(10, h.size)
+    assert_equal('', h.prefix)
+    assert_equal('ustar', h.magic)
+  end
+
+  def test_from_stream_with_evil_name
+    header = tar_file_header("a \0" + "\0" * 97, '', 0o12345, 10)
+    header = StringIO.new(header)
+    h = Archive::Tar::Minitar::PosixHeader.from_stream header
+    assert_equal('a ', h.name)
+  end
+end

data/test/test_tar_input.rb

@@ -0,0 +1,167 @@
+#!/usr/bin/env ruby
+
+require 'minitar'
+require 'minitest_helper'
+require 'base64'
+require 'zlib'
+
+class TestTarInput < Minitest::Test
+  TEST_TGZ = Base64.decode64(<<-EOS).freeze
+H4sIAKJpllQAA0tJLEnUK0ks0kuvYqAVMDAwMDMxUQDR5mbmYNrACMIHA2MjIwUDc3NzEzMz
+QxMDAwUDQ2NTczMGBQOauQgJlBYDfQ90SiKQkZmHWx1QWVoaHnMgXlGA00MEyHdzMMzOnBbC
+wPz28n2uJgOR44Xrq7tsHc/utNe/9FdihkmH3pZ7+zOTRFREzkzYJ99iHHDn4n0/Wb3E8Ceq
+S0uOdSyMMg9Z+WVvX0vJucxs77vrvZf2arWcvHP9wa1Yp9lRnJmC59/P9+43PXum+tj7Ga+8
+rtT+u3d941e765Y/bOrnvpv8X6jtz+wKqyk/v3n8P5xlO3l/1dn9q9Zotpy5funw/Of77Y/5
+LVltz7ToTl7dXf5ppmf3n9p+PPxz/sz/qjZn9yf9Y4R7I2Ft3tqfPTUMGgMYlEMSpGXmpBrT
+2A5Qvjc1xZ3/DTDyv5GJmfFo/qcHCMnILFYAIlA6UDDWU+DlGmgXjYJRMApGwSgYBaNgFIyC
+UTAKRsEoGAWjYBSMglEwCkbBKBgFo2AUjIJRMApGwSgYBaNgFIwCUgAAGnyo6wAoAAA=
+  EOS
+  FILETIMES = Time.utc(2004).to_i
+
+  TEST_CONTENTS = {
+    'data.tar.gz' => { :size => 210, :mode => 0o644 },
+    'file3' => { :size => 18, :mode => 0o755 }
+  }.freeze
+
+  TEST_DATA_CONTENTS = {
+    'data/' => { :size => 0, :mode => 0o755 },
+    'data/__dir__/' => { :size => 0, :mode => 0o755 },
+    'data/file1' => { :size => 16, :mode => 0o644 },
+    'data/file2' => { :size => 16, :mode => 0o644 }
+  }.freeze
+
+  def setup
+    FileUtils.mkdir_p('data__')
+  end
+
+  def teardown
+    FileUtils.rm_rf('data__')
+  end
+
+  def test_each_works
+    reader = Zlib::GzipReader.new(StringIO.new(TEST_TGZ))
+    Minitar::Input.open(reader) do |stream|
+      outer = 0
+      stream.each.with_index do |entry, i|
+        assert_kind_of(Minitar::Reader::EntryStream, entry)
+        assert TEST_CONTENTS.key?(entry.name)
+
+        assert_equal(TEST_CONTENTS[entry.name][:size], entry.size, entry.name)
+        assert_modes_equal(TEST_CONTENTS[entry.name][:mode],
+          entry.mode, entry.name)
+        assert_equal(FILETIMES, entry.mtime, 'entry.mtime')
+
+        if i.zero?
+          data_reader = Zlib::GzipReader.new(StringIO.new(entry.read))
+          Minitar::Input.open(data_reader) do |is2|
+            inner = 0
+            is2.each_with_index do |entry2, _j|
+              assert_kind_of(Minitar::Reader::EntryStream, entry2)
+              assert TEST_DATA_CONTENTS.key?(entry2.name)
+              assert_equal(TEST_DATA_CONTENTS[entry2.name][:size], entry2.size,
+                entry2.name)
+              assert_modes_equal(TEST_DATA_CONTENTS[entry2.name][:mode],
+                entry2.mode, entry2.name)
+              assert_equal(FILETIMES, entry2.mtime, entry2.name)
+              inner += 1
+            end
+            assert_equal(4, inner)
+          end
+        end
+
+        outer += 1
+      end
+
+      assert_equal(2, outer)
+    end
+  end
+
+  def test_extract_entry_works
+    reader = Zlib::GzipReader.new(StringIO.new(TEST_TGZ))
+    Minitar::Input.open(reader) do |stream|
+      outer_count = 0
+      stream.each_with_index do |entry, i|
+        stream.extract_entry('data__', entry)
+        name = File.join('data__', entry.name)
+
+        assert TEST_CONTENTS.key?(entry.name)
+
+        if entry.directory?
+          assert(File.directory?(name))
+        else
+          assert(File.file?(name))
+
+          assert_equal(TEST_CONTENTS[entry.name][:size], File.stat(name).size)
+        end
+
+        assert_modes_equal(TEST_CONTENTS[entry.name][:mode],
+          File.stat(name).mode, entry.name)
+
+        if i.zero?
+          begin
+            ff = File.open(name, 'rb')
+            data_reader = Zlib::GzipReader.new(ff)
+            Minitar::Input.open(data_reader) do |is2|
+              is2.each_with_index do |entry2, _j|
+                is2.extract_entry('data__', entry2)
+                name2 = File.join('data__', entry2.name)
+
+                assert TEST_DATA_CONTENTS.key?(entry2.name)
+
+                if entry2.directory?
+                  assert(File.directory?(name2))
+                else
+                  assert(File.file?(name2))
+                  assert_equal(TEST_DATA_CONTENTS[entry2.name][:size],
+                    File.stat(name2).size)
+                end
+                assert_modes_equal(TEST_DATA_CONTENTS[entry2.name][:mode],
+                  File.stat(name2).mode, name2)
+              end
+            end
+          ensure
+            ff.close unless ff.closed?
+          end
+        end
+
+        outer_count += 1
+      end
+
+      assert_equal(2, outer_count)
+    end
+  end
+
+  def test_extract_entry_breaks_symlinks
+    return if Minitar.windows?
+
+    IO.respond_to?(:write) &&
+      IO.write('data__/file4', '') ||
+      File.open('data__/file4', 'w') { |f| f.write '' }
+
+    File.symlink('data__/file4', 'data__/file3')
+    File.symlink('data__/file4', 'data__/data')
+
+    Minitar.unpack(Zlib::GzipReader.new(StringIO.new(TEST_TGZ)), 'data__')
+    Minitar.unpack(Zlib::GzipReader.new(File.open('data__/data.tar.gz', 'rb')),
+      'data__')
+
+    refute File.symlink?('data__/file3')
+    refute File.symlink?('data__/data')
+  end
+
+  RELATIVE_DIRECTORY_TGZ = Base64.decode64 <<-EOS
+H4sICIIoKVgCA2JhZC1kaXIudGFyANPT0y8sTy0qqWSgHTAwMDAzMVEA0eZmpmDawAjChwEFQ2MDQyMg
+MDUzVDAwNDY0N2VQMGCgAygtLkksAjolEcjIzMOtDqgsLQ2/J0H+gNOjYBSMglEwyAEA2LchrwAGAAA=
+  EOS
+
+  def test_extract_entry_fails_with_relative_directory
+    reader = Zlib::GzipReader.new(StringIO.new(RELATIVE_DIRECTORY_TGZ))
+    Minitar::Input.open(reader) do |stream|
+      stream.each do |entry|
+        assert_raises Archive::Tar::Minitar::SecureRelativePathError do
+          stream.extract_entry('data__', entry)
+        end
+      end
+    end
+  end
+end

data/test/test_tar_output.rb

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby
+
+require 'minitar'
+require 'minitest_helper'
+
+class TestTarOutput < Minitest::Test
+  def setup
+    FileUtils.mkdir_p('data__')
+    %w(a b c).each do |filename|
+      name = File.join('data__', filename)
+      File.open(name, 'wb') { |f|
+        f.puts "#{name}: 123456789012345678901234567890"
+      }
+    end
+    @tarfile = 'data__/bla2.tar'
+  end
+
+  def teardown
+    FileUtils.rm_rf('data__')
+  end
+
+  def test_file_looks_good
+    Minitar::Output.open(@tarfile) do |os|
+      Dir.chdir('data__') do
+        %w(a b c).each do |name|
+          stat = File.stat(name)
+          opts = { :size => stat.size, :mode => 0o644 }
+          os.tar.add_file_simple(name, opts) do |ss|
+            File.open(name, 'rb') { |ff| ss.write(ff.read(4096)) until ff.eof? }
+          end
+        end
+      end
+    end
+    ff = File.open(@tarfile, 'rb')
+    Minitar::Reader.open(ff) do |is|
+      ii = 0
+      is.each do |entry|
+        case ii
+        when 0
+          assert_equal('a', entry.name)
+        when 1
+          assert_equal('b', entry.name)
+        when 2
+          assert_equal('c', entry.name)
+        end
+        ii += 1
+      end
+      assert_equal(3, ii)
+    end
+  ensure
+    ff.close if ff
+  end
+end

data/test/test_tar_reader.rb

@@ -0,0 +1,148 @@
+#!/usr/bin/env ruby
+
+require 'minitar'
+require 'minitest_helper'
+
+class TestTarReader < Minitest::Test
+  def test_multiple_entries
+    str = tar_file_header('lib/foo', '', 0o10644, 10) + "\0" * 512
+    str += tar_file_header('bar', 'baz', 0o644, 0)
+    str += tar_dir_header('foo', 'bar', 0o12345)
+    str += "\0" * 1024
+    names = %w(lib/foo bar foo)
+    prefixes = ['', 'baz', 'bar']
+    modes = [0o10644, 0o644, 0o12345]
+    sizes = [10, 0, 0]
+    isdir = [false, false, true]
+    isfile = [true, true, false]
+    Minitar::Reader.new(StringIO.new(str)) do |is|
+      i = 0
+      is.each_entry do |entry|
+        assert_kind_of(Minitar::Reader::EntryStream, entry)
+        assert_equal(names[i], entry.name)
+        assert_equal(prefixes[i], entry.prefix)
+        assert_equal(sizes[i], entry.size)
+        assert_equal(modes[i], entry.mode)
+        assert_equal(isdir[i], entry.directory?)
+        assert_equal(isfile[i], entry.file?)
+        if prefixes[i] != ''
+          assert_equal(File.join(prefixes[i], names[i]), entry.full_name)
+        else
+          assert_equal(names[i], entry.name)
+        end
+        i += 1
+      end
+      assert_equal(names.size, i)
+    end
+  end
+
+  def test_rewind_entry_works
+    content = ('a'..'z').to_a.join(' ')
+    str = tar_file_header('lib/foo', '', 0o10644, content.size) + content +
+      "\0" * (512 - content.size)
+    str << "\0" * 1024
+    Minitar::Reader.new(StringIO.new(str)) do |is|
+      is.each_entry do |entry|
+        3.times do
+          entry.rewind
+          assert_equal(content, entry.read)
+          assert_equal(content.size, entry.pos)
+        end
+      end
+    end
+  end
+
+  def test_rewind_works
+    content = ('a'..'z').to_a.join(' ')
+    str = tar_file_header('lib/foo', '', 0o10644, content.size) + content +
+      "\0" * (512 - content.size)
+    str << "\0" * 1024
+    Minitar::Reader.new(StringIO.new(str)) do |is|
+      3.times do
+        is.rewind
+        i = 0
+        is.each_entry do |entry|
+          assert_equal(content, entry.read)
+          i += 1
+        end
+        assert_equal(1, i)
+      end
+    end
+  end
+
+  def test_read_works
+    contents = ('a'..'z').inject('') { |a, e| a << e * 100 }
+    str = tar_file_header('lib/foo', '', 0o10644, contents.size) + contents
+    str += "\0" * (512 - (str.size % 512))
+    Minitar::Reader.new(StringIO.new(str)) do |is|
+      is.each_entry do |entry|
+        assert_kind_of(Minitar::Reader::EntryStream, entry)
+        data = entry.read(3000) # bigger than contents.size
+        assert_equal(contents, data)
+        assert_equal(true, entry.eof?)
+      end
+    end
+    Minitar::Reader.new(StringIO.new(str)) do |is|
+      is.each_entry do |entry|
+        assert_kind_of(Minitar::Reader::EntryStream, entry)
+        data = entry.read(100)
+        (entry.size - data.size).times { data << entry.getc.chr }
+        assert_equal(contents, data)
+        assert_equal(nil, entry.read(10))
+        assert_equal(true, entry.eof?)
+      end
+    end
+    Minitar::Reader.new(StringIO.new(str)) do |is|
+      is.each_entry do |entry|
+        assert_kind_of(Minitar::Reader::EntryStream, entry)
+        data = entry.read
+        assert_equal(contents, data)
+        assert_equal(nil, entry.read(10))
+        assert_equal(nil, entry.read)
+        assert_equal(nil, entry.getc)
+        assert_equal(true, entry.eof?)
+      end
+    end
+  end
+
+  def test_eof_works
+    str = tar_file_header('bar', 'baz', 0o644, 0)
+    Minitar::Reader.new(StringIO.new(str)) do |is|
+      is.each_entry do |entry|
+        assert_kind_of(Minitar::Reader::EntryStream, entry)
+        data = entry.read
+        assert_equal(nil, data)
+        assert_equal(nil, entry.read(10))
+        assert_equal(nil, entry.read)
+        assert_equal(nil, entry.getc)
+        assert_equal(true, entry.eof?)
+      end
+    end
+    str = tar_dir_header('foo', 'bar', 0o12345)
+    Minitar::Reader.new(StringIO.new(str)) do |is|
+      is.each_entry do |entry|
+        assert_kind_of(Minitar::Reader::EntryStream, entry)
+        data = entry.read
+        assert_equal(nil, data)
+        assert_equal(nil, entry.read(10))
+        assert_equal(nil, entry.read)
+        assert_equal(nil, entry.getc)
+        assert_equal(true, entry.eof?)
+      end
+    end
+    str = tar_dir_header('foo', 'bar', 0o12345)
+    str += tar_file_header('bar', 'baz', 0o644, 0)
+    str += tar_file_header('bar', 'baz', 0o644, 0)
+    Minitar::Reader.new(StringIO.new(str)) do |is|
+      is.each_entry do |entry|
+        assert_kind_of(Minitar::Reader::EntryStream, entry)
+        data = entry.read
+        assert_equal(nil, data)
+        assert_equal(nil, entry.read(10))
+        assert_equal(nil, entry.read)
+        assert_equal(nil, entry.getc)
+        assert_equal(true, entry.eof?)
+      end
+    end
+  end
+end