[Summary view] [Print] [Text view]

   1  <?php
   2  /**
   3   * Zend Framework
   4   *
   5   * LICENSE
   6   *
   7   * This source file is subject to the new BSD license that is bundled
   8   * with this package in the file LICENSE.txt.
   9   * It is also available through the world-wide-web at this URL:
  10   * http://framework.zend.com/license/new-bsd
  11   * If you did not receive a copy of the license and are unable to
  12   * obtain it through the world-wide-web, please send an email
  13   * to [email protected] so we can send you a copy immediately.
  14   *
  15   * @category   Zend
  16   * @package    Zend_Gdata
  17   * @subpackage Gdata
  18   * @copyright  Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
  19   * @license    http://framework.zend.com/license/new-bsd     New BSD License
  20   * @version    $Id$
  21   */
  22  
  23  /**
  24   * Zend_Http_Client
  25   */
  26  require_once 'Zend/Http/Client.php';
  27  
  28  /**
  29   * Gdata Http Client object.
  30   *
  31   * Class to extend the generic Zend Http Client with the ability to perform
  32   * secure AuthSub requests
  33   *
  34   * @category   Zend
  35   * @package    Zend_Gdata
  36   * @subpackage Gdata
  37   * @copyright  Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
  38   * @license    http://framework.zend.com/license/new-bsd     New BSD License
  39   */
  40  class Zend_Gdata_HttpClient extends Zend_Http_Client
  41  {
  42  
  43      /**
  44       * OpenSSL private key resource id
  45       * This key is used for AuthSub authentication.  If this value is set,
  46       * it is assuemd that secure AuthSub is desired.
  47       *
  48       * @var resource
  49       */
  50      private $_authSubPrivateKeyId = null;
  51  
  52      /**
  53       * Token for AuthSub authentication.
  54       * If this token is set, AuthSub authentication is used.
  55       *
  56       * @var string
  57       */
  58      private $_authSubToken = null;
  59  
  60      /**
  61       * Token for ClientLogin authentication.
  62       * If only this token is set, ClientLogin authentication is used.
  63       *
  64       * @var string
  65       */
  66      private $_clientLoginToken = null;
  67  
  68      /**
  69       * Token for ClientLogin authentication.
  70       * If this token is set, and the AuthSub key is not set,
  71       * ClientLogin authentication is used
  72       *
  73       * @var string
  74       */
  75      private $_clientLoginKey = null;
  76  
  77      /**
  78       * True if this request is being made with data supplied by
  79       * a stream object instead of a raw encoded string.
  80       *
  81       * @var bool
  82       */
  83      protected $_streamingRequest = null;
  84  
  85      /**
  86       * Sets the PEM formatted private key, as read from a file.
  87       *
  88       * This method reads the file and then calls setAuthSubPrivateKey()
  89       * with the file contents.
  90       *
  91       * @param string $file The location of the file containing the PEM key
  92       * @param string $passphrase The optional private key passphrase
  93       * @param bool $useIncludePath Whether to search the include_path
  94       *                             for the file
  95       * @return void
  96       */
  97      public function setAuthSubPrivateKeyFile($file, $passphrase = null,
  98                                               $useIncludePath = false) {
  99          $fp = @fopen($file, "r", $useIncludePath);
 100          if (!$fp) {
 101              require_once 'Zend/Gdata/App/InvalidArgumentException.php';
 102              throw new Zend_Gdata_App_InvalidArgumentException('Failed to open private key file for AuthSub.');
 103          }
 104  
 105          $key = '';
 106          while (!feof($fp)) {
 107              $key .= fread($fp, 8192);
 108          }
 109          $this->setAuthSubPrivateKey($key, $passphrase);
 110          fclose($fp);
 111      }
 112  
 113      /**
 114       * Sets the PEM formatted private key to be used for secure AuthSub auth.
 115       *
 116       * In order to call this method, openssl must be enabled in your PHP
 117       * installation.  Otherwise, a Zend_Gdata_App_InvalidArgumentException
 118       * will be thrown.
 119       *
 120       * @param string $key The private key
 121       * @param string $passphrase The optional private key passphrase
 122       * @throws Zend_Gdata_App_InvalidArgumentException
 123       * @return Zend_Gdata_HttpClient Provides a fluent interface
 124       */
 125      public function setAuthSubPrivateKey($key, $passphrase = null) {
 126          if ($key != null && !function_exists('openssl_pkey_get_private')) {
 127              require_once 'Zend/Gdata/App/InvalidArgumentException.php';
 128              throw new Zend_Gdata_App_InvalidArgumentException(
 129                      'You cannot enable secure AuthSub if the openssl module ' .
 130                      'is not enabled in your PHP installation.');
 131          }
 132          $this->_authSubPrivateKeyId = openssl_pkey_get_private(
 133                  $key, $passphrase);
 134          return $this;
 135      }
 136  
 137      /**
 138       * Gets the openssl private key id
 139       *
 140       * @return string The private key
 141       */
 142      public function getAuthSubPrivateKeyId() {
 143          return $this->_authSubPrivateKeyId;
 144      }
 145  
 146      /**
 147       * Gets the AuthSub token used for authentication
 148       *
 149       * @return string The token
 150       */
 151      public function getAuthSubToken() {
 152          return $this->_authSubToken;
 153      }
 154  
 155      /**
 156       * Sets the AuthSub token used for authentication
 157       *
 158       * @param string $token The token
 159       * @return Zend_Gdata_HttpClient Provides a fluent interface
 160       */
 161      public function setAuthSubToken($token) {
 162          $this->_authSubToken = $token;
 163          return $this;
 164      }
 165  
 166      /**
 167       * Gets the ClientLogin token used for authentication
 168       *
 169       * @return string The token
 170       */
 171      public function getClientLoginToken() {
 172          return $this->_clientLoginToken;
 173      }
 174  
 175      /**
 176       * Sets the ClientLogin token used for authentication
 177       *
 178       * @param string $token The token
 179       * @return Zend_Gdata_HttpClient Provides a fluent interface
 180       */
 181      public function setClientLoginToken($token) {
 182          $this->_clientLoginToken = $token;
 183          return $this;
 184      }
 185  
 186      /**
 187       * Filters the HTTP requests being sent to add the Authorization header.
 188       *
 189       * If both AuthSub and ClientLogin tokens are set,
 190       * AuthSub takes precedence.  If an AuthSub key is set, then
 191       * secure AuthSub authentication is used, and the request is signed.
 192       * Requests must be signed only with the private key corresponding to the
 193       * public key registered with Google.  If an AuthSub key is set, but
 194       * openssl support is not enabled in the PHP installation, an exception is
 195       * thrown.
 196       *
 197       * @param string $method The HTTP method
 198       * @param string $url The URL
 199       * @param array $headers An associate array of headers to be
 200       *                       sent with the request or null
 201       * @param string $body The body of the request or null
 202       * @param string $contentType The MIME content type of the body or null
 203       * @throws Zend_Gdata_App_Exception if there was a signing failure
 204       * @return array The processed values in an associative array,
 205       *               using the same names as the params
 206       */
 207      public function filterHttpRequest($method, $url, $headers = array(), $body = null, $contentType = null) {
 208          if ($this->getAuthSubToken() != null) {
 209              // AuthSub authentication
 210              if ($this->getAuthSubPrivateKeyId() != null) {
 211                  // secure AuthSub
 212                  $time = time();
 213                  $nonce = mt_rand(0, 999999999);
 214                  $dataToSign = $method . ' ' . $url . ' ' . $time . ' ' . $nonce;
 215  
 216                  // compute signature
 217                  $pKeyId = $this->getAuthSubPrivateKeyId();
 218                  $signSuccess = openssl_sign($dataToSign, $signature, $pKeyId,
 219                                              OPENSSL_ALGO_SHA1);
 220                  if (!$signSuccess) {
 221                      require_once 'Zend/Gdata/App/Exception.php';
 222                      throw new Zend_Gdata_App_Exception(
 223                              'openssl_signing failure - returned false');
 224                  }
 225                  // encode signature
 226                  $encodedSignature = base64_encode($signature);
 227  
 228                  // final header
 229                  $headers['authorization'] = 'AuthSub token="' . $this->getAuthSubToken() . '" ' .
 230                                              'data="' . $dataToSign . '" ' .
 231                                              'sig="' . $encodedSignature . '" ' .
 232                                              'sigalg="rsa-sha1"';
 233              } else {
 234                  // AuthSub without secure tokens
 235                  $headers['authorization'] = 'AuthSub token="' . $this->getAuthSubToken() . '"';
 236              }
 237          } elseif ($this->getClientLoginToken() != null) {
 238              $headers['authorization'] = 'GoogleLogin auth=' . $this->getClientLoginToken();
 239          }
 240          return array('method' => $method, 'url' => $url, 'body' => $body, 'headers' => $headers, 'contentType' => $contentType);
 241      }
 242  
 243      /**
 244       * Method for filtering the HTTP response, though no filtering is
 245       * currently done.
 246       *
 247       * @param Zend_Http_Response $response The response object to filter
 248       * @return Zend_Http_Response The filterd response object
 249       */
 250      public function filterHttpResponse($response) {
 251          return $response;
 252      }
 253  
 254      /**
 255       * Return the current connection adapter
 256       *
 257       * @return Zend_Http_Client_Adapter_Interface|string $adapter
 258       */
 259      public function getAdapter()
 260      {
 261          return $this->adapter;
 262      }
 263  
 264     /**
 265       * Load the connection adapter
 266       *
 267       * @param Zend_Http_Client_Adapter_Interface $adapter
 268       * @return void
 269       */
 270      public function setAdapter($adapter)
 271      {
 272          if ($adapter == null) {
 273              $this->adapter = $adapter;
 274          } else {
 275                parent::setAdapter($adapter);
 276          }
 277      }
 278  
 279      /**
 280       * Set the streamingRequest variable which controls whether we are
 281       * sending the raw (already encoded) POST data from a stream source.
 282       *
 283       * @param boolean $value The value to set.
 284       * @return void
 285       */
 286      public function setStreamingRequest($value)
 287      {
 288          $this->_streamingRequest = $value;
 289      }
 290  
 291      /**
 292       * Check whether the client is set to perform streaming requests.
 293       *
 294       * @return boolean True if yes, false otherwise.
 295       */
 296      public function getStreamingRequest()
 297      {
 298          if ($this->_streamingRequest()) {
 299              return true;
 300          } else {
 301              return false;
 302          }
 303      }
 304  
 305      /**
 306       * Prepare the request body (for POST and PUT requests)
 307       *
 308       * @return string
 309       * @throws Zend_Http_Client_Exception
 310       */
 311      protected function _prepareBody()
 312      {
 313          if($this->_streamingRequest) {
 314              $this->setHeaders(self::CONTENT_LENGTH,
 315                  $this->raw_post_data->getTotalSize());
 316              return $this->raw_post_data;
 317          }
 318          else {
 319              return parent::_prepareBody();
 320          }
 321      }
 322  
 323      /**
 324       * Clear all custom parameters we set.
 325       *
 326       * @return Zend_Http_Client
 327       */
 328      public function resetParameters($clearAll = false)
 329      {
 330          $this->_streamingRequest = false;
 331  
 332          return parent::resetParameters($clearAll);
 333      }
 334  
 335      /**
 336       * Set the raw (already encoded) POST data from a stream source.
 337       *
 338       * This is used to support POSTing from open file handles without
 339       * caching the entire body into memory. It is a wrapper around
 340       * Zend_Http_Client::setRawData().
 341       *
 342       * @param string $data The request data
 343       * @param string $enctype The encoding type
 344       * @return Zend_Http_Client
 345       */
 346      public function setRawDataStream($data, $enctype = null)
 347      {
 348          $this->_streamingRequest = true;
 349          return $this->setRawData($data, $enctype);
 350      }
 351  
 352  }