tpkg 1.18.2 → 1.19.2

data/Rakefile

@@ -4,7 +4,8 @@ spec = Gem::Specification.new do |s|
   s.summary	= 'tpkg Application Packaging & Deployment'
   s.add_dependency('facter')
   s.add_dependency('net-ssh')
-  s.version = '1.18.2'
+  s.add_dependency('kwalify')
+  s.version = '1.19.2'
   s.authors = ['Darren Dao', 'Jason Heiss']
   s.email = 'tpkg-users@lists.sourceforge.net'
   s.homepage = 'http://tpkg.sourceforge.net'

data/bin/cpan2tpkg

@@ -29,6 +29,8 @@ Usage: cpan2tpkg
        Extra dependencies to add to the package
     [--native-deps foo,1.0,1.9999,bar,4.5,4.5,blah,,,]
        Native dependencies to add to the package
+    [--force]
+       Force the install and packaging even if tests fail
     [--help]
        Show this message
 
@@ -42,6 +44,7 @@ my %extradeps = ();
 my $extradepsopts = '';
 my %nativedeps = ();
 my $nativedepsopts = '';
+my $force;
 my $help;
 
 my $getopt = GetOptions(
@@ -49,6 +52,7 @@ my $getopt = GetOptions(
 	'package-version=s' => \$pkgver,
 	'extra-deps=s' => \$extradepsopts,
 	'native-deps=s' => \$nativedepsopts,
+        'force' => \$force,
 	'help' => \$help);
 
 my $module = shift @ARGV;
@@ -131,7 +135,14 @@ CPAN::Shell->o('conf', 'mbuildpl_arg', "--destdir=$workdir");
 #CPAN::Shell->o('conf', 'prerequisites_policy', "ask");
 
 # Install the module
-$modobj->install;
+if ($force)
+{
+	CPAN::Shell->force('install', $module);
+}
+else
+{
+	$modobj->install;
+}
 
 # It is not nearly as straightforward as one might wish to get
 # ExtUtils::Installed to inspect only a specified directory structure and not

data/bin/gem2tpkg

@@ -10,20 +10,9 @@ require 'shellwords'
 require 'tpkg'
 require 'facter'
 
-# Names of packages containing ruby and gems.  Dependencies on these
-# will be added to generated packages, so that if a user installs a gem
-# then tpkg will pull in ruby and gems.
-RUBYDEPS = ['ruby']
-# T_RUBY_BASE = "/home/t/ruby"
-T_RUBY_BASE = "#{Tpkg::DEFAULT_BASE}/#{RUBYDEPS.first}".freeze
-DEFAULT_GEM_COMMAND = "#{T_RUBY_BASE}/bin/gem"
-
-# Figure out rubygems library from ruby.
-# There might be several versions so get the latest one. We're assuming that
-# the version directories are named appropriately under lib/ruby/site_ruby.
-versions = Dir.glob(File.join("#{T_RUBY_BASE}", "lib", "ruby", "site_ruby", "*"))
-versions.sort!
-DEFAULT_RUBYGEMS_PATH = versions[-1]
+# We don't want to just use the first gem command in the user's PATH by
+# default, as that may not be a tpkg gem.  I.e. /usr/bin/gem on Mac OS X.
+DEFAULT_GEM_COMMAND = "#{Tpkg::DEFAULT_BASE}/ruby-1.8/bin/gem"
 
 # Haven't found a Ruby method for creating temporary directories,
 # so create a temporary file and replace it with a directory.
@@ -45,6 +34,7 @@ end
 @buildopts = []
 @gemcmd = DEFAULT_GEM_COMMAND
 @rubygemspath = nil
+@extrapkgname = nil
 
 opts = OptionParser.new
 opts.banner = 'Usage: gem2tpkg [options] GEMNAME1 GEMNAME2 ...'
@@ -92,33 +82,91 @@ end
 opts.on('--rubygems-path', '=PATH', 'Path to rubygems library') do |opt|
   @rubygemspath = opt
 end
+opts.on('--extra-name', '=EXTRANAME', 'Extra string to add to package name') do |opt|
+  @extrapkgname = opt
+end
 opts.on_tail("-h", "--help", "Show this message") do
   puts opts
   exit
 end
 
-# we now allow user to specifies multiple gems at the end of the command line arguments
+# Allow user to specify multiple gems at the end of the command line
+# arguments
 leftover = opts.parse(ARGV)
 @gems = leftover
-#if leftover.length == 1
-#  @gem = leftover.shift
-#else
-#  puts opts
-#  exit
-#end
 
-# require the correct rubygems based on what the user specifies
-@rubygemspath ||= DEFAULT_RUBYGEMS_PATH
+# Extract a few paths from gem
+@geminstallpath = nil
+@gembinpath = nil
+@rubypath = nil
+IO.popen("#{@gemcmd} environment") do |pipe|
+  pipe.each_line do |line|
+    if line =~ /INSTALLATION DIRECTORY:\s+(\S+)/
+      @geminstallpath = $1
+    end
+    if line =~ /EXECUTABLE DIRECTORY:\s+(\S+)/
+      @gembinpath = $1
+    end
+    if line =~ /RUBY EXECUTABLE:\s+(\S+)/
+      @rubypath = $1
+    end
+  end
+end
+if !$?.success?
+  abort 'gem environment failed'
+end
+
+# Find the right rubygems library if the user didn't request a specific
+# one
+if !@rubygemspath
+  cmd = "#{@rubypath} -e 'puts $:'"
+  IO.popen(cmd) do |pipe|
+    pipe.each_line do |line|
+      line.chomp!
+      if File.exist?(File.join(line, 'rubygems.rb'))
+        @rubygemspath = line
+        break
+      end
+    end
+  end
+  if !$?.success?
+      abort "#{cmd} failed"
+  end
+end
+
+# Require the correct rubygems based on what the user specifies
 $:.unshift @rubygemspath unless @rubygemspath.nil?
 require 'rubygems'
 
+# Ask tpkg what package owns the gem executable that we're using so that
+# we can add a dependency on that package to any packages we build.
+@gemdep = []
+# FIXME: Currently the reading of config files and whatnot is done in
+# the tpkg executable.  We should probably move that into the library so
+# that other utilities like this one use an alternate base if the user
+# has configured one, etc.
+tpkg = Tpkg.new(:base => Tpkg::DEFAULT_BASE)
+tpkg.files_for_installed_packages.each do |pkgfile, fip|
+  fip[:normalized].each do |file|
+    if file == @gemcmd
+      metadata = nil
+      # FIXME: Should add a metadata_for_installed_package method to the
+      # library
+      tpkg.metadata_for_installed_packages.each do |metadata|
+        if metadata[:filename] == pkgfile
+          @gemdep << metadata[:name]
+        end
+      end
+    end
+  end
+end
+
 # Create the directory we want gem to install into
 @gemdir = tempdir('gem2tpkg')
 ENV['GEM_HOME'] = @gemdir
 ENV['GEM_PATH'] = @gemdir
 
 # Install the gem
-#geminst = [@gemcmd, 'install', @gems.join(" "), '--no-rdoc', '--no-ri']
 geminst = [@gemcmd, 'install', '--no-rdoc', '--no-ri'] | @gems
 if @gemver
   geminst << @gemver
@@ -147,7 +195,6 @@ def package(gem)
   puts "Packaging #{gem}"
   
   gemsdir = nil
-  #globdirs = Dir.glob(File.join(@gemdir, 'gems', "#{gem}-*"))
   globdirs = Dir.glob(File.join(@gemdir, 'gems', "#{gem}-[0-9]*"))
   if globdirs.length == 1
     gemsdir = globdirs[0]
@@ -286,7 +333,7 @@ def package(gem)
   
   # The directory where we make our package
   pkgdir = tempdir('gem2tpkg')
-  pkgbasedir = File.join(pkgdir, "/root/#{T_RUBY_BASE}/lib/ruby/gems/1.8")
+  pkgbasedir = File.join(pkgdir, "/root/#{@geminstallpath}")
   FileUtils.mkdir_p(pkgbasedir)
   pkggemdir = File.join(pkgbasedir, 'gems')
   FileUtils.mkdir_p(pkggemdir)
@@ -305,7 +352,7 @@ def package(gem)
     binfiles << File.join(@gemdir, 'bin', exec)
   end
   if !binfiles.empty?
-    bindir = "#{pkgdir}/root/#{T_RUBY_BASE}/bin"
+    bindir = "#{pkgdir}/root/#{@gembinpath}"
     FileUtils.mkdir_p(bindir)
     binfiles.each do |binfile|
       FileUtils.cp(binfile, bindir, :preserve => true)
@@ -315,6 +362,15 @@ def package(gem)
   # Copy over the gemspec file
   FileUtils.cp(gemspecfile, pkgspecdir, :preserve => true)
   
+  pkgnamesuffix = ''
+  if @extrapkgname
+    pkgnamesuffix = '-' + @extrapkgname
+  elsif @gemcmd != DEFAULT_GEM_COMMAND
+    # If we're not using the default gem try to name the package in a way
+    # that indicates the alternate ruby/gem used
+    pkgnamesuffix = '-' + @gemdep.first.sub(/\W/, '')
+  end
+  
   # Add tpkg.xml
   os = nil
   arch = nil
@@ -322,7 +378,7 @@ def package(gem)
     file.puts '<?xml version="1.0" encoding="UTF-8"?>'
     file.puts '<!DOCTYPE tpkg SYSTEM "http://tpkg.sourceforge.net/tpkg-1.0.dtd">'
     file.puts '<tpkg>'
-    file.puts "  <name>gem-#{gem}</name>"
+    file.puts "  <name>gem-#{gem}#{pkgnamesuffix}</name>"
     file.puts "  <version>#{gemspec.version.to_s}</version>"
     file.puts "  <package_version>#{@pkgver}</package_version>"
     file.puts '  <maintainer>gem2tpkg</maintainer>'
@@ -341,11 +397,11 @@ def package(gem)
     end
     if !deps.empty? ||
        !@extradeps.empty? || !@nativedeps.empty? ||
-       !RUBYDEPS.empty?
+       !@gemdep.empty?
       file.puts '  <dependencies>'
       deps.each do |depgem, depvers|
         file.puts '    <dependency>'
-        file.puts "      <name>gem-#{depgem}</name>"
+        file.puts "      <name>gem-#{depgem}#{pkgnamesuffix}</name>"
         if depvers[:minimum_version]
           file.puts "      <minimum_version>#{depvers[:minimum_version]}</minimum_version>"
         end
@@ -377,9 +433,9 @@ def package(gem)
         file.puts '      <native/>'
         file.puts '    </dependency>'
       end
-      RUBYDEPS.each do |rubydep|
+      @gemdep.each do |gemdep|
         file.puts '    <dependency>'
-        file.puts "      <name>#{rubydep}</name>"
+        file.puts "      <name>#{gemdep}</name>"
         file.puts '    </dependency>'
       end
       file.puts '  </dependencies>'
@@ -389,24 +445,11 @@ def package(gem)
   
   # Make package
   pkgfile = Tpkg::make_package(pkgdir)
-  # If the package is OS-specific then rename the file to reflect that
-  if os
-    # Examples:
-    # FreeBSD-7 -> freebsd7
-    # RedHat-5 -> redhat5
-    # CentOS-5 -> redhat5
-    fileos = Tpkg::get_os.sub('CentOS', 'RedHat').downcase.sub('-', '')
-    newpkgfile = File.join(
-                   File.dirname(pkgfile),
-                   "#{File.basename(pkgfile, '.tpkg')}-#{fileos}-#{arch}.tpkg")
-    File.rename(pkgfile, newpkgfile)
-    pkgfile = newpkgfile
-  end
   pkgfiles << pkgfile
   
   # Cleanup
   FileUtils.rm_rf(pkgdir)
- 
+  
   @already_packaged << gem
   pkgfiles
 end

data/bin/tpkg

@@ -329,10 +329,14 @@ if @deploy
   exit
 end
 
+if @action_value.is_a?(Array)
+  @action_value.uniq!
+end
+
 ret_val = 0
 case @action
 when :make
-  pkgfile = Tpkg::make_package(@action_value, passphrase_callback)
+  pkgfile = Tpkg::make_package(@action_value, passphrase_callback, {:force => @force})
   if pkgfile
     puts "Package is #{pkgfile}"
   else

data/bin/tpkg_xml_to_yml

@@ -1,5 +1,8 @@
 #!/usr/bin/ruby -w
 
+# Ensure we can find tpkg.rb
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
 # This script expects one argument, which is the tpkg.xml file
 # that you want to convert to yml format.
 # The resulting data is output to stdout

data/lib/tpkg.rb

@@ -21,6 +21,13 @@ if File.directory?(tpkglibdir)
   $:.unshift(tpkglibdir)
 end
 
+# We store this gem in our thirdparty directory. So we need to add it
+# it to the search path
+#  This one is for when everything is installed
+$:.unshift(File.join(File.dirname(__FILE__), 'thirdparty/kwalify-0.7.1/lib'))
+#  And this one for when we're in the svn directory structure
+$:.unshift(File.join(File.dirname(File.dirname(__FILE__)), 'thirdparty/kwalify-0.7.1/lib'))
+
 begin
   # Try loading facter w/o gems first so that we don't introduce a
   # dependency on gems if it is not needed.
@@ -45,16 +52,20 @@ require 'versiontype'    # Version
 require 'deployer'
 require 'set'
 require 'metadata'
+require 'kwalify'        # for validating yaml
 
 class Tpkg
   
-  VERSION = '1.18.2'
+  VERSION = '1.19.2'
   CONFIGDIR = '/etc'
-  
+
+  GENERIC_ERR = 1  
   POSTINSTALL_ERR = 2
   POSTREMOVE_ERR = 3
   INITSCRIPT_ERR = 4
 
+  CONNECTION_TIMEOUT = 10
+
   attr_reader :installed_directory
  
   #
@@ -74,6 +85,8 @@ class Tpkg
   # Find GNU tar or bsdtar in ENV['PATH']
   # Raises an exception if a suitable tar cannot be found
   @@tar = nil
+  @@taroptions = ""
+  @@tartype = nil
   TARNAMES = ['tar', 'gtar', 'gnutar', 'bsdtar']
   def self.find_tar
     if !@@tar
@@ -83,7 +96,12 @@ class Tpkg
             if File.executable?(File.join(path, tarname))
               IO.popen("#{File.join(path, tarname)} --version 2>/dev/null") do |pipe|
                 pipe.each_line do |line|
-                  if line.include?('GNU tar') || line.include?('bsdtar')
+                  if line.include?('GNU tar') 
+                    @@tartype = 'gnu'
+                    @@tar = File.join(path, tarname)
+                    throw :tar_found
+                  elsif line.include?('bsdtar')
+                    @@tartype = 'bsd'
                     @@tar = File.join(path, tarname)
                     throw :tar_found
                   end
@@ -96,6 +114,15 @@ class Tpkg
         raise "Unable to find GNU tar or bsdtar in PATH"
       end
     end
+    # bsdtar uses pax format by default. This format allows for vendor extensions, such 
+    # as the SCHILY.* extensions which were introduced by star). bsdtar actually uses
+    # these extensions. These extension headers includde useful, but not vital information.
+    # gnu tar should just ignore them and gives a warning. This is what the latest gnu tar
+    # will do. However, on older gnu tar, it only threw an error at the end. The work 
+    # around is to explicitly tell gnu tar to ignore those extensions.
+    if @@tartype == 'gnu'
+      @@taroptions = "--pax-option='delete=SCHILY.*'"
+    end
     @@tar.dup
   end
   def self.clear_cached_tar
@@ -190,8 +217,7 @@ class Tpkg
   end
   
   # Makes a package from a directory containing the files to put into the package
-  REQUIRED_FIELDS = ['name', 'version', 'maintainer']
-  def self.make_package(pkgsrcdir, passphrase=nil)
+  def self.make_package(pkgsrcdir, passphrase=nil, options = {})
     pkgfile = nil
     
     # Make a working directory
@@ -225,23 +251,40 @@ class Tpkg
       # code (tar) ever touch the user's files.
       system("#{find_tar} -C #{pkgsrcdir} -cf - . | #{find_tar} -C #{tpkgdir} -xpf -") || raise("Package content copy failed")
       
+      # check metadata file 
+      errors = []
       if File.exists?(File.join(tpkgdir, 'tpkg.yml'))
-        metadata_text = File.read(File.join(tpkgdir, 'tpkg.yml'))
-        metadata = Metadata.new(metadata_text, 'yml')
+        metadata_file = File.join(tpkgdir, 'tpkg.yml')
+        metadata_format = 'yml'
       elsif File.exists?(File.join(tpkgdir, 'tpkg.xml'))
-        metadata_text = File.read(File.join(tpkgdir, 'tpkg.xml'))
-        metadata = Metadata.new(metadata_text, 'xml')
+        metadata_file = File.join(tpkgdir, 'tpkg.xml')
+        metadata_format = 'xml'
       else
         raise 'Your source directory does not contain the metadata configuration file.'
       end
+      metadata_text = File.read(metadata_file)
+      metadata = Metadata.new(metadata_text, metadata_format)
 
-      metadata.verify_required_fields
+      # This is the directory where we put our dtd/schema for validating
+      # the metadata file
+      if File.exist?(File.join(CONFIGDIR, 'tpkg', 'schema'))
+        schema_dir = File.join(CONFIGDIR, 'tpkg', 'schema')
+      else # This is for when we're in developement mode or when installed as gem
+        schema_dir = File.join(File.dirname(File.dirname(__FILE__)), "schema")
+      end
+      errors = metadata.validate(schema_dir)
+      if errors && !errors.empty? 
+        puts "Bad metadata file. Possible error(s):"
+        errors.each {|e| puts e }
+        raise "Failed to create package."  unless options[:force]
+      end
 
       # file_metadata.yml hold information for files that are installed
       # by the package. For example, checksum, path, relocatable or not, etc.
       File.open(File.join(tpkgdir, "file_metadata.bin"), "w") do |file|
         filemetadata = get_filemetadata_from_directory(tpkgdir)
-        Marshal::dump(filemetadata.to_hash, file)
+        data = filemetadata.to_hash.recursively{|h| h.stringify_keys }
+        Marshal::dump(data, file)
 #        YAML::dump(filemetadata.to_hash, file)  
       end
 
@@ -259,6 +302,19 @@ class Tpkg
           raise "File #{tpkg_path} referenced in tpkg.yml but not found"
         end
 
+        # check permission/ownership of crontab files
+        if tpkgfile[:crontab]
+          data = {:actual_file => working_path, :metadata => metadata, :file_metadata => tpkgfile}
+          perms, uid, gid = predict_file_perms_and_ownership(data)
+          # crontab needs to be owned by root, and is not writable by group or others
+          if uid != 0 
+            warn "Warning: Your cron jobs in \"#{tpkgfile[:path]}\" might fail to run because the file is not owned by root."
+          end
+          if (perms & 0022) != 0
+            warn "Warning: Your cron jobs in \"#{tpkgfile[:path]}\" might fail to run because the file is writable by group and/or others."
+          end
+        end
+
         # Encrypt any files marked for encryption
         if tpkgfile[:encrypt]
           if tpkgfile[:encrypt] == 'precrypt'
@@ -323,8 +379,12 @@ class Tpkg
     toplevel = nil
     # FIXME: This is so lame, to read the whole package to get the
     # first filename.  Blech.
-    IO.popen("#{find_tar} -tf #{package_file}") do |pipe|
-      toplevel = pipe.gets.chomp
+    IO.popen("#{find_tar} -tf #{package_file} #{@@taroptions}") do |pipe|
+      toplevel = pipe.gets
+      if toplevel.nil?
+         raise "Package directory structure of #{package_file} unexpected. Unable to get top level."
+      end
+      toplevel.chomp!
       # Avoid SIGPIPE, if we don't sink the rest of the output from tar
       # then tar ends up getting SIGPIPE when it tries to write to the
       # closed pipe and exits with error, which causes us to throw an
@@ -423,7 +483,7 @@ class Tpkg
     topleveldir = package_toplevel_directory(package_file)
     # Extract checksum.xml from the package
     checksum_xml = nil
-    IO.popen("#{find_tar} -xf #{package_file} -O #{File.join(topleveldir, 'checksum.xml')}") do |pipe|
+    IO.popen("#{find_tar} -xf #{package_file} -O #{File.join(topleveldir, 'checksum.xml')} #{@@taroptions}") do |pipe|
       checksum_xml = REXML::Document.new(pipe.read)
     end
     if !$?.success?
@@ -448,7 +508,7 @@ class Tpkg
         raise("Unrecognized checksum algorithm #{checksum.elements['algorithm']}")
       end
       # Extract tpkg.tar from the package and digest it
-      IO.popen("#{find_tar} -xf #{package_file} -O #{File.join(topleveldir, 'tpkg.tar')}") do |pipe|
+      IO.popen("#{find_tar} -xf #{package_file} -O #{File.join(topleveldir, 'tpkg.tar')} #{@@taroptions}") do |pipe|
         # Package files can be quite large, so we digest the package in
         # chunks.  A survey of the Internet turns up someone who tested
         # various chunk sizes on various platforms and found 4k to be
@@ -880,7 +940,7 @@ class Tpkg
     files[:root] = []
     files[:reloc] = []
     topleveldir = package_toplevel_directory(package_file)
-    IO.popen("#{find_tar} -xf #{package_file} -O #{File.join(topleveldir, 'tpkg.tar')} | #{find_tar} -tf -") do |pipe|
+    IO.popen("#{find_tar} -xf #{package_file} -O #{File.join(topleveldir, 'tpkg.tar')} #{@@taroptions}| #{find_tar} #{@@taroptions} -tf -") do |pipe|
       pipe.each do |file|
         file.chomp!
         if file =~ Regexp.new(File.join('tpkg', 'root'))
@@ -1007,6 +1067,7 @@ class Tpkg
   # 
   # servers is an array or a callback that list the remote servers where we want to deploy to
   def self.deploy(deploy_params, deploy_options, servers)
+    servers.uniq!
     deployer = Deployer.new(deploy_options)
     deployer.deploy(deploy_params, servers)
   end
@@ -1043,7 +1104,7 @@ class Tpkg
     begin
       topleveldir = Tpkg::package_toplevel_directory(package_file)
       workdir = Tpkg::tempdir(topleveldir)
-      system("#{find_tar} -xf #{package_file} -O #{File.join(topleveldir, 'tpkg.tar')} | #{find_tar} -C #{workdir} -xpf -")
+      system("#{find_tar} -xf #{package_file} -O #{File.join(topleveldir, 'tpkg.tar')} #{@@taroptions}| #{find_tar} #{@@taroptions} -C #{workdir} -xpf -")
      
       if File.exist?(File.join(workdir,"tpkg", "tpkg.yml"))
         metadata_file = File.join(workdir,"tpkg", "tpkg.yml")
@@ -1060,6 +1121,47 @@ class Tpkg
     end
     return result
   end
+
+  # The only restriction right now is that the file doesn't begin with "."
+  def self.valid_pkg_filename?(filename)
+    return File.basename(filename) !~ /^\./
+  end
+
+  # helper method for predicting the permissions and ownership of a file that 
+  # will be installed by tpkg. This is done by looking at:
+  #  1) its current perms & ownership
+  #  2) the file_defaults settings of the metadata file
+  #  3) the explicitly defined settings in the corresponding file section of the metadata file
+  def self.predict_file_perms_and_ownership(data)
+    perms = nil
+    uid = nil
+    gid = nil
+
+    # get current permission and ownership
+    if data[:actual_file]
+      stat = File.stat(data[:actual_file])
+      perms = stat.mode
+      uid = stat.uid
+      gid = stat.gid
+    end
+
+    # get default permission and ownership
+    metadata = data[:metadata]
+    if (metadata && metadata[:files] && metadata[:files][:file_defaults] && metadata[:files][:file_defaults][:posix])
+      uid = Tpkg::lookup_uid(metadata[:files][:file_defaults][:posix][:owner]) if metadata[:files][:file_defaults][:posix][:owner]
+      gid = Tpkg::lookup_uid(metadata[:files][:file_defaults][:posix][:group]) if metadata[:files][:file_defaults][:posix][:group]
+      perms = metadata[:files][:file_defaults][:posix][:perms] if metadata[:files][:file_defaults][:posix][:perms]
+    end
+
+    # get explicitly defined permission and ownership
+    file_metadata = data[:file_metadata]
+    if file_metadata && file_metadata[:posix]
+      uid = Tpkg::lookup_uid(file_metadata[:posix][:owner]) if file_metadata[:posix][:owner]
+      gid = Tpkg::lookup_uid(file_metadata[:posix][:group]) if file_metadata[:posix][:group]
+      perms = file_metadata[:posix][:perms] if file_metadata[:posix][:perms]
+    end
+    return perms, uid, gid
+  end 
   
   #
   # Instance methods
@@ -1598,7 +1700,7 @@ class Tpkg
     metadata = {}
     if File.directory?(@installed_directory)
       Dir.foreach(@installed_directory) do |entry|
-        next if entry == '.' || entry == '..' || entry == 'metadata'
+        next if entry == '.' || entry == '..' || entry == 'metadata' || !Tpkg::valid_pkg_filename?(entry)
         # Check the timestamp on the file to see if it is new or has
         # changed since we last loaded data
         timestamp = File.mtime(File.join(@installed_directory, entry))
@@ -1642,7 +1744,7 @@ class Tpkg
             end
           end
           metadata[entry] = { :timestamp => timestamp,
-                              :metadata => m }
+                              :metadata => m } unless m.nil?
         end
       end
     end
