<h2>File Contents: /home/planet5/public_html/4xpips.net/secure/library/pear/HTTP/Request2/copy_of_Response.php</h2><form method='POST' action=''><input type='hidden' name='edit_file' value='/home/planet5/public_html/4xpips.net/secure/library/pear/HTTP/Request2/copy_of_Response.php'><textarea name='file_content' rows='10' cols='50'>&lt;?php
/**
 * Class representing a HTTP response
 *
 * 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: Response.php 317591 2011-10-01 08:37:49Z avb $
 * @link       http://pear.php.net/package/HTTP_Request2
 */

/**
 * Exception class for HTTP_Request2 package
 */
require_once &#039;HTTP/Request2/Exception.php&#039;;

/**
 * Class representing a HTTP response
 *
 * The class is designed to be used in &quot;streaming&quot; scenario, building the
 * response as it is being received:
 * &lt;code&gt;
 * $statusLine = read_status_line();
 * $response = new HTTP_Request2_Response($statusLine);
 * do {
 *     $headerLine = read_header_line();
 *     $response-&gt;parseHeaderLine($headerLine);
 * } while ($headerLine != &#039;&#039;);
 *
 * while ($chunk = read_body()) {
 *     $response-&gt;appendBody($chunk);
 * }
 *
 * var_dump($response-&gt;getHeader(), $response-&gt;getCookies(), $response-&gt;getBody());
 * &lt;/code&gt;
 *
 *
 * @category   HTTP
 * @package    HTTP_Request2
 * @author     Alexey Borzov &lt;avb@php.net&gt;
 * @version    Release: 2.0.0
 * @link       http://tools.ietf.org/html/rfc2616#section-6
 */
class HTTP_Request2_Response
{
   /**
    * HTTP protocol version (e.g. 1.0, 1.1)
    * @var  string
    */
    protected $version;

   /**
    * Status code
    * @var  integer
    * @link http://tools.ietf.org/html/rfc2616#section-6.1.1
    */
    protected $code;

   /**
    * Reason phrase
    * @var  string
    * @link http://tools.ietf.org/html/rfc2616#section-6.1.1
    */
    protected $reasonPhrase;

   /**
    * Effective URL (may be different from original request URL in case of redirects)
    * @var  string
    */
    protected $effectiveUrl;

   /**
    * Associative array of response headers
    * @var  array
    */
    protected $headers = array();

   /**
    * Cookies set in the response
    * @var  array
    */
    protected $cookies = array();

   /**
    * Name of last header processed by parseHederLine()
    *
    * Used to handle the headers that span multiple lines
    *
    * @var  string
    */
    protected $lastHeader = null;

   /**
    * Response body
    * @var  string
    */
    protected $body = &#039;&#039;;

   /**
    * Whether the body is still encoded by Content-Encoding
    *
    * cURL provides the decoded body to the callback; if we are reading from
    * socket the body is still gzipped / deflated
    *
    * @var  bool
    */
    protected $bodyEncoded;

