Your IP : 18.118.198.47
<?php
namespace Bitrix\UI\FileUploader;
use Bitrix\Main\Error;
use Bitrix\Main\File;
use Bitrix\Main\HttpRequest;
use Bitrix\Main\IO;
use Bitrix\Main\Result;
use Bitrix\Main\Text\Encoding;
class Chunk
{
protected int $size = 0;
protected ?int $fileSize = null;
protected ?int $startRange = null;
protected ?int $endRange = null;
protected string $type = '';
protected string $name = '';
protected int $width = 0;
protected int $height = 0;
protected IO\File $file;
protected function __construct(IO\File $file)
{
$this->setFile($file);
}
public static function createFromRequest(HttpRequest $request): Result
{
$result = new Result();
$fileMimeType = (string)$request->getHeader('Content-Type');
if (!preg_match('~\w+/[-+.\w]+~', $fileMimeType))
{
return $result->addError(new UploaderError(UploaderError::INVALID_CONTENT_TYPE));
}
$contentLength = $request->getHeader('Content-Length');
if ($contentLength === null)
{
return $result->addError(new UploaderError(UploaderError::INVALID_CONTENT_LENGTH));
}
$contentLength = (int)$contentLength;
$filename = static::normalizeFilename((string)$request->getHeader('X-Upload-Content-Name'));
if (empty($filename))
{
return $result->addError(new UploaderError(UploaderError::INVALID_CONTENT_NAME));
}
if (!static::isValidFilename($filename))
{
return $result->addError(new UploaderError(UploaderError::INVALID_FILENAME));
}
$contentRangeResult = static::getContentRange($request);
if (!$contentRangeResult->isSuccess())
{
return $result->addErrors($contentRangeResult->getErrors());
}
$file = static::getFileFromHttpInput();
$contentRange = $contentRangeResult->getData();
$rangeChunkSize = empty($contentRange) ? 0 : ($contentRange['endRange'] - $contentRange['startRange'] + 1);
if ($rangeChunkSize && $contentLength !== $rangeChunkSize)
{
return $result->addError(new UploaderError(
UploaderError::INVALID_RANGE_SIZE,
[
'rangeChunkSize' => $rangeChunkSize,
'contentLength' => $contentLength,
]
));
}
$chunk = new Chunk($file);
if ($chunk->getSize() !== $contentLength)
{
return $result->addError(new UploaderError(
UploaderError::INVALID_CHUNK_SIZE,
[
'chunkSize' => $chunk->getSize(),
'contentLength' => $contentLength,
]
));
}
$chunk->setName($filename);
$chunk->setType($fileMimeType);
if (!empty($contentRange))
{
$chunk->setStartRange($contentRange['startRange']);
$chunk->setEndRange($contentRange['endRange']);
$chunk->setFileSize($contentRange['fileSize']);
}
$result->setData(['chunk' => $chunk]);
return $result;
}
private static function getFileFromHttpInput(): IO\File
{
// This file will be automatically removed on shutdown
$tmpFilePath = TempFile::generateLocalTempFile();
$file = new IO\File($tmpFilePath);
$file->putContents(HttpRequest::getInput());
return $file;
}
private static function getContentRange(HttpRequest $request): Result
{
$contentRange = $request->getHeader('Content-Range');
if ($contentRange === null)
{
return new Result();
}
$result = new Result();
if (!preg_match('/(\d+)-(\d+)\/(\d+)$/', $contentRange, $match))
{
return $result->addError(new UploaderError(UploaderError::INVALID_CONTENT_RANGE));
}
[$startRange, $endRange, $fileSize] = [(int)$match[1], (int)$match[2], (int)$match[3]];
if ($startRange > $endRange)
{
return $result->addError(new UploaderError(UploaderError::INVALID_CONTENT_RANGE));
}
if ($fileSize <= $endRange)
{
return $result->addError(new UploaderError(UploaderError::INVALID_CONTENT_RANGE));
}
$result->setData([
'startRange' => $startRange,
'endRange' => $endRange,
'fileSize' => $fileSize,
]);
return $result;
}
private static function normalizeFilename(string $filename): string
{
$filename = urldecode($filename);
$filename = Encoding::convertEncodingToCurrent($filename);
return \getFileName($filename);
}
private static function isValidFilename(string $filename): bool
{
if (mb_strlen($filename) > 255)
{
return false;
}
if (mb_strpos($filename, '\0') !== false)
{
return false;
}
return true;
}
public function getFile(): IO\File
{
return $this->file;
}
/**
* @internal
*/
public function setFile(IO\File $file): void
{
$this->file = $file;
$this->size = $file->getSize();
}
public function getSize(): int
{
return $this->size;
}
public function getFileSize(): int
{
return $this->fileSize ?? $this->size;
}
protected function setFileSize(int $fileSize): void
{
$this->fileSize = $fileSize;
}
public function getType(): string
{
return $this->type;
}
public function setType(string $type): void
{
$this->type = $type;
}
public function getName(): string
{
return $this->name;
}
public function setName(string $name): void
{
$this->name = $name;
}
public function getWidth(): int
{
return $this->width;
}
public function setWidth(int $width): void
{
$this->width = $width;
}
public function getHeight(): int
{
return $this->height;
}
public function setHeight(int $height): void
{
$this->height = $height;
}
public function getStartRange(): ?int
{
return $this->startRange;
}
protected function setStartRange(int $startRange): void
{
$this->startRange = $startRange;
}
public function getEndRange(): ?int
{
return $this->endRange;
}
protected function setEndRange(int $endRange): void
{
$this->endRange = $endRange;
}
public function isFirst(): bool
{
return $this->startRange === null || $this->startRange === 0;
}
public function isLast(): bool
{
return $this->endRange === null || ($this->endRange + 1) === $this->fileSize;
}
public function isOnlyOne(): bool
{
return (
$this->startRange === null
|| ($this->startRange === 0 && ($this->endRange - $this->startRange + 1) === $this->fileSize)
);
}
public function validate(Configuration $config): Result
{
$result = new Result();
if (in_array(mb_strtolower($this->getName()), $config->getIgnoredFileNames()))
{
return $result->addError(new UploaderError(UploaderError::FILE_NAME_NOT_ALLOWED));
}
if ($config->getMaxFileSize() !== null && $this->getFileSize() > $config->getMaxFileSize())
{
return $result->addError(
new UploaderError(
UploaderError::MAX_FILE_SIZE_EXCEEDED,
[
'maxFileSize' => \CFile::formatSize($config->getMaxFileSize()),
'maxFileSizeInBytes' => $config->getMaxFileSize(),
]
)
);
}
if ($this->getFileSize() < $config->getMinFileSize())
{
return $result->addError(
new UploaderError(
UploaderError::MIN_FILE_SIZE_EXCEEDED,
[
'minFileSize' => \CFile::formatSize($config->getMinFileSize()),
'minFileSizeInBytes' => $config->getMinFileSize(),
]
)
);
}
if (!$this->validateFileType($config->getAcceptedFileTypes()))
{
return $result->addError(new UploaderError(UploaderError::FILE_TYPE_NOT_ALLOWED));
}
$width = 0;
$height = 0;
if (\CFile::isImage($this->getName(), $this->getType()))
{
$image = new File\Image($this->getFile()->getPhysicalPath());
$imageInfo = $image->getInfo(false);
if (!$imageInfo)
{
if ($config->getIgnoreUnknownImageTypes())
{
$result->setData(['width' => $width, 'height' => $height]);
return $result;
}
else
{
return $result->addError(new UploaderError(UploaderError::IMAGE_TYPE_NOT_SUPPORTED));
}
}
$width = $imageInfo->getWidth();
$height = $imageInfo->getHeight();
if ($imageInfo->getFormat() === File\Image::FORMAT_JPEG)
{
$exifData = $image->getExifData();
if (isset($exifData['Orientation']) && $exifData['Orientation'] >= 5 && $exifData['Orientation'] <= 8)
{
[$width, $height] = [$height, $width];
}
}
if (!$config->shouldTreatOversizeImageAsFile())
{
$imageData = new FileData($this->getName(), $this->getType(), $this->getSize());
$imageData->setWidth($width);
$imageData->setHeight($height);
$validationResult = $config->validateImage($imageData);
if (!$validationResult->isSuccess())
{
return $result->addErrors($validationResult->getErrors());
}
}
}
$result->setData(['width' => $width, 'height' => $height]);
return $result;
}
private function validateFileType(array $fileTypes): bool
{
if (count($fileTypes) === 0)
{
return true;
}
$mimeType = $this->getType();
$baseMimeType = preg_replace('/\/.*$/', '', $mimeType);
foreach ($fileTypes as $type)
{
if (!is_string($type) || mb_strlen($type) === 0)
{
continue;
}
$type = mb_strtolower(trim($type));
if ($type[0] === '.') // extension case
{
$filename = mb_strtolower($this->getName());
$offset = mb_strlen($filename) - mb_strlen($type);
if (mb_strpos($filename, $type, $offset) !== false)
{
return true;
}
}
elseif (preg_match('/\/\*$/', $type)) // image/* mime type case
{
if ($baseMimeType === preg_replace('/\/.*$/', '', $type))
{
return true;
}
}
elseif ($mimeType === $type)
{
return true;
}
}
return false;
}
}