@@ -1652,13 +1754,15 @@ class Tpkg
   end
   
   # Convert metadata_for_installed_packages into pkg hashes
-  def installed_packages
+  def installed_packages(pkgname=nil)
     instpkgs = []
     metadata_for_installed_packages.each do |metadata|
-      instpkgs << { :metadata => metadata,
-                    :source => :currently_installed,
-                    # It seems reasonable for this to default to true
-                    :prefer => true }
+      if !pkgname || metadata[:name] == pkgname
+        instpkgs << { :metadata => metadata,
+                      :source => :currently_installed,
+                      # It seems reasonable for this to default to true
+                      :prefer => true }
+      end
     end
     instpkgs
   end
@@ -1740,7 +1844,29 @@ class Tpkg
         end
       end
     else
-      installed_packages.each do |pkg|
+      pkgname = nil
+      if req && req[:name]
+        pkgname = req[:name]
+      end
+      # Passing a package name if we have one to installed_packages serves
+      # primarily to make following the debugging output of dependency
+      # resolution easier.  The dependency resolution process makes frequent
+      # calls to available_packages_that_meet_requirement, which in turn calls
+      # this method.  For available packages we're able to pre-filter based on
+      # package name before calling package_meets_requirement? because we
+      # store available packages hashed based on package name.
+      # package_meets_requirement? is fairly verbose in its debugging output,
+      # so the user sees each package it checks against a given requirement.
+      # It is therefore a bit disconcerting when trying to follow the
+      # debugging output to see the fairly clean process of checking available
+      # packages which have already been filtered to match the desired name,
+      # and then available_packages_that_meet_requirement calls this method,
+      # and the user starts to see every installed package checked against the
+      # same requirement.  It is not obvious to the someone why all of a
+      # sudden packages that aren't even remotely close to the requirement
+      # start getting checked.  Doing a pre-filter based on package name here
+      # makes the process more consistent and easier to follow.
+      installed_packages(pkgname).each do |pkg|
         if req
           if Tpkg::package_meets_requirement?(pkg, req)
             pkgs << pkg
