vendor/symfony/http-client/Response/CurlResponse.php line 28

  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\Response;
  14. use Psr\Log\LoggerInterface;
  15. use Symfony\Component\HttpClient\Chunk\FirstChunk;
  16. use Symfony\Component\HttpClient\Chunk\InformationalChunk;
  17. use Symfony\Component\HttpClient\Exception\TransportException;
  18. use Symfony\Component\HttpClient\Internal\Canary;
  19. use Symfony\Component\HttpClient\Internal\ClientState;
  20. use Symfony\Component\HttpClient\Internal\CurlClientState;
  21. use Symfony\Contracts\HttpClient\ResponseInterface;
  23. /**
  24.  * @author Nicolas Grekas <p@tchwork.com>
  25.  *
  26.  * @internal
  27.  */
  28. final class CurlResponse implements ResponseInterface, StreamableInterface
  29. {
  30.     use CommonResponseTrait {
  31.         getContent as private doGetContent;
  32.     }
  33.     use TransportResponseTrait;
  35.     private CurlClientState $multi;
  37.     /**
  38.      * @var resource
  39.      */
  40.     private $debugBuffer;
  42.     /**
  43.      * @internal
  44.      */
  45.     public function __construct(CurlClientState $multi, \CurlHandle|string $ch, array $options = null, LoggerInterface $logger = null, string $method = 'GET', callable $resolveRedirect = null, int $curlVersion = null, string $originalUrl = null)
  46.     {
  47.         $this->multi = $multi;
  49.         if ($ch instanceof \CurlHandle) {
  50.             $this->handle = $ch;
  51.             $this->debugBuffer = fopen('php://temp', 'w+');
  52.             if (0x074000 === $curlVersion) {
  53.                 fwrite($this->debugBuffer, 'Due to a bug in curl 7.64.0, the debug log is disabled; use another version to work around the issue.');
  54.             } else {
  55.                 curl_setopt($ch, \CURLOPT_VERBOSE, true);
  56.                 curl_setopt($ch, \CURLOPT_STDERR, $this->debugBuffer);
  57.             }
  58.         } else {
  59.             $this->info['url'] = $ch;
  60.             $ch = $this->handle;
  61.         }
  63.         $this->id = $id = (int) $ch;
  64.         $this->logger = $logger;
  65.         $this->shouldBuffer = $options['buffer'] ?? true;
  66.         $this->timeout = $options['timeout'] ?? null;
  67.         $this->info['http_method'] = $method;
  68.         $this->info['user_data'] = $options['user_data'] ?? null;
  69.         $this->info['max_duration'] = $options['max_duration'] ?? null;
  70.         $this->info['start_time'] ??= microtime(true);
  71.         $this->info['original_url'] = $originalUrl ?? $this->info['url'] ?? curl_getinfo($ch, \CURLINFO_EFFECTIVE_URL);
  72.         $info = &$this->info;
  73.         $headers = &$this->headers;
  74.         $debugBuffer = $this->debugBuffer;
  76.         if (!$info['response_headers']) {
  77.             // Used to keep track of what we're waiting for
  78.             curl_setopt($ch, \CURLOPT_PRIVATE, \in_array($method, ['GET', 'HEAD', 'OPTIONS', 'TRACE'], true) && 1.0 < (float) ($options['http_version'] ?? 1.1) ? 'H2' : 'H0'); // H = headers + retry counter
  79.         }
  81.         curl_setopt($ch, \CURLOPT_HEADERFUNCTION, static function ($ch, string $data) use (&$info, &$headers, $options, $multi, $id, &$location, $resolveRedirect, $logger): int {
  82.             return self::parseHeaderLine($ch, $data, $info, $headers, $options, $multi, $id, $location, $resolveRedirect, $logger);
  83.         });
  85.         if (null === $options) {
  86.             // Pushed response: buffer until requested
  87.             curl_setopt($ch, \CURLOPT_WRITEFUNCTION, static function ($ch, string $data) use ($multi, $id): int {
  88.                 $multi->handlesActivity[$id][] = $data;
  89.                 curl_pause($ch, \CURLPAUSE_RECV);
  91.                 return \strlen($data);
  92.             });
  94.             return;
  95.         }
  97.         $execCounter = $multi->execCounter;
  98.         $this->info['pause_handler'] = static function (float $duration) use ($ch, $multi, $execCounter) {
  99.             if (0 < $duration) {
  100.                 if ($execCounter === $multi->execCounter) {
  101.                     $multi->execCounter = !\is_float($execCounter) ? 1 + $execCounter : \PHP_INT_MIN;
  102.                     curl_multi_remove_handle($multi->handle, $ch);
  103.                 }
  105.                 $lastExpiry = end($multi->pauseExpiries);
  106.                 $multi->pauseExpiries[(int) $ch] = $duration += microtime(true);
  107.                 if (false !== $lastExpiry && $lastExpiry > $duration) {
  108.                     asort($multi->pauseExpiries);
  109.                 }
  110.                 curl_pause($ch, \CURLPAUSE_ALL);
  111.             } else {
  112.                 unset($multi->pauseExpiries[(int) $ch]);
  113.                 curl_pause($ch, \CURLPAUSE_CONT);
  114.                 curl_multi_add_handle($multi->handle, $ch);
  115.             }
  116.         };
  118.         $this->inflate = !isset($options['normalized_headers']['accept-encoding']);
  119.         curl_pause($ch, \CURLPAUSE_CONT);
  121.         if ($onProgress = $options['on_progress']) {
  122.             $url = isset($info['url']) ? ['url' => $info['url']] : [];
  123.             curl_setopt($ch, \CURLOPT_NOPROGRESS, false);
  124.             curl_setopt($ch, \CURLOPT_PROGRESSFUNCTION, static function ($ch, $dlSize, $dlNow) use ($onProgress, &$info, $url, $multi, $debugBuffer) {
  125.                 try {
  126.                     rewind($debugBuffer);
  127.                     $debug = ['debug' => stream_get_contents($debugBuffer)];
  128.                     $onProgress($dlNow, $dlSize, $url + curl_getinfo($ch) + $info + $debug);
  129.                 } catch (\Throwable $e) {
  130.                     $multi->handlesActivity[(int) $ch][] = null;
  131.                     $multi->handlesActivity[(int) $ch][] = $e;
  133.                     return 1; // Abort the request
  134.                 }
  136.                 return null;
  137.             });
  138.         }
  140.         curl_setopt($ch, \CURLOPT_WRITEFUNCTION, static function ($ch, string $data) use ($multi, $id): int {
  141.             if ('H' === (curl_getinfo($ch, \CURLINFO_PRIVATE)[0] ?? null)) {
  142.                 $multi->handlesActivity[$id][] = null;
  143.                 $multi->handlesActivity[$id][] = new TransportException(sprintf('Unsupported protocol for "%s"', curl_getinfo($ch, \CURLINFO_EFFECTIVE_URL)));
  145.                 return 0;
  146.             }
  148.             curl_setopt($ch, \CURLOPT_WRITEFUNCTION, static function ($ch, string $data) use ($multi, $id): int {
  149.                 $multi->handlesActivity[$id][] = $data;
  151.                 return \strlen($data);
  152.             });
  154.             $multi->handlesActivity[$id][] = $data;
  156.             return \strlen($data);
  157.         });
  159.         $this->initializer = static function (self $response) {
  160.             $waitFor = curl_getinfo($ch = $response->handle, \CURLINFO_PRIVATE);
  162.             return 'H' === $waitFor[0];
  163.         };
  165.         // Schedule the request in a non-blocking way
  166.         $multi->lastTimeout = null;
  167.         $multi->openHandles[$id] = [$ch, $options];
  168.         curl_multi_add_handle($multi->handle, $ch);
  170.         $this->canary = new Canary(static function () use ($ch, $multi, $id) {
  171.             unset($multi->pauseExpiries[$id], $multi->openHandles[$id], $multi->handlesActivity[$id]);
  172.             curl_setopt($ch, \CURLOPT_PRIVATE, '_0');
  174.             if ($multi->performing) {
  175.                 return;
  176.             }
  178.             curl_multi_remove_handle($multi->handle, $ch);
  179.             curl_setopt_array($ch, [
  180.                 \CURLOPT_NOPROGRESS => true,
  181.                 \CURLOPT_PROGRESSFUNCTION => null,
  182.                 \CURLOPT_HEADERFUNCTION => null,
  183.                 \CURLOPT_WRITEFUNCTION => null,
  184.                 \CURLOPT_READFUNCTION => null,
  185.                 \CURLOPT_INFILE => null,
  186.             ]);
  188.             if (!$multi->openHandles) {
  189.                 // Schedule DNS cache eviction for the next request
  190.                 $multi->dnsCache->evictions = $multi->dnsCache->evictions ?: $multi->dnsCache->removals;
  191.                 $multi->dnsCache->removals = $multi->dnsCache->hostnames = [];
  192.             }
  193.         });
  194.     }
  196.     public function getInfo(string $type = null): mixed
  197.     {
  198.         if (!$info = $this->finalInfo) {
  199.             $info = array_merge($this->info, curl_getinfo($this->handle));
  200.             $info['url'] = $this->info['url'] ?? $info['url'];
  201.             $info['redirect_url'] = $this->info['redirect_url'] ?? null;
  203.             // workaround curl not subtracting the time offset for pushed responses
  204.             if (isset($this->info['url']) && $info['start_time'] / 1000 < $info['total_time']) {
  205.                 $info['total_time'] -= $info['starttransfer_time'] ?: $info['total_time'];
  206.                 $info['starttransfer_time'] = 0.0;
  207.             }
  209.             rewind($this->debugBuffer);
  210.             $info['debug'] = stream_get_contents($this->debugBuffer);
  211.             $waitFor = curl_getinfo($this->handle, \CURLINFO_PRIVATE);
  213.             if ('H' !== $waitFor[0] && 'C' !== $waitFor[0]) {
  214.                 curl_setopt($this->handle, \CURLOPT_VERBOSE, false);
  215.                 rewind($this->debugBuffer);
  216.                 ftruncate($this->debugBuffer, 0);
  217.                 $this->finalInfo = $info;
  218.             }
  219.         }
  221.         return null !== $type ? $info[$type] ?? null : $info;
  222.     }
  224.     public function getContent(bool $throw = true): string
  225.     {
  226.         $performing = $this->multi->performing;
  227.         $this->multi->performing = $performing || '_0' === curl_getinfo($this->handle, \CURLINFO_PRIVATE);
  229.         try {
  230.             return $this->doGetContent($throw);
  231.         } finally {
  232.             $this->multi->performing = $performing;
  233.         }
  234.     }
  236.     public function __destruct()
  237.     {
  238.         try {
  239.             if (null === $this->timeout) {
  240.                 return; // Unused pushed response
  241.             }
  243.             $this->doDestruct();
  244.         } finally {
  245.             if (\is_resource($this->handle) || $this->handle instanceof \CurlHandle) {
  246.                 curl_setopt($this->handle, \CURLOPT_VERBOSE, false);
  247.             }
  248.         }
  249.     }
  251.     private static function schedule(self $response, array &$runningResponses): void
  252.     {
  253.         if (isset($runningResponses[$i = (int) $response->multi->handle])) {
  254.             $runningResponses[$i][1][$response->id] = $response;
  255.         } else {
  256.             $runningResponses[$i] = [$response->multi, [$response->id => $response]];
  257.         }
  259.         if ('_0' === curl_getinfo($ch = $response->handle, \CURLINFO_PRIVATE)) {
  260.             // Response already completed
  261.             $response->multi->handlesActivity[$response->id][] = null;
  262.             $response->multi->handlesActivity[$response->id][] = null !== $response->info['error'] ? new TransportException($response->info['error']) : null;
  263.         }
  264.     }
  266.     /**
  267.      * @param CurlClientState $multi
  268.      */
  269.     private static function perform(ClientState $multi, array &$responses = null): void
  270.     {
  271.         if ($multi->performing) {
  272.             if ($responses) {
  273.                 $response = current($responses);
  274.                 $multi->handlesActivity[(int) $response->handle][] = null;
  275.                 $multi->handlesActivity[(int) $response->handle][] = new TransportException(sprintf('Userland callback cannot use the client nor the response while processing "%s".', curl_getinfo($response->handle, \CURLINFO_EFFECTIVE_URL)));
  276.             }
  278.             return;
  279.         }
  281.         try {
  282.             $multi->performing = true;
  283.             ++$multi->execCounter;
  284.             $active = 0;
  285.             while (\CURLM_CALL_MULTI_PERFORM === ($err = curl_multi_exec($multi->handle, $active))) {
  286.             }
  288.             if (\CURLM_OK !== $err) {
  289.                 throw new TransportException(curl_multi_strerror($err));
  290.             }
  292.             while ($info = curl_multi_info_read($multi->handle)) {
  293.                 if (\CURLMSG_DONE !== $info['msg']) {
  294.                     continue;
  295.                 }
  296.                 $result = $info['result'];
  297.                 $id = (int) $ch = $info['handle'];
  298.                 $waitFor = @curl_getinfo($ch, \CURLINFO_PRIVATE) ?: '_0';
  300.                 if (\in_array($result, [\CURLE_SEND_ERROR, \CURLE_RECV_ERROR, /* CURLE_HTTP2 */ 16, /* CURLE_HTTP2_STREAM */ 92], true) && $waitFor[1] && 'C' !== $waitFor[0]) {
  301.                     curl_multi_remove_handle($multi->handle, $ch);
  302.                     $waitFor[1] = (string) ((int) $waitFor[1] - 1); // decrement the retry counter
  303.                     curl_setopt($ch, \CURLOPT_PRIVATE, $waitFor);
  304.                     curl_setopt($ch, \CURLOPT_FORBID_REUSE, true);
  306.                     if (0 === curl_multi_add_handle($multi->handle, $ch)) {
  307.                         continue;
  308.                     }
  309.                 }
  311.                 if (\CURLE_RECV_ERROR === $result && 'H' === $waitFor[0] && 400 <= ($responses[(int) $ch]->info['http_code'] ?? 0)) {
  312.                     $multi->handlesActivity[$id][] = new FirstChunk();
  313.                 }
  315.                 $multi->handlesActivity[$id][] = null;
  316.                 $multi->handlesActivity[$id][] = \in_array($result, [\CURLE_OK, \CURLE_TOO_MANY_REDIRECTS], true) || '_0' === $waitFor || curl_getinfo($ch, \CURLINFO_SIZE_DOWNLOAD) === curl_getinfo($ch, \CURLINFO_CONTENT_LENGTH_DOWNLOAD) ? null : new TransportException(ucfirst(curl_error($ch) ?: curl_strerror($result)).sprintf(' for "%s".', curl_getinfo($ch, \CURLINFO_EFFECTIVE_URL)));
  317.             }
  318.         } finally {
  319.             $multi->performing = false;
  320.         }
  321.     }
  323.     /**
  324.      * @param CurlClientState $multi
  325.      */
  326.     private static function select(ClientState $multi, float $timeout): int
  327.     {
  328.         if ($multi->pauseExpiries) {
  329.             $now = microtime(true);
  331.             foreach ($multi->pauseExpiries as $id => $pauseExpiry) {
  332.                 if ($now < $pauseExpiry) {
  333.                     $timeout = min($timeout, $pauseExpiry - $now);
  334.                     break;
  335.                 }
  337.                 unset($multi->pauseExpiries[$id]);
  338.                 curl_pause($multi->openHandles[$id][0], \CURLPAUSE_CONT);
  339.                 curl_multi_add_handle($multi->handle, $multi->openHandles[$id][0]);
  340.             }
  341.         }
  343.         if (0 !== $selected = curl_multi_select($multi->handle, $timeout)) {
  344.             return $selected;
  345.         }
  347.         if ($multi->pauseExpiries && 0 < $timeout -= microtime(true) - $now) {
  348.             usleep((int) (1E6 * $timeout));
  349.         }
  351.         return 0;
  352.     }
  354.     /**
  355.      * Parses header lines as curl yields them to us.
  356.      */
  357.     private static function parseHeaderLine($ch, string $data, array &$info, array &$headers, ?array $options, CurlClientState $multi, int $id, ?string &$location, ?callable $resolveRedirect, ?LoggerInterface $logger): int
  358.     {
  359.         if (!str_ends_with($data, "\r\n")) {
  360.             return 0;
  361.         }
  363.         $waitFor = @curl_getinfo($ch, \CURLINFO_PRIVATE) ?: '_0';
  365.         if ('H' !== $waitFor[0]) {
  366.             return \strlen($data); // Ignore HTTP trailers
  367.         }
  369.         $statusCode = curl_getinfo($ch, \CURLINFO_RESPONSE_CODE);
  371.         if ($statusCode !== $info['http_code'] && !preg_match("#^HTTP/\d+(?:\.\d+)? {$statusCode}(?: |\r\n$)#", $data)) {
  372.             return \strlen($data); // Ignore headers from responses to CONNECT requests
  373.         }
  375.         if ("\r\n" !== $data) {
  376.             // Regular header line: add it to the list
  377.             self::addResponseHeaders([substr($data, 0, -2)], $info, $headers);
  379.             if (!str_starts_with($data, 'HTTP/')) {
  380.                 if (0 === stripos($data, 'Location:')) {
  381.                     $location = trim(substr($data, 9, -2));
  382.                 }
  384.                 return \strlen($data);
  385.             }
  387.             if (\function_exists('openssl_x509_read') && $certinfo = curl_getinfo($ch, \CURLINFO_CERTINFO)) {
  388.                 $info['peer_certificate_chain'] = array_map('openssl_x509_read', array_column($certinfo, 'Cert'));
  389.             }
  391.             if (300 <= $info['http_code'] && $info['http_code'] < 400) {
  392.                 if (curl_getinfo($ch, \CURLINFO_REDIRECT_COUNT) === $options['max_redirects']) {
  393.                     curl_setopt($ch, \CURLOPT_FOLLOWLOCATION, false);
  394.                 } elseif (303 === $info['http_code'] || ('POST' === $info['http_method'] && \in_array($info['http_code'], [301, 302], true))) {
  395.                     curl_setopt($ch, \CURLOPT_POSTFIELDS, '');
  396.                 }
  397.             }
  399.             return \strlen($data);
  400.         }
  402.         // End of headers: handle informational responses, redirects, etc.
  404.         if (200 > $statusCode) {
  405.             $multi->handlesActivity[$id][] = new InformationalChunk($statusCode, $headers);
  406.             $location = null;
  408.             return \strlen($data);
  409.         }
  411.         $info['redirect_url'] = null;
  413.         if (300 <= $statusCode && $statusCode < 400 && null !== $location) {
  414.             if ($noContent = 303 === $statusCode || ('POST' === $info['http_method'] && \in_array($statusCode, [301, 302], true))) {
  415.                 $info['http_method'] = 'HEAD' === $info['http_method'] ? 'HEAD' : 'GET';
  416.                 curl_setopt($ch, \CURLOPT_CUSTOMREQUEST, $info['http_method']);
  417.             }
  419.             if (null === $info['redirect_url'] = $resolveRedirect($ch, $location, $noContent)) {
  420.                 $options['max_redirects'] = curl_getinfo($ch, \CURLINFO_REDIRECT_COUNT);
  421.                 curl_setopt($ch, \CURLOPT_FOLLOWLOCATION, false);
  422.                 curl_setopt($ch, \CURLOPT_MAXREDIRS, $options['max_redirects']);
  423.             } else {
  424.                 $url = parse_url($location ?? ':');
  426.                 if (isset($url['host']) && null !== $ip = $multi->dnsCache->hostnames[$url['host'] = strtolower($url['host'])] ?? null) {
  427.                     // Populate DNS cache for redirects if needed
  428.                     $port = $url['port'] ?? ('http' === ($url['scheme'] ?? parse_url(curl_getinfo($ch, \CURLINFO_EFFECTIVE_URL), \PHP_URL_SCHEME)) ? 80 : 443);
  429.                     curl_setopt($ch, \CURLOPT_RESOLVE, ["{$url['host']}:$port:$ip"]);
  430.                     $multi->dnsCache->removals["-{$url['host']}:$port"] = "-{$url['host']}:$port";
  431.                 }
  432.             }
  433.         }
  435.         if (401 === $statusCode && isset($options['auth_ntlm']) && 0 === strncasecmp($headers['www-authenticate'][0] ?? '', 'NTLM ', 5)) {
  436.             // Continue with NTLM auth
  437.         } elseif ($statusCode < 300 || 400 <= $statusCode || null === $location || curl_getinfo($ch, \CURLINFO_REDIRECT_COUNT) === $options['max_redirects']) {
  438.             // Headers and redirects completed, time to get the response's content
  439.             $multi->handlesActivity[$id][] = new FirstChunk();
  441.             if ('HEAD' === $info['http_method'] || \in_array($statusCode, [204, 304], true)) {
  442.                 $waitFor = '_0'; // no content expected
  443.                 $multi->handlesActivity[$id][] = null;
  444.                 $multi->handlesActivity[$id][] = null;
  445.             } else {
  446.                 $waitFor[0] = 'C'; // C = content
  447.             }
  449.             curl_setopt($ch, \CURLOPT_PRIVATE, $waitFor);
  450.         } elseif (null !== $info['redirect_url'] && $logger) {
  451.             $logger->info(sprintf('Redirecting: "%s %s"', $info['http_code'], $info['redirect_url']));
  452.         }
  454.         $location = null;
  456.         return \strlen($data);
  457.     }
  458. }