[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: 714 $,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") ) {
    if ($file =~ /\.bz2$/) {
      $CPAN::Frontend->mydie(qq{
Archive::Tar lacks support for bz2. Can't continue.
});
    }
    $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
    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;
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 ();
ed84aac9	7	$VERSION = sprintf "%.6f", substr(q$Rev: 714 $,4)/1000000 + 5.4;
e82b9348	8	# module is internal to CPAN.pm
	9
	10	@ISA = qw(CPAN::Debug);
	11	$BUGHUNTING = 0; # released code must have turned off
	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") ) {
	211	if ($file =~ /\.bz2$/) {
	212	$CPAN::Frontend->mydie(qq{
	213	Archive::Tar lacks support for bz2. Can't continue.
	214	});
	215	}
	216	$prefer = 2;
	217	} else {
	218	$CPAN::Frontend->mydie(qq{
	219	CPAN.pm needs either the external programs tar, gzip and bzip2
	220	installed. Can't continue.
	221	});
	222	}
	223	if ($prefer==1) { # 1 => external gzip+tar
	224	my($system);
	225	my $is_compressed = $self->gtest();
ed84aac9	226	my $tarcommand = CPAN::HandleConfig->safe_quote($CPAN::Config->{tar}) \|\| "tar";
e82b9348	227	if ($is_compressed) {
ed84aac9	228	my $command = CPAN::HandleConfig->safe_quote($self->{UNGZIPPRG});
	229	$system = qq{$command -dc }.
	230	qq{< "$file" \| $tarcommand xvf -};
e82b9348	231	} else {
ed84aac9	232	$system = qq{$tarcommand xvf "$file"};
e82b9348	233	}
	234	if (system($system) != 0) {
	235	# people find the most curious tar binaries that cannot handle
	236	# pipes
	237	if ($is_compressed) {
	238	(my $ungzf = $file) =~ s/\.gz(?!\n)\Z//;
0cf35e6a	239	$ungzf = File::Basename::basename($ungzf);
	240	my $ct = CPAN::Tarzip->new($file);
	241	if ($ct->gunzip($ungzf)) {
e82b9348	242	$CPAN::Frontend->myprint(qq{Uncompressed $file successfully\n});
	243	} else {
	244	$CPAN::Frontend->mydie(qq{Couldn\'t uncompress $file\n});
	245	}
	246	$file = $ungzf;
	247	}
ed84aac9	248	$system = qq{$tarcommand xvf "$file"};
e82b9348	249	$CPAN::Frontend->myprint(qq{Using Tar:$system:\n});
	250	if (system($system)==0) {
	251	$CPAN::Frontend->myprint(qq{Untarred $file successfully\n});
	252	} else {
	253	$CPAN::Frontend->mydie(qq{Couldn\'t untar $file\n});
	254	}
	255	return 1;
	256	} else {
	257	return 1;
	258	}
	259	} elsif ($prefer==2) { # 2 => modules
	260	my $tar = Archive::Tar->new($file,1);
	261	my $af; # archive file
	262	my @af;
	263	if ($BUGHUNTING) {
	264	# RCS 1.337 had this code, it turned out unacceptable slow but
	265	# it revealed a bug in Archive::Tar. Code is only here to hunt
	266	# the bug again. It should never be enabled in published code.
	267	# GDGraph3d-0.53 was an interesting case according to Larry
	268	# Virden.
	269	warn(">>>Bughunting code enabled<<< " x 20);
	270	for $af ($tar->list_files) {
	271	if ($af =~ m!^(/\|\.\./)!) {
	272	$CPAN::Frontend->mydie("ALERT: Archive contains ".
	273	"illegal member [$af]");
	274	}
	275	$CPAN::Frontend->myprint("$af\n");
	276	$tar->extract($af); # slow but effective for finding the bug
	277	return if $CPAN::Signal;
	278	}
	279	} else {
	280	for $af ($tar->list_files) {
	281	if ($af =~ m!^(/\|\.\./)!) {
	282	$CPAN::Frontend->mydie("ALERT: Archive contains ".
	283	"illegal member [$af]");
	284	}
	285	$CPAN::Frontend->myprint("$af\n");
	286	push @af, $af;
	287	return if $CPAN::Signal;
	288	}
0cf35e6a	289	$tar->extract(@af) or
0cf35e6a	290	$CPAN::Frontend->mydie("Could not untar with Archive::Tar.");
e82b9348	291	}
	292
	293	Mac::BuildTools::convert_files([$tar->list_files], 1)
	294	if ($^O eq 'MacOS');
	295
	296	return 1;
	297	}
	298	}
	299
	300	sub unzip {
	301	my($self) = @_;
	302	my $file = $self->{FILE};
	303	if ($CPAN::META->has_inst("Archive::Zip")) {
	304	# blueprint of the code from Archive::Zip::Tree::extractTree();
	305	my $zip = Archive::Zip->new();
	306	my $status;
	307	$status = $zip->read($file);
	308	die "Read of file[$file] failed\n" if $status != Archive::Zip::AZ_OK();
	309	$CPAN::META->debug("Successfully read file[$file]") if $CPAN::DEBUG;
	310	my @members = $zip->members();
	311	for my $member ( @members ) {
	312	my $af = $member->fileName();
	313	if ($af =~ m!^(/\|\.\./)!) {
	314	$CPAN::Frontend->mydie("ALERT: Archive contains ".
	315	"illegal member [$af]");
	316	}
	317	$status = $member->extractToFileNamed( $af );
	318	$CPAN::META->debug("af[$af]status[$status]") if $CPAN::DEBUG;
	319	die "Extracting of file[$af] from zipfile[$file] failed\n" if
	320	$status != Archive::Zip::AZ_OK();
	321	return if $CPAN::Signal;
	322	}
	323	return 1;
	324	} else {
	325	my $unzip = $CPAN::Config->{unzip} or
	326	$CPAN::Frontend->mydie("Cannot unzip, no unzip program available");
	327	my @system = ($unzip, $file);
	328	return system(@system) == 0;
	329	}
	330	}
	331
	332	1;
	333