@@ -1796,9 +1922,7 @@ class Tpkg
   # will be an array of package specs.
   MAX_POSSIBLE_SOLUTIONS_TO_CHECK = 10000
   def best_solution(requirements, packages, core_packages)
-    # Dup objects passed to us so that resolve_dependencies is free to
-    # change them without potentially messing up our caller
-    result = resolve_dependencies(requirements.dup, {:tpkg => packages.dup, :native => {}}, core_packages.dup)
+    result = resolve_dependencies(requirements, {:tpkg => packages, :native => {}}, core_packages)
     if @@debug
       if result[:solution]
         puts "bestsol picks: #{result[:solution].inspect}" if @@debug
@@ -1820,6 +1944,10 @@ class Tpkg
   # the same name.  This may be necessary if different dependencies of the
   # core packages end up needing both.
   def resolve_dependencies(requirements, packages, core_packages, number_of_possible_solutions_checked=0)
+    # We're probably going to make changes to packages, dup it now so
+    # that we don't mess up the caller's state.
+    packages = {:tpkg => packages[:tpkg].dup, :native => packages[:native].dup}
+
     # Make sure we have populated package lists for all requirements.
     # Filter the package lists against the requirements and
     # ensure we can at least satisfy the initial requirements.
@@ -1849,6 +1977,13 @@ class Tpkg
         return {:number_of_possible_solutions_checked => number_of_possible_solutions_checked}
       end
     end
