File Coverage

blib/lib/HTML/EP/Explorer.pm

Criterion	Covered	Total	%
statement	10	12	83.3
branch			n/a
condition			n/a
subroutine	4	4	100.0
pod			n/a
total	14	16	87.5

# -*- perl -*-
#
#   HTML::EP::Explorer - A Perl package for browsing filesystems and
#       executing actions on files.
#
#
#   This module is
#
#           Copyright (C) 1999     Jochen Wiedmann
#                                  Am Eisteich 9
#                                  72555 Metzingen
#                                  Germany
#
#                                  Email: [e-mail]
#
#   All Rights Reserved.
#
#   You may distribute under the terms of either the GNU General Public
#   License or the Artistic License, as specified in the Perl README file.
#
#   $Id: Explorer.pm,v 1.2 1999/11/04 12:24:10 joe Exp $
#

use strict;

use Cwd ();
use File::Spec ();
use HTML::EP ();
use HTML::EP::Locale ();
use HTML::EP::Session ();


package HTML::EP::Explorer;

@HTML::EP::Explorer::ISA = qw(HTML::EP::Session HTML::EP::Locale HTML::EP);
$HTML::EP::Explorer::VERSION = '0.1006';

sub init {
    my $self = shift;
    $self->HTML::EP::Session::init(@_);
    $self->HTML::EP::Locale::init(@_);
}

sub _ep_explorer_init {
    my $self = shift; my $attr = shift;
    return '' if $self->{_ep_explorer_init_done};
    $self->print("_ep_explorer_init: attr = (", join(",", %$attr), ")\n")
	if $self->{'debug'};
    $self->{_ep_explorer_init_done} = 1;
    my $cgi = $self->{'cgi'};
    $attr->{'class'} ||= "HTML::EP::Session::Cookie";
    $attr->{'id'} ||= "explorer-session";
    $attr->{'path'} ||= "/";
    $attr->{'expires'} ||= "+10y";
    eval { $self->_ep_session($attr) };
    my $session = $self->{$attr->{'var'} || 'session'};
    if ($self->{debug}) {
	require Data::Dumper;
	$self->print("Session = ", Data::Dumper::Dumper($session), "\n");
    }
    if (!$attr->{'noprefs'} and
	($@  or  !exists($session->{'prefs'}))) {
	# First time run, open the prefs page.
	my $prefs = $attr->{'prefs_page'} || "prefs.ep";
	my $return_to = $attr->{'return_to'} || $self->{'env'}->{'PATH_INFO'};
	$self->print("_ep_explorer_init: Redirecting to $prefs, returning to $return_to\n")
	    if $self->{'debug'};
	$cgi->param('return_to', $return_to);
	$self->{'_ep_output'} .= $self->_ep_include({file => $prefs});
	$self->_ep_exit({});
    }
    '';
}

sub InitialConfig {
    my $self = shift;
    { 'actions' => [],
      'filetypes' => [
        { 'name' => $self->{'_ep_language'} eq 'de' ?
	  'Alle Dateien (*)' : 'All Files (*)',
	  'icon' => '/icons/unknown.gif',
	  're' => '.*'
	}],
      'directories' => [
	{ 'name' => 'Root-Directory (/)',
	  'dir' => '/'
	}]
    }
}


sub ReadArray {
    my $self = shift;  my $prefix = shift;
    my $cgi = $self->{'cgi'};
    my %hash;
    foreach my $key ($cgi->param()) {
	next unless $key =~ /^$prefix(.*)/;
	$self->print("ReadArray: Found key $key, saving as $1 (",
		     join(",", $cgi->param($key)), "\n") if $self->{'debug'};
	$hash{$1} = [$cgi->param($key)];
    }
    my @array;
    while (@{$hash{'name'}}) {
	my %h;
	while (my($var, $val) = each %hash) {
	    $h{$var} = shift @$val;
	}
	push(@array, \%h) if $h{'name'};
    }
    \@array;
}


sub ReadDirectories {
    my $dirs = shift()->ReadArray('explorer_directory_');
    my $pwd;
    foreach my $dir (@$dirs) {
	# Don't save the name, that the user gave us. Save the physical
	# filesystem path, so that we can later compare it to paths
	# requested by other users, if "Allow access to other directories"
	# is off.
	$pwd = Cwd::cwd() unless $pwd;
	chdir($dir->{'dir'}) or die "Failed to change directory to $dir: $!";
	$dir->{'dir'} = Cwd::cwd();
    }
    chdir $pwd if $pwd;
    $dirs;
}