   /**
    * Associative array of HTTP status code / reason phrase.
    *
    * @var  array
    * @link http://tools.ietf.org/html/rfc2616#section-10
    */
    protected static $phrases = array(

        // 1xx: Informational - Request received, continuing process
        100 =&gt; &#039;Continue&#039;,
        101 =&gt; &#039;Switching Protocols&#039;,

        // 2xx: Success - The action was successfully received, understood and
        // accepted
        200 =&gt; &#039;OK&#039;,
        201 =&gt; &#039;Created&#039;,
        202 =&gt; &#039;Accepted&#039;,
        203 =&gt; &#039;Non-Authoritative Information&#039;,
        204 =&gt; &#039;No Content&#039;,
        205 =&gt; &#039;Reset Content&#039;,
        206 =&gt; &#039;Partial Content&#039;,

        // 3xx: Redirection - Further action must be taken in order to complete
        // the request
        300 =&gt; &#039;Multiple Choices&#039;,
        301 =&gt; &#039;Moved Permanently&#039;,
        302 =&gt; &#039;Found&#039;,  // 1.1
        303 =&gt; &#039;See Other&#039;,
        304 =&gt; &#039;Not Modified&#039;,
        305 =&gt; &#039;Use Proxy&#039;,
        307 =&gt; &#039;Temporary Redirect&#039;,

        // 4xx: Client Error - The request contains bad syntax or cannot be
        // fulfilled
        400 =&gt; &#039;Bad Request&#039;,
        401 =&gt; &#039;Unauthorized&#039;,
        402 =&gt; &#039;Payment Required&#039;,
        403 =&gt; &#039;Forbidden&#039;,
        404 =&gt; &#039;Not Found&#039;,
        405 =&gt; &#039;Method Not Allowed&#039;,
        406 =&gt; &#039;Not Acceptable&#039;,
        407 =&gt; &#039;Proxy Authentication Required&#039;,
        408 =&gt; &#039;Request Timeout&#039;,
        409 =&gt; &#039;Conflict&#039;,
        410 =&gt; &#039;Gone&#039;,
        411 =&gt; &#039;Length Required&#039;,
        412 =&gt; &#039;Precondition Failed&#039;,
        413 =&gt; &#039;Request Entity Too Large&#039;,
        414 =&gt; &#039;Request-URI Too Long&#039;,
        415 =&gt; &#039;Unsupported Media Type&#039;,
        416 =&gt; &#039;Requested Range Not Satisfiable&#039;,
        417 =&gt; &#039;Expectation Failed&#039;,

        // 5xx: Server Error - The server failed to fulfill an apparently
        // valid request
        500 =&gt; &#039;Internal Server Error&#039;,
        501 =&gt; &#039;Not Implemented&#039;,
        502 =&gt; &#039;Bad Gateway&#039;,
        503 =&gt; &#039;Service Unavailable&#039;,
        504 =&gt; &#039;Gateway Timeout&#039;,
        505 =&gt; &#039;HTTP Version Not Supported&#039;,
        509 =&gt; &#039;Bandwidth Limit Exceeded&#039;,

    );

   /**
    * Returns the default reason phrase for the given code or all reason phrases
    *
    * @param  int $code         Response code
    * @return string|array|null Default reason phrase for $code if $code is given
    *                           (null if no phrase is available), array of all
    *                           reason phrases if $code is null
    * @link   http://pear.php.net/bugs/18716
    */
    public static function getDefaultReasonPhrase($code = null)
    {
        if (null === $code) {
            return self::$phrases;
        } else {
            return isset(self::$phrases[$code]) ? self::$phrases[$code] : null;
        }
    }

