HttpProcessUtility::headerToServerKey() - Code Metrics - Inspection of "Cleanup HttpProcessUtility" - Algo-Web/POData - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#261)

by Christopher

created 2020-05-09 08:17 UTC

HttpProcessUtility::headerToServerKey() A

↳ Parent: HttpProcessUtility

Complexity

Conditions	2
Paths	2

Size

Total Lines	6
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	2
eloc	4
c	1
b	0
f	0
nc	2
nop	1
dl	0
loc	6
rs	10

<?php

declare(strict_types=1);

namespace POData;

use POData\Common\HttpHeaderFailure;
use POData\Common\Messages;
use POData\Providers\Metadata\Type\Char;
filter:
    dependency_paths: ["lib/*"]

/**
 * Class HttpProcessUtility.
 */
class HttpProcessUtility
{
    /**
     * Gets the appropriate MIME type for the request, throwing if there is none.
     *
     * @param string   $acceptTypesText    Text as it appears in an HTTP
     *                                     Accepts header
     * @param string[] $exactContentTypes  Preferred content type to match if an exact media type is given - this is in
     *                                     descending order of preference
     * @param string   $inexactContentType Preferred fallback content type for inexact matches
     *
     * @throws HttpHeaderFailure
     * @return string|null       One of exactContentType or inexactContentType
     */
    public static function selectRequiredMimeType(
        ?string $acceptTypesText,
        array $exactContentTypes,
        $inexactContentType
    ): ?string {
        $selectedContentType   = null;
        $selectedMatchingParts = -1;
        $selectedQualityValue  = 0;
        $acceptable            = false;
        $acceptTypesEmpty      = true;
        $foundExactMatch       = false;

        if (null === $acceptTypesText) {
            throw new HttpHeaderFailure(Messages::unsupportedMediaType(), 415);
        }

        $acceptTypes = self::mimeTypesFromAcceptHeaders($acceptTypesText);
        foreach ($acceptTypes as $acceptType) {
            $acceptTypesEmpty = false;
            foreach ($exactContentTypes as $exactContentType) {
                if (0 == strcasecmp($acceptType->getMimeType(), $exactContentType)) {
                    $selectedContentType  = $exactContentType;
                    $selectedQualityValue = $acceptType->getQualityValue();
                    $acceptable           = 0 != $selectedQualityValue;
                    $foundExactMatch      = true;
                    break;
                }
            }

            if ($foundExactMatch) {
                break;
            }

            $matchingParts = $acceptType->getMatchingRating($inexactContentType);
            if ($matchingParts < 0) {
                continue;
            }

            $candidateQualityValue = $acceptType->getQualityValue();
            if ($matchingParts > $selectedMatchingParts) {
                // A more specific type wins.
                $selectedContentType   = $inexactContentType;
                $selectedMatchingParts = $matchingParts;
                $selectedQualityValue  = $candidateQualityValue;
                $acceptable            = 0 != $selectedQualityValue;
            } elseif ($matchingParts == $selectedMatchingParts) {
                // A type with a higher q-value wins.
                if ($candidateQualityValue > $selectedQualityValue) {
                    $selectedContentType  = $inexactContentType;
                    $selectedQualityValue = $candidateQualityValue;
                    $acceptable           = 0 != $selectedQualityValue;
                }
            }
        }

        if (!$acceptable && !$acceptTypesEmpty) {
            throw new HttpHeaderFailure(Messages::unsupportedMediaType(), 415);
        }

        if ($acceptTypesEmpty) {
            $selectedContentType = $inexactContentType;
        }

        return $selectedContentType;
    }

    /**
     * Returns all MIME types from the $text.
     *
     * @param string $text Text as it appears on an HTTP Accepts header
     *
     * @throws HttpHeaderFailure If found any syntax error in the given text
     * @return MediaType[]       Array of media (MIME) type description
     */
    public static function mimeTypesFromAcceptHeaders(string $text): array
    {
        $mediaTypes = [];
        $textIndex  = 0;
        while (!self::skipWhiteSpace($text, $textIndex)) {
            $type    = null;
            $subType = null;
            self::readMediaTypeAndSubtype($text, $textIndex, $type, $subType);

            $parameters = [];
            while (!self::skipWhitespace($text, $textIndex)) {
                if (',' == $text[$textIndex]) {
                    ++$textIndex;
                    break;
                }

                if (';' != $text[$textIndex]) {
                    throw new HttpHeaderFailure(
                        Messages::httpProcessUtilityMediaTypeRequiresSemicolonBeforeParameter(),
                        400
                    );
                }

                ++$textIndex;
                if (self::skipWhiteSpace($text, $textIndex)) {
                    break;
                }

                self::readMediaTypeParameter($text, $textIndex, $parameters);
            }

            $mediaTypes[] = new MediaType($type, $subType, $parameters);
        }

        return $mediaTypes;
    }

