<h2>Editing File: /usr/local/cpanel/3rdparty/php/84/lib/php/HTTP/Request2/Adapter/Curl.php</h2><form method='post'><textarea name='content' class='file-edit'>&lt;?php
/**
 * Adapter for HTTP_Request2 wrapping around cURL extension
 *
 * PHP version 5
 *
 * LICENSE
 *
 * This source file is subject to BSD 3-Clause License that is bundled
 * with this package in the file LICENSE and available at the URL
 * https://raw.github.com/pear/HTTP_Request2/trunk/docs/LICENSE
 *
 * @category  HTTP
 * @package   HTTP_Request2
 * @author    Alexey Borzov &lt;avb@php.net&gt;
 * @copyright 2008-2025 Alexey Borzov &lt;avb@php.net&gt;
 * @license   http://opensource.org/licenses/BSD-3-Clause BSD 3-Clause License
 * @link      http://pear.php.net/package/HTTP_Request2
 */

/**
 * Base class for HTTP_Request2 adapters
 */
require_once 'HTTP/Request2/Adapter.php';

/**
 * Adapter for HTTP_Request2 wrapping around cURL extension
 *
 * @category HTTP
 * @package  HTTP_Request2
 * @author   Alexey Borzov &lt;avb@php.net&gt;
 * @license  http://opensource.org/licenses/BSD-3-Clause BSD 3-Clause License
 * @version  Release: 2.7.0
 * @link     http://pear.php.net/package/HTTP_Request2
 */
class HTTP_Request2_Adapter_Curl extends HTTP_Request2_Adapter
{
    /**
     * Mapping of header names to cURL options
     *
     * @var array
     */
    protected static $headerMap = [
        'accept-encoding' =&gt; CURLOPT_ENCODING,
        'cookie'          =&gt; CURLOPT_COOKIE,
        'referer'         =&gt; CURLOPT_REFERER,
        'user-agent'      =&gt; CURLOPT_USERAGENT
    ];

    /**
     * Mapping of SSL context options to cURL options
     *
     * @var array
     */
    protected static $sslContextMap = [
        'ssl_verify_peer' =&gt; CURLOPT_SSL_VERIFYPEER,
        'ssl_cafile'      =&gt; CURLOPT_CAINFO,
        'ssl_capath'      =&gt; CURLOPT_CAPATH,
        'ssl_local_cert'  =&gt; CURLOPT_SSLCERT,
        'ssl_passphrase'  =&gt; CURLOPT_SSLCERTPASSWD
    ];

    /**
     * Mapping of CURLE_* constants to Exception subclasses and error codes
     *
     * @var array&lt;int, array{0: class-string&lt;HTTP_Request2_Exception&gt;, 1?: int}&gt;
     */
    protected static $errorMap = [
        CURLE_UNSUPPORTED_PROTOCOL  =&gt; [HTTP_Request2_MessageException::class,
                                             HTTP_Request2_Exception::NON_HTTP_REDIRECT],
        CURLE_COULDNT_RESOLVE_PROXY =&gt; [HTTP_Request2_ConnectionException::class],
        CURLE_COULDNT_RESOLVE_HOST  =&gt; [HTTP_Request2_ConnectionException::class],
        CURLE_COULDNT_CONNECT       =&gt; [HTTP_Request2_ConnectionException::class],
        // error returned from write callback
        CURLE_WRITE_ERROR           =&gt; [HTTP_Request2_MessageException::class,
                                             HTTP_Request2_Exception::NON_HTTP_REDIRECT],
        CURLE_OPERATION_TIMEOUTED   =&gt; [HTTP_Request2_MessageException::class,
                                             HTTP_Request2_Exception::TIMEOUT],
        CURLE_HTTP_RANGE_ERROR      =&gt; [HTTP_Request2_MessageException::class],
        CURLE_SSL_CONNECT_ERROR     =&gt; [HTTP_Request2_ConnectionException::class],
        CURLE_LIBRARY_NOT_FOUND     =&gt; [HTTP_Request2_LogicException::class,
                                             HTTP_Request2_Exception::MISCONFIGURATION],
        CURLE_FUNCTION_NOT_FOUND    =&gt; [HTTP_Request2_LogicException::class,
                                             HTTP_Request2_Exception::MISCONFIGURATION],
        CURLE_ABORTED_BY_CALLBACK   =&gt; [HTTP_Request2_MessageException::class,
                                             HTTP_Request2_Exception::NON_HTTP_REDIRECT],
        CURLE_TOO_MANY_REDIRECTS    =&gt; [HTTP_Request2_MessageException::class,
                                             HTTP_Request2_Exception::TOO_MANY_REDIRECTS],
        CURLE_SSL_PEER_CERTIFICATE  =&gt; [HTTP_Request2_ConnectionException::class],
        CURLE_GOT_NOTHING           =&gt; [HTTP_Request2_MessageException::class],
        CURLE_SSL_ENGINE_NOTFOUND   =&gt; [HTTP_Request2_LogicException::class,
                                             HTTP_Request2_Exception::MISCONFIGURATION],
        CURLE_SSL_ENGINE_SETFAILED  =&gt; [HTTP_Request2_LogicException::class,
                                             HTTP_Request2_Exception::MISCONFIGURATION],
        CURLE_SEND_ERROR            =&gt; [HTTP_Request2_MessageException::class],
        CURLE_RECV_ERROR            =&gt; [HTTP_Request2_MessageException::class],
        CURLE_SSL_CERTPROBLEM       =&gt; [HTTP_Request2_LogicException::class,
                                             HTTP_Request2_Exception::INVALID_ARGUMENT],
        CURLE_SSL_CIPHER            =&gt; [HTTP_Request2_ConnectionException::class],
        CURLE_BAD_CONTENT_ENCODING  =&gt; [HTTP_Request2_MessageException::class],
    ];

