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

Open in your IDE?
  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 $multi;
  36.     private $debugBuffer;
  38.     /**
  39.      * @param \CurlHandle|resource|string $ch
  40.      *
  41.      * @internal
  42.      */
  43.     public function __construct(CurlClientState $multi, $ch, array $options = null, LoggerInterface $logger = null, string $method = 'GET', callable $resolveRedirect = null, int $curlVersion = null)
  44.     {
  45.         $this->multi = $multi;
  47.         if (\is_resource($ch) || $ch instanceof \CurlHandle) {
  48.             $this->handle = $ch;
  49.             $this->debugBuffer = fopen('php://temp', 'w+');
  50.             if (0x074000 === $curlVersion) {
  51.                 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.');
  52.             } else {
  53.                 curl_setopt($ch, \CURLOPT_VERBOSE, true);
  54.                 curl_setopt($ch, \CURLOPT_STDERR, $this->debugBuffer);
  55.             }
  56.         } else {
  57.             $this->info['url'] = $ch;
  58.             $ch = $this->handle;
  59.         }
  61.         $this->id = $id = (int) $ch;
  62.         $this->logger = $logger;
  63.         $this->shouldBuffer = $options['buffer'] ?? true;
  64.         $this->timeout = $options['timeout'] ?? null;
  65.         $this->info['http_method'] = $method;
  66.         $this->info['user_data'] = $options['user_data'] ?? null;
  67.         $this->info['max_duration'] = $options['max_duration'] ?? null;
  68.         $this->info['start_time'] = $this->info['start_time'] ?? microtime(true);
  69.         $info = &$this->info;
  70.         $headers = &$this->headers;
  71.         $debugBuffer = $this->debugBuffer;
  73.         if (!$info['response_headers']) {
  74.             // Used to keep track of what we're waiting for
  75.             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
  76.         }
  78.         curl_setopt($ch, \CURLOPT_HEADERFUNCTION, static function ($ch, string $data) use (&$info, &$headers, $options, $multi, $id, &$location, $resolveRedirect, $logger): int {
  79.             return self::parseHeaderLine($ch, $data, $info, $headers, $options, $multi, $id, $location, $resolveRedirect, $logger);
  80.         });
  82.         if (null === $options) {
  83.             // Pushed response: buffer until requested
  84.             curl_setopt($ch, \CURLOPT_WRITEFUNCTION, static function ($ch, string $data) use ($multi, $id): int {
  85.                 $multi->handlesActivity[$id][] = $data;
  86.                 curl_pause($ch, \CURLPAUSE_RECV);
  88.                 return \strlen($data);
  89.             });
  91.             return;
  92.         }
  94.         $execCounter = $multi->execCounter;
  95.         $this->info['pause_handler'] = static function (float $duration) use ($ch, $multi, $execCounter) {
  96.             if (0 < $duration) {
  97.                 if ($execCounter === $multi->execCounter) {
  98.                     $multi->execCounter = !\is_float($execCounter) ? 1 + $execCounter : \PHP_INT_MIN;
  99.                     curl_multi_remove_handle($multi->handle, $ch);
  100.                 }
  102.                 $lastExpiry = end($multi->pauseExpiries);
  103.                 $multi->pauseExpiries[(int) $ch] = $duration += microtime(true);
  104.                 if (false !== $lastExpiry && $lastExpiry > $duration) {
  105.                     asort($multi->pauseExpiries);
  106.                 }
  107.                 curl_pause($ch, \CURLPAUSE_ALL);
  108.             } else {
  109.                 unset($multi->pauseExpiries[(int) $ch]);
  110.                 curl_pause($ch, \CURLPAUSE_CONT);
  111.                 curl_multi_add_handle($multi->handle, $ch);
  112.             }
  113.         };
  115.         $this->inflate = !isset($options['normalized_headers']['accept-encoding']);
  116.         curl_pause($ch, \CURLPAUSE_CONT);
  118.         if ($onProgress = $options['on_progress']) {
  119.             $url = isset($info['url']) ? ['url' => $info['url']] : [];
  120.             curl_setopt($ch, \CURLOPT_NOPROGRESS, false);
  121.             curl_setopt($ch, \CURLOPT_PROGRESSFUNCTION, static function ($ch, $dlSize, $dlNow) use ($onProgress, &$info, $url, $multi, $debugBuffer) {
  122.                 try {
  123.                     rewind($debugBuffer);
  124.                     $debug = ['debug' => stream_get_contents($debugBuffer)];
  125.                     $onProgress($dlNow, $dlSize, $url + curl_getinfo($ch) + $info + $debug);
  126.                 } catch (\Throwable $e) {
  127.                     $multi->handlesActivity[(int) $ch][] = null;
  128.                     $multi->handlesActivity[(int) $ch][] = $e;
  130.                     return 1; // Abort the request
  131.                 }
  133.                 return null;
  134.             });
  135.         }
  137.         curl_setopt($ch, \CURLOPT_WRITEFUNCTION, static function ($ch, string $data) use ($multi, $id): int {
  138.             if ('H' === (curl_getinfo($ch, \CURLINFO_PRIVATE)[0] ?? null)) {
  139.                 $multi->handlesActivity[$id][] = null;
  140.                 $multi->handlesActivity[$id][] = new TransportException(sprintf('Unsupported protocol for "%s"', curl_getinfo($ch, \CURLINFO_EFFECTIVE_URL)));
  142.                 return 0;
  143.             }
  145.             curl_setopt($ch, \CURLOPT_WRITEFUNCTION, static function ($ch, string $data) use ($multi, $id): int {
  146.                 $multi->handlesActivity[$id][] = $data;
  148.                 return \strlen($data);
  149.             });
  151.             $multi->handlesActivity[$id][] = $data;
  153.             return \strlen($data);
  154.         });
  156.         $this->initializer = static function (self $response) {
  157.             $waitFor = curl_getinfo($ch = $response->handle, \CURLINFO_PRIVATE);
  159.             return 'H' === $waitFor[0];
  160.         };
  162.         // Schedule the request in a non-blocking way
  163.         $multi->lastTimeout = null;
  164.         $multi->openHandles[$id] = [$ch, $options];
  165.         curl_multi_add_handle($multi->handle, $ch);
  167.         $this->canary = new Canary(static function () use ($ch, $multi, $id) {
  168.             unset($multi->pauseExpiries[$id], $multi->openHandles[$id], $multi->handlesActivity[$id]);
  169.             curl_setopt($ch, \CURLOPT_PRIVATE, '_0');
  171.             if ($multi->performing) {
  172.                 return;
  173.             }
  175.             curl_multi_remove_handle($multi->handle, $ch);
  176.             curl_setopt_array($ch, [
  177.                 \CURLOPT_NOPROGRESS => true,
  178.                 \CURLOPT_PROGRESSFUNCTION => null,
  179.                 \CURLOPT_HEADERFUNCTION => null,
  180.                 \CURLOPT_WRITEFUNCTION => null,
  181.                 \CURLOPT_READFUNCTION => null,
  182.                 \CURLOPT_INFILE => null,
  183.             ]);
  185.             if (!$multi->openHandles) {
  186.                 // Schedule DNS cache eviction for the next request
  187.                 $multi->dnsCache->evictions = $multi->dnsCache->evictions ?: $multi->dnsCache->removals;
  188.                 $multi->dnsCache->removals = $multi->dnsCache->hostnames = [];
  189.             }
  190.         });
  191.     }
  193.     /**
  194.      * {@inheritdoc}
  195.      */
  196.     public function getInfo(string $type = null)
  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.     /**
  225.      * {@inheritdoc}
  226.      */
  227.     public function getContent(bool $throw = true): string
  228.     {
  229.         $performing = $this->multi->performing;
  230.         $this->multi->performing = $performing || '_0' === curl_getinfo($this->handle, \CURLINFO_PRIVATE);
  232.         try {
  233.             return $this->doGetContent($throw);
  234.         } finally {
  235.             $this->multi->performing = $performing;
  236.         }
  237.     }
  239.     public function __destruct()
  240.     {
  241.         try {
  242.             if (null === $this->timeout) {
  243.                 return; // Unused pushed response
  244.             }
  246.             $this->doDestruct();
  247.         } finally {
  248.             if (\is_resource($this->handle) || $this->handle instanceof \CurlHandle) {
  249.                 curl_setopt($this->handle, \CURLOPT_VERBOSE, false);
  250.             }
  251.         }
  252.     }
  254.     /**
  255.      * {@inheritdoc}
  256.      */
  257.     private static function schedule(self $response, array &$runningResponses): void
  258.     {
  259.         if (isset($runningResponses[$i = (int) $response->multi->handle])) {
  260.             $runningResponses[$i][1][$response->id] = $response;
  261.         } else {
  262.             $runningResponses[$i] = [$response->multi, [$response->id => $response]];
  263.         }
  265.         if ('_0' === curl_getinfo($ch = $response->handle, \CURLINFO_PRIVATE)) {
  266.             // Response already completed
  267.             $response->multi->handlesActivity[$response->id][] = null;
  268.             $response->multi->handlesActivity[$response->id][] = null !== $response->info['error'] ? new TransportException($response->info['error']) : null;
  269.         }
  270.     }
  272.     /**
  273.      * {@inheritdoc}
  274.      *
  275.      * @param CurlClientState $multi
  276.      */
  277.     private static function perform(ClientState $multi, array &$responses = null): void
  278.     {
  279.         if ($multi->performing) {
  280.             if ($responses) {
  281.                 $response = current($responses);
  282.                 $multi->handlesActivity[(int) $response->handle][] = null;
  283.                 $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)));
  284.             }
  286.             return;
  287.         }
  289.         try {
  290.             $multi->performing = true;
  291.             ++$multi->execCounter;
  292.             $active = 0;
  293.             while (\CURLM_CALL_MULTI_PERFORM === ($err = curl_multi_exec($multi->handle, $active))) {
  294.             }
  296.             if (\CURLM_OK !== $err) {
  297.                 throw new TransportException(curl_multi_strerror($err));
  298.             }
  300.             while ($info = curl_multi_info_read($multi->handle)) {
  301.                 if (\CURLMSG_DONE !== $info['msg']) {
  302.                     continue;
  303.                 }
  304.                 $result = $info['result'];
  305.                 $id = (int) $ch = $info['handle'];
  306.                 $waitFor = @curl_getinfo($ch, \CURLINFO_PRIVATE) ?: '_0';
  308.                 if (\in_array($result, [\CURLE_SEND_ERROR, \CURLE_RECV_ERROR, /* CURLE_HTTP2 */ 16, /* CURLE_HTTP2_STREAM */ 92], true) && $waitFor[1] && 'C' !== $waitFor[0]) {
  309.                     curl_multi_remove_handle($multi->handle, $ch);
  310.                     $waitFor[1] = (string) ((int) $waitFor[1] - 1); // decrement the retry counter
  311.                     curl_setopt($ch, \CURLOPT_PRIVATE, $waitFor);
  312.                     curl_setopt($ch, \CURLOPT_FORBID_REUSE, true);
  314.                     if (0 === curl_multi_add_handle($multi->handle, $ch)) {
  315.                         continue;
  316.                     }
  317.                 }
  319.                 if (\CURLE_RECV_ERROR === $result && 'H' === $waitFor[0] && 400 <= ($responses[(int) $ch]->info['http_code'] ?? 0)) {
  320.                     $multi->handlesActivity[$id][] = new FirstChunk();
  321.                 }
  323.                 $multi->handlesActivity[$id][] = null;
  324.                 $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)));
  325.             }
  326.         } finally {
  327.             $multi->performing = false;
  328.         }
  329.     }
  331.     /**
  332.      * {@inheritdoc}
  333.      *
  334.      * @param CurlClientState $multi
  335.      */
  336.     private static function select(ClientState $multi, float $timeout): int
  337.     {
  338.         if (\PHP_VERSION_ID < 70211) {
  339.             // workaround https://bugs.php.net/76480
  340.             $timeout = min($timeout, 0.01);
  341.         }
  343.         if ($multi->pauseExpiries) {
  344.             $now = microtime(true);
  346.             foreach ($multi->pauseExpiries as $id => $pauseExpiry) {
  347.                 if ($now < $pauseExpiry) {
  348.                     $timeout = min($timeout, $pauseExpiry - $now);
  349.                     break;
  350.                 }
  352.                 unset($multi->pauseExpiries[$id]);
  353.                 curl_pause($multi->openHandles[$id][0], \CURLPAUSE_CONT);
  354.                 curl_multi_add_handle($multi->handle, $multi->openHandles[$id][0]);
  355.             }
  356.         }
  358.         if (0 !== $selected = curl_multi_select($multi->handle, $timeout)) {
  359.             return $selected;
  360.         }
  362.         if ($multi->pauseExpiries && 0 < $timeout -= microtime(true) - $now) {
  363.             usleep((int) (1E6 * $timeout));
  364.         }
  366.         return 0;
  367.     }
  369.     /**
  370.      * Parses header lines as curl yields them to us.
  371.      */
  372.     private static function parseHeaderLine($ch, string $data, array &$info, array &$headers, ?array $options, CurlClientState $multi, int $id, ?string &$location, ?callable $resolveRedirect, ?LoggerInterface $logger): int
  373.     {
  374.         if (!str_ends_with($data, "\r\n")) {
  375.             return 0;
  376.         }
  378.         $waitFor = @curl_getinfo($ch, \CURLINFO_PRIVATE) ?: '_0';
  380.         if ('H' !== $waitFor[0]) {
  381.             return \strlen($data); // Ignore HTTP trailers
  382.         }
  384.         $statusCode = curl_getinfo($ch, \CURLINFO_RESPONSE_CODE);
  386.         if ($statusCode !== $info['http_code'] && !preg_match("#^HTTP/\d+(?:\.\d+)? {$statusCode}(?: |\r\n$)#", $data)) {
  387.             return \strlen($data); // Ignore headers from responses to CONNECT requests
  388.         }
  390.         if ("\r\n" !== $data) {
  391.             // Regular header line: add it to the list
  392.             self::addResponseHeaders([substr($data, 0, -2)], $info, $headers);
  394.             if (!str_starts_with($data, 'HTTP/')) {
  395.                 if (0 === stripos($data, 'Location:')) {
  396.                     $location = trim(substr($data, 9, -2));
  397.                 }
  399.                 return \strlen($data);
  400.             }
  402.             if (\function_exists('openssl_x509_read') && $certinfo = curl_getinfo($ch, \CURLINFO_CERTINFO)) {
  403.                 $info['peer_certificate_chain'] = array_map('openssl_x509_read', array_column($certinfo, 'Cert'));
  404.             }
  406.             if (300 <= $info['http_code'] && $info['http_code'] < 400) {
  407.                 if (curl_getinfo($ch, \CURLINFO_REDIRECT_COUNT) === $options['max_redirects']) {
  408.                     curl_setopt($ch, \CURLOPT_FOLLOWLOCATION, false);
  409.                 } elseif (303 === $info['http_code'] || ('POST' === $info['http_method'] && \in_array($info['http_code'], [301, 302], true))) {
  410.                     curl_setopt($ch, \CURLOPT_POSTFIELDS, '');
  411.                 }
  412.             }
  414.             return \strlen($data);
  415.         }
  417.         // End of headers: handle informational responses, redirects, etc.
  419.         if (200 > $statusCode) {
  420.             $multi->handlesActivity[$id][] = new InformationalChunk($statusCode, $headers);
  421.             $location = null;
  423.             return \strlen($data);
  424.         }
  426.         $info['redirect_url'] = null;
  428.         if (300 <= $statusCode && $statusCode < 400 && null !== $location) {
  429.             if ($noContent = 303 === $statusCode || ('POST' === $info['http_method'] && \in_array($statusCode, [301, 302], true))) {
  430.                 $info['http_method'] = 'HEAD' === $info['http_method'] ? 'HEAD' : 'GET';
  431.                 curl_setopt($ch, \CURLOPT_CUSTOMREQUEST, $info['http_method']);
  432.             }
  434.             if (null === $info['redirect_url'] = $resolveRedirect($ch, $location, $noContent)) {
  435.                 $options['max_redirects'] = curl_getinfo($ch, \CURLINFO_REDIRECT_COUNT);
  436.                 curl_setopt($ch, \CURLOPT_FOLLOWLOCATION, false);
  437.                 curl_setopt($ch, \CURLOPT_MAXREDIRS, $options['max_redirects']);
  438.             } else {
  439.                 $url = parse_url($location ?? ':');
  441.                 if (isset($url['host']) && null !== $ip = $multi->dnsCache->hostnames[$url['host'] = strtolower($url['host'])] ?? null) {
  442.                     // Populate DNS cache for redirects if needed
  443.                     $port = $url['port'] ?? ('http' === ($url['scheme'] ?? parse_url(curl_getinfo($ch, \CURLINFO_EFFECTIVE_URL), \PHP_URL_SCHEME)) ? 80 : 443);
  444.                     curl_setopt($ch, \CURLOPT_RESOLVE, ["{$url['host']}:$port:$ip"]);
  445.                     $multi->dnsCache->removals["-{$url['host']}:$port"] = "-{$url['host']}:$port";
  446.                 }
  447.             }
  448.         }
  450.         if (401 === $statusCode && isset($options['auth_ntlm']) && 0 === strncasecmp($headers['www-authenticate'][0] ?? '', 'NTLM ', 5)) {
  451.             // Continue with NTLM auth
  452.         } elseif ($statusCode < 300 || 400 <= $statusCode || null === $location || curl_getinfo($ch, \CURLINFO_REDIRECT_COUNT) === $options['max_redirects']) {
  453.             // Headers and redirects completed, time to get the response's content
  454.             $multi->handlesActivity[$id][] = new FirstChunk();
  456.             if ('HEAD' === $info['http_method'] || \in_array($statusCode, [204, 304], true)) {
  457.                 $waitFor = '_0'; // no content expected
  458.                 $multi->handlesActivity[$id][] = null;
  459.                 $multi->handlesActivity[$id][] = null;
  460.             } else {
  461.                 $waitFor[0] = 'C'; // C = content
  462.             }
  464.             curl_setopt($ch, \CURLOPT_PRIVATE, $waitFor);
  465.         } elseif (null !== $info['redirect_url'] && $logger) {
  466.             $logger->info(sprintf('Redirecting: "%s %s"', $info['http_code'], $info['redirect_url']));
  467.         }
  469.         $location = null;
  471.         return \strlen($data);
  472.     }
  473. }