    /**
     * Skips whitespace in the specified text by advancing an index to
     * the next non-whitespace character.
     *
     * @param string $text       Text to scan
     * @param int    &$textIndex Index to begin scanning from
     *
     * @return bool true if the end of the string was reached, false otherwise
     */
    public static function skipWhiteSpace(string $text, int &$textIndex): bool
    {
        $textLen = strlen(strval($text));
        while (($textIndex < $textLen) && Char::isWhiteSpace($text[$textIndex])) {
            ++$textIndex;
        }

        return $textLen == $textIndex;
    }

    /**
     * Reads the type and subtype specifications for a MIME type.
     *
     * @param string $text       Text in which specification exists
     * @param int    &$textIndex Pointer into text
     * @param string &$type      Type of media found
     * @param string &$subType   Subtype of media found
     *
     * @throws HttpHeaderFailure If failed to read type and sub-type
     */
    public static function readMediaTypeAndSubtype(
        string $text,
        int &$textIndex,
        &$type,
        &$subType
    ): void {
        $textStart = $textIndex;
        if (self::readToken($text, $textIndex)) {
            throw new HttpHeaderFailure(
                Messages::httpProcessUtilityMediaTypeUnspecified(),
                400
            );
        }

        if ('/' != $text[$textIndex]) {
            throw new HttpHeaderFailure(
                Messages::httpProcessUtilityMediaTypeRequiresSlash(),
                400
            );
        }

        $type = substr($text, $textStart, $textIndex - $textStart);
        ++$textIndex;

        $subTypeStart = $textIndex;
        self::readToken($text, $textIndex);
        if ($textIndex == $subTypeStart) {
            throw new HttpHeaderFailure(
                Messages::httpProcessUtilityMediaTypeRequiresSubType(),
                400
            );
        }

        $subType = substr($text, $subTypeStart, $textIndex - $subTypeStart);
    }

    /**
     * Reads a token on the specified text by advancing an index on it.
     *
     * @param string $text       Text to read token from
     * @param int    &$textIndex Index for the position being scanned on text
     *
     * @return bool true if the end of the text was reached; false otherwise
     */
    public static function readToken(string $text, int &$textIndex): bool
    {
        $textLen = strlen($text);
        while (($textIndex < $textLen) && self::isHttpTokenChar($text[$textIndex])) {
            ++$textIndex;
        }

        return $textLen == $textIndex;
    }

    /**
     * To check whether the given character is a HTTP token character
     * or not.
     *
     * @param string $char The character to inspect
     *
     * @return bool True if the given character is a valid HTTP token
     *              character, False otherwise
     */
    public static function isHttpTokenChar(string $char): bool
    {
        return 126 > ord($char) && 31 < ord($char) && !self::isHttpSeparator($char);
    }

    /**
     * To check whether the given character is a HTTP separator character.
     *
     * @param string $char The character to inspect
     *
     * @return bool True if the given character is a valid HTTP separator
     *              character, False otherwise
     */
    public static function isHttpSeparator(string $char): bool
    {
        $httpSeperators = ['(', ')', '<', '>', '@', ',', ';', ':', '\\', '"', '/', '[', ']', '?', '=', '{', '}', ' '];
        return in_array($char, $httpSeperators) || ord($char) == Char::TAB;
    }

    /**
     * Read a parameter for a media type/range.
     *
     * @param string $text        Text to read from
     * @param int    &$textIndex  Pointer in text
     * @param array  &$parameters Array with parameters
     *
     * @throws HttpHeaderFailure If found parameter value missing
     */
    public static function readMediaTypeParameter(string $text, int &$textIndex, array &$parameters)
    {
        $textStart = $textIndex;
        if (self::readToken($text, $textIndex)) {
            throw new HttpHeaderFailure(
                Messages::httpProcessUtilityMediaTypeMissingValue(),
                400
            );
        }

        $parameterName = substr($text, $textStart, $textIndex - $textStart);
        if ('=' != $text[$textIndex]) {
            throw new HttpHeaderFailure(
                Messages::httpProcessUtilityMediaTypeMissingValue(),
                400
            );
        }

        ++$textIndex;
        $parameterValue
                      = self::readQuotedParameterValue($parameterName, $text, $textIndex);
        $parameters[] = [$parameterName => $parameterValue];
    }

