Ballybran\Routing\Router\RouterRequest::sendResponse()

Complexity

Conditions	18
Paths	112

Size

Total Lines	73
Code Lines	42

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	1

<?php
    public static function sendResponse(Response $response)
    {
        header('HTTP/'.$response->getHttpVersion().' '.$response->getStatus().' '.$response->getStatusText());
        foreach ($response->getHeaders() as $key => $value) {
            foreach ($value as $k => $v) {
                if (0 === $k) {
                    header($key.': '.$v);
                } else {
                    header($key.': '.$v, false);
                }
            }
        }

        $body = $response->getBody();
        if (null === $body) {

The condition null === $body is always false.

            return;
        }

        if (is_callable($body)) {
            $body();

            return;
        }

        $contentLength = $response->getHeader('Content-Length');
        if (null !== $contentLength) {
            $output = fopen('php://output', 'wb');
            if (is_resource($body) && 'stream' == get_resource_type($body)) {
                if (PHP_INT_SIZE > 4) {
                    // use the dedicated function on 64 Bit systems
                    // a workaround to make PHP more possible to use mmap based copy, see https://github.com/sabre-io/http/pull/119
                    $left = (int) $contentLength;
                    // copy with 4MiB chunks
                    $chunk_size = 4 * 1024 * 1024;
                    stream_set_chunk_size($output, $chunk_size);

It seems like $output can also be of type false; however, parameter $fp of stream_set_chunk_size() does only seem to accept resource, maybe add an additional type check?

                    // If this is a partial response, flush the beginning bytes until the first position that is a multiple of the page size.
                    $contentRange = $response->getHeader('Content-Range');
                    // Matching "Content-Range: bytes 1234-5678/7890"
                    if (null !== $contentRange && preg_match('/^bytes\s([0-9]+)-([0-9]+)\//i', $contentRange, $matches)) {
                        // 4kB should be the default page size on most architectures
                        $pageSize = 4096;
                        $offset = (int) $matches[1];
                        $delta = ($offset % $pageSize) > 0 ? ($pageSize - $offset % $pageSize) : 0;
                        if ($delta > 0) {
                            $left -= stream_copy_to_stream($body, $output, min($delta, $left));

It seems like $output can also be of type false; however, parameter $dest of stream_copy_to_stream() does only seem to accept resource, maybe add an additional type check?

                        }
                    }
                    while ($left > 0) {
                        $copied = stream_copy_to_stream($body, $output, min($left, $chunk_size));
                        // stream_copy_to_stream($src, $dest, $maxLength) must return the number of bytes copied or false in case of failure
                        // But when the $maxLength is greater than the total number of bytes remaining in the stream,
                        // It returns the negative number of bytes copied
                        // So break the loop in such cases.
                        if ($copied <= 0) {
                            break;
                        }
                        $left -= $copied;
                    }
                } else {
                    // workaround for 32 Bit systems to avoid stream_copy_to_stream
                    while (!feof($body)) {
                        fwrite($output, fread($body, 8192));

It seems like $output can also be of type false; however, parameter $handle of fwrite() does only seem to accept resource, maybe add an additional type check?

                    }
                }
            } else {
                fwrite($output, $body, (int) $contentLength);

It seems like $body can also be of type callable and resource; however, parameter $string of fwrite() does only seem to accept string, maybe add an additional type check?

            }
        } else {
            file_put_contents('php://output', $body);
        }

        if (is_resource($body)) {
            fclose($body);
        }