[p5sagit/p5-mst-13.2.git] / lib / CPAN / Tarzip.pm

# -*- Mode: cperl; coding: utf-8; cperl-indent-level: 2 -*-
package CPAN::Tarzip;
use strict;
use vars qw($VERSION @ISA $BUGHUNTING);
use CPAN::Debug;
use File::Basename ();
$VERSION = sprintf "%.6f", substr(q$Rev: 858 $,4)/1000000 + 5.4;
# module is internal to CPAN.pm

@ISA = qw(CPAN::Debug);
$BUGHUNTING ||= 0; # released code must have turned off

# it's ok if file doesn't exist, it just matters if it is .gz or .bz2
sub new {
  my($class,$file) = @_;
  $CPAN::Frontend->mydie("new called without arg") unless defined $file;
  if (0) {
    # nonono, we get e.g. 01mailrc.txt uncompressed if only wget is available
    $CPAN::Frontend->mydie("file[$file] doesn't match /\\.(bz2|gz|zip|tgz)\$/")
        unless $file =~ /\.(bz2|gz|zip|tgz)$/i;
  }
  my $me = { FILE => $file };
  if (0) {
  } elsif ($file =~ /\.bz2$/i) {
    unless ($me->{UNGZIPPRG} = $CPAN::Config->{bzip2}) {
      my $bzip2;
      if ($CPAN::META->has_inst("File::Which")) {
        $bzip2 = File::Which::which("bzip2");
      }
      if ($bzip2) {
        $me->{UNGZIPPRG} = $bzip2 || "bzip2";
      } else {
        $CPAN::Frontend->mydie(qq{
CPAN.pm needs the external program bzip2 in order to handle '$file'.
Please install it now and run 'o conf init' to register it as external
program.
});
      }
    }
  } else {
    # yes, we let gzip figure it out in *any* other case
    $me->{UNGZIPPRG} = $CPAN::Config->{gzip} || "gzip";
  }
  bless $me, $class;
}

sub gzip {
  my($self,$read) = @_;
  my $write = $self->{FILE};
  if ($CPAN::META->has_inst("Compress::Zlib")) {
    my($buffer,$fhw);
    $fhw = FileHandle->new($read)
	or $CPAN::Frontend->mydie("Could not open $read: $!");
	my $cwd = `pwd`;
    my $gz = Compress::Zlib::gzopen($write, "wb")
	or $CPAN::Frontend->mydie("Cannot gzopen $write: $! (pwd is $cwd)\n");
    $gz->gzwrite($buffer)
	while read($fhw,$buffer,4096) > 0 ;
    $gz->gzclose() ;
    $fhw->close;
    return 1;
  } else {
    my $command = CPAN::HandleConfig->safe_quote($self->{UNGZIPPRG});
    system(qq{$command -c "$read" > "$write"})==0;
  }
}


sub gunzip {
  my($self,$write) = @_;
  my $read = $self->{FILE};
  if ($CPAN::META->has_inst("Compress::Zlib")) {
    my($buffer,$fhw);
    $fhw = FileHandle->new(">$write")
	or $CPAN::Frontend->mydie("Could not open >$write: $!");
    my $gz = Compress::Zlib::gzopen($read, "rb")
	or $CPAN::Frontend->mydie("Cannot gzopen $read: $!\n");
    $fhw->print($buffer)
	while $gz->gzread($buffer) > 0 ;
    $CPAN::Frontend->mydie("Error reading from $read: $!\n")
	if $gz->gzerror != Compress::Zlib::Z_STREAM_END();
    $gz->gzclose() ;
    $fhw->close;
    return 1;
  } else {
    my $command = CPAN::HandleConfig->safe_quote($self->{UNGZIPPRG});
    system(qq{$command -dc "$read" > "$write"})==0;
  }
}


