1<?php
2namespace GuzzleHttp\Psr7;
3
4use Psr\Http\Message\UriInterface;
5
6/**
7 * PSR-7 URI implementation.
8 *
9 * @author Michael Dowling
10 * @author Tobias Schultze
11 * @author Matthew Weier O'Phinney
12 */
13class Uri implements UriInterface
14{
15    /**
16     * Absolute http and https URIs require a host per RFC 7230 Section 2.7
17     * but in generic URIs the host can be empty. So for http(s) URIs
18     * we apply this default host when no host is given yet to form a
19     * valid URI.
20     */
21    const HTTP_DEFAULT_HOST = 'localhost';
22
23    private static $defaultPorts = [
24        'http'  => 80,
25        'https' => 443,
26        'ftp' => 21,
27        'gopher' => 70,
28        'nntp' => 119,
29        'news' => 119,
30        'telnet' => 23,
31        'tn3270' => 23,
32        'imap' => 143,
33        'pop' => 110,
34        'ldap' => 389,
35    ];
36
37    private static $charUnreserved = 'a-zA-Z0-9_\-\.~';
38    private static $charSubDelims = '!\$&\'\(\)\*\+,;=';
39    private static $replaceQuery = ['=' => '%3D', '&' => '%26'];
40
41    /** @var string Uri scheme. */
42    private $scheme = '';
43
44    /** @var string Uri user info. */
45    private $userInfo = '';
46
47    /** @var string Uri host. */
48    private $host = '';
49
50    /** @var int|null Uri port. */
51    private $port;
52
53    /** @var string Uri path. */
54    private $path = '';
55
56    /** @var string Uri query string. */
57    private $query = '';
58
59    /** @var string Uri fragment. */
60    private $fragment = '';
61
62    /**
63     * @param string $uri URI to parse
64     */
65    public function __construct($uri = '')
66    {
67        // weak type check to also accept null until we can add scalar type hints
68        if ($uri != '') {
69            $parts = parse_url($uri);
70            if ($parts === false) {
71                throw new \InvalidArgumentException("Unable to parse URI: $uri");
72            }
73            $this->applyParts($parts);
74        }
75    }
76
77    public function __toString()
78    {
79        return self::composeComponents(
80            $this->scheme,
81            $this->getAuthority(),
82            $this->path,
83            $this->query,
84            $this->fragment
85        );
86    }
87
88    /**
89     * Composes a URI reference string from its various components.
90     *
91     * Usually this method does not need to be called manually but instead is used indirectly via
92     * `Psr\Http\Message\UriInterface::__toString`.
93     *
94     * PSR-7 UriInterface treats an empty component the same as a missing component as
95     * getQuery(), getFragment() etc. always return a string. This explains the slight
96     * difference to RFC 3986 Section 5.3.
97     *
98     * Another adjustment is that the authority separator is added even when the authority is missing/empty
99     * for the "file" scheme. This is because PHP stream functions like `file_get_contents` only work with
100     * `file:///myfile` but not with `file:/myfile` although they are equivalent according to RFC 3986. But
101     * `file:///` is the more common syntax for the file scheme anyway (Chrome for example redirects to
102     * that format).
103     *
104     * @param string $scheme
105     * @param string $authority
106     * @param string $path
107     * @param string $query
108     * @param string $fragment
109     *
110     * @return string
111     *
112     * @link https://tools.ietf.org/html/rfc3986#section-5.3
113     */
114    public static function composeComponents($scheme, $authority, $path, $query, $fragment)
115    {
116        $uri = '';
117
118        // weak type checks to also accept null until we can add scalar type hints
119        if ($scheme != '') {
120            $uri .= $scheme . ':';
121        }
122
123        if ($authority != ''|| $scheme === 'file') {
124            $uri .= '//' . $authority;
125        }
126
127        $uri .= $path;
128
129        if ($query != '') {
130            $uri .= '?' . $query;
131        }
132
133        if ($fragment != '') {
134            $uri .= '#' . $fragment;
135        }
136
137        return $uri;
138    }
139
140    /**
141     * Whether the URI has the default port of the current scheme.
142     *
143     * `Psr\Http\Message\UriInterface::getPort` may return null or the standard port. This method can be used
144     * independently of the implementation.
145     *
146     * @param UriInterface $uri
147     *
148     * @return bool
149     */
150    public static function isDefaultPort(UriInterface $uri)
151    {
152        return $uri->getPort() === null
153            || (isset(self::$defaultPorts[$uri->getScheme()]) && $uri->getPort() === self::$defaultPorts[$uri->getScheme()]);
154    }
155
156    /**
157     * Whether the URI is absolute, i.e. it has a scheme.
158     *
159     * An instance of UriInterface can either be an absolute URI or a relative reference. This method returns true
160     * if it is the former. An absolute URI has a scheme. A relative reference is used to express a URI relative
161     * to another URI, the base URI. Relative references can be divided into several forms:
162     * - network-path references, e.g. '//example.com/path'
163     * - absolute-path references, e.g. '/path'
164     * - relative-path references, e.g. 'subpath'
165     *
166     * @param UriInterface $uri
167     *
168     * @return bool
169     * @see Uri::isNetworkPathReference
170     * @see Uri::isAbsolutePathReference
171     * @see Uri::isRelativePathReference
172     * @link https://tools.ietf.org/html/rfc3986#section-4
173     */
174    public static function isAbsolute(UriInterface $uri)
175    {
176        return $uri->getScheme() !== '';
177    }
178
179    /**
180     * Whether the URI is a network-path reference.
181     *
182     * A relative reference that begins with two slash characters is termed an network-path reference.
183     *
184     * @param UriInterface $uri
185     *
186     * @return bool
187     * @link https://tools.ietf.org/html/rfc3986#section-4.2
188     */
189    public static function isNetworkPathReference(UriInterface $uri)
190    {
191        return $uri->getScheme() === '' && $uri->getAuthority() !== '';
192    }
193
194    /**
195     * Whether the URI is a absolute-path reference.
196     *
197     * A relative reference that begins with a single slash character is termed an absolute-path reference.
198     *
199     * @param UriInterface $uri
200     *
201     * @return bool
202     * @link https://tools.ietf.org/html/rfc3986#section-4.2
203     */
204    public static function isAbsolutePathReference(UriInterface $uri)
205    {
206        return $uri->getScheme() === ''
207            && $uri->getAuthority() === ''
208            && isset($uri->getPath()[0])
209            && $uri->getPath()[0] === '/';
210    }
211
212    /**
213     * Whether the URI is a relative-path reference.
214     *
215     * A relative reference that does not begin with a slash character is termed a relative-path reference.
216     *
217     * @param UriInterface $uri
218     *
219     * @return bool
220     * @link https://tools.ietf.org/html/rfc3986#section-4.2
221     */
222    public static function isRelativePathReference(UriInterface $uri)
223    {
224        return $uri->getScheme() === ''
225            && $uri->getAuthority() === ''
226            && (!isset($uri->getPath()[0]) || $uri->getPath()[0] !== '/');
227    }
228
229    /**
230     * Whether the URI is a same-document reference.
231     *
232     * A same-document reference refers to a URI that is, aside from its fragment
233     * component, identical to the base URI. When no base URI is given, only an empty
234     * URI reference (apart from its fragment) is considered a same-document reference.
235     *
236     * @param UriInterface      $uri  The URI to check
237     * @param UriInterface|null $base An optional base URI to compare against
238     *
239     * @return bool
240     * @link https://tools.ietf.org/html/rfc3986#section-4.4
241     */
242    public static function isSameDocumentReference(UriInterface $uri, UriInterface $base = null)
243    {
244        if ($base !== null) {
245            $uri = UriResolver::resolve($base, $uri);
246
247            return ($uri->getScheme() === $base->getScheme())
248                && ($uri->getAuthority() === $base->getAuthority())
249                && ($uri->getPath() === $base->getPath())
250                && ($uri->getQuery() === $base->getQuery());
251        }
252
253        return $uri->getScheme() === '' && $uri->getAuthority() === '' && $uri->getPath() === '' && $uri->getQuery() === '';
254    }
255
256    /**
257     * Removes dot segments from a path and returns the new path.
258     *
259     * @param string $path
260     *
261     * @return string
262     *
263     * @deprecated since version 1.4. Use UriResolver::removeDotSegments instead.
264     * @see UriResolver::removeDotSegments
265     */
266    public static function removeDotSegments($path)
267    {
268        return UriResolver::removeDotSegments($path);
269    }
270
271    /**
272     * Converts the relative URI into a new URI that is resolved against the base URI.
273     *
274     * @param UriInterface        $base Base URI
275     * @param string|UriInterface $rel  Relative URI
276     *
277     * @return UriInterface
278     *
279     * @deprecated since version 1.4. Use UriResolver::resolve instead.
280     * @see UriResolver::resolve
281     */
282    public static function resolve(UriInterface $base, $rel)
283    {
284        if (!($rel instanceof UriInterface)) {
285            $rel = new self($rel);
286        }
287
288        return UriResolver::resolve($base, $rel);
289    }
290
291    /**
292     * Creates a new URI with a specific query string value removed.
293     *
294     * Any existing query string values that exactly match the provided key are
295     * removed.
296     *
297     * @param UriInterface $uri URI to use as a base.
298     * @param string       $key Query string key to remove.
299     *
300     * @return UriInterface
301     */
302    public static function withoutQueryValue(UriInterface $uri, $key)
303    {
304        $result = self::getFilteredQueryString($uri, [$key]);
305
306        return $uri->withQuery(implode('&', $result));
307    }
308
309    /**
310     * Creates a new URI with a specific query string value.
311     *
312     * Any existing query string values that exactly match the provided key are
313     * removed and replaced with the given key value pair.
314     *
315     * A value of null will set the query string key without a value, e.g. "key"
316     * instead of "key=value".
317     *
318     * @param UriInterface $uri   URI to use as a base.
319     * @param string       $key   Key to set.
320     * @param string|null  $value Value to set
321     *
322     * @return UriInterface
323     */
324    public static function withQueryValue(UriInterface $uri, $key, $value)
325    {
326        $result = self::getFilteredQueryString($uri, [$key]);
327
328        $result[] = self::generateQueryString($key, $value);
329
330        return $uri->withQuery(implode('&', $result));
331    }
332
333    /**
334     * Creates a new URI with multiple specific query string values.
335     *
336     * It has the same behavior as withQueryValue() but for an associative array of key => value.
337     *
338     * @param UriInterface $uri           URI to use as a base.
339     * @param array        $keyValueArray Associative array of key and values
340     *
341     * @return UriInterface
342     */
343    public static function withQueryValues(UriInterface $uri, array $keyValueArray)
344    {
345        $result = self::getFilteredQueryString($uri, array_keys($keyValueArray));
346
347        foreach ($keyValueArray as $key => $value) {
348            $result[] = self::generateQueryString($key, $value);
349        }
350
351        return $uri->withQuery(implode('&', $result));
352    }
353
354    /**
355     * Creates a URI from a hash of `parse_url` components.
356     *
357     * @param array $parts
358     *
359     * @return UriInterface
360     * @link http://php.net/manual/en/function.parse-url.php
361     *
362     * @throws \InvalidArgumentException If the components do not form a valid URI.
363     */
364    public static function fromParts(array $parts)
365    {
366        $uri = new self();
367        $uri->applyParts($parts);
368        $uri->validateState();
369
370        return $uri;
371    }
372
373    public function getScheme()
374    {
375        return $this->scheme;
376    }
377
378    public function getAuthority()
379    {
380        $authority = $this->host;
381        if ($this->userInfo !== '') {
382            $authority = $this->userInfo . '@' . $authority;
383        }
384
385        if ($this->port !== null) {
386            $authority .= ':' . $this->port;
387        }
388
389        return $authority;
390    }
391
392    public function getUserInfo()
393    {
394        return $this->userInfo;
395    }
396
397    public function getHost()
398    {
399        return $this->host;
400    }
401
402    public function getPort()
403    {
404        return $this->port;
405    }
406
407    public function getPath()
408    {
409        return $this->path;
410    }
411
412    public function getQuery()
413    {
414        return $this->query;
415    }
416
417    public function getFragment()
418    {
419        return $this->fragment;
420    }
421
422    public function withScheme($scheme)
423    {
424        $scheme = $this->filterScheme($scheme);
425
426        if ($this->scheme === $scheme) {
427            return $this;
428        }
429
430        $new = clone $this;
431        $new->scheme = $scheme;
432        $new->removeDefaultPort();
433        $new->validateState();
434
435        return $new;
436    }
437
438    public function withUserInfo($user, $password = null)
439    {
440        $info = $this->filterUserInfoComponent($user);
441        if ($password !== null) {
442            $info .= ':' . $this->filterUserInfoComponent($password);
443        }
444
445        if ($this->userInfo === $info) {
446            return $this;
447        }
448
449        $new = clone $this;
450        $new->userInfo = $info;
451        $new->validateState();
452
453        return $new;
454    }
455
456    public function withHost($host)
457    {
458        $host = $this->filterHost($host);
459
460        if ($this->host === $host) {
461            return $this;
462        }
463
464        $new = clone $this;
465        $new->host = $host;
466        $new->validateState();
467
468        return $new;
469    }
470
471    public function withPort($port)
472    {
473        $port = $this->filterPort($port);
474
475        if ($this->port === $port) {
476            return $this;
477        }
478
479        $new = clone $this;
480        $new->port = $port;
481        $new->removeDefaultPort();
482        $new->validateState();
483
484        return $new;
485    }
486
487    public function withPath($path)
488    {
489        $path = $this->filterPath($path);
490
491        if ($this->path === $path) {
492            return $this;
493        }
494
495        $new = clone $this;
496        $new->path = $path;
497        $new->validateState();
498
499        return $new;
500    }
501
502    public function withQuery($query)
503    {
504        $query = $this->filterQueryAndFragment($query);
505
506        if ($this->query === $query) {
507            return $this;
508        }
509
510        $new = clone $this;
511        $new->query = $query;
512
513        return $new;
514    }
515
516    public function withFragment($fragment)
517    {
518        $fragment = $this->filterQueryAndFragment($fragment);
519
520        if ($this->fragment === $fragment) {
521            return $this;
522        }
523
524        $new = clone $this;
525        $new->fragment = $fragment;
526
527        return $new;
528    }
529
530    /**
531     * Apply parse_url parts to a URI.
532     *
533     * @param array $parts Array of parse_url parts to apply.
534     */
535    private function applyParts(array $parts)
536    {
537        $this->scheme = isset($parts['scheme'])
538            ? $this->filterScheme($parts['scheme'])
539            : '';
540        $this->userInfo = isset($parts['user'])
541            ? $this->filterUserInfoComponent($parts['user'])
542            : '';
543        $this->host = isset($parts['host'])
544            ? $this->filterHost($parts['host'])
545            : '';
546        $this->port = isset($parts['port'])
547            ? $this->filterPort($parts['port'])
548            : null;
549        $this->path = isset($parts['path'])
550            ? $this->filterPath($parts['path'])
551            : '';
552        $this->query = isset($parts['query'])
553            ? $this->filterQueryAndFragment($parts['query'])
554            : '';
555        $this->fragment = isset($parts['fragment'])
556            ? $this->filterQueryAndFragment($parts['fragment'])
557            : '';
558        if (isset($parts['pass'])) {
559            $this->userInfo .= ':' . $this->filterUserInfoComponent($parts['pass']);
560        }
561
562        $this->removeDefaultPort();
563    }
564
565    /**
566     * @param string $scheme
567     *
568     * @return string
569     *
570     * @throws \InvalidArgumentException If the scheme is invalid.
571     */
572    private function filterScheme($scheme)
573    {
574        if (!is_string($scheme)) {
575            throw new \InvalidArgumentException('Scheme must be a string');
576        }
577
578        return strtolower($scheme);
579    }
580
581    /**
582     * @param string $component
583     *
584     * @return string
585     *
586     * @throws \InvalidArgumentException If the user info is invalid.
587     */
588    private function filterUserInfoComponent($component)
589    {
590        if (!is_string($component)) {
591            throw new \InvalidArgumentException('User info must be a string');
592        }
593
594        return preg_replace_callback(
595            '/(?:[^%' . self::$charUnreserved . self::$charSubDelims . ']+|%(?![A-Fa-f0-9]{2}))/',
596            [$this, 'rawurlencodeMatchZero'],
597            $component
598        );
599    }
600
601    /**
602     * @param string $host
603     *
604     * @return string
605     *
606     * @throws \InvalidArgumentException If the host is invalid.
607     */
608    private function filterHost($host)
609    {
610        if (!is_string($host)) {
611            throw new \InvalidArgumentException('Host must be a string');
612        }
613
614        return strtolower($host);
615    }
616
617    /**
618     * @param int|null $port
619     *
620     * @return int|null
621     *
622     * @throws \InvalidArgumentException If the port is invalid.
623     */
624    private function filterPort($port)
625    {
626        if ($port === null) {
627            return null;
628        }
629
630        $port = (int) $port;
631        if (0 > $port || 0xffff < $port) {
632            throw new \InvalidArgumentException(
633                sprintf('Invalid port: %d. Must be between 0 and 65535', $port)
634            );
635        }
636
637        return $port;
638    }
639
640    /**
641     * @param UriInterface $uri
642     * @param array        $keys
643     *
644     * @return array
645     */
646    private static function getFilteredQueryString(UriInterface $uri, array $keys)
647    {
648        $current = $uri->getQuery();
649
650        if ($current === '') {
651            return [];
652        }
653
654        $decodedKeys = array_map('rawurldecode', $keys);
655
656        return array_filter(explode('&', $current), function ($part) use ($decodedKeys) {
657            return !in_array(rawurldecode(explode('=', $part)[0]), $decodedKeys, true);
658        });
659    }
660
661    /**
662     * @param string      $key
663     * @param string|null $value
664     *
665     * @return string
666     */
667    private static function generateQueryString($key, $value)
668    {
669        // Query string separators ("=", "&") within the key or value need to be encoded
670        // (while preventing double-encoding) before setting the query string. All other
671        // chars that need percent-encoding will be encoded by withQuery().
672        $queryString = strtr($key, self::$replaceQuery);
673
674        if ($value !== null) {
675            $queryString .= '=' . strtr($value, self::$replaceQuery);
676        }
677
678        return $queryString;
679    }
680
681    private function removeDefaultPort()
682    {
683        if ($this->port !== null && self::isDefaultPort($this)) {
684            $this->port = null;
685        }
686    }
687
688    /**
689     * Filters the path of a URI
690     *
691     * @param string $path
692     *
693     * @return string
694     *
695     * @throws \InvalidArgumentException If the path is invalid.
696     */
697    private function filterPath($path)
698    {
699        if (!is_string($path)) {
700            throw new \InvalidArgumentException('Path must be a string');
701        }
702
703        return preg_replace_callback(
704            '/(?:[^' . self::$charUnreserved . self::$charSubDelims . '%:@\/]++|%(?![A-Fa-f0-9]{2}))/',
705            [$this, 'rawurlencodeMatchZero'],
706            $path
707        );
708    }
709
710    /**
711     * Filters the query string or fragment of a URI.
712     *
713     * @param string $str
714     *
715     * @return string
716     *
717     * @throws \InvalidArgumentException If the query or fragment is invalid.
718     */
719    private function filterQueryAndFragment($str)
720    {
721        if (!is_string($str)) {
722            throw new \InvalidArgumentException('Query and fragment must be a string');
723        }
724
725        return preg_replace_callback(
726            '/(?:[^' . self::$charUnreserved . self::$charSubDelims . '%:@\/\?]++|%(?![A-Fa-f0-9]{2}))/',
727            [$this, 'rawurlencodeMatchZero'],
728            $str
729        );
730    }
731
732    private function rawurlencodeMatchZero(array $match)
733    {
734        return rawurlencode($match[0]);
735    }
736
737    private function validateState()
738    {
739        if ($this->host === '' && ($this->scheme === 'http' || $this->scheme === 'https')) {
740            $this->host = self::HTTP_DEFAULT_HOST;
741        }
742
743        if ($this->getAuthority() === '') {
744            if (0 === strpos($this->path, '//')) {
745                throw new \InvalidArgumentException('The path of a URI without an authority must not start with two slashes "//"');
746            }
747            if ($this->scheme === '' && false !== strpos(explode('/', $this->path, 2)[0], ':')) {
748                throw new \InvalidArgumentException('A relative URI must not have a path beginning with a segment containing a colon');
749            }
750        } elseif (isset($this->path[0]) && $this->path[0] !== '/') {
751            @trigger_error(
752                'The path of a URI with an authority must start with a slash "/" or be empty. Automagically fixing the URI ' .
753                'by adding a leading slash to the path is deprecated since version 1.4 and will throw an exception instead.',
754                E_USER_DEPRECATED
755            );
756            $this->path = '/'. $this->path;
757            //throw new \InvalidArgumentException('The path of a URI with an authority must start with a slash "/" or be empty');
758        }
759    }
760}
761