Chunk.php

<?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;
    }
 
    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;
    }
}