sub ReadConfig {
    my $self = shift; my $config = shift;
    my $cgi = $self->{'cgi'};

    foreach my $var ($cgi->param()) {
	next unless $var =~ /^explorer_config_(.*)/;
	my $v = $1;
	$config->{$v} = $cgi->param($var);
    }

    $config->{'actions'} = $self->ReadArray('explorer_action_');
    $config->{'status_actions'} = $self->ReadArray('explorer_status_action_');
    $config->{'filetypes'} = $self->ReadArray('explorer_filetype_');
    $config->{'directories'} = $self->ReadDirectories();
    $config;
}


sub _ep_explorer_config {
    my $self = shift;  my $attr = shift;
    my $debug = $self->{'debug'};
    my $cgi = $self->{'cgi'};
    my $file = $attr->{'file'} || "config.pm";
    $self->{'config'} = eval { require $file } || $self->InitialConfig();
    if ($attr->{'maysafe'} && $cgi->param('save')) {
	$self->print("_ep_explorer_config: Saving.\n") if $debug;
	$self->{'config'} = $self->ReadConfig($self->{'config'});
	require Data::Dumper;
	my $fh = Symbol::gensym();
	my $dump = Data::Dumper->new([$self->{'config'}])->Indent(1)->Terse(1);
	$self->print("_ep_explorer_config: Got\n", $dump->Dump(), "\n")
	    if $debug;
	(open($fh, ">$file") and (print $fh $dump->Dump()) and close($fh))
	    or die "Failed to create $file: $!";
    }
    $self->{'actions'} = $self->{'config'}->{'actions'};
    $self->{'status_actions'} = $self->{'config'}->{'status_actions'};
    $self->{'directories'} = $self->{'config'}->{'directories'};
    $self->{'filetypes'} = $self->{'config'}->{'filetypes'};
    $self->{'num_directories'} = @{$self->{'directories'}};
    '';
}

sub ReadPrefs {
    my $self = shift; my $prefs = shift;
    my $cgi = $self->{'cgi'};
    foreach my $var ($cgi->param()) {
	next unless $var =~ /^explorer_prefs_(.*)/;
	my $vr = $1;
	my $val = $cgi->param($var);
	$prefs->{$vr} = $val;
    }
    $prefs;
}

sub _ep_explorer_prefs {
    my $self = shift;  my $attr = shift;
    my $debug = $self->{'debug'};
    $attr->{'noprefs'} = 1;
    $self->_ep_explorer_init($attr);
    my $session = $self->{$attr->{'var'} ||= 'session'};
    my $cgi = $self->{'cgi'};
    my $return;
    if (($return = $cgi->param('save_and_return'))  ||
	 $cgi->param('save')) {
	$self->print("_ep_explorer_prefs: Saving.\n") if $debug;
	$session->{'prefs'} = $self->ReadPrefs($session->{'prefs'});
	if ($debug) {
	    require Data::Dumper;
	    $self->print("_ep_explorer_save: Got\n",
			 Data::Dumper->new([$session->{'prefs'}])
			     ->Indent(1)->Terse(1)->Dump(), "\n");
	}
	$attr->{'locked'} = 1;
	$self->_ep_session_store($attr);
    }
    if ($return  and  (my $return_to = $cgi->param('return_to'))) {
	$self->print("Returning to $return_to\n") if $debug;
	$self->{'_ep_output'} .=
	    $self->_ep_include({'file' => $return_to});
	$self->print("Done including $return_to\n") if $debug;
	$self->_ep_exit({});
    }
    '';
}