sub gtest {
  my($self) = @_;
  return $self->{GTEST} if exists $self->{GTEST};
  my $read = $self->{FILE} or die;
  my $success;
  # After I had reread the documentation in zlib.h, I discovered that
  # uncompressed files do not lead to an gzerror (anymore?).
  if ( $CPAN::META->has_inst("Compress::Zlib") ) {
    my($buffer,$len);
    $len = 0;
    my $gz = Compress::Zlib::gzopen($read, "rb")
	or $CPAN::Frontend->mydie(sprintf("Cannot gzopen %s: %s\n",
                                          $read,
                                          $Compress::Zlib::gzerrno));
    while ($gz->gzread($buffer) > 0 ){
        $len += length($buffer);
        $buffer = "";
    }
    my $err = $gz->gzerror;
    $success = ! $err || $err == Compress::Zlib::Z_STREAM_END();
    if ($len == -s $read){
        $success = 0;
        CPAN->debug("hit an uncompressed file") if $CPAN::DEBUG;
    }
    $gz->gzclose();
    CPAN->debug("err[$err]success[$success]") if $CPAN::DEBUG;
  } else {
    my $command = CPAN::HandleConfig->safe_quote($self->{UNGZIPPRG});
    $success = 0==system(qq{$command -qdt "$read"});
  }
  return $self->{GTEST} = $success;
}


sub TIEHANDLE {
  my($class,$file) = @_;
  my $ret;
  $class->debug("file[$file]");
  my $self = $class->new($file);
  if (0) {
  } elsif (!$self->gtest) {
    my $fh = FileHandle->new($file) or die "Could not open file[$file]: $!";
    binmode $fh;
    $self->{FH} = $fh;
  } elsif ($CPAN::META->has_inst("Compress::Zlib")) {
    my $gz = Compress::Zlib::gzopen($file,"rb") or
	die "Could not gzopen $file";
    $self->{GZ} = $gz;
  } else {
    my $gzip = CPAN::HandleConfig->safe_quote($self->{UNGZIPPRG});
    my $pipe = "$gzip -dc $file |";
    my $fh = FileHandle->new($pipe) or die "Could not pipe[$pipe]: $!";
    binmode $fh;
    $self->{FH} = $fh;
  }
  $self;
}


sub READLINE {
  my($self) = @_;
  if (exists $self->{GZ}) {
    my $gz = $self->{GZ};
    my($line,$bytesread);
    $bytesread = $gz->gzreadline($line);
    return undef if $bytesread <= 0;
    return $line;
  } else {
    my $fh = $self->{FH};
    return scalar <$fh>;
  }
}


sub READ {
  my($self,$ref,$length,$offset) = @_;
  die "read with offset not implemented" if defined $offset;
  if (exists $self->{GZ}) {
    my $gz = $self->{GZ};
    my $byteread = $gz->gzread($$ref,$length);# 30eaf79e8b446ef52464b5422da328a8
    return $byteread;
  } else {
    my $fh = $self->{FH};
    return read($fh,$$ref,$length);
  }
}


sub DESTROY {
    my($self) = @_;
    if (exists $self->{GZ}) {
        my $gz = $self->{GZ};
        $gz->gzclose() if defined $gz; # hard to say if it is allowed
                                       # to be undef ever. AK, 2000-09
    } else {
        my $fh = $self->{FH};
        $fh->close if defined $fh;
    }
    undef $self;
}


