1532 lines
59 KiB
PHP
1532 lines
59 KiB
PHP
<?php
|
|
/**
|
|
* Filemanager PHP class.
|
|
*
|
|
* filemanager.class.php
|
|
* class for the filemanager.php connector
|
|
*
|
|
* @license MIT License
|
|
* @author Riaan Los <mail (at) riaanlos (dot) nl>
|
|
* @author Simon Georget <simon (at) linea21 (dot) com>
|
|
* @copyright Authors
|
|
*/
|
|
class Filemanager
|
|
{
|
|
protected $config = [];
|
|
protected $language = [];
|
|
protected $get = [];
|
|
protected $post = [];
|
|
protected $properties = [];
|
|
protected $item = [];
|
|
protected $languages = [];
|
|
protected $allowed_actions = [];
|
|
protected $root = ''; // Filemanager root folder
|
|
protected $doc_root = ''; // root folder known by JS : $this->config['options']['fileRoot'] (filepath or '/') or $_SERVER['DOCUMENT_ROOT'] - overwritten by setFileRoot() method
|
|
protected $dynamic_fileroot = ''; // Only set if setFileRoot() is called. Second part of the path : '/Filemanager/assets/' ( doc_root - $_SERVER['DOCUMENT_ROOT'])
|
|
protected $path_to_files = ''; // path to FM userfiles folder - automatically computed by the PHP class, something like '/var/www/Filemanager/userfiles'
|
|
protected $logger = false;
|
|
protected $logfile = '';
|
|
protected $cachefolder = '_thumbs/';
|
|
protected $thumbnail_width = 64;
|
|
protected $thumbnail_height = 64;
|
|
protected $separator = 'userfiles'; // @todo fix keep it or not?
|
|
|
|
public function __construct($extraConfig = '')
|
|
{
|
|
|
|
// getting default config file
|
|
$content = file_get_contents('../../scripts/filemanager.config.js.default');
|
|
$config_default = json_decode($content, true);
|
|
|
|
// getting user config file
|
|
if (isset($_REQUEST['config'])) {
|
|
$this->getvar('config');
|
|
if (file_exists('../../scripts/'.$_REQUEST['config'])) {
|
|
$this->__log('Loading '.basename($this->get['config']).' config file.');
|
|
$content = file_get_contents('../../scripts/'.basename($this->get['config']));
|
|
} else {
|
|
$this->__log($this->get['config'].' config file does not exists.');
|
|
$this->error('Given config file ('.basename($this->get['config']).') does not exist !');
|
|
}
|
|
} else {
|
|
$content = file_get_contents('../../scripts/filemanager.config.js');
|
|
}
|
|
$config = json_decode($content, true);
|
|
|
|
// Prevent following bug https://github.com/simogeo/Filemanager/issues/398
|
|
$config_default['security']['uploadRestrictions'] = [];
|
|
|
|
if (!$config) {
|
|
$this->error('Error parsing the settings file! Please check your JSON syntax.');
|
|
}
|
|
$this->config = array_replace_recursive($config_default, $config);
|
|
|
|
// override config options if needed
|
|
if (!empty($extraConfig)) {
|
|
$this->setup($extraConfig);
|
|
}
|
|
|
|
// set logfile path according to system if not set into config file
|
|
if (!isset($this->config['options']['logfile'])) {
|
|
$this->config['options']['logfile'] = sys_get_temp_dir().'/filemanager.log';
|
|
}
|
|
|
|
$this->root = dirname(dirname(dirname(__FILE__))).DIRECTORY_SEPARATOR;
|
|
$this->properties = [
|
|
'Date Created' => null,
|
|
'Date Modified' => null,
|
|
'Height' => null,
|
|
'Width' => null,
|
|
'Size' => null,
|
|
];
|
|
|
|
// Log actions or not?
|
|
if ($this->config['options']['logger'] == true) {
|
|
if (isset($this->config['options']['logfile'])) {
|
|
$this->logfile = $this->config['options']['logfile'];
|
|
}
|
|
$this->enableLog();
|
|
}
|
|
|
|
// if fileRoot is set manually, $this->doc_root takes fileRoot value
|
|
// for security check in is_valid_path() method
|
|
// else it takes $_SERVER['DOCUMENT_ROOT'] default value
|
|
if ($this->config['options']['fileRoot'] !== false) {
|
|
if ($this->config['options']['serverRoot'] === true) {
|
|
$this->doc_root = $_SERVER['DOCUMENT_ROOT'];
|
|
$this->separator = basename($this->config['options']['fileRoot']);
|
|
$this->path_to_files = $_SERVER['DOCUMENT_ROOT'].'/'.$this->config['options']['fileRoot'];
|
|
} else {
|
|
$this->doc_root = $this->config['options']['fileRoot'];
|
|
$this->separator = basename($this->config['options']['fileRoot']);
|
|
$this->path_to_files = $this->config['options']['fileRoot'];
|
|
}
|
|
} else {
|
|
$this->doc_root = $_SERVER['DOCUMENT_ROOT'];
|
|
$this->path_to_files = $this->root.$this->separator.'/';
|
|
}
|
|
|
|
$this->__log(__METHOD__.' $this->root value '.$this->root);
|
|
$this->__log(__METHOD__.' $this->path_to_files '.$this->path_to_files);
|
|
$this->__log(__METHOD__.' $this->doc_root value '.$this->doc_root);
|
|
$this->__log(__METHOD__.' $this->separator value '.$this->separator);
|
|
|
|
$this->setParams();
|
|
$this->setPermissions();
|
|
$this->availableLanguages();
|
|
$this->loadLanguageFile();
|
|
}
|
|
|
|
// $extraconfig should be formatted as json config array.
|
|
public function setup($extraconfig)
|
|
{
|
|
|
|
// Prevent following bug https://github.com/simogeo/Filemanager/issues/398
|
|
$config_default['security']['uploadRestrictions'] = [];
|
|
|
|
$this->config = array_replace_recursive($this->config, $extraconfig);
|
|
}
|
|
|
|
// allow Filemanager to be used with dynamic folders
|
|
public function setFileRoot($path, $mkdir = false)
|
|
{
|
|
|
|
// Paths are bit complex to handle - kind of nightmare actually ....
|
|
// 3 parts are availables
|
|
// [1] $this->doc_root. The first part of the path : '/var/www'
|
|
// [2] $this->dynamic_fileroot. The second part of the path : '/Filemanager/assets/' ( doc_root - $_SERVER['DOCUMENT_ROOT'])
|
|
// [3] $this->path_to_files or $this->doc_root. The full path : '/var/www/Filemanager/assets/'
|
|
|
|
$path = rtrim($path, '/').'/';
|
|
if ($this->config['options']['serverRoot'] === true) {
|
|
$this->doc_root = $_SERVER['DOCUMENT_ROOT'].'/'.$path; // i.e '/var/www/'
|
|
} else {
|
|
$this->doc_root = $path; // i.e '/var/www/'
|
|
}
|
|
|
|
// necessary for retrieving path when set dynamically with $fm->setFileRoot() method
|
|
// https://github.com/simogeo/Filemanager/issues/258 @todo to explore deeper
|
|
$this->dynamic_fileroot = str_replace('//', '/', str_replace($_SERVER['DOCUMENT_ROOT'], '', $this->doc_root));
|
|
$this->path_to_files = $this->doc_root;
|
|
$this->separator = basename($this->doc_root);
|
|
|
|
// do we create folder ?
|
|
if ($mkdir && !file_exists($this->doc_root)) {
|
|
mkdir($this->doc_root, 0755, true);
|
|
$this->__log(__METHOD__.' creating '.$this->doc_root.' folder through mkdir()');
|
|
}
|
|
|
|
$this->__log(__METHOD__.' $this->doc_root value overwritten : '.$this->doc_root);
|
|
$this->__log(__METHOD__.' $this->dynamic_fileroot value '.$this->dynamic_fileroot);
|
|
$this->__log(__METHOD__.' $this->path_to_files '.$this->path_to_files);
|
|
$this->__log(__METHOD__.' $this->separator value '.$this->separator);
|
|
}
|
|
|
|
public function error($string, $textarea = false)
|
|
{
|
|
$array = [
|
|
'Error' => $string,
|
|
'Code' => '-1',
|
|
'Properties' => $this->properties,
|
|
];
|
|
|
|
$this->__log(__METHOD__.' - error message : '.$string);
|
|
|
|
if ($textarea) {
|
|
echo '<textarea>'.json_encode($array).'</textarea>';
|
|
} else {
|
|
echo json_encode($array);
|
|
}
|
|
die();
|
|
}
|
|
|
|
public function lang($string)
|
|
{
|
|
if (isset($this->language[$string]) && $this->language[$string] != '') {
|
|
return $this->language[$string];
|
|
} else {
|
|
return 'Language string error on '.$string;
|
|
}
|
|
}
|
|
|
|
public function getvar($var, $sanitize = true)
|
|
{
|
|
if (!isset($_GET[$var]) || $_GET[$var] == '') {
|
|
$this->error(sprintf($this->lang('INVALID_VAR'), $var));
|
|
} else {
|
|
if ($sanitize) {
|
|
$this->get[$var] = $this->sanitize($_GET[$var]);
|
|
} else {
|
|
$this->get[$var] = $_GET[$var];
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
public function postvar($var, $sanitize = true)
|
|
{
|
|
if (!isset($_POST[$var]) || ($var != 'content' && $_POST[$var] == '')) {
|
|
$this->error(sprintf($this->lang('INVALID_VAR'), $var));
|
|
} else {
|
|
if ($sanitize) {
|
|
$this->post[$var] = $this->sanitize($_POST[$var]);
|
|
} else {
|
|
$this->post[$var] = $_POST[$var];
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
public function getinfo()
|
|
{
|
|
$this->item = [];
|
|
$this->item['properties'] = $this->properties;
|
|
$this->get_file_info('', false);
|
|
|
|
// handle path when set dynamically with $fm->setFileRoot() method
|
|
if ($this->dynamic_fileroot != '') {
|
|
$path = $this->dynamic_fileroot.$this->get['path'];
|
|
// $path = str_replace($_SERVER['DOCUMENT_ROOT'], '', $this->path_to_files) . $this->get['path']; // instruction could replace the line above
|
|
$path = preg_replace('~/+~', '/', $path); // remove multiple slashes
|
|
} else {
|
|
$path = $this->get['path'];
|
|
}
|
|
|
|
$array = [
|
|
'Path' => $path,
|
|
'Filename' => $this->item['filename'],
|
|
'File Type' => $this->item['filetype'],
|
|
'Protected' => $this->item['protected'],
|
|
'Preview' => $this->item['preview'],
|
|
'Properties' => $this->item['properties'],
|
|
'Error' => '',
|
|
'Code' => 0,
|
|
];
|
|
|
|
return $array;
|
|
}
|
|
|
|
public function getfolder()
|
|
{
|
|
$array = [];
|
|
$filesDir = [];
|
|
|
|
$current_path = $this->getFullPath();
|
|
|
|
if (!$this->is_valid_path($current_path)) {
|
|
$this->error('No way.');
|
|
}
|
|
|
|
if (!is_dir($current_path)) {
|
|
$this->error(sprintf($this->lang('DIRECTORY_NOT_EXIST'), $this->get['path']));
|
|
}
|
|
|
|
// check if file is readable
|
|
if (!$this->has_system_permission($current_path, ['r'])) {
|
|
$this->error(sprintf($this->lang('NOT_ALLOWED_SYSTEM')));
|
|
}
|
|
|
|
if (!$handle = @opendir($current_path)) {
|
|
$this->error(sprintf($this->lang('UNABLE_TO_OPEN_DIRECTORY'), $this->get['path']));
|
|
} else {
|
|
while (false !== ($file = readdir($handle))) {
|
|
if ($file != '.' && $file != '..') {
|
|
array_push($filesDir, $file);
|
|
}
|
|
}
|
|
closedir($handle);
|
|
|
|
// By default
|
|
// Sorting files by name ('default' or 'NAME_DESC' cases from $this->config['options']['fileSorting']
|
|
natcasesort($filesDir);
|
|
|
|
foreach ($filesDir as $file) {
|
|
if (is_dir($current_path.$file)) {
|
|
if (!in_array($file, $this->config['exclude']['unallowed_dirs']) && !preg_match($this->config['exclude']['unallowed_dirs_REGEXP'], $file)) {
|
|
|
|
// check if file is writable and readable
|
|
if (!$this->has_system_permission($current_path.$file, ['w', 'r'])) {
|
|
$protected = 1;
|
|
$previewPath = $this->config['icons']['path'].'locked_'.$this->config['icons']['directory'];
|
|
} else {
|
|
$protected = 0;
|
|
$previewPath = $this->config['icons']['path'].$this->config['icons']['directory'];
|
|
}
|
|
|
|
$array[$this->get['path'].$file.'/'] = [
|
|
'Path' => $this->get['path'].$file.'/',
|
|
'Filename' => $file,
|
|
'File Type' => 'dir',
|
|
'Protected' => $protected,
|
|
'Preview' => $previewPath,
|
|
'Properties' => [
|
|
'Date Created' => date($this->config['options']['dateFormat'], filectime($this->getFullPath($this->get['path'].$file.'/'))),
|
|
'Date Modified' => date($this->config['options']['dateFormat'], filemtime($this->getFullPath($this->get['path'].$file.'/'))),
|
|
'filemtime' => filemtime($this->getFullPath($this->get['path'].$file.'/')),
|
|
'Height' => null,
|
|
'Width' => null,
|
|
'Size' => null,
|
|
],
|
|
'Error' => '',
|
|
'Code' => 0,
|
|
];
|
|
}
|
|
} elseif (!in_array($file, $this->config['exclude']['unallowed_files']) && !preg_match($this->config['exclude']['unallowed_files_REGEXP'], $file)) {
|
|
$this->item = [];
|
|
$this->item['properties'] = $this->properties;
|
|
$this->get_file_info($this->get['path'].$file, true);
|
|
|
|
if (!isset($this->params['type']) || (isset($this->params['type']) && strtolower($this->params['type']) == 'images' && in_array(strtolower($this->item['filetype']), array_map('strtolower', $this->config['images']['imagesExt'])))) {
|
|
if ($this->config['upload']['imagesOnly'] == false || ($this->config['upload']['imagesOnly'] == true && in_array(strtolower($this->item['filetype']), array_map('strtolower', $this->config['images']['imagesExt'])))) {
|
|
$array[$this->get['path'].$file] = [
|
|
'Path' => $this->get['path'].$file,
|
|
'Filename' => $this->item['filename'],
|
|
'File Type' => $this->item['filetype'],
|
|
'Protected' => $this->item['protected'],
|
|
'Preview' => $this->item['preview'],
|
|
'Properties' => $this->item['properties'],
|
|
'Error' => '',
|
|
'Code' => 0,
|
|
];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
$array = $this->sortFiles($array);
|
|
|
|
return $array;
|
|
}
|
|
|
|
public function editfile()
|
|
{
|
|
$current_path = $this->getFullPath();
|
|
|
|
// check if file is writable
|
|
if (!$this->has_system_permission($current_path, ['w'])) {
|
|
$this->error(sprintf($this->lang('NOT_ALLOWED_SYSTEM')));
|
|
}
|
|
|
|
if (!$this->has_permission('edit') || !$this->is_valid_path($current_path) || !$this->is_editable($current_path)) {
|
|
$this->error('No way.');
|
|
}
|
|
|
|
$this->__log(__METHOD__.' - editing file '.$current_path);
|
|
|
|
$content = file_get_contents($current_path);
|
|
$content = htmlspecialchars($content);
|
|
|
|
if ($content === false) {
|
|
$this->error(sprintf($this->lang('ERROR_OPENING_FILE')));
|
|
}
|
|
|
|
$array = [
|
|
'Error' => '',
|
|
'Code' => 0,
|
|
'Path' => $this->get['path'],
|
|
'Content' => $this->formatPath($content),
|
|
];
|
|
|
|
return $array;
|
|
}
|
|
|
|
public function savefile()
|
|
{
|
|
$current_path = $this->getFullPath($this->post['path']);
|
|
|
|
if (!$this->has_permission('edit') || !$this->is_valid_path($current_path) || !$this->is_editable($current_path)) {
|
|
$this->error('No way.');
|
|
}
|
|
|
|
if (!$this->has_system_permission($current_path, ['w'])) {
|
|
$this->error(sprintf($this->lang('ERROR_WRITING_PERM')));
|
|
}
|
|
|
|
$this->__log(__METHOD__.' - saving file '.$current_path);
|
|
|
|
$content = htmlspecialchars_decode($this->post['content']);
|
|
$r = file_put_contents($current_path, $content, LOCK_EX);
|
|
|
|
if (!is_numeric($r)) {
|
|
$this->error(sprintf($this->lang('ERROR_SAVING_FILE')));
|
|
}
|
|
|
|
$array = [
|
|
'Error' => '',
|
|
'Code' => 0,
|
|
'Path' => $this->formatPath($this->post['path']),
|
|
];
|
|
|
|
return $array;
|
|
}
|
|
|
|
public function rename()
|
|
{
|
|
$suffix = '';
|
|
|
|
if (substr($this->get['old'], -1, 1) == '/') {
|
|
$this->get['old'] = substr($this->get['old'], 0, (strlen($this->get['old']) - 1));
|
|
$suffix = '/';
|
|
}
|
|
$tmp = explode('/', $this->get['old']);
|
|
$filename = $tmp[(count($tmp) - 1)];
|
|
$path = str_replace('/'.$filename, '', $this->get['old']);
|
|
|
|
$new_file = $this->getFullPath($path.'/'.$this->get['new']).$suffix;
|
|
$old_file = $this->getFullPath($this->get['old']).$suffix;
|
|
|
|
if (!$this->has_permission('rename') || !$this->is_valid_path($old_file)) {
|
|
$this->error('No way.');
|
|
}
|
|
|
|
// check if file is writable
|
|
if (!$this->has_system_permission($old_file, ['w'])) {
|
|
$this->error(sprintf($this->lang('NOT_ALLOWED_SYSTEM')));
|
|
}
|
|
|
|
// check if not requesting main FM userfiles folder
|
|
if ($this->is_root_folder($old_file)) {
|
|
$this->error(sprintf($this->lang('NOT_ALLOWED')));
|
|
}
|
|
|
|
// For file only - we check if the new given extension is allowed regarding the security Policy settings
|
|
if (is_file($old_file) && $this->config['security']['allowChangeExtensions'] && !$this->is_allowed_file_type($new_file)) {
|
|
$this->error(sprintf($this->lang('INVALID_FILE_TYPE')));
|
|
}
|
|
|
|
$this->__log(__METHOD__.' - renaming '.$old_file.' to '.$new_file);
|
|
|
|
if (file_exists($new_file)) {
|
|
if ($suffix == '/' && is_dir($new_file)) {
|
|
$this->error(sprintf($this->lang('DIRECTORY_ALREADY_EXISTS'), $this->get['new']));
|
|
}
|
|
if ($suffix == '' && is_file($new_file)) {
|
|
$this->error(sprintf($this->lang('FILE_ALREADY_EXISTS'), $this->get['new']));
|
|
}
|
|
}
|
|
|
|
if (!rename($old_file, $new_file)) {
|
|
if (is_dir($old_file)) {
|
|
$this->error(sprintf($this->lang('ERROR_RENAMING_DIRECTORY'), $filename, $this->get['new']));
|
|
} else {
|
|
$this->error(sprintf($this->lang('ERROR_RENAMING_FILE'), $filename, $this->get['new']));
|
|
}
|
|
}
|
|
$array = [
|
|
'Error' => '',
|
|
'Code' => 0,
|
|
'Old Path' => $this->formatPath($this->get['old'].$suffix),
|
|
'Old Name' => $filename,
|
|
'New Path' => $this->formatPath($path.'/'.$this->get['new'].$suffix),
|
|
'New Name' => $this->get['new'],
|
|
];
|
|
|
|
return $array;
|
|
}
|
|
|
|
public function move()
|
|
{
|
|
|
|
// dynamic fileroot dir must be used when enabled
|
|
if ($this->dynamic_fileroot != '') {
|
|
$rootDir = $this->dynamic_fileroot;
|
|
//$rootDir = str_replace($_SERVER['DOCUMENT_ROOT'], '', $this->path_to_files); // instruction could replace the line above
|
|
} else {
|
|
$rootDir = $this->get['root'];
|
|
}
|
|
|
|
$rootDir = str_replace('//', '/', $rootDir);
|
|
$oldPath = $this->getFullPath($this->get['old']);
|
|
|
|
// check if file is writable
|
|
if (!$this->has_system_permission($oldPath, ['w'])) {
|
|
$this->error(sprintf($this->lang('NOT_ALLOWED_SYSTEM')), true);
|
|
}
|
|
|
|
// check if not requesting main FM userfiles folder
|
|
if ($this->is_root_folder($oldPath)) {
|
|
$this->error(sprintf($this->lang('NOT_ALLOWED')), true);
|
|
}
|
|
|
|
// old path
|
|
$tmp = explode('/', trim($this->get['old'], '/'));
|
|
$fileName = array_pop($tmp); // file name or new dir name
|
|
$path = '/'.implode('/', $tmp).'/';
|
|
|
|
// new path
|
|
if (substr($this->get['new'], 0, 1) != '/') {
|
|
// make path relative from old dir
|
|
$newPath = $path.'/'.$this->get['new'].'/';
|
|
} else {
|
|
$newPath = $rootDir.'/'.$this->get['new'].'/';
|
|
}
|
|
|
|
$newPath = preg_replace('#/+#', '/', $newPath);
|
|
$newPath = $this->expandPath($newPath, true);
|
|
|
|
$newRelativePath = str_replace('./', '', $newPath);
|
|
$newPath = $this->getFullPath($newPath);
|
|
|
|
if (!$this->has_permission('move') || !$this->is_valid_path($oldPath) || !$this->is_valid_path($newPath)) {
|
|
$this->error('No way.');
|
|
}
|
|
|
|
// check if file already exists
|
|
if (file_exists($newPath.$fileName)) {
|
|
if (is_dir($newPath.$fileName)) {
|
|
$this->error(sprintf($this->lang('DIRECTORY_ALREADY_EXISTS'), rtrim($this->get['new'], '/').'/'.$fileName));
|
|
} else {
|
|
$this->error(sprintf($this->lang('FILE_ALREADY_EXISTS'), rtrim($this->get['new'], '/').'/'.$fileName));
|
|
}
|
|
}
|
|
|
|
// create dir if not exists
|
|
if (!file_exists($newPath)) {
|
|
if (!mkdir($newPath, 0755, true)) {
|
|
$this->error(sprintf($this->lang('UNABLE_TO_CREATE_DIRECTORY'), $newPath));
|
|
}
|
|
}
|
|
|
|
// move
|
|
$this->__log(__METHOD__.' - moving '.$oldPath.' to directory '.$newPath);
|
|
|
|
if (!rename($oldPath, $newPath.$fileName)) {
|
|
if (is_dir($oldPath)) {
|
|
$this->error(sprintf($this->lang('ERROR_RENAMING_DIRECTORY'), $path, $this->get['new']));
|
|
} else {
|
|
$this->error(sprintf($this->lang('ERROR_RENAMING_FILE'), $path.$fileName, $this->get['new']));
|
|
}
|
|
}
|
|
|
|
$array = [
|
|
'Error' => '',
|
|
'Code' => 0,
|
|
'Old Path' => $path,
|
|
'Old Name' => $fileName,
|
|
'New Path' => $this->formatPath($newRelativePath),
|
|
'New Name' => $fileName,
|
|
];
|
|
|
|
return $array;
|
|
}
|
|
|
|
public function delete()
|
|
{
|
|
$current_path = $this->getFullPath();
|
|
$thumbnail_path = $this->get_thumbnail_path($current_path);
|
|
|
|
if (!$this->has_permission('delete') || !$this->is_valid_path($current_path)) {
|
|
$this->error('No way.');
|
|
}
|
|
|
|
// check if file is writable
|
|
if (!$this->has_system_permission($current_path, ['w'])) {
|
|
$this->error(sprintf($this->lang('NOT_ALLOWED_SYSTEM')));
|
|
}
|
|
|
|
// check if not requesting main FM userfiles folder
|
|
if ($this->is_root_folder($current_path)) {
|
|
$this->error(sprintf($this->lang('NOT_ALLOWED')));
|
|
}
|
|
|
|
if (is_dir($current_path)) {
|
|
$this->unlinkRecursive($current_path);
|
|
|
|
// we remove thumbnails if needed
|
|
$this->__log(__METHOD__.' - deleting thumbnails folder '.$thumbnail_path);
|
|
$this->unlinkRecursive($thumbnail_path);
|
|
|
|
$array = [
|
|
'Error' => '',
|
|
'Code' => 0,
|
|
'Path' => $this->formatPath($this->get['path']),
|
|
];
|
|
|
|
$this->__log(__METHOD__.' - deleting folder '.$current_path);
|
|
|
|
return $array;
|
|
} elseif (file_exists($current_path)) {
|
|
unlink($current_path);
|
|
|
|
// delete thumbail if exists
|
|
$this->__log(__METHOD__.' - deleting thumbnail file '.$thumbnail_path);
|
|
if (file_exists($thumbnail_path)) {
|
|
unlink($thumbnail_path);
|
|
}
|
|
|
|
$array = [
|
|
'Error' => '',
|
|
'Code' => 0,
|
|
'Path' => $this->formatPath($this->get['path']),
|
|
];
|
|
|
|
$this->__log(__METHOD__.' - deleting file '.$current_path);
|
|
|
|
return $array;
|
|
} else {
|
|
$this->error(sprintf($this->lang('INVALID_DIRECTORY_OR_FILE')));
|
|
}
|
|
}
|
|
|
|
public function replace()
|
|
{
|
|
$this->setParams();
|
|
|
|
if (!isset($_FILES['fileR']) || !is_uploaded_file($_FILES['fileR']['tmp_name'])) {
|
|
|
|
// if fileSize limit set by the user is greater than size allowed in php.ini file, we apply server restrictions
|
|
// and log a warning into file
|
|
if ($this->config['upload']['fileSizeLimit'] > $this->getMaxUploadFileSize()) {
|
|
$this->__log(__METHOD__.' [WARNING] : file size limit set by user is greater than size allowed in php.ini file : '.$this->config['upload']['fileSizeLimit'].$this->lang('mb').' > '.$this->getMaxUploadFileSize().$this->lang('mb').'.');
|
|
$this->config['upload']['fileSizeLimit'] = $this->getMaxUploadFileSize();
|
|
$this->error(sprintf($this->lang('UPLOAD_FILES_SMALLER_THAN'), $this->config['upload']['fileSizeLimit'].$this->lang('mb')), true);
|
|
}
|
|
|
|
$this->error(sprintf($this->lang('INVALID_FILE_UPLOAD').' '.sprintf($this->lang('UPLOAD_FILES_SMALLER_THAN'), $this->config['upload']['fileSizeLimit'].$this->lang('mb'))), true);
|
|
}
|
|
// we determine max upload size if not set
|
|
if ($this->config['upload']['fileSizeLimit'] == 'auto') {
|
|
$this->config['upload']['fileSizeLimit'] = $this->getMaxUploadFileSize();
|
|
}
|
|
|
|
if ($_FILES['fileR']['size'] > ($this->config['upload']['fileSizeLimit'] * 1024 * 1024)) {
|
|
$this->error(sprintf($this->lang('UPLOAD_FILES_SMALLER_THAN'), $this->config['upload']['fileSizeLimit'].$this->lang('mb')), true);
|
|
}
|
|
|
|
// we check the given file has the same extension as the old one
|
|
if (strtolower(pathinfo($_FILES['fileR']['name'], PATHINFO_EXTENSION)) != strtolower(pathinfo($this->post['newfilepath'], PATHINFO_EXTENSION))) {
|
|
$this->error(sprintf($this->lang('ERROR_REPLACING_FILE').' '.pathinfo($this->post['newfilepath'], PATHINFO_EXTENSION)), true);
|
|
}
|
|
|
|
if (!$this->is_allowed_file_type($_FILES['fileR']['name'])) {
|
|
$this->error(sprintf($this->lang('INVALID_FILE_TYPE')), true);
|
|
}
|
|
|
|
// we check if extension is allowed regarding the security Policy settings
|
|
if (!$this->is_allowed_file_type($_FILES['fileR']['name'])) {
|
|
$this->error(sprintf($this->lang('INVALID_FILE_TYPE')), true);
|
|
}
|
|
|
|
// we check if only images are allowed
|
|
if ($this->config['upload']['imagesOnly'] || (isset($this->params['type']) && strtolower($this->params['type']) == 'images')) {
|
|
if (!($size = @getimagesize($_FILES['fileR']['tmp_name']))) {
|
|
$this->error(sprintf($this->lang('UPLOAD_IMAGES_ONLY')), true);
|
|
}
|
|
if (!in_array($size[2], [1, 2, 3, 7, 8])) {
|
|
$this->error(sprintf($this->lang('UPLOAD_IMAGES_TYPE_JPEG_GIF_PNG')), true);
|
|
}
|
|
}
|
|
|
|
$current_path = $this->getFullPath($this->post['newfilepath']);
|
|
|
|
// check if file is writable
|
|
if (!$this->has_system_permission($current_path, ['w'])) {
|
|
$this->error(sprintf($this->lang('NOT_ALLOWED_SYSTEM')), true);
|
|
}
|
|
|
|
if (!$this->has_permission('replace') || !$this->is_valid_path($current_path)) {
|
|
$this->error('No way.');
|
|
}
|
|
|
|
move_uploaded_file($_FILES['fileR']['tmp_name'], $current_path);
|
|
|
|
// we delete thumbnail if file is image and thumbnail already
|
|
if ($this->is_image($current_path) && file_exists($this->get_thumbnail($current_path))) {
|
|
unlink($this->get_thumbnail($current_path));
|
|
}
|
|
|
|
// automatically resize image if it's too big
|
|
$imagePath = $current_path;
|
|
if ($this->is_image($imagePath) && $this->config['images']['resize']['enabled']) {
|
|
if ($size = @getimagesize($imagePath)) {
|
|
if ($size[0] > $this->config['images']['resize']['maxWidth'] || $size[1] > $this->config['images']['resize']['maxHeight']) {
|
|
require_once './inc/wideimage/lib/WideImage.php';
|
|
|
|
$image = WideImage::load($imagePath);
|
|
$resized = $image->resize($this->config['images']['resize']['maxWidth'], $this->config['images']['resize']['maxHeight'], 'inside');
|
|
$resized->saveToFile($imagePath);
|
|
|
|
$this->__log(__METHOD__.' - resizing image : '.$current_path);
|
|
}
|
|
}
|
|
}
|
|
|
|
chmod($current_path, 0644);
|
|
|
|
$response = [
|
|
'Path' => dirname($this->post['newfilepath']),
|
|
'Name' => basename($this->post['newfilepath']),
|
|
'Error' => '',
|
|
'Code' => 0,
|
|
];
|
|
|
|
$this->__log(__METHOD__.' - replacing file '.$current_path);
|
|
|
|
echo '<textarea>'.json_encode($response).'</textarea>';
|
|
die();
|
|
}
|
|
|
|
public function add()
|
|
{
|
|
$this->setParams();
|
|
|
|
if (!isset($_FILES['newfile']) || !is_uploaded_file($_FILES['newfile']['tmp_name'])) {
|
|
|
|
// if fileSize limit set by the user is greater than size allowed in php.ini file, we apply server restrictions
|
|
// and log a warning into file
|
|
if ($this->config['upload']['fileSizeLimit'] > $this->getMaxUploadFileSize()) {
|
|
$this->__log(__METHOD__.' [WARNING] : file size limit set by user is greater than size allowed in php.ini file : '.$this->config['upload']['fileSizeLimit'].'Mb > '.$this->getMaxUploadFileSize().'Mb.');
|
|
$this->config['upload']['fileSizeLimit'] = $this->getMaxUploadFileSize();
|
|
$this->error(sprintf($this->lang('UPLOAD_FILES_SMALLER_THAN'), $this->config['upload']['fileSizeLimit'].$this->lang('mb')), true);
|
|
}
|
|
|
|
$this->error(sprintf($this->lang('INVALID_FILE_UPLOAD').' '.sprintf($this->lang('UPLOAD_FILES_SMALLER_THAN'), $this->config['upload']['fileSizeLimit'].$this->lang('mb'))), true);
|
|
}
|
|
// we determine max upload size if not set
|
|
if ($this->config['upload']['fileSizeLimit'] == 'auto') {
|
|
$this->config['upload']['fileSizeLimit'] = $this->getMaxUploadFileSize();
|
|
}
|
|
|
|
if ($_FILES['newfile']['size'] > ($this->config['upload']['fileSizeLimit'] * 1024 * 1024)) {
|
|
$this->error(sprintf($this->lang('UPLOAD_FILES_SMALLER_THAN'), $this->config['upload']['fileSizeLimit'].$this->lang('mb')), true);
|
|
}
|
|
|
|
// we check if extension is allowed regarding the security Policy settings
|
|
if (!$this->is_allowed_file_type($_FILES['newfile']['name'])) {
|
|
$this->error(sprintf($this->lang('INVALID_FILE_TYPE')), true);
|
|
}
|
|
|
|
// we check if only images are allowed
|
|
if ($this->config['upload']['imagesOnly'] || (isset($this->params['type']) && strtolower($this->params['type']) == 'images')) {
|
|
if (!($size = @getimagesize($_FILES['newfile']['tmp_name']))) {
|
|
$this->error(sprintf($this->lang('UPLOAD_IMAGES_ONLY')), true);
|
|
}
|
|
if (!in_array($size[2], [1, 2, 3, 7, 8])) {
|
|
$this->error(sprintf($this->lang('UPLOAD_IMAGES_TYPE_JPEG_GIF_PNG')), true);
|
|
}
|
|
}
|
|
$_FILES['newfile']['name'] = $this->cleanString($_FILES['newfile']['name'], ['.', '-']);
|
|
|
|
$current_path = $this->getFullPath($this->post['currentpath']);
|
|
|
|
if (!$this->is_valid_path($current_path)) {
|
|
$this->error('No way.');
|
|
}
|
|
|
|
if (!$this->config['upload']['overwrite']) {
|
|
$_FILES['newfile']['name'] = $this->checkFilename($current_path, $_FILES['newfile']['name']);
|
|
}
|
|
move_uploaded_file($_FILES['newfile']['tmp_name'], $current_path.$_FILES['newfile']['name']);
|
|
|
|
// automatically resize image if it's too big
|
|
$imagePath = $current_path.$_FILES['newfile']['name'];
|
|
if ($this->is_image($imagePath) && $this->config['images']['resize']['enabled']) {
|
|
if ($size = @getimagesize($imagePath)) {
|
|
if ($size[0] > $this->config['images']['resize']['maxWidth'] || $size[1] > $this->config['images']['resize']['maxHeight']) {
|
|
require_once './inc/wideimage/lib/WideImage.php';
|
|
|
|
$image = WideImage::load($imagePath);
|
|
$resized = $image->resize($this->config['images']['resize']['maxWidth'], $this->config['images']['resize']['maxHeight'], 'inside');
|
|
$resized->saveToFile($imagePath);
|
|
|
|
$this->__log(__METHOD__.' - resizing image : '.$_FILES['newfile']['name'].' into '.$current_path);
|
|
}
|
|
}
|
|
}
|
|
|
|
chmod($current_path.$_FILES['newfile']['name'], 0644);
|
|
|
|
$response = [
|
|
'Path' => $this->post['currentpath'],
|
|
'Name' => $_FILES['newfile']['name'],
|
|
'Error' => '',
|
|
'Code' => 0,
|
|
];
|
|
|
|
$this->__log(__METHOD__.' - adding file '.$_FILES['newfile']['name'].' into '.$current_path);
|
|
|
|
echo '<textarea>'.json_encode($response).'</textarea>';
|
|
die();
|
|
}
|
|
|
|
public function addfolder()
|
|
{
|
|
$current_path = $this->getFullPath();
|
|
|
|
if (!$this->is_valid_path($current_path)) {
|
|
$this->error('No way.');
|
|
}
|
|
if (is_dir($current_path.$this->get['name'])) {
|
|
$this->error(sprintf($this->lang('DIRECTORY_ALREADY_EXISTS'), $this->get['name']));
|
|
}
|
|
$newdir = $this->cleanString($this->get['name']);
|
|
if (!mkdir($current_path.$newdir, 0755)) {
|
|
$this->error(sprintf($this->lang('UNABLE_TO_CREATE_DIRECTORY'), $newdir));
|
|
}
|
|
$array = [
|
|
'Parent' => $this->get['path'],
|
|
'Name' => $this->get['name'],
|
|
'Error' => '',
|
|
'Code' => 0,
|
|
];
|
|
$this->__log(__METHOD__.' - adding folder '.$current_path.$newdir);
|
|
|
|
return $array;
|
|
}
|
|
|
|
/**
|
|
* function zipFile. Creates a zip file from source to destination.
|
|
*
|
|
* @param string $source Source path for zip
|
|
* @param string $destination Destination path for zip
|
|
* @param string|bool $flag OPTIONAL If true includes the folder also
|
|
*
|
|
* @return bool
|
|
*
|
|
* @link http://stackoverflow.com/questions/17584869/zip-main-folder-with-sub-folder-inside
|
|
*/
|
|
public function zipFile($source, $destination, $flag = '')
|
|
{
|
|
if (!extension_loaded('zip') || !file_exists($source)) {
|
|
return false;
|
|
}
|
|
|
|
$zip = new ZipArchive();
|
|
if (!$zip->open($destination, ZIPARCHIVE::CREATE)) {
|
|
return false;
|
|
}
|
|
|
|
$source = str_replace('\\', '/', realpath($source));
|
|
if ($flag) {
|
|
$flag = basename($source).'/';
|
|
//$zip->addEmptyDir(basename($source) . '/');
|
|
}
|
|
|
|
if (is_dir($source) === true) {
|
|
// add file to prevent empty archive error on download
|
|
$zip->addFromString('fm', "This archive has been generated by simogeo's Filemanager : https://github.com/simogeo/Filemanager/");
|
|
|
|
$files = new RecursiveIteratorIterator(new RecursiveDirectoryIterator($source), RecursiveIteratorIterator::SELF_FIRST);
|
|
foreach ($files as $file) {
|
|
$file = str_replace('\\', '/', realpath($file));
|
|
|
|
if (is_dir($file) === true) {
|
|
$zip->addEmptyDir(str_replace($source.'/', '', $flag.$file.'/'));
|
|
} elseif (is_file($file) === true) {
|
|
$zip->addFromString(str_replace($source.'/', '', $flag.$file), file_get_contents($file));
|
|
}
|
|
}
|
|
} elseif (is_file($source) === true) {
|
|
$zip->addFromString($flag.basename($source), file_get_contents($source));
|
|
}
|
|
|
|
return $zip->close();
|
|
}
|
|
|
|
public function download()
|
|
{
|
|
$current_path = $this->getFullPath();
|
|
|
|
if (!$this->has_permission('download') || !$this->is_valid_path($current_path)) {
|
|
$this->error('No way.');
|
|
}
|
|
|
|
// check if file is writable
|
|
if (!$this->has_system_permission($current_path, ['w'])) {
|
|
$this->error(sprintf($this->lang('NOT_ALLOWED_SYSTEM')), true);
|
|
}
|
|
|
|
// we check if extension is allowed regarding the security Policy settings
|
|
if (is_file($current_path)) {
|
|
if (!$this->is_allowed_file_type(basename($current_path))) {
|
|
$this->error(sprintf($this->lang('INVALID_FILE_TYPE')), true);
|
|
}
|
|
} else {
|
|
|
|
// check if permission is granted
|
|
if (is_dir($current_path) && $this->config['security']['allowFolderDownload'] == false) {
|
|
$this->error(sprintf($this->lang('NOT_ALLOWED')), true);
|
|
}
|
|
|
|
// check if not requesting main FM userfiles folder
|
|
if ($this->is_root_folder($current_path)) {
|
|
$this->error(sprintf($this->lang('NOT_ALLOWED')), true);
|
|
}
|
|
|
|
$destination_path = sys_get_temp_dir().'/'.uniqid().'.zip';
|
|
|
|
// if Zip archive is created
|
|
if ($this->zipFile($current_path, $destination_path, true)) {
|
|
$current_path = $destination_path;
|
|
} else {
|
|
$this->error($this->lang('ERROR_CREATING_ZIP'));
|
|
}
|
|
}
|
|
|
|
if (isset($this->get['path']) && file_exists($current_path)) {
|
|
header('Content-type: application/force-download');
|
|
header('Content-Disposition: inline; filename="'.basename($current_path).'"');
|
|
header('Content-Transfer-Encoding: Binary');
|
|
header('Content-length: '.filesize($current_path));
|
|
header('Content-Type: application/octet-stream');
|
|
header('Content-Disposition: attachment; filename="'.basename($current_path).'"');
|
|
readfile($current_path);
|
|
$this->__log(__METHOD__.' - downloading '.$current_path);
|
|
exit();
|
|
} else {
|
|
$this->error(sprintf($this->lang('FILE_DOES_NOT_EXIST'), $current_path));
|
|
}
|
|
}
|
|
|
|
public function preview($thumbnail)
|
|
{
|
|
$current_path = $this->getFullPath();
|
|
|
|
if (isset($this->get['path']) && file_exists($current_path)) {
|
|
|
|
// if $thumbnail is set to true we return the thumbnail
|
|
if ($this->config['options']['generateThumbnails'] == true && $thumbnail == true) {
|
|
// get thumbnail (and create it if needed)
|
|
$returned_path = $this->get_thumbnail($current_path);
|
|
} else {
|
|
$returned_path = $current_path;
|
|
}
|
|
|
|
header('Content-type: image/'.strtolower(pathinfo($returned_path, PATHINFO_EXTENSION)));
|
|
header('Content-Transfer-Encoding: Binary');
|
|
header('Content-length: '.filesize($returned_path));
|
|
header('Content-Disposition: inline; filename="'.basename($returned_path).'"');
|
|
readfile($returned_path);
|
|
|
|
exit();
|
|
} else {
|
|
$this->error(sprintf($this->lang('FILE_DOES_NOT_EXIST'), $current_path));
|
|
}
|
|
}
|
|
|
|
public function getMaxUploadFileSize()
|
|
{
|
|
$max_upload = (int) ini_get('upload_max_filesize');
|
|
$max_post = (int) ini_get('post_max_size');
|
|
$memory_limit = (int) ini_get('memory_limit');
|
|
|
|
$upload_mb = min($max_upload, $max_post, $memory_limit);
|
|
|
|
$this->__log(__METHOD__.' - max upload file size is '.$upload_mb.'Mb');
|
|
|
|
return $upload_mb;
|
|
}
|
|
|
|
private function setParams()
|
|
{
|
|
$tmp = (isset($_SERVER['HTTP_REFERER']) ? $_SERVER['HTTP_REFERER'] : '/');
|
|
$tmp = explode('?', $tmp);
|
|
$params = [];
|
|
if (isset($tmp[1]) && $tmp[1] != '') {
|
|
$params_tmp = explode('&', $tmp[1]);
|
|
if (is_array($params_tmp)) {
|
|
foreach ($params_tmp as $value) {
|
|
$tmp = explode('=', $value);
|
|
if (isset($tmp[0]) && $tmp[0] != '' && isset($tmp[1]) && $tmp[1] != '') {
|
|
$params[$tmp[0]] = $tmp[1];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
$this->params = $params;
|
|
}
|
|
|
|
private function setPermissions()
|
|
{
|
|
$this->allowed_actions = $this->config['options']['capabilities'];
|
|
|
|
if ($this->config['edit']['enabled']) {
|
|
array_push($this->allowed_actions, 'edit');
|
|
}
|
|
}
|
|
|
|
// check if system permission is granted
|
|
private function has_system_permission($filepath, $perms)
|
|
{
|
|
if (in_array('r', $perms)) {
|
|
if (!is_readable($filepath)) {
|
|
return false;
|
|
}
|
|
}
|
|
if (in_array('w', $perms)) {
|
|
if (!is_writable($filepath)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
private function get_file_info($path = '', $thumbnail = false)
|
|
{
|
|
|
|
// DO NOT rawurlencode() since $current_path it
|
|
// is used for displaying name file
|
|
if ($path == '') {
|
|
$current_path = $this->get['path'];
|
|
} else {
|
|
$current_path = $path;
|
|
}
|
|
$tmp = explode('/', $current_path);
|
|
$this->item['filename'] = $tmp[(count($tmp) - 1)];
|
|
|
|
$tmp = explode('.', $this->item['filename']);
|
|
$this->item['filetype'] = $tmp[(count($tmp) - 1)];
|
|
$this->item['filemtime'] = filemtime($this->getFullPath($current_path));
|
|
$this->item['filectime'] = filectime($this->getFullPath($current_path));
|
|
|
|
// check if file is writable and readable
|
|
if (!$this->has_system_permission($this->getFullPath($current_path), ['w', 'r'])) {
|
|
$this->item['protected'] = 1;
|
|
$this->item['preview'] = $this->config['icons']['path'].'locked_'.$this->config['icons']['default'];
|
|
// prevent Internal Server Error HTTP_CODE 500 on non readable files/folders
|
|
// without returning errors
|
|
return;
|
|
} else {
|
|
$this->item['protected'] = 0;
|
|
$this->item['preview'] = $this->config['icons']['path'].$this->config['icons']['default'];
|
|
}
|
|
|
|
if (is_dir($current_path)) {
|
|
$this->item['preview'] = $this->config['icons']['path'].$this->config['icons']['directory'];
|
|
} elseif (in_array(strtolower($this->item['filetype']), array_map('strtolower', $this->config['images']['imagesExt']))) {
|
|
|
|
// svg should not be previewed as raster formats images
|
|
if ($this->item['filetype'] == 'svg') {
|
|
$this->item['preview'] = $current_path;
|
|
} else {
|
|
$this->item['preview'] = 'connectors/php/filemanager.php?mode=preview&path='.rawurlencode($current_path).'&'.time();
|
|
if ($thumbnail) {
|
|
$this->item['preview'] .= '&thumbnail=true';
|
|
}
|
|
}
|
|
//if(isset($get['getsize']) && $get['getsize']=='true') {
|
|
$this->item['properties']['Size'] = filesize($this->getFullPath($current_path));
|
|
if ($this->item['properties']['Size']) {
|
|
list($width, $height, $type, $attr) = getimagesize($this->getFullPath($current_path));
|
|
} else {
|
|
$this->item['properties']['Size'] = 0;
|
|
list($width, $height) = [0, 0];
|
|
}
|
|
$this->item['properties']['Height'] = $height;
|
|
$this->item['properties']['Width'] = $width;
|
|
$this->item['properties']['Size'] = filesize($this->getFullPath($current_path));
|
|
//}
|
|
} elseif (file_exists($this->root.$this->config['icons']['path'].strtolower($this->item['filetype']).'.png')) {
|
|
$this->item['preview'] = $this->config['icons']['path'].strtolower($this->item['filetype']).'.png';
|
|
$this->item['properties']['Size'] = filesize($this->getFullPath($current_path));
|
|
if (!$this->item['properties']['Size']) {
|
|
$this->item['properties']['Size'] = 0;
|
|
}
|
|
}
|
|
|
|
$this->item['properties']['Date Modified'] = date($this->config['options']['dateFormat'], $this->item['filemtime']);
|
|
$this->item['properties']['filemtime'] = filemtime($this->getFullPath($current_path));
|
|
//$return['properties']['Date Created'] = $this->config['options']['dateFormat'], $return['filectime']); // PHP cannot get create timestamp
|
|
}
|
|
|
|
private function getFullPath($path = '')
|
|
{
|
|
if ($path == '') {
|
|
if (isset($this->get['path'])) {
|
|
$path = $this->get['path'];
|
|
}
|
|
}
|
|
|
|
if ($this->config['options']['fileRoot'] !== false) {
|
|
$full_path = $this->doc_root.rawurldecode(str_replace($this->doc_root, '', $path));
|
|
if ($this->dynamic_fileroot != '') {
|
|
$full_path = $this->doc_root.rawurldecode(str_replace($this->dynamic_fileroot, '', $path));
|
|
// $dynPart = str_replace($_SERVER['DOCUMENT_ROOT'], '', $this->path_to_files); // instruction could replace the line above
|
|
// $full_path = $this->path_to_files . rawurldecode(str_replace ( $dynPart , '' , $path)); // instruction could replace the line above
|
|
}
|
|
} else {
|
|
$full_path = $this->doc_root.rawurldecode($path);
|
|
}
|
|
|
|
$full_path = str_replace('//', '/', $full_path);
|
|
|
|
// $this->__log("getFullPath() returned path : " . $full_path);
|
|
|
|
return $full_path;
|
|
}
|
|
|
|
/**
|
|
* format path regarding the initial configuration.
|
|
*
|
|
* @param string $path
|
|
*/
|
|
private function formatPath($path)
|
|
{
|
|
if ($this->dynamic_fileroot != '') {
|
|
$a = explode($this->separator, $path);
|
|
|
|
return end($a);
|
|
} else {
|
|
return $path;
|
|
}
|
|
}
|
|
|
|
private function sortFiles($array)
|
|
{
|
|
|
|
// handle 'NAME_ASC'
|
|
if ($this->config['options']['fileSorting'] == 'NAME_ASC') {
|
|
$array = array_reverse($array);
|
|
}
|
|
|
|
// handle 'TYPE_ASC' and 'TYPE_DESC'
|
|
if (strpos($this->config['options']['fileSorting'], 'TYPE_') !== false || $this->config['options']['fileSorting'] == 'default') {
|
|
$a = [];
|
|
$b = [];
|
|
|
|
foreach ($array as $key => $item) {
|
|
if (strcmp($item['File Type'], 'dir') == 0) {
|
|
$a[$key] = $item;
|
|
} else {
|
|
$b[$key] = $item;
|
|
}
|
|
}
|
|
|
|
if ($this->config['options']['fileSorting'] == 'TYPE_ASC') {
|
|
$array = array_merge($a, $b);
|
|
}
|
|
|
|
if ($this->config['options']['fileSorting'] == 'TYPE_DESC' || $this->config['options']['fileSorting'] == 'default') {
|
|
$array = array_merge($b, $a);
|
|
}
|
|
}
|
|
|
|
// handle 'MODIFIED_ASC' and 'MODIFIED_DESC'
|
|
if (strpos($this->config['options']['fileSorting'], 'MODIFIED_') !== false) {
|
|
$modified_order_array = []; // new array as a column to sort collector
|
|
|
|
foreach ($array as $item) {
|
|
$modified_order_array[] = $item['Properties']['filemtime'];
|
|
}
|
|
|
|
if ($this->config['options']['fileSorting'] == 'MODIFIED_ASC') {
|
|
array_multisort($modified_order_array, SORT_ASC, $array);
|
|
}
|
|
if ($this->config['options']['fileSorting'] == 'MODIFIED_DESC') {
|
|
array_multisort($modified_order_array, SORT_DESC, $array);
|
|
}
|
|
|
|
return $array;
|
|
}
|
|
|
|
return $array;
|
|
}
|
|
|
|
// @todo to remove
|
|
// private function startsWith($haystack, $needle) {
|
|
// // search backwards starting from haystack length characters from the end
|
|
// return $needle === "" || strrpos($haystack, $needle, -strlen($haystack)) !== FALSE;
|
|
// }
|
|
|
|
private function is_valid_path($path)
|
|
{
|
|
|
|
// @todo to remove
|
|
// if(!$this->startsWith(realpath($path), realpath($this->path_to_files))) return false;
|
|
// @see https://github.com/simogeo/Filemanager/issues/332
|
|
// @see http://stackoverflow.com/questions/5642785/php-a-good-way-to-universalize-paths-across-oss-slash-directions
|
|
|
|
// $givenpath = str_replace(array('/', '\\'), DIRECTORY_SEPARATOR, $path);
|
|
// $rootpath = str_replace(array('/', '\\'), DIRECTORY_SEPARATOR, $this->path_to_files);
|
|
// $this->__log('substr doc_root : ' . substr(realpath($path) . DIRECTORY_SEPARATOR, 0, strlen($this->doc_root)));
|
|
// $this->__log('doc_root : ' . realpath($this->doc_root) . DIRECTORY_SEPARATOR);
|
|
|
|
// return $this->startsWith($givenpath, $rootpath);
|
|
|
|
$this->__log('substr path_to_files : '.substr(realpath($path).DIRECTORY_SEPARATOR, 0, strlen($this->path_to_files)));
|
|
$this->__log('path_to_files : '.realpath($this->path_to_files).DIRECTORY_SEPARATOR);
|
|
|
|
return (substr(realpath($path).DIRECTORY_SEPARATOR, 0, strlen(realpath($this->path_to_files))).DIRECTORY_SEPARATOR) == (realpath($this->path_to_files).DIRECTORY_SEPARATOR);
|
|
}
|
|
|
|
private function unlinkRecursive($dir, $deleteRootToo = true)
|
|
{
|
|
if (!$dh = @opendir($dir)) {
|
|
return;
|
|
}
|
|
while (false !== ($obj = readdir($dh))) {
|
|
if ($obj == '.' || $obj == '..') {
|
|
continue;
|
|
}
|
|
|
|
if (!@unlink($dir.'/'.$obj)) {
|
|
$this->unlinkRecursive($dir.'/'.$obj, true);
|
|
}
|
|
}
|
|
|
|
closedir($dh);
|
|
|
|
if ($deleteRootToo) {
|
|
@rmdir($dir);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
/**
|
|
* is_allowed_file_type()
|
|
* check if extension is allowed regarding the security Policy / Restrictions settings.
|
|
*
|
|
* @param string $file
|
|
*/
|
|
private function is_allowed_file_type($file)
|
|
{
|
|
$path_parts = pathinfo($file);
|
|
|
|
// if there is no extension
|
|
if (!isset($path_parts ['extension'])) {
|
|
// we check if no extension file are allowed
|
|
return (bool) $this->config['security']['allowNoExtension'];
|
|
}
|
|
|
|
$exts = array_map('strtolower', $this->config['security']['uploadRestrictions']);
|
|
|
|
if ($this->config['security']['uploadPolicy'] == 'DISALLOW_ALL') {
|
|
if (!in_array(strtolower($path_parts['extension']), $exts)) {
|
|
return false;
|
|
}
|
|
}
|
|
if ($this->config['security']['uploadPolicy'] == 'ALLOW_ALL') {
|
|
if (in_array(strtolower($path_parts['extension']), $exts)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
private function cleanString($string, $allowed = [])
|
|
{
|
|
$allow = null;
|
|
|
|
if (!empty($allowed)) {
|
|
foreach ($allowed as $value) {
|
|
$allow .= "\\$value";
|
|
}
|
|
}
|
|
|
|
$mapping = [
|
|
'Š' => 'S', 'š' => 's', 'Đ' => 'Dj', 'đ' => 'dj', 'Ž' => 'Z', 'ž' => 'z', 'Č' => 'C', 'č' => 'c', 'Ć' => 'C', 'ć' => 'c',
|
|
'À' => 'A', 'Á' => 'A', 'Â' => 'A', 'Ã' => 'A', 'Ä' => 'A', 'Å' => 'A', 'Æ' => 'A', 'Ç' => 'C', 'È' => 'E', 'É' => 'E',
|
|
'Ê' => 'E', 'Ë' => 'E', 'Ì' => 'I', 'Í' => 'I', 'Î' => 'I', 'Ï' => 'I', 'Ñ' => 'N', 'Ò' => 'O', 'Ó' => 'O', 'Ô' => 'O',
|
|
'Õ' => 'O', 'Ö' => 'O', 'Ő' => 'O', 'Ø' => 'O', 'Ù' => 'U', 'Ú' => 'U', 'Û' => 'U', 'Ü' => 'U', 'Ű' => 'U', 'Ý' => 'Y',
|
|
'Þ' => 'B', 'ß' => 'Ss', 'à' => 'a', 'á' => 'a', 'â' => 'a', 'ã' => 'a', 'ä' => 'a', 'å' => 'a', 'æ' => 'a', 'ç' => 'c',
|
|
'è' => 'e', 'é' => 'e', 'ê' => 'e', 'ë' => 'e', 'ì' => 'i', 'í' => 'i', 'î' => 'i', 'ï' => 'i', 'ð' => 'o', 'ñ' => 'n',
|
|
'ò' => 'o', 'ó' => 'o', 'ô' => 'o', 'õ' => 'o', 'ö' => 'o', 'ő' => 'o', 'ø' => 'o', 'ù' => 'u', 'ú' => 'u', 'ű' => 'u',
|
|
'û' => 'u', 'ü' => 'u', 'ý' => 'y', 'ý' => 'y', 'þ' => 'b', 'ÿ' => 'y', 'Ŕ' => 'R', 'ŕ' => 'r', ' ' => '_', "'" => '_', '/' => '',
|
|
];
|
|
|
|
if (is_array($string)) {
|
|
$cleaned = [];
|
|
|
|
foreach ($string as $key => $clean) {
|
|
$clean = strtr($clean, $mapping);
|
|
|
|
if ($this->config['options']['chars_only_latin'] == true) {
|
|
$clean = preg_replace("/[^{$allow}_a-zA-Z0-9]/u", '', $clean);
|
|
// $clean = preg_replace("/[^{$allow}_a-zA-Z0-9\x{0430}-\x{044F}\x{0410}-\x{042F}]/u", '', $clean); // allow only latin alphabet with cyrillic
|
|
}
|
|
$cleaned[$key] = preg_replace('/[_]+/', '_', $clean); // remove double underscore
|
|
}
|
|
} else {
|
|
$clean = strtr($string, $mapping);
|
|
if ($this->config['options']['chars_only_latin'] == true) {
|
|
$clean = preg_replace("/[^{$allow}_a-zA-Z0-9]/u", '', $clean);
|
|
// $clean = preg_replace("/[^{$allow}_a-zA-Z0-9\x{0430}-\x{044F}\x{0410}-\x{042F}]/u", '', $string); // allow only latin alphabet with cyrillic
|
|
}
|
|
$cleaned = preg_replace('/[_]+/', '_', $clean); // remove double underscore
|
|
}
|
|
|
|
return $cleaned;
|
|
}
|
|
|
|
/**
|
|
* Checking if permission is set or not for a given action.
|
|
*
|
|
* @param string $action
|
|
*
|
|
* @return bool
|
|
*/
|
|
private function has_permission($action)
|
|
{
|
|
return in_array($action, $this->allowed_actions);
|
|
}
|
|
|
|
/**
|
|
* Return Thumbnail path from given path
|
|
* works for both file and dir path.
|
|
*
|
|
* @param string $path
|
|
*/
|
|
private function get_thumbnail_path($path)
|
|
{
|
|
$pos = strrpos($path, $this->separator);
|
|
$a[0] = substr($path, 0, $pos);
|
|
$a[1] = substr($path, $pos + strlen($this->separator));
|
|
|
|
$path_parts = pathinfo($path);
|
|
|
|
$thumbnail_path = $a[0].$this->separator.'/'.$this->cachefolder.dirname(end($a)).'/';
|
|
if (!is_dir($path)) {
|
|
$thumbnail_name = $path_parts['filename'].'_'.$this->thumbnail_width.'x'.$this->thumbnail_height.'px.'.$path_parts['extension'];
|
|
}
|
|
|
|
if (is_dir($path)) {
|
|
$thumbnail_fullpath = $thumbnail_path;
|
|
} else {
|
|
$thumbnail_fullpath = $thumbnail_path.$thumbnail_name;
|
|
}
|
|
|
|
return $thumbnail_fullpath;
|
|
}
|
|
|
|
/**
|
|
* For debugging just call
|
|
* the direct URL http://localhost/Filemanager/connectors/php/filemanager.php?mode=preview&path=%2FFilemanager%2Fuserfiles%2FMy%20folder3%2Fblanches_neiges.jPg&thumbnail=true
|
|
* and echo vars below.
|
|
*
|
|
* @param string $path
|
|
*/
|
|
private function get_thumbnail($path)
|
|
{
|
|
require_once './inc/wideimage/lib/WideImage.php';
|
|
|
|
$thumbnail_fullpath = $this->get_thumbnail_path($path);
|
|
|
|
// echo $thumbnail_fullpath.'<br>';
|
|
|
|
// if thumbnail does not exist we generate it or cacheThumbnail is set to false
|
|
if (!file_exists($thumbnail_fullpath) || $this->config['options']['cacheThumbnails'] == false) {
|
|
|
|
// create folder if it does not exist
|
|
if (!file_exists(dirname($thumbnail_fullpath))) {
|
|
mkdir(dirname($thumbnail_fullpath), 0755, true);
|
|
}
|
|
$image = WideImage::load($path);
|
|
$resized = $image->resize($this->thumbnail_width, $this->thumbnail_height, 'outside')->crop('center', 'center', $this->thumbnail_width, $this->thumbnail_height);
|
|
$resized->saveToFile($thumbnail_fullpath);
|
|
|
|
$this->__log(__METHOD__.' - generating thumbnail : '.$thumbnail_fullpath);
|
|
}
|
|
|
|
return $thumbnail_fullpath;
|
|
}
|
|
|
|
private function sanitize($var)
|
|
{
|
|
$sanitized = strip_tags($var);
|
|
$sanitized = str_replace('http://', '', $sanitized);
|
|
$sanitized = str_replace('https://', '', $sanitized);
|
|
$sanitized = str_replace('../', '', $sanitized);
|
|
|
|
return $sanitized;
|
|
}
|
|
|
|
private function checkFilename($path, $filename, $i = '')
|
|
{
|
|
if (!file_exists($path.$filename)) {
|
|
return $filename;
|
|
} else {
|
|
$_i = $i;
|
|
$tmp = explode(/*$this->config['upload']['suffix'] . */$i.'.', $filename);
|
|
if ($i == '') {
|
|
$i = 1;
|
|
} else {
|
|
$i++;
|
|
}
|
|
$filename = str_replace($_i.'.'.$tmp[(count($tmp) - 1)], $i.'.'.$tmp[(count($tmp) - 1)], $filename);
|
|
|
|
return $this->checkFilename($path, $filename, $i);
|
|
}
|
|
}
|
|
|
|
private function loadLanguageFile()
|
|
{
|
|
|
|
// we load langCode var passed into URL if present and if exists
|
|
// else, we use default configuration var
|
|
$lang = $this->config['options']['culture'];
|
|
if (isset($this->params['langCode']) && in_array($this->params['langCode'], $this->languages)) {
|
|
$lang = $this->params['langCode'];
|
|
}
|
|
|
|
if (file_exists($this->root.'scripts/languages/'.$lang.'.js')) {
|
|
$stream = file_get_contents($this->root.'scripts/languages/'.$lang.'.js');
|
|
$this->language = json_decode($stream, true);
|
|
} else {
|
|
$l = substr($lang, 0, 2); // we try with 2 chars language file
|
|
if (file_exists($this->root.'scripts/languages/'.$l.'.js')) {
|
|
$stream = file_get_contents($this->root.'scripts/languages/'.$l.'.js');
|
|
$this->language = json_decode($stream, true);
|
|
} else {
|
|
// we include default language file
|
|
$stream = file_get_contents($this->root.'scripts/languages/'.$this->config['options']['culture'].'.js');
|
|
$this->language = json_decode($stream, true);
|
|
}
|
|
}
|
|
}
|
|
|
|
private function availableLanguages()
|
|
{
|
|
if ($handle = opendir($this->root.'/scripts/languages/')) {
|
|
while (false !== ($file = readdir($handle))) {
|
|
if ($file != '.' && $file != '..') {
|
|
array_push($this->languages, pathinfo($file, PATHINFO_FILENAME));
|
|
}
|
|
}
|
|
closedir($handle);
|
|
}
|
|
}
|
|
|
|
private function is_image($path)
|
|
{
|
|
$a = getimagesize($path);
|
|
$image_type = $a[2];
|
|
|
|
return in_array($image_type, [IMAGETYPE_GIF, IMAGETYPE_JPEG, IMAGETYPE_PNG, IMAGETYPE_BMP]);
|
|
}
|
|
|
|
private function is_root_folder($path)
|
|
{
|
|
return rtrim($this->path_to_files, '/') == rtrim($path, '/');
|
|
}
|
|
|
|
private function is_editable($file)
|
|
{
|
|
$path_parts = pathinfo($file);
|
|
|
|
$exts = array_map('strtolower', $this->config['edit']['editExt']);
|
|
|
|
return in_array($path_parts['extension'], $exts);
|
|
}
|
|
|
|
private function get_user_ip()
|
|
{
|
|
$client = @$_SERVER['HTTP_CLIENT_IP'];
|
|
$forward = @$_SERVER['HTTP_X_FORWARDED_FOR'];
|
|
$remote = $_SERVER['REMOTE_ADDR'];
|
|
|
|
if (filter_var($client, FILTER_VALIDATE_IP)) {
|
|
$ip = $client;
|
|
} elseif (filter_var($forward, FILTER_VALIDATE_IP)) {
|
|
$ip = $forward;
|
|
} else {
|
|
$ip = $remote;
|
|
}
|
|
|
|
return $ip;
|
|
}
|
|
|
|
private function __log($msg)
|
|
{
|
|
if ($this->logger == true) {
|
|
$fp = fopen($this->logfile, 'a');
|
|
$str = '['.date('d/m/Y h:i:s', time()).']#'.$this->get_user_ip().'#'.$msg;
|
|
fwrite($fp, $str.PHP_EOL);
|
|
fclose($fp);
|
|
}
|
|
}
|
|
|
|
public function enableLog($logfile = '')
|
|
{
|
|
$this->logger = true;
|
|
|
|
if ($logfile != '') {
|
|
$this->logfile = $logfile;
|
|
}
|
|
|
|
$this->__log(__METHOD__.' - Log enabled (in '.$this->logfile.' file)');
|
|
}
|
|
|
|
public function disableLog()
|
|
{
|
|
$this->logger = false;
|
|
|
|
$this->__log(__METHOD__.' - Log disabled');
|
|
}
|
|
|
|
/**
|
|
* Remove "../" from path.
|
|
*
|
|
* @param string path to be converted
|
|
* @param bool if dir names should be cleaned
|
|
*
|
|
* @return string or false in case of error (as exception are not used here)
|
|
*/
|
|
public function expandPath($path, $clean = false)
|
|
{
|
|
$todo = explode('/', $path);
|
|
$fullPath = [];
|
|
|
|
foreach ($todo as $dir) {
|
|
if ($dir == '..') {
|
|
$element = array_pop($fullPath);
|
|
if (is_null($element)) {
|
|
return false;
|
|
}
|
|
} else {
|
|
if ($clean) {
|
|
$dir = $this->cleanString($dir);
|
|
}
|
|
array_push($fullPath, $dir);
|
|
}
|
|
}
|
|
|
|
return implode('/', $fullPath);
|
|
}
|
|
}
|