sub _ep_explorer_basedir {
    my $self = shift; my $attr = shift;
    return if $self->{'basedir'};
    my $cgi = $self->{'cgi'};
    my $session = $self->{'session'};
    my $debug = $self->{'debug'};
    my $basedir = $cgi->param('basedir') || $session->{'basedir'}
        || $attr->{'basedir'} || $self->{'directories'}->[0]
	|| $ENV{'DOCUMENT_ROOT'};
    $basedir = HTML::EP::Explorer::Dir->new($basedir)->{'dir'};
    chdir($basedir)
	or die "Failed to change directory to $basedir: $!";
    $basedir = Cwd::cwd();
    if (!$session->{'basedir'} or $session->{'basedir'} ne $basedir) {
	$self->{'modified'} = 1;
	$session->{'basedir'} = $basedir;
    }
    foreach my $dir (@{$self->{'directories'}}) {
	$self->print("Checking whether $dir->{'dir'} is $basedir.\n")
	    if $debug;
	if ($dir->{'dir'} eq $basedir) {
	    $self->{'in_top_dir'} = 1;
	    $self->{'in_base_dir'} = $dir;
	    $self->{'display_dir'} = "/";
	    $self->print("Yes, it is.\n") if $debug;
	    last;
	}
    }
    if (!$self->{'in_top_dir'}) {
	$self->{'in_top_dir'} = ($basedir eq File::Spec->rootdir());
	foreach my $dir (@{$self->{'directories'}}) {
	    $self->print("Checking whether $basedir is below $dir->{'dir'}.\n")
		if $debug;
	    if ($basedir =~ /^\Q$dir->{'dir'}\E(\/.*)$/) {
		$self->{'in_base_dir'} = $dir;
		$self->{'display_dir'} = $1;
		$self->print("Yes, it is.\n") if $debug;
		last;
	    }
	}
	if (!$self->{'in_base_dir'}) {
	    die "Directory $basedir is outside of the permitted area."
		if $self->{'config'}->{'dirs_restricted'};
	    $self->{'display_dir'} = $basedir;
	}
    }
    $self->print("Basedir is $basedir.\n") if $debug;
    $self->{'basedir'} = $basedir;
    '';
}

sub _ep_explorer_sortby {
    my $self = shift; my $attr = shift;
    my $cgi = $self->{'cgi'};
    my $session = $self->{'session'};
    my $sortby = $cgi->param('sortby') || $session->{'sortby'} ||
	$attr->{'sortby'} || "name";
    if (!$session->{'sortby'}  ||  $session->{'sortby'} ne $sortby) {
	$self->{'modified'} = 1;
	$session->{'sortby'} = $sortby;
    }
    $self->print("Sorting by $sortby.\n") if $self->{'debug'};
    $self->{'sortby'} = $sortby;
    '';
}

sub _ep_explorer_filetype {
    my $self = shift; my $attr = shift;
    my $cgi = $self->{'cgi'};
    my $debug = $self->{'debug'};
    my $session = $self->{'session'};
    my $filetype = $cgi->param('filetype') || $session->{'filetype'}
	|| $attr->{'filetype'} || '';
    $self->print("Looking for file type $filetype\n") if $debug;
    my $found;
    foreach my $ft (@{$self->{'filetypes'}}) {
	if ($filetype eq $ft->{'name'}) {
	    $found = $ft;
	    last;
	}
    }
    if ($found) {
	$self->print("Found it.\n") if $debug;
    } elsif (@{$self->{'filetypes'}}) {
	$found = $self->{'filetypes'}->[0];
	$self->print("Choosing default file type $found->{'name'}\n")
	    if $debug;
    } else {
	$self->print("No file type found.\n");
    }

    $found->{'selected'} = 'SELECTED' if $found;
    my $name = $found ? $found->{'name'} : '';
    if (!defined($session->{'filetype'}) ||
	$session->{'filetype'} ne $name) {
	$self->{'modified'} = 1;
	$session->{'filetype'} = $name;
    }
    $self->print("Filetype is $found->{'name'}.\n")
	if $self->{'debug'} and $found;
    $self->{'filetype'} = $found;
    '';
}