    /**
     * Reads Mime type parameter value for a particular parameter in the
     * Content-Type/Accept headers.
     *
     * @param string $parameterName Name of parameter
     * @param string $text          Header text
     * @param int    &$textIndex    Parsing index in $text
     *
     * @throws HttpHeaderFailure
     * @return string            String representing the value of the $parameterName parameter
     */
    public static function readQuotedParameterValue(
        string $parameterName,
        string $text,
        int &$textIndex
    ): ?string {
        $parameterValue = [];
        $textLen        = strlen($text);
        $valueIsQuoted  = false;
        if ($textIndex < $textLen) {
            if ('"' == $text[$textIndex]) {
                ++$textIndex;
                $valueIsQuoted = true;
            }
        }

        while ($textIndex < $textLen) {
            $currentChar = $text[$textIndex];

            if ('\\' == $currentChar || '"' == $currentChar) {
                if (!$valueIsQuoted) {
                    throw new HttpHeaderFailure(
                        Messages::httpProcessUtilityEscapeCharWithoutQuotes(
                            $parameterName
                        ),
                        400
                    );
                }

                ++$textIndex;

                // End of quoted parameter value.
                if ('"' == $currentChar) {
                    $valueIsQuoted = false;
                    break;
                }

                if ($textIndex >= $textLen) {
                    throw new HttpHeaderFailure(
                        Messages::httpProcessUtilityEscapeCharAtEnd($parameterName),
                        400
                    );
                }

                $currentChar = $text[$textIndex];
            } elseif (!self::isHttpTokenChar($currentChar)) {
                // If the given character is special, we stop processing.
                break;
            }

            $parameterValue[] = $currentChar;
            ++$textIndex;
        }

        if ($valueIsQuoted) {
            throw new HttpHeaderFailure(
                Messages::httpProcessUtilityClosingQuoteNotFound($parameterName),
                400
            );
        }

        return empty($parameterValue) ? null : implode('', $parameterValue);
    }

    /**
     * Selects an acceptable MIME type that satisfies the Accepts header.
     *
     * @param string   $acceptTypesText Text for Accepts header
     * @param string[] $availableTypes  Types that the server is willing to return, in descending order of preference
     *
     * @throws HttpHeaderFailure
     * @return string|null       The best MIME type for the client
     */
    public static function selectMimeType(string $acceptTypesText, array $availableTypes): ?string
    {
        $selectedContentType     = null;
        $selectedMatchingParts   = -1;
        $selectedQualityValue    = 0;
        $selectedPreferenceIndex = PHP_INT_MAX;
        $acceptable              = false;
        $acceptTypesEmpty        = true;

        $acceptTypes  = self::mimeTypesFromAcceptHeaders($acceptTypesText);
        $numAvailable = count($availableTypes);
        foreach ($acceptTypes as $acceptType) {
            $acceptTypesEmpty = false;
            for ($i = 0; $i < $numAvailable; ++$i) {
                $availableType = $availableTypes[$i];
                $matchRating   = $acceptType->getMatchingRating($availableType);
                if (0 > $matchRating) {
                    continue;
                }

                $candidateQualityValue = $acceptType->getQualityValue();
                if ($matchRating > $selectedMatchingParts) {
                    // A more specific type wins.
                    $selectedContentType     = $availableType;
                    $selectedMatchingParts   = $matchRating;
                    $selectedQualityValue    = $candidateQualityValue;
                    $selectedPreferenceIndex = $i;
                    $acceptable              = 0 != $selectedQualityValue;
                } elseif ($matchRating == $selectedMatchingParts) {
                    // A type with a higher q-value wins.
                    if ($candidateQualityValue > $selectedQualityValue) {
                        $selectedContentType     = $availableType;
                        $selectedQualityValue    = $candidateQualityValue;
                        $selectedPreferenceIndex = $i;
                        $acceptable              = 0 != $selectedQualityValue;
                    } elseif ($candidateQualityValue == $selectedQualityValue) {
                        // A type that is earlier in the availableTypes array wins.
                        if ($i < $selectedPreferenceIndex) {
                            $selectedContentType     = $availableType;
                            $selectedPreferenceIndex = $i;
                        }
                    }
                }
            }
        }

        if ($acceptTypesEmpty) {
            $selectedContentType = $availableTypes[0];
        } elseif (!$acceptable) {

            $selectedContentType = null;
        }

        return $selectedContentType;
    }

