vendor/symfony/http-client/HttpClientTrait.php line 419

  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Symfony\Component\HttpClient;
  14. use Symfony\Component\HttpClient\Exception\InvalidArgumentException;
  15. use Symfony\Component\HttpClient\Exception\TransportException;
  17. /**
  18.  * Provides the common logic from writing HttpClientInterface implementations.
  19.  *
  20.  * All private methods are static to prevent implementers from creating memory leaks via circular references.
  21.  *
  22.  * @author Nicolas Grekas <p@tchwork.com>
  23.  */
  24. trait HttpClientTrait
  25. {
  26.     private static int $CHUNK_SIZE = 16372;
  28.     public function withOptions(array $options): static
  29.     {
  30.         $clone = clone $this;
  31.         $clone->defaultOptions = self::mergeDefaultOptions($options, $this->defaultOptions);
  33.         return $clone;
  34.     }
  36.     /**
  37.      * Validates and normalizes method, URL and options, and merges them with defaults.
  38.      *
  39.      * @throws InvalidArgumentException When a not-supported option is found
  40.      */
  41.     private static function prepareRequest(?string $method, ?string $url, array $options, array $defaultOptions = [], bool $allowExtraOptions = false): array
  42.     {
  43.         if (null !== $method) {
  44.             if (\strlen($method) !== strspn($method, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ')) {
  45.                 throw new InvalidArgumentException(sprintf('Invalid HTTP method "%s", only uppercase letters are accepted.', $method));
  46.             }
  47.             if (!$method) {
  48.                 throw new InvalidArgumentException('The HTTP method cannot be empty.');
  49.             }
  50.         }
  52.         $options = self::mergeDefaultOptions($options, $defaultOptions, $allowExtraOptions);
  54.         $buffer = $options['buffer'] ?? true;
  56.         if ($buffer instanceof \Closure) {
  57.             $options['buffer'] = static function (array $headers) use ($buffer) {
  58.                 if (!\is_bool($buffer = $buffer($headers))) {
  59.                     if (!\is_array($bufferInfo = @stream_get_meta_data($buffer))) {
  60.                         throw new \LogicException(sprintf('The closure passed as option "buffer" must return bool or stream resource, got "%s".', get_debug_type($buffer)));
  61.                     }
  63.                     if (false === strpbrk($bufferInfo['mode'], 'acew+')) {
  64.                         throw new \LogicException(sprintf('The stream returned by the closure passed as option "buffer" must be writeable, got mode "%s".', $bufferInfo['mode']));
  65.                     }
  66.                 }
  68.                 return $buffer;
  69.             };
  70.         } elseif (!\is_bool($buffer)) {
  71.             if (!\is_array($bufferInfo = @stream_get_meta_data($buffer))) {
  72.                 throw new InvalidArgumentException(sprintf('Option "buffer" must be bool, stream resource or Closure, "%s" given.', get_debug_type($buffer)));
  73.             }
  75.             if (false === strpbrk($bufferInfo['mode'], 'acew+')) {
  76.                 throw new InvalidArgumentException(sprintf('The stream in option "buffer" must be writeable, mode "%s" given.', $bufferInfo['mode']));
  77.             }
  78.         }
  80.         if (isset($options['json'])) {
  81.             if (isset($options['body']) && '' !== $options['body']) {
  82.                 throw new InvalidArgumentException('Define either the "json" or the "body" option, setting both is not supported.');
  83.             }
  84.             $options['body'] = self::jsonEncode($options['json']);
  85.             unset($options['json']);
  87.             if (!isset($options['normalized_headers']['content-type'])) {
  88.                 $options['normalized_headers']['content-type'] = ['Content-Type: application/json'];
  89.             }
  90.         }
  92.         if (!isset($options['normalized_headers']['accept'])) {
  93.             $options['normalized_headers']['accept'] = ['Accept: */*'];
  94.         }
  96.         if (isset($options['body'])) {
  97.             if (\is_array($options['body']) && (!isset($options['normalized_headers']['content-type'][0]) || !str_contains($options['normalized_headers']['content-type'][0], 'application/x-www-form-urlencoded'))) {
  98.                 $options['normalized_headers']['content-type'] = ['Content-Type: application/x-www-form-urlencoded'];
  99.             }
  101.             $options['body'] = self::normalizeBody($options['body']);
  103.             if (\is_string($options['body'])
  104.                 && (string) \strlen($options['body']) !== substr($h = $options['normalized_headers']['content-length'][0] ?? '', 16)
  105.                 && ('' !== $h || '' !== $options['body'])
  106.             ) {
  107.                 if ('chunked' === substr($options['normalized_headers']['transfer-encoding'][0] ?? '', \strlen('Transfer-Encoding: '))) {
  108.                     unset($options['normalized_headers']['transfer-encoding']);
  109.                     $options['body'] = self::dechunk($options['body']);
  110.                 }
  112.                 $options['normalized_headers']['content-length'] = [substr_replace($h ?: 'Content-Length: ', \strlen($options['body']), 16)];
  113.             }
  114.         }
  116.         if (isset($options['peer_fingerprint'])) {
  117.             $options['peer_fingerprint'] = self::normalizePeerFingerprint($options['peer_fingerprint']);
  118.         }
  120.         // Validate on_progress
  121.         if (isset($options['on_progress']) && !\is_callable($onProgress = $options['on_progress'])) {
  122.             throw new InvalidArgumentException(sprintf('Option "on_progress" must be callable, "%s" given.', get_debug_type($onProgress)));
  123.         }
  125.         if (\is_array($options['auth_basic'] ?? null)) {
  126.             $count = \count($options['auth_basic']);
  127.             if ($count <= 0 || $count > 2) {
  128.                 throw new InvalidArgumentException(sprintf('Option "auth_basic" must contain 1 or 2 elements, "%s" given.', $count));
  129.             }
  131.             $options['auth_basic'] = implode(':', $options['auth_basic']);
  132.         }
  134.         if (!\is_string($options['auth_basic'] ?? '')) {
  135.             throw new InvalidArgumentException(sprintf('Option "auth_basic" must be string or an array, "%s" given.', get_debug_type($options['auth_basic'])));
  136.         }
  138.         if (isset($options['auth_bearer'])) {
  139.             if (!\is_string($options['auth_bearer'])) {
  140.                 throw new InvalidArgumentException(sprintf('Option "auth_bearer" must be a string, "%s" given.', get_debug_type($options['auth_bearer'])));
  141.             }
  142.             if (preg_match('{[^\x21-\x7E]}', $options['auth_bearer'])) {
  143.                 throw new InvalidArgumentException('Invalid character found in option "auth_bearer": '.json_encode($options['auth_bearer']).'.');
  144.             }
  145.         }
  147.         if (isset($options['auth_basic'], $options['auth_bearer'])) {
  148.             throw new InvalidArgumentException('Define either the "auth_basic" or the "auth_bearer" option, setting both is not supported.');
  149.         }
  151.         if (null !== $url) {
  152.             // Merge auth with headers
  153.             if (($options['auth_basic'] ?? false) && !($options['normalized_headers']['authorization'] ?? false)) {
  154.                 $options['normalized_headers']['authorization'] = ['Authorization: Basic '.base64_encode($options['auth_basic'])];
  155.             }
  156.             // Merge bearer with headers
  157.             if (($options['auth_bearer'] ?? false) && !($options['normalized_headers']['authorization'] ?? false)) {
  158.                 $options['normalized_headers']['authorization'] = ['Authorization: Bearer '.$options['auth_bearer']];
  159.             }
  161.             unset($options['auth_basic'], $options['auth_bearer']);
  163.             // Parse base URI
  164.             if (\is_string($options['base_uri'])) {
  165.                 $options['base_uri'] = self::parseUrl($options['base_uri']);
  166.             }
  168.             // Validate and resolve URL
  169.             $url = self::parseUrl($url, $options['query']);
  170.             $url = self::resolveUrl($url, $options['base_uri'], $defaultOptions['query'] ?? []);
  171.         }
  173.         // Finalize normalization of options
  174.         $options['http_version'] = (string) ($options['http_version'] ?? '') ?: null;
  175.         if (0 > $options['timeout'] = (float) ($options['timeout'] ?? \ini_get('default_socket_timeout'))) {
  176.             $options['timeout'] = 172800.0; // 2 days
  177.         }
  179.         $options['max_duration'] = isset($options['max_duration']) ? (float) $options['max_duration'] : 0;
  180.         $options['headers'] = array_merge(...array_values($options['normalized_headers']));
  182.         return [$url, $options];
  183.     }
  185.     /**
  186.      * @throws InvalidArgumentException When an invalid option is found
  187.      */
  188.     private static function mergeDefaultOptions(array $options, array $defaultOptions, bool $allowExtraOptions = false): array
  189.     {
  190.         $options['normalized_headers'] = self::normalizeHeaders($options['headers'] ?? []);
  192.         if ($defaultOptions['headers'] ?? false) {
  193.             $options['normalized_headers'] += self::normalizeHeaders($defaultOptions['headers']);
  194.         }
  196.         $options['headers'] = array_merge(...array_values($options['normalized_headers']) ?: [[]]);
  198.         if ($resolve = $options['resolve'] ?? false) {
  199.             $options['resolve'] = [];
  200.             foreach ($resolve as $k => $v) {
  201.                 $options['resolve'][substr(self::parseUrl('http://'.$k)['authority'], 2)] = (string) $v;
  202.             }
  203.         }
  205.         // Option "query" is never inherited from defaults
  206.         $options['query'] ??= [];
  208.         $options += $defaultOptions;
  210.         if (isset(self::$emptyDefaults)) {
  211.             foreach (self::$emptyDefaults as $k => $v) {
  212.                 if (!isset($options[$k])) {
  213.                     $options[$k] = $v;
  214.                 }
  215.             }
  216.         }
  218.         if (isset($defaultOptions['extra'])) {
  219.             $options['extra'] += $defaultOptions['extra'];
  220.         }
  222.         if ($resolve = $defaultOptions['resolve'] ?? false) {
  223.             foreach ($resolve as $k => $v) {
  224.                 $options['resolve'] += [substr(self::parseUrl('http://'.$k)['authority'], 2) => (string) $v];
  225.             }
  226.         }
  228.         if ($allowExtraOptions || !$defaultOptions) {
  229.             return $options;
  230.         }
  232.         // Look for unsupported options
  233.         foreach ($options as $name => $v) {
  234.             if (\array_key_exists($name, $defaultOptions) || 'normalized_headers' === $name) {
  235.                 continue;
  236.             }
  238.             if ('auth_ntlm' === $name) {
  239.                 if (!\extension_loaded('curl')) {
  240.                     $msg = 'try installing the "curl" extension to use "%s" instead.';
  241.                 } else {
  242.                     $msg = 'try using "%s" instead.';
  243.                 }
  245.                 throw new InvalidArgumentException(sprintf('Option "auth_ntlm" is not supported by "%s", '.$msg, __CLASS__, CurlHttpClient::class));
  246.             }
  248.             $alternatives = [];
  250.             foreach ($defaultOptions as $k => $v) {
  251.                 if (levenshtein($name, $k) <= \strlen($name) / 3 || str_contains($k, $name)) {
  252.                     $alternatives[] = $k;
  253.                 }
  254.             }
  256.             throw new InvalidArgumentException(sprintf('Unsupported option "%s" passed to "%s", did you mean "%s"?', $name, __CLASS__, implode('", "', $alternatives ?: array_keys($defaultOptions))));
  257.         }
  259.         return $options;
  260.     }
  262.     /**
  263.      * @return string[][]
  264.      *
  265.      * @throws InvalidArgumentException When an invalid header is found
  266.      */
  267.     private static function normalizeHeaders(array $headers): array
  268.     {
  269.         $normalizedHeaders = [];
  271.         foreach ($headers as $name => $values) {
  272.             if ($values instanceof \Stringable) {
  273.                 $values = (string) $values;
  274.             }
  276.             if (\is_int($name)) {
  277.                 if (!\is_string($values)) {
  278.                     throw new InvalidArgumentException(sprintf('Invalid value for header "%s": expected string, "%s" given.', $name, get_debug_type($values)));
  279.                 }
  280.                 [$name, $values] = explode(':', $values, 2);
  281.                 $values = [ltrim($values)];
  282.             } elseif (!is_iterable($values)) {
  283.                 if (\is_object($values)) {
  284.                     throw new InvalidArgumentException(sprintf('Invalid value for header "%s": expected string, "%s" given.', $name, get_debug_type($values)));
  285.                 }
  287.                 $values = (array) $values;
  288.             }
  290.             $lcName = strtolower($name);
  291.             $normalizedHeaders[$lcName] = [];
  293.             foreach ($values as $value) {
  294.                 $normalizedHeaders[$lcName][] = $value = $name.': '.$value;
  296.                 if (\strlen($value) !== strcspn($value, "\r\n\0")) {
  297.                     throw new InvalidArgumentException(sprintf('Invalid header: CR/LF/NUL found in "%s".', $value));
  298.                 }
  299.             }
  300.         }
  302.         return $normalizedHeaders;
  303.     }
  305.     /**
  306.      * @param array|string|resource|\Traversable|\Closure $body
  307.      *
  308.      * @return string|resource|\Closure
  309.      *
  310.      * @throws InvalidArgumentException When an invalid body is passed
  311.      */
  312.     private static function normalizeBody($body)
  313.     {
  314.         if (\is_array($body)) {
  315.             array_walk_recursive($body, $caster = static function (&$v) use (&$caster) {
  316.                 if (\is_object($v)) {
  317.                     if ($vars = get_object_vars($v)) {
  318.                         array_walk_recursive($vars, $caster);
  319.                         $v = $vars;
  320.                     } elseif (method_exists($v, '__toString')) {
  321.                         $v = (string) $v;
  322.                     }
  323.                 }
  324.             });
  326.             return http_build_query($body, '', '&');
  327.         }
  329.         if (\is_string($body)) {
  330.             return $body;
  331.         }
  333.         $generatorToCallable = static function (\Generator $body): \Closure {
  334.             return static function () use ($body) {
  335.                 while ($body->valid()) {
  336.                     $chunk = $body->current();
  337.                     $body->next();
  339.                     if ('' !== $chunk) {
  340.                         return $chunk;
  341.                     }
  342.                 }
  344.                 return '';
  345.             };
  346.         };
  348.         if ($body instanceof \Generator) {
  349.             return $generatorToCallable($body);
  350.         }
  352.         if ($body instanceof \Traversable) {
  353.             return $generatorToCallable((static function ($body) { yield from $body; })($body));
  354.         }
  356.         if ($body instanceof \Closure) {
  357.             $r = new \ReflectionFunction($body);
  358.             $body = $r->getClosure();
  360.             if ($r->isGenerator()) {
  361.                 $body = $body(self::$CHUNK_SIZE);
  363.                 return $generatorToCallable($body);
  364.             }
  366.             return $body;
  367.         }
  369.         if (!\is_array(@stream_get_meta_data($body))) {
  370.             throw new InvalidArgumentException(sprintf('Option "body" must be string, stream resource, iterable or callable, "%s" given.', get_debug_type($body)));
  371.         }
  373.         return $body;
  374.     }
  376.     private static function dechunk(string $body): string
  377.     {
  378.         $h = fopen('php://temp', 'w+');
  379.         stream_filter_append($h, 'dechunk', \STREAM_FILTER_WRITE);
  380.         fwrite($h, $body);
  381.         $body = stream_get_contents($h, -1, 0);
  382.         rewind($h);
  383.         ftruncate($h, 0);
  385.         if (fwrite($h, '-') && '' !== stream_get_contents($h, -1, 0)) {
  386.             throw new TransportException('Request body has broken chunked encoding.');
  387.         }
  389.         return $body;
  390.     }
  392.     /**
  393.      * @throws InvalidArgumentException When an invalid fingerprint is passed
  394.      */
  395.     private static function normalizePeerFingerprint(mixed $fingerprint): array
  396.     {
  397.         if (\is_string($fingerprint)) {
  398.             $fingerprint = match (\strlen($fingerprint = str_replace(':', '', $fingerprint))) {
  399.                 32 => ['md5' => $fingerprint],
  400.                 40 => ['sha1' => $fingerprint],
  401.                 44 => ['pin-sha256' => [$fingerprint]],
  402.                 64 => ['sha256' => $fingerprint],
  403.                 default => throw new InvalidArgumentException(sprintf('Cannot auto-detect fingerprint algorithm for "%s".', $fingerprint)),
  404.             };
  405.         } elseif (\is_array($fingerprint)) {
  406.             foreach ($fingerprint as $algo => $hash) {
  407.                 $fingerprint[$algo] = 'pin-sha256' === $algo ? (array) $hash : str_replace(':', '', $hash);
  408.             }
  409.         } else {
  410.             throw new InvalidArgumentException(sprintf('Option "peer_fingerprint" must be string or array, "%s" given.', get_debug_type($fingerprint)));
  411.         }
  413.         return $fingerprint;
  414.     }
  416.     /**
  417.      * @throws InvalidArgumentException When the value cannot be json-encoded
  418.      */
  419.     private static function jsonEncode(mixed $value, int $flags = null, int $maxDepth = 512): string
  420.     {
  421.         $flags ??= \JSON_HEX_TAG | \JSON_HEX_APOS | \JSON_HEX_AMP | \JSON_HEX_QUOT | \JSON_PRESERVE_ZERO_FRACTION;
  423.         try {
  424.             $value = json_encode($value, $flags | \JSON_THROW_ON_ERROR, $maxDepth);
  425.         } catch (\JsonException $e) {
  426.             throw new InvalidArgumentException('Invalid value for "json" option: '.$e->getMessage());
  427.         }
  429.         return $value;
  430.     }
  432.     /**
  433.      * Resolves a URL against a base URI.
  434.      *
  435.      * @see https://tools.ietf.org/html/rfc3986#section-5.2.2
  436.      *
  437.      * @throws InvalidArgumentException When an invalid URL is passed
  438.      */
  439.     private static function resolveUrl(array $url, ?array $base, array $queryDefaults = []): array
  440.     {
  441.         if (null !== $base && '' === ($base['scheme'] ?? '').($base['authority'] ?? '')) {
  442.             throw new InvalidArgumentException(sprintf('Invalid "base_uri" option: host or scheme is missing in "%s".', implode('', $base)));
  443.         }
  445.         if (null === $url['scheme'] && (null === $base || null === $base['scheme'])) {
  446.             throw new InvalidArgumentException(sprintf('Invalid URL: scheme is missing in "%s". Did you forget to add "http(s)://"?', implode('', $base ?? $url)));
  447.         }
  449.         if (null === $base && '' === $url['scheme'].$url['authority']) {
  450.             throw new InvalidArgumentException(sprintf('Invalid URL: no "base_uri" option was provided and host or scheme is missing in "%s".', implode('', $url)));
  451.         }
  453.         if (null !== $url['scheme']) {
  454.             $url['path'] = self::removeDotSegments($url['path'] ?? '');
  455.         } else {
  456.             if (null !== $url['authority']) {
  457.                 $url['path'] = self::removeDotSegments($url['path'] ?? '');
  458.             } else {
  459.                 if (null === $url['path']) {
  460.                     $url['path'] = $base['path'];
  461.                     $url['query'] ??= $base['query'];
  462.                 } else {
  463.                     if ('/' !== $url['path'][0]) {
  464.                         if (null === $base['path']) {
  465.                             $url['path'] = '/'.$url['path'];
  466.                         } else {
  467.                             $segments = explode('/', $base['path']);
  468.                             array_splice($segments, -1, 1, [$url['path']]);
  469.                             $url['path'] = implode('/', $segments);
  470.                         }
  471.                     }
  473.                     $url['path'] = self::removeDotSegments($url['path']);
  474.                 }
  476.                 $url['authority'] = $base['authority'];
  478.                 if ($queryDefaults) {
  479.                     $url['query'] = '?'.self::mergeQueryString(substr($url['query'] ?? '', 1), $queryDefaults, false);
  480.                 }
  481.             }
  483.             $url['scheme'] = $base['scheme'];
  484.         }
  486.         if ('' === ($url['path'] ?? '')) {
  487.             $url['path'] = '/';
  488.         }
  490.         if ('?' === ($url['query'] ?? '')) {
  491.             $url['query'] = null;
  492.         }
  494.         return $url;
  495.     }
  497.     /**
  498.      * Parses a URL and fixes its encoding if needed.
  499.      *
  500.      * @throws InvalidArgumentException When an invalid URL is passed
  501.      */
  502.     private static function parseUrl(string $url, array $query = [], array $allowedSchemes = ['http' => 80, 'https' => 443]): array
  503.     {
  504.         if (false === $parts = parse_url($url)) {
  505.             throw new InvalidArgumentException(sprintf('Malformed URL "%s".', $url));
  506.         }
  508.         if ($query) {
  509.             $parts['query'] = self::mergeQueryString($parts['query'] ?? null, $query, true);
  510.         }
  512.         $port = $parts['port'] ?? 0;
  514.         if (null !== $scheme = $parts['scheme'] ?? null) {
  515.             if (!isset($allowedSchemes[$scheme = strtolower($scheme)])) {
  516.                 throw new InvalidArgumentException(sprintf('Unsupported scheme in "%s".', $url));
  517.             }
  519.             $port = $allowedSchemes[$scheme] === $port ? 0 : $port;
  520.             $scheme .= ':';
  521.         }
  523.         if (null !== $host = $parts['host'] ?? null) {
  524.             if (!\defined('INTL_IDNA_VARIANT_UTS46') && preg_match('/[\x80-\xFF]/', $host)) {
  525.                 throw new InvalidArgumentException(sprintf('Unsupported IDN "%s", try enabling the "intl" PHP extension or running "composer require symfony/polyfill-intl-idn".', $host));
  526.             }
  528.             $host = \defined('INTL_IDNA_VARIANT_UTS46') ? idn_to_ascii($host, \IDNA_DEFAULT | \IDNA_USE_STD3_RULES | \IDNA_CHECK_BIDI | \IDNA_CHECK_CONTEXTJ | \IDNA_NONTRANSITIONAL_TO_ASCII, \INTL_IDNA_VARIANT_UTS46) ?: strtolower($host) : strtolower($host);
  529.             $host .= $port ? ':'.$port : '';
  530.         }
  532.         foreach (['user', 'pass', 'path', 'query', 'fragment'] as $part) {
  533.             if (!isset($parts[$part])) {
  534.                 continue;
  535.             }
  537.             if (str_contains($parts[$part], '%')) {
  538.                 // https://tools.ietf.org/html/rfc3986#section-2.3
  539.                 $parts[$part] = preg_replace_callback('/%(?:2[DE]|3[0-9]|[46][1-9A-F]|5F|[57][0-9A]|7E)++/i', function ($m) { return rawurldecode($m[0]); }, $parts[$part]);
  540.             }
  542.             // https://tools.ietf.org/html/rfc3986#section-3.3
  543.             $parts[$part] = preg_replace_callback("#[^-A-Za-z0-9._~!$&/'()[\]*+,;=:@\\\\^`{|}%]++#", function ($m) { return rawurlencode($m[0]); }, $parts[$part]);
  544.         }
  546.         return [
  547.             'scheme' => $scheme,
  548.             'authority' => null !== $host ? '//'.(isset($parts['user']) ? $parts['user'].(isset($parts['pass']) ? ':'.$parts['pass'] : '').'@' : '').$host : null,
  549.             'path' => isset($parts['path'][0]) ? $parts['path'] : null,
  550.             'query' => isset($parts['query']) ? '?'.$parts['query'] : null,
  551.             'fragment' => isset($parts['fragment']) ? '#'.$parts['fragment'] : null,
  552.         ];
  553.     }
  555.     /**
  556.      * Removes dot-segments from a path.
  557.      *
  558.      * @see https://tools.ietf.org/html/rfc3986#section-5.2.4
  559.      */
  560.     private static function removeDotSegments(string $path)
  561.     {
  562.         $result = '';
  564.         while (!\in_array($path, ['', '.', '..'], true)) {
  565.             if ('.' === $path[0] && (str_starts_with($path, $p = '../') || str_starts_with($path, $p = './'))) {
  566.                 $path = substr($path, \strlen($p));
  567.             } elseif ('/.' === $path || str_starts_with($path, '/./')) {
  568.                 $path = substr_replace($path, '/', 0, 3);
  569.             } elseif ('/..' === $path || str_starts_with($path, '/../')) {
  570.                 $i = strrpos($result, '/');
  571.                 $result = $i ? substr($result, 0, $i) : '';
  572.                 $path = substr_replace($path, '/', 0, 4);
  573.             } else {
  574.                 $i = strpos($path, '/', 1) ?: \strlen($path);
  575.                 $result .= substr($path, 0, $i);
  576.                 $path = substr($path, $i);
  577.             }
  578.         }
  580.         return $result;
  581.     }
  583.     /**
  584.      * Merges and encodes a query array with a query string.
  585.      *
  586.      * @throws InvalidArgumentException When an invalid query-string value is passed
  587.      */
  588.     private static function mergeQueryString(?string $queryString, array $queryArray, bool $replace): ?string
  589.     {
  590.         if (!$queryArray) {
  591.             return $queryString;
  592.         }
  594.         $query = [];
  596.         if (null !== $queryString) {
  597.             foreach (explode('&', $queryString) as $v) {
  598.                 if ('' !== $v) {
  599.                     $k = urldecode(explode('=', $v, 2)[0]);
  600.                     $query[$k] = (isset($query[$k]) ? $query[$k].'&' : '').$v;
  601.                 }
  602.             }
  603.         }
  605.         if ($replace) {
  606.             foreach ($queryArray as $k => $v) {
  607.                 if (null === $v) {
  608.                     unset($query[$k]);
  609.                 }
  610.             }
  611.         }
  613.         $queryString = http_build_query($queryArray, '', '&', \PHP_QUERY_RFC3986);
  614.         $queryArray = [];
  616.         if ($queryString) {
  617.             if (str_contains($queryString, '%')) {
  618.                 // https://tools.ietf.org/html/rfc3986#section-2.3 + some chars not encoded by browsers
  619.                 $queryString = strtr($queryString, [
  620.                     '%21' => '!',
  621.                     '%24' => '$',
  622.                     '%28' => '(',
  623.                     '%29' => ')',
  624.                     '%2A' => '*',
  625.                     '%2F' => '/',
  626.                     '%3A' => ':',
  627.                     '%3B' => ';',
  628.                     '%40' => '@',
  629.                     '%5B' => '[',
  630.                     '%5C' => '\\',
  631.                     '%5D' => ']',
  632.                     '%5E' => '^',
  633.                     '%60' => '`',
  634.                     '%7C' => '|',
  635.                 ]);
  636.             }
  638.             foreach (explode('&', $queryString) as $v) {
  639.                 $queryArray[rawurldecode(explode('=', $v, 2)[0])] = $v;
  640.             }
  641.         }
  643.         return implode('&', $replace ? array_replace($query, $queryArray) : ($query + $queryArray));
  644.     }
  646.     /**
  647.      * Loads proxy configuration from the same environment variables as curl when no proxy is explicitly set.
  648.      */
  649.     private static function getProxy(?string $proxy, array $url, ?string $noProxy): ?array
  650.     {
  651.         if (null === $proxy = self::getProxyUrl($proxy, $url)) {
  652.             return null;
  653.         }
  655.         $proxy = (parse_url($proxy) ?: []) + ['scheme' => 'http'];
  657.         if (!isset($proxy['host'])) {
  658.             throw new TransportException('Invalid HTTP proxy: host is missing.');
  659.         }
  661.         if ('http' === $proxy['scheme']) {
  662.             $proxyUrl = 'tcp://'.$proxy['host'].':'.($proxy['port'] ?? '80');
  663.         } elseif ('https' === $proxy['scheme']) {
  664.             $proxyUrl = 'ssl://'.$proxy['host'].':'.($proxy['port'] ?? '443');
  665.         } else {
  666.             throw new TransportException(sprintf('Unsupported proxy scheme "%s": "http" or "https" expected.', $proxy['scheme']));
  667.         }
  669.         $noProxy ??= $_SERVER['no_proxy'] ?? $_SERVER['NO_PROXY'] ?? '';
  670.         $noProxy = $noProxy ? preg_split('/[\s,]+/', $noProxy) : [];
  672.         return [
  673.             'url' => $proxyUrl,
  674.             'auth' => isset($proxy['user']) ? 'Basic '.base64_encode(rawurldecode($proxy['user']).':'.rawurldecode($proxy['pass'] ?? '')) : null,
  675.             'no_proxy' => $noProxy,
  676.         ];
  677.     }
  679.     private static function getProxyUrl(?string $proxy, array $url): ?string
  680.     {
  681.         if (null !== $proxy) {
  682.             return $proxy;
  683.         }
  685.         // Ignore HTTP_PROXY except on the CLI to work around httpoxy set of vulnerabilities
  686.         $proxy = $_SERVER['http_proxy'] ?? (\in_array(\PHP_SAPI, ['cli', 'phpdbg'], true) ? $_SERVER['HTTP_PROXY'] ?? null : null) ?? $_SERVER['all_proxy'] ?? $_SERVER['ALL_PROXY'] ?? null;
  688.         if ('https:' === $url['scheme']) {
  689.             $proxy = $_SERVER['https_proxy'] ?? $_SERVER['HTTPS_PROXY'] ?? $proxy;
  690.         }
  692.         return $proxy;
  693.     }
  695.     private static function shouldBuffer(array $headers): bool
  696.     {
  697.         if (null === $contentType = $headers['content-type'][0] ?? null) {
  698.             return false;
  699.         }
  701.         if (false !== $i = strpos($contentType, ';')) {
  702.             $contentType = substr($contentType, 0, $i);
  703.         }
  705.         return $contentType && preg_match('#^(?:text/|application/(?:.+\+)?(?:json|xml)$)#i', $contentType);
  706.     }
  707. }