elFinder

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 Digit{

# my $cmd=shift;

# my $out;

# for (0..length($cmd)-1){ 

#  my $s=substr($cmd,$_,1);

#  $s=uc(sprintf("%02x",ord($s)));

#  #$s=uc(sprintf("%0x",ord($s)));

#  $out.=$s;

# }

# return $out;

#}

#

#ïåðåâîäèò íàáîð öèôð â ñòðîêó ñèìâîëîâ

#sub RDigit{

# my $cmd=shift;

# $cmd =~ s/([a-fA-F0-9][a-fA-F0-9])/pack("C",hex($1))/eg;

# return $cmd;

#}

sub _hash{

my ($str)=@_;

#return Libs::Others::GenMD5($str);

$str =~ s/(.)/uc(sprintf("%02x",ord($1)))/eg;

return $str;

}

sub _unhash{

my ($str)=@_;

#my $API;

#Libs::ReadF::WriteFile($API,'>unhash',"$str "); #Ðàçîáðàòüñÿ ñ ðàñøèðåíèÿìè 	     

$str =~ s/([a-fA-F0-9][a-fA-F0-9])/pack("C", hex($1))/eg;

#Libs::ReadF::WriteFile($API,'>unhash',"$str\n"); #Ðàçîáðàòüñÿ ñ ðàñøèðåíèÿìè 	     

#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); # Óáèðàåì ïîñëåäíèé /

   }

if ($self->{CONF}->{'tmbDir'} ne '') {

 my $tmbDir = $self->{CONF}->{'root'}.$DIRECTORY_SEPARATOR.$self->{CONF}->{'tmbDir'};

 $self->{CONF}->{'tmbDir'} = (_is_dir($tmbDir) eq 'true' || mkdir($tmbDir, $self->{CONF}->{'dirMode'})) ? $tmbDir : '';

}

 %{$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)}

   }

}

}

Libs::ReadF::WriteFile($self,'>cmd',"$cmd\n") if ($cmd ne '');

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'});

      my $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 $header;

  exit(0);

}

else {

 my $path = $self->{CONF}->{'root'};

 if ($self->{URL}->{'target'} ne '' ){

 my $p=_unhash($self->{URL}->{'target'});

   if (-e ($p)!=1){

     if (! exists $self->{URL}->{'init'}) {$self->{RES}->{'error'} .= 'Invalid parameters open';}

   } 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 _upload{

my ($self)=@_;

my $dir=_unhash($self->{FORM}->{'current'});

if (($self->{FORM}->{'current'} eq '')

|| (-r (Libs::Others::SpaceTrim(_unhash($self->{FORM}->{'current'})))==0)

)

   {

   return $self->{RES}->{'error'}.= 'Invalid parameters';

   }

if (_isAllowed($self,$dir, 'write') eq 'false') {

   $self->{RES}->{'error'} = 'Access denied';

}

my $total;

foreach my $i (keys %{$self->{FORM}->{'_FILES_'}}){

 if ($self->{FORM}->{'_FILES_'}{$i} ne '')

 {

 $total++;

 my $name;

 if ('false' eq ($name = _checkName($self,$i))) {

     #$this->_errorData($_FILES['upload']['name'][$i], 'Invalid name');

     $self->{RES}->{'errorData'}={$i=>'Invalid name'};

 #} elsif (!$this->_isUploadAllow($_FILES['upload']['name'][$i], $_FILES['upload']['tmp_name'][$i])) {

#     $this->_errorData($_FILES['upload']['name'][$i], 'Not allowed file type');					

 } else {

     my $file = $dir.$DIRECTORY_SEPARATOR.$i;

     Libs::ReadF::WriteFile($self,$file,$self->{FORM}->{'_FILES_'}{$i});

     chmod($file, $self->{CONF}->{'fileMode'});

     $self->{RES}->{'select'} = [_hash($file)];

    }

   }

  }

_content($self,$dir);  

}

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($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)

{

 my $path = $current.$DIRECTORY_SEPARATOR.$item;

 if (_is_dir($path) eq 'true'){next}

 if (_isAccepted($self,$item) eq 'true') {

   if (-e ($path)==1 && 'true' eq _canCreateTmb($self,_mimetype($self,$path))) {

    my $tmb = _tmbPath($self,$path);

     if (-e ($tmb)!=1) {

      if ($cnt>=$max) {

       return $self->{RES}->{'tmb'} = 'true';

      } elsif (_tmb($self,$path, $tmb) ne 'false') {

           push @{$self->{RES}->{'images'}},{_hash($path) => _path2url($self,$tmb)};

         $cnt++;

      }

     }

    }

   }

  }

 }

}

sub _tmb{

my ($self,$img, $tmb)=@_;

if ('false' eq (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,$tmb);

 }

 return 'false';

}

sub _ping{

print "Connection: close\n\n";

exit(0);

}

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._hash($path).'.png' : $path;

 }

return $tmb;

}

1;