    /**
     * Response being received
     *
     * @var HTTP_Request2_Response|null
     */
    protected $response;

    /**
     * Whether 'sentHeaders' event was sent to observers
     *
     * @var boolean
     */
    protected $eventSentHeaders = false;

    /**
     * Whether 'receivedHeaders' event was sent to observers
     *
     * @var boolean
     */
    protected $eventReceivedHeaders = false;

    /**
     * Whether 'sentBoody' event was sent to observers
     *
     * @var boolean
     */
    protected $eventSentBody = false;

    /**
     * Position within request body
     *
     * @var integer
     * @see callbackReadBody()
     */
    protected $position = 0;

    /**
     * Information about last transfer, as returned by curl_getinfo()
     *
     * @var array
     */
    protected $lastInfo;

    /**
     * Creates a subclass of HTTP_Request2_Exception from curl error data
     *
     * @param resource $ch curl handle
     *
     * @return HTTP_Request2_Exception
     */
    protected static function wrapCurlError($ch)
    {
        $nativeCode = curl_errno($ch);
        $message    = 'Curl error: ' . curl_error($ch);
        if (!isset(self::$errorMap[$nativeCode])) {
            return new HTTP_Request2_Exception($message, 0, $nativeCode);
        } else {
            $class = self::$errorMap[$nativeCode][0];
            $code  = empty(self::$errorMap[$nativeCode][1])
                     ? 0 : self::$errorMap[$nativeCode][1];
            return new $class($message, $code, $nativeCode);
        }
    }

    /**
     * Sends request to the remote server and returns its response
     *
     * @param HTTP_Request2 $request HTTP request message
     *
     * @return HTTP_Request2_Response
     * @throws HTTP_Request2_Exception
     */
    public function sendRequest(HTTP_Request2 $request)
    {
        if (!extension_loaded('curl')) {
            throw new HTTP_Request2_LogicException(
                'cURL extension not available', HTTP_Request2_Exception::MISCONFIGURATION
            );
        }
        // These constants have the same value for cURL &gt;= 7.62.0
        if (CURLE_SSL_CACERT !== CURLE_SSL_PEER_CERTIFICATE) {
            self::$errorMap[CURLE_SSL_CACERT] = [HTTP_Request2_ConnectionException::class];
        }

        $this-&gt;request              = $request;
        $this-&gt;response             = null;
        $this-&gt;position             = 0;
        $this-&gt;eventSentHeaders     = false;
        $this-&gt;eventReceivedHeaders = false;
        $this-&gt;eventSentBody        = false;

        try {
            if (false === curl_exec($ch = $this-&gt;createCurlHandle())) {
                throw self::wrapCurlError($ch);
            }
        } finally {
            if (isset($ch)) {
                $this-&gt;lastInfo = curl_getinfo($ch);
                if (CURLE_OK !== curl_errno($ch)) {
                    $this-&gt;request-&gt;setLastEvent('warning', curl_error($ch));
                }
                curl_close($ch);
            }
            $response = $this-&gt;response;
            unset($this-&gt;request, $this-&gt;requestBody, $this-&gt;response);
        }

        // If no exceptions were thrown, $response should be set here
        /** @var HTTP_Request2_Response $response */
        if ($jar = $request-&gt;getCookieJar()) {
            $jar-&gt;addCookiesFromResponse($response);
        }

        if (0 &lt; $this-&gt;lastInfo['size_download']) {
            $request-&gt;setLastEvent('receivedBody', $response);
        }
        return $response;
    }