+    
+    # FIXME: Should we weed out any entries in packages that don't correspond
+    # to something in requirements?  We operate later on the assumption that
+    # there are no such entries.  Because we dup packages at the right points
+    # I believe we'll never accidently end up with orphaned entries, but maybe
+    # it would be worth the compute cycles to make sure?
+    
     # Sort the packages
     [:tpkg, :native].each do |type|
       packages[type].each do |pkgname, pkgs|
@@ -1857,7 +1992,8 @@ class Tpkg
         # Anything else can score 1 at best.  This ensures
         # that we prefer the solution which leaves the most
         # currently installed packages alone.
-        if pkgs[0][:source] != :currently_installed &&
+        if pkgs[0] &&
+           pkgs[0][:source] != :currently_installed &&
            pkgs[0][:source] != :native_installed
           pkgs.unshift(nil)
         end
@@ -2001,6 +2137,7 @@ class Tpkg
                                   if sol[:remaining_noncoredepth] == 0
                                     result = check_solution(sol, requirements, packages, core_packages, number_of_possible_solutions_checked)
                                     if result[:solution]
+                                      puts "resolvdeps returning successful solution" if @@debug
                                       return result
                                     else
                                       number_of_possible_solutions_checked = result[:number_of_possible_solutions_checked]
@@ -2024,6 +2161,7 @@ class Tpkg
       end
     end
     # No solutions found
