PageRenderTime 872ms CodeModel.GetById 181ms app.highlight 354ms RepoModel.GetById 123ms app.codeStats 1ms

/lib/PEAR/HTTP/Request.php

https://bitbucket.org/andrewjleavitt/magestudy
PHP | 1521 lines | 736 code | 159 blank | 626 comment | 192 complexity | e409fdbe1518e11e16943f5185eccc2b MD5 | raw file

Large files files are truncated, but you can click here to view the full file

   1<?php
   2/**
   3 * Class for performing HTTP requests
   4 *
   5 * PHP versions 4 and 5
   6 *
   7 * LICENSE:
   8 *
   9 * Copyright (c) 2002-2007, Richard Heyes
  10 * All rights reserved.
  11 *
  12 * Redistribution and use in source and binary forms, with or without
  13 * modification, are permitted provided that the following conditions
  14 * are met:
  15 *
  16 * o Redistributions of source code must retain the above copyright
  17 *   notice, this list of conditions and the following disclaimer.
  18 * o Redistributions in binary form must reproduce the above copyright
  19 *   notice, this list of conditions and the following disclaimer in the
  20 *   documentation and/or other materials provided with the distribution.
  21 * o The names of the authors may not be used to endorse or promote
  22 *   products derived from this software without specific prior written
  23 *   permission.
  24 *
  25 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  26 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  27 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  28 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  29 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  30 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  31 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  32 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  33 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  34 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  35 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  36 *
  37 * @category    HTTP
  38 * @package     HTTP_Request
  39 * @author      Richard Heyes <richard@phpguru.org>
  40 * @author      Alexey Borzov <avb@php.net>
  41 * @copyright   2002-2007 Richard Heyes
  42 * @license     http://opensource.org/licenses/bsd-license.php New BSD License
  43 * @version     CVS: $Id: Request.php,v 1.63 2008/10/11 11:07:10 avb Exp $
  44 * @link        http://pear.php.net/package/HTTP_Request/
  45 */
  46
  47/**
  48 * PEAR and PEAR_Error classes (for error handling)
  49 */
  50require_once 'PEAR.php';
  51/**
  52 * Socket class
  53 */
  54require_once 'Net/Socket.php';
  55/**
  56 * URL handling class
  57 */
  58require_once 'Net/URL.php';
  59
  60/**#@+
  61 * Constants for HTTP request methods
  62 */
  63define('HTTP_REQUEST_METHOD_GET',     'GET',     true);
  64define('HTTP_REQUEST_METHOD_HEAD',    'HEAD',    true);
  65define('HTTP_REQUEST_METHOD_POST',    'POST',    true);
  66define('HTTP_REQUEST_METHOD_PUT',     'PUT',     true);
  67define('HTTP_REQUEST_METHOD_DELETE',  'DELETE',  true);
  68define('HTTP_REQUEST_METHOD_OPTIONS', 'OPTIONS', true);
  69define('HTTP_REQUEST_METHOD_TRACE',   'TRACE',   true);
  70/**#@-*/
  71
  72/**#@+
  73 * Constants for HTTP request error codes
  74 */
  75define('HTTP_REQUEST_ERROR_FILE',             1);
  76define('HTTP_REQUEST_ERROR_URL',              2);
  77define('HTTP_REQUEST_ERROR_PROXY',            4);
  78define('HTTP_REQUEST_ERROR_REDIRECTS',        8);
  79define('HTTP_REQUEST_ERROR_RESPONSE',        16);
  80define('HTTP_REQUEST_ERROR_GZIP_METHOD',     32);
  81define('HTTP_REQUEST_ERROR_GZIP_READ',       64);
  82define('HTTP_REQUEST_ERROR_GZIP_DATA',      128);
  83define('HTTP_REQUEST_ERROR_GZIP_CRC',       256);
  84/**#@-*/
  85
  86/**#@+
  87 * Constants for HTTP protocol versions
  88 */
  89define('HTTP_REQUEST_HTTP_VER_1_0', '1.0', true);
  90define('HTTP_REQUEST_HTTP_VER_1_1', '1.1', true);
  91/**#@-*/
  92
  93if (extension_loaded('mbstring') && (2 & ini_get('mbstring.func_overload'))) {
  94   /**
  95    * Whether string functions are overloaded by their mbstring equivalents
  96    */
  97    define('HTTP_REQUEST_MBSTRING', true);
  98} else {
  99   /**
 100    * @ignore
 101    */
 102    define('HTTP_REQUEST_MBSTRING', false);
 103}
 104
 105/**
 106 * Class for performing HTTP requests
 107 *
 108 * Simple example (fetches yahoo.com and displays it):
 109 * <code>
 110 * $a = &new HTTP_Request('http://www.yahoo.com/');
 111 * $a->sendRequest();
 112 * echo $a->getResponseBody();
 113 * </code>
 114 *
 115 * @category    HTTP
 116 * @package     HTTP_Request
 117 * @author      Richard Heyes <richard@phpguru.org>
 118 * @author      Alexey Borzov <avb@php.net>
 119 * @version     Release: 1.4.4
 120 */
 121class HTTP_Request
 122{
 123   /**#@+
 124    * @access private
 125    */
 126    /**
 127    * Instance of Net_URL
 128    * @var Net_URL
 129    */
 130    var $_url;
 131
 132    /**
 133    * Type of request
 134    * @var string
 135    */
 136    var $_method;
 137
 138    /**
 139    * HTTP Version
 140    * @var string
 141    */
 142    var $_http;
 143
 144    /**
 145    * Request headers
 146    * @var array
 147    */
 148    var $_requestHeaders;
 149
 150    /**
 151    * Basic Auth Username
 152    * @var string
 153    */
 154    var $_user;
 155
 156    /**
 157    * Basic Auth Password
 158    * @var string
 159    */
 160    var $_pass;
 161
 162    /**
 163    * Socket object
 164    * @var Net_Socket
 165    */
 166    var $_sock;
 167
 168    /**
 169    * Proxy server
 170    * @var string
 171    */
 172    var $_proxy_host;
 173
 174    /**
 175    * Proxy port
 176    * @var integer
 177    */
 178    var $_proxy_port;
 179
 180    /**
 181    * Proxy username
 182    * @var string
 183    */
 184    var $_proxy_user;
 185
 186    /**
 187    * Proxy password
 188    * @var string
 189    */
 190    var $_proxy_pass;
 191
 192    /**
 193    * Post data
 194    * @var array
 195    */
 196    var $_postData;
 197
 198   /**
 199    * Request body
 200    * @var string
 201    */
 202    var $_body;
 203
 204   /**
 205    * A list of methods that MUST NOT have a request body, per RFC 2616
 206    * @var array
 207    */
 208    var $_bodyDisallowed = array('TRACE');
 209
 210   /**
 211    * Methods having defined semantics for request body
 212    *
 213    * Content-Length header (indicating that the body follows, section 4.3 of
 214    * RFC 2616) will be sent for these methods even if no body was added
 215    *
 216    * @var array
 217    */
 218    var $_bodyRequired = array('POST', 'PUT');
 219
 220   /**
 221    * Files to post
 222    * @var array
 223    */
 224    var $_postFiles = array();
 225
 226    /**
 227    * Connection timeout.
 228    * @var float
 229    */
 230    var $_timeout;
 231
 232    /**
 233    * HTTP_Response object
 234    * @var HTTP_Response
 235    */
 236    var $_response;
 237
 238    /**
 239    * Whether to allow redirects
 240    * @var boolean
 241    */
 242    var $_allowRedirects;
 243
 244    /**
 245    * Maximum redirects allowed
 246    * @var integer
 247    */
 248    var $_maxRedirects;
 249
 250    /**
 251    * Current number of redirects
 252    * @var integer
 253    */
 254    var $_redirects;
 255
 256   /**
 257    * Whether to append brackets [] to array variables
 258    * @var bool
 259    */
 260    var $_useBrackets = true;
 261
 262   /**
 263    * Attached listeners
 264    * @var array
 265    */
 266    var $_listeners = array();
 267
 268   /**
 269    * Whether to save response body in response object property
 270    * @var bool
 271    */
 272    var $_saveBody = true;
 273
 274   /**
 275    * Timeout for reading from socket (array(seconds, microseconds))
 276    * @var array
 277    */
 278    var $_readTimeout = null;
 279
 280   /**
 281    * Options to pass to Net_Socket::connect. See stream_context_create
 282    * @var array
 283    */
 284    var $_socketOptions = null;
 285   /**#@-*/
 286
 287    /**
 288    * Constructor
 289    *
 290    * Sets up the object
 291    * @param    string  The url to fetch/access
 292    * @param    array   Associative array of parameters which can have the following keys:
 293    * <ul>
 294    *   <li>method         - Method to use, GET, POST etc (string)</li>
 295    *   <li>http           - HTTP Version to use, 1.0 or 1.1 (string)</li>
 296    *   <li>user           - Basic Auth username (string)</li>
 297    *   <li>pass           - Basic Auth password (string)</li>
 298    *   <li>proxy_host     - Proxy server host (string)</li>
 299    *   <li>proxy_port     - Proxy server port (integer)</li>
 300    *   <li>proxy_user     - Proxy auth username (string)</li>
 301    *   <li>proxy_pass     - Proxy auth password (string)</li>
 302    *   <li>timeout        - Connection timeout in seconds (float)</li>
 303    *   <li>allowRedirects - Whether to follow redirects or not (bool)</li>
 304    *   <li>maxRedirects   - Max number of redirects to follow (integer)</li>
 305    *   <li>useBrackets    - Whether to append [] to array variable names (bool)</li>
 306    *   <li>saveBody       - Whether to save response body in response object property (bool)</li>
 307    *   <li>readTimeout    - Timeout for reading / writing data over the socket (array (seconds, microseconds))</li>
 308    *   <li>socketOptions  - Options to pass to Net_Socket object (array)</li>
 309    * </ul>
 310    * @access public
 311    */
 312    function HTTP_Request($url = '', $params = array())
 313    {
 314        $this->_method         =  HTTP_REQUEST_METHOD_GET;
 315        $this->_http           =  HTTP_REQUEST_HTTP_VER_1_1;
 316        $this->_requestHeaders = array();
 317        $this->_postData       = array();
 318        $this->_body           = null;
 319
 320        $this->_user = null;
 321        $this->_pass = null;
 322
 323        $this->_proxy_host = null;
 324        $this->_proxy_port = null;
 325        $this->_proxy_user = null;
 326        $this->_proxy_pass = null;
 327
 328        $this->_allowRedirects = false;
 329        $this->_maxRedirects   = 3;
 330        $this->_redirects      = 0;
 331
 332        $this->_timeout  = null;
 333        $this->_response = null;
 334
 335        foreach ($params as $key => $value) {
 336            $this->{'_' . $key} = $value;
 337        }
 338
 339        if (!empty($url)) {
 340            $this->setURL($url);
 341        }
 342
 343        // Default useragent
 344        $this->addHeader('User-Agent', 'PEAR HTTP_Request class ( http://pear.php.net/ )');
 345
 346        // We don't do keep-alives by default
 347        $this->addHeader('Connection', 'close');
 348
 349        // Basic authentication
 350        if (!empty($this->_user)) {
 351            $this->addHeader('Authorization', 'Basic ' . base64_encode($this->_user . ':' . $this->_pass));
 352        }
 353
 354        // Proxy authentication (see bug #5913)
 355        if (!empty($this->_proxy_user)) {
 356            $this->addHeader('Proxy-Authorization', 'Basic ' . base64_encode($this->_proxy_user . ':' . $this->_proxy_pass));
 357        }
 358
 359        // Use gzip encoding if possible
 360        if (HTTP_REQUEST_HTTP_VER_1_1 == $this->_http && extension_loaded('zlib')) {
 361            $this->addHeader('Accept-Encoding', 'gzip');
 362        }
 363    }
 364
 365    /**
 366    * Generates a Host header for HTTP/1.1 requests
 367    *
 368    * @access private
 369    * @return string
 370    */
 371    function _generateHostHeader()
 372    {
 373        if ($this->_url->port != 80 AND strcasecmp($this->_url->protocol, 'http') == 0) {
 374            $host = $this->_url->host . ':' . $this->_url->port;
 375
 376        } elseif ($this->_url->port != 443 AND strcasecmp($this->_url->protocol, 'https') == 0) {
 377            $host = $this->_url->host . ':' . $this->_url->port;
 378
 379        } elseif ($this->_url->port == 443 AND strcasecmp($this->_url->protocol, 'https') == 0 AND strpos($this->_url->url, ':443') !== false) {
 380            $host = $this->_url->host . ':' . $this->_url->port;
 381
 382        } else {
 383            $host = $this->_url->host;
 384        }
 385
 386        return $host;
 387    }
 388
 389    /**
 390    * Resets the object to its initial state (DEPRECATED).
 391    * Takes the same parameters as the constructor.
 392    *
 393    * @param  string $url    The url to be requested
 394    * @param  array  $params Associative array of parameters
 395    *                        (see constructor for details)
 396    * @access public
 397    * @deprecated deprecated since 1.2, call the constructor if this is necessary
 398    */
 399    function reset($url, $params = array())
 400    {
 401        $this->HTTP_Request($url, $params);
 402    }
 403
 404    /**
 405    * Sets the URL to be requested
 406    *
 407    * @param  string The url to be requested
 408    * @access public
 409    */
 410    function setURL($url)
 411    {
 412        $this->_url = new Net_URL($url, $this->_useBrackets);
 413
 414        if (!empty($this->_url->user) || !empty($this->_url->pass)) {
 415            $this->setBasicAuth($this->_url->user, $this->_url->pass);
 416        }
 417
 418        if (HTTP_REQUEST_HTTP_VER_1_1 == $this->_http) {
 419            $this->addHeader('Host', $this->_generateHostHeader());
 420        }
 421
 422        // set '/' instead of empty path rather than check later (see bug #8662)
 423        if (empty($this->_url->path)) {
 424            $this->_url->path = '/';
 425        }
 426    }
 427
 428   /**
 429    * Returns the current request URL
 430    *
 431    * @return   string  Current request URL
 432    * @access   public
 433    */
 434    function getUrl()
 435    {
 436        return empty($this->_url)? '': $this->_url->getUrl();
 437    }
 438
 439    /**
 440    * Sets a proxy to be used
 441    *
 442    * @param string     Proxy host
 443    * @param int        Proxy port
 444    * @param string     Proxy username
 445    * @param string     Proxy password
 446    * @access public
 447    */
 448    function setProxy($host, $port = 8080, $user = null, $pass = null)
 449    {
 450        $this->_proxy_host = $host;
 451        $this->_proxy_port = $port;
 452        $this->_proxy_user = $user;
 453        $this->_proxy_pass = $pass;
 454
 455        if (!empty($user)) {
 456            $this->addHeader('Proxy-Authorization', 'Basic ' . base64_encode($user . ':' . $pass));
 457        }
 458    }
 459
 460    /**
 461    * Sets basic authentication parameters
 462    *
 463    * @param string     Username
 464    * @param string     Password
 465    */
 466    function setBasicAuth($user, $pass)
 467    {
 468        $this->_user = $user;
 469        $this->_pass = $pass;
 470
 471        $this->addHeader('Authorization', 'Basic ' . base64_encode($user . ':' . $pass));
 472    }
 473
 474    /**
 475    * Sets the method to be used, GET, POST etc.
 476    *
 477    * @param string     Method to use. Use the defined constants for this
 478    * @access public
 479    */
 480    function setMethod($method)
 481    {
 482        $this->_method = $method;
 483    }
 484
 485    /**
 486    * Sets the HTTP version to use, 1.0 or 1.1
 487    *
 488    * @param string     Version to use. Use the defined constants for this
 489    * @access public
 490    */
 491    function setHttpVer($http)
 492    {
 493        $this->_http = $http;
 494    }
 495
 496    /**
 497    * Adds a request header
 498    *
 499    * @param string     Header name
 500    * @param string     Header value
 501    * @access public
 502    */
 503    function addHeader($name, $value)
 504    {
 505        $this->_requestHeaders[strtolower($name)] = $value;
 506    }
 507
 508    /**
 509    * Removes a request header
 510    *
 511    * @param string     Header name to remove
 512    * @access public
 513    */
 514    function removeHeader($name)
 515    {
 516        if (isset($this->_requestHeaders[strtolower($name)])) {
 517            unset($this->_requestHeaders[strtolower($name)]);
 518        }
 519    }
 520
 521    /**
 522    * Adds a querystring parameter
 523    *
 524    * @param string     Querystring parameter name
 525    * @param string     Querystring parameter value
 526    * @param bool       Whether the value is already urlencoded or not, default = not
 527    * @access public
 528    */
 529    function addQueryString($name, $value, $preencoded = false)
 530    {
 531        $this->_url->addQueryString($name, $value, $preencoded);
 532    }
 533
 534    /**
 535    * Sets the querystring to literally what you supply
 536    *
 537    * @param string     The querystring data. Should be of the format foo=bar&x=y etc
 538    * @param bool       Whether data is already urlencoded or not, default = already encoded
 539    * @access public
 540    */
 541    function addRawQueryString($querystring, $preencoded = true)
 542    {
 543        $this->_url->addRawQueryString($querystring, $preencoded);
 544    }
 545
 546    /**
 547    * Adds postdata items
 548    *
 549    * @param string     Post data name
 550    * @param string     Post data value
 551    * @param bool       Whether data is already urlencoded or not, default = not
 552    * @access public
 553    */
 554    function addPostData($name, $value, $preencoded = false)
 555    {
 556        if ($preencoded) {
 557            $this->_postData[$name] = $value;
 558        } else {
 559            $this->_postData[$name] = $this->_arrayMapRecursive('urlencode', $value);
 560        }
 561    }
 562
 563   /**
 564    * Recursively applies the callback function to the value
 565    *
 566    * @param    mixed   Callback function
 567    * @param    mixed   Value to process
 568    * @access   private
 569    * @return   mixed   Processed value
 570    */
 571    function _arrayMapRecursive($callback, $value)
 572    {
 573        if (!is_array($value)) {
 574            return call_user_func($callback, $value);
 575        } else {
 576            $map = array();
 577            foreach ($value as $k => $v) {
 578                $map[$k] = $this->_arrayMapRecursive($callback, $v);
 579            }
 580            return $map;
 581        }
 582    }
 583
 584   /**
 585    * Adds a file to form-based file upload
 586    *
 587    * Used to emulate file upload via a HTML form. The method also sets
 588    * Content-Type of HTTP request to 'multipart/form-data'.
 589    *
 590    * If you just want to send the contents of a file as the body of HTTP
 591    * request you should use setBody() method.
 592    *
 593    * @access public
 594    * @param  string    name of file-upload field
 595    * @param  mixed     file name(s)
 596    * @param  mixed     content-type(s) of file(s) being uploaded
 597    * @return bool      true on success
 598    * @throws PEAR_Error
 599    */
 600    function addFile($inputName, $fileName, $contentType = 'application/octet-stream')
 601    {
 602        if (!is_array($fileName) && !is_readable($fileName)) {
 603            return PEAR::raiseError("File '{$fileName}' is not readable", HTTP_REQUEST_ERROR_FILE);
 604        } elseif (is_array($fileName)) {
 605            foreach ($fileName as $name) {
 606                if (!is_readable($name)) {
 607                    return PEAR::raiseError("File '{$name}' is not readable", HTTP_REQUEST_ERROR_FILE);
 608                }
 609            }
 610        }
 611        $this->addHeader('Content-Type', 'multipart/form-data');
 612        $this->_postFiles[$inputName] = array(
 613            'name' => $fileName,
 614            'type' => $contentType
 615        );
 616        return true;
 617    }
 618
 619    /**
 620    * Adds raw postdata (DEPRECATED)
 621    *
 622    * @param string     The data
 623    * @param bool       Whether data is preencoded or not, default = already encoded
 624    * @access public
 625    * @deprecated       deprecated since 1.3.0, method setBody() should be used instead
 626    */
 627    function addRawPostData($postdata, $preencoded = true)
 628    {
 629        $this->_body = $preencoded ? $postdata : urlencode($postdata);
 630    }
 631
 632   /**
 633    * Sets the request body (for POST, PUT and similar requests)
 634    *
 635    * @param    string  Request body
 636    * @access   public
 637    */
 638    function setBody($body)
 639    {
 640        $this->_body = $body;
 641    }
 642
 643    /**
 644    * Clears any postdata that has been added (DEPRECATED).
 645    *
 646    * Useful for multiple request scenarios.
 647    *
 648    * @access public
 649    * @deprecated deprecated since 1.2
 650    */
 651    function clearPostData()
 652    {
 653        $this->_postData = null;
 654    }
 655
 656    /**
 657    * Appends a cookie to "Cookie:" header
 658    *
 659    * @param string $name cookie name
 660    * @param string $value cookie value
 661    * @access public
 662    */
 663    function addCookie($name, $value)
 664    {
 665        $cookies = isset($this->_requestHeaders['cookie']) ? $this->_requestHeaders['cookie']. '; ' : '';
 666        $this->addHeader('Cookie', $cookies . $name . '=' . $value);
 667    }
 668
 669    /**
 670    * Clears any cookies that have been added (DEPRECATED).
 671    *
 672    * Useful for multiple request scenarios
 673    *
 674    * @access public
 675    * @deprecated deprecated since 1.2
 676    */
 677    function clearCookies()
 678    {
 679        $this->removeHeader('Cookie');
 680    }
 681
 682    /**
 683    * Sends the request
 684    *
 685    * @access public
 686    * @param  bool   Whether to store response body in Response object property,
 687    *                set this to false if downloading a LARGE file and using a Listener
 688    * @return mixed  PEAR error on error, true otherwise
 689    */
 690    function sendRequest($saveBody = true)
 691    {
 692        if (!$this->_url instanceof Net_Url) {
 693            return PEAR::raiseError('No URL given', HTTP_REQUEST_ERROR_URL);
 694        }
 695
 696        $host = isset($this->_proxy_host) ? $this->_proxy_host : $this->_url->host;
 697        $port = isset($this->_proxy_port) ? $this->_proxy_port : $this->_url->port;
 698
 699        if (strcasecmp($this->_url->protocol, 'https') == 0) {
 700            // Bug #14127, don't try connecting to HTTPS sites without OpenSSL
 701            if (version_compare(PHP_VERSION, '4.3.0', '<') || !extension_loaded('openssl')) {
 702                return PEAR::raiseError('Need PHP 4.3.0 or later with OpenSSL support for https:// requests',
 703                                        HTTP_REQUEST_ERROR_URL);
 704            } elseif (isset($this->_proxy_host)) {
 705                return PEAR::raiseError('HTTPS proxies are not supported', HTTP_REQUEST_ERROR_PROXY);
 706            }
 707            $host = 'ssl://' . $host;
 708        }
 709
 710        // magic quotes may fuck up file uploads and chunked response processing
 711        $magicQuotes = ini_get('magic_quotes_runtime');
 712        ini_set('magic_quotes_runtime', false);
 713
 714        // RFC 2068, section 19.7.1: A client MUST NOT send the Keep-Alive
 715        // connection token to a proxy server...
 716        if (isset($this->_proxy_host) && !empty($this->_requestHeaders['connection']) &&
 717            'Keep-Alive' == $this->_requestHeaders['connection'])
 718        {
 719            $this->removeHeader('connection');
 720        }
 721
 722        $keepAlive = (HTTP_REQUEST_HTTP_VER_1_1 == $this->_http && empty($this->_requestHeaders['connection'])) ||
 723                     (!empty($this->_requestHeaders['connection']) && 'Keep-Alive' == $this->_requestHeaders['connection']);
 724        $sockets   = &PEAR::getStaticProperty('HTTP_Request', 'sockets');
 725        $sockKey   = $host . ':' . $port;
 726        unset($this->_sock);
 727
 728        // There is a connected socket in the "static" property?
 729        if ($keepAlive && !empty($sockets[$sockKey]) &&
 730            !empty($sockets[$sockKey]->fp))
 731        {
 732            $this->_sock =& $sockets[$sockKey];
 733            $err = null;
 734        } else {
 735            $this->_notify('connect');
 736            $this->_sock = new Net_Socket();
 737            $err = $this->_sock->connect($host, $port, null, $this->_timeout, $this->_socketOptions);
 738        }
 739        PEAR::isError($err) or $err = $this->_sock->write($this->_buildRequest());
 740
 741        if (!PEAR::isError($err)) {
 742            if (!empty($this->_readTimeout)) {
 743                $this->_sock->setTimeout($this->_readTimeout[0], $this->_readTimeout[1]);
 744            }
 745
 746            $this->_notify('sentRequest');
 747
 748            // Read the response
 749            $this->_response = new HTTP_Response($this->_sock, $this->_listeners);
 750            $err = $this->_response->process(
 751                $this->_saveBody && $saveBody,
 752                HTTP_REQUEST_METHOD_HEAD != $this->_method
 753            );
 754
 755            if ($keepAlive) {
 756                $keepAlive = (isset($this->_response->_headers['content-length'])
 757                              || (isset($this->_response->_headers['transfer-encoding'])
 758                                  && strtolower($this->_response->_headers['transfer-encoding']) == 'chunked'));
 759                if ($keepAlive) {
 760                    if (isset($this->_response->_headers['connection'])) {
 761                        $keepAlive = strtolower($this->_response->_headers['connection']) == 'keep-alive';
 762                    } else {
 763                        $keepAlive = 'HTTP/'.HTTP_REQUEST_HTTP_VER_1_1 == $this->_response->_protocol;
 764                    }
 765                }
 766            }
 767        }
 768
 769        ini_set('magic_quotes_runtime', $magicQuotes);
 770
 771        if (PEAR::isError($err)) {
 772            return $err;
 773        }
 774
 775        if (!$keepAlive) {
 776            $this->disconnect();
 777        // Store the connected socket in "static" property
 778        } elseif (empty($sockets[$sockKey]) || empty($sockets[$sockKey]->fp)) {
 779            $sockets[$sockKey] =& $this->_sock;
 780        }
 781
 782        // Check for redirection
 783        if (    $this->_allowRedirects
 784            AND $this->_redirects <= $this->_maxRedirects
 785            AND $this->getResponseCode() > 300
 786            AND $this->getResponseCode() < 399
 787            AND !empty($this->_response->_headers['location'])) {
 788
 789
 790            $redirect = $this->_response->_headers['location'];
 791
 792            // Absolute URL
 793            if (preg_match('/^https?:\/\//i', $redirect)) {
 794                $this->_url = new Net_URL($redirect);
 795                $this->addHeader('Host', $this->_generateHostHeader());
 796            // Absolute path
 797            } elseif ($redirect{0} == '/') {
 798                $this->_url->path = $redirect;
 799
 800            // Relative path
 801            } elseif (substr($redirect, 0, 3) == '../' OR substr($redirect, 0, 2) == './') {
 802                if (substr($this->_url->path, -1) == '/') {
 803                    $redirect = $this->_url->path . $redirect;
 804                } else {
 805                    $redirect = dirname($this->_url->path) . '/' . $redirect;
 806                }
 807                $redirect = Net_URL::resolvePath($redirect);
 808                $this->_url->path = $redirect;
 809
 810            // Filename, no path
 811            } else {
 812                if (substr($this->_url->path, -1) == '/') {
 813                    $redirect = $this->_url->path . $redirect;
 814                } else {
 815                    $redirect = dirname($this->_url->path) . '/' . $redirect;
 816                }
 817                $this->_url->path = $redirect;
 818            }
 819
 820            $this->_redirects++;
 821            return $this->sendRequest($saveBody);
 822
 823        // Too many redirects
 824        } elseif ($this->_allowRedirects AND $this->_redirects > $this->_maxRedirects) {
 825            return PEAR::raiseError('Too many redirects', HTTP_REQUEST_ERROR_REDIRECTS);
 826        }
 827
 828        return true;
 829    }
 830
 831    /**
 832     * Disconnect the socket, if connected. Only useful if using Keep-Alive.
 833     *
 834     * @access public
 835     */
 836    function disconnect()
 837    {
 838        if (!empty($this->_sock) && !empty($this->_sock->fp)) {
 839            $this->_notify('disconnect');
 840            $this->_sock->disconnect();
 841        }
 842    }
 843
 844    /**
 845    * Returns the response code
 846    *
 847    * @access public
 848    * @return mixed     Response code, false if not set
 849    */
 850    function getResponseCode()
 851    {
 852        return isset($this->_response->_code) ? $this->_response->_code : false;
 853    }
 854
 855    /**
 856    * Returns the response reason phrase
 857    *
 858    * @access public
 859    * @return mixed     Response reason phrase, false if not set
 860    */
 861    function getResponseReason()
 862    {
 863        return isset($this->_response->_reason) ? $this->_response->_reason : false;
 864    }
 865
 866    /**
 867    * Returns either the named header or all if no name given
 868    *
 869    * @access public
 870    * @param string     The header name to return, do not set to get all headers
 871    * @return mixed     either the value of $headername (false if header is not present)
 872    *                   or an array of all headers
 873    */
 874    function getResponseHeader($headername = null)
 875    {
 876        if (!isset($headername)) {
 877            return isset($this->_response->_headers)? $this->_response->_headers: array();
 878        } else {
 879            $headername = strtolower($headername);
 880            return isset($this->_response->_headers[$headername]) ? $this->_response->_headers[$headername] : false;
 881        }
 882    }
 883
 884    /**
 885    * Returns the body of the response
 886    *
 887    * @access public
 888    * @return mixed     response body, false if not set
 889    */
 890    function getResponseBody()
 891    {
 892        return isset($this->_response->_body) ? $this->_response->_body : false;
 893    }
 894
 895    /**
 896    * Returns cookies set in response
 897    *
 898    * @access public
 899    * @return mixed     array of response cookies, false if none are present
 900    */
 901    function getResponseCookies()
 902    {
 903        return isset($this->_response->_cookies) ? $this->_response->_cookies : false;
 904    }
 905
 906    /**
 907    * Builds the request string
 908    *
 909    * @access private
 910    * @return string The request string
 911    */
 912    function _buildRequest()
 913    {
 914        $separator = ini_get('arg_separator.output');
 915        ini_set('arg_separator.output', '&');
 916        $querystring = ($querystring = $this->_url->getQueryString()) ? '?' . $querystring : '';
 917        ini_set('arg_separator.output', $separator);
 918
 919        $host = isset($this->_proxy_host) ? $this->_url->protocol . '://' . $this->_url->host : '';
 920        $port = (isset($this->_proxy_host) AND $this->_url->port != 80) ? ':' . $this->_url->port : '';
 921        $path = $this->_url->path . $querystring;
 922        $url  = $host . $port . $path;
 923
 924        if (!strlen($url)) {
 925            $url = '/';
 926        }
 927
 928        $request = $this->_method . ' ' . $url . ' HTTP/' . $this->_http . "\r\n";
 929
 930        if (in_array($this->_method, $this->_bodyDisallowed) ||
 931            (0 == strlen($this->_body) && (HTTP_REQUEST_METHOD_POST != $this->_method ||
 932             (empty($this->_postData) && empty($this->_postFiles)))))
 933        {
 934            $this->removeHeader('Content-Type');
 935        } else {
 936            if (empty($this->_requestHeaders['content-type'])) {
 937                // Add default content-type
 938                $this->addHeader('Content-Type', 'application/x-www-form-urlencoded');
 939            } elseif ('multipart/form-data' == $this->_requestHeaders['content-type']) {
 940                $boundary = 'HTTP_Request_' . md5(uniqid('request') . microtime());
 941                $this->addHeader('Content-Type', 'multipart/form-data; boundary=' . $boundary);
 942            }
 943        }
 944
 945        // Request Headers
 946        if (!empty($this->_requestHeaders)) {
 947            foreach ($this->_requestHeaders as $name => $value) {
 948                $canonicalName = implode('-', array_map('ucfirst', explode('-', $name)));
 949                $request      .= $canonicalName . ': ' . $value . "\r\n";
 950            }
 951        }
 952
 953        // Method does not allow a body, simply add a final CRLF
 954        if (in_array($this->_method, $this->_bodyDisallowed)) {
 955
 956            $request .= "\r\n";
 957
 958        // Post data if it's an array
 959        } elseif (HTTP_REQUEST_METHOD_POST == $this->_method &&
 960                  (!empty($this->_postData) || !empty($this->_postFiles))) {
 961
 962            // "normal" POST request
 963            if (!isset($boundary)) {
 964                $postdata = implode('&', array_map(
 965                    create_function('$a', 'return $a[0] . \'=\' . $a[1];'),
 966                    $this->_flattenArray('', $this->_postData)
 967                ));
 968
 969            // multipart request, probably with file uploads
 970            } else {
 971                $postdata = '';
 972                if (!empty($this->_postData)) {
 973                    $flatData = $this->_flattenArray('', $this->_postData);
 974                    foreach ($flatData as $item) {
 975                        $postdata .= '--' . $boundary . "\r\n";
 976                        $postdata .= 'Content-Disposition: form-data; name="' . $item[0] . '"';
 977                        $postdata .= "\r\n\r\n" . urldecode($item[1]) . "\r\n";
 978                    }
 979                }
 980                foreach ($this->_postFiles as $name => $value) {
 981                    if (is_array($value['name'])) {
 982                        $varname       = $name . ($this->_useBrackets? '[]': '');
 983                    } else {
 984                        $varname       = $name;
 985                        $value['name'] = array($value['name']);
 986                    }
 987                    foreach ($value['name'] as $key => $filename) {
 988                        $fp       = fopen($filename, 'r');
 989                        $basename = basename($filename);
 990                        $type     = is_array($value['type'])? @$value['type'][$key]: $value['type'];
 991
 992                        $postdata .= '--' . $boundary . "\r\n";
 993                        $postdata .= 'Content-Disposition: form-data; name="' . $varname . '"; filename="' . $basename . '"';
 994                        $postdata .= "\r\nContent-Type: " . $type;
 995                        $postdata .= "\r\n\r\n" . fread($fp, filesize($filename)) . "\r\n";
 996                        fclose($fp);
 997                    }
 998                }
 999                $postdata .= '--' . $boundary . "--\r\n";
1000            }
1001            $request .= 'Content-Length: ' .
1002                        (HTTP_REQUEST_MBSTRING? mb_strlen($postdata, 'iso-8859-1'): strlen($postdata)) .
1003                        "\r\n\r\n";
1004            $request .= $postdata;
1005
1006        // Explicitly set request body
1007        } elseif (0 < strlen($this->_body)) {
1008
1009            $request .= 'Content-Length: ' .
1010                        (HTTP_REQUEST_MBSTRING? mb_strlen($this->_body, 'iso-8859-1'): strlen($this->_body)) .
1011                        "\r\n\r\n";
1012            $request .= $this->_body;
1013
1014        // No body: send a Content-Length header nonetheless (request #12900),
1015        // but do that only for methods that require a body (bug #14740)
1016        } else {
1017
1018            if (in_array($this->_method, $this->_bodyRequired)) {
1019                $request .= "Content-Length: 0\r\n";
1020            }
1021            $request .= "\r\n";
1022        }
1023
1024        return $request;
1025    }
1026
1027   /**
1028    * Helper function to change the (probably multidimensional) associative array
1029    * into the simple one.
1030    *
1031    * @param    string  name for item
1032    * @param    mixed   item's values
1033    * @return   array   array with the following items: array('item name', 'item value');
1034    * @access   private
1035    */
1036    function _flattenArray($name, $values)
1037    {
1038        if (!is_array($values)) {
1039            return array(array($name, $values));
1040        } else {
1041            $ret = array();
1042            foreach ($values as $k => $v) {
1043                if (empty($name)) {
1044                    $newName = $k;
1045                } elseif ($this->_useBrackets) {
1046                    $newName = $name . '[' . $k . ']';
1047                } else {
1048                    $newName = $name;
1049                }
1050                $ret = array_merge($ret, $this->_flattenArray($newName, $v));
1051            }
1052            return $ret;
1053        }
1054    }
1055
1056
1057   /**
1058    * Adds a Listener to the list of listeners that are notified of
1059    * the object's events
1060    *
1061    * Events sent by HTTP_Request object
1062    * - 'connect': on connection to server
1063    * - 'sentRequest': after the request was sent
1064    * - 'disconnect': on disconnection from server
1065    *
1066    * Events sent by HTTP_Response object
1067    * - 'gotHeaders': after receiving response headers (headers are passed in $data)
1068    * - 'tick': on receiving a part of response body (the part is passed in $data)
1069    * - 'gzTick': on receiving a gzip-encoded part of response body (ditto)
1070    * - 'gotBody': after receiving the response body (passes the decoded body in $data if it was gzipped)
1071    *
1072    * @param    HTTP_Request_Listener   listener to attach
1073    * @return   boolean                 whether the listener was successfully attached
1074    * @access   public
1075    */
1076    function attach(&$listener)
1077    {
1078        if (!is_a($listener, 'HTTP_Request_Listener')) {
1079            return false;
1080        }
1081        $this->_listeners[$listener->getId()] =& $listener;
1082        return true;
1083    }
1084
1085
1086   /**
1087    * Removes a Listener from the list of listeners
1088    *
1089    * @param    HTTP_Request_Listener   listener to detach
1090    * @return   boolean                 whether the listener was successfully detached
1091    * @access   public
1092    */
1093    function detach(&$listener)
1094    {
1095        if (!is_a($listener, 'HTTP_Request_Listener') ||
1096            !isset($this->_listeners[$listener->getId()])) {
1097            return false;
1098        }
1099        unset($this->_listeners[$listener->getId()]);
1100        return true;
1101    }
1102
1103
1104   /**
1105    * Notifies all registered listeners of an event.
1106    *
1107    * @param    string  Event name
1108    * @param    mixed   Additional data
1109    * @access   private
1110    * @see      HTTP_Request::attach()
1111    */
1112    function _notify($event, $data = null)
1113    {
1114        foreach (array_keys($this->_listeners) as $id) {
1115            $this->_listeners[$id]->update($this, $event, $data);
1116        }
1117    }
1118}
1119
1120
1121/**
1122 * Response class to complement the Request class
1123 *
1124 * @category    HTTP
1125 * @package     HTTP_Request
1126 * @author      Richard Heyes <richard@phpguru.org>
1127 * @author      Alexey Borzov <avb@php.net>
1128 * @version     Release: 1.4.4
1129 */
1130class HTTP_Response
1131{
1132    /**
1133    * Socket object
1134    * @var Net_Socket
1135    */
1136    var $_sock;
1137
1138    /**
1139    * Protocol
1140    * @var string
1141    */
1142    var $_protocol;
1143
1144    /**
1145    * Return code
1146    * @var string
1147    */
1148    var $_code;
1149
1150    /**
1151    * Response reason phrase
1152    * @var string
1153    */
1154    var $_reason;
1155
1156    /**
1157    * Response headers
1158    * @var array
1159    */
1160    var $_headers;
1161
1162    /**
1163    * Cookies set in response
1164    * @var array
1165    */
1166    var $_cookies;
1167
1168    /**
1169    * Response body
1170    * @var string
1171    */
1172    var $_body = '';
1173
1174   /**
1175    * Used by _readChunked(): remaining length of the current chunk
1176    * @var string
1177    */
1178    var $_chunkLength = 0;
1179
1180   /**
1181    * Attached listeners
1182    * @var array
1183    */
1184    var $_listeners = array();
1185
1186   /**
1187    * Bytes left to read from message-body
1188    * @var null|int
1189    */
1190    var $_toRead;
1191
1192    /**
1193    * Constructor
1194    *
1195    * @param  Net_Socket    socket to read the response from
1196    * @param  array         listeners attached to request
1197    */
1198    function HTTP_Response(&$sock, &$listeners)
1199    {
1200        $this->_sock      =& $sock;
1201        $this->_listeners =& $listeners;
1202    }
1203
1204
1205   /**
1206    * Processes a HTTP response
1207    *
1208    * This extracts response code, headers, cookies and decodes body if it
1209    * was encoded in some way
1210    *
1211    * @access public
1212    * @param  bool      Whether to store response body in object property, set
1213    *                   this to false if downloading a LARGE file and using a Listener.
1214    *                   This is assumed to be true if body is gzip-encoded.
1215    * @param  bool      Whether the response can actually have a message-body.
1216    *                   Will be set to false for HEAD requests.
1217    * @throws PEAR_Error
1218    * @return mixed     true on success, PEAR_Error in case of malformed response
1219    */
1220    function process($saveBody = true, $canHaveBody = true)
1221    {
1222        do {
1223            $line = $this->_sock->readLine();
1224            if (!preg_match('!^(HTTP/\d\.\d) (\d{3})(?: (.+))?!', $line, $s)) {
1225                return PEAR::raiseError('Malformed response', HTTP_REQUEST_ERROR_RESPONSE);
1226            } else {
1227                $this->_protocol = $s[1];
1228                $this->_code     = intval($s[2]);
1229                $this->_reason   = empty($s[3])? null: $s[3];
1230            }
1231            while ('' !== ($header = $this->_sock->readLine())) {
1232                $this->_processHeader($header);
1233            }
1234        } while (100 == $this->_code);
1235
1236        $this->_notify('gotHeaders', $this->_headers);
1237
1238        // RFC 2616, section 4.4:
1239        // 1. Any response message which "MUST NOT" include a message-body ...
1240        // is always terminated by the first empty line after the header fields
1241        // 3. ... If a message is received with both a
1242        // Transfer-Encoding header field and a Content-Length header field,
1243        // the latter MUST be ignored.
1244        $canHaveBody = $canHaveBody && $this->_code >= 200 &&
1245                       $this->_code != 204 && $this->_code != 304;
1246
1247        // If response body is present, read it and decode
1248        $chunked = isset($this->_headers['transfer-encoding']) && ('chunked' == $this->_headers['transfer-encoding']);
1249        $gzipped = isset($this->_headers['content-encoding']) && ('gzip' == $this->_headers['content-encoding']);
1250        $hasBody = false;
1251        if ($canHaveBody && ($chunked || !isset($this->_headers['content-length']) ||
1252                0 != $this->_headers['content-length']))
1253        {
1254            if ($chunked || !isset($this->_headers['content-length'])) {
1255                $this->_toRead = null;
1256            } else {
1257                $this->_toRead = $this->_headers['content-length'];
1258            }
1259            while (!$this->_sock->eof() && (is_null($this->_toRead) || 0 < $this->_toRead)) {
1260                if ($chunked) {
1261                    $data = $this->_readChunked();
1262                } elseif (is_null($this->_toRead)) {
1263                    $data = $this->_sock->read(4096);
1264                } else {
1265                    $data = $this->_sock->read(min(4096, $this->_toRead));
1266                    $this->_toRead -= HTTP_REQUEST_MBSTRING? mb_strlen($data, 'iso-8859-1'): strlen($data);
1267                }
1268                if ('' == $data && (!$this->_chunkLength || $this->_sock->eof())) {
1269                    break;
1270                } else {
1271                    $hasBody = true;
1272                    if ($saveBody || $gzipped) {
1273                        $this->_body .= $data;
1274                    }
1275                    $this->_notify($gzipped? 'gzTick': 'tick', $data);
1276                }
1277            }
1278        }
1279
1280        if ($hasBody) {
1281            // Uncompress the body if needed
1282            if ($gzipped) {
1283                $body = $this->_decodeGzip($this->_body);
1284                if (PEAR::isError($body)) {
1285                    return $body;
1286                }
1287                $this->_body = $body;
1288                $this->_notify('gotBody', $this->_body);
1289            } else {
1290                $this->_notify('gotBody');
1291            }
1292        }
1293        return true;
1294    }
1295
1296
1297   /**
1298    * Processes the response header
1299    *
1300    * @access private
1301    * @param  string    HTTP header
1302    */
1303    function _processHeader($header)
1304    {
1305        if (false === strpos($header, ':')) {
1306            return;
1307        }
1308        list($headername, $headervalue) = explode(':', $header, 2);
1309        $headername  = strtolower($headername);
1310        $headervalue = ltrim($headervalue);
1311
1312        if ('set-cookie' != $headername) {
1313            if (isset($this->_headers[$headername])) {
1314                $this->_headers[$headername] .= ',' . $headervalue;
1315            } else {
1316                $this->_headers[$headername]  = $headervalue;
1317            }
1318        } else {
1319            $this->_parseCookie($headervalue);
1320        }
1321    }
1322
1323
1324   /**
1325    * Parse a Set-Cookie header to fill $_cookies array
1326    *
1327    * @access private
1328    * @param  string    value of Set-Cookie header
1329    */
1330    function _parseCookie($headervalue)
1331    {
1332        $cookie = array(
1333            'expires' => null,
1334            'domain'  => null,
1335            'path'    => null,
1336            'secure'  => false
1337        );
1338
1339        // Only a name=value pair
1340        if (!strpos($headervalue, ';')) {
1341            $pos = strpos($headervalue, '=');
1342            $cookie['name']  = trim(substr($headervalue, 0, $pos));
1343            $cookie['value'] = trim(substr($headervalue, $pos + 1));
1344
1345        // Some optional parameters are supplied
1346        } else {
1347            $elements = explode(';', $headervalue);
1348            $pos = strpos($elements[0], '=');
1349            $cookie['name']  = trim(substr($elements[0], 0, $pos));
1350            $cookie['value'] = trim(substr($elements[0], $pos + 1));
1351
1352            for ($i = 1; $i < count($elements); $i++) {
1353                if (false === strpos($elements[$i], '=')) {
1354                    $elName  = trim($elements[$i]);
1355                    $elValue = null;
1356                } else {
1357                    list ($elName, $elValue) = array_map('trim', explode('=', $elements[$i]));
1358                }
1359                $elName = strtolower($elName);
1360                if ('secure' == $elName) {
1361                    $cookie['secure'] = true;
1362                } elseif ('expires' == $elName) {
1363                    $cookie['expires'] = str_replace('"', '', $elValue);
1364                } elseif ('path' == $elName || 'domain' == $elName) {
1365                    $cookie[$elName] = urldecode($elValue);
1366                } else {
1367                    $cookie[$elName] = $elValue;
1368                }
1369            }
1370        }
1371        $this->_cookies[] = $cookie;
1372    }
1373
1374
1375   /**
1376    * Read a part of response body encoded with chunked Transfer-Encoding
1377    *
1378    * @access private
1379    * @return string
1380    */
1381    function _readChunked()
1382    {
1383        // at start of the next chunk?
1384        if (0 == $this->_chunkLength) {
1385            $line = $this->_sock->readLine();
1386            if (preg_match('/^([0-9a-f]+)/i', $line, $matches)) {
1387                $this->_chunkLength = hexdec($matches[1]);
1388                // Chunk with zero length indicates the end
1389                if (0 == $this->_chunkLength) {
1390                    $this->_sock->readLine(); // make this an eof()
1391                    return '';
1392                }
1393            } else {
1394                return '';
1395            }
1396        }
1397        $data = $this->_sock->read($this->_chunkLength);
1398        $this->_chunkLength -= HTTP_REQUEST_MBSTRING? mb_strlen($data, 'iso-8859-1'): strlen($data);
1399        if (0 == $this->_chunkLength) {
1400            $this->_sock->readLine(); // Trailing CRLF
1401        }
1402        return $data;
1403    }
1404
1405
1406   /**
1407    * Notifies all registered listeners of an event.
1408    *
1409    * @param    string  Event name
1410    * @param    mixed   Additional data
1411    * @access   private
1412    * @see HTTP_Request::_notify()
1413    */
1414    function _notify($event, $data = null)
1415    {
1416        foreach (array_keys($this->_listeners) as $id) {
1417            $this->_listeners[$id]->update($this, $event, $data);
1418        }
1419    }
1420
1421
1422   /**
1423    * Decodes the message-body encoded by gzip
1424    *
1425    * The real decoding work is done by gzinflate() built-in function, this
1426    * method only parses the header and checks data for compliance with
1427    * RFC 1952
1428    *
1429    * @access   private
1430    * @param    string  gzip-encoded data
1431    * @return   string  decoded data
1432    */
1433    function _decodeGzip($data)
1434    {
1435        if (HTTP_REQUEST_MBSTRING) {
1436            $oldEncoding = mb_internal_encoding();
1437            mb_internal_encoding('iso-8859-1');
1438        }
1439        $length = strlen($data);
1440        // If it doesn't look like gzip-encoded data, don't bother
1441        if (18 > $length || strcmp(substr($data, 0, 2), "\x1f\x8b")) {
1442            return $data;
1443        }
1444        $method = ord(substr($data, 2, 1));
1445        if (8 != $method) {
1446            return PEAR::raiseError('_decodeGzip(): unknown compression method', HTTP_REQUEST_ERROR_GZIP_METHOD);
1447        }
1448        $flags = ord(substr($data, 3, 1));
1449        if ($flags & 224) {
1450            return PEAR::raiseError('_decodeGzip(): reserved bits are set', HTTP_REQUEST_ERROR_GZIP_DATA);
1451        }
1452
1453        // header is 10 bytes minimum. may be longer, though.
1454        $headerLength = 10;
1455        // extra fields, need to skip 'em
1456        if ($flags & 4) {
1457            if ($length - $headerLength - 2 < 8) {
1458                return PEAR::raiseError('_decodeGzip(): data too short', HTTP_REQUEST_ERROR_GZIP_DATA);
1459            }
1460            $extraLength = unpack('v', substr($data, 10, 2));
1461            if ($length - $headerLength - 2 - $extraLength[1] < 8) {
1462                return PEAR::raiseError('_decodeGzip(): data too short', HTTP_REQUEST_ERROR_GZIP_DATA);
1463            }
1464            $headerLength += $extraLength[1] + 2;
1465        }
1466        // file name, need to skip that
1467        if ($flags & 8) {
1468            if ($length - $headerLength - 1 < 8) {
1469                return PEAR::raiseError('_decodeGzip(): data too short', HTTP_REQUEST_ERROR_GZIP_DATA);
1470            }
1471            $filenameLength = strpos(substr($data, $headerLength), chr(0));
1472            if (false === $filenameLength || $length - $headerLength - $filenameLength - 1 < 8) {
1473                return PEAR::raiseError('_decodeGzip(): data too short', HTTP_REQUEST_ERROR_GZIP_DATA);
1474            }
1475            $headerLength += $filenameLength + 1;
1476        }
1477        // comment, need to skip that also
1478        if ($flags & 16) {
1479            if ($length - $headerLength - 1 < 8) {
1480                return PEAR::raiseError('_decodeGzip(): data too short', HTTP_REQUEST_ERROR_GZIP_DATA);
1481            }
1482            $commentLength = strpos(substr($data, $headerLength), chr(0));
1483            if (false === $commentLength || $length - $headerLength - $commentLength - 1 < 8) {
1484                return PEAR::raiseError('_decodeGzip(): data too short', HTTP_REQUEST_ERROR_GZIP_DATA);
1485            }
1486            $headerLength += $commentLength + 1;
1487        }
1488        // have a CRC for header. let's check
1489        if ($flags & 1) {
1490            if ($length - $headerLength - 2 < 8) {
1491                return PEAR::raiseError('_decodeGzip(): data too short', HTTP_REQUEST_ERROR_GZIP_DATA);
1492            }
1493            $crcReal   = 0xffff & crc32(substr($data, 0, $headerLength));
1494            $crcStored = unpack('v', substr($data, $headerLength, 2));
1495            if ($crcReal != $crcStored[1]) {
1496                return PEAR::raiseError('_decodeGzip(): header CRC check failed', HTTP_REQUEST_ERROR_GZIP_CRC);
1497            }
1498            $headerLength += 2;
1499        }
1500        // unpacked data CRC and size at the end of encoded data
1501        $tmp = unpack('V2', substr($data, -8));
1502        $dataCrc  = $tmp[1];
1503        $dataSize = $tmp[2];
1504
1505        // finally, call the gzinflate() function
1506        // don't pass $dataSize to gzinflate, see bugs #13135, #14370
1507        $unpacked = gzinflate(substr($data, $headerLength, -8));
1508        if (false === $unpacked) {
1509            return PEAR::raiseError('_decodeGzip(): gzinflate() call failed', HTTP_REQUEST_ERROR_GZIP_READ);
1510      

Large files files are truncated, but you can click here to view the full file