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

  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 = $options['proxy']
  93.             ?? ('https:' === $url['scheme'] ? $_SERVER['https_proxy'] ?? $_SERVER['HTTPS_PROXY'] ?? null : null)
  94.             // Ignore HTTP_PROXY except on the CLI to work around httpoxy set of vulnerabilities
  95.             ?? $_SERVER['http_proxy'] ?? (\in_array(\PHP_SAPI, ['cli', 'phpdbg'], true) ? $_SERVER['HTTP_PROXY'] ?? null : null) ?? $_SERVER['all_proxy'] ?? $_SERVER['ALL_PROXY'] ?? null;
  96.         $url = implode('', $url);
  98.         if (!isset($options['normalized_headers']['user-agent'])) {
  99.             $options['headers'][] = 'User-Agent: Symfony HttpClient/Curl';
  100.         }
  102.         $curlopts = [
  103.             \CURLOPT_URL => $url,
  104.             \CURLOPT_TCP_NODELAY => true,
  105.             \CURLOPT_PROTOCOLS => \CURLPROTO_HTTP | \CURLPROTO_HTTPS,
  106.             \CURLOPT_REDIR_PROTOCOLS => \CURLPROTO_HTTP | \CURLPROTO_HTTPS,
  107.             \CURLOPT_FOLLOWLOCATION => true,
  108.             \CURLOPT_MAXREDIRS => 0 < $options['max_redirects'] ? $options['max_redirects'] : 0,
  109.             \CURLOPT_COOKIEFILE => '', // Keep track of cookies during redirects
  110.             \CURLOPT_TIMEOUT => 0,
  111.             \CURLOPT_PROXY => $proxy,
  112.             \CURLOPT_NOPROXY => $options['no_proxy'] ?? $_SERVER['no_proxy'] ?? $_SERVER['NO_PROXY'] ?? '',
  113.             \CURLOPT_SSL_VERIFYPEER => $options['verify_peer'],
  114.             \CURLOPT_SSL_VERIFYHOST => $options['verify_host'] ? 2 : 0,
  115.             \CURLOPT_CAINFO => $options['cafile'],
  116.             \CURLOPT_CAPATH => $options['capath'],
  117.             \CURLOPT_SSL_CIPHER_LIST => $options['ciphers'],
  118.             \CURLOPT_SSLCERT => $options['local_cert'],
  119.             \CURLOPT_SSLKEY => $options['local_pk'],
  120.             \CURLOPT_KEYPASSWD => $options['passphrase'],
  121.             \CURLOPT_CERTINFO => $options['capture_peer_cert_chain'],
  122.         ];
  124.         if (1.0 === (float) $options['http_version']) {
  125.             $curlopts[\CURLOPT_HTTP_VERSION] = \CURL_HTTP_VERSION_1_0;
  126.         } elseif (1.1 === (float) $options['http_version']) {
  127.             $curlopts[\CURLOPT_HTTP_VERSION] = \CURL_HTTP_VERSION_1_1;
  128.         } elseif (\defined('CURL_VERSION_HTTP2') && (\CURL_VERSION_HTTP2 & CurlClientState::$curlVersion['features']) && ('https:' === $scheme || 2.0 === (float) $options['http_version'])) {
  129.             $curlopts[\CURLOPT_HTTP_VERSION] = \CURL_HTTP_VERSION_2_0;
  130.         }
  132.         if (isset($options['auth_ntlm'])) {
  133.             $curlopts[\CURLOPT_HTTPAUTH] = \CURLAUTH_NTLM;
  134.             $curlopts[\CURLOPT_HTTP_VERSION] = \CURL_HTTP_VERSION_1_1;
  136.             if (\is_array($options['auth_ntlm'])) {
  137.                 $count = \count($options['auth_ntlm']);
  138.                 if ($count <= 0 || $count > 2) {
  139.                     throw new InvalidArgumentException(sprintf('Option "auth_ntlm" must contain 1 or 2 elements, %d given.', $count));
  140.                 }
  142.                 $options['auth_ntlm'] = implode(':', $options['auth_ntlm']);
  143.             }
  145.             if (!\is_string($options['auth_ntlm'])) {
  146.                 throw new InvalidArgumentException(sprintf('Option "auth_ntlm" must be a string or an array, "%s" given.', get_debug_type($options['auth_ntlm'])));
  147.             }
  149.             $curlopts[\CURLOPT_USERPWD] = $options['auth_ntlm'];
  150.         }
  152.         if (!\ZEND_THREAD_SAFE) {
  153.             $curlopts[\CURLOPT_DNS_USE_GLOBAL_CACHE] = false;
  154.         }
  156.         if (\defined('CURLOPT_HEADEROPT') && \defined('CURLHEADER_SEPARATE')) {
  157.             $curlopts[\CURLOPT_HEADEROPT] = \CURLHEADER_SEPARATE;
  158.         }
  160.         // curl's resolve feature varies by host:port but ours varies by host only, let's handle this with our own DNS map
  161.         if (isset($this->multi->dnsCache->hostnames[$host])) {
  162.             $options['resolve'] += [$host => $this->multi->dnsCache->hostnames[$host]];
  163.         }
  165.         if ($options['resolve'] || $this->multi->dnsCache->evictions) {
  166.             // First reset any old DNS cache entries then add the new ones
  167.             $resolve = $this->multi->dnsCache->evictions;
  168.             $this->multi->dnsCache->evictions = [];
  170.             if ($resolve && 0x072A00 > CurlClientState::$curlVersion['version_number']) {
  171.                 // DNS cache removals require curl 7.42 or higher
  172.                 $this->multi->reset();
  173.             }
  175.             foreach ($options['resolve'] as $host => $ip) {
  176.                 $resolve[] = null === $ip ? "-$host:$port" : "$host:$port:$ip";
  177.                 $this->multi->dnsCache->hostnames[$host] = $ip;
  178.                 $this->multi->dnsCache->removals["-$host:$port"] = "-$host:$port";
  179.             }
  181.             $curlopts[\CURLOPT_RESOLVE] = $resolve;
  182.         }
  184.         if ('POST' === $method) {
  185.             // Use CURLOPT_POST to have browser-like POST-to-GET redirects for 301, 302 and 303
  186.             $curlopts[\CURLOPT_POST] = true;
  187.         } elseif ('HEAD' === $method) {
  188.             $curlopts[\CURLOPT_NOBODY] = true;
  189.         } else {
  190.             $curlopts[\CURLOPT_CUSTOMREQUEST] = $method;
  191.         }
  193.         if ('\\' !== \DIRECTORY_SEPARATOR && $options['timeout'] < 1) {
  194.             $curlopts[\CURLOPT_NOSIGNAL] = true;
  195.         }
  197.         if (\extension_loaded('zlib') && !isset($options['normalized_headers']['accept-encoding'])) {
  198.             $options['headers'][] = 'Accept-Encoding: gzip'; // Expose only one encoding, some servers mess up when more are provided
  199.         }
  200.         $body = $options['body'];
  202.         foreach ($options['headers'] as $i => $header) {
  203.             if (\is_string($body) && '' !== $body && 0 === stripos($header, 'Content-Length: ')) {
  204.                 // Let curl handle Content-Length headers
  205.                 unset($options['headers'][$i]);
  206.                 continue;
  207.             }
  208.             if (':' === $header[-2] && \strlen($header) - 2 === strpos($header, ': ')) {
  209.                 // curl requires a special syntax to send empty headers
  210.                 $curlopts[\CURLOPT_HTTPHEADER][] = substr_replace($header, ';', -2);
  211.             } else {
  212.                 $curlopts[\CURLOPT_HTTPHEADER][] = $header;
  213.             }
  214.         }
  216.         // Prevent curl from sending its default Accept and Expect headers
  217.         foreach (['accept', 'expect'] as $header) {
  218.             if (!isset($options['normalized_headers'][$header][0])) {
  219.                 $curlopts[\CURLOPT_HTTPHEADER][] = $header.':';
  220.             }
  221.         }
  223.         if (!\is_string($body)) {
  224.             if (\is_resource($body)) {
  225.                 $curlopts[\CURLOPT_INFILE] = $body;
  226.             } else {
  227.                 $eof = false;
  228.                 $buffer = '';
  229.                 $curlopts[\CURLOPT_READFUNCTION] = static function ($ch, $fd, $length) use ($body, &$buffer, &$eof) {
  230.                     return self::readRequestBody($length, $body, $buffer, $eof);
  231.                 };
  232.             }
  234.             if (isset($options['normalized_headers']['content-length'][0])) {
  235.                 $curlopts[\CURLOPT_INFILESIZE] = (int) substr($options['normalized_headers']['content-length'][0], \strlen('Content-Length: '));
  236.             }
  237.             if (!isset($options['normalized_headers']['transfer-encoding'])) {
  238.                 $curlopts[\CURLOPT_HTTPHEADER][] = 'Transfer-Encoding:'.(isset($curlopts[\CURLOPT_INFILESIZE]) ? '' : ' chunked');
  239.             }
  241.             if ('POST' !== $method) {
  242.                 $curlopts[\CURLOPT_UPLOAD] = true;
  244.                 if (!isset($options['normalized_headers']['content-type']) && 0 !== ($curlopts[\CURLOPT_INFILESIZE] ?? null)) {
  245.                     $curlopts[\CURLOPT_HTTPHEADER][] = 'Content-Type: application/x-www-form-urlencoded';
  246.                 }
  247.             }
  248.         } elseif ('' !== $body || 'POST' === $method) {
  249.             $curlopts[\CURLOPT_POSTFIELDS] = $body;
  250.         }
  252.         if ($options['peer_fingerprint']) {
  253.             if (!isset($options['peer_fingerprint']['pin-sha256'])) {
  254.                 throw new TransportException(__CLASS__.' supports only "pin-sha256" fingerprints.');
  255.             }
  257.             $curlopts[\CURLOPT_PINNEDPUBLICKEY] = 'sha256//'.implode(';sha256//', $options['peer_fingerprint']['pin-sha256']);
  258.         }
  260.         if ($options['bindto']) {
  261.             if (file_exists($options['bindto'])) {
  262.                 $curlopts[\CURLOPT_UNIX_SOCKET_PATH] = $options['bindto'];
  263.             } elseif (!str_starts_with($options['bindto'], 'if!') && preg_match('/^(.*):(\d+)$/', $options['bindto'], $matches)) {
  264.                 $curlopts[\CURLOPT_INTERFACE] = $matches[1];
  265.                 $curlopts[\CURLOPT_LOCALPORT] = $matches[2];
  266.             } else {
  267.                 $curlopts[\CURLOPT_INTERFACE] = $options['bindto'];
  268.             }
  269.         }
  271.         if (0 < $options['max_duration']) {
  272.             $curlopts[\CURLOPT_TIMEOUT_MS] = 1000 * $options['max_duration'];
  273.         }
  275.         if (!empty($options['extra']['curl']) && \is_array($options['extra']['curl'])) {
  276.             $this->validateExtraCurlOptions($options['extra']['curl']);
  277.             $curlopts += $options['extra']['curl'];
  278.         }
  280.         if ($pushedResponse = $this->multi->pushedResponses[$url] ?? null) {
  281.             unset($this->multi->pushedResponses[$url]);
  283.             if (self::acceptPushForRequest($method, $options, $pushedResponse)) {
  284.                 $this->logger?->debug(sprintf('Accepting pushed response: "%s %s"', $method, $url));
  286.                 // Reinitialize the pushed response with request's options
  287.                 $ch = $pushedResponse->handle;
  288.                 $pushedResponse = $pushedResponse->response;
  289.                 $pushedResponse->__construct($this->multi, $url, $options, $this->logger);
  290.             } else {
  291.                 $this->logger?->debug(sprintf('Rejecting pushed response: "%s"', $url));
  292.                 $pushedResponse = null;
  293.             }
  294.         }
  296.         if (!$pushedResponse) {
  297.             $ch = curl_init();
  298.             $this->logger?->info(sprintf('Request: "%s %s"', $method, $url));
  299.             $curlopts += [\CURLOPT_SHARE => $this->multi->share];
  300.         }
  302.         foreach ($curlopts as $opt => $value) {
  303.             if (null !== $value && !curl_setopt($ch, $opt, $value) && \CURLOPT_CERTINFO !== $opt && (!\defined('CURLOPT_HEADEROPT') || \CURLOPT_HEADEROPT !== $opt)) {
  304.                 $constantName = $this->findConstantName($opt);
  305.                 throw new TransportException(sprintf('Curl option "%s" is not supported.', $constantName ?? $opt));
  306.             }
  307.         }
  309.         return $pushedResponse ?? new CurlResponse($this->multi, $ch, $options, $this->logger, $method, self::createRedirectResolver($options, $host, $port), CurlClientState::$curlVersion['version_number'], $url);
  310.     }
  312.     public function stream(ResponseInterface|iterable $responses, float $timeout = null): ResponseStreamInterface
  313.     {
  314.         if ($responses instanceof CurlResponse) {
  315.             $responses = [$responses];
  316.         }
  318.         if ($this->multi->handle instanceof \CurlMultiHandle) {
  319.             $active = 0;
  320.             while (\CURLM_CALL_MULTI_PERFORM === curl_multi_exec($this->multi->handle, $active)) {
  321.             }
  322.         }
  324.         return new ResponseStream(CurlResponse::stream($responses, $timeout));
  325.     }
  327.     public function reset()
  328.     {
  329.         $this->multi->reset();
  330.     }
  332.     /**
  333.      * Accepts pushed responses only if their headers related to authentication match the request.
  334.      */
  335.     private static function acceptPushForRequest(string $method, array $options, PushedResponse $pushedResponse): bool
  336.     {
  337.         if ('' !== $options['body'] || $method !== $pushedResponse->requestHeaders[':method'][0]) {
  338.             return false;
  339.         }
  341.         foreach (['proxy', 'no_proxy', 'bindto', 'local_cert', 'local_pk'] as $k) {
  342.             if ($options[$k] !== $pushedResponse->parentOptions[$k]) {
  343.                 return false;
  344.             }
  345.         }
  347.         foreach (['authorization', 'cookie', 'range', 'proxy-authorization'] as $k) {
  348.             $normalizedHeaders = $options['normalized_headers'][$k] ?? [];
  349.             foreach ($normalizedHeaders as $i => $v) {
  350.                 $normalizedHeaders[$i] = substr($v, \strlen($k) + 2);
  351.             }
  353.             if (($pushedResponse->requestHeaders[$k] ?? []) !== $normalizedHeaders) {
  354.                 return false;
  355.             }
  356.         }
  358.         return true;
  359.     }
  361.     /**
  362.      * Wraps the request's body callback to allow it to return strings longer than curl requested.
  363.      */
  364.     private static function readRequestBody(int $length, \Closure $body, string &$buffer, bool &$eof): string
  365.     {
  366.         if (!$eof && \strlen($buffer) < $length) {
  367.             if (!\is_string($data = $body($length))) {
  368.                 throw new TransportException(sprintf('The return value of the "body" option callback must be a string, "%s" returned.', get_debug_type($data)));
  369.             }
  371.             $buffer .= $data;
  372.             $eof = '' === $data;
  373.         }
  375.         $data = substr($buffer, 0, $length);
  376.         $buffer = substr($buffer, $length);
  378.         return $data;
  379.     }
  381.     /**
  382.      * Resolves relative URLs on redirects and deals with authentication headers.
  383.      *
  384.      * Work around CVE-2018-1000007: Authorization and Cookie headers should not follow redirects - fixed in Curl 7.64
  385.      */
  386.     private static function createRedirectResolver(array $options, string $host, int $port): \Closure
  387.     {
  388.         $redirectHeaders = [];
  389.         if (0 < $options['max_redirects']) {
  390.             $redirectHeaders['host'] = $host;
  391.             $redirectHeaders['port'] = $port;
  392.             $redirectHeaders['with_auth'] = $redirectHeaders['no_auth'] = array_filter($options['headers'], static function ($h) {
  393.                 return 0 !== stripos($h, 'Host:');
  394.             });
  396.             if (isset($options['normalized_headers']['authorization'][0]) || isset($options['normalized_headers']['cookie'][0])) {
  397.                 $redirectHeaders['no_auth'] = array_filter($options['headers'], static function ($h) {
  398.                     return 0 !== stripos($h, 'Authorization:') && 0 !== stripos($h, 'Cookie:');
  399.                 });
  400.             }
  401.         }
  403.         return static function ($ch, string $location, bool $noContent) use (&$redirectHeaders) {
  404.             try {
  405.                 $location = self::parseUrl($location);
  406.             } catch (InvalidArgumentException) {
  407.                 return null;
  408.             }
  410.             if ($noContent && $redirectHeaders) {
  411.                 $filterContentHeaders = static function ($h) {
  412.                     return 0 !== stripos($h, 'Content-Length:') && 0 !== stripos($h, 'Content-Type:') && 0 !== stripos($h, 'Transfer-Encoding:');
  413.                 };
  414.                 $redirectHeaders['no_auth'] = array_filter($redirectHeaders['no_auth'], $filterContentHeaders);
  415.                 $redirectHeaders['with_auth'] = array_filter($redirectHeaders['with_auth'], $filterContentHeaders);
  416.             }
  418.             if ($redirectHeaders && $host = parse_url('http:'.$location['authority'], \PHP_URL_HOST)) {
  419.                 $port = parse_url('http:'.$location['authority'], \PHP_URL_PORT) ?: ('http:' === $location['scheme'] ? 80 : 443);
  420.                 $requestHeaders = $redirectHeaders['host'] === $host && $redirectHeaders['port'] === $port ? $redirectHeaders['with_auth'] : $redirectHeaders['no_auth'];
  421.                 curl_setopt($ch, \CURLOPT_HTTPHEADER, $requestHeaders);
  422.             } elseif ($noContent && $redirectHeaders) {
  423.                 curl_setopt($ch, \CURLOPT_HTTPHEADER, $redirectHeaders['with_auth']);
  424.             }
  426.             $url = self::parseUrl(curl_getinfo($ch, \CURLINFO_EFFECTIVE_URL));
  427.             $url = self::resolveUrl($location, $url);
  429.             curl_setopt($ch, \CURLOPT_PROXY, $options['proxy']
  430.                 ?? ('https:' === $url['scheme'] ? $_SERVER['https_proxy'] ?? $_SERVER['HTTPS_PROXY'] ?? null : null)
  431.                 // Ignore HTTP_PROXY except on the CLI to work around httpoxy set of vulnerabilities
  432.                 ?? $_SERVER['http_proxy'] ?? (\in_array(\PHP_SAPI, ['cli', 'phpdbg'], true) ? $_SERVER['HTTP_PROXY'] ?? null : null) ?? $_SERVER['all_proxy'] ?? $_SERVER['ALL_PROXY'] ?? null
  433.             );
  435.             return implode('', $url);
  436.         };
  437.     }
  439.     private function findConstantName(int $opt): ?string
  440.     {
  441.         $constants = array_filter(get_defined_constants(), static function ($v, $k) use ($opt) {
  442.             return $v === $opt && 'C' === $k[0] && (str_starts_with($k, 'CURLOPT_') || str_starts_with($k, 'CURLINFO_'));
  443.         }, \ARRAY_FILTER_USE_BOTH);
  445.         return key($constants);
  446.     }
  448.     /**
  449.      * Prevents overriding options that are set internally throughout the request.
  450.      */
  451.     private function validateExtraCurlOptions(array $options): void
  452.     {
  453.         $curloptsToConfig = [
  454.             // options used in CurlHttpClient
  455.             \CURLOPT_HTTPAUTH => 'auth_ntlm',
  456.             \CURLOPT_USERPWD => 'auth_ntlm',
  457.             \CURLOPT_RESOLVE => 'resolve',
  458.             \CURLOPT_NOSIGNAL => 'timeout',
  459.             \CURLOPT_HTTPHEADER => 'headers',
  460.             \CURLOPT_INFILE => 'body',
  461.             \CURLOPT_READFUNCTION => 'body',
  462.             \CURLOPT_INFILESIZE => 'body',
  463.             \CURLOPT_POSTFIELDS => 'body',
  464.             \CURLOPT_UPLOAD => 'body',
  465.             \CURLOPT_INTERFACE => 'bindto',
  466.             \CURLOPT_TIMEOUT_MS => 'max_duration',
  467.             \CURLOPT_TIMEOUT => 'max_duration',
  468.             \CURLOPT_MAXREDIRS => 'max_redirects',
  469.             \CURLOPT_PROXY => 'proxy',
  470.             \CURLOPT_NOPROXY => 'no_proxy',
  471.             \CURLOPT_SSL_VERIFYPEER => 'verify_peer',
  472.             \CURLOPT_SSL_VERIFYHOST => 'verify_host',
  473.             \CURLOPT_CAINFO => 'cafile',
  474.             \CURLOPT_CAPATH => 'capath',
  475.             \CURLOPT_SSL_CIPHER_LIST => 'ciphers',
  476.             \CURLOPT_SSLCERT => 'local_cert',
  477.             \CURLOPT_SSLKEY => 'local_pk',
  478.             \CURLOPT_KEYPASSWD => 'passphrase',
  479.             \CURLOPT_CERTINFO => 'capture_peer_cert_chain',
  480.             \CURLOPT_USERAGENT => 'normalized_headers',
  481.             \CURLOPT_REFERER => 'headers',
  482.             // options used in CurlResponse
  483.             \CURLOPT_NOPROGRESS => 'on_progress',
  484.             \CURLOPT_PROGRESSFUNCTION => 'on_progress',
  485.         ];
  487.         if (\defined('CURLOPT_UNIX_SOCKET_PATH')) {
  488.             $curloptsToConfig[\CURLOPT_UNIX_SOCKET_PATH] = 'bindto';
  489.         }
  491.         if (\defined('CURLOPT_PINNEDPUBLICKEY')) {
  492.             $curloptsToConfig[\CURLOPT_PINNEDPUBLICKEY] = 'peer_fingerprint';
  493.         }
  495.         $curloptsToCheck = [
  496.             \CURLOPT_PRIVATE,
  497.             \CURLOPT_HEADERFUNCTION,
  498.             \CURLOPT_WRITEFUNCTION,
  499.             \CURLOPT_VERBOSE,
  500.             \CURLOPT_STDERR,
  501.             \CURLOPT_RETURNTRANSFER,
  502.             \CURLOPT_URL,
  503.             \CURLOPT_FOLLOWLOCATION,
  504.             \CURLOPT_HEADER,
  505.             \CURLOPT_CONNECTTIMEOUT,
  506.             \CURLOPT_CONNECTTIMEOUT_MS,
  507.             \CURLOPT_HTTP_VERSION,
  508.             \CURLOPT_PORT,
  509.             \CURLOPT_DNS_USE_GLOBAL_CACHE,
  510.             \CURLOPT_PROTOCOLS,
  511.             \CURLOPT_REDIR_PROTOCOLS,
  512.             \CURLOPT_COOKIEFILE,
  513.             \CURLINFO_REDIRECT_COUNT,
  514.         ];
  516.         if (\defined('CURLOPT_HTTP09_ALLOWED')) {
  517.             $curloptsToCheck[] = \CURLOPT_HTTP09_ALLOWED;
  518.         }
  520.         if (\defined('CURLOPT_HEADEROPT')) {
  521.             $curloptsToCheck[] = \CURLOPT_HEADEROPT;
  522.         }
  524.         $methodOpts = [
  525.             \CURLOPT_POST,
  526.             \CURLOPT_PUT,
  527.             \CURLOPT_CUSTOMREQUEST,
  528.             \CURLOPT_HTTPGET,
  529.             \CURLOPT_NOBODY,
  530.         ];
  532.         foreach ($options as $opt => $optValue) {
  533.             if (isset($curloptsToConfig[$opt])) {
  534.                 $constName = $this->findConstantName($opt) ?? $opt;
  535.                 throw new InvalidArgumentException(sprintf('Cannot set "%s" with "extra.curl", use option "%s" instead.', $constName, $curloptsToConfig[$opt]));
  536.             }
  538.             if (\in_array($opt, $methodOpts)) {
  539.                 throw new InvalidArgumentException('The HTTP method cannot be overridden using "extra.curl".');
  540.             }
  542.             if (\in_array($opt, $curloptsToCheck)) {
  543.                 $constName = $this->findConstantName($opt) ?? $opt;
  544.                 throw new InvalidArgumentException(sprintf('Cannot set "%s" with "extra.curl".', $constName));
  545.             }
  546.         }
  547.     }
  548. }