[Summary view] [Print] [Text view]

   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 [email protected] so we can send you a copy immediately.
  15   *
  16   * @category   Zend
  17   * @package    Zend_Http
  18   * @subpackage Client
  19   * @version    $Id: Client.php 24593 2012-01-05 20:35:02Z matthew $
  20   * @copyright  Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)
  21   * @license    http://framework.zend.com/license/new-bsd     New BSD License
  22   */
  23  
  24  /**
  25   * @see Zend_Loader
  26   */
  27  require_once  'Zend/Loader.php';
  28  
  29  
  30  /**
  31   * @see Zend_Uri
  32   */
  33  require_once  'Zend/Uri.php';
  34  
  35  
  36  /**
  37   * @see Zend_Http_Client_Adapter_Interface
  38   */
  39  require_once  'Zend/Http/Client/Adapter/Interface.php';
  40  
  41  
  42  /**
  43   * @see Zend_Http_Response
  44   */
  45  require_once  'Zend/Http/Response.php';
  46  
  47  /**
  48   * @see Zend_Http_Response_Stream
  49   */
  50  require_once  'Zend/Http/Response/Stream.php';
  51  
  52  /**
  53   * Zend_Http_Client is an implementation of an HTTP client in PHP. The client
  54   * supports basic features like sending different HTTP requests and handling
  55   * redirections, as well as more advanced features like proxy settings, HTTP
  56   * authentication and cookie persistence (using a Zend_Http_CookieJar object)
  57   *
  58   * @todo Implement proxy settings
  59   * @category   Zend
  60   * @package    Zend_Http
  61   * @subpackage Client
  62   * @throws     Zend_Http_Client_Exception
  63   * @copyright  Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)
  64   * @license    http://framework.zend.com/license/new-bsd     New BSD License
  65   */
  66  class Zend_Http_Client
  67  {
  68      /**
  69       * HTTP request methods
  70       */
  71      const GET     = 'GET';
  72      const POST    = 'POST';
  73      const PUT     = 'PUT';
  74      const HEAD    = 'HEAD';
  75      const DELETE  = 'DELETE';
  76      const TRACE   = 'TRACE';
  77      const OPTIONS = 'OPTIONS';
  78      const CONNECT = 'CONNECT';
  79      const MERGE   = 'MERGE';
  80  
  81      /**
  82       * Supported HTTP Authentication methods
  83       */
  84      const AUTH_BASIC = 'basic';
  85      //const AUTH_DIGEST = 'digest'; <-- not implemented yet
  86  
  87      /**
  88       * HTTP protocol versions
  89       */
  90      const HTTP_1 = '1.1';
  91      const HTTP_0 = '1.0';
  92  
  93      /**
  94       * Content attributes
  95       */
  96      const CONTENT_TYPE   = 'Content-Type';
  97      const CONTENT_LENGTH = 'Content-Length';
  98  
  99      /**
 100       * POST data encoding methods
 101       */
 102      const ENC_URLENCODED = 'application/x-www-form-urlencoded';
 103      const ENC_FORMDATA   = 'multipart/form-data';
 104  
 105      /**
 106       * Value types for Body key/value pairs
 107       */
 108      const VTYPE_SCALAR  = 'SCALAR';
 109      const VTYPE_FILE    = 'FILE';
 110  
 111      /**
 112       * Configuration array, set using the constructor or using ::setConfig()
 113       *
 114       * @var array
 115       */
 116      protected $config = array(
 117          'maxredirects'    => 5,
 118          'strictredirects' => false,
 119          'useragent'       => 'Zend_Http_Client',
 120          'timeout'         => 10,
 121          'adapter'         => 'Zend_Http_Client_Adapter_Socket',
 122          'httpversion'     => self::HTTP_1,
 123          'keepalive'       => false,
 124          'storeresponse'   => true,
 125          'strict'          => true,
 126          'output_stream'   => false,
 127          'encodecookies'   => true,
 128          'rfc3986_strict'  => false
 129      );
 130  
 131      /**
 132       * The adapter used to perform the actual connection to the server
 133       *
 134       * @var Zend_Http_Client_Adapter_Interface
 135       */
 136      protected $adapter = null;
 137  
 138      /**
 139       * Request URI
 140       *
 141       * @var Zend_Uri_Http
 142       */
 143      protected $uri = null;
 144  
 145      /**
 146       * Associative array of request headers
 147       *
 148       * @var array
 149       */
 150      protected $headers = array();
 151  
 152      /**
 153       * HTTP request method
 154       *
 155       * @var string
 156       */
 157      protected $method = self::GET;
 158  
 159      /**
 160       * Associative array of GET parameters
 161       *
 162       * @var array
 163       */
 164      protected $paramsGet = array();
 165  
 166      /**
 167       * Associative array of POST parameters
 168       *
 169       * @var array
 170       */
 171      protected $paramsPost = array();
 172  
 173      /**
 174       * Request body content type (for POST requests)
 175       *
 176       * @var string
 177       */
 178      protected $enctype = null;
 179  
 180      /**
 181       * The raw post data to send. Could be set by setRawData($data, $enctype).
 182       *
 183       * @var string
 184       */
 185      protected $raw_post_data = null;
 186  
 187      /**
 188       * HTTP Authentication settings
 189       *
 190       * Expected to be an associative array with this structure:
 191       * $this->auth = array('user' => 'username', 'password' => 'password', 'type' => 'basic')
 192       * Where 'type' should be one of the supported authentication types (see the AUTH_*
 193       * constants), for example 'basic' or 'digest'.
 194       *
 195       * If null, no authentication will be used.
 196       *
 197       * @var array|null
 198       */
 199      protected $auth;
 200  
 201      /**
 202       * File upload arrays (used in POST requests)
 203       *
 204       * An associative array, where each element is of the format:
 205       *   'name' => array('filename.txt', 'text/plain', 'This is the actual file contents')
 206       *
 207       * @var array
 208       */
 209      protected $files = array();
 210  
 211      /**
 212       * Ordered list of keys from key/value pair data to include in body
 213       *
 214       * An associative array, where each element is of the format:
 215       *   '<field name>' => VTYPE_SCALAR | VTYPE_FILE
 216       *
 217       * @var array
 218       */
 219      protected $body_field_order = array();
 220  
 221      /**
 222       * The client's cookie jar
 223       *
 224       * @var Zend_Http_CookieJar
 225       */
 226      protected $cookiejar = null;
 227  
 228      /**
 229       * The last HTTP request sent by the client, as string
 230       *
 231       * @var string
 232       */
 233      protected $last_request = null;
 234  
 235      /**
 236       * The last HTTP response received by the client
 237       *
 238       * @var Zend_Http_Response
 239       */
 240      protected $last_response = null;
 241  
 242      /**
 243       * Redirection counter
 244       *
 245       * @var int
 246       */
 247      protected $redirectCounter = 0;
 248  
 249      /**
 250       * Status for unmasking GET array params
 251       *
 252       * @var boolean
 253       */
 254      protected $_unmaskStatus = false;
 255  
 256      /**
 257       * Status if the http_build_query function escapes brackets
 258       *
 259       * @var boolean
 260       */
 261      protected $_queryBracketsEscaped = true;
 262  
 263      /**
 264       * Fileinfo magic database resource
 265       *
 266       * This variable is populated the first time _detectFileMimeType is called
 267       * and is then reused on every call to this method
 268       *
 269       * @var resource
 270       */
 271      static protected $_fileInfoDb = null;
 272  
 273      /**
 274       * Constructor method. Will create a new HTTP client. Accepts the target
 275       * URL and optionally configuration array.
 276       *
 277       * @param Zend_Uri_Http|string $uri
 278       * @param array $config Configuration key-value pairs.
 279       */
 280      public function __construct($uri = null, $config = null)
 281      {
 282          if ($uri !== null) {
 283              $this->setUri($uri);
 284          }
 285          if ($config !== null) {
 286              $this->setConfig($config);
 287          }
 288  
 289          $this->_queryBracketsEscaped = version_compare(phpversion(), '5.1.3', '>=');
 290      }
 291  
 292      /**
 293       * Set the URI for the next request
 294       *
 295       * @param  Zend_Uri_Http|string $uri
 296       * @return Zend_Http_Client
 297       * @throws Zend_Http_Client_Exception
 298       */
 299      public function setUri($uri)
 300      {
 301          if ($uri instanceof Zend_Uri_Http) {
 302              // clone the URI in order to keep the passed parameter constant
 303              $uri = clone $uri;
 304          } elseif (is_string($uri)) {
 305              $uri = Zend_Uri::factory($uri);
 306          }
 307  
 308          if (!$uri instanceof Zend_Uri_Http) {
 309              /** @see Zend_Http_Client_Exception */
 310              require_once  'Zend/Http/Client/Exception.php';
 311              throw new Zend_Http_Client_Exception('Passed parameter is not a valid HTTP URI.');
 312          }
 313  
 314          // Set auth if username and password has been specified in the uri
 315          if ($uri->getUsername() && $uri->getPassword()) {
 316              $this->setAuth($uri->getUsername(), $uri->getPassword());
 317          }
 318  
 319          // We have no ports, set the defaults
 320          if (! $uri->getPort()) {
 321              $uri->setPort(($uri->getScheme() == 'https' ? 443 : 80));
 322          }
 323  
 324          $this->uri = $uri;
 325  
 326          return $this;
 327      }
 328  
 329      /**
 330       * Get the URI for the next request
 331       *
 332       * @param boolean $as_string If true, will return the URI as a string
 333       * @return Zend_Uri_Http|string
 334       */
 335      public function getUri($as_string = false)
 336      {
 337          if ($as_string && $this->uri instanceof Zend_Uri_Http) {
 338              return $this->uri->__toString();
 339          } else {
 340              return $this->uri;
 341          }
 342      }
 343  
 344      /**
 345       * Set configuration parameters for this HTTP client
 346       *
 347       * @param  Zend_Config | array $config
 348       * @return Zend_Http_Client
 349       * @throws Zend_Http_Client_Exception
 350       */
 351      public function setConfig($config = array())
 352      {
 353          if ($config instanceof Zend_Config) {
 354              $config = $config->toArray();
 355  
 356          } elseif (! is_array($config)) {
 357              /** @see Zend_Http_Client_Exception */
 358              require_once  'Zend/Http/Client/Exception.php';
 359              throw new Zend_Http_Client_Exception('Array or Zend_Config object expected, got ' . gettype($config));
 360          }
 361  
 362          foreach ($config as $k => $v) {
 363              $this->config[strtolower($k)] = $v;
 364          }
 365  
 366          // Pass configuration options to the adapter if it exists
 367          if ($this->adapter instanceof Zend_Http_Client_Adapter_Interface) {
 368              $this->adapter->setConfig($config);
 369          }
 370  
 371          return $this;
 372      }
 373  
 374      /**
 375       * Set the next request's method
 376       *
 377       * Validated the passed method and sets it. If we have files set for
 378       * POST requests, and the new method is not POST, the files are silently
 379       * dropped.
 380       *
 381       * @param string $method
 382       * @return Zend_Http_Client
 383       * @throws Zend_Http_Client_Exception
 384       */
 385      public function setMethod($method = self::GET)
 386      {
 387          if (! preg_match('/^[^\x00-\x1f\x7f-\xff\(\)<>@,;:\\\\"\/\[\]\?={}\s]+$/', $method)) {
 388              /** @see Zend_Http_Client_Exception */
 389              require_once  'Zend/Http/Client/Exception.php';
 390              throw new Zend_Http_Client_Exception("'{$method}' is not a valid HTTP request method.");
 391          }
 392  
 393          if (($method == self::POST || $method == self::PUT || $method == self::DELETE) && $this->enctype === null) {
 394              $this->setEncType(self::ENC_URLENCODED);
 395          }
 396  
 397          $this->method = $method;
 398  
 399          return $this;
 400      }
 401  
 402      /**
 403       * Set one or more request headers
 404       *
 405       * This function can be used in several ways to set the client's request
 406       * headers:
 407       * 1. By providing two parameters: $name as the header to set (e.g. 'Host')
 408       *    and $value as it's value (e.g. 'www.example.com').
 409       * 2. By providing a single header string as the only parameter
 410       *    e.g. 'Host: www.example.com'
 411       * 3. By providing an array of headers as the first parameter
 412       *    e.g. array('host' => 'www.example.com', 'x-foo: bar'). In This case
 413       *    the function will call itself recursively for each array item.
 414       *
 415       * @param string|array $name Header name, full header string ('Header: value')
 416       *     or an array of headers
 417       * @param mixed $value Header value or null
 418       * @return Zend_Http_Client
 419       * @throws Zend_Http_Client_Exception
 420       */
 421      public function setHeaders($name, $value = null)
 422      {
 423          // If we got an array, go recursive!
 424          if (is_array($name)) {
 425              foreach ($name as $k => $v) {
 426                  if (is_string($k)) {
 427                      $this->setHeaders($k, $v);
 428                  } else {
 429                      $this->setHeaders($v, null);
 430                  }
 431              }
 432          } else {
 433              // Check if $name needs to be split
 434              if ($value === null && (strpos($name, ':') > 0)) {
 435                  list($name, $value) = explode(':', $name, 2);
 436              }
 437  
 438              // Make sure the name is valid if we are in strict mode
 439              if ($this->config['strict'] && (! preg_match('/^[a-zA-Z0-9-]+$/', $name))) {
 440                  /** @see Zend_Http_Client_Exception */
 441                  require_once  'Zend/Http/Client/Exception.php';
 442                  throw new Zend_Http_Client_Exception("{$name} is not a valid HTTP header name");
 443              }
 444  
 445              $normalized_name = strtolower($name);
 446  
 447              // If $value is null or false, unset the header
 448              if ($value === null || $value === false) {
 449                  unset($this->headers[$normalized_name]);
 450  
 451              // Else, set the header
 452              } else {
 453                  // Header names are stored lowercase internally.
 454                  if (is_string($value)) {
 455                      $value = trim($value);
 456                  }
 457                  $this->headers[$normalized_name] = array($name, $value);
 458              }
 459          }
 460  
 461          return $this;
 462      }
 463  
 464      /**
 465       * Get the value of a specific header
 466       *
 467       * Note that if the header has more than one value, an array
 468       * will be returned.
 469       *
 470       * @param string $key
 471       * @return string|array|null The header value or null if it is not set
 472       */
 473      public function getHeader($key)
 474      {
 475          $key = strtolower($key);
 476          if (isset($this->headers[$key])) {
 477              return $this->headers[$key][1];
 478          } else {
 479              return null;
 480          }
 481      }
 482  
 483      /**
 484       * Set a GET parameter for the request. Wrapper around _setParameter
 485       *
 486       * @param string|array $name
 487       * @param string $value
 488       * @return Zend_Http_Client
 489       */
 490      public function setParameterGet($name, $value = null)
 491      {
 492          if (is_array($name)) {
 493              foreach ($name as $k => $v)
 494                  $this->_setParameter('GET', $k, $v);
 495          } else {
 496              $this->_setParameter('GET', $name, $value);
 497          }
 498  
 499          return $this;
 500      }
 501  
 502      /**
 503       * Set a POST parameter for the request. Wrapper around _setParameter
 504       *
 505       * @param string|array $name
 506       * @param string $value
 507       * @return Zend_Http_Client
 508       */
 509      public function setParameterPost($name, $value = null)
 510      {
 511          if (is_array($name)) {
 512              foreach ($name as $k => $v)
 513                  $this->_setParameter('POST', $k, $v);
 514          } else {
 515              $this->_setParameter('POST', $name, $value);
 516          }
 517  
 518          return $this;
 519      }
 520  
 521      /**
 522       * Set a GET or POST parameter - used by SetParameterGet and SetParameterPost
 523       *
 524       * @param string $type GET or POST
 525       * @param string $name
 526       * @param string $value
 527       * @return null
 528       */
 529      protected function _setParameter($type, $name, $value)
 530      {
 531          $parray = array();
 532          $type = strtolower($type);
 533          switch ($type) {
 534              case 'get':
 535                  $parray = &$this->paramsGet;
 536                  break;
 537              case 'post':
 538                  $parray = &$this->paramsPost;
 539                  if ( $value === null ) {
 540                      if (isset($this->body_field_order[$name]))
 541                          unset($this->body_field_order[$name]);
 542                  } else {
 543                      $this->body_field_order[$name] = self::VTYPE_SCALAR;
 544                  }
 545                  break;
 546          }
 547  
 548          if ($value === null) {
 549              if (isset($parray[$name])) unset($parray[$name]);
 550          } else {
 551              $parray[$name] = $value;
 552          }
 553      }
 554  
 555      /**
 556       * Get the number of redirections done on the last request
 557       *
 558       * @return int
 559       */
 560      public function getRedirectionsCount()
 561      {
 562          return $this->redirectCounter;
 563      }
 564  
 565      /**
 566       * Set HTTP authentication parameters
 567       *
 568       * $type should be one of the supported types - see the self::AUTH_*
 569       * constants.
 570       *
 571       * To enable authentication:
 572       * <code>
 573       * $this->setAuth('shahar', 'secret', Zend_Http_Client::AUTH_BASIC);
 574       * </code>
 575       *
 576       * To disable authentication:
 577       * <code>
 578       * $this->setAuth(false);
 579       * </code>
 580       *
 581       * @see http://www.faqs.org/rfcs/rfc2617.html
 582       * @param string|false $user User name or false disable authentication
 583       * @param string $password Password
 584       * @param string $type Authentication type
 585       * @return Zend_Http_Client
 586       * @throws Zend_Http_Client_Exception
 587       */
 588      public function setAuth($user, $password = '', $type = self::AUTH_BASIC)
 589      {
 590          // If we got false or null, disable authentication
 591          if ($user === false || $user === null) {
 592              $this->auth = null;
 593  
 594              // Clear the auth information in the uri instance as well
 595              if ($this->uri instanceof Zend_Uri_Http) {
 596                  $this->getUri()->setUsername('');
 597                  $this->getUri()->setPassword('');
 598              }
 599          // Else, set up authentication
 600          } else {
 601              // Check we got a proper authentication type
 602              if (! defined('self::AUTH_' . strtoupper($type))) {
 603                  /** @see Zend_Http_Client_Exception */
 604                  require_once  'Zend/Http/Client/Exception.php';
 605                  throw new Zend_Http_Client_Exception("Invalid or not supported authentication type: '$type'");
 606              }
 607  
 608              $this->auth = array(
 609                  'user' => (string) $user,
 610                  'password' => (string) $password,
 611                  'type' => $type
 612              );
 613          }
 614  
 615          return $this;
 616      }
 617  
 618      /**
 619       * Set the HTTP client's cookie jar.
 620       *
 621       * A cookie jar is an object that holds and maintains cookies across HTTP requests
 622       * and responses.
 623       *
 624       * @param Zend_Http_CookieJar|boolean $cookiejar Existing cookiejar object, true to create a new one, false to disable
 625       * @return Zend_Http_Client
 626       * @throws Zend_Http_Client_Exception
 627       */
 628      public function setCookieJar($cookiejar = true)
 629      {
 630          Zend_Loader::loadClass('Zend_Http_CookieJar');
 631  
 632          if ($cookiejar instanceof Zend_Http_CookieJar) {
 633              $this->cookiejar = $cookiejar;
 634          } elseif ($cookiejar === true) {
 635              $this->cookiejar = new Zend_Http_CookieJar();
 636          } elseif (! $cookiejar) {
 637              $this->cookiejar = null;
 638          } else {
 639              /** @see Zend_Http_Client_Exception */
 640              require_once  'Zend/Http/Client/Exception.php';
 641              throw new Zend_Http_Client_Exception('Invalid parameter type passed as CookieJar');
 642          }
 643  
 644          return $this;
 645      }
 646  
 647      /**
 648       * Return the current cookie jar or null if none.
 649       *
 650       * @return Zend_Http_CookieJar|null
 651       */
 652      public function getCookieJar()
 653      {
 654          return $this->cookiejar;
 655      }
 656  
 657      /**
 658       * Add a cookie to the request. If the client has no Cookie Jar, the cookies
 659       * will be added directly to the headers array as "Cookie" headers.
 660       *
 661       * @param Zend_Http_Cookie|string $cookie
 662       * @param string|null $value If "cookie" is a string, this is the cookie value.
 663       * @return Zend_Http_Client
 664       * @throws Zend_Http_Client_Exception
 665       */
 666      public function setCookie($cookie, $value = null)
 667      {
 668          Zend_Loader::loadClass('Zend_Http_Cookie');
 669  
 670          if (is_array($cookie)) {
 671              foreach ($cookie as $c => $v) {
 672                  if (is_string($c)) {
 673                      $this->setCookie($c, $v);
 674                  } else {
 675                      $this->setCookie($v);
 676                  }
 677              }
 678  
 679              return $this;
 680          }
 681  
 682          if ($value !== null && $this->config['encodecookies']) {
 683              $value = urlencode($value);
 684          }
 685  
 686          if (isset($this->cookiejar)) {
 687              if ($cookie instanceof Zend_Http_Cookie) {
 688                  $this->cookiejar->addCookie($cookie);
 689              } elseif (is_string($cookie) && $value !== null) {
 690                  $cookie = Zend_Http_Cookie::fromString("{$cookie}={$value}",
 691                                                         $this->uri,
 692                                                         $this->config['encodecookies']);
 693                  $this->cookiejar->addCookie($cookie);
 694              }
 695          } else {
 696              if ($cookie instanceof Zend_Http_Cookie) {
 697                  $name = $cookie->getName();
 698                  $value = $cookie->getValue();
 699                  $cookie = $name;
 700              }
 701  
 702              if (preg_match("/[=,; \t\r\n\013\014]/", $cookie)) {
 703                  /** @see Zend_Http_Client_Exception */
 704                  require_once  'Zend/Http/Client/Exception.php';
 705                  throw new Zend_Http_Client_Exception("Cookie name cannot contain these characters: =,; \t\r\n\013\014 ({$cookie})");
 706              }
 707  
 708              $value = addslashes($value);
 709  
 710              if (! isset($this->headers['cookie'])) {
 711                  $this->headers['cookie'] = array('Cookie', '');
 712              }
 713              $this->headers['cookie'][1] .= $cookie . '=' . $value . '; ';
 714          }
 715  
 716          return $this;
 717      }
 718  
 719      /**
 720       * Set a file to upload (using a POST request)
 721       *
 722       * Can be used in two ways:
 723       *
 724       * 1. $data is null (default): $filename is treated as the name if a local file which
 725       *    will be read and sent. Will try to guess the content type using mime_content_type().
 726       * 2. $data is set - $filename is sent as the file name, but $data is sent as the file
 727       *    contents and no file is read from the file system. In this case, you need to
 728       *    manually set the Content-Type ($ctype) or it will default to
 729       *    application/octet-stream.
 730       *
 731       * @param string $filename Name of file to upload, or name to save as
 732       * @param string $formname Name of form element to send as
 733       * @param string $data Data to send (if null, $filename is read and sent)
 734       * @param string $ctype Content type to use (if $data is set and $ctype is
 735       *     null, will be application/octet-stream)
 736       * @return Zend_Http_Client
 737       * @throws Zend_Http_Client_Exception
 738       */
 739      public function setFileUpload($filename, $formname, $data = null, $ctype = null)
 740      {
 741          if ($data === null) {
 742              if (($data = @file_get_contents($filename)) === false) {
 743                  /** @see Zend_Http_Client_Exception */
 744                  require_once  'Zend/Http/Client/Exception.php';
 745                  throw new Zend_Http_Client_Exception("Unable to read file '{$filename}' for upload");
 746              }
 747  
 748              if (! $ctype) {
 749                  $ctype = $this->_detectFileMimeType($filename);
 750              }
 751          }
 752  
 753          // Force enctype to multipart/form-data
 754          $this->setEncType(self::ENC_FORMDATA);
 755  
 756          $this->files[] = array(
 757              'formname' => $formname,
 758              'filename' => basename($filename),
 759              'ctype'    => $ctype,
 760              'data'     => $data
 761          );
 762          
 763          $this->body_field_order[$formname] = self::VTYPE_FILE;
 764  
 765          return $this;
 766      }
 767  
 768      /**
 769       * Set the encoding type for POST data
 770       *
 771       * @param string $enctype
 772       * @return Zend_Http_Client
 773       */
 774      public function setEncType($enctype = self::ENC_URLENCODED)
 775      {
 776          $this->enctype = $enctype;
 777  
 778          return $this;
 779      }
 780  
 781      /**
 782       * Set the raw (already encoded) POST data.
 783       *
 784       * This function is here for two reasons:
 785       * 1. For advanced user who would like to set their own data, already encoded
 786       * 2. For backwards compatibilty: If someone uses the old post($data) method.
 787       *    this method will be used to set the encoded data.
 788       *
 789       * $data can also be stream (such as file) from which the data will be read.
 790       *
 791       * @param string|resource $data
 792       * @param string $enctype
 793       * @return Zend_Http_Client
 794       */
 795      public function setRawData($data, $enctype = null)
 796      {
 797          $this->raw_post_data = $data;
 798          $this->setEncType($enctype);
 799          if (is_resource($data)) {
 800              // We've got stream data
 801              $stat = @fstat($data);
 802              if($stat) {
 803                  $this->setHeaders(self::CONTENT_LENGTH, $stat['size']);
 804              }
 805          }
 806          return $this;
 807      }
 808  
 809      /**
 810       * Set the unmask feature for GET parameters as array
 811       *
 812       * Example:
 813       * foo%5B0%5D=a&foo%5B1%5D=b
 814       * becomes
 815       * foo=a&foo=b
 816       *
 817       * This is usefull for some services
 818       *
 819       * @param boolean $status
 820       * @return Zend_Http_Client
 821       */
 822      public function setUnmaskStatus($status = true)
 823      {
 824          $this->_unmaskStatus = (BOOL)$status;
 825          return $this;
 826      }
 827  
 828      /**
 829       * Returns the currently configured unmask status
 830       *
 831       * @return boolean
 832       */
 833      public function getUnmaskStatus()
 834      {
 835          return $this->_unmaskStatus;
 836      }
 837  
 838      /**
 839       * Clear all GET and POST parameters
 840       *
 841       * Should be used to reset the request parameters if the client is
 842       * used for several concurrent requests.
 843       *
 844       * clearAll parameter controls if we clean just parameters or also
 845       * headers and last_*
 846       *
 847       * @param bool $clearAll Should all data be cleared?
 848       * @return Zend_Http_Client
 849       */
 850      public function resetParameters($clearAll = false)
 851      {
 852          // Reset parameter data
 853          $this->paramsGet     = array();
 854          $this->paramsPost    = array();
 855          $this->files         = array();
 856          $this->raw_post_data = null;
 857          $this->enctype       = null;
 858  
 859          if($clearAll) {
 860              $this->headers = array();
 861              $this->last_request = null;
 862              $this->last_response = null;
 863          } else {
 864              // Clear outdated headers
 865              if (isset($this->headers[strtolower(self::CONTENT_TYPE)])) {
 866                  unset($this->headers[strtolower(self::CONTENT_TYPE)]);
 867              }
 868              if (isset($this->headers[strtolower(self::CONTENT_LENGTH)])) {
 869                  unset($this->headers[strtolower(self::CONTENT_LENGTH)]);
 870              }
 871          }
 872  
 873          return $this;
 874      }
 875  
 876      /**
 877       * Get the last HTTP request as string
 878       *
 879       * @return string
 880       */
 881      public function getLastRequest()
 882      {
 883          return $this->last_request;
 884      }
 885  
 886      /**
 887       * Get the last HTTP response received by this client
 888       *
 889       * If $config['storeresponse'] is set to false, or no response was
 890       * stored yet, will return null
 891       *
 892       * @return Zend_Http_Response or null if none
 893       */
 894      public function getLastResponse()
 895      {
 896          return $this->last_response;
 897      }
 898  
 899      /**
 900       * Load the connection adapter
 901       *
 902       * While this method is not called more than one for a client, it is
 903       * seperated from ->request() to preserve logic and readability
 904       *
 905       * @param Zend_Http_Client_Adapter_Interface|string $adapter
 906       * @return null
 907       * @throws Zend_Http_Client_Exception
 908       */
 909      public function setAdapter($adapter)
 910      {
 911          if (is_string($adapter)) {
 912              try {
 913                  Zend_Loader::loadClass($adapter);
 914              } catch (Zend_Exception $e) {
 915                  /** @see Zend_Http_Client_Exception */
 916                  require_once  'Zend/Http/Client/Exception.php';
 917                  throw new Zend_Http_Client_Exception("Unable to load adapter '$adapter': {$e->getMessage()}", 0, $e);
 918              }
 919  
 920              $adapter = new $adapter;
 921          }
 922  
 923          if (! $adapter instanceof Zend_Http_Client_Adapter_Interface) {
 924              /** @see Zend_Http_Client_Exception */
 925              require_once  'Zend/Http/Client/Exception.php';
 926              throw new Zend_Http_Client_Exception('Passed adapter is not a HTTP connection adapter');
 927          }
 928  
 929          $this->adapter = $adapter;
 930          $config = $this->config;
 931          unset($config['adapter']);
 932          $this->adapter->setConfig($config);
 933      }
 934  
 935      /**
 936       * Load the connection adapter
 937       *
 938       * @return Zend_Http_Client_Adapter_Interface $adapter
 939       */
 940      public function getAdapter()
 941      {
 942          if (null === $this->adapter) {
 943              $this->setAdapter($this->config['adapter']);
 944          }
 945  
 946          return $this->adapter;
 947      }
 948  
 949      /**
 950       * Set streaming for received data
 951       *
 952       * @param string|boolean $streamfile Stream file, true for temp file, false/null for no streaming
 953       * @return Zend_Http_Client
 954       */
 955      public function setStream($streamfile = true)
 956      {
 957          $this->setConfig(array("output_stream" => $streamfile));
 958          return $this;
 959      }
 960  
 961      /**
 962       * Get status of streaming for received data
 963       * @return boolean|string
 964       */
 965      public function getStream()
 966      {
 967          return $this->config["output_stream"];
 968      }
 969  
 970      /**
 971       * Create temporary stream
 972       *
 973       * @return resource
 974       */
 975      protected function _openTempStream()
 976      {
 977          $this->_stream_name = $this->config['output_stream'];
 978          if(!is_string($this->_stream_name)) {
 979              // If name is not given, create temp name
 980              $this->_stream_name = tempnam(isset($this->config['stream_tmp_dir'])?$this->config['stream_tmp_dir']:sys_get_temp_dir(),
 981                   'Zend_Http_Client');
 982          }
 983  
 984          if (false === ($fp = @fopen($this->_stream_name, "w+b"))) {
 985                  if ($this->adapter instanceof Zend_Http_Client_Adapter_Interface) {
 986                      $this->adapter->close();
 987                  }
 988                  require_once  'Zend/Http/Client/Exception.php';
 989                  throw new Zend_Http_Client_Exception("Could not open temp file {$this->_stream_name}");
 990          }
 991  
 992          return $fp;
 993      }
 994  
 995      /**
 996       * Send the HTTP request and return an HTTP response object
 997       *
 998       * @param string $method
 999       * @return Zend_Http_Response
1000       * @throws Zend_Http_Client_Exception
1001       */
1002      public function request($method = null)
1003      {
1004          if (! $this->uri instanceof Zend_Uri_Http) {
1005              /** @see Zend_Http_Client_Exception */
1006              require_once  'Zend/Http/Client/Exception.php';
1007              throw new Zend_Http_Client_Exception('No valid URI has been passed to the client');
1008          }
1009  
1010          if ($method) {
1011              $this->setMethod($method);
1012          }
1013          $this->redirectCounter = 0;
1014          $response = null;
1015  
1016          // Make sure the adapter is loaded
1017          if ($this->adapter == null) {
1018              $this->setAdapter($this->config['adapter']);
1019          }
1020  
1021          // Send the first request. If redirected, continue.
1022          do {
1023              // Clone the URI and add the additional GET parameters to it
1024              $uri = clone $this->uri;
1025              if (! empty($this->paramsGet)) {
1026                  $query = $uri->getQuery();
1027                     if (! empty($query)) {
1028                         $query .= '&';
1029                     }
1030                  $query .= http_build_query($this->paramsGet, null, '&');
1031                  if ($this->config['rfc3986_strict']) {
1032                      $query = str_replace('+', '%20', $query);
1033                  }
1034  
1035                  // @see ZF-11671 to unmask for some services to foo=val1&foo=val2
1036                  if ($this->getUnmaskStatus()) {
1037                      if ($this->_queryBracketsEscaped) {
1038                          $query = preg_replace('/%5B(?:[0-9]|[1-9][0-9]+)%5D=/', '=', $query);
1039                      } else {
1040                          $query = preg_replace('/\\[(?:[0-9]|[1-9][0-9]+)\\]=/', '=', $query);
1041                      }
1042                  }
1043  
1044                  $uri->setQuery($query);
1045              }
1046  
1047              $body = $this->_prepareBody();
1048              $headers = $this->_prepareHeaders();
1049  
1050              // check that adapter supports streaming before using it
1051              if(is_resource($body) && !($this->adapter instanceof Zend_Http_Client_Adapter_Stream)) {
1052                  /** @see Zend_Http_Client_Exception */
1053                  require_once  'Zend/Http/Client/Exception.php';
1054                  throw new Zend_Http_Client_Exception('Adapter does not support streaming');
1055              }
1056  
1057              // Open the connection, send the request and read the response
1058              $this->adapter->connect($uri->getHost(), $uri->getPort(),
1059                  ($uri->getScheme() == 'https' ? true : false));
1060  
1061              if($this->config['output_stream']) {
1062                  if($this->adapter instanceof Zend_Http_Client_Adapter_Stream) {
1063                      $stream = $this->_openTempStream();
1064                      $this->adapter->setOutputStream($stream);
1065                  } else {
1066                      /** @see Zend_Http_Client_Exception */
1067                      require_once  'Zend/Http/Client/Exception.php';
1068                      throw new Zend_Http_Client_Exception('Adapter does not support streaming');
1069                  }
1070              }
1071  
1072              $this->last_request = $this->adapter->write($this->method,
1073                  $uri, $this->config['httpversion'], $headers, $body);
1074  
1075              $response = $this->adapter->read();
1076              if (! $response) {
1077                  /** @see Zend_Http_Client_Exception */
1078                  require_once  'Zend/Http/Client/Exception.php';
1079                  throw new Zend_Http_Client_Exception('Unable to read response, or response is empty');
1080              }
1081  
1082              if($this->config['output_stream']) {
1083                  $streamMetaData = stream_get_meta_data($stream);
1084                  if ($streamMetaData['seekable']) {
1085                      rewind($stream);
1086                  }
1087                  // cleanup the adapter
1088                  $this->adapter->setOutputStream(null);
1089                  $response = Zend_Http_Response_Stream::fromStream($response, $stream);
1090                  $response->setStreamName($this->_stream_name);
1091                  if(!is_string($this->config['output_stream'])) {
1092                      // we used temp name, will need to clean up
1093                      $response->setCleanup(true);
1094                  }
1095              } else {
1096                  $response = Zend_Http_Response::fromString($response);
1097              }
1098  
1099              if ($this->config['storeresponse']) {
1100                  $this->last_response = $response;
1101              }
1102  
1103              // Load cookies into cookie jar
1104              if (isset($this->cookiejar)) {
1105                  $this->cookiejar->addCookiesFromResponse($response, $uri, $this->config['encodecookies']);
1106              }
1107  
1108              // If we got redirected, look for the Location header
1109              if ($response->isRedirect() && ($location = $response->getHeader('location'))) {
1110  
1111                  // Avoid problems with buggy servers that add whitespace at the
1112                  // end of some headers (See ZF-11283)
1113                  $location = trim($location);
1114  
1115                  // Check whether we send the exact same request again, or drop the parameters
1116                  // and send a GET request
1117                  if ($response->getStatus() == 303 ||
1118                     ((! $this->config['strictredirects']) && ($response->getStatus() == 302 ||
1119                         $response->getStatus() == 301))) {
1120  
1121                      $this->resetParameters();
1122                      $this->setMethod(self::GET);
1123                  }
1124  
1125                  // If we got a well formed absolute URI
1126                  if (($scheme = substr($location, 0, 6)) && ($scheme == 'http:/' || $scheme == 'https:')) {
1127                      $this->setHeaders('host', null);
1128                      $this->setUri($location);
1129  
1130                  } else {
1131  
1132                      // Split into path and query and set the query
1133                      if (strpos($location, '?') !== false) {
1134                          list($location, $query) = explode('?', $location, 2);
1135                      } else {
1136                          $query = '';
1137                      }
1138                      $this->uri->setQuery($query);
1139  
1140                      // Else, if we got just an absolute path, set it
1141                      if(strpos($location, '/') === 0) {
1142                          $this->uri->setPath($location);
1143  
1144                          // Else, assume we have a relative path
1145                      } else {
1146                          // Get the current path directory, removing any trailing slashes
1147                          $path = $this->uri->getPath();
1148                          $path = rtrim(substr($path, 0, strrpos($path, '/')), "/");
1149                          $this->uri->setPath($path . '/' . $location);
1150                      }
1151                  }
1152                  ++$this->redirectCounter;
1153  
1154              } else {
1155                  // If we didn't get any location, stop redirecting
1156                  break;
1157              }
1158  
1159          } while ($this->redirectCounter < $this->config['maxredirects']);
1160  
1161          return $response;
1162      }
1163  
1164      /**
1165       * Prepare the request headers
1166       *
1167       * @return array
1168       */
1169      protected function _prepareHeaders()
1170      {
1171          $headers = array();
1172  
1173          // Set the host header
1174          if (! isset($this->headers['host'])) {
1175              $host = $this->uri->getHost();
1176  
1177              // If the port is not default, add it
1178              if (! (($this->uri->getScheme() == 'http' && $this->uri->getPort() == 80) ||
1179                    ($this->uri->getScheme() == 'https' && $this->uri->getPort() == 443))) {
1180                  $host .= ':' . $this->uri->getPort();
1181              }
1182  
1183              $headers[] = "Host: {$host}";
1184          }
1185  
1186          // Set the connection header
1187          if (! isset($this->headers['connection'])) {
1188              if (! $this->config['keepalive']) {
1189                  $headers[] = "Connection: close";
1190              }
1191          }
1192  
1193          // Set the Accept-encoding header if not set - depending on whether
1194          // zlib is available or not.
1195          if (! isset($this->headers['accept-encoding'])) {
1196              if (function_exists('gzinflate')) {
1197                  $headers[] = 'Accept-encoding: gzip, deflate';
1198              } else {
1199                  $headers[] = 'Accept-encoding: identity';
1200              }
1201          }
1202  
1203          // Set the Content-Type header
1204          if (($this->method == self::POST || $this->method == self::PUT) &&
1205             (! isset($this->headers[strtolower(self::CONTENT_TYPE)]) && isset($this->enctype))) {
1206  
1207              $headers[] = self::CONTENT_TYPE . ': ' . $this->enctype;
1208          }
1209  
1210          // Set the user agent header
1211          if (! isset($this->headers['user-agent']) && isset($this->config['useragent'])) {
1212              $headers[] = "User-Agent: {$this->config['useragent']}";
1213          }
1214  
1215          // Set HTTP authentication if needed
1216          if (is_array($this->auth)) {
1217              $auth = self::encodeAuthHeader($this->auth['user'], $this->auth['password'], $this->auth['type']);
1218              $headers[] = "Authorization: {$auth}";
1219          }
1220  
1221          // Load cookies from cookie jar
1222          if (isset($this->cookiejar)) {
1223              $cookstr = $this->cookiejar->getMatchingCookies($this->uri,
1224                  true, Zend_Http_CookieJar::COOKIE_STRING_CONCAT);
1225  
1226              if ($cookstr) {
1227                  $headers[] = "Cookie: {$cookstr}";
1228              }
1229          }
1230  
1231          // Add all other user defined headers
1232          foreach ($this->headers as $header) {
1233              list($name, $value) = $header;
1234              if (is_array($value)) {
1235                  $value = implode(', ', $value);
1236              }
1237  
1238              $headers[] = "$name: $value";
1239          }
1240  
1241          return $headers;
1242      }
1243  
1244      /**
1245       * Prepare the request body (for POST and PUT requests)
1246       *
1247       * @return string
1248       * @throws Zend_Http_Client_Exception
1249       */
1250      protected function _prepareBody()
1251      {
1252          // According to RFC2616, a TRACE request should not have a body.
1253          if ($this->method == self::TRACE) {
1254              return '';
1255          }
1256  
1257          if (isset($this->raw_post_data) && is_resource($this->raw_post_data)) {
1258              return $this->raw_post_data;
1259          }
1260          // If mbstring overloads substr and strlen functions, we have to
1261          // override it's internal encoding
1262          if (function_exists('mb_internal_encoding') &&
1263             ((int) ini_get('mbstring.func_overload')) & 2) {
1264  
1265              $mbIntEnc = mb_internal_encoding();
1266              mb_internal_encoding('ASCII');
1267          }
1268  
1269          // If we have raw_post_data set, just use it as the body.
1270          if (isset($this->raw_post_data)) {
1271              $this->setHeaders(self::CONTENT_LENGTH, strlen($this->raw_post_data));
1272              if (isset($mbIntEnc)) {
1273                  mb_internal_encoding($mbIntEnc);
1274              }
1275  
1276              return $this->raw_post_data;
1277          }
1278  
1279          $body = '';
1280  
1281          // If we have files to upload, force enctype to multipart/form-data
1282          if (count ($this->files) > 0) {
1283              $this->setEncType(self::ENC_FORMDATA);
1284          }
1285  
1286          // If we have POST parameters or files, encode and add them to the body
1287          if (count($this->paramsPost) > 0 || count($this->files) > 0) {
1288              switch($this->enctype) {
1289                  case self::ENC_FORMDATA:
1290                      // Encode body as multipart/form-data
1291                      $boundary = '---ZENDHTTPCLIENT-' . md5(microtime());
1292                      $this->setHeaders(self::CONTENT_TYPE, self::ENC_FORMDATA . "; boundary={$boundary}");
1293  
1294                      // Encode all files and POST vars in the order they were given
1295                      foreach ($this->body_field_order as $fieldName=>$fieldType) {
1296                          switch ($fieldType) {
1297                              case self::VTYPE_FILE:
1298                                  foreach ($this->files as $file) {
1299                                      if ($file['formname']===$fieldName) {
1300                                          $fhead = array(self::CONTENT_TYPE => $file['ctype']);
1301                                          $body .= self::encodeFormData($boundary, $file['formname'], $file['data'], $file['filename'], $fhead);
1302                                      }
1303                                  }
1304                                  break;
1305                              case self::VTYPE_SCALAR:
1306                                  if (isset($this->paramsPost[$fieldName])) {
1307                                      if (is_array($this->paramsPost[$fieldName])) {
1308                                          $flattened = self::_flattenParametersArray($this->paramsPost[$fieldName], $fieldName);
1309                                          foreach ($flattened as $pp) {
1310                                              $body .= self::encodeFormData($boundary, $pp[0], $pp[1]);
1311                                          }
1312                                      } else {
1313                                          $body .= self::encodeFormData($boundary, $fieldName, $this->paramsPost[$fieldName]);
1314                                      }
1315                                  }
1316                                  break;
1317                          }
1318                      }
1319  
1320                      $body .= "--{$boundary}--\r\n";
1321                      break;
1322  
1323                  case self::ENC_URLENCODED:
1324                      // Encode body as application/x-www-form-urlencoded
1325                      $this->setHeaders(self::CONTENT_TYPE, self::ENC_URLENCODED);
1326                      $body = http_build_query($this->paramsPost, '', '&');
1327                      break;
1328  
1329                  default:
1330                      if (isset($mbIntEnc)) {
1331                          mb_internal_encoding($mbIntEnc);
1332                      }
1333  
1334                      /** @see Zend_Http_Client_Exception */
1335                      require_once  'Zend/Http/Client/Exception.php';
1336                      throw new Zend_Http_Client_Exception("Cannot handle content type '{$this->enctype}' automatically." .
1337                          " Please use Zend_Http_Client::setRawData to send this kind of content.");
1338                      break;
1339              }
1340          }
1341  
1342          // Set the Content-Length if we have a body or if request is POST/PUT
1343          if ($body || $this->method == self::POST || $this->method == self::PUT) {
1344              $this->setHeaders(self::CONTENT_LENGTH, strlen($body));
1345          }
1346  
1347          if (isset($mbIntEnc)) {
1348              mb_internal_encoding($mbIntEnc);
1349          }
1350  
1351          return $body;
1352      }
1353  
1354      /**
1355       * Helper method that gets a possibly multi-level parameters array (get or
1356       * post) and flattens it.
1357       *
1358       * The method returns an array of (key, value) pairs (because keys are not
1359       * necessarily unique. If one of the parameters in as array, it will also
1360       * add a [] suffix to the key.
1361       *
1362       * This method is deprecated since Zend Framework 1.9 in favour of
1363       * self::_flattenParametersArray() and will be dropped in 2.0
1364       *
1365       * @deprecated since 1.9
1366       *
1367       * @param  array $parray    The parameters array
1368       * @param  bool  $urlencode Whether to urlencode the name and value
1369       * @return array
1370       */
1371      protected function _getParametersRecursive($parray, $urlencode = false)
1372      {
1373          // Issue a deprecated notice
1374          trigger_error("The " .  __METHOD__ . " method is deprecated and will be dropped in 2.0.",
1375              E_USER_NOTICE);
1376  
1377          if (! is_array($parray)) {
1378              return $parray;
1379          }
1380          $parameters = array();
1381  
1382          foreach ($parray as $name => $value) {
1383              if ($urlencode) {
1384                  $name = urlencode($name);
1385              }
1386  
1387              // If $value is an array, iterate over it
1388              if (is_array($value)) {
1389                  $name .= ($urlencode ? '%5B%5D' : '[]');
1390                  foreach ($value as $subval) {
1391                      if ($urlencode) {
1392                          $subval = urlencode($subval);
1393                      }
1394                      $parameters[] = array($name, $subval);
1395                  }
1396              } else {
1397                  if ($urlencode) {
1398                      $value = urlencode($value);
1399                  }
1400                  $parameters[] = array($name, $value);
1401              }
1402          }
1403  
1404          return $parameters;
1405      }
1406  
1407      /**
1408       * Attempt to detect the MIME type of a file using available extensions
1409       *
1410       * This method will try to detect the MIME type of a file. If the fileinfo
1411       * extension is available, it will be used. If not, the mime_magic
1412       * extension which is deprected but is still available in many PHP setups
1413       * will be tried.
1414       *
1415       * If neither extension is available, the default application/octet-stream
1416       * MIME type will be returned
1417       *
1418       * @param  string $file File path
1419       * @return string       MIME type
1420       */
1421      protected function _detectFileMimeType($file)
1422      {
1423          $type = null;
1424  
1425          // First try with fileinfo functions
1426          if (function_exists('finfo_open')) {
1427              if (self::$_fileInfoDb === null) {
1428                  self::$_fileInfoDb = @finfo_open(FILEINFO_MIME);
1429              }
1430  
1431              if (self::$_fileInfoDb) {
1432                  $type = finfo_file(self::$_fileInfoDb, $file);
1433              }
1434  
1435          } elseif (function_exists('mime_content_type')) {
1436              $type = mime_content_type($file);
1437          }
1438  
1439          // Fallback to the default application/octet-stream
1440          if (! $type) {
1441              $type = 'application/octet-stream';
1442          }
1443  
1444          return $type;
1445      }
1446  
1447      /**
1448       * Encode data to a multipart/form-data part suitable for a POST request.
1449       *
1450       * @param string $boundary
1451       * @param string $name
1452       * @param mixed $value
1453       * @param string $filename
1454       * @param array $headers Associative array of optional headers @example ("Content-Transfer-Encoding" => "binary")
1455       * @return string
1456       */
1457      public static function encodeFormData($boundary, $name, $value, $filename = null, $headers = array()) {
1458          $ret = "--{$boundary}\r\n" .
1459              'Content-Disposition: form-data; name="' . $name .'"';
1460  
1461          if ($filename) {
1462              $ret .= '; filename="' . $filename . '"';
1463          }
1464          $ret .= "\r\n";
1465  
1466          foreach ($headers as $hname => $hvalue) {
1467              $ret .= "{$hname}: {$hvalue}\r\n";
1468          }
1469          $ret .= "\r\n";
1470  
1471          $ret .= "{$value}\r\n";
1472  
1473          return $ret;
1474      }
1475  
1476      /**
1477       * Create a HTTP authentication "Authorization:" header according to the
1478       * specified user, password and authentication method.
1479       *
1480       * @see http://www.faqs.org/rfcs/rfc2617.html
1481       * @param string $user
1482       * @param string $password
1483       * @param string $type
1484       * @return string
1485       * @throws Zend_Http_Client_Exception
1486       */
1487      public static function encodeAuthHeader($user, $password, $type = self::AUTH_BASIC)
1488      {
1489          $authHeader = null;
1490  
1491          switch ($type) {
1492              case self::AUTH_BASIC:
1493                  // In basic authentication, the user name cannot contain ":"
1494                  if (strpos($user, ':') !== false) {
1495                      /** @see Zend_Http_Client_Exception */
1496                      require_once  'Zend/Http/Client/Exception.php';
1497                      throw new Zend_Http_Client_Exception("The user name cannot contain ':' in 'Basic' HTTP authentication");
1498                  }
1499  
1500                  $authHeader = 'Basic ' . base64_encode($user . ':' . $password);
1501                  break;
1502  
1503              //case self::AUTH_DIGEST:
1504                  /**
1505                   * @todo Implement digest authentication
1506                   */
1507              //    break;
1508  
1509              default:
1510                  /** @see Zend_Http_Client_Exception */
1511                  require_once  'Zend/Http/Client/Exception.php';
1512                  throw new Zend_Http_Client_Exception("Not a supported HTTP authentication type: '$type'");
1513          }
1514  
1515          return $authHeader;
1516      }
1517  
1518      /**
1519       * Convert an array of parameters into a flat array of (key, value) pairs
1520       *
1521       * Will flatten a potentially multi-dimentional array of parameters (such
1522       * as POST parameters) into a flat array of (key, value) paris. In case
1523       * of multi-dimentional arrays, square brackets ([]) will be added to the
1524       * key to indicate an array.
1525       *
1526       * @since  1.9
1527       *
1528       * @param  array  $parray
1529       * @param  string $prefix
1530       * @return array
1531       */
1532      static protected function _flattenParametersArray($parray, $prefix = null)
1533      {
1534          if (! is_array($parray)) {
1535              return $parray;
1536          }
1537  
1538          $parameters = array();
1539  
1540          foreach($parray as $name => $value) {
1541  
1542              // Calculate array key
1543              if ($prefix) {
1544                  if (is_int($name)) {
1545                      $key = $prefix . '[]';
1546                  } else {
1547                      $key = $prefix . "[$name]";
1548                  }
1549              } else {
1550                  $key = $name;
1551              }
1552  
1553              if (is_array($value)) {
1554                  $parameters = array_merge($parameters, self::_flattenParametersArray($value, $key));
1555  
1556              } else {
1557                  $parameters[] = array($key, $value);
1558              }
1559          }
1560  
1561          return $parameters;
1562      }
1563  
1564  }