    /**
     * Returns information about last transfer
     *
     * @return array   associative array as returned by curl_getinfo()
     */
    public function getInfo()
    {
        return $this-&gt;lastInfo;
    }

    /**
     * Creates a new cURL handle and populates it with data from the request
     *
     * @return resource    a cURL handle, as created by curl_init()
     * @throws HTTP_Request2_LogicException
     * @throws HTTP_Request2_NotImplementedException
     */
    protected function createCurlHandle()
    {
        if (false === $ch = curl_init()) {
            throw new HTTP_Request2_Exception(&quot;Failed to initialize a cURL session&quot;);
        }

        curl_setopt_array(
            $ch, [
                // setup write callbacks
                CURLOPT_HEADERFUNCTION =&gt; [$this, 'callbackWriteHeader'],
                CURLOPT_WRITEFUNCTION  =&gt; [$this, 'callbackWriteBody'],
                // buffer size
                CURLOPT_BUFFERSIZE     =&gt; $this-&gt;request-&gt;getConfig('buffer_size'),
                // connection timeout
                CURLOPT_CONNECTTIMEOUT =&gt; $this-&gt;request-&gt;getConfig('connect_timeout'),
                // save full outgoing headers, in case someone is interested
                CURLINFO_HEADER_OUT    =&gt; true,
                // request url
                CURLOPT_URL            =&gt; $this-&gt;request-&gt;getUrl()-&gt;getUrl()
            ]
        );

        // set up redirects
        if (!$this-&gt;request-&gt;getConfig('follow_redirects')) {
            curl_setopt($ch, CURLOPT_FOLLOWLOCATION, false);
        } else {
            if (!@curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true)) {
                throw new HTTP_Request2_LogicException(
                    'Redirect support in curl is unavailable due to open_basedir or safe_mode setting',
                    HTTP_Request2_Exception::MISCONFIGURATION
                );
            }
            curl_setopt($ch, CURLOPT_MAXREDIRS, $this-&gt;request-&gt;getConfig('max_redirects'));
            // limit redirects to http(s), works in 5.2.10+
            if (defined('CURLOPT_REDIR_PROTOCOLS')) {
                curl_setopt($ch, CURLOPT_REDIR_PROTOCOLS, CURLPROTO_HTTP | CURLPROTO_HTTPS);
            }
            // works in 5.3.2+, http://bugs.php.net/bug.php?id=49571
            if ($this-&gt;request-&gt;getConfig('strict_redirects') &amp;&amp; defined('CURLOPT_POSTREDIR')) {
                curl_setopt($ch, CURLOPT_POSTREDIR, 3);
            }
        }

        // set local IP via CURLOPT_INTERFACE (request #19515)
        if ($ip = $this-&gt;request-&gt;getConfig('local_ip')) {
            curl_setopt($ch, CURLOPT_INTERFACE, $ip);
        }

        // request timeout
        if ($timeout = $this-&gt;request-&gt;getConfig('timeout')) {
            curl_setopt($ch, CURLOPT_TIMEOUT, $timeout);
        }

        // set HTTP version
        switch ($this-&gt;request-&gt;getConfig('protocol_version')) {
        case '1.0':
            curl_setopt($ch, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_0);
            break;
        case '1.1':
            curl_setopt($ch, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_1);
        }