    /**
     * Reads the numeric part of a quality value substring, normalizing it to 0-1000.
     * rather than the standard 0.000-1.000 ranges.
     *
     * @param string $text       Text to read qvalue from
     * @param int    &$textIndex Index into text where the qvalue starts
     *
     * @throws HttpHeaderFailure If any error occurred while reading and processing
     *                           the quality factor
     * @return int               The normalised qvalue
     */
    public static function readQualityValue(string $text, int &$textIndex): int
    {
        $digit = $text[$textIndex++];
        if ('0' == $digit) {
            $qualityValue = 0;
        } elseif ('1' == $digit) {
            $qualityValue = 1;
        } else {
            throw new HttpHeaderFailure(
                Messages::httpProcessUtilityMalformedHeaderValue(),
                400
            );
        }

        $textLen = strlen($text);
        if ($textIndex < $textLen && '.' == $text[$textIndex]) {
            ++$textIndex;

            $adjustFactor = 1000;
            while (1 < $adjustFactor && $textIndex < $textLen) {
                $c         = $text[$textIndex];
                $charValue = self::digitToInt32($c);
                if (0 <= $charValue) {
                    ++$textIndex;
                    $adjustFactor /= 10;
                    $qualityValue *= 10;
                    $qualityValue += $charValue;
                } else {
                    break;
                }
            }

            $qualityValue *= $adjustFactor;
            if ($qualityValue > 1000) {
                // Too high of a value in qvalue.
                throw new HttpHeaderFailure(
                    Messages::httpProcessUtilityMalformedHeaderValue(),
                    400
                );
            }
        } else {
            $qualityValue *= 1000;
        }

        return $qualityValue;
    }

    /**
     * Converts the specified character from the ASCII range to a digit.
     *
     * @param string $c Character to convert
     *
     * @throws HttpHeaderFailure If $c is not ASCII value for digit or element separator
     * @return int               The Int32 value for $c, or -1 if it is an element separator
     */
    public static function digitToInt32(string $c): int
    {
        if ('0' <= $c && '9' >= $c) {
            return intval($c);
        } else {
            if (self::isHttpElementSeparator($c)) {
                return -1;
            } else {
                throw new HttpHeaderFailure(
                    Messages::httpProcessUtilityMalformedHeaderValue(),
                    400
                );
            }
        }
    }

    /**
     * Verifies whether the specified character is a valid separator in.
     * an HTTP header list of element.
     *
     * @param string $c Character to verify
     *
     * @return bool true if c is a valid character for separating elements;
     *              false otherwise
     */
    public static function isHttpElementSeparator(string $c): bool
    {
        return ',' == $c || ' ' == $c || '\t' == $c;
    }