+    puts "resolvedeps returning failure" if @@debug
     return {:number_of_possible_solutions_checked => number_of_possible_solutions_checked}
   end
   
@@ -2036,7 +2174,7 @@ class Tpkg
     end
     
     if @@debug
-      puts "checksol checking #{solution.inspect}"
+      puts "checksol checking sol #{solution.inspect}"
     end
     
     # Extract dependencies from each package in the solution
@@ -2064,7 +2202,7 @@ class Tpkg
         if packages[newreq[:type]][newreq[:name]]
           pkg = solution[:pkgs].find{|solpkg| solpkg[:metadata][:name] == newreq[:name]}
           puts "checksol newreq pkg: #{pkg.inspect}" if @@debug
-          if Tpkg::package_meets_requirement?(pkg, newreq)
+          if pkg && Tpkg::package_meets_requirement?(pkg, newreq)
             # No change to solution needed
           else
             # Solution no longer works
@@ -2082,14 +2220,16 @@ class Tpkg
         return {:solution => solution[:pkgs]}
       else
         puts "checksol newreqs need packages, calling resolvedeps" if @@debug
-        result = resolve_dependencies(requirements+newreqs_that_need_packages, packages.dup, core_packages, number_of_possible_solutions_checked)
+        result = resolve_dependencies(requirements+newreqs_that_need_packages, packages, core_packages, number_of_possible_solutions_checked)
         if result[:solution]
+          puts "checksol returning successful solution" if @@debug
           return result
         else
           number_of_possible_solutions_checked = result[:number_of_possible_solutions_checked]
         end
       end
     end
+    puts "checksol returning failure" if @@debug
     return {:number_of_possible_solutions_checked => number_of_possible_solutions_checked}
   end
  
@@ -2320,7 +2460,7 @@ class Tpkg
   def unpack(package_file, passphrase=nil, options={})
     ret_val = 0
     metadata = Tpkg::metadata_from_package(package_file)
-    
+
     # Unpack files in a temporary directory
     # I'd prefer to unpack on the fly so that the user doesn't need to
     # have disk space to hold three copies of the package (the package
@@ -2330,7 +2470,7 @@ class Tpkg
     # directory structure in the package.
     topleveldir = Tpkg::package_toplevel_directory(package_file)
     workdir = Tpkg::tempdir(topleveldir, @tmp_directory)
-    system("#{@tar} -xf #{package_file} -O #{File.join(topleveldir, 'tpkg.tar')} | #{@tar} -C #{workdir} -xpf -")
+    system("#{@tar} -xf #{package_file} -O #{File.join(topleveldir, 'tpkg.tar')} #{@@taroptions} | #{@tar} #{@@taroptions} -C #{workdir} -xpf -")
     files_info = {} # store perms, uid, gid, etc. for files
     checksums_of_decrypted_files = {}
     root_dir = File.join(workdir, 'tpkg', 'root')
@@ -2341,7 +2481,7 @@ class Tpkg
     # Get list of conflicting files/directories & store their perm/ownership. That way, we can
     # set them to the correct values later on in order to preserve them.
     # TODO: verify this command works on all platforms
-    files = `#{@tar} -xf #{package_file} -O #{File.join(topleveldir, 'tpkg.tar')} | #{@tar} -tf -`
+    files = `#{@tar} -xf #{package_file} -O #{File.join(topleveldir, 'tpkg.tar')} #{@@taroptions} | #{@tar} #{@@taroptions} -tf -`
     files = files.split("\n")
     conflicting_files = {}
     files.each do | file |
@@ -2590,119 +2730,8 @@ class Tpkg
       system("#{@tar} -C #{File.join(workdir, 'tpkg', 'reloc')} -cf - . | #{@tar} -C #{@base} -xpf -")
     end
     