sub untar {
  my($self) = @_;
  my $file = $self->{FILE};
  my($prefer) = 0;

  if (0) { # makes changing order easier
  } elsif ($BUGHUNTING){
    $prefer=2;
  } elsif (MM->maybe_command($self->{UNGZIPPRG})
           &&
           MM->maybe_command($CPAN::Config->{tar})) {
    # should be default until Archive::Tar handles bzip2
    $prefer = 1;
  } elsif (
           $CPAN::META->has_inst("Archive::Tar")
           &&
           $CPAN::META->has_inst("Compress::Zlib") ) {
    $prefer = 2;
  } else {
    $CPAN::Frontend->mydie(qq{
CPAN.pm needs either the external programs tar, gzip and bzip2
installed. Can't continue.
});
  }
  if ($prefer==1) { # 1 => external gzip+tar
    my($system);
    my $is_compressed = $self->gtest();
    my $tarcommand = CPAN::HandleConfig->safe_quote($CPAN::Config->{tar}) || "tar";
    if ($is_compressed) {
      my $command = CPAN::HandleConfig->safe_quote($self->{UNGZIPPRG});
      $system = qq{$command -dc }.
          qq{< "$file" | $tarcommand xvf -};
    } else {
      $system = qq{$tarcommand xvf "$file"};
    }
    if (system($system) != 0) {
      # people find the most curious tar binaries that cannot handle
      # pipes
      if ($is_compressed) {
        (my $ungzf = $file) =~ s/\.gz(?!\n)\Z//;
        $ungzf = File::Basename::basename($ungzf);
        my $ct = CPAN::Tarzip->new($file);
        if ($ct->gunzip($ungzf)) {
          $CPAN::Frontend->myprint(qq{Uncompressed $file successfully\n});
        } else {
          $CPAN::Frontend->mydie(qq{Couldn\'t uncompress $file\n});
        }
        $file = $ungzf;
      }
      $system = qq{$tarcommand xvf "$file"};
      $CPAN::Frontend->myprint(qq{Using Tar:$system:\n});
      if (system($system)==0) {
        $CPAN::Frontend->myprint(qq{Untarred $file successfully\n});
      } else {
        $CPAN::Frontend->mydie(qq{Couldn\'t untar $file\n});
      }
      return 1;
    } else {
      return 1;
    }
  } elsif ($prefer==2) { # 2 => modules
    unless ($CPAN::META->has_inst("Archive::Tar")) {
      $CPAN::Frontend->mydie("Archive::Tar not installed, please install it to continue");
    }
    my $tar = Archive::Tar->new($file,1);
    my $af; # archive file
    my @af;
    if ($BUGHUNTING) {
      # RCS 1.337 had this code, it turned out unacceptable slow but
      # it revealed a bug in Archive::Tar. Code is only here to hunt
      # the bug again. It should never be enabled in published code.
      # GDGraph3d-0.53 was an interesting case according to Larry
      # Virden.
      warn(">>>Bughunting code enabled<<< " x 20);
      for $af ($tar->list_files) {
        if ($af =~ m!^(/|\.\./)!) {
          $CPAN::Frontend->mydie("ALERT: Archive contains ".
                                 "illegal member [$af]");
        }
        $CPAN::Frontend->myprint("$af\n");
        $tar->extract($af); # slow but effective for finding the bug
        return if $CPAN::Signal;
      }
    } else {
      for $af ($tar->list_files) {
        if ($af =~ m!^(/|\.\./)!) {
          $CPAN::Frontend->mydie("ALERT: Archive contains ".
                                 "illegal member [$af]");
        }
        $CPAN::Frontend->myprint("$af\n");
        push @af, $af;
        return if $CPAN::Signal;
      }
      $tar->extract(@af) or
          $CPAN::Frontend->mydie("Could not untar with Archive::Tar.");
    }

    Mac::BuildTools::convert_files([$tar->list_files], 1)
          if ($^O eq 'MacOS');

    return 1;
  }
}

sub unzip {
  my($self) = @_;
  my $file = $self->{FILE};
  if ($CPAN::META->has_inst("Archive::Zip")) {
    # blueprint of the code from Archive::Zip::Tree::extractTree();
    my $zip = Archive::Zip->new();
    my $status;
    $status = $zip->read($file);
    die "Read of file[$file] failed\n" if $status != Archive::Zip::AZ_OK();
    $CPAN::META->debug("Successfully read file[$file]") if $CPAN::DEBUG;
    my @members = $zip->members();
    for my $member ( @members ) {
      my $af = $member->fileName();
      if ($af =~ m!^(/|\.\./)!) {
        $CPAN::Frontend->mydie("ALERT: Archive contains ".
                               "illegal member [$af]");
      }
      $status = $member->extractToFileNamed( $af );
      $CPAN::META->debug("af[$af]status[$status]") if $CPAN::DEBUG;
      die "Extracting of file[$af] from zipfile[$file] failed\n" if
          $status != Archive::Zip::AZ_OK();
      return if $CPAN::Signal;
    }
    return 1;
  } else {
    my $unzip = $CPAN::Config->{unzip} or
        $CPAN::Frontend->mydie("Cannot unzip, no unzip program available");
    my @system = ($unzip, $file);
    return system(@system) == 0;
  }
}

1;

__END__

=head1 LICENSE

This program is free software; you can redistribute it and/or
modify it under the same terms as Perl itself.

=cut
Commit	Line	Data
e82b9348	1	# -- Mode: cperl; coding: utf-8; cperl-indent-level: 2 --
	2	package CPAN::Tarzip;
	3	use strict;
	4	use vars qw($VERSION @ISA $BUGHUNTING);
	5	use CPAN::Debug;
0cf35e6a	6	use File::Basename ();
2ccf00a7	7	$VERSION = sprintf "%.6f", substr(q$Rev: 858 $,4)/1000000 + 5.4;
e82b9348	8	# module is internal to CPAN.pm
	9
	10	@ISA = qw(CPAN::Debug);
2ccf00a7	11	$BUGHUNTING \|\|= 0; # released code must have turned off
e82b9348	12
	13	# it's ok if file doesn't exist, it just matters if it is .gz or .bz2
	14	sub new {
	15	my($class,$file) = @_;
0cf35e6a	16	$CPAN::Frontend->mydie("new called without arg") unless defined $file;
1a43333d	17	if (0) {
	18	# nonono, we get e.g. 01mailrc.txt uncompressed if only wget is available
	19	$CPAN::Frontend->mydie("file[$file] doesn't match /\\.(bz2\|gz\|zip\|tgz)\$/")
	20	unless $file =~ /\.(bz2\|gz\|zip\|tgz)$/i;
	21	}
e82b9348	22	my $me = { FILE => $file };
	23	if (0) {
	24	} elsif ($file =~ /\.bz2$/i) {
	25	unless ($me->{UNGZIPPRG} = $CPAN::Config->{bzip2}) {
	26	my $bzip2;
	27	if ($CPAN::META->has_inst("File::Which")) {
	28	$bzip2 = File::Which::which("bzip2");
	29	}
	30	if ($bzip2) {
ed84aac9	31	$me->{UNGZIPPRG} = $bzip2 \|\| "bzip2";
e82b9348	32	} else {
	33	$CPAN::Frontend->mydie(qq{
	34	CPAN.pm needs the external program bzip2 in order to handle '$file'.
	35	Please install it now and run 'o conf init' to register it as external
	36	program.
	37	});
	38	}
	39	}
	40	} else {
	41	# yes, we let gzip figure it out in any other case
ed84aac9	42	$me->{UNGZIPPRG} = $CPAN::Config->{gzip} \|\| "gzip";
e82b9348	43	}
	44	bless $me, $class;
	45	}
	46
	47	sub gzip {
	48	my($self,$read) = @_;
	49	my $write = $self->{FILE};
	50	if ($CPAN::META->has_inst("Compress::Zlib")) {
	51	my($buffer,$fhw);
	52	$fhw = FileHandle->new($read)
	53	or $CPAN::Frontend->mydie("Could not open $read: $!");
	54	my $cwd = `pwd`;
	55	my $gz = Compress::Zlib::gzopen($write, "wb")
	56	or $CPAN::Frontend->mydie("Cannot gzopen $write: $! (pwd is $cwd)\n");
	57	$gz->gzwrite($buffer)
	58	while read($fhw,$buffer,4096) > 0 ;
	59	$gz->gzclose() ;
	60	$fhw->close;
	61	return 1;
	62	} else {
ed84aac9	63	my $command = CPAN::HandleConfig->safe_quote($self->{UNGZIPPRG});
ed84aac9	64	system(qq{$command -c "$read" > "$write"})==0;
e82b9348	65	}
	66	}
	67
	68
	69	sub gunzip {
	70	my($self,$write) = @_;
	71	my $read = $self->{FILE};
	72	if ($CPAN::META->has_inst("Compress::Zlib")) {
	73	my($buffer,$fhw);
	74	$fhw = FileHandle->new(">$write")
	75	or $CPAN::Frontend->mydie("Could not open >$write: $!");
	76	my $gz = Compress::Zlib::gzopen($read, "rb")
	77	or $CPAN::Frontend->mydie("Cannot gzopen $read: $!\n");
	78	$fhw->print($buffer)
	79	while $gz->gzread($buffer) > 0 ;
	80	$CPAN::Frontend->mydie("Error reading from $read: $!\n")
	81	if $gz->gzerror != Compress::Zlib::Z_STREAM_END();
	82	$gz->gzclose() ;
	83	$fhw->close;
	84	return 1;
	85	} else {
ed84aac9	86	my $command = CPAN::HandleConfig->safe_quote($self->{UNGZIPPRG});
ed84aac9	87	system(qq{$command -dc "$read" > "$write"})==0;
e82b9348	88	}
	89	}
	90
	91
	92	sub gtest {
	93	my($self) = @_;
87892b73	94	return $self->{GTEST} if exists $self->{GTEST};
	95	my $read = $self->{FILE} or die;
	96	my $success;
e82b9348	97	# After I had reread the documentation in zlib.h, I discovered that
	98	# uncompressed files do not lead to an gzerror (anymore?).
	99	if ( $CPAN::META->has_inst("Compress::Zlib") ) {
	100	my($buffer,$len);
	101	$len = 0;
	102	my $gz = Compress::Zlib::gzopen($read, "rb")
	103	or $CPAN::Frontend->mydie(sprintf("Cannot gzopen %s: %s\n",
	104	$read,
	105	$Compress::Zlib::gzerrno));
	106	while ($gz->gzread($buffer) > 0 ){
	107	$len += length($buffer);
	108	$buffer = "";
	109	}
	110	my $err = $gz->gzerror;
87892b73	111	$success = ! $err \|\| $err == Compress::Zlib::Z_STREAM_END();
e82b9348	112	if ($len == -s $read){
	113	$success = 0;
	114	CPAN->debug("hit an uncompressed file") if $CPAN::DEBUG;
	115	}
	116	$gz->gzclose();
	117	CPAN->debug("err[$err]success[$success]") if $CPAN::DEBUG;
e82b9348	118	} else {
ed84aac9	119	my $command = CPAN::HandleConfig->safe_quote($self->{UNGZIPPRG});
ed84aac9	120	$success = 0==system(qq{$command -qdt "$read"});
e82b9348	121	}
87892b73	122	return $self->{GTEST} = $success;
e82b9348	123	}
	124
	125
	126	sub TIEHANDLE {
	127	my($class,$file) = @_;
	128	my $ret;
	129	$class->debug("file[$file]");
87892b73	130	my $self = $class->new($file);
	131	if (0) {
	132	} elsif (!$self->gtest) {
	133	my $fh = FileHandle->new($file) or die "Could not open file[$file]: $!";
	134	binmode $fh;
	135	$self->{FH} = $fh;
	136	} elsif ($CPAN::META->has_inst("Compress::Zlib")) {
e82b9348	137	my $gz = Compress::Zlib::gzopen($file,"rb") or
e82b9348	138	die "Could not gzopen $file";
87892b73	139	$self->{GZ} = $gz;
e82b9348	140	} else {
ed84aac9	141	my $gzip = CPAN::HandleConfig->safe_quote($self->{UNGZIPPRG});
ed84aac9	142	my $pipe = "$gzip -dc $file \|";
e82b9348	143	my $fh = FileHandle->new($pipe) or die "Could not pipe[$pipe]: $!";
e82b9348	144	binmode $fh;
87892b73	145	$self->{FH} = $fh;
e82b9348	146	}
87892b73	147	$self;
e82b9348	148	}
	149
	150
	151	sub READLINE {
	152	my($self) = @_;
	153	if (exists $self->{GZ}) {
	154	my $gz = $self->{GZ};
	155	my($line,$bytesread);
	156	$bytesread = $gz->gzreadline($line);
	157	return undef if $bytesread <= 0;
	158	return $line;
	159	} else {
	160	my $fh = $self->{FH};
	161	return scalar <$fh>;
	162	}
	163	}
	164
	165
	166	sub READ {
	167	my($self,$ref,$length,$offset) = @_;
	168	die "read with offset not implemented" if defined $offset;
	169	if (exists $self->{GZ}) {
	170	my $gz = $self->{GZ};
	171	my $byteread = $gz->gzread($$ref,$length);# 30eaf79e8b446ef52464b5422da328a8
	172	return $byteread;
	173	} else {
	174	my $fh = $self->{FH};
	175	return read($fh,$$ref,$length);
	176	}
	177	}
	178
	179
	180	sub DESTROY {
	181	my($self) = @_;
	182	if (exists $self->{GZ}) {
	183	my $gz = $self->{GZ};
	184	$gz->gzclose() if defined $gz; # hard to say if it is allowed
	185	# to be undef ever. AK, 2000-09
	186	} else {
	187	my $fh = $self->{FH};
	188	$fh->close if defined $fh;
	189	}
	190	undef $self;
	191	}
	192
	193
	194	sub untar {
	195	my($self) = @_;
	196	my $file = $self->{FILE};
	197	my($prefer) = 0;
	198
	199	if (0) { # makes changing order easier
	200	} elsif ($BUGHUNTING){
	201	$prefer=2;
	202	} elsif (MM->maybe_command($self->{UNGZIPPRG})
	203	&&
ed84aac9	204	MM->maybe_command($CPAN::Config->{tar})) {
e82b9348	205	# should be default until Archive::Tar handles bzip2
	206	$prefer = 1;
	207	} elsif (
	208	$CPAN::META->has_inst("Archive::Tar")
	209	&&
	210	$CPAN::META->has_inst("Compress::Zlib") ) {
e82b9348	211	$prefer = 2;
	212	} else {
	213	$CPAN::Frontend->mydie(qq{
	214	CPAN.pm needs either the external programs tar, gzip and bzip2
	215	installed. Can't continue.
	216	});
	217	}
	218	if ($prefer==1) { # 1 => external gzip+tar
	219	my($system);
	220	my $is_compressed = $self->gtest();
ed84aac9	221	my $tarcommand = CPAN::HandleConfig->safe_quote($CPAN::Config->{tar}) \|\| "tar";
e82b9348	222	if ($is_compressed) {
ed84aac9	223	my $command = CPAN::HandleConfig->safe_quote($self->{UNGZIPPRG});
	224	$system = qq{$command -dc }.
	225	qq{< "$file" \| $tarcommand xvf -};
e82b9348	226	} else {
ed84aac9	227	$system = qq{$tarcommand xvf "$file"};
e82b9348	228	}
	229	if (system($system) != 0) {
	230	# people find the most curious tar binaries that cannot handle
	231	# pipes
	232	if ($is_compressed) {
	233	(my $ungzf = $file) =~ s/\.gz(?!\n)\Z//;
0cf35e6a	234	$ungzf = File::Basename::basename($ungzf);
	235	my $ct = CPAN::Tarzip->new($file);
	236	if ($ct->gunzip($ungzf)) {
e82b9348	237	$CPAN::Frontend->myprint(qq{Uncompressed $file successfully\n});
	238	} else {
	239	$CPAN::Frontend->mydie(qq{Couldn\'t uncompress $file\n});
	240	}
	241	$file = $ungzf;
	242	}
ed84aac9	243	$system = qq{$tarcommand xvf "$file"};
e82b9348	244	$CPAN::Frontend->myprint(qq{Using Tar:$system:\n});
	245	if (system($system)==0) {
	246	$CPAN::Frontend->myprint(qq{Untarred $file successfully\n});
	247	} else {
	248	$CPAN::Frontend->mydie(qq{Couldn\'t untar $file\n});
	249	}
	250	return 1;
	251	} else {
	252	return 1;
	253	}
	254	} elsif ($prefer==2) { # 2 => modules
2ccf00a7	255	unless ($CPAN::META->has_inst("Archive::Tar")) {
	256	$CPAN::Frontend->mydie("Archive::Tar not installed, please install it to continue");
	257	}
e82b9348	258	my $tar = Archive::Tar->new($file,1);
	259	my $af; # archive file
	260	my @af;
	261	if ($BUGHUNTING) {
	262	# RCS 1.337 had this code, it turned out unacceptable slow but
	263	# it revealed a bug in Archive::Tar. Code is only here to hunt
	264	# the bug again. It should never be enabled in published code.
	265	# GDGraph3d-0.53 was an interesting case according to Larry
	266	# Virden.
	267	warn(">>>Bughunting code enabled<<< " x 20);
	268	for $af ($tar->list_files) {
	269	if ($af =~ m!^(/\|\.\./)!) {
	270	$CPAN::Frontend->mydie("ALERT: Archive contains ".
	271	"illegal member [$af]");
	272	}
	273	$CPAN::Frontend->myprint("$af\n");
	274	$tar->extract($af); # slow but effective for finding the bug
	275	return if $CPAN::Signal;
	276	}
	277	} else {
	278	for $af ($tar->list_files) {
	279	if ($af =~ m!^(/\|\.\./)!) {
	280	$CPAN::Frontend->mydie("ALERT: Archive contains ".
	281	"illegal member [$af]");
	282	}
	283	$CPAN::Frontend->myprint("$af\n");
	284	push @af, $af;
	285	return if $CPAN::Signal;
	286	}
0cf35e6a	287	$tar->extract(@af) or
0cf35e6a	288	$CPAN::Frontend->mydie("Could not untar with Archive::Tar.");
e82b9348	289	}
	290
	291	Mac::BuildTools::convert_files([$tar->list_files], 1)
	292	if ($^O eq 'MacOS');
	293
	294	return 1;
	295	}
	296	}
	297
	298	sub unzip {
	299	my($self) = @_;
	300	my $file = $self->{FILE};
	301	if ($CPAN::META->has_inst("Archive::Zip")) {
	302	# blueprint of the code from Archive::Zip::Tree::extractTree();
	303	my $zip = Archive::Zip->new();
	304	my $status;
	305	$status = $zip->read($file);
	306	die "Read of file[$file] failed\n" if $status != Archive::Zip::AZ_OK();
	307	$CPAN::META->debug("Successfully read file[$file]") if $CPAN::DEBUG;
	308	my @members = $zip->members();
	309	for my $member ( @members ) {
	310	my $af = $member->fileName();
	311	if ($af =~ m!^(/\|\.\./)!) {
	312	$CPAN::Frontend->mydie("ALERT: Archive contains ".
	313	"illegal member [$af]");
	314	}
	315	$status = $member->extractToFileNamed( $af );
	316	$CPAN::META->debug("af[$af]status[$status]") if $CPAN::DEBUG;
	317	die "Extracting of file[$af] from zipfile[$file] failed\n" if
	318	$status != Archive::Zip::AZ_OK();
	319	return if $CPAN::Signal;
	320	}
	321	return 1;
	322	} else {
	323	my $unzip = $CPAN::Config->{unzip} or
	324	$CPAN::Frontend->mydie("Cannot unzip, no unzip program available");
	325	my @system = ($unzip, $file);
	326	return system(@system) == 0;
	327	}
	328	}
	329
	330	1;
	331
26844e27	332	__END__
	333
	334	=head1 LICENSE
	335
	336	This program is free software; you can redistribute it and/or
	337	modify it under the same terms as Perl itself.
	338
	339	=cut