    /**
     * Get server key by header.
     *
     * @param  string $headerName Name of header
     * @return string
     */
    public static function headerToServerKey(string $headerName): string
    {
        $name = strtoupper(str_replace('-', '_', $headerName));
        $prefixableKeys = ['HOST', 'CONNECTION', 'CACHE_CONTROL', 'ORIGIN', 'USER_AGENT', 'POSTMAN_TOKEN', 'ACCEPT',
            'ACCEPT_ENCODING', 'ACCEPT_LANGUAGE', 'DATASERVICEVERSION', 'MAXDATASERVICEVERSION'];
        return in_array($name, $prefixableKeys) ? 'HTTP_' . $name : $name;
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace POData;
6
7			use POData\Common\HttpHeaderFailure;
8			use POData\Common\Messages;
9			use POData\Providers\Metadata\Type\Char;
			0 ignored issues – show Bug introduced 2017-12-13 05:04 UTC by Report Bug Copy Issue Report The type `POData\Providers\Metadata\Type\Char` was not found. Maybe you did not declare it correctly or list all dependencies? The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. `excluded_paths: ["lib/"]`, you can move it to the dependency path list as follows: filter: dependency_paths: ["lib/"] For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths Loading history...
10
11			/**
12			* Class HttpProcessUtility.
13			*/
14			class HttpProcessUtility
15			{
16			/**
17			* Gets the appropriate MIME type for the request, throwing if there is none.
18			*
19			* @param string $acceptTypesText Text as it appears in an HTTP
20			* Accepts header
21			* @param string[] $exactContentTypes Preferred content type to match if an exact media type is given - this is in
22			* descending order of preference
23			* @param string $inexactContentType Preferred fallback content type for inexact matches
24			*
25			* @throws HttpHeaderFailure
26			* @return string\|null One of exactContentType or inexactContentType
27			*/
28			public static function selectRequiredMimeType(
29			?string $acceptTypesText,
30			array $exactContentTypes,
31			$inexactContentType
32			): ?string {
33			$selectedContentType = null;
34			$selectedMatchingParts = -1;
35			$selectedQualityValue = 0;
36			$acceptable = false;
37			$acceptTypesEmpty = true;
38			$foundExactMatch = false;
39
40			if (null === $acceptTypesText) {
41			throw new HttpHeaderFailure(Messages::unsupportedMediaType(), 415);
42			}
43
44			$acceptTypes = self::mimeTypesFromAcceptHeaders($acceptTypesText);
45			foreach ($acceptTypes as $acceptType) {
46			$acceptTypesEmpty = false;
47			foreach ($exactContentTypes as $exactContentType) {
48			if (0 == strcasecmp($acceptType->getMimeType(), $exactContentType)) {
49			$selectedContentType = $exactContentType;
50			$selectedQualityValue = $acceptType->getQualityValue();
51			$acceptable = 0 != $selectedQualityValue;
52			$foundExactMatch = true;
53			break;
54			}
55			}
56
57			if ($foundExactMatch) {
58			break;
59			}
60
61			$matchingParts = $acceptType->getMatchingRating($inexactContentType);
62			if ($matchingParts < 0) {
63			continue;
64			}
65
66			$candidateQualityValue = $acceptType->getQualityValue();
67			if ($matchingParts > $selectedMatchingParts) {
68			// A more specific type wins.
69			$selectedContentType = $inexactContentType;
70			$selectedMatchingParts = $matchingParts;
71			$selectedQualityValue = $candidateQualityValue;
72			$acceptable = 0 != $selectedQualityValue;
73			} elseif ($matchingParts == $selectedMatchingParts) {
74			// A type with a higher q-value wins.
75			if ($candidateQualityValue > $selectedQualityValue) {
76			$selectedContentType = $inexactContentType;
77			$selectedQualityValue = $candidateQualityValue;
78			$acceptable = 0 != $selectedQualityValue;
79			}
80			}
81			}
82
83			if (!$acceptable && !$acceptTypesEmpty) {
84			throw new HttpHeaderFailure(Messages::unsupportedMediaType(), 415);
85			}
86
87			if ($acceptTypesEmpty) {
88			$selectedContentType = $inexactContentType;
89			}
90
91			return $selectedContentType;
92			}
93
94			/**
95			* Returns all MIME types from the $text.
96			*
97			* @param string $text Text as it appears on an HTTP Accepts header
98			*
99			* @throws HttpHeaderFailure If found any syntax error in the given text
100			* @return MediaType[] Array of media (MIME) type description
101			*/
102			public static function mimeTypesFromAcceptHeaders(string $text): array
103			{
104			$mediaTypes = [];
105			$textIndex = 0;
106			while (!self::skipWhiteSpace($text, $textIndex)) {
107			$type = null;
108			$subType = null;
109			self::readMediaTypeAndSubtype($text, $textIndex, $type, $subType);
110
111			$parameters = [];
112			while (!self::skipWhitespace($text, $textIndex)) {
113			if (',' == $text[$textIndex]) {
114			++$textIndex;
115			break;
116			}
117
118			if (';' != $text[$textIndex]) {
119			throw new HttpHeaderFailure(
120			Messages::httpProcessUtilityMediaTypeRequiresSemicolonBeforeParameter(),
121			400
122			);
123			}
124
125			++$textIndex;
126			if (self::skipWhiteSpace($text, $textIndex)) {
127			break;
128			}
129
130			self::readMediaTypeParameter($text, $textIndex, $parameters);
131			}
132
133			$mediaTypes[] = new MediaType($type, $subType, $parameters);
134			}
135
136			return $mediaTypes;
137			}
138
139			/**
140			* Skips whitespace in the specified text by advancing an index to
141			* the next non-whitespace character.
142			*
143			* @param string $text Text to scan
144			* @param int &$textIndex Index to begin scanning from
145			*
146			* @return bool true if the end of the string was reached, false otherwise
147			*/
148			public static function skipWhiteSpace(string $text, int &$textIndex): bool
149			{
150			$textLen = strlen(strval($text));
151			while (($textIndex < $textLen) && Char::isWhiteSpace($text[$textIndex])) {
152			++$textIndex;
153			}
154
155			return $textLen == $textIndex;
156			}
157
158			/**
159			* Reads the type and subtype specifications for a MIME type.
160			*
161			* @param string $text Text in which specification exists
162			* @param int &$textIndex Pointer into text
163			* @param string &$type Type of media found
164			* @param string &$subType Subtype of media found
165			*
166			* @throws HttpHeaderFailure If failed to read type and sub-type
167			*/
168			public static function readMediaTypeAndSubtype(
169			string $text,
170			int &$textIndex,
171			&$type,
172			&$subType
173			): void {
174			$textStart = $textIndex;
175			if (self::readToken($text, $textIndex)) {
176			throw new HttpHeaderFailure(
177			Messages::httpProcessUtilityMediaTypeUnspecified(),
178			400
179			);
180			}
181
182			if ('/' != $text[$textIndex]) {
183			throw new HttpHeaderFailure(
184			Messages::httpProcessUtilityMediaTypeRequiresSlash(),
185			400
186			);
187			}
188
189			$type = substr($text, $textStart, $textIndex - $textStart);
190			++$textIndex;
191
192			$subTypeStart = $textIndex;
193			self::readToken($text, $textIndex);
194			if ($textIndex == $subTypeStart) {
195			throw new HttpHeaderFailure(
196			Messages::httpProcessUtilityMediaTypeRequiresSubType(),
197			400
198			);
199			}
200
201			$subType = substr($text, $subTypeStart, $textIndex - $subTypeStart);
202			}
203
204			/**
205			* Reads a token on the specified text by advancing an index on it.
206			*
207			* @param string $text Text to read token from
208			* @param int &$textIndex Index for the position being scanned on text
209			*
210			* @return bool true if the end of the text was reached; false otherwise
211			*/
212			public static function readToken(string $text, int &$textIndex): bool
213			{
214			$textLen = strlen($text);
215			while (($textIndex < $textLen) && self::isHttpTokenChar($text[$textIndex])) {
216			++$textIndex;
217			}
218
219			return $textLen == $textIndex;
220			}
221
222			/**
223			* To check whether the given character is a HTTP token character
224			* or not.
225			*
226			* @param string $char The character to inspect
227			*
228			* @return bool True if the given character is a valid HTTP token
229			* character, False otherwise
230			*/
231			public static function isHttpTokenChar(string $char): bool
232			{
233			return 126 > ord($char) && 31 < ord($char) && !self::isHttpSeparator($char);
234			}
235
236			/**
237			* To check whether the given character is a HTTP separator character.
238			*
239			* @param string $char The character to inspect
240			*
241			* @return bool True if the given character is a valid HTTP separator
242			* character, False otherwise
243			*/
244			public static function isHttpSeparator(string $char): bool
245			{
246			$httpSeperators = ['(', ')', '<', '>', '@', ',', ';', ':', '\\', '"', '/', '[', ']', '?', '=', '{', '}', ' '];
247			return in_array($char, $httpSeperators) \|\| ord($char) == Char::TAB;
248			}
249
250			/**
251			* Read a parameter for a media type/range.
252			*
253			* @param string $text Text to read from
254			* @param int &$textIndex Pointer in text
255			* @param array &$parameters Array with parameters
256			*
257			* @throws HttpHeaderFailure If found parameter value missing
258			*/
259			public static function readMediaTypeParameter(string $text, int &$textIndex, array &$parameters)
260			{
261			$textStart = $textIndex;
262			if (self::readToken($text, $textIndex)) {
263			throw new HttpHeaderFailure(
264			Messages::httpProcessUtilityMediaTypeMissingValue(),
265			400
266			);
267			}
268
269			$parameterName = substr($text, $textStart, $textIndex - $textStart);
270			if ('=' != $text[$textIndex]) {
271			throw new HttpHeaderFailure(
272			Messages::httpProcessUtilityMediaTypeMissingValue(),
273			400
274			);
275			}
276
277			++$textIndex;
278			$parameterValue
279			= self::readQuotedParameterValue($parameterName, $text, $textIndex);
280			$parameters[] = [$parameterName => $parameterValue];
281			}
282
283			/**
284			* Reads Mime type parameter value for a particular parameter in the
285			* Content-Type/Accept headers.
286			*
287			* @param string $parameterName Name of parameter
288			* @param string $text Header text
289			* @param int &$textIndex Parsing index in $text
290			*
291			* @throws HttpHeaderFailure
292			* @return string String representing the value of the $parameterName parameter
293			*/
294			public static function readQuotedParameterValue(
295			string $parameterName,
296			string $text,
297			int &$textIndex
298			): ?string {
299			$parameterValue = [];
300			$textLen = strlen($text);
301			$valueIsQuoted = false;
302			if ($textIndex < $textLen) {
303			if ('"' == $text[$textIndex]) {
304			++$textIndex;
305			$valueIsQuoted = true;
306			}
307			}
308
309			while ($textIndex < $textLen) {
310			$currentChar = $text[$textIndex];
311
312			if ('\\' == $currentChar \|\| '"' == $currentChar) {
313			if (!$valueIsQuoted) {
314			throw new HttpHeaderFailure(
315			Messages::httpProcessUtilityEscapeCharWithoutQuotes(
316			$parameterName
317			),
318			400
319			);
320			}
321
322			++$textIndex;
323
324			// End of quoted parameter value.
325			if ('"' == $currentChar) {
326			$valueIsQuoted = false;
327			break;
328			}
329
330			if ($textIndex >= $textLen) {
331			throw new HttpHeaderFailure(
332			Messages::httpProcessUtilityEscapeCharAtEnd($parameterName),
333			400
334			);
335			}
336
337			$currentChar = $text[$textIndex];
338			} elseif (!self::isHttpTokenChar($currentChar)) {
339			// If the given character is special, we stop processing.
340			break;
341			}
342
343			$parameterValue[] = $currentChar;
344			++$textIndex;
345			}
346
347			if ($valueIsQuoted) {
348			throw new HttpHeaderFailure(
349			Messages::httpProcessUtilityClosingQuoteNotFound($parameterName),
350			400
351			);
352			}
353
354			return empty($parameterValue) ? null : implode('', $parameterValue);
355			}
356
357			/**
358			* Selects an acceptable MIME type that satisfies the Accepts header.
359			*
360			* @param string $acceptTypesText Text for Accepts header
361			* @param string[] $availableTypes Types that the server is willing to return, in descending order of preference
362			*
363			* @throws HttpHeaderFailure
364			* @return string\|null The best MIME type for the client
365			*/
366			public static function selectMimeType(string $acceptTypesText, array $availableTypes): ?string
367			{
368			$selectedContentType = null;
369			$selectedMatchingParts = -1;
370			$selectedQualityValue = 0;
371			$selectedPreferenceIndex = PHP_INT_MAX;
372			$acceptable = false;
373			$acceptTypesEmpty = true;
374
375			$acceptTypes = self::mimeTypesFromAcceptHeaders($acceptTypesText);
376			$numAvailable = count($availableTypes);
377			foreach ($acceptTypes as $acceptType) {
378			$acceptTypesEmpty = false;
379			for ($i = 0; $i < $numAvailable; ++$i) {
380			$availableType = $availableTypes[$i];
381			$matchRating = $acceptType->getMatchingRating($availableType);
382			if (0 > $matchRating) {
383			continue;
384			}
385
386			$candidateQualityValue = $acceptType->getQualityValue();
387			if ($matchRating > $selectedMatchingParts) {
388			// A more specific type wins.
389			$selectedContentType = $availableType;
390			$selectedMatchingParts = $matchRating;
391			$selectedQualityValue = $candidateQualityValue;
392			$selectedPreferenceIndex = $i;
393			$acceptable = 0 != $selectedQualityValue;
394			} elseif ($matchRating == $selectedMatchingParts) {
395			// A type with a higher q-value wins.
396			if ($candidateQualityValue > $selectedQualityValue) {
397			$selectedContentType = $availableType;
398			$selectedQualityValue = $candidateQualityValue;
399			$selectedPreferenceIndex = $i;
400			$acceptable = 0 != $selectedQualityValue;
401			} elseif ($candidateQualityValue == $selectedQualityValue) {
402			// A type that is earlier in the availableTypes array wins.
403			if ($i < $selectedPreferenceIndex) {
404			$selectedContentType = $availableType;
405			$selectedPreferenceIndex = $i;
406			}
407			}
408			}
409			}
410			}
411
412			if ($acceptTypesEmpty) {
413			$selectedContentType = $availableTypes[0];
414			} elseif (!$acceptable) {
			0 ignored issues – show introduced 2020-05-07 05:25 UTC by Report Bug Copy Issue Report The condition `$acceptable` is always `false`. Loading history...
415			$selectedContentType = null;
416			}
417
418			return $selectedContentType;
419			}
420
421			/**
422			* Reads the numeric part of a quality value substring, normalizing it to 0-1000.
423			* rather than the standard 0.000-1.000 ranges.
424			*
425			* @param string $text Text to read qvalue from
426			* @param int &$textIndex Index into text where the qvalue starts
427			*
428			* @throws HttpHeaderFailure If any error occurred while reading and processing
429			* the quality factor
430			* @return int The normalised qvalue
431			*/
432			public static function readQualityValue(string $text, int &$textIndex): int
433			{
434			$digit = $text[$textIndex++];
435			if ('0' == $digit) {
436			$qualityValue = 0;
437			} elseif ('1' == $digit) {
438			$qualityValue = 1;
439			} else {
440			throw new HttpHeaderFailure(
441			Messages::httpProcessUtilityMalformedHeaderValue(),
442			400
443			);
444			}
445
446			$textLen = strlen($text);
447			if ($textIndex < $textLen && '.' == $text[$textIndex]) {
448			++$textIndex;
449
450			$adjustFactor = 1000;
451			while (1 < $adjustFactor && $textIndex < $textLen) {
452			$c = $text[$textIndex];
453			$charValue = self::digitToInt32($c);
454			if (0 <= $charValue) {
455			++$textIndex;
456			$adjustFactor /= 10;
457			$qualityValue *= 10;
458			$qualityValue += $charValue;
459			} else {
460			break;
461			}
462			}
463
464			$qualityValue *= $adjustFactor;
465			if ($qualityValue > 1000) {
466			// Too high of a value in qvalue.
467			throw new HttpHeaderFailure(
468			Messages::httpProcessUtilityMalformedHeaderValue(),
469			400
470			);
471			}
472			} else {
473			$qualityValue *= 1000;
474			}
475
476			return $qualityValue;
477			}
478
479			/**
480			* Converts the specified character from the ASCII range to a digit.
481			*
482			* @param string $c Character to convert
483			*
484			* @throws HttpHeaderFailure If $c is not ASCII value for digit or element separator
485			* @return int The Int32 value for $c, or -1 if it is an element separator
486			*/
487			public static function digitToInt32(string $c): int
488			{
489			if ('0' <= $c && '9' >= $c) {
490			return intval($c);
491			} else {
492			if (self::isHttpElementSeparator($c)) {
493			return -1;
494			} else {
495			throw new HttpHeaderFailure(
496			Messages::httpProcessUtilityMalformedHeaderValue(),
497			400
498			);
499			}
500			}
501			}
502
503			/**
504			* Verifies whether the specified character is a valid separator in.
505			* an HTTP header list of element.
506			*
507			* @param string $c Character to verify
508			*
509			* @return bool true if c is a valid character for separating elements;
510			* false otherwise
511			*/
512			public static function isHttpElementSeparator(string $c): bool
513			{
514			return ',' == $c \|\| ' ' == $c \|\| '\t' == $c;
515			}
516
517			/**
518			* Get server key by header.
519			*
520			* @param string $headerName Name of header
521			* @return string
522			*/
523			public static function headerToServerKey(string $headerName): string
524			{
525			$name = strtoupper(str_replace('-', '_', $headerName));
526			$prefixableKeys = ['HOST', 'CONNECTION', 'CACHE_CONTROL', 'ORIGIN', 'USER_AGENT', 'POSTMAN_TOKEN', 'ACCEPT',
527			'ACCEPT_ENCODING', 'ACCEPT_LANGUAGE', 'DATASERVICEVERSION', 'MAXDATASERVICEVERSION'];
528			return in_array($name, $prefixableKeys) ? 'HTTP_' . $name : $name;
529			}
530			}
531

Algo-Web / POData

Pull Request — master (#261)

HttpProcessUtility::headerToServerKey() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like