php/external/Zend/Http/Client.php

   1 <?php
   2
   3 /**
   4  * Zend Framework
   5  *
   6  * LICENSE
   7  *
   8  * This source file is subject to the new BSD license that is bundled
   9  * with this package in the file LICENSE.txt.
  10  * It is also available through the world-wide-web at this URL:
  11  * http://framework.zend.com/license/new-bsd
  12  * If you did not receive a copy of the license and are unable to
  13  * obtain it through the world-wide-web, please send an email
  14  * to license@zend.com so we can send you a copy immediately.
  15  *
  16  * @category   Zend
  17  * @package    Zend_Http
  18  * @subpackage Client
  19  * @version    $Id: Client.php 8064 2008-02-16 10:58:39Z thomas $
  20  * @copyright  Copyright (c) 2005-2008 Zend Technologies USA Inc. (http://www.zend.com)
  21  * @license    http://framework.zend.com/license/new-bsd     New BSD License
  22  */
  23
  24 require_once 'external/Zend/Loader.php';
  25 require_once 'external/Zend/Uri.php';
  26 require_once 'external/Zend/Http/Client/Adapter/Interface.php';
  27 require_once 'external/Zend/Http/Response.php';
  28
  29 /**
  30  * Zend_Http_Client is an implemetation of an HTTP client in PHP. The client
  31  * supports basic features like sending different HTTP requests and handling
  32  * redirections, as well as more advanced features like proxy settings, HTTP
  33  * authentication and cookie persistance (using a Zend_Http_CookieJar object)
  34  *
  35  * @todo Implement proxy settings
  36  * @category   Zend
  37  * @package    Zend_Http
  38  * @subpackage Client
  39  * @throws     Zend_Http_Client_Exception
  40  * @copyright  Copyright (c) 2005-2008 Zend Technologies USA Inc. (http://www.zend.com)
  41  * @license    http://framework.zend.com/license/new-bsd     New BSD License
  42  */
  43 class Zend_Http_Client {
  44   /**
  45    * HTTP request methods
  46    */
  47   const GET = 'GET';
  48   const POST = 'POST';
  49   const PUT = 'PUT';
  50   const HEAD = 'HEAD';
  51   const DELETE = 'DELETE';
  52   const TRACE = 'TRACE';
  53   const OPTIONS = 'OPTIONS';
  54   const CONNECT = 'CONNECT';
  55
  56   /**
  57    * Supported HTTP Authentication methods
  58    */
  59   const AUTH_BASIC = 'basic';
  60   //const AUTH_DIGEST = 'digest'; <-- not implemented yet
  61
  62
  63   /**
  64    * HTTP protocol versions
  65    */
  66   const HTTP_1 = '1.1';
  67   const HTTP_0 = '1.0';
  68
  69   /**
  70    * POST data encoding methods
  71    */
  72   const ENC_URLENCODED = 'application/x-www-form-urlencoded';
  73   const ENC_FORMDATA = 'multipart/form-data';
  74
  75   /**
  76    * Configuration array, set using the constructor or using ::setConfig()
  77    *
  78    * @var unknown_type
  79    */
  80   protected $config = array('maxredirects' => 5, 'strictredirects' => false,
  81       'useragent' => 'Zend_Http_Client', 'timeout' => 10,
  82       'adapter' => 'Zend_Http_Client_Adapter_Socket', 'httpversion' => self::HTTP_1,
  83       'keepalive' => false, 'storeresponse' => true, 'strict' => true);
  84
  85   /**
  86    * The adapter used to preform the actual connection to the server
  87    *
  88    * @var Zend_Http_Client_Adapter_Interface
  89    */
  90   protected $adapter = null;
  91
  92   /**
  93    * Request URI
  94    *
  95    * @var Zend_Uri_Http
  96    */
  97   protected $uri;
  98
  99   /**
 100    * Associative array of request headers
 101    *
 102    * @var array
 103    */
 104   protected $headers = array();
 105
 106   /**
 107    * HTTP request method
 108    *
 109    * @var string
 110    */
 111   protected $method = self::GET;
 112
 113   /**
 114    * Associative array of GET parameters
 115    *
 116    * @var array
 117    */
 118   protected $paramsGet = array();
 119
 120   /**
 121    * Assiciative array of POST parameters
 122    *
 123    * @var array
 124    */
 125   protected $paramsPost = array();
 126
 127   /**
 128    * Request body content type (for POST requests)
 129    *
 130    * @var string
 131    */
 132   protected $enctype = null;
 133
 134   /**
 135    * The raw post data to send. Could be set by setRawData($data, $enctype).
 136    *
 137    * @var string
 138    */
 139   protected $raw_post_data = null;
 140
 141   /**
 142    * HTTP Authentication settings
 143    *
 144    * Expected to be an associative array with this structure:
 145    * $this->auth = array('user' => 'username', 'password' => 'password', 'type' => 'basic')
 146    * Where 'type' should be one of the supported authentication types (see the AUTH_*
 147    * constants), for example 'basic' or 'digest'.
 148    *
 149    * If null, no authentication will be used.
 150    *
 151    * @var array|null
 152    */
 153   protected $auth;
 154
 155   /**
 156    * File upload arrays (used in POST requests)
 157    *
 158    * An associative array, where each element is of the format:
 159    *   'name' => array('filename.txt', 'text/plain', 'This is the actual file contents')
 160    *
 161    * @var array
 162    */
 163   protected $files = array();
 164
 165   /**
 166    * The client's cookie jar
 167    *
 168    * @var Zend_Http_CookieJar
 169    */
 170   protected $cookiejar = null;
 171
 172   /**
 173    * The last HTTP request sent by the client, as string
 174    *
 175    * @var string
 176    */
 177   protected $last_request = null;
 178
 179   /**
 180    * The last HTTP response received by the client
 181    *
 182    * @var Zend_Http_Response
 183    */
 184   protected $last_response = null;
 185
 186   /**
 187    * Redirection counter
 188    *
 189    * @var int
 190    */
 191   protected $redirectCounter = 0;
 192
 193   /**
 194    * Contructor method. Will create a new HTTP client. Accepts the target
 195    * URL and optionally and array of headers.
 196    *
 197    * @param Zend_Uri_Http|string $uri
 198    * @param array $headers Optional request headers to set
 199    */
 200   public function __construct($uri = null, $config = null) {
 201     if ($uri !== null) $this->setUri($uri);
 202     if ($config !== null) $this->setConfig($config);
 203   }
 204
 205   /**
 206    * Set the URI for the next request
 207    *
 208    * @param  Zend_Uri_Http|string $uri
 209    * @return Zend_Http_Client
 210    * @throws Zend_Http_Client_Exception
 211    */
 212   public function setUri($uri) {
 213     if (is_string($uri)) {
 214       $uri = Zend_Uri::factory($uri);
 215     }
 216
 217     if (! $uri instanceof Zend_Uri_Http) {
 218       require_once 'external/Zend/Http/Client/Exception.php';
 219       throw new Zend_Http_Client_Exception('Passed parameter is not a valid HTTP URI.');
 220     }
 221
 222     // We have no ports, set the defaults
 223     if (! $uri->getPort()) {
 224       $uri->setPort(($uri->getScheme() == 'https' ? 443 : 80));
 225     }
 226
 227     $this->uri = $uri;
 228
 229     return $this;
 230   }
 231
 232   /**
 233    * Get the URI for the next request
 234    *
 235    * @param boolean $as_string If true, will return the URI as a string
 236    * @return Zend_Uri_Http|string
 237    */
 238   public function getUri($as_string = false) {
 239     if ($as_string && $this->uri instanceof Zend_Uri_Http) {
 240       return $this->uri->__toString();
 241     } else {
 242       return $this->uri;
 243     }
 244   }
 245
 246   /**
 247    * Set configuration parameters for this HTTP client
 248    *
 249    * @param array $config
 250    * @return Zend_Http_Client
 251    */
 252   public function setConfig($config = array()) {
 253     if (! is_array($config)) {
 254       require_once 'external/Zend/Http/Client/Exception.php';
 255       throw new Zend_Http_Client_Exception('Expected array parameter, given ' . gettype($config));
 256     }
 257
 258     foreach ($config as $k => $v)
 259       $this->config[strtolower($k)] = $v;
 260
 261     return $this;
 262   }
 263
 264   /**
 265    * Set the next request's method
 266    *
 267    * Validated the passed method and sets it. If we have files set for
 268    * POST requests, and the new method is not POST, the files are silently
 269    * dropped.
 270    *
 271    * @param string $method
 272    * @return Zend_Http_Client
 273    */
 274   public function setMethod($method = self::GET) {
 275     if (! preg_match('/^[A-Za-z_]+$/', $method)) {
 276       require_once 'external/Zend/Http/Client/Exception.php';
 277       throw new Zend_Http_Client_Exception("'{$method}' is not a valid HTTP request method.");
 278     }
 279
 280     if ($method == self::POST && $this->enctype === null) $this->setEncType(self::ENC_URLENCODED);
 281
 282     $this->method = $method;
 283
 284     return $this;
 285   }
 286
 287   /**
 288    * Set one or more request headers
 289    *
 290    * This function can be used in several ways to set the client's request
 291    * headers:
 292    * 1. By providing two parameters: $name as the header to set (eg. 'Host')
 293    *    and $value as it's value (eg. 'www.example.com').
 294    * 2. By providing a single header string as the only parameter
 295    *    eg. 'Host: www.example.com'
 296    * 3. By providing an array of headers as the first parameter
 297    *    eg. array('host' => 'www.example.com', 'x-foo: bar'). In This case
 298    *    the function will call itself recursively for each array item.
 299    *
 300    * @param string|array $name Header name, full header string ('Header: value')
 301    *     or an array of headers
 302    * @param mixed $value Header value or null
 303    * @return Zend_Http_Client
 304    */
 305   public function setHeaders($name, $value = null) {
 306     // If we got an array, go recusive!
 307     if (is_array($name)) {
 308       foreach ($name as $k => $v) {
 309         if (is_string($k)) {
 310           $this->setHeaders($k, $v);
 311         } else {
 312           $this->setHeaders($v, null);
 313         }
 314       }
 315     } else {
 316       // Check if $name needs to be split
 317       if ($value === null && (strpos($name, ':') > 0)) list($name, $value) = explode(':', $name, 2);
 318
 319       // Make sure the name is valid if we are in strict mode
 320       if ($this->config['strict'] && (! preg_match('/^[a-zA-Z0-9-]+$/', $name))) {
 321         require_once 'external/Zend/Http/Client/Exception.php';
 322         throw new Zend_Http_Client_Exception("{$name} is not a valid HTTP header name");
 323       }
 324
 325       $normalized_name = strtolower($name);
 326
 327       // If $value is null or false, unset the header
 328       if ($value === null || $value === false) {
 329         unset($this->headers[$normalized_name]);
 330
 331       // Else, set the header
 332       } else {
 333         // Header names are storred lowercase internally.
 334         if (is_string($value)) $value = trim($value);
 335         $this->headers[$normalized_name] = array($name, $value);
 336       }
 337     }
 338
 339     return $this;
 340   }
 341
 342   /**
 343    * Get the value of a specific header
 344    *
 345    * Note that if the header has more than one value, an array
 346    * will be returned.
 347    *
 348    * @param unknown_type $key
 349    * @return string|array|null The header value or null if it is not set
 350    */
 351   public function getHeader($key) {
 352     $key = strtolower($key);
 353     if (isset($this->headers[$key])) {
 354       return $this->headers[$key][1];
 355     } else {
 356       return null;
 357     }
 358   }
 359
 360   /**
 361    * Set a GET parameter for the request. Wrapper around _setParameter
 362    *
 363    * @param string|array $name
 364    * @param string $value
 365    * @return Zend_Http_Client
 366    */
 367   public function setParameterGet($name, $value = null) {
 368     if (is_array($name)) {
 369       foreach ($name as $k => $v)
 370         $this->_setParameter('GET', $k, $v);
 371     } else {
 372       $this->_setParameter('GET', $name, $value);
 373     }
 374
 375     return $this;
 376   }
 377
 378   /**
 379    * Set a POST parameter for the request. Wrapper around _setParameter
 380    *
 381    * @param string|array $name
 382    * @param string $value
 383    * @return Zend_Http_Client
 384    */
 385   public function setParameterPost($name, $value = null) {
 386     if (is_array($name)) {
 387       foreach ($name as $k => $v)
 388         $this->_setParameter('POST', $k, $v);
 389     } else {
 390       $this->_setParameter('POST', $name, $value);
 391     }
 392
 393     return $this;
 394   }
 395
 396   /**
 397    * Set a GET or POST parameter - used by SetParameterGet and SetParameterPost
 398    *
 399    * @param string $type GET or POST
 400    * @param string $name
 401    * @param string $value
 402    */
 403   protected function _setParameter($type, $name, $value) {
 404     $parray = array();
 405     $type = strtolower($type);
 406     switch ($type) {
 407       case 'get':
 408         $parray = &$this->paramsGet;
 409         break;
 410       case 'post':
 411         $parray = &$this->paramsPost;
 412         break;
 413     }
 414
 415     if ($value === null) {
 416       if (isset($parray[$name])) unset($parray[$name]);
 417     } else {
 418       $parray[$name] = $value;
 419     }
 420   }
 421
 422   /**
 423    * Get the number of redirections done on the last request
 424    *
 425    * @return int
 426    */
 427   public function getRedirectionsCount() {
 428     return $this->redirectCounter;
 429   }
 430
 431   /**
 432    * Set HTTP authentication parameters
 433    *
 434    * $type should be one of the supported types - see the self::AUTH_*
 435    * constants.
 436    *
 437    * To enable authentication:
 438    * <code>
 439    * $this->setAuth('shahar', 'secret', Zend_Http_Client::AUTH_BASIC);
 440    * </code>
 441    *
 442    * To disable authentication:
 443    * <code>
 444    * $this->setAuth(false);
 445    * </code>
 446    *
 447    * @see http://www.faqs.org/rfcs/rfc2617.html
 448    * @param string|false $user User name or false disable authentication
 449    * @param string $password Password
 450    * @param string $type Authentication type
 451    * @return Zend_Http_Client
 452    */
 453   public function setAuth($user, $password = '', $type = self::AUTH_BASIC) {
 454     // If we got false or null, disable authentication
 455     if ($user === false || $user === null) {
 456       $this->auth = null;
 457
 458     // Else, set up authentication
 459     } else {
 460       // Check we got a proper authentication type
 461       if (! defined('self::AUTH_' . strtoupper($type))) {
 462         require_once 'external/Zend/Http/Client/Exception.php';
 463         throw new Zend_Http_Client_Exception("Invalid or not supported authentication type: '$type'");
 464       }
 465
 466       $this->auth = array('user' => (string)$user, 'password' => (string)$password,
 467           'type' => $type);
 468     }
 469
 470     return $this;
 471   }
 472
 473   /**
 474    * Set the HTTP client's cookie jar.
 475    *
 476    * A cookie jar is an object that holds and maintains cookies across HTTP requests
 477    * and responses.
 478    *
 479    * @param Zend_Http_CookieJar|boolean $cookiejar Existing cookiejar object, true to create a new one, false to disable
 480    * @return Zend_Http_Client
 481    */
 482   public function setCookieJar($cookiejar = true) {
 483     if (! class_exists('Zend_Http_CookieJar')) require_once 'external/Zend/Http/CookieJar.php';
 484
 485     if ($cookiejar instanceof Zend_Http_CookieJar) {
 486       $this->cookiejar = $cookiejar;
 487     } elseif ($cookiejar === true) {
 488       $this->cookiejar = new Zend_Http_CookieJar();
 489     } elseif (! $cookiejar) {
 490       $this->cookiejar = null;
 491     } else {
 492       require_once 'external/Zend/Http/Client/Exception.php';
 493       throw new Zend_Http_Client_Exception('Invalid parameter type passed as CookieJar');
 494     }
 495
 496     return $this;
 497   }
 498
 499   /**
 500    * Return the current cookie jar or null if none.
 501    *
 502    * @return Zend_Http_CookieJar|null
 503    */
 504   public function getCookieJar() {
 505     return $this->cookiejar;
 506   }
 507
 508   /**
 509    * Add a cookie to the request. If the client has no Cookie Jar, the cookies
 510    * will be added directly to the headers array as "Cookie" headers.
 511    *
 512    * @param Zend_Http_Cookie|string $cookie
 513    * @param string|null $value If "cookie" is a string, this is the cookie value.
 514    * @return Zend_Http_Client
 515    */
 516   public function setCookie($cookie, $value = null) {
 517     if (! class_exists('Zend_Http_Cookie')) require_once 'external/Zend/Http/Cookie.php';
 518
 519     if (is_array($cookie)) {
 520       foreach ($cookie as $c => $v) {
 521         if (is_string($c)) {
 522           $this->setCookie($c, $v);
 523         } else {
 524           $this->setCookie($v);
 525         }
 526       }
 527
 528       return $this;
 529     }
 530
 531     if ($value !== null) $value = urlencode($value);
 532
 533     if (isset($this->cookiejar)) {
 534       if ($cookie instanceof Zend_Http_Cookie) {
 535         $this->cookiejar->addCookie($cookie);
 536       } elseif (is_string($cookie) && $value !== null) {
 537         $cookie = Zend_Http_Cookie::fromString("{$cookie}={$value}", $this->uri);
 538         $this->cookiejar->addCookie($cookie);
 539       }
 540     } else {
 541       if ($cookie instanceof Zend_Http_Cookie) {
 542         $name = $cookie->getName();
 543         $value = $cookie->getValue();
 544         $cookie = $name;
 545       }
 546
 547       if (preg_match("/[=,; \t\r\n\013\014]/", $cookie)) {
 548         require_once 'external/Zend/Http/Client/Exception.php';
 549         throw new Zend_Http_Client_Exception("Cookie name cannot contain these characters: =,; \t\r\n\013\014 ({$cookie})");
 550       }
 551
 552       $value = addslashes($value);
 553
 554       if (! isset($this->headers['cookie'])) $this->headers['cookie'] = array('Cookie', '');
 555       $this->headers['cookie'][1] .= $cookie . '=' . $value . '; ';
 556     }
 557
 558     return $this;
 559   }
 560
 561   /**
 562    * Set a file to upload (using a POST request)
 563    *
 564    * Can be used in two ways:
 565    *
 566    * 1. $data is null (default): $filename is treated as the name if a local file which
 567    *    will be read and sent. Will try to guess the content type using mime_content_type().
 568    * 2. $data is set - $filename is sent as the file name, but $data is sent as the file
 569    *    contents and no file is read from the file system. In this case, you need to
 570    *    manually set the content-type ($ctype) or it will default to
 571    *    application/octet-stream.
 572    *
 573    * @param string $filename Name of file to upload, or name to save as
 574    * @param string $formname Name of form element to send as
 575    * @param string $data Data to send (if null, $filename is read and sent)
 576    * @param string $ctype Content type to use (if $data is set and $ctype is
 577    *     null, will be application/octet-stream)
 578    * @return Zend_Http_Client
 579    */
 580   public function setFileUpload($filename, $formname, $data = null, $ctype = null) {
 581     if ($data === null) {
 582       if (($data = @file_get_contents($filename)) === false) {
 583         require_once 'external/Zend/Http/Client/Exception.php';
 584         throw new Zend_Http_Client_Exception("Unable to read file '{$filename}' for upload");
 585       }
 586
 587       if (! $ctype && function_exists('mime_content_type')) $ctype = mime_content_type($filename);
 588     }
 589
 590     // Force enctype to multipart/form-data
 591     $this->setEncType(self::ENC_FORMDATA);
 592
 593     if ($ctype === null) $ctype = 'application/octet-stream';
 594     $this->files[$formname] = array(basename($filename), $ctype, $data);
 595
 596     return $this;
 597   }
 598
 599   /**
 600    * Set the encoding type for POST data
 601    *
 602    * @param string $enctype
 603    * @return Zend_Http_Client
 604    */
 605   public function setEncType($enctype = self::ENC_URLENCODED) {
 606     $this->enctype = $enctype;
 607
 608     return $this;
 609   }
 610
 611   /**
 612    * Set the raw (already encoded) POST data.
 613    *
 614    * This function is here for two reasons:
 615    * 1. For advanced user who would like to set their own data, already encoded
 616    * 2. For backwards compatibilty: If someone uses the old post($data) method.
 617    *    this method will be used to set the encoded data.
 618    *
 619    * @param string $data
 620    * @param string $enctype
 621    * @return Zend_Http_Client
 622    */
 623   public function setRawData($data, $enctype = null) {
 624     $this->raw_post_data = $data;
 625     $this->setEncType($enctype);
 626
 627     return $this;
 628   }
 629
 630   /**
 631    * Clear all GET and POST parameters
 632    *
 633    * Should be used to reset the request parameters if the client is
 634    * used for several concurrent requests.
 635    *
 636    * @return Zend_Http_Client
 637    */
 638   public function resetParameters() {
 639     // Reset parameter data
 640     $this->paramsGet = array();
 641     $this->paramsPost = array();
 642     $this->files = array();
 643     $this->raw_post_data = null;
 644
 645     // Clear outdated headers
 646     if (isset($this->headers['content-type'])) unset($this->headers['content-type']);
 647     if (isset($this->headers['content-length'])) unset($this->headers['content-length']);
 648
 649     return $this;
 650   }
 651
 652   /**
 653    * Get the last HTTP request as string
 654    *
 655    * @return string
 656    */
 657   public function getLastRequest() {
 658     return $this->last_request;
 659   }
 660
 661   /**
 662    * Get the last HTTP response received by this client
 663    *
 664    * If $config['storeresponse'] is set to false, or no response was
 665    * stored yet, will return null
 666    *
 667    * @return Zend_Http_Response or null if none
 668    */
 669   public function getLastResponse() {
 670     return $this->last_response;
 671   }
 672
 673   /**
 674    * Load the connection adapter
 675    *
 676    * While this method is not called more than one for a client, it is
 677    * seperated from ->request() to preserve logic and readability
 678    *
 679    * @param Zend_Http_Client_Adapter_Interface|string $adapter
 680    */
 681   public function setAdapter($adapter) {
 682     if (is_string($adapter)) {
 683       try {
 684         Zend_Loader::loadClass($adapter);
 685       } catch (Zend_Exception $e) {
 686         require_once 'external/Zend/Http/Client/Exception.php';
 687         throw new Zend_Http_Client_Exception("Unable to load adapter '$adapter': {$e->getMessage()}");
 688       }
 689
 690       $adapter = new $adapter();
 691     }
 692
 693     if (! $adapter instanceof Zend_Http_Client_Adapter_Interface) {
 694       require_once 'external/Zend/Http/Client/Exception.php';
 695       throw new Zend_Http_Client_Exception('Passed adapter is not a HTTP connection adapter');
 696     }
 697
 698     $this->adapter = $adapter;
 699     $config = $this->config;
 700     unset($config['adapter']);
 701     $this->adapter->setConfig($config);
 702   }
 703
 704   /**
 705    * Send the HTTP request and return an HTTP response object
 706    *
 707    * @param string $method
 708    * @return Zend_Http_Response
 709    */
 710   public function request($method = null) {
 711     if (! $this->uri instanceof Zend_Uri_Http) {
 712       require_once 'external/Zend/Http/Client/Exception.php';
 713       throw new Zend_Http_Client_Exception('No valid URI has been passed to the client');
 714     }
 715
 716     if ($method) $this->setMethod($method);
 717     $this->redirectCounter = 0;
 718     $response = null;
 719
 720     // Make sure the adapter is loaded
 721     if ($this->adapter == null) $this->setAdapter($this->config['adapter']);
 722
 723     // Send the first request. If redirected, continue.
 724     do {
 725       // Clone the URI and add the additional GET parameters to it
 726       $uri = clone $this->uri;
 727       if (! empty($this->paramsGet)) {
 728         $query = $uri->getQuery();
 729         if (! empty($query)) $query .= '&';
 730         $query .= http_build_query($this->paramsGet, null, '&');
 731
 732         $uri->setQuery($query);
 733       }
 734
 735       $body = $this->prepare_body();
 736       $headers = $this->prepare_headers();
 737
 738       // Open the connection, send the request and read the response
 739       $this->adapter->connect($uri->getHost(), $uri->getPort(), ($uri->getScheme() == 'https' ? true : false));
 740
 741       $this->last_request = $this->adapter->write($this->method, $uri, $this->config['httpversion'], $headers, $body);
 742
 743       $response = $this->adapter->read();
 744       if (! $response) {
 745         require_once 'external/Zend/Http/Client/Exception.php';
 746         throw new Zend_Http_Client_Exception('Unable to read response, or response is empty');
 747       }
 748
 749       $response = Zend_Http_Response::fromString($response);
 750       if ($this->config['storeresponse']) $this->last_response = $response;
 751
 752       // Load cookies into cookie jar
 753       if (isset($this->cookiejar)) $this->cookiejar->addCookiesFromResponse($response, $uri);
 754
 755       // If we got redirected, look for the Location header
 756       if ($response->isRedirect() && ($location = $response->getHeader('location'))) {
 757
 758         // Check whether we send the exact same request again, or drop the parameters
 759         // and send a GET request
 760         if ($response->getStatus() == 303 || ((! $this->config['strictredirects']) && ($response->getStatus() == 302 || $response->getStatus() == 301))) {
 761
 762           $this->resetParameters();
 763           $this->setMethod(self::GET);
 764         }
 765
 766         // If we got a well formed absolute URI
 767         if (Zend_Uri_Http::check($location)) {
 768           $this->setHeaders('host', null);
 769           $this->setUri($location);
 770
 771         } else {
 772
 773           // Split into path and query and set the query
 774           if (strpos($location, '?') !== false) {
 775             list($location, $query) = explode('?', $location, 2);
 776           } else {
 777             $query = '';
 778           }
 779           $this->uri->setQuery($query);
 780
 781           // Else, if we got just an absolute path, set it
 782           if (strpos($location, '/') === 0) {
 783             $this->uri->setPath($location);
 784
 785           // Else, assume we have a relative path
 786           } else {
 787             // Get the current path directory, removing any trailing slashes
 788             $path = $this->uri->getPath();
 789             $path = rtrim(substr($path, 0, strrpos($path, '/')), "/");
 790             $this->uri->setPath($path . '/' . $location);
 791           }
 792         }
 793         ++ $this->redirectCounter;
 794
 795       } else {
 796         // If we didn't get any location, stop redirecting
 797         break;
 798       }
 799
 800     } while ($this->redirectCounter < $this->config['maxredirects']);
 801
 802     return $response;
 803   }
 804
 805   /**
 806    * Prepare the request headers
 807    *
 808    * @return array
 809    */
 810   protected function prepare_headers() {
 811     $headers = array();
 812
 813     // Set the host header
 814     if (! isset($this->headers['host'])) {
 815       $host = $this->uri->getHost();
 816
 817       // If the port is not default, add it
 818       if (! (($this->uri->getScheme() == 'http' && $this->uri->getPort() == 80) || ($this->uri->getScheme() == 'https' && $this->uri->getPort() == 443))) {
 819         $host .= ':' . $this->uri->getPort();
 820       }
 821
 822       $headers[] = "Host: {$host}";
 823     }
 824
 825     // Set the connection header
 826     if (! isset($this->headers['connection'])) {
 827       if (! $this->config['keepalive']) $headers[] = "Connection: close";
 828     }
 829
 830     // Set the Accept-encoding header if not set - depending on whether
 831     // zlib is available or not.
 832     if (! isset($this->headers['accept-encoding'])) {
 833       if (function_exists('gzinflate')) {
 834         $headers[] = 'Accept-encoding: gzip, deflate';
 835       } else {
 836         $headers[] = 'Accept-encoding: identity';
 837       }
 838     }
 839
 840     // Set the content-type header
 841     if ($this->method == self::POST && (! isset($this->headers['content-type']) && isset($this->enctype))) {
 842
 843       $headers[] = "Content-type: {$this->enctype}";
 844     }
 845
 846     // Set the user agent header
 847     if (! isset($this->headers['user-agent']) && isset($this->config['useragent'])) {
 848       $headers[] = "User-agent: {$this->config['useragent']}";
 849     }
 850
 851     // Set HTTP authentication if needed
 852     if (is_array($this->auth)) {
 853       $auth = self::encodeAuthHeader($this->auth['user'], $this->auth['password'], $this->auth['type']);
 854       $headers[] = "Authorization: {$auth}";
 855     }
 856
 857     // Load cookies from cookie jar
 858     if (isset($this->cookiejar)) {
 859       $cookstr = $this->cookiejar->getMatchingCookies($this->uri, true, Zend_Http_CookieJar::COOKIE_STRING_CONCAT);
 860
 861       if ($cookstr) $headers[] = "Cookie: {$cookstr}";
 862     }
 863
 864     // Add all other user defined headers
 865     foreach ($this->headers as $header) {
 866       list($name, $value) = $header;
 867       if (is_array($value)) $value = implode(', ', $value);
 868
 869       $headers[] = "$name: $value";
 870     }
 871
 872     return $headers;
 873   }
 874
 875   /**
 876    * Prepare the request body (for POST and PUT requests)
 877    *
 878    * @return string
 879    */
 880   protected function prepare_body() {
 881     // According to RFC2616, a TRACE request should not have a body.
 882     if ($this->method == self::TRACE) {
 883       return '';
 884     }
 885
 886     // If we have raw_post_data set, just use it as the body.
 887     if (isset($this->raw_post_data)) {
 888       $this->setHeaders('Content-length', strlen($this->raw_post_data));
 889       return $this->raw_post_data;
 890     }
 891
 892     $body = '';
 893
 894     // If we have files to upload, force enctype to multipart/form-data
 895     if (count($this->files) > 0) $this->setEncType(self::ENC_FORMDATA);
 896
 897     // If we have POST parameters or files, encode and add them to the body
 898     if (count($this->paramsPost) > 0 || count($this->files) > 0) {
 899       switch ($this->enctype) {
 900         case self::ENC_FORMDATA:
 901           // Encode body as multipart/form-data
 902           $boundary = '---ZENDHTTPCLIENT-' . md5(microtime());
 903           $this->setHeaders('Content-type', self::ENC_FORMDATA . "; boundary={$boundary}");
 904
 905           // Get POST parameters and encode them
 906           $params = $this->_getParametersRecursive($this->paramsPost);
 907           foreach ($params as $pp) {
 908             $body .= self::encodeFormData($boundary, $pp[0], $pp[1]);
 909           }
 910
 911           // Encode files
 912           foreach ($this->files as $name => $file) {
 913             $fhead = array('Content-type' => $file[1]);
 914             $body .= self::encodeFormData($boundary, $name, $file[2], $file[0], $fhead);
 915           }
 916
 917           $body .= "--{$boundary}--\r\n";
 918           break;
 919
 920         case self::ENC_URLENCODED:
 921           // Encode body as application/x-www-form-urlencoded
 922           $this->setHeaders('Content-type', self::ENC_URLENCODED);
 923           $body = http_build_query($this->paramsPost, '', '&');
 924           break;
 925
 926         default:
 927           require_once 'external/Zend/Http/Client/Exception.php';
 928           throw new Zend_Http_Client_Exception("Cannot handle content type '{$this->enctype}' automatically." . " Please use Zend_Http_Client::setRawData to send this kind of content.");
 929           break;
 930       }
 931     }
 932
 933     if ($body) $this->setHeaders('Content-length', strlen($body));
 934     return $body;
 935   }
 936
 937   /**
 938    * Helper method that gets a possibly multi-level parameters array (get or
 939    * post) and flattens it.
 940    *
 941    * The method returns an array of (key, value) pairs (because keys are not
 942    * necessarily unique. If one of the parameters in as array, it will also
 943    * add a [] suffix to the key.
 944    *
 945    * @param array $parray The parameters array
 946    * @param bool $urlencode Whether to urlencode the name and value
 947    * @return array
 948    */
 949   protected function _getParametersRecursive($parray, $urlencode = false) {
 950     if (! is_array($parray)) return $parray;
 951     $parameters = array();
 952
 953     foreach ($parray as $name => $value) {
 954       if ($urlencode) $name = urlencode($name);
 955
 956       // If $value is an array, iterate over it
 957       if (is_array($value)) {
 958         $name .= ($urlencode ? '%5B%5D' : '[]');
 959         foreach ($value as $subval) {
 960           if ($urlencode) $subval = urlencode($subval);
 961           $parameters[] = array($name, $subval);
 962         }
 963       } else {
 964         if ($urlencode) $value = urlencode($value);
 965         $parameters[] = array($name, $value);
 966       }
 967     }
 968
 969     return $parameters;
 970   }
 971
 972   /**
 973    * Encode data to a multipart/form-data part suitable for a POST request.
 974    *
 975    * @param string $boundary
 976    * @param string $name
 977    * @param mixed $value
 978    * @param string $filename
 979    * @param array $headers Associative array of optional headers @example ("Content-transfer-encoding" => "binary")
 980    * @return string
 981    */
 982   public static function encodeFormData($boundary, $name, $value, $filename = null, $headers = array()) {
 983     $ret = "--{$boundary}\r\n" . 'Content-disposition: form-data; name="' . $name . '"';
 984
 985     if ($filename) $ret .= '; filename="' . $filename . '"';
 986     $ret .= "\r\n";
 987
 988     foreach ($headers as $hname => $hvalue) {
 989       $ret .= "{$hname}: {$hvalue}\r\n";
 990     }
 991     $ret .= "\r\n";
 992
 993     $ret .= "{$value}\r\n";
 994
 995     return $ret;
 996   }
 997
 998   /**
 999    * Create a HTTP authentication "Authorization:" header according to the
1000    * specified user, password and authentication method.
1001    *
1002    * @see http://www.faqs.org/rfcs/rfc2617.html
1003    * @param string $user
1004    * @param string $password
1005    * @param string $type
1006    * @return string
1007    */
1008   public static function encodeAuthHeader($user, $password, $type = self::AUTH_BASIC) {
1009     $authHeader = null;
1010
1011     switch ($type) {
1012       case self::AUTH_BASIC:
1013         // In basic authentication, the user name cannot contain ":"
1014         if (strpos($user, ':') !== false) {
1015           require_once 'external/Zend/Http/Client/Exception.php';
1016           throw new Zend_Http_Client_Exception("The user name cannot contain ':' in 'Basic' HTTP authentication");
1017         }
1018
1019         $authHeader = 'Basic ' . base64_encode($user . ':' . $password);
1020         break;
1021
1022       //case self::AUTH_DIGEST:
1023       /**
1024        * @todo Implement digest authentication
1025        */
1026       //    break;
1027
1028
1029       default:
1030         require_once 'external/Zend/Http/Client/Exception.php';
1031         throw new Zend_Http_Client_Exception("Not a supported HTTP authentication type: '$type'");
1032     }
1033
1034     return $authHeader;
1035   }
1036 }