sub _ep_explorer_browse {
    my $self = shift; my $attr = shift;
    my $cgi = $self->{'cgi'};
    my $debug = $self->{'debug'};
    my $session = $self->{'session'};
    $self->{'modified'} = 0;
    my $dir_template = $self->{'dir_template'}
	or die "Missing template variable: dir_template";
    my $item = $attr->{'item'} || die "Missing item name";

    $self->_ep_explorer_basedir($attr);
    $self->_ep_explorer_filetype($attr);
    $self->_ep_explorer_sortby($attr);

    my $dir = HTML::EP::Explorer::Dir->new($self->{'basedir'});
    my $list = $dir->Read($self->{'filetype'}->{'re'});
    my $sortby = $self->{'sortby'};
    my $updir;
    if ($list->[0]->IsDir()
	and  $list->[0]->{'name'} eq File::Spec->updir()) {
	$updir = shift @$list;
    }
    $self->print("Sorting by $sortby.\n") if $debug;
    if ($sortby eq 'type') {
	@$list = sort {
	    if ($a->IsDir()) {
		$b->IsDir() ? $a->{'name'} cmp $b->{'name'} : -1;
	    } elsif ($b->IsDir()) {
		return 1;
	    } else {
		my $ae = ($a =~ /\.(.*?)$/) ? $1 : '';
		my $be = ($b =~ /\.(.*?)$/) ? $1 : '';
		($ae cmp $be) || ($a->{'name'} cmp $b->{'name'});
	    }
	} @$list;
    } elsif ($sortby eq 'uid') {
	@$list = sort { (getpwuid($a->{'uid'}) || '') cmp
			(getpwuid($b->{'uid'}) || '')} @$list;
    } elsif ($sortby eq 'gid') {
	@$list = sort { (getgrgid($a->{'gid'}) || '') cmp
			(getgrgid($b->{'gid'}) || '')} @$list;
    } elsif ($sortby =~ /^(?:size|[amc]time)$/) {
	@$list = sort { $a->{$sortby} <=> $b->{$sortby} } @$list;
    } else {
	@$list = sort { $a->{$sortby} cmp $b->{$sortby} } @$list;
    }
    unshift(@$list, $updir)
	if $updir and !$self->{'in_top_dir'};
    my $output = '';
    $self->{'i'} = 0;
    foreach my $i (@$list) {
	$self->{$item} = $i;
	$output .= $i->AsHtml($self, $item);
	++$self->{'i'};
    }

    $self->_ep_session_store($attr) if $self->{'modified'};
    $output;
}

sub _format_ACTIONS {
    my $self = shift; my $item = shift;

    my $str = '';
    foreach my $action (@{$self->{'actions'}}) {
	$self->{'action'} = $action;
	$self->{'icon'} = $action->{'icon'} ?
	    qq{} :
	    $action->{'name'};
	$str .= $self->ParseVars($self->{'action_template'});
    }

    $str;
}

sub FindAction {
    my $self = shift; my $attr = shift;
    my $cgi = $self->{'cgi'};
    my $name = $cgi->param('faction') || $attr->{'faction'} ||
	die "Missing action name";
    my $debug = $self->{'debug'};
    $self->print("FindAction: Looking for $name\n") if $debug;
    my $action;
    foreach my $a (@{$self->{'actions'}}) {
	if ($a->{'name'} eq $name) {
	    $action = $a;
	    last;
	}
    }
    $self->{'action'} = $action or die "Unknown action: $name";
    $self->print("Selected action is $action->{'name'}\n") if $debug;
    $action;
}

sub FindStatusAction {
    my $self = shift;  my $script = shift;  my $attr = shift;
    my $debug = $self->{'debug'};
    $self->print("FindStatusAction: Looking for $script\n") if $debug;
    my $action;
    foreach my $sa (@{$self->{'status_actions'}}) {
	if ($sa->{'name'} eq $script) {
	    $self->print("FindStatusAction: Returning ",
			 join(",", %$sa), "\n") if $debug;
	    return $sa;
	}
    }
    die "FindStatusAction: Unknown script $script";
}


sub _ep_explorer_logfile {
    my $self = shift; my $attr = shift;
    my $debug = $self->{'debug'};
    my $action = $self->FindAction({});
    my $fh = Symbol::gensym();
    require Fcntl;
    $self->print("Opening logfile: $action->{'logfile'}\n") if $debug;
    sysopen($fh, $action->{'logfile'}, Fcntl::O_RDONLY())
	or die "Failed to open logfile $action->{'logfile'}: $!";
    $self->Stop();
    my $cgi = $self->{'cgi'};
    $self->print($cgi->header('-type' => 'text/plain'));
    $self->print("\n");
    seek($fh, -2000, 2);
    $| = 1;
    my $pos;
    local $/ = undef;
    while(1) {
	$pos = tell($fh);
	if (eof($fh)) {
	    sleep 15;
	    seek($fh, $pos, 0);
	} else {
	    my $line = <$fh>;
	    if (!defined($line)) {
		$self->print("Failed to read: $!");
		last;
	    } else {
		$self->print($line);
	    }
	}
    }
    '';
}