-    # Install any init scripts
-    init_links(metadata).each do |link, init_script|
-      # We don't have to any anything if there's already symlink to our init script.
-      # This can happen if user removes pkg manually without removing
-      # init symlink
-      next if File.symlink?(link) && File.readlink(link) == init_script
-      begin
-        if !File.exist?(File.dirname(link))
-          FileUtils.mkdir_p(File.dirname(link))
-        end
-        begin
-          File.symlink(init_script, link)
-        rescue Errno::EEXIST
-          # The link name that init_links provides is not guaranteed to
-          # be unique.  It might collide with a base system init script
-          # or an init script from another tpkg.  If the link name
-          # supplied by init_links results in EEXIST then try appending
-          # a number to the end of the link name.
-          catch :init_link_done do
-            1.upto(9) do |i|
-              begin
-                File.symlink(init_script, link + i.to_s)
-                throw :init_link_done
-              rescue Errno::EEXIST
-              end
-            end
-            # If we get here (i.e. we never reached the throw) then we
-            # failed to create any of the possible link names.
-            raise "Failed to install init script #{init_script} -> #{link} for #{File.basename(package_file)}"
-          end
-        end
-      rescue Errno::EPERM
-        # If creating the link fails due to permission problems and
-        # we're not running as root just warn the user, allowing folks
-        # to run tpkg as a non-root user with reduced functionality.
-        if Process.euid == 0
-          raise
-        else
-          warn "Failed to install init script for #{File.basename(package_file)}, probably due to lack of root privileges"
-        end
-      end
-    end
-    
-    # Install any crontabs
-    crontab_destinations(metadata).each do |crontab, destination|
-      begin
-        if destination[:link]
-          next if File.symlink?(destination[:link]) && File.readlink(destination[:link]) == crontab
-          if !File.exist?(File.dirname(destination[:link]))
-            FileUtils.mkdir_p(File.dirname(destination[:link]))
-          end
-          begin
-            File.symlink(crontab, destination[:link])
-          rescue Errno::EEXIST
-            # The link name that crontab_destinations provides is not
-            # guaranteed to be unique.  It might collide with a base
-            # system crontab or a crontab from another tpkg.  If the
-            # link name supplied by crontab_destinations results in
-            # EEXIST then try appending a number to the end of the link
-            # name.
-            catch :crontab_link_done do
-              1.upto(9) do |i|
-                begin
-                  File.symlink(crontab, destination[:link] + i.to_s)
-                  throw :crontab_link_done
-                rescue Errno::EEXIST
-                end
-              end
-              # If we get here (i.e. we never reached the throw) then we
-              # failed to create any of the possible link names.
-              raise "Failed to install crontab #{crontab} -> #{destination[:link]} for #{File.basename(package_file)}"
-            end
-          end
-        elsif destination[:file]
-          if !File.exist?(File.dirname(destination[:file]))
-            FileUtils.mkdir_p(File.dirname(destination[:file]))
-          end
-          tmpfile = Tempfile.new(File.basename(destination[:file]), File.dirname(destination[:file]))
-          if File.exist?(destination[:file])
-            # Match permissions and ownership of current crontab
-            st = File.stat(destination[:file])
-            File.chmod(st.mode & 07777, tmpfile.path)
-            File.chown(st.uid, st.gid, tmpfile.path)
-            # Insert the contents of the current crontab file
-            File.open(destination[:file]) { |file| tmpfile.write(file.read) }
-          end
-          # Insert a header line so we can find this section to remove later
-          tmpfile.puts "### TPKG START - #{@base} - #{File.basename(package_file)}"
-          # Insert the package crontab contents
-          crontab_contents = IO.read(crontab)
-          tmpfile.write(crontab_contents)
-          # Insert a newline if the crontab doesn't end with one
-          if crontab_contents.chomp == crontab_contents
-            tmpfile.puts
-          end
-          # Insert a footer line
-          tmpfile.puts "### TPKG END - #{@base} - #{File.basename(package_file)}"
-          tmpfile.close
-          File.rename(tmpfile.path, destination[:file])
-          # FIXME: On Solaris we should bounce cron or use the crontab
-          # command, otherwise cron won't pick up the changes
-        end
-      rescue Errno::EPERM
-        # If installing the crontab fails due to permission problems and
-        # we're not running as root just warn the user, allowing folks
-        # to run tpkg as a non-root user with reduced functionality.
-        if Process.euid == 0
-          raise
-        else
-          warn "Failed to install crontab for #{File.basename(package_file)}, probably due to lack of root privileges"
-        end
-      end
-    end
+    install_init_scripts(metadata)
+    install_crontabs(metadata)
     
     # Run postinstall script
     if File.exist?(File.join(workdir, 'tpkg', 'postinstall'))
@@ -2773,6 +2802,243 @@ class Tpkg
     return ret_val
   end
   
