Your IP : 216.73.216.81
<?php
declare(strict_types=1);
namespace Laminas\Filter\File;
use Laminas\Filter\AbstractFilter;
use Laminas\Filter\Exception;
use Laminas\Stdlib\ErrorHandler;
use Psr\Http\Message\StreamFactoryInterface;
use Psr\Http\Message\UploadedFileFactoryInterface;
use Psr\Http\Message\UploadedFileInterface;
use function basename;
use function file_exists;
use function filesize;
use function is_array;
use function is_dir;
use function is_string;
use function move_uploaded_file;
use function pathinfo;
use function spl_object_hash;
use function sprintf;
use function str_replace;
use function strlen;
use function uniqid;
use function unlink;
use const DIRECTORY_SEPARATOR;
use const UPLOAD_ERR_OK;
/**
* @psalm-type Options = array{
* target: string|null,
* use_upload_name: bool,
* use_upload_extension: bool,
* overwrite: bool,
* randomize: bool,
* stream_factory: StreamFactoryInterface|null,
* upload_file_factory: UploadedFileFactoryInterface|null,
* ...
* }
* @template TOptions of Options
* @extends AbstractFilter<TOptions>
*/
class RenameUpload extends AbstractFilter
{
/** @var TOptions */
protected $options = [
'target' => null,
'use_upload_name' => false,
'use_upload_extension' => false,
'overwrite' => false,
'randomize' => false,
'stream_factory' => null,
'upload_file_factory' => null,
];
/**
* Store already filtered values, so we can filter multiple
* times the same file without being block by move_uploaded_file
* internal checks
*
* @var array
*/
protected $alreadyFiltered = [];
/**
* Constructor
*
* @param array|string $targetOrOptions The target file path or an options array
*/
public function __construct($targetOrOptions = [])
{
if (is_array($targetOrOptions)) {
$this->setOptions($targetOrOptions);
} else {
$this->setTarget($targetOrOptions);
}
}
/**
* @param StreamFactoryInterface $factory Factory to use to produce a PSR-7
* stream with which to seed a PSR-7 UploadedFileInterface.
* @return self
*/
public function setStreamFactory(StreamFactoryInterface $factory)
{
$this->options['stream_factory'] = $factory;
return $this;
}
/**
* @return null|StreamFactoryInterface
*/
public function getStreamFactory()
{
return $this->options['stream_factory'];
}
/**
* @param string $target Target file path or directory
* @return self
*/
public function setTarget($target)
{
if (! is_string($target)) {
throw new Exception\InvalidArgumentException(
'Invalid target, must be a string'
);
}
$this->options['target'] = $target;
return $this;
}
/**
* @return string Target file path or directory
*/
public function getTarget()
{
return $this->options['target'];
}
/**
* @param UploadedFileFactoryInterface $factory Factory to use to produce
* filtered PSR-7 UploadedFileInterface instances.
* @return self
*/
public function setUploadFileFactory(UploadedFileFactoryInterface $factory)
{
$this->options['upload_file_factory'] = $factory;
return $this;
}
/**
* @return null|UploadedFileFactoryInterface
*/
public function getUploadFileFactory()
{
return $this->options['upload_file_factory'];
}
/**
* @param bool $flag When true, this filter will use the $_FILES['name']
* as the target filename.
* Otherwise, it uses the default 'target' rules.
* @return self
*/
public function setUseUploadName($flag = true)
{
$this->options['use_upload_name'] = (bool) $flag;
return $this;
}
/**
* @return bool
*/
public function getUseUploadName()
{
return $this->options['use_upload_name'];
}
/**
* @param bool $flag When true, this filter will use the original file
* extension for the target filename
* @return self
*/
public function setUseUploadExtension($flag = true)
{
$this->options['use_upload_extension'] = (bool) $flag;
return $this;
}
/**
* @return bool
*/
public function getUseUploadExtension()
{
return $this->options['use_upload_extension'];
}
/**
* @param bool $flag Shall existing files be overwritten?
* @return self
*/
public function setOverwrite($flag = true)
{
$this->options['overwrite'] = (bool) $flag;
return $this;
}
/**
* @return bool
*/
public function getOverwrite()
{
return $this->options['overwrite'];
}
/**
* @param bool $flag Shall target files have a random postfix attached?
* @return self
*/
public function setRandomize($flag = true)
{
$this->options['randomize'] = (bool) $flag;
return $this;
}
/**
* @return bool
*/
public function getRandomize()
{
return $this->options['randomize'];
}
/**
* Defined by Laminas\Filter\Filter
*
* Renames the file $value to the new name set before
* Returns the file $value, removing all but digit characters
*
* @param string|array|UploadedFileInterface $value Full path of file to
* change; $_FILES data array; or UploadedFileInterface instance.
* @return string|array|UploadedFileInterface Returns one of the following:
* - New filename, for string $value
* - Array with tmp_name and name keys for array $value
* - UploadedFileInterface for UploadedFileInterface $value
* @throws Exception\RuntimeException
*/
public function filter($value)
{
// PSR-7 uploaded file
if ($value instanceof UploadedFileInterface) {
return $this->filterPsr7UploadedFile($value);
}
// File upload via traditional SAPI
if (is_array($value) && isset($value['tmp_name'])) {
return $this->filterSapiUploadedFile($value);
}
// String filename
if (is_string($value)) {
return $this->filterStringFilename($value);
}
// Unrecognized; return verbatim
return $value;
}
/**
* @param string $sourceFile Source file path
* @param string $targetFile Target file path
* @throws Exception\RuntimeException
* @return bool
*/
protected function moveUploadedFile($sourceFile, $targetFile)
{
ErrorHandler::start();
$result = move_uploaded_file($sourceFile, $targetFile);
$warningException = ErrorHandler::stop();
if (! $result || null !== $warningException) {
throw new Exception\RuntimeException(
sprintf("File '%s' could not be renamed. An error occurred while processing the file.", $sourceFile),
0,
$warningException
);
}
return $result;
}
/**
* @param string $targetFile Target file path
* @return void
* @throws Exception\InvalidArgumentException
*/
protected function checkFileExists($targetFile)
{
if (! file_exists($targetFile)) {
return;
}
if (! $this->getOverwrite()) {
throw new Exception\InvalidArgumentException(
sprintf("File '%s' could not be renamed. It already exists.", $targetFile)
);
}
unlink($targetFile);
}
/**
* @param string $source
* @param string|null $clientFileName
* @return string
*/
protected function getFinalTarget($source, $clientFileName)
{
$target = $this->getTarget();
if ($target === null || $target === '*') {
$target = $source;
}
// Get the target directory
if (is_dir($target)) {
$targetDir = $target;
$last = $target[strlen($target) - 1];
if (($last !== '/') && ($last !== '\\')) {
$targetDir .= DIRECTORY_SEPARATOR;
}
} else {
$info = pathinfo($target);
$targetDir = $info['dirname'] . DIRECTORY_SEPARATOR;
}
// Get the target filename
if ($this->getUseUploadName()) {
$targetFile = basename($clientFileName);
} elseif (! is_dir($target)) {
$targetFile = basename($target);
if ($this->getUseUploadExtension() && ! $this->getRandomize()) {
$targetInfo = pathinfo($targetFile);
$sourceinfo = pathinfo($clientFileName);
if (isset($sourceinfo['extension'])) {
$targetFile = $targetInfo['filename'] . '.' . $sourceinfo['extension'];
}
}
} else {
$targetFile = basename($source);
}
if ($this->getRandomize()) {
$targetFile = $this->applyRandomToFilename($clientFileName, $targetFile);
}
return $targetDir . $targetFile;
}
/**
* @param string $source
* @param string $filename
* @return string
*/
protected function applyRandomToFilename($source, $filename)
{
$info = pathinfo($filename);
$filename = $info['filename'] . str_replace('.', '_', uniqid('_', true));
$sourceinfo = pathinfo($source);
$extension = '';
if ($this->getUseUploadExtension() === true && isset($sourceinfo['extension'])) {
$extension .= '.' . $sourceinfo['extension'];
} elseif (isset($info['extension'])) {
$extension .= '.' . $info['extension'];
}
return $filename . $extension;
}
/**
* @param string $fileName
* @return string
*/
private function filterStringFilename($fileName)
{
if (isset($this->alreadyFiltered[$fileName])) {
return $this->alreadyFiltered[$fileName];
}
$targetFile = $this->getFinalTarget($fileName, $fileName);
if ($fileName === $targetFile || ! file_exists($fileName)) {
return $fileName;
}
$this->checkFileExists($targetFile);
$this->moveUploadedFile($fileName, $targetFile);
$this->alreadyFiltered[$fileName] = $targetFile;
return $this->alreadyFiltered[$fileName];
}
/**
* @param array<string, mixed> $fileData
* @return array<string, string>
*/
private function filterSapiUploadedFile(array $fileData)
{
$sourceFile = $fileData['tmp_name'];
if (isset($this->alreadyFiltered[$sourceFile])) {
return $this->alreadyFiltered[$sourceFile];
}
$clientFilename = $fileData['name'];
$targetFile = $this->getFinalTarget($sourceFile, $clientFilename);
if ($sourceFile === $targetFile || ! file_exists($sourceFile)) {
return $fileData;
}
$this->checkFileExists($targetFile);
$this->moveUploadedFile($sourceFile, $targetFile);
$this->alreadyFiltered[$sourceFile] = $fileData;
$this->alreadyFiltered[$sourceFile]['tmp_name'] = $targetFile;
return $this->alreadyFiltered[$sourceFile];
}
/**
* @return UploadedFileInterface
* @throws Exception\RuntimeException If no stream factory is composed in the filter.
* @throws Exception\RuntimeException If no uploaded file factory is composed in the filter.
*/
private function filterPsr7UploadedFile(UploadedFileInterface $uploadedFile)
{
$alreadyFilteredKey = spl_object_hash($uploadedFile);
if (isset($this->alreadyFiltered[$alreadyFilteredKey])) {
return $this->alreadyFiltered[$alreadyFilteredKey];
}
$sourceFile = $uploadedFile->getStream()->getMetadata('uri');
$clientFilename = $uploadedFile->getClientFilename();
$targetFile = $this->getFinalTarget($sourceFile, $clientFilename);
if ($sourceFile === $targetFile || ! file_exists($sourceFile)) {
return $uploadedFile;
}
$this->checkFileExists($targetFile);
$uploadedFile->moveTo($targetFile);
$streamFactory = $this->getStreamFactory();
if (! $streamFactory) {
throw new Exception\RuntimeException(sprintf(
'No PSR-17 %s present; cannot filter file. Please pass the stream_factory'
. ' option with a %s instance when creating the filter for use with PSR-7.',
StreamFactoryInterface::class,
StreamFactoryInterface::class
));
}
$stream = $streamFactory->createStreamFromFile($targetFile);
$uploadedFileFactory = $this->getUploadFileFactory();
if (! $uploadedFileFactory) {
throw new Exception\RuntimeException(sprintf(
'No PSR-17 %s present; cannot filter file. Please pass the upload_file_factory'
. ' option with a %s instance when creating the filter for use with PSR-7.',
UploadedFileFactoryInterface::class,
UploadedFileFactoryInterface::class
));
}
$this->alreadyFiltered[$alreadyFilteredKey] = $uploadedFileFactory->createUploadedFile(
$stream,
filesize($targetFile),
UPLOAD_ERR_OK,
$uploadedFile->getClientFilename(),
$uploadedFile->getClientMediaType()
);
return $this->alreadyFiltered[$alreadyFilteredKey];
}
}