PHPFastCGI\FastCGIDaemon\Http\Request

Complexity

Total Complexity

54

Size/Duplication

Total Lines	302
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

16 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	12	2
A	setServerRequestCreator()	0	4	1
A	getParams()	0	4	1
A	cleanUploadedFiles()	0	6	2
A	setBufferSize()	0	4	1
A	getBufferSize()	0	4	1
A	setUploadDir()	0	4	1
A	getUploadDir()	0	4	2
A	getQuery()	0	10	3
B	getPost()	0	27	9
C	parseMultipartFormData()	0	54	16
A	getCookies()	0	15	3
A	getStdin()	0	4	1
A	getServerRequest()	0	23	2
A	getHttpFoundationRequest()	0	12	2
B	addFile()	0	31	7

<?php

declare(strict_types=1);

namespace PHPFastCGI\FastCGIDaemon\Http;

use Nyholm\Psr7Server\ServerRequestCreatorInterface;
use Psr\Http\Message\ServerRequestInterface;
use Symfony\Component\HttpFoundation\Request as HttpFoundationRequest;

/**
 * The default implementation of the RequestInterface.
 */
final class Request implements RequestInterface
{
    /**
     * @var ServerRequestCreatorInterface|null
     */
    private static $serverRequestCreator = null;

    /**
     * @var int
     */
    private static $bufferSize = 10485760; // 10 MB

    /**
     * @var string
     */
    private static $uploadDir = null;

    /**
     * @var array
     */
    private $uploadedFiles = [];

    /**
     * @var array
     */
    private $params;

    /**
     * @var resource
     */
    private $stdin;

    /**
     * Constructor.
     *
     * @param array    $params The FastCGI server params as an associative array
     * @param resource $stdin  The FastCGI stdin data as a stream resource
     */
    public function __construct(array $params, $stdin)
    {
        $this->params = [];

        foreach ($params as $name => $value) {
            $this->params[strtoupper($name)] = $value;
        }

        $this->stdin  = $stdin;

        rewind($this->stdin);
    }

    public static function setServerRequestCreator(ServerRequestCreatorInterface $serverRequestCreator): void
    {
        self::$serverRequestCreator = $serverRequestCreator;
    }

    /**
     * {@inheritdoc}
     */
    public function getParams(): array
    {
        return $this->params;
    }

    /**
     * Remove all uploaded files
     */
    public function cleanUploadedFiles(): void
    {
        foreach ($this->uploadedFiles as $file) {
            @unlink($file['tmp_name']);

It seems like you do not handle an error condition here. This can introduce security issues, and is generally not recommended.

        }
    }

    /**
     * Set a buffer size to read uploaded files
     */
    public static function setBufferSize(int $size): void
    {
        static::$bufferSize = $size;

Since PHPFastCGI\FastCGIDaemon\Http\Request is declared final, using late-static binding will have no effect. You might want to replace static with self instead.

    }

    public static function getBufferSize(): int
    {
        return static::$bufferSize;

Since PHPFastCGI\FastCGIDaemon\Http\Request is declared final, using late-static binding will have no effect. You might want to replace static with self instead.

    }

    public static function setUploadDir(string $dir): void
    {
        static::$uploadDir = $dir;

Since PHPFastCGI\FastCGIDaemon\Http\Request is declared final, using late-static binding will have no effect. You might want to replace static with self instead.

    }

    public static function getUploadDir(): string
    {
        return static::$uploadDir ?: sys_get_temp_dir();

Since PHPFastCGI\FastCGIDaemon\Http\Request is declared final, using late-static binding will have no effect. You might want to replace static with self instead.

    }

    /**
     * {@inheritdoc}
     */
    public function getQuery(): array
    {
        $query = null;

        if (isset($this->params['QUERY_STRING'])) {
            parse_str($this->params['QUERY_STRING'], $query);
        }

        return $query ?: [];
    }

    /**
     * {@inheritdoc}
     */
    public function getPost(): array
    {
        $post = null;

        if (isset($this->params['REQUEST_METHOD']) && isset($this->params['CONTENT_TYPE'])) {
            $requestMethod = $this->params['REQUEST_METHOD'];
            $contentType   = $this->params['CONTENT_TYPE'];

            if (strcasecmp($requestMethod, 'POST') === 0 && stripos($contentType, 'multipart/form-data') === 0) {
                if (preg_match('/boundary=(?P<quote>[\'"]?)(.*)(?P=quote)/', $contentType, $matches)) {
                    list($postData, $this->uploadedFiles) = $this->parseMultipartFormData($this->stdin, $matches[2]);
                    parse_str($postData, $post);

                    return $post;
                }
            }

            if (strcasecmp($requestMethod, 'POST') === 0 && stripos($contentType, 'application/x-www-form-urlencoded') === 0) {
                $postData = stream_get_contents($this->stdin);
                rewind($this->stdin);

                parse_str($postData, $post);
            }
        }

        return $post ?: [];
    }