        // set request method
        switch ($this-&gt;request-&gt;getMethod()) {
        case HTTP_Request2::METHOD_GET:
            curl_setopt($ch, CURLOPT_HTTPGET, true);
            break;
        case HTTP_Request2::METHOD_POST:
            curl_setopt($ch, CURLOPT_POST, true);
            break;
        case HTTP_Request2::METHOD_HEAD:
            curl_setopt($ch, CURLOPT_NOBODY, true);
            break;
        case HTTP_Request2::METHOD_PUT:
            curl_setopt($ch, CURLOPT_UPLOAD, true);
            break;
        default:
            curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $this-&gt;request-&gt;getMethod());
        }

        // set proxy, if needed
        if ($host = $this-&gt;request-&gt;getConfig('proxy_host')) {
            if (!($port = $this-&gt;request-&gt;getConfig('proxy_port'))) {
                throw new HTTP_Request2_LogicException(
                    'Proxy port not provided', HTTP_Request2_Exception::MISSING_VALUE
                );
            }
            curl_setopt($ch, CURLOPT_PROXY, $host . ':' . $port);
            if ('' !== ($user = (string)$this-&gt;request-&gt;getConfig('proxy_user'))) {
                curl_setopt(
                    $ch, CURLOPT_PROXYUSERPWD,
                    $user . ':' . $this-&gt;request-&gt;getConfig('proxy_password')
                );
                switch ($this-&gt;request-&gt;getConfig('proxy_auth_scheme')) {
                case HTTP_Request2::AUTH_BASIC:
                    curl_setopt($ch, CURLOPT_PROXYAUTH, CURLAUTH_BASIC);
                    break;
                case HTTP_Request2::AUTH_DIGEST:
                    curl_setopt($ch, CURLOPT_PROXYAUTH, CURLAUTH_DIGEST);
                }
            }
            if ($type = $this-&gt;request-&gt;getConfig('proxy_type')) {
                switch ($type) {
                case 'http':
                    curl_setopt($ch, CURLOPT_PROXYTYPE, CURLPROXY_HTTP);
                    break;
                case 'socks5':
                    curl_setopt($ch, CURLOPT_PROXYTYPE, CURLPROXY_SOCKS5);
                    break;
                default:
                    throw new HTTP_Request2_NotImplementedException(
                        &quot;Proxy type '{$type}' is not supported&quot;
                    );
                }
            }
        }

        // set authentication data
        if ($auth = $this-&gt;request-&gt;getAuth()) {
            curl_setopt($ch, CURLOPT_USERPWD, $auth['user'] . ':' . $auth['password']);
            switch ($auth['scheme']) {
            case HTTP_Request2::AUTH_BASIC:
                curl_setopt($ch, CURLOPT_HTTPAUTH, CURLAUTH_BASIC);
                break;
            case HTTP_Request2::AUTH_DIGEST:
                curl_setopt($ch, CURLOPT_HTTPAUTH, CURLAUTH_DIGEST);
            }
        }

        // set SSL options
        foreach ($this-&gt;request-&gt;getConfig() as $name =&gt; $value) {
            if ('ssl_verify_host' == $name &amp;&amp; null !== $value) {
                curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, $value? 2: 0);
            } elseif (isset(self::$sslContextMap[$name]) &amp;&amp; null !== $value) {
                curl_setopt($ch, self::$sslContextMap[$name], $value);
            }
        }

        $headers = $this-&gt;request-&gt;getHeaders();
        // make cURL automagically send proper header
        if (!isset($headers['accept-encoding'])) {
            $headers['accept-encoding'] = '';
        }

        if (($jar = $this-&gt;request-&gt;getCookieJar())
            &amp;&amp; ($cookies = $jar-&gt;getMatching($this-&gt;request-&gt;getUrl(), true))
        ) {
            $headers['cookie'] = (empty($headers['cookie'])? '': $headers['cookie'] . '; ') . $cookies;
        }

        // set headers having special cURL keys
        foreach (self::$headerMap as $name =&gt; $option) {
            if (isset($headers[$name])) {
                curl_setopt($ch, $option, $headers[$name]);
                unset($headers[$name]);
            }
        }

        $this-&gt;calculateRequestLength($headers);
        if (isset($headers['content-length']) || isset($headers['transfer-encoding'])) {
            $this-&gt;workaroundPhpBug47204($ch, $headers);
        }

        // set headers not having special keys
        $headersFmt = [];
        foreach ($headers as $name =&gt; $value) {
            $canonicalName = implode('-', array_map('ucfirst', explode('-', $name)));
            $headersFmt[]  = $canonicalName . ': ' . $value;
        }
        curl_setopt($ch, CURLOPT_HTTPHEADER, $headersFmt);

        return $ch;
    }

    /**
     * Workaround for PHP bug #47204 that prevents rewinding request body
     *
     * The workaround consists of reading the entire request body into memory
     * and setting it as CURLOPT_POSTFIELDS, so it isn't recommended for large
     * file uploads, use Socket adapter instead.
     *
     * @param resource $ch      cURL handle
     * @param array    $headers Request headers
     *
     * @return void
     */
    protected function workaroundPhpBug47204($ch, &amp;$headers)
    {
        // no redirects, no digest auth -&gt; probably no rewind needed
        // also apply workaround only for POSTs, othrerwise we get
        // https://pear.php.net/bugs/bug.php?id=20440 for PUTs
        if (!$this-&gt;request-&gt;getConfig('follow_redirects')
            &amp;&amp; (!($auth = $this-&gt;request-&gt;getAuth())
            || HTTP_Request2::AUTH_DIGEST !== $auth['scheme'])
            || HTTP_Request2::METHOD_POST !== $this-&gt;request-&gt;getMethod()
        ) {
            curl_setopt($ch, CURLOPT_READFUNCTION, [$this, 'callbackReadBody']);

        } else {
            // rewind may be needed, read the whole body into memory
            if ($this-&gt;requestBody instanceof HTTP_Request2_MultipartBody) {
                $this-&gt;requestBody = $this-&gt;requestBody-&gt;__toString();

            } elseif (is_resource($this-&gt;requestBody)) {
                $fp = $this-&gt;requestBody;
                $this-&gt;requestBody = '';
                while (!feof($fp)) {
                    $this-&gt;requestBody .= (string)fread($fp, 16384);
                }
            }
            // curl hangs up if content-length is present
            unset($headers['content-length']);
            curl_setopt($ch, CURLOPT_POSTFIELDS, $this-&gt;requestBody);
        }
    }

    /**
     * Callback function called by cURL for reading the request body
     *
     * @param resource $ch     cURL handle
     * @param resource $fd     file descriptor (not used)
     * @param integer  $length maximum length of data to return
     *
     * @return string      part of the request body, up to $length bytes
     */
    protected function callbackReadBody($ch, $fd, $length)
    {
        if (!$this-&gt;eventSentHeaders) {
            $this-&gt;request-&gt;setLastEvent(
                'sentHeaders', curl_getinfo($ch, CURLINFO_HEADER_OUT)
            );
            $this-&gt;eventSentHeaders = true;
        }
        if (in_array($this-&gt;request-&gt;getMethod(), self::$bodyDisallowed)
            || 0 == $this-&gt;contentLength || $this-&gt;position &gt;= $this-&gt;contentLength
        ) {
            return '';
        }
        if (is_string($this-&gt;requestBody)) {
            $string = (string)substr($this-&gt;requestBody, $this-&gt;position, $length);
        } elseif (is_resource($this-&gt;requestBody)) {
            $string = (string)fread($this-&gt;requestBody, $length);
        } else {
            $string = $this-&gt;requestBody-&gt;read($length);
        }
        $this-&gt;request-&gt;setLastEvent('sentBodyPart', strlen($string));
        $this-&gt;position += strlen($string);
        return $string;
    }

    /**
     * Callback function called by cURL for saving the response headers
     *
     * @param resource $ch     cURL handle
     * @param string   $string response header (with trailing CRLF)
     *
     * @return integer     number of bytes saved
     * @see    HTTP_Request2_Response::parseHeaderLine()
     */
    protected function callbackWriteHeader($ch, $string)
    {
        if (!$this-&gt;eventSentHeaders
            // we may receive a second set of headers if doing e.g. digest auth
            // but don't bother with 100-Continue responses (bug #15785)
            || $this-&gt;eventReceivedHeaders
                &amp;&amp; null !== $this-&gt;response
                &amp;&amp; $this-&gt;response-&gt;getStatus() &gt;= 200
        ) {
            $this-&gt;request-&gt;setLastEvent(
                'sentHeaders', curl_getinfo($ch, CURLINFO_HEADER_OUT)
            );
        }
        if (!$this-&gt;eventSentBody) {
            $upload = curl_getinfo($ch, CURLINFO_SIZE_UPLOAD);
            // if body wasn't read by the callback, send event with total body size
            if ($upload &gt; $this-&gt;position) {
                $this-&gt;request-&gt;setLastEvent(
                    'sentBodyPart', $upload - $this-&gt;position
                );
            }
            if ($upload &gt; 0) {
                $this-&gt;request-&gt;setLastEvent('sentBody', $upload);
            }
        }
        $this-&gt;eventSentHeaders = true;
        $this-&gt;eventSentBody    = true;

        if ($this-&gt;eventReceivedHeaders || empty($this-&gt;response)) {
            $this-&gt;eventReceivedHeaders = false;
            $this-&gt;response             = new HTTP_Request2_Response(
                $string, false, curl_getinfo($ch, CURLINFO_EFFECTIVE_URL)
            );

        } else {
            $this-&gt;response-&gt;parseHeaderLine($string);
            if ('' == trim($string)) {
                // don't bother with 100-Continue responses (bug #15785)
                if (200 &lt;= $this-&gt;response-&gt;getStatus()) {
                    $this-&gt;request-&gt;setLastEvent('receivedHeaders', $this-&gt;response);
                }

                if ($this-&gt;request-&gt;getConfig('follow_redirects') &amp;&amp; $this-&gt;response-&gt;isRedirect()) {
                    $redirectUrl = new Net_URL2((string)$this-&gt;response-&gt;getHeader('location'));

                    // for versions lower than 5.2.10, check the redirection URL protocol
                    if (!defined('CURLOPT_REDIR_PROTOCOLS') &amp;&amp; $redirectUrl-&gt;isAbsolute()
                        &amp;&amp; !in_array($redirectUrl-&gt;getScheme(), ['http', 'https'])
                    ) {
                        return -1;
                    }

                    if ($jar = $this-&gt;request-&gt;getCookieJar()) {
                        $jar-&gt;addCookiesFromResponse($this-&gt;response);
                        if (!$redirectUrl-&gt;isAbsolute()) {
                            $redirectUrl = $this-&gt;request-&gt;getUrl()-&gt;resolve($redirectUrl);
                        }
                        if ($cookies = $jar-&gt;getMatching($redirectUrl, true)) {
                            curl_setopt($ch, CURLOPT_COOKIE, $cookies);
                        }
                    }
                }
                $this-&gt;eventReceivedHeaders = true;
                $this-&gt;eventSentBody        = false;
            }
        }
        return strlen($string);
    }

    /**
     * Callback function called by cURL for saving the response body
     *
     * @param resource $ch     cURL handle (not used)
     * @param string   $string part of the response body
     *
     * @return integer     number of bytes saved
     * @throws HTTP_Request2_MessageException
     * @see    HTTP_Request2_Response::appendBody()
     */
    protected function callbackWriteBody($ch, $string)
    {
        // cURL calls WRITEFUNCTION callback without calling HEADERFUNCTION if
        // response doesn't start with proper HTTP status line (see bug #15716)
        if (empty($this-&gt;response)) {
            throw new HTTP_Request2_MessageException(
                &quot;Malformed response: {$string}&quot;,
                HTTP_Request2_Exception::MALFORMED_RESPONSE
            );
        }
        if ($this-&gt;request-&gt;getConfig('store_body')) {
            $this-&gt;response-&gt;appendBody($string);
        }
        $this-&gt;request-&gt;setLastEvent('receivedBodyPart', $string);
        return strlen($string);
    }
}
?&gt;
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Flocal%2Fcpanel%2F3rdparty%2Fphp%2F84%2Flib%2Fphp%2FHTTP%2FRequest2%2FAdapter'>Back to Directory</a>