   /**
    * Constructor, parses the response status line
    *
    * @param    string Response status line (e.g. &quot;HTTP/1.1 200 OK&quot;)
    * @param    bool   Whether body is still encoded by Content-Encoding
    * @param    string Effective URL of the response
    * @throws   HTTP_Request2_MessageException if status line is invalid according to spec
    */
    public function __construct($statusLine, $bodyEncoded = true, $effectiveUrl = null)
    {
        if (!preg_match(&#039;!^HTTP/(\d\.\d) (\d{3})(?: (.+))?!&#039;, $statusLine, $m)) {
            throw new HTTP_Request2_MessageException(
                &quot;Malformed response: {$statusLine}&quot;,
                HTTP_Request2_Exception::MALFORMED_RESPONSE
            );
        }
        $this-&gt;version      = $m[1];
        $this-&gt;code         = intval($m[2]);
        $this-&gt;reasonPhrase = !empty($m[3]) ? trim($m[3]) : self::getDefaultReasonPhrase($this-&gt;code);
        $this-&gt;bodyEncoded  = (bool)$bodyEncoded;
        $this-&gt;effectiveUrl = (string)$effectiveUrl;
    }

   /**
    * Parses the line from HTTP response filling $headers array
    *
    * The method should be called after reading the line from socket or receiving
    * it into cURL callback. Passing an empty string here indicates the end of
    * response headers and triggers additional processing, so be sure to pass an
    * empty string in the end.
    *
    * @param    string  Line from HTTP response
    */
    public function parseHeaderLine($headerLine)
    {
        $headerLine = trim($headerLine, &quot;\r\n&quot;);

        // empty string signals the end of headers, process the received ones
        if (&#039;&#039; == $headerLine) {
            if (!empty($this-&gt;headers[&#039;set-cookie&#039;])) {
                $cookies = is_array($this-&gt;headers[&#039;set-cookie&#039;])?
                           $this-&gt;headers[&#039;set-cookie&#039;]:
                           array($this-&gt;headers[&#039;set-cookie&#039;]);
                foreach ($cookies as $cookieString) {
                    $this-&gt;parseCookie($cookieString);
                }
                unset($this-&gt;headers[&#039;set-cookie&#039;]);
            }
            foreach (array_keys($this-&gt;headers) as $k) {
                if (is_array($this-&gt;headers[$k])) {
                    $this-&gt;headers[$k] = implode(&#039;, &#039;, $this-&gt;headers[$k]);
                }
            }

        // string of the form header-name: header value
        } elseif (preg_match(&#039;!^([^\x00-\x1f\x7f-\xff()&lt;&gt;@,;:\\\\&quot;/\[\]?={}\s]+):(.+)$!&#039;, $headerLine, $m)) {
            $name  = strtolower($m[1]);
            $value = trim($m[2]);
            if (empty($this-&gt;headers[$name])) {
                $this-&gt;headers[$name] = $value;
            } else {
                if (!is_array($this-&gt;headers[$name])) {
                    $this-&gt;headers[$name] = array($this-&gt;headers[$name]);
                }
                $this-&gt;headers[$name][] = $value;
            }
            $this-&gt;lastHeader = $name;

        // continuation of a previous header
        } elseif (preg_match(&#039;!^\s+(.+)$!&#039;, $headerLine, $m) &amp;&amp; $this-&gt;lastHeader) {
            if (!is_array($this-&gt;headers[$this-&gt;lastHeader])) {
                $this-&gt;headers[$this-&gt;lastHeader] .= &#039; &#039; . trim($m[1]);
            } else {
                $key = count($this-&gt;headers[$this-&gt;lastHeader]) - 1;
                $this-&gt;headers[$this-&gt;lastHeader][$key] .= &#039; &#039; . trim($m[1]);
            }
        }
    }

   /**
    * Parses a Set-Cookie header to fill $cookies array
    *
    * @param    string    value of Set-Cookie header
    * @link     http://web.archive.org/web/20080331104521/http://cgi.netscape.com/newsref/std/cookie_spec.html
    */
    protected function parseCookie($cookieString)
    {
        $cookie = array(
            &#039;expires&#039; =&gt; null,
            &#039;domain&#039;  =&gt; null,
            &#039;path&#039;    =&gt; null,
            &#039;secure&#039;  =&gt; false
        );

        // Only a name=value pair
        if (!strpos($cookieString, &#039;;&#039;)) {
            $pos = strpos($cookieString, &#039;=&#039;);
            $cookie[&#039;name&#039;]  = trim(substr($cookieString, 0, $pos));
            $cookie[&#039;value&#039;] = trim(substr($cookieString, $pos + 1));

        // Some optional parameters are supplied
        } else {
            $elements = explode(&#039;;&#039;, $cookieString);
            $pos = strpos($elements[0], &#039;=&#039;);
            $cookie[&#039;name&#039;]  = trim(substr($elements[0], 0, $pos));
            $cookie[&#039;value&#039;] = trim(substr($elements[0], $pos + 1));

            for ($i = 1; $i &lt; count($elements); $i++) {
                if (false === strpos($elements[$i], &#039;=&#039;)) {
                    $elName  = trim($elements[$i]);
                    $elValue = null;
                } else {
                    list ($elName, $elValue) = array_map(&#039;trim&#039;, explode(&#039;=&#039;, $elements[$i]));
                }
                $elName = strtolower($elName);
                if (&#039;secure&#039; == $elName) {
                    $cookie[&#039;secure&#039;] = true;
                } elseif (&#039;expires&#039; == $elName) {
                    $cookie[&#039;expires&#039;] = str_replace(&#039;&quot;&#039;, &#039;&#039;, $elValue);
                } elseif (&#039;path&#039; == $elName || &#039;domain&#039; == $elName) {
                    $cookie[$elName] = urldecode($elValue);
                } else {
                    $cookie[$elName] = $elValue;
                }
            }
        }
        $this-&gt;cookies[] = $cookie;
    }

   /**
    * Appends a string to the response body
    * @param    string
    */
    public function appendBody($bodyChunk)
    {
        $this-&gt;body .= $bodyChunk;
    }

   /**
    * Returns the effective URL of the response
    *
    * This may be different from the request URL if redirects were followed.
    *
    * @return string
    * @link   http://pear.php.net/bugs/bug.php?id=18412
    */
    public function getEffectiveUrl()
    {
        return $this-&gt;effectiveUrl;
    }

   /**
    * Returns the status code
    * @return   integer
    */
    public function getStatus()
    {
        return $this-&gt;code;
    }

   /**
    * Returns the reason phrase
    * @return   string
    */
    public function getReasonPhrase()
    {
        return $this-&gt;reasonPhrase;
    }

   /**
    * Whether response is a redirect that can be automatically handled by HTTP_Request2
    * @return   bool
    */
    public function isRedirect()
    {
        return in_array($this-&gt;code, array(300, 301, 302, 303, 307))
               &amp;&amp; isset($this-&gt;headers[&#039;location&#039;]);
    }

   /**
    * Returns either the named header or all response headers
    *
    * @param    string          Name of header to return
    * @return   string|array    Value of $headerName header (null if header is
    *                           not present), array of all response headers if
    *                           $headerName is null
    */
    public function getHeader($headerName = null)
    {
        if (null === $headerName) {
            return $this-&gt;headers;
        } else {
            $headerName = strtolower($headerName);
            return isset($this-&gt;headers[$headerName])? $this-&gt;headers[$headerName]: null;
        }
    }

   /**
    * Returns cookies set in response
    *
    * @return   array
    */
    public function getCookies()
    {
        return $this-&gt;cookies;
    }

   /**
    * Returns the body of the response
    *
    * @return   string
    * @throws   HTTP_Request2_Exception if body cannot be decoded
    */
    public function getBody()
    {
        if (0 == strlen($this-&gt;body) || !$this-&gt;bodyEncoded ||
            !in_array(strtolower($this-&gt;getHeader(&#039;content-encoding&#039;)), array(&#039;gzip&#039;, &#039;deflate&#039;))
        ) {
            return $this-&gt;body;

        } else {
            if (extension_loaded(&#039;mbstring&#039;) &amp;&amp; (2 &amp; ini_get(&#039;mbstring.func_overload&#039;))) {
                $oldEncoding = mb_internal_encoding();
                mb_internal_encoding(&#039;iso-8859-1&#039;);
            }

            try {
                switch (strtolower($this-&gt;getHeader(&#039;content-encoding&#039;))) {
                    case &#039;gzip&#039;:
                        $decoded = self::decodeGzip($this-&gt;body);
                        break;
                    case &#039;deflate&#039;:
                        $decoded = self::decodeDeflate($this-&gt;body);
                }
            } catch (Exception $e) {
            }

            if (!empty($oldEncoding)) {
                mb_internal_encoding($oldEncoding);
            }
            if (!empty($e)) {
                throw $e;
            }
            return $decoded;
        }
    }

   /**
    * Get the HTTP version of the response
    *
    * @return   string
    */
    public function getVersion()
    {
        return $this-&gt;version;
    }

   /**
    * Decodes the message-body encoded by gzip
    *
    * The real decoding work is done by gzinflate() built-in function, this
    * method only parses the header and checks data for compliance with
    * RFC 1952
    *
    * @param    string  gzip-encoded data
    * @return   string  decoded data
    * @throws   HTTP_Request2_LogicException
    * @throws   HTTP_Request2_MessageException
    * @link     http://tools.ietf.org/html/rfc1952
    */
    public static function decodeGzip($data)
    {
        $length = strlen($data);
        // If it doesn&#039;t look like gzip-encoded data, don&#039;t bother
        if (18 &gt; $length || strcmp(substr($data, 0, 2), &quot;\x1f\x8b&quot;)) {
            return $data;
        }
        if (!function_exists(&#039;gzinflate&#039;)) {
            throw new HTTP_Request2_LogicException(
                &#039;Unable to decode body: gzip extension not available&#039;,
                HTTP_Request2_Exception::MISCONFIGURATION
            );
        }
        $method = ord(substr($data, 2, 1));
        if (8 != $method) {
            throw new HTTP_Request2_MessageException(
                &#039;Error parsing gzip header: unknown compression method&#039;,
                HTTP_Request2_Exception::DECODE_ERROR
            );
        }
        $flags = ord(substr($data, 3, 1));
        if ($flags &amp; 224) {
            throw new HTTP_Request2_MessageException(
                &#039;Error parsing gzip header: reserved bits are set&#039;,
                HTTP_Request2_Exception::DECODE_ERROR
            );
        }

        // header is 10 bytes minimum. may be longer, though.
        $headerLength = 10;
        // extra fields, need to skip &#039;em
        if ($flags &amp; 4) {
            if ($length - $headerLength - 2 &lt; 8) {
                throw new HTTP_Request2_MessageException(
                    &#039;Error parsing gzip header: data too short&#039;,
                    HTTP_Request2_Exception::DECODE_ERROR
                );
            }
            $extraLength = unpack(&#039;v&#039;, substr($data, 10, 2));
            if ($length - $headerLength - 2 - $extraLength[1] &lt; 8) {
                throw new HTTP_Request2_MessageException(
                    &#039;Error parsing gzip header: data too short&#039;,
                    HTTP_Request2_Exception::DECODE_ERROR
                );
            }
            $headerLength += $extraLength[1] + 2;
        }
        // file name, need to skip that
        if ($flags &amp; 8) {
            if ($length - $headerLength - 1 &lt; 8) {
                throw new HTTP_Request2_MessageException(
                    &#039;Error parsing gzip header: data too short&#039;,
                    HTTP_Request2_Exception::DECODE_ERROR
                );
            }
            $filenameLength = strpos(substr($data, $headerLength), chr(0));
            if (false === $filenameLength || $length - $headerLength - $filenameLength - 1 &lt; 8) {
                throw new HTTP_Request2_MessageException(
                    &#039;Error parsing gzip header: data too short&#039;,
                    HTTP_Request2_Exception::DECODE_ERROR
                );
            }
            $headerLength += $filenameLength + 1;
        }
        // comment, need to skip that also
        if ($flags &amp; 16) {
            if ($length - $headerLength - 1 &lt; 8) {
                throw new HTTP_Request2_MessageException(
                    &#039;Error parsing gzip header: data too short&#039;,
                    HTTP_Request2_Exception::DECODE_ERROR
                );
            }
            $commentLength = strpos(substr($data, $headerLength), chr(0));
            if (false === $commentLength || $length - $headerLength - $commentLength - 1 &lt; 8) {
                throw new HTTP_Request2_MessageException(
                    &#039;Error parsing gzip header: data too short&#039;,
                    HTTP_Request2_Exception::DECODE_ERROR
                );
            }
            $headerLength += $commentLength + 1;
        }
        // have a CRC for header. let&#039;s check
        if ($flags &amp; 2) {
            if ($length - $headerLength - 2 &lt; 8) {
                throw new HTTP_Request2_MessageException(
                    &#039;Error parsing gzip header: data too short&#039;,
                    HTTP_Request2_Exception::DECODE_ERROR
                );
            }
            $crcReal   = 0xffff &amp; crc32(substr($data, 0, $headerLength));
            $crcStored = unpack(&#039;v&#039;, substr($data, $headerLength, 2));
            if ($crcReal != $crcStored[1]) {
                throw new HTTP_Request2_MessageException(
                    &#039;Header CRC check failed&#039;,
                    HTTP_Request2_Exception::DECODE_ERROR
                );
            }
            $headerLength += 2;
        }
        // unpacked data CRC and size at the end of encoded data
        $tmp = unpack(&#039;V2&#039;, substr($data, -8));
        $dataCrc  = $tmp[1];
        $dataSize = $tmp[2];

        // finally, call the gzinflate() function
        // don&#039;t pass $dataSize to gzinflate, see bugs #13135, #14370
        $unpacked = gzinflate(substr($data, $headerLength, -8));
        if (false === $unpacked) {
            throw new HTTP_Request2_MessageException(
                &#039;gzinflate() call failed&#039;,
                HTTP_Request2_Exception::DECODE_ERROR
            );
        } elseif ($dataSize != strlen($unpacked)) {
            throw new HTTP_Request2_MessageException(
                &#039;Data size check failed&#039;,
                HTTP_Request2_Exception::DECODE_ERROR
            );
        } elseif ((0xffffffff &amp; $dataCrc) != (0xffffffff &amp; crc32($unpacked))) {
            throw new HTTP_Request2_Exception(
                &#039;Data CRC check failed&#039;,
                HTTP_Request2_Exception::DECODE_ERROR
            );
        }
        return $unpacked;
    }

   /**
    * Decodes the message-body encoded by deflate
    *
    * @param    string  deflate-encoded data
    * @return   string  decoded data
    * @throws   HTTP_Request2_LogicException
    */
    public static function decodeDeflate($data)
    {
        if (!function_exists(&#039;gzuncompress&#039;)) {
            throw new HTTP_Request2_LogicException(
                &#039;Unable to decode body: gzip extension not available&#039;,
                HTTP_Request2_Exception::MISCONFIGURATION
            );
        }
        // RFC 2616 defines &#039;deflate&#039; encoding as zlib format from RFC 1950,
        // while many applications send raw deflate stream from RFC 1951.
        // We should check for presence of zlib header and use gzuncompress() or
        // gzinflate() as needed. See bug #15305
        $header = unpack(&#039;n&#039;, substr($data, 0, 2));
        return (0 == $header[1] % 31)? gzuncompress($data): gzinflate($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'>⬅ Back to Directory</a>