500 Zeilen
16 KiB
PHP
500 Zeilen
16 KiB
PHP
<?php
|
|
/**
|
|
* This file contains the the static file handler class.
|
|
*
|
|
* @package Core
|
|
* @subpackage cClasses
|
|
* @version $Rev$
|
|
*
|
|
* @author Mischa Holz
|
|
* @copyright four for business AG <www.4fb.de>
|
|
* @license http://www.contenido.org/license/LIZENZ.txt
|
|
* @link http://www.4fb.de
|
|
* @link http://www.contenido.org
|
|
*/
|
|
defined('CON_FRAMEWORK') || die('Illegal call: Missing framework initialization - request aborted.');
|
|
|
|
/**
|
|
* Class for file handling.
|
|
* Provides functions for dealing with files.
|
|
*
|
|
* @package Core
|
|
* @subpackage Util
|
|
*/
|
|
class cFileHandler {
|
|
|
|
/**
|
|
* Creates a new file
|
|
*
|
|
* @param string $filename
|
|
* the name and path of the new file
|
|
* @param string $content [optional]
|
|
* content of the new file
|
|
* @return bool
|
|
* true on success. Otherwise false.
|
|
*/
|
|
public static function create($filename, $content = '') {
|
|
$success = file_put_contents($filename, $content) === strlen($content);
|
|
if ($success) {
|
|
self::setDefaultFilePerms($filename);
|
|
}
|
|
|
|
return $success;
|
|
}
|
|
|
|
/**
|
|
* Reads bytes from a file
|
|
*
|
|
* @param string $filename
|
|
* the name and path of the file
|
|
* @param int $length [optional]
|
|
* the number of bytes to read.
|
|
* @param int $offset [optional]
|
|
* this will be the first byte which is read.
|
|
* @param bool $reverse [optional]
|
|
* if true, the function will start from the back of the file.
|
|
* @throws cInvalidArgumentException
|
|
* if the file with the given filename does not exist
|
|
* @return string|bool
|
|
* On success it returns the bytes which have been read.
|
|
* Otherwise false.
|
|
*/
|
|
public static function read($filename, $length = 0, $offset = 0, $reverse = false) {
|
|
if (!cFileHandler::exists($filename)) {
|
|
throw new cInvalidArgumentException('The file ' . $filename . ' could not be accessed because it does not exist.');
|
|
}
|
|
|
|
if ($reverse) {
|
|
return file_get_contents($filename, false, NULL, filesize($filename) - $length - $offset, $length);
|
|
} else if ($length > 0 && $offset == 0) {
|
|
return file_get_contents($filename, false, NULL, 0, $length);
|
|
} else if ($offset > 0 && $length == 0) {
|
|
return file_get_contents($filename, false, NULL, $offset);
|
|
} else if ($offset > 0 && $length > 0) {
|
|
return file_get_contents($filename, false, NULL, $offset, $length);
|
|
} else {
|
|
return file_get_contents($filename);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Reads a file line by line
|
|
*
|
|
* @param string $filename
|
|
* the name and path of the file
|
|
* @param int $lines [optional]
|
|
* the number of lines to be read.
|
|
* @param int $lineoffset [optional]
|
|
* this will be the first line which is read.
|
|
* @throws cInvalidArgumentException
|
|
* if the file with the given filename does not exist
|
|
* @return string|array|bool
|
|
* If one line was read the function will return it.
|
|
* If more than one line was read the function will return an array
|
|
* containing the lines. Otherwise false is returned
|
|
*/
|
|
public static function readLine($filename, $lines = 0, $lineoffset = 0) {
|
|
if (!cFileHandler::exists($filename)) {
|
|
throw new cInvalidArgumentException('The file ' . $filename . ' could not be accessed because it does not exist.');
|
|
}
|
|
|
|
$f = fopen($filename, 'r');
|
|
|
|
if ($f === false) {
|
|
fclose($f);
|
|
return false;
|
|
}
|
|
if ($lines == 0) {
|
|
$lines = 1;
|
|
}
|
|
|
|
for ($i = 0; $i < $lineoffset; $i++) {
|
|
$waste = fgets($f);
|
|
}
|
|
|
|
$ret = NULL;
|
|
if ($lines > 1) {
|
|
$ret = array();
|
|
for ($i = 0; $i < $lines; $i++) {
|
|
$temp = fgets($f);
|
|
if ($temp === false) {
|
|
fclose($f);
|
|
return false;
|
|
}
|
|
$ret[] = substr($temp, 0, strlen($temp) - 1);
|
|
}
|
|
} else {
|
|
$ret = fgets($f);
|
|
$ret = substr($ret, 0, strlen($ret) - 1);
|
|
}
|
|
|
|
fclose($f);
|
|
return $ret;
|
|
}
|
|
|
|
/**
|
|
* Writes data to a file
|
|
*
|
|
* @param string $filename
|
|
* the name and path of the file
|
|
* @param string $content
|
|
* the data which should be written
|
|
* @param bool $append [optional]
|
|
* if true the data will be appended to the file.
|
|
* @return bool
|
|
* true on success, false otherwise
|
|
*/
|
|
public static function write($filename, $content, $append = false) {
|
|
$flag = 0;
|
|
if ($append && self::exists($filename)) {
|
|
$flag = FILE_APPEND;
|
|
}
|
|
|
|
$success = file_put_contents($filename, $content, $flag);
|
|
if ((int) $success != 0) {
|
|
self::setDefaultFilePerms($filename);
|
|
}
|
|
|
|
return !($success === false);
|
|
}
|
|
|
|
/**
|
|
* Writes a line to a file (this is similar to
|
|
* cFileHandler::write($filename, $data."\n", $apppend)
|
|
*
|
|
* @see cFileHandler::write($filename, $content, $append)
|
|
* @param string $filename
|
|
* the name and path to the file
|
|
* @param string $content
|
|
* the data of the line
|
|
* @param bool $append [optional]
|
|
* if true the data will be appended to file.
|
|
* @return bool
|
|
* true on success, false otherwise
|
|
*/
|
|
public static function writeLine($filename, $content, $append = false) {
|
|
return self::write($filename, $content . "\n", $append);
|
|
}
|
|
|
|
/**
|
|
* Checks if a file exists
|
|
*
|
|
* @param string $filename
|
|
* the name and path of the file
|
|
* @return bool
|
|
* true if the file exists
|
|
*/
|
|
public static function exists($filename) {
|
|
return file_exists($filename);
|
|
}
|
|
|
|
/**
|
|
* Checks if the file is writable for the PHP user
|
|
*
|
|
* @param string $filename
|
|
* the name and path of the file
|
|
* @return bool
|
|
* true if the file can be written
|
|
*/
|
|
public static function writeable($filename) {
|
|
return is_writable($filename);
|
|
}
|
|
|
|
/**
|
|
* Checks if a file is readable for the PHP user
|
|
*
|
|
* @param string $filename
|
|
* the name and path of the file
|
|
* @throws cInvalidArgumentException
|
|
* if the file with the given filename does not exist
|
|
* @return bool
|
|
* true if the file is readable
|
|
*/
|
|
public static function readable($filename) {
|
|
if (!cFileHandler::exists($filename)) {
|
|
throw new cInvalidArgumentException('The file ' . $filename . ' could not be accessed because it does not exist.');
|
|
}
|
|
|
|
return is_readable($filename);
|
|
}
|
|
|
|
/**
|
|
* Removes a file from the filesystem
|
|
*
|
|
* @param string $filename
|
|
* the name and path of the file
|
|
* @throws cInvalidArgumentException
|
|
* if the file with the given filename does not exist
|
|
* @return bool
|
|
* true on success
|
|
*/
|
|
public static function remove($filename) {
|
|
if (!cFileHandler::exists($filename)) {
|
|
throw new cInvalidArgumentException('The file ' . $filename . ' could not be accessed because it does not exist.');
|
|
}
|
|
|
|
return unlink($filename);
|
|
}
|
|
|
|
/**
|
|
* Truncates a file so that it is empty
|
|
*
|
|
* @param string $filename
|
|
* the name and path of the file
|
|
* @throws cInvalidArgumentException
|
|
* if the file with the given filename does not exist
|
|
* @return bool
|
|
* true on success
|
|
*/
|
|
public static function truncate($filename) {
|
|
if (!cFileHandler::exists($filename)) {
|
|
throw new cInvalidArgumentException('The file ' . $filename . ' could not be accessed because it does not exist.');
|
|
}
|
|
$success = file_put_contents($filename, '') === 0;
|
|
if ($success) {
|
|
self::setDefaultFilePerms($filename);
|
|
}
|
|
|
|
return $success;
|
|
}
|
|
|
|
/**
|
|
* Moves a file
|
|
*
|
|
* @param string $filename
|
|
* the name of the source file
|
|
* @param string $destination
|
|
* the destination. Note that the file can also be renamed in the
|
|
* process of moving it
|
|
* @throws cInvalidArgumentException
|
|
* if the file with the given filename does not exist
|
|
* @return bool
|
|
* true on success
|
|
*/
|
|
public static function move($filename, $destination) {
|
|
if (!cFileHandler::exists($filename)) {
|
|
throw new cInvalidArgumentException('The file ' . $filename . ' could not be accessed because it does not exist.');
|
|
}
|
|
$success = rename($filename, $destination);
|
|
if ($success) {
|
|
self::setDefaultFilePerms($destination);
|
|
}
|
|
|
|
return $success;
|
|
}
|
|
|
|
/**
|
|
* Renames a file
|
|
*
|
|
* @param string $filename
|
|
* the name and path of the file
|
|
* @param string $new_filename
|
|
* the new name of the file
|
|
* @throws cInvalidArgumentException
|
|
* if the file with the given filename does not exist
|
|
* @return bool
|
|
* true on success
|
|
*/
|
|
public static function rename($filename, $new_filename) {
|
|
if (!cFileHandler::exists($filename)) {
|
|
throw new cInvalidArgumentException('The file ' . $filename . ' could not be accessed because it does not exist.');
|
|
}
|
|
$success = rename($filename, dirname($filename) . '/' . $new_filename);
|
|
if ($success) {
|
|
self::setDefaultFilePerms(dirname($filename) . '/' . $new_filename);
|
|
}
|
|
|
|
return $success;
|
|
}
|
|
|
|
/**
|
|
* Copies a file
|
|
*
|
|
* @param string $filename
|
|
* the name and path of the file
|
|
* @param string $destination
|
|
* the destination. Note that existing files get overwritten
|
|
* @throws cInvalidArgumentException
|
|
* if the file with the given filename does not exist
|
|
* @return bool
|
|
* true on success
|
|
*/
|
|
public static function copy($filename, $destination) {
|
|
if (!cFileHandler::exists($filename)) {
|
|
throw new cInvalidArgumentException('The file ' . $filename . ' could not be accessed because it does not exist.');
|
|
}
|
|
$success = copy($filename, $destination);
|
|
if ($success) {
|
|
self::setDefaultFilePerms($destination);
|
|
}
|
|
|
|
return $success;
|
|
}
|
|
|
|
/**
|
|
* Changes the file permissions
|
|
*
|
|
* @param string $filename
|
|
* the name and path of the file
|
|
* @param int $mode
|
|
* the new access mode : php chmod needs octal value
|
|
* @throws cInvalidArgumentException
|
|
* if the file with the given filename does not exist
|
|
* @return bool
|
|
* true on success
|
|
*/
|
|
public static function chmod($filename, $mode) {
|
|
if (!cFileHandler::exists($filename)) {
|
|
throw new cInvalidArgumentException('The file ' . $filename . ' could not be accessed because it does not exist.');
|
|
}
|
|
// chmod needs octal value for correct execution.
|
|
$mode = intval($mode, 8);
|
|
return chmod($filename, $mode);
|
|
}
|
|
|
|
/**
|
|
* Returns an array containing information about the file.
|
|
* Currently
|
|
* following elements are in it: 'size' - the file size (in byte) 'atime' -
|
|
* the time the file was last accessed (unix timestamp) 'ctime' - time the
|
|
* file was created (unix timestamp) 'mtime' - time the file was last
|
|
* modified (unix timestamp) 'perms' - permissions of the file represented
|
|
* in 4 octal digits 'extension' - the file extension or '' if there's no
|
|
* extension 'mime' - the mime type of the file
|
|
*
|
|
* @param string $filename
|
|
* the name and path to the file
|
|
* @throws cInvalidArgumentException
|
|
* if the file with the given filename does not exist
|
|
* @return array
|
|
* Returns an array containing information about the file
|
|
*/
|
|
public static function info($filename) {
|
|
if (!cFileHandler::exists($filename)) {
|
|
throw new cInvalidArgumentException('The file ' . $filename . ' could not be accessed because it does not exist.');
|
|
}
|
|
|
|
$ret = array();
|
|
|
|
$ret['size'] = @filesize($filename);
|
|
$ret['atime'] = @fileatime($filename);
|
|
$ret['ctime'] = @filectime($filename);
|
|
$ret['mtime'] = @filemtime($filename);
|
|
|
|
$temp = @decoct(fileperms($filename));
|
|
$ret['perms'] = substr($temp, strlen($temp) - 4);
|
|
|
|
$ret['extension'] = substr(basename($filename), (int) strrpos(basename($filename), '.') + 1);
|
|
if ($ret['extension'] == basename($filename)) {
|
|
$ret['extension'] = '';
|
|
}
|
|
|
|
if (version_compare(PHP_VERSION, '5.3', '<') && function_exists('mime_content_type')) {
|
|
// function is deprecated in PHP 5.3
|
|
$ret['mime'] = @mime_content_type($filename);
|
|
} else if (function_exists('finfo_open')) {
|
|
// extension has to be installed seperately in versions prior to 5.3
|
|
$finfo = @finfo_open(FILEINFO_MIME_TYPE);
|
|
$ret['mime'] = @finfo_file($finfo, $filename);
|
|
} else {
|
|
$ret['mime'] = '';
|
|
}
|
|
|
|
return $ret;
|
|
}
|
|
|
|
/**
|
|
* Returns the extension of passed filename
|
|
*
|
|
* @param string $basename
|
|
* @return string
|
|
*/
|
|
public static function getExtension($basename) {
|
|
return pathinfo($basename, PATHINFO_EXTENSION);
|
|
}
|
|
|
|
/**
|
|
* Sets the default file permissions on the given file.
|
|
*
|
|
* @param string $filename
|
|
* the name of the file
|
|
* @return bool
|
|
* true on success or false on failure
|
|
*/
|
|
public static function setDefaultFilePerms($filename) {
|
|
$cfg = cRegistry::getConfig();
|
|
|
|
if (isset($cfg['default_perms']['file']) === false) {
|
|
return false;
|
|
}
|
|
|
|
$filePerms = $cfg['default_perms']['file'];
|
|
return cFileHandler::chmod($filename, $filePerms);
|
|
}
|
|
|
|
/**
|
|
* Validates the given filename.
|
|
*
|
|
* @param string $filename
|
|
* the filename to validate
|
|
* @param bool $notifyAndExitOnFailure [optional]
|
|
* if set, function will show a notification and will exit the script
|
|
* @return bool
|
|
* true if the given filename is valid, false otherwise
|
|
*/
|
|
public static function validateFilename($filename, $notifyAndExitOnFailure = true) {
|
|
|
|
$notification = new Contenido_Notification();
|
|
// check if filename only contains valid characters
|
|
if (preg_match('/[^a-z0-9._-]/i', $filename)) {
|
|
// validation failure...
|
|
if ($notifyAndExitOnFailure) {
|
|
$notification->displayNotification("error", i18n("Please insert file name."));
|
|
exit();
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// check if filename is empty
|
|
if (strlen(trim($filename)) == 0) {
|
|
// validation failure...
|
|
if ($notifyAndExitOnFailure) {
|
|
// display notification and exit
|
|
$notification->displayNotification("error", i18n("Please insert file name."));
|
|
exit();
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Check if given filename is either '.' or '..'.
|
|
*
|
|
* @param string $fileName
|
|
* @return bool
|
|
*/
|
|
public static function fileNameIsDot($fileName) {
|
|
// bugfix: function must work with full paths of files
|
|
$name = end(explode('/', $fileName));
|
|
if ($name != '.' && $name != '..') {
|
|
return false;
|
|
} else {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Check if file name begins with a period.
|
|
*
|
|
* @param string $fileName
|
|
* @return bool
|
|
*/
|
|
public static function fileNameBeginsWithDot($fileName) {
|
|
return strpos(end(explode('/', $fileName)), ".") === 0;
|
|
}
|
|
}
|