Debian Codegraph @

vendor/guzzlehttp/psr7/src/UriNormalizer.php

raw
1 <?php
2
3 declare(strict_types=1);
4
5 namespace GuzzleHttp\Psr7;
6
7 use Psr\Http\Message\UriInterface;
8
9 /**
10 * Provides methods to normalize and compare URIs.
11 *
12 * @author Tobias Schultze
13 *
14 * @see https://datatracker.ietf.org/doc/html/rfc3986#section-6
15 */
16 final class UriNormalizer
17 {
18 /**
19 * Default normalizations which only include the ones that preserve semantics.
20 */
21 public const PRESERVING_NORMALIZATIONS =
22 self::CAPITALIZE_PERCENT_ENCODING |
23 self::DECODE_UNRESERVED_CHARACTERS |
24 self::CONVERT_EMPTY_PATH |
25 self::REMOVE_DEFAULT_HOST |
26 self::REMOVE_DEFAULT_PORT |
27 self::REMOVE_DOT_SEGMENTS;
28
29 /**
30 * All letters within a percent-encoding triplet (e.g., "%3A") are case-insensitive, and should be capitalized.
31 *
32 * Example: http://example.org/a%c2%b1b → http://example.org/a%C2%B1b
33 */
34 public const CAPITALIZE_PERCENT_ENCODING = 1;
35
36 /**
37 * Decodes percent-encoded octets of unreserved characters.
38 *
39 * For consistency, percent-encoded octets in the ranges of ALPHA (%41–%5A and %61–%7A), DIGIT (%30–%39),
40 * hyphen (%2D), period (%2E), underscore (%5F), or tilde (%7E) should not be created by URI producers and,
41 * when found in a URI, should be decoded to their corresponding unreserved characters by URI normalizers.
42 *
43 * Example: http://example.org/%7Eusern%61me/ → http://example.org/~username/
44 */
45 public const DECODE_UNRESERVED_CHARACTERS = 2;
46
47 /**
48 * Converts the empty path to "/" for http and https URIs.
49 *
50 * Example: http://example.org → http://example.org/
51 */
52 public const CONVERT_EMPTY_PATH = 4;
53
54 /**
55 * Removes the default host of the given URI scheme from the URI.
56 *
57 * Only the "file" scheme defines the default host "localhost".
58 * All of `file:/myfile`, `file:///myfile`, and `file://localhost/myfile`
59 * are equivalent according to RFC 3986. The first format is not accepted
60 * by PHPs stream functions and thus already normalized implicitly to the
61 * second format in the Uri class. See `GuzzleHttp\Psr7\Uri::composeComponents`.
62 *
63 * Example: file://localhost/myfile → file:///myfile
64 */
65 public const REMOVE_DEFAULT_HOST = 8;
66
67 /**
68 * Removes the default port of the given URI scheme from the URI.
69 *
70 * Example: http://example.org:80/ → http://example.org/
71 */
72 public const REMOVE_DEFAULT_PORT = 16;
73
74 /**
75 * Removes unnecessary dot-segments.
76 *
77 * Dot-segments in relative-path references are not removed as it would
78 * change the semantics of the URI reference.
79 *
80 * Example: http://example.org/../a/b/../c/./d.html → http://example.org/a/c/d.html
81 */
82 public const REMOVE_DOT_SEGMENTS = 32;
83
84 /**
85 * Paths which include two or more adjacent slashes are converted to one.
86 *
87 * Webservers usually ignore duplicate slashes and treat those URIs equivalent.
88 * But in theory those URIs do not need to be equivalent. So this normalization
89 * may change the semantics. Encoded slashes (%2F) are not removed.
90 *
91 * Example: http://example.org//foo///bar.html → http://example.org/foo/bar.html
92 */
93 public const REMOVE_DUPLICATE_SLASHES = 64;
94
95 /**
96 * Sort query parameters with their values in alphabetical order.
97 *
98 * However, the order of parameters in a URI may be significant (this is not defined by the standard).
99 * So this normalization is not safe and may change the semantics of the URI.
100 *
101 * Example: ?lang=en&article=fred → ?article=fred&lang=en
102 *
103 * Note: The sorting is neither locale nor Unicode aware (the URI query does not get decoded at all) as the
104 * purpose is to be able to compare URIs in a reproducible way, not to have the params sorted perfectly.
105 */
106 public const SORT_QUERY_PARAMETERS = 128;
107
108 /**
109 * Returns a normalized URI.
110 *
111 * The scheme and host component are already normalized to lowercase per PSR-7 UriInterface.
112 * This methods adds additional normalizations that can be configured with the $flags parameter.
113 *
114 * PSR-7 UriInterface cannot distinguish between an empty component and a missing component as
115 * getQuery(), getFragment() etc. always return a string. This means the URIs "/?#" and "/" are
116 * treated equivalent which is not necessarily true according to RFC 3986. But that difference
117 * is highly uncommon in reality. So this potential normalization is implied in PSR-7 as well.
118 *
119 * @param UriInterface $uri The URI to normalize
120 * @param int $flags A bitmask of normalizations to apply, see constants
121 *
122 * @see https://datatracker.ietf.org/doc/html/rfc3986#section-6.2
123 */
124 public static function normalize(UriInterface $uri, int $flags = self::PRESERVING_NORMALIZATIONS): UriInterface
125 {
126 if ($flags & self::CAPITALIZE_PERCENT_ENCODING) {
127 $uri = self::capitalizePercentEncoding($uri);
128 }
129
130 if ($flags & self::DECODE_UNRESERVED_CHARACTERS) {
131 $uri = self::decodeUnreservedCharacters($uri);
132 }
133
134 if ($flags & self::CONVERT_EMPTY_PATH && $uri->getPath() === ''
135 && ($uri->getScheme() === 'http' || $uri->getScheme() === 'https')
136 ) {
137 $uri = $uri->withPath('/');
138 }
139
140 if ($flags & self::REMOVE_DEFAULT_HOST && $uri->getScheme() === 'file' && $uri->getHost() === 'localhost') {
141 $uri = $uri->withHost('');
142 }
143
144 if ($flags & self::REMOVE_DEFAULT_PORT && $uri->getPort() !== null && Uri::isDefaultPort($uri)) {
145 $uri = $uri->withPort(null);
146 }
147
148 if ($flags & self::REMOVE_DOT_SEGMENTS && !Uri::isRelativePathReference($uri)) {
149 $uri = $uri->withPath(UriResolver::removeDotSegments($uri->getPath()));
150 }
151
152 if ($flags & self::REMOVE_DUPLICATE_SLASHES) {
153 $path = preg_replace('#//++#', '/', $uri->getPath());
154
155 if ($path === null) {
156 throw new \RuntimeException('Unable to remove duplicate slashes from URI path: '.preg_last_error_msg());
157 }
158
159 $uri = $uri->withPath($path);
160 }
161
162 if ($flags & self::SORT_QUERY_PARAMETERS && $uri->getQuery() !== '') {
163 $queryKeyValues = explode('&', $uri->getQuery());
164 sort($queryKeyValues);
165 $uri = $uri->withQuery(implode('&', $queryKeyValues));
166 }
167
168 return $uri;
169 }
170
171 /**
172 * Whether two URIs can be considered equivalent.
173 *
174 * Both URIs are normalized automatically before comparison with the given $normalizations bitmask. The method also
175 * accepts relative URI references and returns true when they are equivalent. This of course assumes they will be
176 * resolved against the same base URI. If this is not the case, determination of equivalence or difference of
177 * relative references does not mean anything.
178 *
179 * @param UriInterface $uri1 An URI to compare
180 * @param UriInterface $uri2 An URI to compare
181 * @param int $normalizations A bitmask of normalizations to apply, see constants
182 *
183 * @see https://datatracker.ietf.org/doc/html/rfc3986#section-6.1
184 */
185 public static function isEquivalent(UriInterface $uri1, UriInterface $uri2, int $normalizations = self::PRESERVING_NORMALIZATIONS): bool
186 {
187 return (string) self::normalize($uri1, $normalizations) === (string) self::normalize($uri2, $normalizations);
188 }
189
190 private static function capitalizePercentEncoding(UriInterface $uri): UriInterface
191 {
192 $regex = '/(?:%[A-Fa-f0-9]{2})++/';
193
194 $callback = function (array $match): string {
195 return strtoupper($match[0]);
196 };
197
198 return $uri
199 ->withPath(self::normalizePercentEncodingInComponent($uri->getPath(), $regex, $callback))
200 ->withQuery(self::normalizePercentEncodingInComponent($uri->getQuery(), $regex, $callback))
201 ->withFragment(self::normalizePercentEncodingInComponent($uri->getFragment(), $regex, $callback));
202 }
203
204 private static function decodeUnreservedCharacters(UriInterface $uri): UriInterface
205 {
206 $regex = '/%(?:2D|2E|5F|7E|3[0-9]|[46][1-9A-F]|[57][0-9A])/i';
207
208 $callback = function (array $match): string {
209 return rawurldecode($match[0]);
210 };
211
212 return $uri
213 ->withPath(self::normalizePercentEncodingInComponent($uri->getPath(), $regex, $callback))
214 ->withQuery(self::normalizePercentEncodingInComponent($uri->getQuery(), $regex, $callback))
215 ->withFragment(self::normalizePercentEncodingInComponent($uri->getFragment(), $regex, $callback));
216 }
217
218 /**
219 * @param callable(array): string $callback
220 */
221 private static function normalizePercentEncodingInComponent(string $component, string $regex, callable $callback): string
222 {
223 $normalized = preg_replace_callback($regex, $callback, $component);
224
225 if ($normalized === null) {
226 throw new \RuntimeException('Unable to normalize URI component percent-encoding: '.preg_last_error_msg());
227 }
228
229 return $normalized;
230 }
231
232 private function __construct()
233 {
234 // cannot be instantiated
235 }
236 }