sub _ep_explorer_queue {
    my $self = shift;  my $attr = shift;
    my $cgi = $self->{'cgi'};
    my $debug = $self->{'debug'};
    my $action = $self->FindAction($attr);

    my $ignore_cache;
    if (my $script = $cgi->param('script')) {
	my $status_action = $self->FindStatusAction($script, $attr);
        my %env = %ENV;
        $env{'job'} = quotemeta($cgi->param('job'));
        $env{'user'} = quotemeta($self->User());
        foreach my $var (split(/\n/, $action->{'vars'})) {
	    if ($var =~ /^\s*(.*?)\s*=\s*(.*?)\s*$/) {
		$env{$1} = $2;
	    }
        }
        local %ENV = %env;
	if ($debug) {
	    my $command = $status_action->{'script'};
	    $command =~ s/\$(\w+)/$ENV{$1}/g;
	    $self->print("_ep_explorer_queue: Executing command ($command)\n");
	}
        system "$status_action->{'script'} >/dev/null";
	$ignore_cache = 1;
    }

    my $input;
    my $file = File::Spec->catfile("status",
				   $cgi->escape($action->{'name'}));
    if (!$ignore_cache  &&  $self->{'config'}->{'cache'}) {
	my($dev, $ino, $mode, $nlink, $uid, $gid, $rdev, $size, $atime,
	   $mtime) = stat $file;
	my $regen_time = $mtime + $self->{'config'}->{'cache'};
	$self->print("Cache file $file ",
		     -f _ ? "exists.\n" : "doesn't exist.\n",
		     -f _ ? "Modification time is $mtime, current time is " .
		            time() . ", regeneration time is $regen_time\n"
		          : "") if $debug;
	if (-f _  &&  $regen_time > time()) {
	    $self->print("Trying to load cache file $file.\n") if $debug;
	    require Fcntl;
	    my $fh = Symbol::gensym();
	    if (open($fh, "<$file")  and  flock($fh, Fcntl::LOCK_SH())) {
		local $/ = undef;
		$input = <$fh>;
	    }
	    $self->print($input ? "Got:\n$input\n" : "Not successful ($!)\n")
		if $debug;
	}
    }
    if (!$input) {
	my $command = $action->{'status'};
	local $ENV{'user'} = quotemeta($self->User());
	$input = `$command 2>&1`;
	if ($self->{'config'}->{'cache'}) {
	    require Fcntl;
	    my $fh = Symbol::gensym();
	    if (sysopen($fh, $file, Fcntl::O_RDWR()|Fcntl::O_CREAT())
		and flock($fh, Fcntl::LOCK_EX())) {
		print $fh $input;
		truncate($fh, length($input));
	    }
	}
    }

    my @status;
    foreach my $line (split(/\n/, $input)) {
	if ($line =~ /^(\S+)\s+(\S+)\s+(\d+)\s+(\S.*?)\s+(\d+)\s+bytes/) {
	    push(@status, { 'rank' => $1,
			    'owner' => $2,
			    'job' => $3,
			    'file' => $4,
			    'size' => $5 });
	}
    }
    $self->{'status'} = \@status;
    $self->{'status_num'} = @status;
    '';
}

sub _ep_explorer_action {
    my $self = shift;  my $attr = shift;
    my $cgi = $self->{'cgi'};
    my $debug = $self->{'debug'};
    my $name = $cgi->param('faction') || $attr->{'faction'}
	|| die "Missing action name";
    my $action = $self->FindAction($attr);

    my @files;
    my $file;
    if (($file = $cgi->param('files'))  ||  ($file = $attr->{'files'})) {
	@files = split(" ", $file);
    } elsif (($file = $cgi->param('file')) || ($file = $attr->{'file'})) {
	@files = $file;
    } else {
	die "Missing file name";
    }
    $self->print("Selected files are:\n", map{"  $_\n"} @files) if $debug;

    my $command = $action->{'script'};
    my $files;
    if ($command =~ /\$files/) {
	# Can handle multiple files
	$files = join(" ", map {
	    quotemeta(HTML::EP::Explorer::File->new($_)->{'file'})
	} @files);
	$command =~ s/\$files/$files/sg;
	$command .= " 2>&1" if $attr->{'execute'};
    } else {
	my @commands;
	foreach my $file (@files) {
	    my $c = $command;
	    my $f = quotemeta(HTML::EP::Explorer::File->new($file)->{'file'});
	    $c =~ s/\$file/$f/sg;
	    push(@commands, $attr->{'execute'} ? "$c 2>&1" : $c);
	}
	$command = join(";", @commands);
    }
    $self->print("Selected command is $command\n") if $debug;
    local $ENV{'user'} = quotemeta($self->User());
    local $ENV{'files'} = $files if $files;
    if ($attr->{'execute'}) {
	return `$command`;
    } else {
	return $command;
    }
}

