You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
853 lines
25 KiB
853 lines
25 KiB
#
|
|
# Copyright (C) 2004 Mauricio Julio Fernández Pradier
|
|
# See LICENSE.txt for additional licensing information.
|
|
#
|
|
|
|
require 'yaml'
|
|
require 'yaml/syck'
|
|
require 'fileutils'
|
|
require 'zlib'
|
|
require 'digest/md5'
|
|
require 'fileutils'
|
|
require 'find'
|
|
require 'stringio'
|
|
|
|
require 'rubygems/specification'
|
|
require 'rubygems/security'
|
|
|
|
module Gem
|
|
|
|
# Wrapper for FileUtils meant to provide logging and additional operations if
|
|
# needed.
|
|
class FileOperations
|
|
extend FileUtils
|
|
class << self
|
|
# additional methods not implemented in FileUtils
|
|
end
|
|
def initialize(logger = nil)
|
|
@logger = logger
|
|
end
|
|
|
|
def method_missing(meth, *args, &block)
|
|
case
|
|
when FileUtils.respond_to?(meth)
|
|
@logger.log "#{meth}: #{args}" if @logger
|
|
FileUtils.send meth, *args, &block
|
|
when FileOperations.respond_to?(meth)
|
|
@logger.log "#{meth}: #{args}" if @logger
|
|
FileOperations.send meth, *args, &block
|
|
else
|
|
super
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
module Package
|
|
|
|
class NonSeekableIO < StandardError; end
|
|
class ArgumentError < ::ArgumentError; end
|
|
class ClosedIO < StandardError; end
|
|
class BadCheckSum < StandardError; end
|
|
class TooLongFileName < StandardError; end
|
|
|
|
module FSyncDir
|
|
private
|
|
def fsync_dir(dirname)
|
|
# make sure this hits the disc
|
|
begin
|
|
dir = open(dirname, "r")
|
|
dir.fsync
|
|
rescue # ignore IOError if it's an unpatched (old) Ruby
|
|
ensure
|
|
dir.close if dir rescue nil
|
|
end
|
|
end
|
|
end
|
|
|
|
class TarHeader
|
|
FIELDS = [:name, :mode, :uid, :gid, :size, :mtime, :checksum, :typeflag,
|
|
:linkname, :magic, :version, :uname, :gname, :devmajor,
|
|
:devminor, :prefix]
|
|
FIELDS.each {|x| attr_reader x}
|
|
|
|
def self.new_from_stream(stream)
|
|
data = stream.read(512)
|
|
fields = data.unpack( "A100" + # record name
|
|
"A8A8A8" + # mode, uid, gid
|
|
"A12A12" + # size, mtime
|
|
"A8A" + # checksum, typeflag
|
|
"A100" + # linkname
|
|
"A6A2" + # magic, version
|
|
"A32" + # uname
|
|
"A32" + # gname
|
|
"A8A8" + # devmajor, devminor
|
|
"A155" # prefix
|
|
)
|
|
name = fields.shift
|
|
mode = fields.shift.oct
|
|
uid = fields.shift.oct
|
|
gid = fields.shift.oct
|
|
size = fields.shift.oct
|
|
mtime = fields.shift.oct
|
|
checksum = fields.shift.oct
|
|
typeflag = fields.shift
|
|
linkname = fields.shift
|
|
magic = fields.shift
|
|
version = fields.shift.oct
|
|
uname = fields.shift
|
|
gname = fields.shift
|
|
devmajor = fields.shift.oct
|
|
devminor = fields.shift.oct
|
|
prefix = fields.shift
|
|
|
|
empty = (data == "\0" * 512)
|
|
|
|
new(:name=>name, :mode=>mode, :uid=>uid, :gid=>gid, :size=>size,
|
|
:mtime=>mtime, :checksum=>checksum, :typeflag=>typeflag, :magic=>magic,
|
|
:version=>version, :uname=>uname, :gname=>gname, :devmajor=>devmajor,
|
|
:devminor=>devminor, :prefix=>prefix, :empty => empty )
|
|
end
|
|
|
|
def initialize(vals)
|
|
unless vals[:name] && vals[:size] && vals[:prefix] && vals[:mode]
|
|
raise Package::ArgumentError
|
|
end
|
|
vals[:uid] ||= 0
|
|
vals[:gid] ||= 0
|
|
vals[:mtime] ||= 0
|
|
vals[:checksum] ||= ""
|
|
vals[:typeflag] ||= "0"
|
|
vals[:magic] ||= "ustar"
|
|
vals[:version] ||= "00"
|
|
vals[:uname] ||= "wheel"
|
|
vals[:gname] ||= "wheel"
|
|
vals[:devmajor] ||= 0
|
|
vals[:devminor] ||= 0
|
|
FIELDS.each {|x| instance_variable_set "@#{x.to_s}", vals[x]}
|
|
@empty = vals[:empty]
|
|
end
|
|
|
|
def empty?
|
|
@empty
|
|
end
|
|
|
|
def to_s
|
|
update_checksum
|
|
header(checksum)
|
|
end
|
|
|
|
def update_checksum
|
|
h = header(" " * 8)
|
|
@checksum = oct(calculate_checksum(h), 6)
|
|
end
|
|
|
|
private
|
|
def oct(num, len)
|
|
"%0#{len}o" % num
|
|
end
|
|
|
|
def calculate_checksum(hdr)
|
|
hdr.unpack("C*").inject{|a,b| a+b}
|
|
end
|
|
|
|
def header(chksum)
|
|
# 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)
|
|
# };
|
|
arr = [name, oct(mode, 7), oct(uid, 7), oct(gid, 7), oct(size, 11),
|
|
oct(mtime, 11), chksum, " ", typeflag, linkname, magic, version,
|
|
uname, gname, oct(devmajor, 7), oct(devminor, 7), prefix]
|
|
str = arr.pack("a100a8a8a8a12a12" + # name, mode, uid, gid, size, mtime
|
|
"a7aaa100a6a2" + # chksum, typeflag, linkname, magic, version
|
|
"a32a32a8a8a155") # uname, gname, devmajor, devminor, prefix
|
|
str + "\0" * ((512 - str.size) % 512)
|
|
end
|
|
end
|
|
|
|
class TarWriter
|
|
class FileOverflow < StandardError; end
|
|
class BlockNeeded < StandardError; end
|
|
|
|
class BoundedStream
|
|
attr_reader :limit, :written
|
|
def initialize(io, limit)
|
|
@io = io
|
|
@limit = limit
|
|
@written = 0
|
|
end
|
|
|
|
def write(data)
|
|
if data.size + @written > @limit
|
|
raise FileOverflow,
|
|
"You tried to feed more data than fits in the file."
|
|
end
|
|
@io.write data
|
|
@written += data.size
|
|
data.size
|
|
end
|
|
end
|
|
class RestrictedStream
|
|
def initialize(anIO)
|
|
@io = anIO
|
|
end
|
|
|
|
def write(data)
|
|
@io.write data
|
|
end
|
|
end
|
|
|
|
def self.new(anIO)
|
|
writer = super(anIO)
|
|
return writer unless block_given?
|
|
begin
|
|
yield writer
|
|
ensure
|
|
writer.close
|
|
end
|
|
nil
|
|
end
|
|
|
|
def initialize(anIO)
|
|
@io = anIO
|
|
@closed = false
|
|
end
|
|
|
|
def add_file_simple(name, mode, size)
|
|
raise BlockNeeded unless block_given?
|
|
raise ClosedIO if @closed
|
|
name, prefix = split_name(name)
|
|
header = TarHeader.new(:name => name, :mode => mode,
|
|
:size => size, :prefix => prefix).to_s
|
|
@io.write header
|
|
os = BoundedStream.new(@io, size)
|
|
yield os
|
|
#FIXME: what if an exception is raised in the block?
|
|
min_padding = size - os.written
|
|
@io.write("\0" * min_padding)
|
|
remainder = (512 - (size % 512)) % 512
|
|
@io.write("\0" * remainder)
|
|
end
|
|
|
|
def add_file(name, mode)
|
|
raise BlockNeeded unless block_given?
|
|
raise ClosedIO if @closed
|
|
raise NonSeekableIO unless @io.respond_to? :pos=
|
|
name, prefix = split_name(name)
|
|
init_pos = @io.pos
|
|
@io.write "\0" * 512 # placeholder for the header
|
|
yield RestrictedStream.new(@io)
|
|
#FIXME: what if an exception is raised in the block?
|
|
#FIXME: what if an exception is raised in the block?
|
|
size = @io.pos - init_pos - 512
|
|
remainder = (512 - (size % 512)) % 512
|
|
@io.write("\0" * remainder)
|
|
final_pos = @io.pos
|
|
@io.pos = init_pos
|
|
header = TarHeader.new(:name => name, :mode => mode,
|
|
:size => size, :prefix => prefix).to_s
|
|
@io.write header
|
|
@io.pos = final_pos
|
|
end
|
|
|
|
def mkdir(name, mode)
|
|
raise ClosedIO if @closed
|
|
name, prefix = split_name(name)
|
|
header = TarHeader.new(:name => name, :mode => mode, :typeflag => "5",
|
|
:size => 0, :prefix => prefix).to_s
|
|
@io.write header
|
|
nil
|
|
end
|
|
|
|
def flush
|
|
raise ClosedIO if @closed
|
|
@io.flush if @io.respond_to? :flush
|
|
end
|
|
|
|
def close
|
|
#raise ClosedIO if @closed
|
|
return if @closed
|
|
@io.write "\0" * 1024
|
|
@closed = true
|
|
end
|
|
|
|
private
|
|
def split_name name
|
|
raise TooLongFileName if name.size > 256
|
|
if name.size <= 100
|
|
prefix = ""
|
|
else
|
|
parts = name.split(/\//)
|
|
newname = parts.pop
|
|
nxt = ""
|
|
loop do
|
|
nxt = parts.pop
|
|
break if newname.size + 1 + nxt.size > 100
|
|
newname = nxt + "/" + newname
|
|
end
|
|
prefix = (parts + [nxt]).join "/"
|
|
name = newname
|
|
raise TooLongFileName if name.size > 100 || prefix.size > 155
|
|
end
|
|
return name, prefix
|
|
end
|
|
end
|
|
|
|
class TarReader
|
|
include Gem::Package
|
|
class UnexpectedEOF < StandardError; end
|
|
module InvalidEntry
|
|
def read(len=nil); raise ClosedIO; end
|
|
def getc; raise ClosedIO; end
|
|
def rewind; raise ClosedIO; end
|
|
end
|
|
class Entry
|
|
TarHeader::FIELDS.each{|x| attr_reader x}
|
|
|
|
def initialize(header, anIO)
|
|
@io = anIO
|
|
@name = header.name
|
|
@mode = header.mode
|
|
@uid = header.uid
|
|
@gid = header.gid
|
|
@size = header.size
|
|
@mtime = header.mtime
|
|
@checksum = header.checksum
|
|
@typeflag = header.typeflag
|
|
@linkname = header.linkname
|
|
@magic = header.magic
|
|
@version = header.version
|
|
@uname = header.uname
|
|
@gname = header.gname
|
|
@devmajor = header.devmajor
|
|
@devminor = header.devminor
|
|
@prefix = header.prefix
|
|
@read = 0
|
|
@orig_pos = @io.pos
|
|
end
|
|
|
|
def read(len = nil)
|
|
return nil if @read >= @size
|
|
len ||= @size - @read
|
|
max_read = [len, @size - @read].min
|
|
ret = @io.read(max_read)
|
|
@read += ret.size
|
|
ret
|
|
end
|
|
|
|
def getc
|
|
return nil if @read >= @size
|
|
ret = @io.getc
|
|
@read += 1 if ret
|
|
ret
|
|
end
|
|
|
|
def is_directory?
|
|
@typeflag == "5"
|
|
end
|
|
|
|
def is_file?
|
|
@typeflag == "0"
|
|
end
|
|
|
|
def eof?
|
|
@read >= @size
|
|
end
|
|
|
|
def pos
|
|
@read
|
|
end
|
|
|
|
def rewind
|
|
raise NonSeekableIO unless @io.respond_to? :pos=
|
|
@io.pos = @orig_pos
|
|
@read = 0
|
|
end
|
|
|
|
alias_method :is_directory, :is_directory?
|
|
alias_method :is_file, :is_file
|
|
|
|
def bytes_read
|
|
@read
|
|
end
|
|
|
|
def full_name
|
|
if @prefix != ""
|
|
File.join(@prefix, @name)
|
|
else
|
|
@name
|
|
end
|
|
end
|
|
|
|
def close
|
|
invalidate
|
|
end
|
|
|
|
private
|
|
def invalidate
|
|
extend InvalidEntry
|
|
end
|
|
end
|
|
|
|
def self.new(anIO)
|
|
reader = super(anIO)
|
|
return reader unless block_given?
|
|
begin
|
|
yield reader
|
|
ensure
|
|
reader.close
|
|
end
|
|
nil
|
|
end
|
|
|
|
def initialize(anIO)
|
|
@io = anIO
|
|
@init_pos = anIO.pos
|
|
end
|
|
|
|
def each(&block)
|
|
each_entry(&block)
|
|
end
|
|
|
|
# do not call this during a #each or #each_entry iteration
|
|
def rewind
|
|
if @init_pos == 0
|
|
raise NonSeekableIO unless @io.respond_to? :rewind
|
|
@io.rewind
|
|
else
|
|
raise NonSeekableIO unless @io.respond_to? :pos=
|
|
@io.pos = @init_pos
|
|
end
|
|
end
|
|
|
|
def each_entry
|
|
loop do
|
|
return if @io.eof?
|
|
header = TarHeader.new_from_stream(@io)
|
|
return if header.empty?
|
|
entry = Entry.new header, @io
|
|
size = entry.size
|
|
yield entry
|
|
skip = (512 - (size % 512)) % 512
|
|
if @io.respond_to? :seek
|
|
# avoid reading...
|
|
@io.seek(size - entry.bytes_read, IO::SEEK_CUR)
|
|
else
|
|
pending = size - entry.bytes_read
|
|
while pending > 0
|
|
bread = @io.read([pending, 4096].min).size
|
|
raise UnexpectedEOF if @io.eof?
|
|
pending -= bread
|
|
end
|
|
end
|
|
@io.read(skip) # discard trailing zeros
|
|
# make sure nobody can use #read, #getc or #rewind anymore
|
|
entry.close
|
|
end
|
|
end
|
|
|
|
def close
|
|
end
|
|
end
|
|
|
|
class TarInput
|
|
include FSyncDir
|
|
include Enumerable
|
|
attr_reader :metadata
|
|
class << self; private :new end
|
|
|
|
def initialize(io, security_policy = nil)
|
|
@io = io
|
|
@tarreader = TarReader.new(@io)
|
|
has_meta = false
|
|
data_sig, meta_sig, data_dgst, meta_dgst = nil, nil, nil, nil
|
|
dgst_algo = security_policy ? Gem::Security::OPT[:dgst_algo] : nil
|
|
|
|
@tarreader.each do |entry|
|
|
case entry.full_name
|
|
when "metadata"
|
|
# (GS) Changed to line below: @metadata = YAML.load(entry.read) rescue nil
|
|
@metadata = load_gemspec(entry.read)
|
|
has_meta = true
|
|
break
|
|
when "metadata.gz"
|
|
begin
|
|
# if we have a security_policy, then pre-read the
|
|
# metadata file and calculate it's digest
|
|
sio = nil
|
|
if security_policy
|
|
Gem.ensure_ssl_available
|
|
sio = StringIO.new(entry.read)
|
|
meta_dgst = dgst_algo.digest(sio.string)
|
|
sio.rewind
|
|
end
|
|
|
|
gzis = Zlib::GzipReader.new(sio || entry)
|
|
# YAML wants an instance of IO
|
|
# (GS) Changed to line below: @metadata = YAML.load(gzis) rescue nil
|
|
@metadata = load_gemspec(gzis)
|
|
has_meta = true
|
|
ensure
|
|
gzis.close
|
|
end
|
|
when 'metadata.gz.sig'
|
|
meta_sig = entry.read
|
|
when 'data.tar.gz.sig'
|
|
data_sig = entry.read
|
|
when 'data.tar.gz'
|
|
if security_policy
|
|
Gem.ensure_ssl_available
|
|
data_dgst = dgst_algo.digest(entry.read)
|
|
end
|
|
end
|
|
end
|
|
|
|
if security_policy
|
|
Gem.ensure_ssl_available
|
|
# map trust policy from string to actual class (or a
|
|
# serialized YAML file, if that exists)
|
|
if (security_policy.is_a?(String))
|
|
if Gem::Security.constants.index(security_policy)
|
|
# load one of the pre-defined security policies
|
|
security_policy = Gem::Security.const_get(security_policy)
|
|
elsif File.exists?(security_policy)
|
|
# FIXME: this doesn't work yet
|
|
security_policy = YAML::load(File.read(security_policy))
|
|
else
|
|
raise Gem::Exception, "Unknown trust policy '#{security_policy}'"
|
|
end
|
|
end
|
|
|
|
if data_sig && data_dgst && meta_sig && meta_dgst
|
|
# the user has a trust policy, and we have a signed gem
|
|
# file, so use the trust policy to verify the gem signature
|
|
|
|
begin
|
|
security_policy.verify_gem(data_sig, data_dgst, @metadata.cert_chain)
|
|
rescue Exception => e
|
|
raise "Couldn't verify data signature: #{e}"
|
|
end
|
|
|
|
begin
|
|
security_policy.verify_gem(meta_sig, meta_dgst, @metadata.cert_chain)
|
|
rescue Exception => e
|
|
raise "Couldn't verify metadata signature: #{e}"
|
|
end
|
|
elsif security_policy.only_signed
|
|
raise Gem::Exception, "Unsigned gem"
|
|
else
|
|
# FIXME: should display warning here (trust policy, but
|
|
# either unsigned or badly signed gem file)
|
|
end
|
|
end
|
|
|
|
@tarreader.rewind
|
|
@fileops = FileOperations.new
|
|
raise RuntimeError, "No metadata found!" unless has_meta
|
|
end
|
|
|
|
# Attempt to YAML-load a gemspec from the given _io_ parameter. Return nil if it fails.
|
|
def load_gemspec(io)
|
|
Gem::Specification.from_yaml(io)
|
|
rescue Gem::Exception
|
|
nil
|
|
end
|
|
|
|
def self.open(filename, security_policy = nil, &block)
|
|
open_from_io(File.open(filename, "rb"), security_policy, &block)
|
|
end
|
|
|
|
def self.open_from_io(io, security_policy = nil, &block)
|
|
raise "Want a block" unless block_given?
|
|
begin
|
|
is = new(io, security_policy)
|
|
yield is
|
|
ensure
|
|
is.close if is
|
|
end
|
|
end
|
|
|
|
def each(&block)
|
|
@tarreader.each do |entry|
|
|
next unless entry.full_name == "data.tar.gz"
|
|
is = zipped_stream(entry)
|
|
begin
|
|
TarReader.new(is) do |inner|
|
|
inner.each(&block)
|
|
end
|
|
ensure
|
|
is.close if is
|
|
end
|
|
end
|
|
@tarreader.rewind
|
|
end
|
|
|
|
# Return an IO stream for the zipped entry.
|
|
#
|
|
# If zlib is earlier than 1.2.1, then read the entry into memory
|
|
# and create a string IO object from it. This avoids a "buffer
|
|
# error" problem on windows when using an earlier version of zlib.
|
|
# This problem has not been observed in versions of zlib 1.2.1 or
|
|
# later.
|
|
def zipped_stream(entry)
|
|
if Zlib::ZLIB_VERSION < '1.2.1'
|
|
zis = Zlib::GzipReader.new entry
|
|
dis = zis.read
|
|
is = StringIO.new(dis)
|
|
else
|
|
is = Zlib::GzipReader.new entry
|
|
end
|
|
ensure
|
|
zis.finish if zis
|
|
end
|
|
|
|
def extract_entry(destdir, entry, expected_md5sum = nil)
|
|
if entry.is_directory?
|
|
dest = File.join(destdir, entry.full_name)
|
|
if file_class.dir? dest
|
|
@fileops.chmod entry.mode, dest, :verbose=>false
|
|
else
|
|
@fileops.mkdir_p(dest, :mode => entry.mode, :verbose=>false)
|
|
end
|
|
fsync_dir dest
|
|
fsync_dir File.join(dest, "..")
|
|
return
|
|
end
|
|
# it's a file
|
|
md5 = Digest::MD5.new if expected_md5sum
|
|
destdir = File.join(destdir, File.dirname(entry.full_name))
|
|
@fileops.mkdir_p(destdir, :mode => 0755, :verbose=>false)
|
|
destfile = File.join(destdir, File.basename(entry.full_name))
|
|
@fileops.chmod(0600, destfile, :verbose=>false) rescue nil # Errno::ENOENT
|
|
file_class.open(destfile, "wb", entry.mode) do |os|
|
|
loop do
|
|
data = entry.read(4096)
|
|
break unless data
|
|
md5 << data if expected_md5sum
|
|
os.write(data)
|
|
end
|
|
os.fsync
|
|
end
|
|
@fileops.chmod(entry.mode, destfile, :verbose=>false)
|
|
fsync_dir File.dirname(destfile)
|
|
fsync_dir File.join(File.dirname(destfile), "..")
|
|
if expected_md5sum && expected_md5sum != md5.hexdigest
|
|
raise BadCheckSum
|
|
end
|
|
end
|
|
|
|
def close
|
|
@io.close
|
|
@tarreader.close
|
|
end
|
|
|
|
private
|
|
|
|
def file_class
|
|
File
|
|
end
|
|
end
|
|
|
|
class TarOutput
|
|
|
|
class << self; private :new end
|
|
|
|
class << self
|
|
|
|
end
|
|
|
|
def initialize(io)
|
|
@io = io
|
|
@external = TarWriter.new @io
|
|
end
|
|
|
|
def external_handle
|
|
@external
|
|
end
|
|
|
|
def self.open(filename, signer = nil, &block)
|
|
io = File.open(filename, "wb")
|
|
open_from_io(io, signer, &block)
|
|
nil
|
|
end
|
|
|
|
def self.open_from_io(io, signer = nil, &block)
|
|
outputter = new(io)
|
|
metadata = nil
|
|
set_meta = lambda{|x| metadata = x}
|
|
raise "Want a block" unless block_given?
|
|
begin
|
|
data_sig, meta_sig = nil, nil
|
|
|
|
outputter.external_handle.add_file("data.tar.gz", 0644) do |inner|
|
|
begin
|
|
sio = signer ? StringIO.new : nil
|
|
os = Zlib::GzipWriter.new(sio || inner)
|
|
|
|
TarWriter.new(os) do |inner_tar_stream|
|
|
klass = class <<inner_tar_stream; self end
|
|
if RUBY_VERSION >= "1.9" then
|
|
klass.funcall(:define_method, :metadata=, &set_meta)
|
|
else
|
|
klass.send(:define_method, :metadata=, &set_meta)
|
|
end
|
|
block.call inner_tar_stream
|
|
end
|
|
ensure
|
|
os.flush
|
|
os.finish
|
|
#os.close
|
|
|
|
# if we have a signing key, then sign the data
|
|
# digest and return the signature
|
|
data_sig = nil
|
|
if signer
|
|
dgst_algo = Gem::Security::OPT[:dgst_algo]
|
|
dig = dgst_algo.digest(sio.string)
|
|
data_sig = signer.sign(dig)
|
|
inner.write(sio.string)
|
|
end
|
|
end
|
|
end
|
|
|
|
# if we have a data signature, then write it to the gem too
|
|
if data_sig
|
|
sig_file = 'data.tar.gz.sig'
|
|
outputter.external_handle.add_file(sig_file, 0644) do |os|
|
|
os.write(data_sig)
|
|
end
|
|
end
|
|
|
|
outputter.external_handle.add_file("metadata.gz", 0644) do |os|
|
|
begin
|
|
sio = signer ? StringIO.new : nil
|
|
gzos = Zlib::GzipWriter.new(sio || os)
|
|
gzos.write metadata
|
|
ensure
|
|
gzos.flush
|
|
gzos.finish
|
|
|
|
# if we have a signing key, then sign the metadata
|
|
# digest and return the signature
|
|
if signer
|
|
dgst_algo = Gem::Security::OPT[:dgst_algo]
|
|
dig = dgst_algo.digest(sio.string)
|
|
meta_sig = signer.sign(dig)
|
|
os.write(sio.string)
|
|
end
|
|
end
|
|
end
|
|
|
|
# if we have a metadata signature, then write to the gem as
|
|
# well
|
|
if meta_sig
|
|
sig_file = 'metadata.gz.sig'
|
|
outputter.external_handle.add_file(sig_file, 0644) do |os|
|
|
os.write(meta_sig)
|
|
end
|
|
end
|
|
|
|
ensure
|
|
outputter.close
|
|
end
|
|
nil
|
|
end
|
|
|
|
def close
|
|
@external.close
|
|
@io.close
|
|
end
|
|
end
|
|
end # module Package
|
|
|
|
|
|
module Package
|
|
#FIXME: refactor the following 2 methods
|
|
def self.open(dest, mode = "r", signer = nil, &block)
|
|
raise "Block needed" unless block_given?
|
|
|
|
case mode
|
|
when "r"
|
|
security_policy = signer
|
|
TarInput.open(dest, security_policy, &block)
|
|
when "w"
|
|
TarOutput.open(dest, signer, &block)
|
|
else
|
|
raise "Unknown Package open mode"
|
|
end
|
|
end
|
|
|
|
def self.open_from_io(io, mode = "r", signer = nil, &block)
|
|
raise "Block needed" unless block_given?
|
|
|
|
case mode
|
|
when "r"
|
|
security_policy = signer
|
|
TarInput.open_from_io(io, security_policy, &block)
|
|
when "w"
|
|
TarOutput.open_from_io(io, signer, &block)
|
|
else
|
|
raise "Unknown Package open mode"
|
|
end
|
|
end
|
|
|
|
def self.pack(src, destname, signer = nil)
|
|
TarOutput.open(destname, signer) do |outp|
|
|
dir_class.chdir(src) do
|
|
outp.metadata = (file_class.read("RPA/metadata") rescue nil)
|
|
find_class.find('.') do |entry|
|
|
case
|
|
when file_class.file?(entry)
|
|
entry.sub!(%r{\./}, "")
|
|
next if entry =~ /\ARPA\//
|
|
stat = File.stat(entry)
|
|
outp.add_file_simple(entry, stat.mode, stat.size) do |os|
|
|
file_class.open(entry, "rb") do |f|
|
|
os.write(f.read(4096)) until f.eof?
|
|
end
|
|
end
|
|
when file_class.dir?(entry)
|
|
entry.sub!(%r{\./}, "")
|
|
next if entry == "RPA"
|
|
outp.mkdir(entry, file_class.stat(entry).mode)
|
|
else
|
|
raise "Don't know how to pack this yet!"
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
class << self
|
|
def file_class
|
|
File
|
|
end
|
|
|
|
def dir_class
|
|
Dir
|
|
end
|
|
|
|
def find_class
|
|
Find
|
|
end
|
|
end
|
|
end
|
|
|
|
end
|
|
|