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 _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'       => 'auto',       # 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

'WebCharset'   => 'WINDOWS-1251',

'UTF'	       => 'true'

);

$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'        => $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}

#my $str=$ctr->convert(substr($path,rindex($path,$DIRECTORY_SEPARATOR)+1));

return substr($path,rindex($path,$DIRECTORY_SEPARATOR)+1)

}

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 {-d "$path/$_" && _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'  => -d "$path" ? 'directory' : $self->_mimetype("$path"),

 'name'  => _basename("$path"), # Ñäåëàòü çàìåíó äâîéíûõ êàâû÷åê

 'date'  =>  Libs::Others::LocalDate($self,$self->{CONF}->{'DateTimeFormat'},'',$info[9]),

 'size'  => -d "$path" ?  0 : $info[7],

 'read'  => _isAllowed($self,"$path", 'read'),

 'write' => _isAllowed($self,"$path", 'write'),

 'rm'    => _isAllowed($self,"$path", 'rm'),

);

if ($info{'mime'} ne 'directory') {

 if ($self->{CONF}->{'fileURL'} eq 'true' && $info{'read'}) {

    #$info{'url'} = $this->_path2url($lpath ? $lpath : $path);

 }

if ($info{'mime'} =~ /image/) {

  if ('false' != (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)=@_;

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 '')) { # || !is_array($_GET['targets'])

return $self->{RES}->{'error'}.= 'Invalid parameters '. $self->{URL}->{'targets[]'};

}

foreach my $hash (split(',',$self->{URL}->{'targets[]'})) {

 $hash=_unhash($hash);

 if (-d $hash) {system("rm -r $hash")}

 else {unlink($hash);}

}

_content($self,_unhash($self->{URL}->{'current'}),'true');

}

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=$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,_unhash($self->{URL}->{'current'}),'true');

} 

}

sub _utime{

my ($self)=@_;

return time().'0';

}

sub _checkName{

my ($self,$n)=@_;

#$n = strip_tags(trim($n));

if ($self->{CONF}->{'dotFiles'} eq 'false' && '.' eq substr($n, 0, 1)) {

 return 'false';

}

return ($n =~ /[>|<|\/|:]+/) ? 'false' : $n;

}

1;