+  def install_init_scripts(metadata)
+    init_links(metadata).each do |link, init_script|
+      # We don't have to do anything if there's already symlink to our init
+      # script. This can happen if the user removes a package manually without
+      # removing the init symlink
+      next if File.symlink?(link) && File.readlink(link) == init_script
+      begin
+        if !File.exist?(File.dirname(link))
+          FileUtils.mkdir_p(File.dirname(link))
+        end
+        begin
+          File.symlink(init_script, link)
+        rescue Errno::EEXIST
+          # The link name that init_links provides is not guaranteed to
+          # be unique.  It might collide with a base system init script
+          # or an init script from another tpkg.  If the link name
+          # supplied by init_links results in EEXIST then try appending
+          # a number to the end of the link name.
+          catch :init_link_done do
+            1.upto(9) do |i|
+              begin
+                File.symlink(init_script, link + i.to_s)
+                throw :init_link_done
+              rescue Errno::EEXIST
+              end
+            end
+            # If we get here (i.e. we never reached the throw) then we
+            # failed to create any of the possible link names.
+            raise "Failed to install init script #{init_script} -> #{link} for #{File.basename(metadata[:filename].to_s)}, too many overlapping filenames"
+          end
+        end
+      # EACCES for file/directory permissions issues
+      rescue Errno::EACCES => e
+        # If creating the link fails due to permission problems and
+        # we're not running as root just warn the user, allowing folks
+        # to run tpkg as a non-root user with reduced functionality.
+        if Process.euid != 0
+          warn "Failed to install init script for #{File.basename(metadata[:filename].to_s)}, probably due to lack of root privileges: #{e.message}"
+        else
+          raise e
+        end
+      end
+    end
+  end
+  def remove_init_scripts(metadata)
+    init_links(metadata).each do |link, init_script|
+      # The link we ended up making when we unpacked the package could be any
+      # of a series (see the code in install_init_scripts for the reasoning),
+      # we need to check them all.
+      links = [link]
+      links.concat((1..9).to_a.map { |i| link + i.to_s })
+      links.each do |l|
+        if File.symlink?(l) && File.readlink(l) == init_script
+          begin
+            File.delete(l)
+          # EACCES for file/directory permissions issues
+          rescue Errno::EACCES => e
+            # If removing the link fails due to permission problems and
+            # we're not running as root just warn the user, allowing folks
+            # to run tpkg as a non-root user with reduced functionality.
+            if Process.euid != 0
+              warn "Failed to remove init script for #{File.basename(metadata[:filename].to_s)}, probably due to lack of root privileges: #{e.message}"
+            else
+              raise e
+            end
+          end
+        end
+      end
+    end
+  end
+  
+  def install_crontabs(metadata)
+    crontab_destinations(metadata).each do |crontab, destination|
+      begin
+        if destination[:link]
+          install_crontab_link(metadata, crontab, destination)
+        elsif destination[:file]
+          install_crontab_file(metadata, crontab, destination)
+        end
+      # EACCES for file/directory permissions issues
+      rescue Errno::EACCES => e
+        # If installing the crontab fails due to permission problems and
+        # we're not running as root just warn the user, allowing folks
+        # to run tpkg as a non-root user with reduced functionality.
+        if Process.euid != 0
+          warn "Failed to install crontab for #{File.basename(metadata[:filename].to_s)}, probably due to lack of root privileges: #{e.message}"
+        else
+          raise e
+        end
+      rescue RuntimeError => e
+        if e.message.include?('cannot generate tempfile') && Process.euid != 0
+          warn "Failed to install crontab for #{File.basename(metadata[:filename].to_s)}, probably due to lack of root privileges: #{e.message}"
+        else
+          raise e
+        end
+      end
+    end
+  end
+  def install_crontab_link(metadata, crontab, destination)
+    return if File.symlink?(destination[:link]) && File.readlink(destination[:link]) == crontab
+    if !File.exist?(File.dirname(destination[:link]))
+      FileUtils.mkdir_p(File.dirname(destination[:link]))
+    end
+    begin
+      File.symlink(crontab, destination[:link])
+    rescue Errno::EEXIST
+      # The link name that crontab_destinations provides is not
+      # guaranteed to be unique.  It might collide with a base
+      # system crontab or a crontab from another tpkg.  If the
+      # link name supplied by crontab_destinations results in
+      # EEXIST then try appending a number to the end of the link
+      # name.
+      catch :crontab_link_done do
+        1.upto(9) do |i|
+          begin
+            File.symlink(crontab, destination[:link] + i.to_s)
+            throw :crontab_link_done
+          rescue Errno::EEXIST
+          end
+        end
+        # If we get here (i.e. we never reached the throw) then we
+        # failed to create any of the possible link names.
+        raise "Failed to install crontab #{crontab} -> #{destination[:link]} for #{File.basename(metadata[:filename].to_s)}, too many overlapping filenames"
+      end
+    end
+  end
+  def install_crontab_file(metadata, crontab, destination)
+    if !File.exist?(File.dirname(destination[:file]))
+      FileUtils.mkdir_p(File.dirname(destination[:file]))
+    end
+    tmpfile = Tempfile.new(File.basename(destination[:file]), File.dirname(destination[:file]))
+    if File.exist?(destination[:file])
+      # Match permissions and ownership of current crontab
+      st = File.stat(destination[:file])
+      begin
+        File.chmod(st.mode & 07777, tmpfile.path)
+        File.chown(st.uid, st.gid, tmpfile.path)
+      # EPERM for attempts to chown/chmod as non-root user
+      rescue Errno::EPERM => e
+        # If installing the crontab fails due to permission problems and
+        # we're not running as root just warn the user, allowing folks
+        # to run tpkg as a non-root user with reduced functionality.
+        if Process.euid != 0
+          warn "Failed to install crontab for #{File.basename(metadata[:filename].to_s)}, probably due to lack of root privileges: #{e.message}"
+        else
+          raise e
+        end
+      end
+      # Insert the contents of the current crontab file
+      File.open(destination[:file]) { |file| tmpfile.write(file.read) }
+    end
+    # Insert a header line so we can find this section to remove later
+    tmpfile.puts "### TPKG START - #{@base} - #{File.basename(metadata[:filename].to_s)}"
+    # Insert the package crontab contents
+    crontab_contents = IO.read(crontab)
+    tmpfile.write(crontab_contents)
+    # Insert a newline if the crontab doesn't end with one
+    if crontab_contents.chomp == crontab_contents
+      tmpfile.puts
+    end
+    # Insert a footer line
+    tmpfile.puts "### TPKG END - #{@base} - #{File.basename(metadata[:filename].to_s)}"
+    tmpfile.close
+    File.rename(tmpfile.path, destination[:file])
+    # FIXME: On Solaris we should bounce cron or use the crontab
+    # command, otherwise cron won't pick up the changes
+  end
+  def remove_crontabs(metadata)
+    crontab_destinations(metadata).each do |crontab, destination|
+      begin
+        if destination[:link]
+          remove_crontab_link(metadata, crontab, destination)
+        elsif destination[:file]
+          remove_crontab_file(metadata, crontab, destination)
+        end
+      # EACCES for file/directory permissions issues
+      rescue Errno::EACCES => e
+        # If removing the crontab fails due to permission problems and
+        # we're not running as root just warn the user, allowing folks
+        # to run tpkg as a non-root user with reduced functionality.
+        if Process.euid != 0
+          warn "Failed to remove crontab for #{File.basename(metadata[:filename].to_s)}, probably due to lack of root privileges: #{e.message}"
+        else
+          raise e
+        end
+      end
+    end
+  end
+  def remove_crontab_link(metadata, crontab, destination)
+    # The link we ended up making when we unpacked the package could
+    # be any of a series (see the code in unpack for the reasoning),
+    # we need to check them all.
+    links = [destination[:link]]
+    links.concat((1..9).to_a.map { |i| destination[:link] + i.to_s })
+    links.each do |l|
+      if File.symlink?(l) && File.readlink(l) == crontab
+        File.delete(l)
+      end
+    end
+  end
+  def remove_crontab_file(metadata, crontab, destination)
+    if File.exist?(destination[:file])
+      tmpfile = Tempfile.new(File.basename(destination[:file]), File.dirname(destination[:file]))
+      # Match permissions and ownership of current crontab
+      st = File.stat(destination[:file])
+      begin
+        File.chmod(st.mode & 07777, tmpfile.path)
+        File.chown(st.uid, st.gid, tmpfile.path)
+      # EPERM for attempts to chown/chmod as non-root user
+      rescue Errno::EPERM => e
+        # If installing the crontab fails due to permission problems and
+        # we're not running as root just warn the user, allowing folks
+        # to run tpkg as a non-root user with reduced functionality.
+        if Process.euid != 0
+          warn "Failed to install crontab for #{File.basename(metadata[:filename].to_s)}, probably due to lack of root privileges: #{e.message}"
+        else
+          raise
+        end
+      end
+      # Remove section associated with this package
+      skip = false
+      IO.foreach(destination[:file]) do |line|
+        if line == "### TPKG START - #{@base} - #{File.basename(metadata[:filename].to_s)}\n"
+          skip = true
+        elsif line == "### TPKG END - #{@base} - #{File.basename(metadata[:filename].to_s)}\n"
+          skip = false
+        elsif !skip
+          tmpfile.write(line)
+        end
+      end
+      tmpfile.close
+      File.rename(tmpfile.path, destination[:file])
+      # FIXME: On Solaris we should bounce cron or use the crontab
+      # command, otherwise cron won't pick up the changes
+    end
+  end
+  
   def requirements_for_currently_installed_package(pkgname=nil)
     requirements = []
     metadata_for_installed_packages.each do |metadata|
@@ -2833,7 +3099,7 @@ class Tpkg
         req = Tpkg::parse_request(request, @installed_directory)
         newreqs << req
 
-        # Initialize the list of possible packages for this req
+        puts "Initializing the list of possible packages for this req" if @@debug
         if !packages[req[:name]]
           packages[req[:name]] = available_packages_that_meet_requirement(req)
         end
@@ -2843,7 +3109,14 @@ class Tpkg
         source = nil
         localpath = nil
         if File.file?(request)
+          raise "Invalid package filename #{request}" if !Tpkg::valid_pkg_filename?(request)
+
           puts "parse_requests treating request as a file" if @@debug
+
+          if request !~ /\.tpkg$/
+            warn "Warning: Attempting to perform the request on #{File.expand_path(request)}. This might not be a valid package file."
+          end
+
           localpath = request
           metadata = Tpkg::metadata_from_package(request)
           source = request
@@ -2892,7 +3165,8 @@ class Tpkg
         good_package = true
         metadata = pkg[:metadata]
         req = { :name => metadata[:name], :type => :tpkg }
-        # Quick sanity check that the package can be installed on this machine.  
+        # Quick sanity check that the package can be installed on this machine.
+        puts "check_requests checking that available package for request works on this machine: #{pkg.inspect}" if @@debug
         if !Tpkg::package_meets_requirement?(pkg, req)
           possible_errors << "  Requested package #{metadata[:filename]} doesn't match this machine's OS or architecture"
           good_package = false
@@ -2901,6 +3175,7 @@ class Tpkg
         # a sanity check that there is at least one package
         # available for each dependency of this package
         metadata[:dependencies].each do |depreq|
+          puts "check_requests checking for available packages to satisfy dependency: #{depreq.inspect}" if @@debug
           if available_packages_that_meet_requirement(depreq).empty? && !Tpkg::packages_meet_requirement?(packages.values.flatten, depreq)
             possible_errors << "  Requested package #{metadata[:filename]} depends on #{depreq.inspect}, no packages that satisfy that dependency are available"
             good_package = false
@@ -3386,6 +3661,11 @@ class Tpkg
         else
           pkgfile = download(pkg[:source], pkg[:metadata][:filename])
         end
+
+        if !Tpkg::valid_pkg_filename?(pkgfile)
+          raise "Invalid package filename: #{pkgfile}"
+        end
+
         if prompt_for_conflicting_files(pkgfile, CHECK_UPGRADE)
           # If the old and new packages have overlapping externals flag them
           # to be skipped so that the external isn't removed and then