    private function parseMultipartFormData($stream, string $boundary): array {
        $post = "";
        $files = [];
        $fieldType = $fieldName = $filename = $mimeType = null;
        $inHeader = $getContent = false;

$getContent is not used, you could remove the assignment.

        while (!feof($stream)) {
            $getContent = $fieldName && !$inHeader;

The expression $fieldName of type string|null is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== null instead.

            $buffer = stream_get_line($stream, static::$bufferSize,  "\n" . ($getContent ? '--'.$boundary : ''));

Since PHPFastCGI\FastCGIDaemon\Http\Request is declared final, using late-static binding will have no effect. You might want to replace static with self instead.

            $buffer = trim($buffer, "\r");

            // Find the empty line between headers and body
            if ($inHeader && strlen($buffer) == 0) {
                $inHeader = false;

                continue;
            }

            if ($getContent) {
                if ($fieldType === 'data') {
                    $post .= (isset($post[0]) ? '&' : '') . $fieldName . "=" . urlencode($buffer);
                } elseif ($fieldType === 'file' && $filename) {
                    $tmpPath = @tempnam($this->getUploadDir(), 'fastcgi_upload');
                    $err = file_put_contents($tmpPath, $buffer);
                    $this->addFile($files, $fieldName, $filename, $tmpPath, $mimeType, false === $err);
                    $filename = $mimeType = null;
                }
                $fieldName = $fieldType = null;

                continue;
            }

            // Assert: We may be in the header, lets try to find 'Content-Disposition' and 'Content-Type'.
            if (strpos($buffer, 'Content-Disposition') === 0) {
                $inHeader = true;
                if (preg_match('/name=\"([^\"]*)\"/', $buffer, $matches)) {
                    $fieldName = $matches[1];
                }
                if (preg_match('/filename=\"([^\"]*)\"/', $buffer, $matches)) {
                    $filename = $matches[1];
                    $fieldType = 'file';
                } else {
                    $fieldType = 'data';
                }
            } elseif (strpos($buffer, 'Content-Type') === 0) {
                $inHeader = true;
                if (preg_match('/Content-Type: (.*)?/', $buffer, $matches)) {
                    $mimeType = trim($matches[1]);
                }
            }
        }

        return [$post, $files];
    }

    /**
     * {@inheritdoc}
     */
    public function getCookies(): array
    {
        $cookies = [];

        if (isset($this->params['HTTP_COOKIE'])) {
            $cookiePairs = explode(';', $this->params['HTTP_COOKIE']);

            foreach ($cookiePairs as $cookiePair) {
                list($name, $value) = explode('=', trim($cookiePair));
                $cookies[$name] = $value;
            }
        }

        return $cookies;
    }

    /**
     * {@inheritdoc}
     */
    public function getStdin()
    {
        return $this->stdin;
    }

    /**
     * {@inheritdoc}
     */
    public function getServerRequest(): ServerRequestInterface
    {
        if (null === self::$serverRequestCreator) {
            throw new \RuntimeException('You need to add an object of \Nyholm\Psr7Server\ServerRequestCreatorInterface to \PHPFastCGI\FastCGIDaemon\Http\Request::setServerRequestCreator to use PSR-7 requests. Please install and read more at https://github.com/nyholm/psr7-server');
        }

        $server  = $this->params;
        $query   = $this->getQuery();
        $post    = $this->getPost();
        $cookies = $this->getCookies();

        return self::$serverRequestCreator->fromArrays(
            $server,
            self::$serverRequestCreator->getHeadersFromServer($server),
            $cookies,
            $query,
            $post,
            $this->uploadedFiles,
            $this->stdin
        );


    }

    /**
     * {@inheritdoc}
     */
    public function getHttpFoundationRequest(): HttpFoundationRequest
    {
        if (!class_exists(HttpFoundationRequest::class)) {
            throw new \RuntimeException('You need to install symfony/http-foundation:^4.0 to use HttpFoundation requests.');
        }

        $query   = $this->getQuery();
        $post    = $this->getPost();
        $cookies = $this->getCookies();

        return new HttpFoundationRequest($query, $post, [], $cookies, $this->uploadedFiles, $this->params, $this->stdin);
    }

    /**
     * Add a file to the $files array
     */
    private function addFile(array &$files, string $fieldName, string $filename, string $tmpPath, string $mimeType, bool $err): void
    {
        $data = [
            'type' => $mimeType ?: 'application/octet-stream',
            'name' => $filename,
            'tmp_name' => $tmpPath,
            'error' => $err ? UPLOAD_ERR_CANT_WRITE : UPLOAD_ERR_OK,
            'size' => filesize($tmpPath),
        ];

        $parts = preg_split('|(\[[^\]]*\])|', $fieldName, -1, PREG_SPLIT_NO_EMPTY | PREG_SPLIT_DELIM_CAPTURE);
        $count = count($parts);
        if (1 === $count) {
            $files[$fieldName] = $data;
        } else {
            $current = &$files;
            foreach ($parts as $i => $part) {
                if ($part === '[]') {
                    $current[] = $data;
                    continue;
                }

                $trimmedMatch = trim($part, '[]');
                if ($i === $count -1) {
                    $current[$trimmedMatch] = $data;
                } else {
                    $current = &$current[$trimmedMatch];
                }
            }
        }
    }
}