elFinder - elFinder.pm - Redmine

elFinder.pm

Дмитрий Ривлин, 26.05.2010 17:43

 package Libs::elFinder;
 require 5.004;
 use strict;
 use vars qw/$VERSION $DIRECTORY_SEPARATOR/;
 use Libs::Others;
 use Libs::Web;   # ��� ��� ������� � WEB ������� ������ � ��� �����
 use Libs::ReadF;
 use Libs::Image;
 $VERSION = "0.1.0-dev"; # ������ ������ � API
 $DIRECTORY_SEPARATOR='/';
 sub _hash{
 my ($str)=@_;
 #return Libs::Others::GenMD5($str);
 return $str;
+}
 sub _unhash{
 my ($str)=@_;
 #return Libs::Others::GenMD5($str);
 return $str;
+}
 sub new{ # �������� ������ ������. ������ ���������� �����
  my ($class,%cfg)=@_; #Mod - ������ ������� ��� ��������
  my $self = bless {}, $class;
 %{$self->{CONF}} = (
 'root'         => '',           # path to root directory
 'URL'          => '',           # root directory URL
 'rootAlias'    => 'Home',       # display this instead of root directory name
 'disabled'     => [],           # list of not allowed commands
 'dotFiles'     => 'false',      # display dot files
 'dirSize'      => 'true',       # count total directories sizes
 'fileMode'     => 0666,         # new files mode
 'dirMode'      => 0777,         # new folders mode
 'mimeDetect'   => 'auto',       # files mimetypes detection method (finfo, mime_content_type, linux (file -ib), bsd (file -Ib), internal (by extensions))
 'uploadAllow'  => [],           # mimetypes which allowed to upload
 'uploadDeny'   => [],           # mimetypes which not allowed to upload
 'uploadOrder'  => 'deny,allow', # order to proccess uploadAllow and uploadAllow options
 'imgLib'       => 'imagick',       # image manipulation library (imagick, mogrify, gd)
 'tmbDir'       => '.tmb',       # directory name for image thumbnails. Set to "" to avoid thumbnails generation
 'tmbCleanProb' => 1,            # how frequiently clean thumbnails dir (0 - never, 200 - every init request)
 'tmbAtOnce'    => 5,            # number of thumbnails to generate per request
 'tmbSize'      => 48,           # images thumbnails size (px)
 'fileURL'      => 'true',       # display file URL in "get info"
 'DateTimeFormat'=> '%d-%m-%Y %H:%i:%S', # file modification date format
 '@Months'      => '������,�������,����,������,���,����,����,������,��������,�������,������,�������',
 '@WeekDays'    => '�����������,�����������,�������,�����,������,�������,�������',
 'logger'       => 'null',       # object logger
 'aclObj'       => 'null',       # acl object (not implemented yet)
 'aclRole'      => 'user',       # role for acl
 'defaults'     => {             # default permisions
 	'read'   => 'true',
 	'write'  => 'true',
 	'rm'     => 'true'
 	},
 'perms'        => [],           # individual folders/files permisions
 'debug'        => 'false',      # send debug to client
 'archiveMimes' => [],           # allowed archive's mimetypes to create. Leave empty for all available types.
 'archivers'    => []            # info about archivers to use. See example below. Leave empty for auto detect
 );
 $self->{CONF}       = { %{$self->{CONF}},%cfg };     # ������ ����� ������������
 #                      { %{$self->{CONF}},Libs::ReadF::LoadCfgDB($self,'') }
  ($self->{FORM} , $self->{URL} ) = Libs::Web::ReadForms($self);      # ������ � ������ ������ URL,multipart,forms
  %{ $self->{CTYPE} }    = Libs::ReadF::LoadCfg($self,"$self->{CONF}->{'DirConf'}/mime.types",1);   # mime.types ��� ����������� ������ �����������
  %{$self->{RES}} = ();
  if (substr($self->{CONF}->{'root'}, -1) eq $DIRECTORY_SEPARATOR) {
      $self->{CONF}->{'root'} = substr($self->{CONF}->{'root'}, 0, -1); # ������� ��������� /
+   }
  %{$self->{CMD}} = (
 'open'      => '_open',
 'reload'    => '_reload',
 'mkdir'     => '_mkdir',
 'mkfile'    => '_mkfile',
 'rename'    => '_rename',
 'upload'    => '_upload',
 'paste'     => '_paste',
 'rm'        => '_rm',
 'duplicate' => '_duplicate',
 'read'      => '_fread',
 'edit'      => '_edit',
 'archive'   => '_archive',
 'extract'   => '_extract',
 'resize'    => '_resize',
 'tmb'       => '_thumbnails',
 'ping'      => '_ping'
 );
 #$ctr = Text::Iconv->new($self->{CONF}->{'WebCharset'},'UTF-8');
  return $self;
+}
 sub _run {
 my ($self)=@_;
 if ($self->{CONF}->{'root'} eq '' || _is_dir($self->{CONF}->{'root'}) eq 'false') {$self->{RES}->{'error'} = 'Invalid backend configuration';return}
 if (_isAllowed($self,$self->{CONF}->{'root'}, 'read') eq 'false') {$self->{RES}->{'error'} =  'Access denied';return}
 my $cmd = '';
 if ($self->{FORM}->{'cmd'} ne '') {$cmd = Libs::Others::SpaceTrim($self->{FORM}->{'cmd'});}
 elsif ($self->{URL}->{'cmd'} ne '') {$cmd = Libs::Others::SpaceTrim($self->{URL}->{'cmd'});}
 if (exists $self->{URL}->{'init'}) {
 my $ts = $self->_utime();
 $self->{RES}->{'disabled'} =  $self->{CONF}->{'disabled'};
 %{$self->{RES}->{'params'}} = (
 	'dotFiles'   => $self->{CONF}->{'dotFiles'},
 	'uplMaxSize' => $self->{CONF}->{'uplMaxSize'},
 	'archives'   => [],
 	'extract'    => [],
 	'url'        => lc($self->{CONF}->{'fileURL'}) eq 'true' ? $self->{CONF}->{'URL'} : ''
 	);
 #if (isset($this->_commands['archive']) || isset($this->_commands['extract'])) {
 #$this->_checkArchivers();
 #if (isset($this->_commands['archive'])) {
 #$this->_result['params']['archives'] = $this->_options['archiveMimes'];
 #}
 #if (isset($this->_commands['extract'])) {
 #$this->_result['params']['extract'] = array_keys($this->_options['archivers']['extract']);
 #}
 #}
 ## clean thumbnails dir
 if ($self->{CONF}->{'tmbDir'} ne '') {
    srand( time()* 1000000);
    if (rand(200) <= $self->{CONF}->{'tmbCleanProb'}) {
        my $ts2 = $self->_utime();
        opendir(DIR,$self->{CONF}->{'tmbDir'});
        my @content = grep {!/^\.{1,2}$/} sort readdir(DIR);
        closedir(DIR);
        foreach my $subdir (@content){unlink($self->{CONF}->{'tmbDir'}.$DIRECTORY_SEPARATOR.$subdir)}
+   }
+}
+}
 if ($cmd ne '') {
  my $func=$self->{CMD}->{$cmd};
  $self->$func($self);
  } else {
 $self->_open();
+ }
+}
 sub _isAllowed{
 my ($self,$path, $action)=@_;
 #print "[$path, $action]\n";
 #return 'true';
 #print $self->{CONF}->{'defaults'}{$action};
 #if    ($action eq 'read'){return 'true'}
 #elsif ($action eq 'write'){return 'true'}
 #elsif ($action eq 'rm'){return 'true'}
 #return 'true';
 #print "$self->{CONF}->{'root'}[$action]\n";
 #$path = substr($path, length($self->{CONF}{'root'})+1);
 #foreach ($self->{CONF}->{'perms'} as $regex => $rules) { # ������� �� ���
 #  if (preg_match($regex, $path)) {
 #      if (isset($rules[$action])) { return $rules[$action];}
 #  }
 #}
 return (exists $self->{CONF}->{'defaults'}{$action}) ? $self->{CONF}->{'defaults'}{$action} : 'false';
+}
 sub _basename{
 my ($path)=@_;
 if (rindex($path,$DIRECTORY_SEPARATOR)==-1){return $path}
 return substr($path,rindex($path,$DIRECTORY_SEPARATOR)+1)
+}
 sub _dirname{
 my ($path)=@_;
 if (rindex($path,$DIRECTORY_SEPARATOR)==-1){return $path}
 return substr($path,0,rindex($path,$DIRECTORY_SEPARATOR))
+}
 sub _is_dir{
 my ($path)=@_;
 if (-d "$path"){return 'true'}
 return 'false';
+}
 sub _isAccepted{
 my ($self,$file)=@_;
 $file=_basename($file);
 if ('.' eq $file || '..' eq $file) {return 'false';}
 if ($self->{CONF}->{'dotFiles'} ne 'true' && '.' eq substr($file, 0, 1)) {return 'false';}
 return 'true';
+}
 sub _tree{
     my ($self,$path) = @_;
     my %dir = (
               'hash'  => _hash("$path"),
               'name'  =>  $path eq $self->{CONF}->{'root'} && $self->{CONF}->{'rootAlias'} ne '' ? $self->{CONF}->{'rootAlias'} : _basename($path),
               'read'  => _isAllowed($self,$path, 'read'),
               'write' => _isAllowed($self,$path, 'write'),
               'dirs'  => []
                  );
     if ($dir{'read'} eq 'true'){
      opendir(DIR,$path);
      my @content = grep {!/^\.{1,2}$/} sort readdir(DIR);
      closedir(DIR);
      foreach my $subdir (grep {_is_dir("$path/$_") eq 'true' && _isAccepted($self,"$path/$_") eq 'true'} @content){
            my %dirs=_tree($self,"$path/$subdir");
            push @{$dir{'dirs'}},{%dirs};
+     }
+    }
    return %dir;
+ }
 sub _cwd{
 my ($self,$path)=@_;
 my $rel  = $self->{CONF}->{'rootAlias'} ne '' ? $self->{CONF}->{'rootAlias'} : _basename($self->{CONF}->{'root'});
 my $name;
 if ($path eq $self->{CONF}->{'root'}) {$name = $rel;}
 else {
       $name = _basename($path);
       $rel .= $DIRECTORY_SEPARATOR.substr($path, length($self->{CONF}->{'root'})+1);
+}
 %{$self->{RES}->{'cwd'}} = (
 'hash'       => _hash("$path"),
 'name'       => $name,
 'mime'       => 'directory',
 'rel'        => $rel,
 'size'       => 0,
 'date'       => Libs::Others::LocalDate($self,$self->{CONF}->{'DateTimeFormat'},'',int(-M "$path")),
 'read'       => 'true',
 'write'      => _isAllowed($self,$path, 'write'),
 'rm'         => $path eq $self->{CONF}->{'root'} ? 'false' : _isAllowed($self,$path, 'rm')
 );
+}
 sub _cdc{
 my ($self,$path)=@_;
 opendir(DIR,$path);
 my @content = grep {!/^\.{1,2}$/} sort readdir(DIR);
 closedir(DIR);
 foreach my $subdir ( grep {_isAccepted($self,"$path/$_") eq 'true'} sort {-f "$path/$a" cmp -f "$path/$b"} @content)
 {push @{$self->{RES}->{'cdc'}},{_info($self,"$path/$subdir")};}
+}
 sub _info{
 my ($self,$path)=@_;
 my @info=(-l "$path") ? lstat("$path") : stat("$path");
 my %info= (
  'hash'  => _hash("$path"),
  'mime'  => (_is_dir("$path") eq 'true') ? 'directory' : $self->_mimetype("$path"),
  'name'  => _basename("$path"),
  'date'  =>  Libs::Others::LocalDate($self,$self->{CONF}->{'DateTimeFormat'},'',$info[9]),
  'size'  => (_is_dir("$path") eq 'true') ?  0 : $info[7],
  'read'  => _isAllowed($self,"$path", 'read'),
  'write' => _isAllowed($self,"$path", 'write'),
  'rm'    => _isAllowed($self,"$path", 'rm'),
 );
 if ($info{'mime'} ne 'directory') {
  if (lc($self->{CONF}->{'fileURL'}) eq 'true' && $info{'read'} eq 'true') {
      $info{'url'} = _path2url($self,$path);
+ }
 if ($info{'mime'} =~ /image/) {
   if ('false' ne (my @s = Libs::Image::GetImgInfo($self,$path))) { $info{'dim'} = $s[0].'x'.$s[1];}
   if ($info{'read'} eq 'true') {
       $info{'resize'} = ( exists $info{'dim'});
       #$tmb = _tmbPath($self,$path);
       #if (-f $tmb) {$info{'tmb'}  = _path2url($self,$tmb);}
       #elsif ($info{'resize'}) {$self->{RES}->{'tmb'} = 'true'}
+   }
+ }
+}
 return %info;
+}
 sub _mimetype{
 my ($self,$path)=@_;
 if (rindex($path,$DIRECTORY_SEPARATOR)!=-1){$path=substr($path,rindex($path,$DIRECTORY_SEPARATOR)+1)}
 my ($name,$ext);
 if (rindex($path,'.')!=-1){
  $ext=substr($path,rindex($path,'.')+1);
  $name=substr($path,0,rindex($path,'.'))
+}
 else {$name=$path}
 my $mt=$self->{CTYPE}->{lc($ext)};
 $mt=($mt ne '') ? $mt :'unknown;';
 return $mt;
+}
 sub _content{
 my ($self,$path,$flag)=@_;
 _cwd($self,$path);
 _cdc($self,$path);
 if ($self->{RES}->{'cdc'} eq '') {push @{$self->{RES}->{'cdc'}},;}
 if (exists $self->{URL}->{tree} || lc($flag) eq 'true') { $self->{RES}->{'tree'} = {_tree($self,$self->{CONF}->{'root'})};}
+}
 sub _open{
 my ($self)=@_;
 if ($self->{URL}->{'current'} ne '') { # read file
 my $dir=_unhash($self->{URL}->{'current'});
 my $file=_unhash($self->{URL}->{'target'});
 if (($self->{URL}->{'current'} eq '')
 || ($self->{URL}->{'target'} eq '')
 || (-r (Libs::Others::SpaceTrim($dir))==0)
 || (-r (Libs::Others::SpaceTrim($file))==0)
 || (_is_dir($self,$file) eq 'true')
+)
+  {
    #Libs::ReadF::WriteFile($self,'>header',"����\n"); #����������� � ������������
    print "Status: 404 Not Found\n";
    exit(0);
+   }
 if (_isAllowed($self,$dir, 'read') eq 'false' || _isAllowed($self,$file, 'read') eq 'false') {
    print "Status: 403 Access Denied\n";
    exit(0);
+ }
 my $mime  = _mimetype($self,$file);
 my @parts = split('/', $mime);
 my $disp  = ($parts[0] eq 'image' || $parts[0] eq 'text') ? 'inline' : 'attachments';
 my $header="Content-Type: $mime\n";
   $header.="Content-Disposition: ".$disp."; filename="._basename($file)."\n";
 #print "Content-Location: ".str_replace($this->_options['root'], '', $file));
   $header.='Content-Transfer-Encoding: binary'."\n\n";
 #print "Content-Length: ".filesize($file));
 #print "Connection: close\n\n";
   $header.=Libs::ReadF::ReadBinFile($self,$file);
   #print STDERR $header;
   Libs::ReadF::WriteFile($self,'>header',"$header\n"); #����������� � ������������
   print $header;
   exit(0);
+}
 else {
  my $path = $self->{CONF}->{'root'};
  if ($self->{URL}->{'target'} ne '' ){
  my $p=_unhash($self->{URL}->{'target'});
    if (-r ($self->{URL}->{'target'})==0){
      if (! exists $self->{URL}->{'init'}) {$self->{RES}->{'error'} .= 'Invalid parameters';}
    } elsif (_isAllowed($self,$p, 'read') eq 'false') {
     if (! exists $self->{URL}->{'init'}) {$self->{RES}->{'error'} .= 'Access denied';}
    } else {$path = $p;}
+ }
  if (exists $self->{URL}->{current}) {$self->{RES}->{'error'} .= "$self->{URL}->{current}<br>"}
  _content($self,$path);
+ }
+}
 sub _rm{
 my ($self)=@_;
 if (($self->{URL}->{'current'} eq '')
 || (-r (Libs::Others::SpaceTrim(_unhash($self->{URL}->{'current'})))==0)
 || ($self->{URL}->{'targets[]'} eq '')) {
 return $self->{RES}->{'error'}.= 'Invalid parameters '. $self->{URL}->{'targets[]'};
+}
 foreach my $hash (split(',',$self->{URL}->{'targets[]'})) {
  $hash=_unhash($hash);
  if (_is_dir("$hash") eq 'true') {$hash=~ s/ /\\ /mg;system("rm -r $hash")}
  else {unlink($hash);}
  if ($? == -1) { $self->{RES}->{'error'}.= 'Error in rm '.$hash." $!"}
+}
 _content($self,_unhash($self->{URL}->{'current'}),'true');
+}
 sub _rename{
 my ($self)=@_;
 if (($self->{URL}->{'current'} eq '')
 || ($self->{URL}->{'target'} eq '')
 || (-r (Libs::Others::SpaceTrim(_unhash($self->{URL}->{'current'})))==0)
 || (-r (Libs::Others::SpaceTrim(_unhash($self->{URL}->{'target'})))==0))
+   {
    return $self->{RES}->{'error'}.= 'File not found';
+   }
 my $dir=_unhash($self->{URL}->{'current'});
 my $name;
 my $target=_unhash($self->{URL}->{'target'});
 if (_isAllowed($self,$dir, 'write') eq 'false') {
    $self->{RES}->{'error'} = 'Access denied';
 } elsif ('false' eq ($name = _checkName($self,$self->{URL}->{'name'})) ) {
    $self->{RES}->{'error'} = 'Invalid name';
 } elsif (-r ($dir.$DIRECTORY_SEPARATOR.$name)) {
    $self->{RES}->{'error'} = 'File or folder with the same name already exists';
 } elsif (! rename($target,$dir.$DIRECTORY_SEPARATOR.$name)) {
    $self->{RES}->{'error'} = 'Unable to rename file';
 } else {
   #$this->_rmTmb($target);
   $self->{RES}->{'select'} =[_hash($dir.$DIRECTORY_SEPARATOR.$name)];
   _content($self,$self->{URL}->{'current'},_is_dir($dir.$DIRECTORY_SEPARATOR.$name));
+}
+}
 sub _mkdir{
 my ($self)=@_;
 if (($self->{URL}->{'current'} eq '') || (-r (Libs::Others::SpaceTrim(_unhash($self->{URL}->{'current'})))==0)){
     return $self->{RES}->{'error'}.= 'Invalid parameters ';
+ }
 my $dir=_unhash($self->{URL}->{'current'});
 my $name;
 if (_isAllowed($self,$dir, 'write') eq 'false') {
    $self->{RES}->{'error'} = 'Access denied';
 } elsif ('false' eq ($name = _checkName($self,$self->{URL}->{'name'})) ) {
    $self->{RES}->{'error'} = 'Invalid name';
 } elsif (-r ($dir.$DIRECTORY_SEPARATOR.$name)) {
    $self->{RES}->{'error'} = 'File or folder with the same name already exists';
 } elsif (! mkdir($dir.$DIRECTORY_SEPARATOR.$name, $self->{CONF}->{'dirMode'})) {
    $self->{RES}->{'error'} = 'Unable to create folder';
 } else {
   $self->{RES}->{'select'} =[_hash($dir.$DIRECTORY_SEPARATOR.$name)];
   _content($self,$self->{URL}->{'current'},'true');
+}
+}
 sub _mkfile{
 my ($self)=@_;
 if (($self->{URL}->{'current'} eq '') || (-r (Libs::Others::SpaceTrim(_unhash($self->{URL}->{'current'})))==0)){
     return $self->{RES}->{'error'}.= 'Invalid parameters ';
+ }
 my $dir=_unhash($self->{URL}->{'current'});
 my $name;
 if (_isAllowed($self,$dir, 'write') eq 'false') {
    $self->{RES}->{'error'} = 'Access denied';
 } elsif ('false' eq ($name = _checkName($self,$self->{URL}->{'name'})) ) {
    $self->{RES}->{'error'} = 'Invalid name';
 } elsif (-r ($dir.$DIRECTORY_SEPARATOR.$name)) {
    $self->{RES}->{'error'} = 'File or folder with the same name already exists';
 } else {
         $name=$dir.$DIRECTORY_SEPARATOR.$name;
         if (! open(FILE,">$name"))
+         {
            $self->{RES}->{'error'} = 'Unable to create file '.$name;
+         }
          else {
           close(FILE);
           $self->{RES}->{'select'} =[_hash($dir.$DIRECTORY_SEPARATOR.$name)];
           _content($self,$self->{URL}->{'current'});
+         }
+ }
+}
 sub _duplicate{
 my ($self)=@_;
 if (($self->{URL}->{'current'} eq '')
 || ($self->{URL}->{'target'} eq '')
 || (-r (Libs::Others::SpaceTrim(_unhash($self->{URL}->{'current'})))==0)
 || (-r (Libs::Others::SpaceTrim(_unhash($self->{URL}->{'target'})))==0))
+   {
    return $self->{RES}->{'error'}.= 'Invalid parameters';
+   }
 my $dir=_unhash($self->{URL}->{'current'});
 my $target=_unhash($self->{URL}->{'target'});
 if (_isAllowed($self,$dir, 'write') eq 'false') {
    return $self->{RES}->{'error'} = 'Access denied';
+}
 my $dup = _uniqueName($self,$target);
 my $dupt=$dup;
 my $targett=$target;
 $dupt =~ s/ /\\ /mg;
 $targett =~ s/ /\\ /mg;
 if (_is_dir("$target") eq 'true') {system("cp -r $targett $dupt")}
 else {system("cp $targett $dupt")}
 if ($? == -1) { $self->{RES}->{'error'}='Error in copy '.$target." $!"}
 $self->{RES}->{'select'} =[_hash($dup)];
 _content($self,$self->{URL}->{'current'},_is_dir($target));
+}
 sub _fread{
 my ($self)=@_;
 if (($self->{URL}->{'current'} eq '')
 || ($self->{URL}->{'target'} eq '')
 || (-r (Libs::Others::SpaceTrim(_unhash($self->{URL}->{'current'})))==0)
 || (-r (Libs::Others::SpaceTrim(_unhash($self->{URL}->{'target'})))==0))
+   {
    return $self->{RES}->{'error'}.= 'Invalid parameters';
+   }
 my $dir=_unhash($self->{URL}->{'current'});
 my $target=_unhash($self->{URL}->{'target'});
 if (_isAllowed($self,$target, 'read') eq 'false') {
    $self->{RES}->{'error'} = 'Access denied';
+}
 $self->{RES}->{'content'} = Libs::ReadF::ReadBinFile($self,$target);
+}
 sub _edit{
 my ($self)=@_;
 if (($self->{FORM}->{'current'} eq '')
 || ($self->{FORM}->{'target'} eq '')
 || (-r (Libs::Others::SpaceTrim(_unhash($self->{FORM}->{'current'})))==0)
 || (-r (Libs::Others::SpaceTrim(_unhash($self->{FORM}->{'target'})))==0)
 || ($self->{FORM}->{'content'} eq '')
+)
+   {
    return $self->{RES}->{'error'}.= 'Invalid parameters';
+   }
 my $dir=_unhash($self->{URL}->{'current'});
 my $target=_unhash($self->{URL}->{'target'});
 if (_isAllowed($self,$target, 'write') eq 'false') {
    $self->{RES}->{'error'} = 'Access denied';
+}
 Libs::ReadF::WriteFile($self,$target,$self->{FORM}->{'content'});
 $self->{RES}->{'target'} = _info($self,$target);
 #$self->{RES}->{'content'} = Lib::ReadF::ReadBinFile($self,$target);
+}
 sub _resize{
 my ($self)=@_;
 if (($self->{URL}->{'current'} eq '')
 || ($self->{URL}->{'target'} eq '')
 || (-r (Libs::Others::SpaceTrim(_unhash($self->{URL}->{'current'})))==0)
 || (-r (Libs::Others::SpaceTrim(_unhash($self->{URL}->{'target'})))==0)
 || ($self->{URL}->{'width'} eq '')
 || ($self->{URL}->{'height'} eq '')
+)
+   {
    return $self->{RES}->{'error'}.= 'Invalid parameters';
+   }
 my $dir=_unhash($self->{URL}->{'current'});
 my $target=_unhash($self->{URL}->{'target'});
 if (_isAllowed($self,$target, 'write') eq 'false') {
    return $self->{RES}->{'error'} = 'Access denied';
+}
 if (!(_mimetype($self,$target) =~ 'image')) {
    return $self->{RES}->{'error'} = 'File is not an image';
+}
 #$self->{RES}->{'error'} = $target;
 my $image=Libs::Image::ResizeImageWH($self,$target,$self->{URL}->{'width'},$self->{URL}->{'height'});
 $image->Write(filename=>$target);
 $self->{RES}->{'select'} =[_hash($target)];
 _content($self,$self->{URL}->{'current'});
+}
 sub _thumbnails{
 my ($self)=@_;
 my $current=_unhash($self->{URL}->{'current'});
 if ($self->{CONF}->{'tmbDir'} ne '' && $current ne '' && (-r (Libs::Others::SpaceTrim(_unhash($self->{URL}->{'current'})))!=0)) {
 $self->{RES}->{'select'} =[_hash($current)];
 $self->{RES}->{'images'} =[];
 opendir(DIR,$current);
 my @content = grep {!/^\.{1,2}$/} sort readdir(DIR);
 closedir(DIR);
 my $cnt=0;
 my $max=($self->{CONF}->{'tmbAtOnce'} > 0) ? $self->{CONF}->{'tmbAtOnce'} : 5;
 foreach my $item (@content)
+{
 if (_isAccepted($self,$item) eq 'true') {
   my $path = $current.$DIRECTORY_SEPARATOR.$item;
    if (-r ($path)==0 && _canCreateTmb($self,_mimetype($self,$path))) {
     my $tmb = _tmbPath($self,$path);
      if (-r ($tmb)!=0) {
       if ($cnt>=$max) {
        return $self->{RES}->{'tmb'} = 'true';
       } elsif (_tmb($self,$path, $tmb) ne 'false') {
          $self->{RES}->{'images'}[_hash($path)] = _path2url($tmb);
          $cnt++;
+      }
+     }
+    }
+   }
+  }
+ }
+}
 sub _tmb{
 my ($self,$img, $tmb)=@_;
 if ('false' ne (my @s = Libs::Image::GetImgInfo($self,$img))){
   return 'false';
+ }
 my $tmbSize = $self->{CONF}->{'tmbSize'};
 if ($self->{CONF}->{'imgLib'} eq 'imagick')
+ {
  return Libs::Image::ThumbnailImage($self,$img,$tmbSize);
+ }
  return 'false';
+}
 sub _utime{
 my ($self)=@_;
 return time().'0';
+}
 sub _checkName{
 my ($self,$n)=@_;
 if ($self->{CONF}->{'dotFiles'} eq 'false' && '.' eq substr($n, 0, 1)) { return 'false';}
 return ($n =~ /[>|<|\/|:]+/) ? 'false' : $n;
+}
 sub _uniqueName{
 my ($self,$f,$suffix)=@_;
 $suffix=($suffix eq '') ? 'copy ' : $suffix;
 my $dir  = _dirname($f);
 my $name = _basename($f);
 #if (_is_dir($f) eq 'false') {
  #if (!( $name =~ /\.(tar\.gz|tar\.bz|tar\.bz2|[a-z0-9]{1,4})$/i)) {
  #  $ext = '.'.$1;
  #  $name = substr($name, 0, -length($m[0]));
  # }
   $name=$suffix.$name;
 # }
 return $dir.$DIRECTORY_SEPARATOR.$name;
+}
 sub _path2url{
 my ($self,$path)=@_;
 my $dir  = substr(_dirname($path), length($self->{CONF}->{'root'})+1);
 my $file = _basename($path);
 return $self->{CONF}->{'URL'}.(($dir ne  '') ? '/'.$dir :'' ).'/'.$file;
+}
 sub _canCreateTmb{
 my ($self,$mime)=@_;
 if ($self->{CONF}->{'tmbDir'} ne '' && $self->{CONF}->{'imgLib'} ne '' && index($mime,'image')!=-1)
+ {
   return 'true';
+ }
 return 'false';
+}
 sub _tmbPath{
 my ($self,$path)=@_;
 my $tmb;
 if ($self->{CONF}->{'tmbDir'} ne '')
+ {
   $tmb = (_dirname($path) ne $self->{CONF}->{'tmbDir'}) ? $self->{CONF}->{'tmbDir'}.$DIRECTORY_SEPARATOR.$path.'.png' : $path;
+ }
 return $tmb;
+}
 ;