sub User {
    $ENV{'REMOTE_USER'} || "anonymous";
}

sub _format_MODE {
    my $self = shift; my $mode = shift;
    (($mode & 0400) ? "r" : "-") .
    (($mode & 0200) ? "w" : "-") .
    (($mode & 04000) ? "s" : (($mode & 0100) ? "x" : "-")) .
    (($mode & 040)  ? "r" : "-") .
    (($mode & 020)  ? "w" : "-") .
    (($mode & 02000) ? "s" : (($mode & 010) ? "x" : "-")) .
    (($mode & 04)   ? "r" : "-") .
    (($mode & 02)   ? "w" : "-") .
    (($mode & 01)   ? "x" : "-");
}

sub _format_UID {
    my $self = shift; my $uid = shift;
    my $u = getpwuid($uid);
    defined $u ? $u : $uid;
}

sub _format_GID {
    my $self = shift; my $gid = shift;
    my $g = getgrgid($gid);
    defined $g ? $g : $gid;
}

sub _format_DATE {
    my $self = shift; my $time = shift;
    return '' unless $time;
    return $self->_format_TIME(scalar(localtime($time)));
}

sub _format_SELECTED {
    my $self = shift; shift() ? "SELECTED" : "";
}

package HTML::EP::Explorer::File;

sub new {
    my $proto = shift;  my $file = shift;
    $file =~ s/^file://;
    my $self = { 'file' => $file, @_ };
    $self->{'name'} ||= File::Basename::basename($file);
    $self->{'url'} ||= "file:$file";
    bless($self, (ref($proto) || $proto));
}

sub IsDir { 0 }

sub AsHtml {
    my $self = shift;  my $ep = shift;
    foreach my $ft (@{$ep->{'filetypes'}}) {
	if ($ft->{'icon'}  &&  $self->{'name'} =~ /$ft->{'re'}/) {
	    $self->{'icon'} = $ft->{'icon'};
	    last;
	}
    }
    $self->{'icon'} = "unknown.gif" unless $self->{'icon'};
    $ep->ParseVars($ep->{'file_template'}
		   or die "Missing template variable: file_template");
}


package HTML::EP::Explorer::Dir;

sub new {
    my $proto = shift;  my $dir = shift;
    $dir =~ s/^file://;
    my $self = { 'dir' => $dir, @_ };
    $self->{'name'} ||= File::Basename::basename($dir);
    $self->{'url'} ||= "file:$dir";
    bless($self, (ref($proto) || $proto));
}

sub IsDir { 1 }

sub AsHtml {
    my $self = shift;  my $ep = shift;
    $ep->ParseVars($ep->{'dir_template'}
		   or die "Missing template variable: dir_template");
}

sub Read {
    my $self = shift;  my $re = shift;
    my $fh = Symbol::gensym();
    my $pwd = Cwd::cwd();
    my $curdir = File::Spec->curdir();
    my $dir = $self->{'dir'};
    my @list;
    chdir $dir or die "Failed to change directory to $dir: $!";
    opendir($fh, $curdir) or die "Failed to open directory $dir: $!";
    while (defined(my $f = readdir($fh))) {
	next if $f eq $curdir;
	my($dev, $ino, $mode, $nlink, $uid, $gid, $rdev, $size,
	   $atime, $mtime, $ctime, $blksize) = stat $f;
	if (-f _) {
	    push(@list,
		 HTML::EP::Explorer::File->new(File::Spec->catfile($dir, $f),
					       'name' => $f,
					       'mode' => $mode,
					       'uid' => $uid,
					       'gid' => $gid,
					       'size' => $size,
					       'mtime' => $mtime,
					       'ctime' => $ctime,
					       'atime' => $atime))
		if !$re || $f =~ /$re/;
	} elsif (-d _) {
	    push(@list,
		 HTML::EP::Explorer::Dir->new(File::Spec->catdir($dir, $f),
					      'name' => $f,
					      'mode' => $mode,
					      'uid' => $uid,
					      'gid' => $gid,
					      'size' => $size,
					      'mtime' => $mtime,
					      'ctime' => $ctime,
					      'atime' => $atime))
	}
    }
    closedir $fh;
    chdir $pwd;
    \@list;
}


1;

__END__