vendor/symfony/http-client/CurlHttpClient.php line 309

  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 Psr\Log\LoggerAwareInterface;
  15. use Psr\Log\LoggerInterface;
  16. use Symfony\Component\HttpClient\Exception\InvalidArgumentException;
  17. use Symfony\Component\HttpClient\Exception\TransportException;
  18. use Symfony\Component\HttpClient\Internal\CurlClientState;
  19. use Symfony\Component\HttpClient\Internal\PushedResponse;
  20. use Symfony\Component\HttpClient\Response\CurlResponse;
  21. use Symfony\Component\HttpClient\Response\ResponseStream;
  22. use Symfony\Contracts\HttpClient\HttpClientInterface;
  23. use Symfony\Contracts\HttpClient\ResponseInterface;
  24. use Symfony\Contracts\HttpClient\ResponseStreamInterface;
  25. use Symfony\Contracts\Service\ResetInterface;
  27. /**
  28.  * A performant implementation of the HttpClientInterface contracts based on the curl extension.
  29.  *
  30.  * This provides fully concurrent HTTP requests, with transparent
  31.  * HTTP/2 push when a curl version that supports it is installed.
  32.  *
  33.  * @author Nicolas Grekas <p@tchwork.com>
  34.  */
  35. final class CurlHttpClient implements HttpClientInterface, LoggerAwareInterface, ResetInterface
  36. {
  37.     use HttpClientTrait;
  39.     private array $defaultOptions = self::OPTIONS_DEFAULTS + [
  40.         'auth_ntlm' => null, // array|string - an array containing the username as first value, and optionally the
  41.                              //   password as the second one; or string like username:password - enabling NTLM auth
  42.         'extra' => [
  43.             'curl' => [],    // A list of extra curl options indexed by their corresponding CURLOPT_*
  44.         ],
  45.     ];
  46.     private static array $emptyDefaults = self::OPTIONS_DEFAULTS + ['auth_ntlm' => null];
  48.     private ?LoggerInterface $logger = null;
  50.     /**
  51.      * An internal object to share state between the client and its responses.
  52.      */
  53.     private CurlClientState $multi;
  55.     /**
  56.      * @param array $defaultOptions     Default request's options
  57.      * @param int   $maxHostConnections The maximum number of connections to a single host
  58.      * @param int   $maxPendingPushes   The maximum number of pushed responses to accept in the queue
  59.      *
  60.      * @see HttpClientInterface::OPTIONS_DEFAULTS for available options
  61.      */
  62.     public function __construct(array $defaultOptions = [], int $maxHostConnections = 6, int $maxPendingPushes = 50)
  63.     {
  64.         if (!\extension_loaded('curl')) {
  65.             throw new \LogicException('You cannot use the "Symfony\Component\HttpClient\CurlHttpClient" as the "curl" extension is not installed.');
  66.         }
  68.         $this->defaultOptions['buffer'] ??= self::shouldBuffer(...);
  70.         if ($defaultOptions) {
  71.             [, $this->defaultOptions] = self::prepareRequest(null, null, $defaultOptions, $this->defaultOptions);
  72.         }
  74.         $this->multi = new CurlClientState($maxHostConnections, $maxPendingPushes);
  75.     }
  77.     public function setLogger(LoggerInterface $logger): void
  78.     {
  79.         $this->logger = $this->multi->logger = $logger;
  80.     }
  82.     /**
  83.      * @see HttpClientInterface::OPTIONS_DEFAULTS for available options
  84.      */
  85.     public function request(string $method, string $url, array $options = []): ResponseInterface
  86.     {
  87.         [$url, $options] = self::prepareRequest($method, $url, $options, $this->defaultOptions);
  88.         $scheme = $url['scheme'];
  89.         $authority = $url['authority'];
  90.         $host = parse_url($authority, \PHP_URL_HOST);
  91.         $port = parse_url($authority, \PHP_URL_PORT) ?: ('http:' === $scheme ? 80 : 443);
  92.         $proxy = self::getProxyUrl($options['proxy'], $url);
  93.         $url = implode('', $url);
  95.         if (!isset($options['normalized_headers']['user-agent'])) {
  96.             $options['headers'][] = 'User-Agent: Symfony HttpClient/Curl';
  97.         }
  99.         $curlopts = [
  100.             \CURLOPT_URL => $url,
  101.             \CURLOPT_TCP_NODELAY => true,
  102.             \CURLOPT_PROTOCOLS => \CURLPROTO_HTTP | \CURLPROTO_HTTPS,
  103.             \CURLOPT_REDIR_PROTOCOLS => \CURLPROTO_HTTP | \CURLPROTO_HTTPS,
  104.             \CURLOPT_FOLLOWLOCATION => true,
  105.             \CURLOPT_MAXREDIRS => 0 < $options['max_redirects'] ? $options['max_redirects'] : 0,
  106.             \CURLOPT_COOKIEFILE => '', // Keep track of cookies during redirects
  107.             \CURLOPT_TIMEOUT => 0,
  108.             \CURLOPT_PROXY => $proxy,
  109.             \CURLOPT_NOPROXY => $options['no_proxy'] ?? $_SERVER['no_proxy'] ?? $_SERVER['NO_PROXY'] ?? '',
  110.             \CURLOPT_SSL_VERIFYPEER => $options['verify_peer'],
  111.             \CURLOPT_SSL_VERIFYHOST => $options['verify_host'] ? 2 : 0,
  112.             \CURLOPT_CAINFO => $options['cafile'],
  113.             \CURLOPT_CAPATH => $options['capath'],
  114.             \CURLOPT_SSL_CIPHER_LIST => $options['ciphers'],
  115.             \CURLOPT_SSLCERT => $options['local_cert'],
  116.             \CURLOPT_SSLKEY => $options['local_pk'],
  117.             \CURLOPT_KEYPASSWD => $options['passphrase'],
  118.             \CURLOPT_CERTINFO => $options['capture_peer_cert_chain'],
  119.         ];
  121.         if (1.0 === (float) $options['http_version']) {
  122.             $curlopts[\CURLOPT_HTTP_VERSION] = \CURL_HTTP_VERSION_1_0;
  123.         } elseif (1.1 === (float) $options['http_version']) {
  124.             $curlopts[\CURLOPT_HTTP_VERSION] = \CURL_HTTP_VERSION_1_1;
  125.         } elseif (\defined('CURL_VERSION_HTTP2') && (\CURL_VERSION_HTTP2 & CurlClientState::$curlVersion['features']) && ('https:' === $scheme || 2.0 === (float) $options['http_version'])) {
  126.             $curlopts[\CURLOPT_HTTP_VERSION] = \CURL_HTTP_VERSION_2_0;
  127.         }
  129.         if (isset($options['auth_ntlm'])) {
  130.             $curlopts[\CURLOPT_HTTPAUTH] = \CURLAUTH_NTLM;
  131.             $curlopts[\CURLOPT_HTTP_VERSION] = \CURL_HTTP_VERSION_1_1;
  133.             if (\is_array($options['auth_ntlm'])) {
  134.                 $count = \count($options['auth_ntlm']);
  135.                 if ($count <= 0 || $count > 2) {
  136.                     throw new InvalidArgumentException(sprintf('Option "auth_ntlm" must contain 1 or 2 elements, %d given.', $count));
  137.                 }
  139.                 $options['auth_ntlm'] = implode(':', $options['auth_ntlm']);
  140.             }
  142.             if (!\is_string($options['auth_ntlm'])) {
  143.                 throw new InvalidArgumentException(sprintf('Option "auth_ntlm" must be a string or an array, "%s" given.', get_debug_type($options['auth_ntlm'])));
  144.             }
  146.             $curlopts[\CURLOPT_USERPWD] = $options['auth_ntlm'];
  147.         }
  149.         if (!\ZEND_THREAD_SAFE) {
  150.             $curlopts[\CURLOPT_DNS_USE_GLOBAL_CACHE] = false;
  151.         }
  153.         if (\defined('CURLOPT_HEADEROPT') && \defined('CURLHEADER_SEPARATE')) {
  154.             $curlopts[\CURLOPT_HEADEROPT] = \CURLHEADER_SEPARATE;
  155.         }
  157.         // curl's resolve feature varies by host:port but ours varies by host only, let's handle this with our own DNS map
  158.         if (isset($this->multi->dnsCache->hostnames[$host])) {
  159.             $options['resolve'] += [$host => $this->multi->dnsCache->hostnames[$host]];
  160.         }
  162.         if ($options['resolve'] || $this->multi->dnsCache->evictions) {
  163.             // First reset any old DNS cache entries then add the new ones
  164.             $resolve = $this->multi->dnsCache->evictions;
  165.             $this->multi->dnsCache->evictions = [];
  167.             if ($resolve && 0x072A00 > CurlClientState::$curlVersion['version_number']) {
  168.                 // DNS cache removals require curl 7.42 or higher
  169.                 $this->multi->reset();
  170.             }
  172.             foreach ($options['resolve'] as $host => $ip) {
  173.                 $resolve[] = null === $ip ? "-$host:$port" : "$host:$port:$ip";
  174.                 $this->multi->dnsCache->hostnames[$host] = $ip;
  175.                 $this->multi->dnsCache->removals["-$host:$port"] = "-$host:$port";
  176.             }
  178.             $curlopts[\CURLOPT_RESOLVE] = $resolve;
  179.         }
  181.         if ('POST' === $method) {
  182.             // Use CURLOPT_POST to have browser-like POST-to-GET redirects for 301, 302 and 303
  183.             $curlopts[\CURLOPT_POST] = true;
  184.         } elseif ('HEAD' === $method) {
  185.             $curlopts[\CURLOPT_NOBODY] = true;
  186.         } else {
  187.             $curlopts[\CURLOPT_CUSTOMREQUEST] = $method;
  188.         }
  190.         if ('\\' !== \DIRECTORY_SEPARATOR && $options['timeout'] < 1) {
  191.             $curlopts[\CURLOPT_NOSIGNAL] = true;
  192.         }
  194.         if (\extension_loaded('zlib') && !isset($options['normalized_headers']['accept-encoding'])) {
  195.             $options['headers'][] = 'Accept-Encoding: gzip'; // Expose only one encoding, some servers mess up when more are provided
  196.         }
  197.         $body = $options['body'];
  199.         foreach ($options['headers'] as $i => $header) {
  200.             if (\is_string($body) && '' !== $body && 0 === stripos($header, 'Content-Length: ')) {
  201.                 // Let curl handle Content-Length headers
  202.                 unset($options['headers'][$i]);
  203.                 continue;
  204.             }
  205.             if (':' === $header[-2] && \strlen($header) - 2 === strpos($header, ': ')) {
  206.                 // curl requires a special syntax to send empty headers
  207.                 $curlopts[\CURLOPT_HTTPHEADER][] = substr_replace($header, ';', -2);
  208.             } else {
  209.                 $curlopts[\CURLOPT_HTTPHEADER][] = $header;
  210.             }
  211.         }
  213.         // Prevent curl from sending its default Accept and Expect headers
  214.         foreach (['accept', 'expect'] as $header) {
  215.             if (!isset($options['normalized_headers'][$header][0])) {
  216.                 $curlopts[\CURLOPT_HTTPHEADER][] = $header.':';
  217.             }
  218.         }
  220.         if (!\is_string($body)) {
  221.             if (\is_resource($body)) {
  222.                 $curlopts[\CURLOPT_INFILE] = $body;
  223.             } else {
  224.                 $eof = false;
  225.                 $buffer = '';
  226.                 $curlopts[\CURLOPT_READFUNCTION] = static function ($ch, $fd, $length) use ($body, &$buffer, &$eof) {
  227.                     return self::readRequestBody($length, $body, $buffer, $eof);
  228.                 };
  229.             }
  231.             if (isset($options['normalized_headers']['content-length'][0])) {
  232.                 $curlopts[\CURLOPT_INFILESIZE] = (int) substr($options['normalized_headers']['content-length'][0], \strlen('Content-Length: '));
  233.             }
  234.             if (!isset($options['normalized_headers']['transfer-encoding'])) {
  235.                 $curlopts[\CURLOPT_HTTPHEADER][] = 'Transfer-Encoding:'.(isset($curlopts[\CURLOPT_INFILESIZE]) ? '' : ' chunked');
  236.             }
  238.             if ('POST' !== $method) {
  239.                 $curlopts[\CURLOPT_UPLOAD] = true;
  241.                 if (!isset($options['normalized_headers']['content-type']) && 0 !== ($curlopts[\CURLOPT_INFILESIZE] ?? null)) {
  242.                     $curlopts[\CURLOPT_HTTPHEADER][] = 'Content-Type: application/x-www-form-urlencoded';
  243.                 }
  244.             }
  245.         } elseif ('' !== $body || 'POST' === $method) {
  246.             $curlopts[\CURLOPT_POSTFIELDS] = $body;
  247.         }
  249.         if ($options['peer_fingerprint']) {
  250.             if (!isset($options['peer_fingerprint']['pin-sha256'])) {
  251.                 throw new TransportException(__CLASS__.' supports only "pin-sha256" fingerprints.');
  252.             }
  254.             $curlopts[\CURLOPT_PINNEDPUBLICKEY] = 'sha256//'.implode(';sha256//', $options['peer_fingerprint']['pin-sha256']);
  255.         }
  257.         if ($options['bindto']) {
  258.             if (file_exists($options['bindto'])) {
  259.                 $curlopts[\CURLOPT_UNIX_SOCKET_PATH] = $options['bindto'];
  260.             } elseif (!str_starts_with($options['bindto'], 'if!') && preg_match('/^(.*):(\d+)$/', $options['bindto'], $matches)) {
  261.                 $curlopts[\CURLOPT_INTERFACE] = $matches[1];
  262.                 $curlopts[\CURLOPT_LOCALPORT] = $matches[2];
  263.             } else {
  264.                 $curlopts[\CURLOPT_INTERFACE] = $options['bindto'];
  265.             }
  266.         }
  268.         if (0 < $options['max_duration']) {
  269.             $curlopts[\CURLOPT_TIMEOUT_MS] = 1000 * $options['max_duration'];
  270.         }
  272.         if (!empty($options['extra']['curl']) && \is_array($options['extra']['curl'])) {
  273.             $this->validateExtraCurlOptions($options['extra']['curl']);
  274.             $curlopts += $options['extra']['curl'];
  275.         }
  277.         if ($pushedResponse = $this->multi->pushedResponses[$url] ?? null) {
  278.             unset($this->multi->pushedResponses[$url]);
  280.             if (self::acceptPushForRequest($method, $options, $pushedResponse)) {
  281.                 $this->logger?->debug(sprintf('Accepting pushed response: "%s %s"', $method, $url));
  283.                 // Reinitialize the pushed response with request's options
  284.                 $ch = $pushedResponse->handle;
  285.                 $pushedResponse = $pushedResponse->response;
  286.                 $pushedResponse->__construct($this->multi, $url, $options, $this->logger);
  287.             } else {
  288.                 $this->logger?->debug(sprintf('Rejecting pushed response: "%s"', $url));
  289.                 $pushedResponse = null;
  290.             }
  291.         }
  293.         if (!$pushedResponse) {
  294.             $ch = curl_init();
  295.             $this->logger?->info(sprintf('Request: "%s %s"', $method, $url));
  296.             $curlopts += [\CURLOPT_SHARE => $this->multi->share];
  297.         }
  299.         foreach ($curlopts as $opt => $value) {
  300.             if (null !== $value && !curl_setopt($ch, $opt, $value) && \CURLOPT_CERTINFO !== $opt && (!\defined('CURLOPT_HEADEROPT') || \CURLOPT_HEADEROPT !== $opt)) {
  301.                 $constantName = $this->findConstantName($opt);
  302.                 throw new TransportException(sprintf('Curl option "%s" is not supported.', $constantName ?? $opt));
  303.             }
  304.         }
  306.         return $pushedResponse ?? new CurlResponse($this->multi, $ch, $options, $this->logger, $method, self::createRedirectResolver($options, $host, $port), CurlClientState::$curlVersion['version_number'], $url);
  307.     }
  309.     public function stream(ResponseInterface|iterable $responses, float $timeout = null): ResponseStreamInterface
  310.     {
  311.         if ($responses instanceof CurlResponse) {
  312.             $responses = [$responses];
  313.         }
  315.         if ($this->multi->handle instanceof \CurlMultiHandle) {
  316.             $active = 0;
  317.             while (\CURLM_CALL_MULTI_PERFORM === curl_multi_exec($this->multi->handle, $active)) {
  318.             }
  319.         }
  321.         return new ResponseStream(CurlResponse::stream($responses, $timeout));
  322.     }
  324.     public function reset()
  325.     {
  326.         $this->multi->reset();
  327.     }
  329.     /**
  330.      * Accepts pushed responses only if their headers related to authentication match the request.
  331.      */
  332.     private static function acceptPushForRequest(string $method, array $options, PushedResponse $pushedResponse): bool
  333.     {
  334.         if ('' !== $options['body'] || $method !== $pushedResponse->requestHeaders[':method'][0]) {
  335.             return false;
  336.         }
  338.         foreach (['proxy', 'no_proxy', 'bindto', 'local_cert', 'local_pk'] as $k) {
  339.             if ($options[$k] !== $pushedResponse->parentOptions[$k]) {
  340.                 return false;
  341.             }
  342.         }
  344.         foreach (['authorization', 'cookie', 'range', 'proxy-authorization'] as $k) {
  345.             $normalizedHeaders = $options['normalized_headers'][$k] ?? [];
  346.             foreach ($normalizedHeaders as $i => $v) {
  347.                 $normalizedHeaders[$i] = substr($v, \strlen($k) + 2);
  348.             }
  350.             if (($pushedResponse->requestHeaders[$k] ?? []) !== $normalizedHeaders) {
  351.                 return false;
  352.             }
  353.         }
  355.         return true;
  356.     }
  358.     /**
  359.      * Wraps the request's body callback to allow it to return strings longer than curl requested.
  360.      */
  361.     private static function readRequestBody(int $length, \Closure $body, string &$buffer, bool &$eof): string
  362.     {
  363.         if (!$eof && \strlen($buffer) < $length) {
  364.             if (!\is_string($data = $body($length))) {
  365.                 throw new TransportException(sprintf('The return value of the "body" option callback must be a string, "%s" returned.', get_debug_type($data)));
  366.             }
  368.             $buffer .= $data;
  369.             $eof = '' === $data;
  370.         }
  372.         $data = substr($buffer, 0, $length);
  373.         $buffer = substr($buffer, $length);
  375.         return $data;
  376.     }
  378.     /**
  379.      * Resolves relative URLs on redirects and deals with authentication headers.
  380.      *
  381.      * Work around CVE-2018-1000007: Authorization and Cookie headers should not follow redirects - fixed in Curl 7.64
  382.      */
  383.     private static function createRedirectResolver(array $options, string $host, int $port): \Closure
  384.     {
  385.         $redirectHeaders = [];
  386.         if (0 < $options['max_redirects']) {
  387.             $redirectHeaders['host'] = $host;
  388.             $redirectHeaders['port'] = $port;
  389.             $redirectHeaders['with_auth'] = $redirectHeaders['no_auth'] = array_filter($options['headers'], static function ($h) {
  390.                 return 0 !== stripos($h, 'Host:');
  391.             });
  393.             if (isset($options['normalized_headers']['authorization'][0]) || isset($options['normalized_headers']['cookie'][0])) {
  394.                 $redirectHeaders['no_auth'] = array_filter($options['headers'], static function ($h) {
  395.                     return 0 !== stripos($h, 'Authorization:') && 0 !== stripos($h, 'Cookie:');
  396.                 });
  397.             }
  398.         }
  400.         return static function ($ch, string $location, bool $noContent) use (&$redirectHeaders, $options) {
  401.             try {
  402.                 $location = self::parseUrl($location);
  403.             } catch (InvalidArgumentException) {
  404.                 return null;
  405.             }
  407.             if ($noContent && $redirectHeaders) {
  408.                 $filterContentHeaders = static function ($h) {
  409.                     return 0 !== stripos($h, 'Content-Length:') && 0 !== stripos($h, 'Content-Type:') && 0 !== stripos($h, 'Transfer-Encoding:');
  410.                 };
  411.                 $redirectHeaders['no_auth'] = array_filter($redirectHeaders['no_auth'], $filterContentHeaders);
  412.                 $redirectHeaders['with_auth'] = array_filter($redirectHeaders['with_auth'], $filterContentHeaders);
  413.             }
  415.             if ($redirectHeaders && $host = parse_url('http:'.$location['authority'], \PHP_URL_HOST)) {
  416.                 $port = parse_url('http:'.$location['authority'], \PHP_URL_PORT) ?: ('http:' === $location['scheme'] ? 80 : 443);
  417.                 $requestHeaders = $redirectHeaders['host'] === $host && $redirectHeaders['port'] === $port ? $redirectHeaders['with_auth'] : $redirectHeaders['no_auth'];
  418.                 curl_setopt($ch, \CURLOPT_HTTPHEADER, $requestHeaders);
  419.             } elseif ($noContent && $redirectHeaders) {
  420.                 curl_setopt($ch, \CURLOPT_HTTPHEADER, $redirectHeaders['with_auth']);
  421.             }
  423.             $url = self::parseUrl(curl_getinfo($ch, \CURLINFO_EFFECTIVE_URL));
  424.             $url = self::resolveUrl($location, $url);
  426.             curl_setopt($ch, \CURLOPT_PROXY, self::getProxyUrl($options['proxy'], $url));
  428.             return implode('', $url);
  429.         };
  430.     }
  432.     private function findConstantName(int $opt): ?string
  433.     {
  434.         $constants = array_filter(get_defined_constants(), static function ($v, $k) use ($opt) {
  435.             return $v === $opt && 'C' === $k[0] && (str_starts_with($k, 'CURLOPT_') || str_starts_with($k, 'CURLINFO_'));
  436.         }, \ARRAY_FILTER_USE_BOTH);
  438.         return key($constants);
  439.     }
  441.     /**
  442.      * Prevents overriding options that are set internally throughout the request.
  443.      */
  444.     private function validateExtraCurlOptions(array $options): void
  445.     {
  446.         $curloptsToConfig = [
  447.             // options used in CurlHttpClient
  448.             \CURLOPT_HTTPAUTH => 'auth_ntlm',
  449.             \CURLOPT_USERPWD => 'auth_ntlm',
  450.             \CURLOPT_RESOLVE => 'resolve',
  451.             \CURLOPT_NOSIGNAL => 'timeout',
  452.             \CURLOPT_HTTPHEADER => 'headers',
  453.             \CURLOPT_INFILE => 'body',
  454.             \CURLOPT_READFUNCTION => 'body',
  455.             \CURLOPT_INFILESIZE => 'body',
  456.             \CURLOPT_POSTFIELDS => 'body',
  457.             \CURLOPT_UPLOAD => 'body',
  458.             \CURLOPT_INTERFACE => 'bindto',
  459.             \CURLOPT_TIMEOUT_MS => 'max_duration',
  460.             \CURLOPT_TIMEOUT => 'max_duration',
  461.             \CURLOPT_MAXREDIRS => 'max_redirects',
  462.             \CURLOPT_POSTREDIR => 'max_redirects',
  463.             \CURLOPT_PROXY => 'proxy',
  464.             \CURLOPT_NOPROXY => 'no_proxy',
  465.             \CURLOPT_SSL_VERIFYPEER => 'verify_peer',
  466.             \CURLOPT_SSL_VERIFYHOST => 'verify_host',
  467.             \CURLOPT_CAINFO => 'cafile',
  468.             \CURLOPT_CAPATH => 'capath',
  469.             \CURLOPT_SSL_CIPHER_LIST => 'ciphers',
  470.             \CURLOPT_SSLCERT => 'local_cert',
  471.             \CURLOPT_SSLKEY => 'local_pk',
  472.             \CURLOPT_KEYPASSWD => 'passphrase',
  473.             \CURLOPT_CERTINFO => 'capture_peer_cert_chain',
  474.             \CURLOPT_USERAGENT => 'normalized_headers',
  475.             \CURLOPT_REFERER => 'headers',
  476.             // options used in CurlResponse
  477.             \CURLOPT_NOPROGRESS => 'on_progress',
  478.             \CURLOPT_PROGRESSFUNCTION => 'on_progress',
  479.         ];
  481.         if (\defined('CURLOPT_UNIX_SOCKET_PATH')) {
  482.             $curloptsToConfig[\CURLOPT_UNIX_SOCKET_PATH] = 'bindto';
  483.         }
  485.         if (\defined('CURLOPT_PINNEDPUBLICKEY')) {
  486.             $curloptsToConfig[\CURLOPT_PINNEDPUBLICKEY] = 'peer_fingerprint';
  487.         }
  489.         $curloptsToCheck = [
  490.             \CURLOPT_PRIVATE,
  491.             \CURLOPT_HEADERFUNCTION,
  492.             \CURLOPT_WRITEFUNCTION,
  493.             \CURLOPT_VERBOSE,
  494.             \CURLOPT_STDERR,
  495.             \CURLOPT_RETURNTRANSFER,
  496.             \CURLOPT_URL,
  497.             \CURLOPT_FOLLOWLOCATION,
  498.             \CURLOPT_HEADER,
  499.             \CURLOPT_CONNECTTIMEOUT,
  500.             \CURLOPT_CONNECTTIMEOUT_MS,
  501.             \CURLOPT_HTTP_VERSION,
  502.             \CURLOPT_PORT,
  503.             \CURLOPT_DNS_USE_GLOBAL_CACHE,
  504.             \CURLOPT_PROTOCOLS,
  505.             \CURLOPT_REDIR_PROTOCOLS,
  506.             \CURLOPT_COOKIEFILE,
  507.             \CURLINFO_REDIRECT_COUNT,
  508.         ];
  510.         if (\defined('CURLOPT_HTTP09_ALLOWED')) {
  511.             $curloptsToCheck[] = \CURLOPT_HTTP09_ALLOWED;
  512.         }
  514.         if (\defined('CURLOPT_HEADEROPT')) {
  515.             $curloptsToCheck[] = \CURLOPT_HEADEROPT;
  516.         }
  518.         $methodOpts = [
  519.             \CURLOPT_POST,
  520.             \CURLOPT_PUT,
  521.             \CURLOPT_CUSTOMREQUEST,
  522.             \CURLOPT_HTTPGET,
  523.             \CURLOPT_NOBODY,
  524.         ];
  526.         foreach ($options as $opt => $optValue) {
  527.             if (isset($curloptsToConfig[$opt])) {
  528.                 $constName = $this->findConstantName($opt) ?? $opt;
  529.                 throw new InvalidArgumentException(sprintf('Cannot set "%s" with "extra.curl", use option "%s" instead.', $constName, $curloptsToConfig[$opt]));
  530.             }
  532.             if (\in_array($opt, $methodOpts)) {
  533.                 throw new InvalidArgumentException('The HTTP method cannot be overridden using "extra.curl".');
  534.             }
  536.             if (\in_array($opt, $curloptsToCheck)) {
  537.                 $constName = $this->findConstantName($opt) ?? $opt;
  538.                 throw new InvalidArgumentException(sprintf('Cannot set "%s" with "extra.curl".', $constName));
  539.             }
  540.         }
  541.     }
  542. }