mirror of
https://github.com/Lastorder-DC/rhymix.git
synced 2026-01-03 08:41:39 +09:00
1019 lines
22 KiB
PHP
1019 lines
22 KiB
PHP
<?php
|
|
|
|
namespace Rhymix\Framework;
|
|
|
|
/**
|
|
* The storage class.
|
|
*/
|
|
class Storage
|
|
{
|
|
/**
|
|
* Use atomic rename to overwrite files.
|
|
*/
|
|
public static $safe_overwrite = true;
|
|
|
|
/**
|
|
* Cache the umask here.
|
|
*/
|
|
protected static $_umask;
|
|
|
|
/**
|
|
* Cache the opcache status here.
|
|
*/
|
|
protected static $_opcache;
|
|
|
|
/**
|
|
* Cache locks here.
|
|
*/
|
|
protected static $_locks = array();
|
|
|
|
/**
|
|
* Check if a path really exists.
|
|
*
|
|
* @param string $path
|
|
* @return bool
|
|
*/
|
|
public static function exists(string $path): bool
|
|
{
|
|
$path = rtrim($path, '/\\');
|
|
clearstatcache(true, $path);
|
|
return @file_exists($path);
|
|
}
|
|
|
|
/**
|
|
* Check if the given path is a file.
|
|
*
|
|
* @param string $path
|
|
* @return bool
|
|
*/
|
|
public static function isFile(string $path): bool
|
|
{
|
|
$path = rtrim($path, '/\\');
|
|
return @self::exists($path) && @is_file($path);
|
|
}
|
|
|
|
/**
|
|
* Check if the given path is an empty file.
|
|
*
|
|
* @param string $path
|
|
* @return bool
|
|
*/
|
|
public static function isEmptyFile(string $path): bool
|
|
{
|
|
$path = rtrim($path, '/\\');
|
|
return @self::exists($path) && @is_file($path) && (@filesize($path) == 0);
|
|
}
|
|
|
|
|
|
/**
|
|
* Check if the given path is a directory.
|
|
*
|
|
* @param string $path
|
|
* @return bool
|
|
*/
|
|
public static function isDirectory(string $path): bool
|
|
{
|
|
$path = rtrim($path, '/\\');
|
|
return @self::exists($path) && @is_dir($path);
|
|
}
|
|
|
|
/**
|
|
* Check if the given path is an empty directory.
|
|
*
|
|
* @param string $path
|
|
* @return bool
|
|
*/
|
|
public static function isEmptyDirectory(string $path): bool
|
|
{
|
|
$path = rtrim($path, '/\\');
|
|
if (!self::isDirectory($path))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
$iterator = new \FilesystemIterator($path, \FilesystemIterator::SKIP_DOTS);
|
|
return (iterator_count($iterator)) === 0 ? true : false;
|
|
}
|
|
|
|
/**
|
|
* Check if the given path is a symbolic link.
|
|
*
|
|
* @param string $path
|
|
* @return bool
|
|
*/
|
|
public static function isSymlink(string $path): bool
|
|
{
|
|
$path = rtrim($path, '/\\');
|
|
return @is_link($path);
|
|
}
|
|
|
|
/**
|
|
* Check if the given path is a valid symbolic link.
|
|
*
|
|
* @param string $path
|
|
* @return bool
|
|
*/
|
|
public static function isValidSymlink(string $path): bool
|
|
{
|
|
$path = rtrim($path, '/\\');
|
|
return @is_link($path) && ($target = @readlink($path)) !== false && self::exists($target);
|
|
}
|
|
|
|
/**
|
|
* Check if the given path is readable.
|
|
*
|
|
* @param string $path
|
|
* @return bool
|
|
*/
|
|
public static function isReadable(string $path): bool
|
|
{
|
|
$path = rtrim($path, '/\\');
|
|
return @self::exists($path) && @is_readable($path);
|
|
}
|
|
|
|
/**
|
|
* Check if the given path is writable.
|
|
*
|
|
* @param string $path
|
|
* @return bool
|
|
*/
|
|
public static function isWritable(string $path): bool
|
|
{
|
|
$path = rtrim($path, '/\\');
|
|
return @self::exists($path) && @is_writable($path);
|
|
}
|
|
|
|
/**
|
|
* Check if the given path is executable.
|
|
*
|
|
* @param string $path
|
|
* @return bool
|
|
*/
|
|
public static function isExecutable(string $path): bool
|
|
{
|
|
$path = rtrim($path, '/\\');
|
|
if (function_exists('exec') && !\RX_WINDOWS)
|
|
{
|
|
@exec('/bin/ls -l ' . escapeshellarg($path), $output, $return_var);
|
|
if ($return_var === 0)
|
|
{
|
|
return preg_match('@^[a-z-]{9}x@', array_pop($output)) === 1;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return @self::exists($path) && @is_executable($path);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the size of a file.
|
|
*
|
|
* This method returns the size of a file, or false on error.
|
|
*
|
|
* @param string $filename
|
|
* @return int|false
|
|
*/
|
|
public static function getSize(string $filename)
|
|
{
|
|
$filename = rtrim($filename, '/\\');
|
|
if (self::exists($filename) && @is_file($filename) && @is_readable($filename))
|
|
{
|
|
return @filesize($filename);
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the content of a file.
|
|
*
|
|
* This method returns the content if it exists and is readable.
|
|
* If $stream is true, it will return the content as a stream instead of
|
|
* loading the entire content in memory. This may be useful for large files.
|
|
* If the file cannot be opened, this method returns false.
|
|
*
|
|
* @param string $filename
|
|
* @param bool $stream (optional)
|
|
* @return string|resource|false
|
|
*/
|
|
public static function read(string $filename, bool $stream = false)
|
|
{
|
|
$filename = rtrim($filename, '/\\');
|
|
if (self::exists($filename) && @is_file($filename) && @is_readable($filename))
|
|
{
|
|
if ($stream)
|
|
{
|
|
$result = @fopen($filename, 'r');
|
|
}
|
|
else
|
|
{
|
|
$result = @file_get_contents($filename);
|
|
}
|
|
|
|
if ($result === false)
|
|
{
|
|
trigger_error('Cannot read file: ' . $filename, \E_USER_WARNING);
|
|
}
|
|
return $result;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Read PHP data from a file, formatted for easy retrieval.
|
|
*
|
|
* This method returns the data on success and false on failure.
|
|
*
|
|
* @param string $filename
|
|
* @return mixed
|
|
*/
|
|
public static function readPHPData(string $filename)
|
|
{
|
|
$filename = rtrim($filename, '/\\');
|
|
if (@is_file($filename) && @is_readable($filename))
|
|
{
|
|
return @include $filename;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Write $content to a file.
|
|
*
|
|
* If $content is a stream, this method will copy it to the target file
|
|
* without loading the entire content in memory. This may be useful for large files.
|
|
* This method returns true on success and false on failure.
|
|
*
|
|
* @param string $filename
|
|
* @param string|resource $content
|
|
* @param string $mode (optional)
|
|
* @param ?int $perms (optional)
|
|
* @return string|false
|
|
*/
|
|
public static function write(string $filename, $content, string $mode = 'w', ?int $perms = null)
|
|
{
|
|
$filename = rtrim($filename, '/\\');
|
|
$destination_dir = dirname($filename);
|
|
if (!self::exists($destination_dir))
|
|
{
|
|
$mkdir_success = self::createDirectory($destination_dir);
|
|
if (!$mkdir_success && !self::exists($destination_dir))
|
|
{
|
|
trigger_error('Cannot create directory to write file: ' . $filename, \E_USER_WARNING);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (self::$safe_overwrite && strncasecmp($mode, 'a', 1) && @is_writable($destination_dir))
|
|
{
|
|
$use_atomic_rename = true;
|
|
$original_filename = $filename;
|
|
$filename = $filename . '.tmp.' . microtime(true);
|
|
}
|
|
else
|
|
{
|
|
$use_atomic_rename = false;
|
|
}
|
|
|
|
if ($fp = @fopen($filename, $mode))
|
|
{
|
|
flock($fp, \LOCK_EX);
|
|
if (is_resource($content))
|
|
{
|
|
$result = stream_copy_to_stream($content, $fp);
|
|
}
|
|
else
|
|
{
|
|
$result = fwrite($fp, $content);
|
|
}
|
|
fflush($fp);
|
|
flock($fp, \LOCK_UN);
|
|
fclose($fp);
|
|
|
|
if ($result === false || (is_string($content) && strlen($content) !== $result))
|
|
{
|
|
trigger_error('Cannot write file: ' . (isset($original_filename) ? $original_filename : $filename), \E_USER_WARNING);
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
trigger_error('Cannot write file: ' . (isset($original_filename) ? $original_filename : $filename), \E_USER_WARNING);
|
|
return false;
|
|
}
|
|
|
|
@chmod($filename, ($perms === null ? (0666 & ~self::getUmask()) : $perms));
|
|
|
|
if ($use_atomic_rename)
|
|
{
|
|
$rename_success = @rename($filename, $original_filename);
|
|
if (!$rename_success)
|
|
{
|
|
@unlink($original_filename);
|
|
$rename_success = @rename($filename, $original_filename);
|
|
if (!$rename_success)
|
|
{
|
|
@unlink($filename);
|
|
trigger_error('Cannot write file: ' . (isset($original_filename) ? $original_filename : $filename), \E_USER_WARNING);
|
|
return false;
|
|
}
|
|
}
|
|
$filename = $original_filename;
|
|
}
|
|
|
|
if (self::$_opcache === null)
|
|
{
|
|
self::$_opcache = function_exists('opcache_invalidate');
|
|
}
|
|
if (self::$_opcache && substr($filename, -4) === '.php')
|
|
{
|
|
@opcache_invalidate($filename, true);
|
|
}
|
|
|
|
clearstatcache(true, $filename);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Write PHP data to a file, formatted for easy retrieval.
|
|
*
|
|
* This method returns true on success and false on failure.
|
|
* Resources and anonymous functions cannot be saved.
|
|
*
|
|
* @param string $filename
|
|
* @param mixed $data
|
|
* @param string|null $comment (optional)
|
|
* @param bool $serialize (optional)
|
|
* @return string|false
|
|
*/
|
|
public static function writePHPData(string $filename, $data, ?string $comment = null, bool $serialize = true)
|
|
{
|
|
if ($comment !== null)
|
|
{
|
|
$comment = '/* ' . preg_replace_callback('/[\x00-\x1f\xff*?<>\/\\\\\'"]/', function($match) {
|
|
return rawurlencode($match[0]);
|
|
}, $comment) . " */\n";
|
|
}
|
|
|
|
if ($serialize)
|
|
{
|
|
$content = '<' . '?php ' . $comment . 'return unserialize(' . var_export(serialize($data), true) . ');' . PHP_EOL;
|
|
}
|
|
else
|
|
{
|
|
$content = '<' . '?php ' . $comment . 'return ' . var_export($data, true) . ';' . PHP_EOL;
|
|
}
|
|
|
|
return self::write($filename, $content);
|
|
}
|
|
|
|
/**
|
|
* Copy $source to $destination.
|
|
*
|
|
* This method returns true on success and false on failure.
|
|
* If the destination permissions are not given, they will be copied from the source.
|
|
*
|
|
* @param string $source
|
|
* @param string $destination
|
|
* @param ?int $destination_perms (optional)
|
|
* @return bool
|
|
*/
|
|
public static function copy(string $source, string $destination, ?int $destination_perms = null): bool
|
|
{
|
|
$source = rtrim($source, '/\\');
|
|
$destination = rtrim($destination, '/\\');
|
|
if (!self::exists($source))
|
|
{
|
|
trigger_error('Cannot copy because the source does not exist: ' . $source, \E_USER_WARNING);
|
|
return false;
|
|
}
|
|
|
|
$destination_dir = dirname($destination);
|
|
if (!self::exists($destination_dir) && !self::createDirectory($destination_dir))
|
|
{
|
|
trigger_error('Cannot create directory to copy into: ' . $destination_dir, \E_USER_WARNING);
|
|
return false;
|
|
}
|
|
elseif (self::isDirectory($destination))
|
|
{
|
|
$destination_dir = $destination;
|
|
$destination = $destination . '/' . basename($source);
|
|
}
|
|
|
|
if (self::$safe_overwrite && @is_writable($destination_dir))
|
|
{
|
|
$use_atomic_rename = true;
|
|
$original_destination = $destination;
|
|
$destination = $destination . '.tmp.' . microtime(true);
|
|
}
|
|
else
|
|
{
|
|
$use_atomic_rename = false;
|
|
}
|
|
|
|
$copy_success = @copy($source, $destination);
|
|
if (!$copy_success)
|
|
{
|
|
trigger_error('Cannot copy ' . $source . ' to ' . (isset($original_destination) ? $original_destination : $destination), \E_USER_WARNING);
|
|
return false;
|
|
}
|
|
|
|
if ($destination_perms === null)
|
|
{
|
|
if (is_uploaded_file($source))
|
|
{
|
|
@chmod($destination, 0666 & ~self::getUmask());
|
|
}
|
|
else
|
|
{
|
|
@chmod($destination, 0777 & @fileperms($source));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
@chmod($destination, $destination_perms);
|
|
}
|
|
|
|
if ($use_atomic_rename)
|
|
{
|
|
$rename_success = @rename($destination, $original_destination);
|
|
if (!$rename_success)
|
|
{
|
|
@unlink($original_destination);
|
|
$rename_success = @rename($destination, $original_destination);
|
|
if (!$rename_success)
|
|
{
|
|
@unlink($destination);
|
|
trigger_error('Cannot copy ' . $source . ' to ' . (isset($original_destination) ? $original_destination : $destination), \E_USER_WARNING);
|
|
return false;
|
|
}
|
|
}
|
|
$destination = $original_destination;
|
|
}
|
|
|
|
if (self::$_opcache === null)
|
|
{
|
|
self::$_opcache = function_exists('opcache_invalidate');
|
|
}
|
|
if (self::$_opcache && substr($destination, -4) === '.php')
|
|
{
|
|
@opcache_invalidate($destination, true);
|
|
}
|
|
|
|
clearstatcache(true, $destination);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Move $source to $destination.
|
|
*
|
|
* This method returns true on success and false on failure.
|
|
*
|
|
* @param string $source
|
|
* @param string $destination
|
|
* @return bool
|
|
*/
|
|
public static function move(string $source, string $destination): bool
|
|
{
|
|
$source = rtrim($source, '/\\');
|
|
$destination = rtrim($destination, '/\\');
|
|
if (!self::exists($source))
|
|
{
|
|
trigger_error('Cannot move because the source does not exist: ' . $source, \E_USER_WARNING);
|
|
return false;
|
|
}
|
|
|
|
$destination_dir = dirname($destination);
|
|
if (!self::exists($destination_dir) && !self::createDirectory($destination_dir))
|
|
{
|
|
trigger_error('Cannot create directory to move into: ' . $destination_dir, \E_USER_WARNING);
|
|
return false;
|
|
}
|
|
elseif (self::isDirectory($destination))
|
|
{
|
|
$destination = $destination . '/' . basename($source);
|
|
}
|
|
|
|
$result = @rename($source, $destination);
|
|
if (!$result)
|
|
{
|
|
trigger_error('Cannot move ' . $source . ' to ' . $destination, \E_USER_WARNING);
|
|
return false;
|
|
}
|
|
|
|
if (is_uploaded_file($source))
|
|
{
|
|
@chmod($destination, 0666 & ~self::getUmask());
|
|
}
|
|
|
|
if (self::$_opcache === null)
|
|
{
|
|
self::$_opcache = function_exists('opcache_invalidate');
|
|
}
|
|
if (self::$_opcache)
|
|
{
|
|
if (substr($source, -4) === '.php')
|
|
{
|
|
@opcache_invalidate($source, true);
|
|
}
|
|
if (substr($destination, -4) === '.php')
|
|
{
|
|
@opcache_invalidate($destination, true);
|
|
}
|
|
}
|
|
|
|
clearstatcache(true, $destination);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Move uploaded $source to $destination.
|
|
*
|
|
* This method returns true on success and false on failure.
|
|
*
|
|
* @param string $source
|
|
* @param string $destination
|
|
* @param string $type (optional)
|
|
* @return bool
|
|
*/
|
|
public static function moveUploadedFile(string $source, string $destination, string $type = ''): bool
|
|
{
|
|
if ($type === 'copy')
|
|
{
|
|
if (!self::copy($source, $destination))
|
|
{
|
|
if (!self::copy($source, $destination))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
chmod($destination, 0666 & ~self::getUmask());
|
|
}
|
|
elseif ($type === 'move')
|
|
{
|
|
if (!self::move($source, $destination))
|
|
{
|
|
if (!self::move($source, $destination))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
chmod($destination, 0666 & ~self::getUmask());
|
|
}
|
|
else
|
|
{
|
|
if (!@move_uploaded_file($source, $destination))
|
|
{
|
|
if (!@move_uploaded_file($source, $destination))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Delete a file.
|
|
*
|
|
* This method returns true if the file exists and has been successfully
|
|
* deleted, and false on any kind of failure.
|
|
*
|
|
* @param string $filename
|
|
* @return bool
|
|
*/
|
|
public static function delete(string $filename): bool
|
|
{
|
|
$filename = rtrim($filename, '/\\');
|
|
if (!self::exists($filename))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
$result = @is_file($filename) && @unlink($filename);
|
|
if (!$result)
|
|
{
|
|
trigger_error('Cannot delete file: ' . $filename, \E_USER_WARNING);
|
|
}
|
|
|
|
if (self::$_opcache === null)
|
|
{
|
|
self::$_opcache = function_exists('opcache_invalidate');
|
|
}
|
|
if (self::$_opcache && substr($filename, -4) === '.php')
|
|
{
|
|
@opcache_invalidate($filename, true);
|
|
}
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* Create a directory.
|
|
*
|
|
* @param string $dirname
|
|
* @param ?int $mode
|
|
* @return bool
|
|
*/
|
|
public static function createDirectory(string $dirname, ?int $mode = null): bool
|
|
{
|
|
$dirname = rtrim($dirname, '/\\');
|
|
if ($mode === null)
|
|
{
|
|
$mode = 0777 & ~self::getUmask();
|
|
}
|
|
|
|
$result = @mkdir($dirname, $mode, true);
|
|
if (!$result)
|
|
{
|
|
if (!is_dir($dirname))
|
|
{
|
|
trigger_error('Cannot create directory: ' . $dirname, \E_USER_WARNING);
|
|
}
|
|
else
|
|
{
|
|
@chmod($dirname, $mode);
|
|
}
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Read the list of files in a directory.
|
|
*
|
|
* @param string $dirname
|
|
* @param bool $full_path (optional)
|
|
* @param bool $skip_dotfiles (optional)
|
|
* @param bool $skip_subdirs (optional)
|
|
* @return array|false
|
|
*/
|
|
public static function readDirectory(string $dirname, bool $full_path = true, bool $skip_dotfiles = true, bool $skip_subdirs = true)
|
|
{
|
|
$dirname = rtrim($dirname, '/\\');
|
|
if (!self::isDirectory($dirname))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
try
|
|
{
|
|
$iterator = new \FilesystemIterator($dirname, \FilesystemIterator::CURRENT_AS_PATHNAME | \FilesystemIterator::SKIP_DOTS);
|
|
|
|
$result = array();
|
|
foreach ($iterator as $fileinfo)
|
|
{
|
|
if (!$skip_subdirs || !is_dir($fileinfo))
|
|
{
|
|
$basename = basename($fileinfo);
|
|
if (!$skip_dotfiles || $basename[0] !== '.')
|
|
{
|
|
$result[] = $full_path ? $fileinfo : $basename;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (\UnexpectedValueException $e)
|
|
{
|
|
trigger_error($e->getMessage(), \E_USER_WARNING);
|
|
return false;
|
|
}
|
|
|
|
sort($result);
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* Copy a directory recursively.
|
|
*
|
|
* @param string $source
|
|
* @param string $destination
|
|
* @param string $exclude_regexp (optional)
|
|
* @return bool
|
|
*/
|
|
public static function copyDirectory(string $source, string $destination, string $exclude_regexp = ''): bool
|
|
{
|
|
$source = rtrim($source, '/\\');
|
|
$destination = rtrim($destination, '/\\');
|
|
if (!self::isDirectory($source))
|
|
{
|
|
trigger_error('Cannot copy because the source does not exist: ' . $source, \E_USER_WARNING);
|
|
return false;
|
|
}
|
|
if (!self::isDirectory($destination) && !self::createDirectory($destination))
|
|
{
|
|
trigger_error('Cannot create directory to copy into: ' . $destination, \E_USER_WARNING);
|
|
return false;
|
|
}
|
|
|
|
$rdi_options = \FilesystemIterator::KEY_AS_PATHNAME | \FilesystemIterator::CURRENT_AS_FILEINFO | \FilesystemIterator::SKIP_DOTS;
|
|
$rii_options = \RecursiveIteratorIterator::CHILD_FIRST;
|
|
|
|
try
|
|
{
|
|
$iterator = new \RecursiveIteratorIterator(new \RecursiveDirectoryIterator($source, $rdi_options), $rii_options);
|
|
|
|
foreach ($iterator as $path)
|
|
{
|
|
$path_source = $path->getPathname();
|
|
if (strpos($path_source, $source) !== 0)
|
|
{
|
|
continue;
|
|
}
|
|
if ($exclude_regexp && preg_match($exclude_regexp, $path_source))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
$path_destination = $destination . substr($path_source, strlen($source));
|
|
if ($path->isDir())
|
|
{
|
|
$status = self::isDirectory($path_destination) || self::createDirectory($path_destination, $path->getPerms());
|
|
if (!$status)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$status = self::copy($path_source, $path_destination, $path->getPerms());
|
|
if (!$status)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (\UnexpectedValueException $e)
|
|
{
|
|
trigger_error($e->getMessage(), \E_USER_WARNING);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Move a directory.
|
|
*
|
|
* @param string $source
|
|
* @param string $destination
|
|
* @return bool
|
|
*/
|
|
public static function moveDirectory(string $source, string $destination): bool
|
|
{
|
|
return self::move($source, $destination);
|
|
}
|
|
|
|
/**
|
|
* Delete a directory recursively.
|
|
*
|
|
* @param string $dirname
|
|
* @param bool $delete_self (optional)
|
|
* @return bool
|
|
*/
|
|
public static function deleteDirectory(string $dirname, bool $delete_self = true): bool
|
|
{
|
|
$dirname = rtrim($dirname, '/\\');
|
|
if (!self::exists($dirname))
|
|
{
|
|
return false;
|
|
}
|
|
if (!self::isDirectory($dirname))
|
|
{
|
|
trigger_error('Delete target is not a directory: ' . $dirname, \E_USER_WARNING);
|
|
return false;
|
|
}
|
|
|
|
$rdi_options = \FilesystemIterator::KEY_AS_PATHNAME | \FilesystemIterator::CURRENT_AS_FILEINFO | \FilesystemIterator::SKIP_DOTS;
|
|
$rii_options = \RecursiveIteratorIterator::CHILD_FIRST;
|
|
$iterator = new \RecursiveIteratorIterator(new \RecursiveDirectoryIterator($dirname, $rdi_options), $rii_options);
|
|
|
|
foreach ($iterator as $path)
|
|
{
|
|
if ($path->isDir())
|
|
{
|
|
if (!@rmdir($path->getPathname()))
|
|
{
|
|
trigger_error('Cannot delete directory: ' . $path->getPathname(), \E_USER_WARNING);
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (!@unlink($path->getPathname()))
|
|
{
|
|
trigger_error('Cannot delete file: ' . $path->getPathname(), \E_USER_WARNING);
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ($delete_self)
|
|
{
|
|
$result = @rmdir($dirname);
|
|
if (!$result)
|
|
{
|
|
trigger_error('Cannot delete directory: ' . $dirname, \E_USER_WARNING);
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Delete a directory only if it is empty.
|
|
*
|
|
* @param string $dirname
|
|
* @param bool $delete_empty_parents (optional)
|
|
* @return bool
|
|
*/
|
|
public static function deleteEmptyDirectory(string $dirname, bool $delete_empty_parents = false): bool
|
|
{
|
|
$dirname = rtrim($dirname, '/\\');
|
|
if (!self::isDirectory($dirname) || !self::isEmptyDirectory($dirname))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
$result = @rmdir($dirname);
|
|
if (!$result)
|
|
{
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
if ($delete_empty_parents)
|
|
{
|
|
self::deleteEmptyDirectory(dirname($dirname), true);
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the current umask.
|
|
*
|
|
* @return int
|
|
*/
|
|
public static function getUmask(): int
|
|
{
|
|
if (self::$_umask === null)
|
|
{
|
|
self::$_umask = intval(config('file.umask'), 8) ?: 0;
|
|
}
|
|
return self::$_umask;
|
|
}
|
|
|
|
/**
|
|
* Set the current umask.
|
|
*
|
|
* @param int $umask
|
|
* @return void
|
|
*/
|
|
public static function setUmask(int $umask): void
|
|
{
|
|
self::$_umask = $umask;
|
|
}
|
|
|
|
/**
|
|
* Determine the best umask for this installation of Rhymix.
|
|
*
|
|
* @return string
|
|
*/
|
|
public static function recommendUmask(): string
|
|
{
|
|
// On Windows, set the umask to 0000.
|
|
if (\RX_WINDOWS)
|
|
{
|
|
return '0000';
|
|
}
|
|
|
|
// Get the UID of the owner of the current file.
|
|
$file_uid = fileowner(__FILE__);
|
|
|
|
// Get the UID of the current PHP process.
|
|
$php_uid = self::getServerUID();
|
|
|
|
// If both UIDs are the same, set the umask to 0022.
|
|
if ($file_uid == $php_uid)
|
|
{
|
|
return '0022';
|
|
}
|
|
|
|
// Otherwise, set the umask to 0000.
|
|
else
|
|
{
|
|
return '0000';
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the UID of the server process.
|
|
*
|
|
* @return int|false
|
|
*/
|
|
public static function getServerUID()
|
|
{
|
|
if (function_exists('posix_geteuid'))
|
|
{
|
|
return posix_geteuid();
|
|
}
|
|
else
|
|
{
|
|
$testfile = \RX_BASEDIR . 'files/cache/uidcheck_' . time();
|
|
if (self::exists($testfile))
|
|
{
|
|
self::delete($testfile);
|
|
}
|
|
|
|
if (self::write($testfile, 'TEST'))
|
|
{
|
|
$uid = fileowner($testfile);
|
|
self::delete($testfile);
|
|
return $uid;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Obtain an exclusive lock.
|
|
*
|
|
* @param string $name
|
|
* @return bool
|
|
*/
|
|
public static function getLock(string $name): bool
|
|
{
|
|
$name = str_replace('.', '%2E', rawurlencode($name));
|
|
if (isset(self::$_locks[$name]))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
$lockdir = \RX_BASEDIR . 'files/locks';
|
|
if (!self::isDirectory($lockdir) && !self::createDirectory($lockdir))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
self::$_locks[$name] = @fopen($lockdir . '/' . $name . '.lock', 'w');
|
|
if (!self::$_locks[$name])
|
|
{
|
|
unset(self::$_locks[$name]);
|
|
return false;
|
|
}
|
|
|
|
$result = @flock(self::$_locks[$name], \LOCK_EX | \LOCK_NB);
|
|
if (!$result)
|
|
{
|
|
@fclose(self::$_locks[$name]);
|
|
unset(self::$_locks[$name]);
|
|
return false;
|
|
}
|
|
|
|
register_shutdown_function('\\Rhymix\\Framework\\Storage::clearLocks');
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Clear all locks.
|
|
*
|
|
* @return void
|
|
*/
|
|
public static function clearLocks(): void
|
|
{
|
|
foreach (self::$_locks as $name => $lock)
|
|
{
|
|
@flock($lock, \LOCK_UN);
|
|
@fclose($lock);
|
|
@unlink(\RX_BASEDIR . 'files/locks/' . $name . '.lock');
|
|
unset(self::$_locks[$name]);
|
|
}
|
|
}
|
|
}
|