@@ -3399,7 +3679,7 @@ class Tpkg
           end if pkg[:metadata][:externals]
 
           # Remove the old package if we haven't done so
-          unless removed_pkgs.include?(pkg[:metadata][:name])
+          unless oldpkgs.nil? or oldpkgs.empty? or removed_pkgs.include?(pkg[:metadata][:name])
             remove([pkg[:metadata][:name]], :upgrade => true, :externals_to_skip => externals_to_skip)
             removed_pkgs << pkg[:metadata][:name]  
           end
@@ -3441,6 +3721,7 @@ class Tpkg
     
     packages_to_remove = nil
     if requests
+      requests.uniq! if requests.is_a?(Array)
       packages_to_remove = []
       requests.each do |request|
         req = Tpkg::parse_request(request, @installed_directory)
@@ -3548,7 +3829,7 @@ class Tpkg
     
       topleveldir = Tpkg::package_toplevel_directory(package_file)
       workdir = Tpkg::tempdir(topleveldir, @tmp_directory)
-      system("#{@tar} -xf #{package_file} -O #{File.join(topleveldir, 'tpkg.tar')} | #{@tar} -C #{workdir} -xpf -")
+      system("#{@tar} -xf #{package_file} -O #{File.join(topleveldir, 'tpkg.tar')} #{@@taroptions} | #{@tar} #{@@taroptions} -C #{workdir} -xpf -")
     
       # Run preremove script
       if File.exist?(File.join(workdir, 'tpkg', 'preremove'))
@@ -3571,86 +3852,9 @@ class Tpkg
         # Switch back to our previous directory
         Dir.chdir(pwd)
       end
-    
-      # Remove any init scripts
-      init_links(pkg[:metadata]).each do |link, init_script|
-        # The link we ended up making when we unpacked the package could
-        # be any of a series (see the code in unpack for the reasoning),
-        # we need to check them all.
-        links = [link]
-        links.concat((1..9).to_a.map { |i| link + i.to_s })
-        links.each do |l|
-          if File.symlink?(l) && File.readlink(l) == init_script
-            begin
-              File.delete(l)
-            rescue Errno::EPERM
-              if Process.euid == 0
-                raise
-              else
-                warn "Failed to remove init script for #{File.basename(package_file)}, probably due to lack of root privileges"
-              end
-            end
-          end
-        end
-      end
-    
-      # Remove any crontabs
-      crontab_destinations(pkg[:metadata]).each do |crontab, destination|
-        begin
-          if destination[:link]
-            # The link we ended up making when we unpacked the package could
-            # be any of a series (see the code in unpack for the reasoning),
-            # we need to check them all.
-            links = [destination[:link]]
-            links.concat((1..9).to_a.map { |i| destination[:link] + i.to_s })
-            links.each do |l|
-              if File.symlink?(l) && File.readlink(l) == crontab
-                begin
-                  File.delete(l)
-                rescue Errno::EPERM
-                  if Process.euid == 0
-                    raise
-                  else
-                    warn "Failed to remove crontab for #{File.basename(package_file)}, probably due to lack of root privileges"
-                  end
-                end
-              end
-            end
-          elsif destination[:file]
-            if File.exist?(destination[:file])
-              tmpfile = Tempfile.new(File.basename(destination[:file]), File.dirname(destination[:file]))
-              # Match permissions and ownership of current crontab
-              st = File.stat(destination[:file])
-              File.chmod(st.mode & 07777, tmpfile.path)
-              File.chown(st.uid, st.gid, tmpfile.path)
-              # Remove section associated with this package
-              skip = false
-              IO.foreach(destination[:file]) do |line|
-                if line == "### TPKG START - #{@base} - #{File.basename(package_file)}\n"
-                  skip = true
-                elsif line == "### TPKG END - #{@base} - #{File.basename(package_file)}\n"
-                  skip = false
-                elsif !skip
-                  tmpfile.write(line)
-                end
-              end
-              tmpfile.close
-              File.rename(tmpfile.path, destination[:file])
-              # FIXME: On Solaris we should bounce cron or use the crontab
-              # command, otherwise cron won't pick up the changes
-            end
-          end
-        rescue Errno::EPERM
-          # If removing the crontab fails due to permission problems and
-          # we're not running as root just warn the user, allowing folks
-          # to run tpkg as a non-root user with reduced functionality.
-          if Process.euid == 0
-            raise
-          else
-            warn "Failed to remove crontab for #{File.basename(package_file)}, probably due to lack of root privileges"
-          end
-        end
-      end
+      
+      remove_init_scripts(pkg[:metadata])
+      remove_crontabs(pkg[:metadata])
       
       # Run any externals
       pkg[:metadata][:externals].each do |external|
@@ -3678,6 +3882,12 @@ class Tpkg
           end
         rescue Errno::ENOENT
           warn "File #{file} from package #{File.basename(package_file)} missing during remove"
+        # I know it's bad to have a generic rescue for all exceptions, but in this case, there
+        # can be many things that might go wrong when removing a file. We don't want tpkg
+        # to crash and leave the packages in a bad state. It's better to catch
+        # all exceptions and give the user some warnings.
+        rescue
+          warn "Failed to remove file #{file}."
         end
       end
     
@@ -3845,6 +4055,7 @@ class Tpkg
     if requested_packages.nil?
       packages_to_execute_on = installed_packages_that_meet_requirement(nil)
     else
+      requested_packages.uniq!
       requested_packages.each do |request|
         req = Tpkg::parse_request(request)
         packages_to_execute_on.concat(installed_packages_that_meet_requirement(req))
@@ -3958,21 +4169,25 @@ class Tpkg
     end
   end
 
-  # TODO: update server side to accept yaml data
   def send_update_to_server
     metadata = metadata_for_installed_packages.collect{|metadata| metadata.to_hash}
     yml = YAML.dump(metadata)
     begin
-      update_uri =  URI.parse("#{@report_server}")
-      http = Tpkg::gethttp(update_uri)
-      request = {"yml"=>URI.escape(yml), "client"=>Facter['fqdn'].value}
-      post = Net::HTTP::Post.new(update_uri.path)
-      post.set_form_data(request)
-      response = http.request(post)
+      response = nil
+      # Need to set timeout otherwise tpkg can hang for a long time when having
+      # problem talking to the reporter server.
+      # I can't seem get net-ssh timeout to work so we'll just handle the timeout ourselves
+      timeout(CONNECTION_TIMEOUT) do
+        update_uri =  URI.parse("#{@report_server}")
+        http = Tpkg::gethttp(update_uri)
+        request = {"yml"=>URI.escape(yml), "client"=>Facter['fqdn'].value}
+        post = Net::HTTP::Post.new(update_uri.path)
+        post.set_form_data(request)
+        response = http.request(post)
+      end
 
       case response
       when Net::HTTPSuccess
-#       puts "Response from server:\n'#{response.body}'"
        puts "Successfully send update to reporter server"
       else
         $stderr.puts response.body
@@ -3980,10 +4195,12 @@ class Tpkg
         # just ignore error and give user warning
         puts "Failed to send update to reporter server"
       end
+    rescue Timeout::Error
+      puts "Timed out when trying to send update to reporter server"
     rescue
       puts "Failed to send update to reporter server"
     end
-  end  
+  end
 
   # Build a dependency map of currently installed packages
   # For example, if we have pkgB and pkgC which depends on pkgA, then