extlib/HTTP/Request2.php

   1 <?php\r
   2 /**\r
   3  * Class representing a HTTP request message\r
   4  *\r
   5  * PHP version 5\r
   6  *\r
   7  * LICENSE:\r
   8  *\r
   9  * Copyright (c) 2008-2011, Alexey Borzov <avb@php.net>\r
  10  * All rights reserved.\r
  11  *\r
  12  * Redistribution and use in source and binary forms, with or without\r
  13  * modification, are permitted provided that the following conditions\r
  14  * are met:\r
  15  *\r
  16  *    * Redistributions of source code must retain the above copyright\r
  17  *      notice, this list of conditions and the following disclaimer.\r
  18  *    * Redistributions in binary form must reproduce the above copyright\r
  19  *      notice, this list of conditions and the following disclaimer in the\r
  20  *      documentation and/or other materials provided with the distribution.\r
  21  *    * The names of the authors may not be used to endorse or promote products\r
  22  *      derived from this software without specific prior written permission.\r
  23  *\r
  24  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS\r
  25  * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,\r
  26  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR\r
  27  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR\r
  28  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,\r
  29  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,\r
  30  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR\r
  31  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY\r
  32  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING\r
  33  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r
  34  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
  35  *\r
  36  * @category   HTTP\r
  37  * @package    HTTP_Request2\r
  38  * @author     Alexey Borzov <avb@php.net>\r
  39  * @license    http://opensource.org/licenses/bsd-license.php New BSD License\r
  40  * @version    SVN: $Id: Request2.php 308735 2011-02-27 20:31:28Z avb $\r
  41  * @link       http://pear.php.net/package/HTTP_Request2\r
  42  */\r
  43 \r
  44 /**\r
  45  * A class representing an URL as per RFC 3986.\r
  46  */\r
  47 require_once 'Net/URL2.php';\r
  48 \r
  49 /**\r
  50  * Exception class for HTTP_Request2 package\r
  51  */\r
  52 require_once 'HTTP/Request2/Exception.php';\r
  53 \r
  54 /**\r
  55  * Class representing a HTTP request message\r
  56  *\r
  57  * @category   HTTP\r
  58  * @package    HTTP_Request2\r
  59  * @author     Alexey Borzov <avb@php.net>\r
  60  * @version    Release: 2.0.0RC1\r
  61  * @link       http://tools.ietf.org/html/rfc2616#section-5\r
  62  */\r
  63 class HTTP_Request2 implements SplSubject\r
  64 {\r
  65    /**#@+\r
  66     * Constants for HTTP request methods\r
  67     *\r
  68     * @link http://tools.ietf.org/html/rfc2616#section-5.1.1\r
  69     */\r
  70     const METHOD_OPTIONS = 'OPTIONS';\r
  71     const METHOD_GET     = 'GET';\r
  72     const METHOD_HEAD    = 'HEAD';\r
  73     const METHOD_POST    = 'POST';\r
  74     const METHOD_PUT     = 'PUT';\r
  75     const METHOD_DELETE  = 'DELETE';\r
  76     const METHOD_TRACE   = 'TRACE';\r
  77     const METHOD_CONNECT = 'CONNECT';\r
  78    /**#@-*/\r
  79 \r
  80    /**#@+\r
  81     * Constants for HTTP authentication schemes\r
  82     *\r
  83     * @link http://tools.ietf.org/html/rfc2617\r
  84     */\r
  85     const AUTH_BASIC  = 'basic';\r
  86     const AUTH_DIGEST = 'digest';\r
  87    /**#@-*/\r
  88 \r
  89    /**\r
  90     * Regular expression used to check for invalid symbols in RFC 2616 tokens\r
  91     * @link http://pear.php.net/bugs/bug.php?id=15630\r
  92     */\r
  93     const REGEXP_INVALID_TOKEN = '![\x00-\x1f\x7f-\xff()<>@,;:\\\\"/\[\]?={}\s]!';\r
  94 \r
  95    /**\r
  96     * Regular expression used to check for invalid symbols in cookie strings\r
  97     * @link http://pear.php.net/bugs/bug.php?id=15630\r
  98     * @link http://web.archive.org/web/20080331104521/http://cgi.netscape.com/newsref/std/cookie_spec.html\r
  99     */\r
 100     const REGEXP_INVALID_COOKIE = '/[\s,;]/';\r
 101 \r
 102    /**\r
 103     * Fileinfo magic database resource\r
 104     * @var  resource\r
 105     * @see  detectMimeType()\r
 106     */\r
 107     private static $_fileinfoDb;\r
 108 \r
 109    /**\r
 110     * Observers attached to the request (instances of SplObserver)\r
 111     * @var  array\r
 112     */\r
 113     protected $observers = array();\r
 114 \r
 115    /**\r
 116     * Request URL\r
 117     * @var  Net_URL2\r
 118     */\r
 119     protected $url;\r
 120 \r
 121    /**\r
 122     * Request method\r
 123     * @var  string\r
 124     */\r
 125     protected $method = self::METHOD_GET;\r
 126 \r
 127    /**\r
 128     * Authentication data\r
 129     * @var  array\r
 130     * @see  getAuth()\r
 131     */\r
 132     protected $auth;\r
 133 \r
 134    /**\r
 135     * Request headers\r
 136     * @var  array\r
 137     */\r
 138     protected $headers = array();\r
 139 \r
 140    /**\r
 141     * Configuration parameters\r
 142     * @var  array\r
 143     * @see  setConfig()\r
 144     */\r
 145     protected $config = array(\r
 146         'adapter'           => 'HTTP_Request2_Adapter_Socket',\r
 147         'connect_timeout'   => 10,\r
 148         'timeout'           => 0,\r
 149         'use_brackets'      => true,\r
 150         'protocol_version'  => '1.1',\r
 151         'buffer_size'       => 16384,\r
 152         'store_body'        => true,\r
 153 \r
 154         'proxy_host'        => '',\r
 155         'proxy_port'        => '',\r
 156         'proxy_user'        => '',\r
 157         'proxy_password'    => '',\r
 158         'proxy_auth_scheme' => self::AUTH_BASIC,\r
 159 \r
 160         'ssl_verify_peer'   => true,\r
 161         'ssl_verify_host'   => true,\r
 162         'ssl_cafile'        => null,\r
 163         'ssl_capath'        => null,\r
 164         'ssl_local_cert'    => null,\r
 165         'ssl_passphrase'    => null,\r
 166 \r
 167         'digest_compat_ie'  => false,\r
 168 \r
 169         'follow_redirects'  => false,\r
 170         'max_redirects'     => 5,\r
 171         'strict_redirects'  => false\r
 172     );\r
 173 \r
 174    /**\r
 175     * Last event in request / response handling, intended for observers\r
 176     * @var  array\r
 177     * @see  getLastEvent()\r
 178     */\r
 179     protected $lastEvent = array(\r
 180         'name' => 'start',\r
 181         'data' => null\r
 182     );\r
 183 \r
 184    /**\r
 185     * Request body\r
 186     * @var  string|resource\r
 187     * @see  setBody()\r
 188     */\r
 189     protected $body = '';\r
 190 \r
 191    /**\r
 192     * Array of POST parameters\r
 193     * @var  array\r
 194     */\r
 195     protected $postParams = array();\r
 196 \r
 197    /**\r
 198     * Array of file uploads (for multipart/form-data POST requests)\r
 199     * @var  array\r
 200     */\r
 201     protected $uploads = array();\r
 202 \r
 203    /**\r
 204     * Adapter used to perform actual HTTP request\r
 205     * @var  HTTP_Request2_Adapter\r
 206     */\r
 207     protected $adapter;\r
 208 \r
 209    /**\r
 210     * Cookie jar to persist cookies between requests\r
 211     * @var HTTP_Request2_CookieJar\r
 212     */\r
 213     protected $cookieJar = null;\r
 214 \r
 215    /**\r
 216     * Constructor. Can set request URL, method and configuration array.\r
 217     *\r
 218     * Also sets a default value for User-Agent header.\r
 219     *\r
 220     * @param    string|Net_Url2     Request URL\r
 221     * @param    string              Request method\r
 222     * @param    array               Configuration for this Request instance\r
 223     */\r
 224     public function __construct($url = null, $method = self::METHOD_GET, array $config = array())\r
 225     {\r
 226         $this->setConfig($config);\r
 227         if (!empty($url)) {\r
 228             $this->setUrl($url);\r
 229         }\r
 230         if (!empty($method)) {\r
 231             $this->setMethod($method);\r
 232         }\r
 233         $this->setHeader('user-agent', 'HTTP_Request2/2.0.0RC1 ' .\r
 234                          '(http://pear.php.net/package/http_request2) ' .\r
 235                          'PHP/' . phpversion());\r
 236     }\r
 237 \r
 238    /**\r
 239     * Sets the URL for this request\r
 240     *\r
 241     * If the URL has userinfo part (username & password) these will be removed\r
 242     * and converted to auth data. If the URL does not have a path component,\r
 243     * that will be set to '/'.\r
 244     *\r
 245     * @param    string|Net_URL2 Request URL\r
 246     * @return   HTTP_Request2\r
 247     * @throws   HTTP_Request2_LogicException\r
 248     */\r
 249     public function setUrl($url)\r
 250     {\r
 251         if (is_string($url)) {\r
 252             $url = new Net_URL2(\r
 253                 $url, array(Net_URL2::OPTION_USE_BRACKETS => $this->config['use_brackets'])\r
 254             );\r
 255         }\r
 256         if (!$url instanceof Net_URL2) {\r
 257             throw new HTTP_Request2_LogicException(\r
 258                 'Parameter is not a valid HTTP URL',\r
 259                 HTTP_Request2_Exception::INVALID_ARGUMENT\r
 260             );\r
 261         }\r
 262         // URL contains username / password?\r
 263         if ($url->getUserinfo()) {\r
 264             $username = $url->getUser();\r
 265             $password = $url->getPassword();\r
 266             $this->setAuth(rawurldecode($username), $password? rawurldecode($password): '');\r
 267             $url->setUserinfo('');\r
 268         }\r
 269         if ('' == $url->getPath()) {\r
 270             $url->setPath('/');\r
 271         }\r
 272         $this->url = $url;\r
 273 \r
 274         return $this;\r
 275     }\r
 276 \r
 277    /**\r
 278     * Returns the request URL\r
 279     *\r
 280     * @return   Net_URL2\r
 281     */\r
 282     public function getUrl()\r
 283     {\r
 284         return $this->url;\r
 285     }\r
 286 \r
 287    /**\r
 288     * Sets the request method\r
 289     *\r
 290     * @param    string\r
 291     * @return   HTTP_Request2\r
 292     * @throws   HTTP_Request2_LogicException if the method name is invalid\r
 293     */\r
 294     public function setMethod($method)\r
 295     {\r
 296         // Method name should be a token: http://tools.ietf.org/html/rfc2616#section-5.1.1\r
 297         if (preg_match(self::REGEXP_INVALID_TOKEN, $method)) {\r
 298             throw new HTTP_Request2_LogicException(\r
 299                 "Invalid request method '{$method}'",\r
 300                 HTTP_Request2_Exception::INVALID_ARGUMENT\r
 301             );\r
 302         }\r
 303         $this->method = $method;\r
 304 \r
 305         return $this;\r
 306     }\r
 307 \r
 308    /**\r
 309     * Returns the request method\r
 310     *\r
 311     * @return   string\r
 312     */\r
 313     public function getMethod()\r
 314     {\r
 315         return $this->method;\r
 316     }\r
 317 \r
 318    /**\r
 319     * Sets the configuration parameter(s)\r
 320     *\r
 321     * The following parameters are available:\r
 322     * <ul>\r
 323     *   <li> 'adapter'           - adapter to use (string)</li>\r
 324     *   <li> 'connect_timeout'   - Connection timeout in seconds (integer)</li>\r
 325     *   <li> 'timeout'           - Total number of seconds a request can take.\r
 326     *                              Use 0 for no limit, should be greater than\r
 327     *                              'connect_timeout' if set (integer)</li>\r
 328     *   <li> 'use_brackets'      - Whether to append [] to array variable names (bool)</li>\r
 329     *   <li> 'protocol_version'  - HTTP Version to use, '1.0' or '1.1' (string)</li>\r
 330     *   <li> 'buffer_size'       - Buffer size to use for reading and writing (int)</li>\r
 331     *   <li> 'store_body'        - Whether to store response body in response object.\r
 332     *                              Set to false if receiving a huge response and\r
 333     *                              using an Observer to save it (boolean)</li>\r
 334     *   <li> 'proxy_host'        - Proxy server host (string)</li>\r
 335     *   <li> 'proxy_port'        - Proxy server port (integer)</li>\r
 336     *   <li> 'proxy_user'        - Proxy auth username (string)</li>\r
 337     *   <li> 'proxy_password'    - Proxy auth password (string)</li>\r
 338     *   <li> 'proxy_auth_scheme' - Proxy auth scheme, one of HTTP_Request2::AUTH_* constants (string)</li>\r
 339     *   <li> 'ssl_verify_peer'   - Whether to verify peer's SSL certificate (bool)</li>\r
 340     *   <li> 'ssl_verify_host'   - Whether to check that Common Name in SSL\r
 341     *                              certificate matches host name (bool)</li>\r
 342     *   <li> 'ssl_cafile'        - Cerificate Authority file to verify the peer\r
 343     *                              with (use with 'ssl_verify_peer') (string)</li>\r
 344     *   <li> 'ssl_capath'        - Directory holding multiple Certificate\r
 345     *                              Authority files (string)</li>\r
 346     *   <li> 'ssl_local_cert'    - Name of a file containing local cerificate (string)</li>\r
 347     *   <li> 'ssl_passphrase'    - Passphrase with which local certificate\r
 348     *                              was encoded (string)</li>\r
 349     *   <li> 'digest_compat_ie'  - Whether to imitate behaviour of MSIE 5 and 6\r
 350     *                              in using URL without query string in digest\r
 351     *                              authentication (boolean)</li>\r
 352     *   <li> 'follow_redirects'  - Whether to automatically follow HTTP Redirects (boolean)</li>\r
 353     *   <li> 'max_redirects'     - Maximum number of redirects to follow (integer)</li>\r
 354     *   <li> 'strict_redirects'  - Whether to keep request method on redirects via status 301 and\r
 355     *                              302 (true, needed for compatibility with RFC 2616)\r
 356     *                              or switch to GET (false, needed for compatibility with most\r
 357     *                              browsers) (boolean)</li>\r
 358     * </ul>\r
 359     *\r
 360     * @param    string|array    configuration parameter name or array\r
 361     *                           ('parameter name' => 'parameter value')\r
 362     * @param    mixed           parameter value if $nameOrConfig is not an array\r
 363     * @return   HTTP_Request2\r
 364     * @throws   HTTP_Request2_LogicException If the parameter is unknown\r
 365     */\r
 366     public function setConfig($nameOrConfig, $value = null)\r
 367     {\r
 368         if (is_array($nameOrConfig)) {\r
 369             foreach ($nameOrConfig as $name => $value) {\r
 370                 $this->setConfig($name, $value);\r
 371             }\r
 372 \r
 373         } else {\r
 374             if (!array_key_exists($nameOrConfig, $this->config)) {\r
 375                 throw new HTTP_Request2_LogicException(\r
 376                     "Unknown configuration parameter '{$nameOrConfig}'",\r
 377                     HTTP_Request2_Exception::INVALID_ARGUMENT\r
 378                 );\r
 379             }\r
 380             $this->config[$nameOrConfig] = $value;\r
 381         }\r
 382 \r
 383         return $this;\r
 384     }\r
 385 \r
 386    /**\r
 387     * Returns the value(s) of the configuration parameter(s)\r
 388     *\r
 389     * @param    string  parameter name\r
 390     * @return   mixed   value of $name parameter, array of all configuration\r
 391     *                   parameters if $name is not given\r
 392     * @throws   HTTP_Request2_LogicException If the parameter is unknown\r
 393     */\r
 394     public function getConfig($name = null)\r
 395     {\r
 396         if (null === $name) {\r
 397             return $this->config;\r
 398         } elseif (!array_key_exists($name, $this->config)) {\r
 399             throw new HTTP_Request2_LogicException(\r
 400                 "Unknown configuration parameter '{$name}'",\r
 401                 HTTP_Request2_Exception::INVALID_ARGUMENT\r
 402             );\r
 403         }\r
 404         return $this->config[$name];\r
 405     }\r
 406 \r
 407    /**\r
 408     * Sets the autentification data\r
 409     *\r
 410     * @param    string  user name\r
 411     * @param    string  password\r
 412     * @param    string  authentication scheme\r
 413     * @return   HTTP_Request2\r
 414     */\r
 415     public function setAuth($user, $password = '', $scheme = self::AUTH_BASIC)\r
 416     {\r
 417         if (empty($user)) {\r
 418             $this->auth = null;\r
 419         } else {\r
 420             $this->auth = array(\r
 421                 'user'     => (string)$user,\r
 422                 'password' => (string)$password,\r
 423                 'scheme'   => $scheme\r
 424             );\r
 425         }\r
 426 \r
 427         return $this;\r
 428     }\r
 429 \r
 430    /**\r
 431     * Returns the authentication data\r
 432     *\r
 433     * The array has the keys 'user', 'password' and 'scheme', where 'scheme'\r
 434     * is one of the HTTP_Request2::AUTH_* constants.\r
 435     *\r
 436     * @return   array\r
 437     */\r
 438     public function getAuth()\r
 439     {\r
 440         return $this->auth;\r
 441     }\r
 442 \r
 443    /**\r
 444     * Sets request header(s)\r
 445     *\r
 446     * The first parameter may be either a full header string 'header: value' or\r
 447     * header name. In the former case $value parameter is ignored, in the latter\r
 448     * the header's value will either be set to $value or the header will be\r
 449     * removed if $value is null. The first parameter can also be an array of\r
 450     * headers, in that case method will be called recursively.\r
 451     *\r
 452     * Note that headers are treated case insensitively as per RFC 2616.\r
 453     *\r
 454     * <code>\r
 455     * $req->setHeader('Foo: Bar'); // sets the value of 'Foo' header to 'Bar'\r
 456     * $req->setHeader('FoO', 'Baz'); // sets the value of 'Foo' header to 'Baz'\r
 457     * $req->setHeader(array('foo' => 'Quux')); // sets the value of 'Foo' header to 'Quux'\r
 458     * $req->setHeader('FOO'); // removes 'Foo' header from request\r
 459     * </code>\r
 460     *\r
 461     * @param    string|array    header name, header string ('Header: value')\r
 462     *                           or an array of headers\r
 463     * @param    string|array|null header value if $name is not an array,\r
 464     *                           header will be removed if value is null\r
 465     * @param    bool            whether to replace previous header with the\r
 466     *                           same name or append to its value\r
 467     * @return   HTTP_Request2\r
 468     * @throws   HTTP_Request2_LogicException\r
 469     */\r
 470     public function setHeader($name, $value = null, $replace = true)\r
 471     {\r
 472         if (is_array($name)) {\r
 473             foreach ($name as $k => $v) {\r
 474                 if (is_string($k)) {\r
 475                     $this->setHeader($k, $v, $replace);\r
 476                 } else {\r
 477                     $this->setHeader($v, null, $replace);\r
 478                 }\r
 479             }\r
 480         } else {\r
 481             if (null === $value && strpos($name, ':')) {\r
 482                 list($name, $value) = array_map('trim', explode(':', $name, 2));\r
 483             }\r
 484             // Header name should be a token: http://tools.ietf.org/html/rfc2616#section-4.2\r
 485             if (preg_match(self::REGEXP_INVALID_TOKEN, $name)) {\r
 486                 throw new HTTP_Request2_LogicException(\r
 487                     "Invalid header name '{$name}'",\r
 488                     HTTP_Request2_Exception::INVALID_ARGUMENT\r
 489                 );\r
 490             }\r
 491             // Header names are case insensitive anyway\r
 492             $name = strtolower($name);\r
 493             if (null === $value) {\r
 494                 unset($this->headers[$name]);\r
 495 \r
 496             } else {\r
 497                 if (is_array($value)) {\r
 498                     $value = implode(', ', array_map('trim', $value));\r
 499                 } elseif (is_string($value)) {\r
 500                     $value = trim($value);\r
 501                 }\r
 502                 if (!isset($this->headers[$name]) || $replace) {\r
 503                     $this->headers[$name] = $value;\r
 504                 } else {\r
 505                     $this->headers[$name] .= ', ' . $value;\r
 506                 }\r
 507             }\r
 508         }\r
 509 \r
 510         return $this;\r
 511     }\r
 512 \r
 513    /**\r
 514     * Returns the request headers\r
 515     *\r
 516     * The array is of the form ('header name' => 'header value'), header names\r
 517     * are lowercased\r
 518     *\r
 519     * @return   array\r
 520     */\r
 521     public function getHeaders()\r
 522     {\r
 523         return $this->headers;\r
 524     }\r
 525 \r
 526    /**\r
 527     * Adds a cookie to the request\r
 528     *\r
 529     * If the request does not have a CookieJar object set, this method simply\r
 530     * appends a cookie to "Cookie:" header.\r
 531     *\r
 532     * If a CookieJar object is available, the cookie is stored in that object.\r
 533     * Data from request URL will be used for setting its 'domain' and 'path'\r
 534     * parameters, 'expires' and 'secure' will be set to null and false,\r
 535     * respectively. If you need further control, use CookieJar's methods.\r
 536     *\r
 537     * @param    string  cookie name\r
 538     * @param    string  cookie value\r
 539     * @return   HTTP_Request2\r
 540     * @throws   HTTP_Request2_LogicException\r
 541     * @see      setCookieJar()\r
 542     */\r
 543     public function addCookie($name, $value)\r
 544     {\r
 545         if (!empty($this->cookieJar)) {\r
 546             $this->cookieJar->store(array('name' => $name, 'value' => $value),\r
 547                                     $this->url);\r
 548 \r
 549         } else {\r
 550             $cookie = $name . '=' . $value;\r
 551             if (preg_match(self::REGEXP_INVALID_COOKIE, $cookie)) {\r
 552                 throw new HTTP_Request2_LogicException(\r
 553                     "Invalid cookie: '{$cookie}'",\r
 554                     HTTP_Request2_Exception::INVALID_ARGUMENT\r
 555                 );\r
 556             }\r
 557             $cookies = empty($this->headers['cookie'])? '': $this->headers['cookie'] . '; ';\r
 558             $this->setHeader('cookie', $cookies . $cookie);\r
 559         }\r
 560 \r
 561         return $this;\r
 562     }\r
 563 \r
 564    /**\r
 565     * Sets the request body\r
 566     *\r
 567     * If you provide file pointer rather than file name, it should support\r
 568     * fstat() and rewind() operations.\r
 569     *\r
 570     * @param    string|resource|HTTP_Request2_MultipartBody  Either a string\r
 571     *               with the body or filename containing body or pointer to\r
 572     *               an open file or object with multipart body data\r
 573     * @param    bool    Whether first parameter is a filename\r
 574     * @return   HTTP_Request2\r
 575     * @throws   HTTP_Request2_LogicException\r
 576     */\r
 577     public function setBody($body, $isFilename = false)\r
 578     {\r
 579         if (!$isFilename && !is_resource($body)) {\r
 580             if (!$body instanceof HTTP_Request2_MultipartBody) {\r
 581                 $this->body = (string)$body;\r
 582             } else {\r
 583                 $this->body = $body;\r
 584             }\r
 585         } else {\r
 586             $fileData = $this->fopenWrapper($body, empty($this->headers['content-type']));\r
 587             $this->body = $fileData['fp'];\r
 588             if (empty($this->headers['content-type'])) {\r
 589                 $this->setHeader('content-type', $fileData['type']);\r
 590             }\r
 591         }\r
 592         $this->postParams = $this->uploads = array();\r
 593 \r
 594         return $this;\r
 595     }\r
 596 \r
 597    /**\r
 598     * Returns the request body\r
 599     *\r
 600     * @return   string|resource|HTTP_Request2_MultipartBody\r
 601     */\r
 602     public function getBody()\r
 603     {\r
 604         if (self::METHOD_POST == $this->method &&\r
 605             (!empty($this->postParams) || !empty($this->uploads))\r
 606         ) {\r
 607             if (0 === strpos($this->headers['content-type'], 'application/x-www-form-urlencoded')) {\r
 608                 $body = http_build_query($this->postParams, '', '&');\r
 609                 if (!$this->getConfig('use_brackets')) {\r
 610                     $body = preg_replace('/%5B\d+%5D=/', '=', $body);\r
 611                 }\r
 612                 // support RFC 3986 by not encoding '~' symbol (request #15368)\r
 613                 return str_replace('%7E', '~', $body);\r
 614 \r
 615             } elseif (0 === strpos($this->headers['content-type'], 'multipart/form-data')) {\r
 616                 require_once 'HTTP/Request2/MultipartBody.php';\r
 617                 return new HTTP_Request2_MultipartBody(\r
 618                     $this->postParams, $this->uploads, $this->getConfig('use_brackets')\r
 619                 );\r
 620             }\r
 621         }\r
 622         return $this->body;\r
 623     }\r
 624 \r
 625    /**\r
 626     * Adds a file to form-based file upload\r
 627     *\r
 628     * Used to emulate file upload via a HTML form. The method also sets\r
 629     * Content-Type of HTTP request to 'multipart/form-data'.\r
 630     *\r
 631     * If you just want to send the contents of a file as the body of HTTP\r
 632     * request you should use setBody() method.\r
 633     *\r
 634     * If you provide file pointers rather than file names, they should support\r
 635     * fstat() and rewind() operations.\r
 636     *\r
 637     * @param    string  name of file-upload field\r
 638     * @param    string|resource|array   full name of local file, pointer to\r
 639     *               open file or an array of files\r
 640     * @param    string  filename to send in the request\r
 641     * @param    string  content-type of file being uploaded\r
 642     * @return   HTTP_Request2\r
 643     * @throws   HTTP_Request2_LogicException\r
 644     */\r
 645     public function addUpload($fieldName, $filename, $sendFilename = null,\r
 646                               $contentType = null)\r
 647     {\r
 648         if (!is_array($filename)) {\r
 649             $fileData = $this->fopenWrapper($filename, empty($contentType));\r
 650             $this->uploads[$fieldName] = array(\r
 651                 'fp'        => $fileData['fp'],\r
 652                 'filename'  => !empty($sendFilename)? $sendFilename\r
 653                                 :(is_string($filename)? basename($filename): 'anonymous.blob') ,\r
 654                 'size'      => $fileData['size'],\r
 655                 'type'      => empty($contentType)? $fileData['type']: $contentType\r
 656             );\r
 657         } else {\r
 658             $fps = $names = $sizes = $types = array();\r
 659             foreach ($filename as $f) {\r
 660                 if (!is_array($f)) {\r
 661                     $f = array($f);\r
 662                 }\r
 663                 $fileData = $this->fopenWrapper($f[0], empty($f[2]));\r
 664                 $fps[]   = $fileData['fp'];\r
 665                 $names[] = !empty($f[1])? $f[1]\r
 666                             :(is_string($f[0])? basename($f[0]): 'anonymous.blob');\r
 667                 $sizes[] = $fileData['size'];\r
 668                 $types[] = empty($f[2])? $fileData['type']: $f[2];\r
 669             }\r
 670             $this->uploads[$fieldName] = array(\r
 671                 'fp' => $fps, 'filename' => $names, 'size' => $sizes, 'type' => $types\r
 672             );\r
 673         }\r
 674         if (empty($this->headers['content-type']) ||\r
 675             'application/x-www-form-urlencoded' == $this->headers['content-type']\r
 676         ) {\r
 677             $this->setHeader('content-type', 'multipart/form-data');\r
 678         }\r
 679 \r
 680         return $this;\r
 681     }\r
 682 \r
 683    /**\r
 684     * Adds POST parameter(s) to the request.\r
 685     *\r
 686     * @param    string|array    parameter name or array ('name' => 'value')\r
 687     * @param    mixed           parameter value (can be an array)\r
 688     * @return   HTTP_Request2\r
 689     */\r
 690     public function addPostParameter($name, $value = null)\r
 691     {\r
 692         if (!is_array($name)) {\r
 693             $this->postParams[$name] = $value;\r
 694         } else {\r
 695             foreach ($name as $k => $v) {\r
 696                 $this->addPostParameter($k, $v);\r
 697             }\r
 698         }\r
 699         if (empty($this->headers['content-type'])) {\r
 700             $this->setHeader('content-type', 'application/x-www-form-urlencoded');\r
 701         }\r
 702 \r
 703         return $this;\r
 704     }\r
 705 \r
 706    /**\r
 707     * Attaches a new observer\r
 708     *\r
 709     * @param    SplObserver\r
 710     */\r
 711     public function attach(SplObserver $observer)\r
 712     {\r
 713         foreach ($this->observers as $attached) {\r
 714             if ($attached === $observer) {\r
 715                 return;\r
 716             }\r
 717         }\r
 718         $this->observers[] = $observer;\r
 719     }\r
 720 \r
 721    /**\r
 722     * Detaches an existing observer\r
 723     *\r
 724     * @param    SplObserver\r
 725     */\r
 726     public function detach(SplObserver $observer)\r
 727     {\r
 728         foreach ($this->observers as $key => $attached) {\r
 729             if ($attached === $observer) {\r
 730                 unset($this->observers[$key]);\r
 731                 return;\r
 732             }\r
 733         }\r
 734     }\r
 735 \r
 736    /**\r
 737     * Notifies all observers\r
 738     */\r
 739     public function notify()\r
 740     {\r
 741         foreach ($this->observers as $observer) {\r
 742             $observer->update($this);\r
 743         }\r
 744     }\r
 745 \r
 746    /**\r
 747     * Sets the last event\r
 748     *\r
 749     * Adapters should use this method to set the current state of the request\r
 750     * and notify the observers.\r
 751     *\r
 752     * @param    string  event name\r
 753     * @param    mixed   event data\r
 754     */\r
 755     public function setLastEvent($name, $data = null)\r
 756     {\r
 757         $this->lastEvent = array(\r
 758             'name' => $name,\r
 759             'data' => $data\r
 760         );\r
 761         $this->notify();\r
 762     }\r
 763 \r
 764    /**\r
 765     * Returns the last event\r
 766     *\r
 767     * Observers should use this method to access the last change in request.\r
 768     * The following event names are possible:\r
 769     * <ul>\r
 770     *   <li>'connect'                 - after connection to remote server,\r
 771     *                                   data is the destination (string)</li>\r
 772     *   <li>'disconnect'              - after disconnection from server</li>\r
 773     *   <li>'sentHeaders'             - after sending the request headers,\r
 774     *                                   data is the headers sent (string)</li>\r
 775     *   <li>'sentBodyPart'            - after sending a part of the request body,\r
 776     *                                   data is the length of that part (int)</li>\r
 777     *   <li>'sentBody'                - after sending the whole request body,\r
 778     *                                   data is request body length (int)</li>\r
 779     *   <li>'receivedHeaders'         - after receiving the response headers,\r
 780     *                                   data is HTTP_Request2_Response object</li>\r
 781     *   <li>'receivedBodyPart'        - after receiving a part of the response\r
 782     *                                   body, data is that part (string)</li>\r
 783     *   <li>'receivedEncodedBodyPart' - as 'receivedBodyPart', but data is still\r
 784     *                                   encoded by Content-Encoding</li>\r
 785     *   <li>'receivedBody'            - after receiving the complete response\r
 786     *                                   body, data is HTTP_Request2_Response object</li>\r
 787     * </ul>\r
 788     * Different adapters may not send all the event types. Mock adapter does\r
 789     * not send any events to the observers.\r
 790     *\r
 791     * @return   array   The array has two keys: 'name' and 'data'\r
 792     */\r
 793     public function getLastEvent()\r
 794     {\r
 795         return $this->lastEvent;\r
 796     }\r
 797 \r
 798    /**\r
 799     * Sets the adapter used to actually perform the request\r
 800     *\r
 801     * You can pass either an instance of a class implementing HTTP_Request2_Adapter\r
 802     * or a class name. The method will only try to include a file if the class\r
 803     * name starts with HTTP_Request2_Adapter_, it will also try to prepend this\r
 804     * prefix to the class name if it doesn't contain any underscores, so that\r
 805     * <code>\r
 806     * $request->setAdapter('curl');\r
 807     * </code>\r
 808     * will work.\r
 809     *\r
 810     * @param    string|HTTP_Request2_Adapter\r
 811     * @return   HTTP_Request2\r
 812     * @throws   HTTP_Request2_LogicException\r
 813     */\r
 814     public function setAdapter($adapter)\r
 815     {\r
 816         if (is_string($adapter)) {\r
 817             if (!class_exists($adapter, false)) {\r
 818                 if (false === strpos($adapter, '_')) {\r
 819                     $adapter = 'HTTP_Request2_Adapter_' . ucfirst($adapter);\r
 820                 }\r
 821                 if (preg_match('/^HTTP_Request2_Adapter_([a-zA-Z0-9]+)$/', $adapter)) {\r
 822                     include_once str_replace('_', DIRECTORY_SEPARATOR, $adapter) . '.php';\r
 823                 }\r
 824                 if (!class_exists($adapter, false)) {\r
 825                     throw new HTTP_Request2_LogicException(\r
 826                         "Class {$adapter} not found",\r
 827                         HTTP_Request2_Exception::MISSING_VALUE\r
 828                     );\r
 829                 }\r
 830             }\r
 831             $adapter = new $adapter;\r
 832         }\r
 833         if (!$adapter instanceof HTTP_Request2_Adapter) {\r
 834             throw new HTTP_Request2_LogicException(\r
 835                 'Parameter is not a HTTP request adapter',\r
 836                 HTTP_Request2_Exception::INVALID_ARGUMENT\r
 837             );\r
 838         }\r
 839         $this->adapter = $adapter;\r
 840 \r
 841         return $this;\r
 842     }\r
 843 \r
 844    /**\r
 845     * Sets the cookie jar\r
 846     *\r
 847     * A cookie jar is used to maintain cookies across HTTP requests and\r
 848     * responses. Cookies from jar will be automatically added to the request\r
 849     * headers based on request URL.\r
 850     *\r
 851     * @param HTTP_Request2_CookieJar|bool   Existing CookieJar object, true to\r
 852     *                                       create a new one, false to remove\r
 853     */\r
 854     public function setCookieJar($jar = true)\r
 855     {\r
 856         if (!class_exists('HTTP_Request2_CookieJar', false)) {\r
 857             require_once 'HTTP/Request2/CookieJar.php';\r
 858         }\r
 859 \r
 860         if ($jar instanceof HTTP_Request2_CookieJar) {\r
 861             $this->cookieJar = $jar;\r
 862         } elseif (true === $jar) {\r
 863             $this->cookieJar = new HTTP_Request2_CookieJar();\r
 864         } elseif (!$jar) {\r
 865             $this->cookieJar = null;\r
 866         } else {\r
 867             throw new HTTP_Request2_LogicException(\r
 868                 'Invalid parameter passed to setCookieJar()',\r
 869                 HTTP_Request2_Exception::INVALID_ARGUMENT\r
 870             );\r
 871         }\r
 872 \r
 873         return $this;\r
 874     }\r
 875 \r
 876    /**\r
 877     * Returns current CookieJar object or null if none\r
 878     *\r
 879     * @return HTTP_Request2_CookieJar|null\r
 880     */\r
 881     public function getCookieJar()\r
 882     {\r
 883         return $this->cookieJar;\r
 884     }\r
 885 \r
 886    /**\r
 887     * Sends the request and returns the response\r
 888     *\r
 889     * @throws   HTTP_Request2_Exception\r
 890     * @return   HTTP_Request2_Response\r
 891     */\r
 892     public function send()\r
 893     {\r
 894         // Sanity check for URL\r
 895         if (!$this->url instanceof Net_URL2\r
 896             || !$this->url->isAbsolute()\r
 897             || !in_array(strtolower($this->url->getScheme()), array('https', 'http'))\r
 898         ) {\r
 899             throw new HTTP_Request2_LogicException(\r
 900                 'HTTP_Request2 needs an absolute HTTP(S) request URL, '\r
 901                 . ($this->url instanceof Net_URL2\r
 902                    ? 'none' : "'" . $this->url->__toString() . "'")\r
 903                 . ' given',\r
 904                 HTTP_Request2_Exception::INVALID_ARGUMENT\r
 905             );\r
 906         }\r
 907         if (empty($this->adapter)) {\r
 908             $this->setAdapter($this->getConfig('adapter'));\r
 909         }\r
 910         // magic_quotes_runtime may break file uploads and chunked response\r
 911         // processing; see bug #4543. Don't use ini_get() here; see bug #16440.\r
 912         if ($magicQuotes = get_magic_quotes_runtime()) {\r
 913             set_magic_quotes_runtime(false);\r
 914         }\r
 915         // force using single byte encoding if mbstring extension overloads\r
 916         // strlen() and substr(); see bug #1781, bug #10605\r
 917         if (extension_loaded('mbstring') && (2 & ini_get('mbstring.func_overload'))) {\r
 918             $oldEncoding = mb_internal_encoding();\r
 919             mb_internal_encoding('iso-8859-1');\r
 920         }\r
 921 \r
 922         try {\r
 923             $response = $this->adapter->sendRequest($this);\r
 924         } catch (Exception $e) {\r
 925         }\r
 926         // cleanup in either case (poor man's "finally" clause)\r
 927         if ($magicQuotes) {\r
 928             set_magic_quotes_runtime(true);\r
 929         }\r
 930         if (!empty($oldEncoding)) {\r
 931             mb_internal_encoding($oldEncoding);\r
 932         }\r
 933         // rethrow the exception\r
 934         if (!empty($e)) {\r
 935             throw $e;\r
 936         }\r
 937         return $response;\r
 938     }\r
 939 \r
 940    /**\r
 941     * Wrapper around fopen()/fstat() used by setBody() and addUpload()\r
 942     *\r
 943     * @param  string|resource file name or pointer to open file\r
 944     * @param  bool            whether to try autodetecting MIME type of file,\r
 945     *                         will only work if $file is a filename, not pointer\r
 946     * @return array array('fp' => file pointer, 'size' => file size, 'type' => MIME type)\r
 947     * @throws HTTP_Request2_LogicException\r
 948     */\r
 949     protected function fopenWrapper($file, $detectType = false)\r
 950     {\r
 951         if (!is_string($file) && !is_resource($file)) {\r
 952             throw new HTTP_Request2_LogicException(\r
 953                 "Filename or file pointer resource expected",\r
 954                 HTTP_Request2_Exception::INVALID_ARGUMENT\r
 955             );\r
 956         }\r
 957         $fileData = array(\r
 958             'fp'   => is_string($file)? null: $file,\r
 959             'type' => 'application/octet-stream',\r
 960             'size' => 0\r
 961         );\r
 962         if (is_string($file)) {\r
 963             $track = @ini_set('track_errors', 1);\r
 964             if (!($fileData['fp'] = @fopen($file, 'rb'))) {\r
 965                 $e = new HTTP_Request2_LogicException(\r
 966                     $php_errormsg, HTTP_Request2_Exception::READ_ERROR\r
 967                 );\r
 968             }\r
 969             @ini_set('track_errors', $track);\r
 970             if (isset($e)) {\r
 971                 throw $e;\r
 972             }\r
 973             if ($detectType) {\r
 974                 $fileData['type'] = self::detectMimeType($file);\r
 975             }\r
 976         }\r
 977         if (!($stat = fstat($fileData['fp']))) {\r
 978             throw new HTTP_Request2_LogicException(\r
 979                 "fstat() call failed", HTTP_Request2_Exception::READ_ERROR\r
 980             );\r
 981         }\r
 982         $fileData['size'] = $stat['size'];\r
 983 \r
 984         return $fileData;\r
 985     }\r
 986 \r
 987    /**\r
 988     * Tries to detect MIME type of a file\r
 989     *\r
 990     * The method will try to use fileinfo extension if it is available,\r
 991     * deprecated mime_content_type() function in the other case. If neither\r
 992     * works, default 'application/octet-stream' MIME type is returned\r
 993     *\r
 994     * @param    string  filename\r
 995     * @return   string  file MIME type\r
 996     */\r
 997     protected static function detectMimeType($filename)\r
 998     {\r
 999         // finfo extension from PECL available\r
1000         if (function_exists('finfo_open')) {\r
1001             if (!isset(self::$_fileinfoDb)) {\r
1002                 self::$_fileinfoDb = @finfo_open(FILEINFO_MIME);\r
1003             }\r
1004             if (self::$_fileinfoDb) {\r
1005                 $info = finfo_file(self::$_fileinfoDb, $filename);\r
1006             }\r
1007         }\r
1008         // (deprecated) mime_content_type function available\r
1009         if (empty($info) && function_exists('mime_content_type')) {\r
1010             return mime_content_type($filename);\r
1011         }\r
1012         return empty($info)? 'application/octet-stream': $info;\r
1013     }\r
1014 }\r
1015 ?>