Zend/Oauth/Config.php

   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 license@zend.com so we can send you a copy immediately.
  14  *
  15  * @category   Zend
  16  * @package    Zend_Oauth
  17  * @copyright  Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
  18  * @license    http://framework.zend.com/license/new-bsd     New BSD License
  19
  20  */
  21
  22 /** Zend_Oauth */
  23 require_once 'Zend/Oauth.php';
  24
  25 /** Zend_Uri */
  26 require_once 'Zend/Uri.php';
  27
  28 /** Zend_Oauth_Config_Interface */
  29 require_once 'Zend/Oauth/Config/ConfigInterface.php';
  30
  31 /**
  32  * @category   Zend
  33  * @package    Zend_Oauth
  34  * @copyright  Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
  35  * @license    http://framework.zend.com/license/new-bsd     New BSD License
  36  */
  37 class Zend_Oauth_Config implements Zend_Oauth_Config_ConfigInterface
  38 {
  39     /**
  40      * Signature method used when signing all parameters for an HTTP request
  41      *
  42      * @var string
  43      */
  44     protected $_signatureMethod = 'HMAC-SHA1';
  45
  46     /**
  47      * Three request schemes are defined by OAuth, of which passing
  48      * all OAuth parameters by Header is preferred. The other two are
  49      * POST Body and Query String.
  50      *
  51      * @var string
  52      */
  53     protected $_requestScheme = Zend_Oauth::REQUEST_SCHEME_HEADER;
  54
  55     /**
  56      * Preferred request Method - one of GET or POST - which Zend_Oauth
  57      * will enforce as standard throughout the library. Generally a default
  58      * of POST works fine unless a Provider specifically requires otherwise.
  59      *
  60      * @var string
  61      */
  62     protected $_requestMethod = Zend_Oauth::POST;
  63
  64     /**
  65      * OAuth Version; This defaults to 1.0 - Must not be changed!
  66      *
  67      * @var string
  68      */
  69     protected $_version = '1.0';
  70
  71     /**
  72      * This optional value is used to define where the user is redirected to
  73      * after authorizing a Request Token from an OAuth Providers website.
  74      * It's optional since a Provider may ask for this to be defined in advance
  75      * when registering a new application for a Consumer Key.
  76      *
  77      * @var string
  78      */
  79     protected $_callbackUrl = null;
  80
  81     /**
  82      * The URL root to append default OAuth endpoint paths.
  83      *
  84      * @var string
  85      */
  86     protected $_siteUrl = null;
  87
  88     /**
  89      * The URL to which requests for a Request Token should be directed.
  90      * When absent, assumed siteUrl+'/request_token'
  91      *
  92      * @var string
  93      */
  94     protected $_requestTokenUrl = null;
  95
  96     /**
  97      * The URL to which requests for an Access Token should be directed.
  98      * When absent, assumed siteUrl+'/access_token'
  99      *
 100      * @var string
 101      */
 102     protected $_accessTokenUrl = null;
 103
 104     /**
 105      * The URL to which users should be redirected to authorize a Request Token.
 106      * When absent, assumed siteUrl+'/authorize'
 107      *
 108      * @var string
 109      */
 110     protected $_authorizeUrl = null;
 111
 112     /**
 113      * An OAuth application's Consumer Key.
 114      *
 115      * @var string
 116      */
 117     protected $_consumerKey = null;
 118
 119     /**
 120      * Every Consumer Key has a Consumer Secret unless you're in RSA-land.
 121      *
 122      * @var string
 123      */
 124     protected $_consumerSecret = null;
 125
 126     /**
 127      * If relevant, a PEM encoded RSA private key encapsulated as a
 128      * Zend_Crypt_Rsa Key
 129      *
 130      * @var Zend_Crypt_Rsa_Key_Private
 131      */
 132     protected $_rsaPrivateKey = null;
 133
 134     /**
 135      * If relevant, a PEM encoded RSA public key encapsulated as a
 136      * Zend_Crypt_Rsa Key
 137      *
 138      * @var Zend_Crypt_Rsa_Key_Public
 139      */
 140     protected $_rsaPublicKey = null;
 141
 142     /**
 143      * Generally this will nearly always be an Access Token represented as a
 144      * Zend_Oauth_Token_Access object.
 145      *
 146      * @var Zend_Oauth_Token
 147      */
 148     protected $_token = null;
 149
 150     /**
 151      * Constructor; create a new object with an optional array|Zend_Config
 152      * instance containing initialising options.
 153      *
 154      * @param  array|Zend_Config $options
 155      * @return void
 156      */
 157     public function __construct($options = null)
 158     {
 159         if ($options !== null) {
 160             if ($options instanceof Zend_Config) {
 161                 $options = $options->toArray();
 162             }
 163             $this->setOptions($options);
 164         }
 165     }
 166
 167     /**
 168      * Parse option array or Zend_Config instance and setup options using their
 169      * relevant mutators.
 170      *
 171      * @param  array|Zend_Config $options
 172      * @return Zend_Oauth_Config
 173      */
 174     public function setOptions(array $options)
 175     {
 176         foreach ($options as $key => $value) {
 177             switch ($key) {
 178                 case 'consumerKey':
 179                     $this->setConsumerKey($value);
 180                     break;
 181                 case 'consumerSecret':
 182                     $this->setConsumerSecret($value);
 183                     break;
 184                 case 'signatureMethod':
 185                     $this->setSignatureMethod($value);
 186                     break;
 187                 case 'version':
 188                     $this->setVersion($value);
 189                     break;
 190                 case 'callbackUrl':
 191                     $this->setCallbackUrl($value);
 192                     break;
 193                 case 'siteUrl':
 194                     $this->setSiteUrl($value);
 195                     break;
 196                 case 'requestTokenUrl':
 197                     $this->setRequestTokenUrl($value);
 198                     break;
 199                 case 'accessTokenUrl':
 200                     $this->setAccessTokenUrl($value);
 201                     break;
 202                 case 'userAuthorizationUrl':
 203                     $this->setUserAuthorizationUrl($value);
 204                     break;
 205                 case 'authorizeUrl':
 206                     $this->setAuthorizeUrl($value);
 207                     break;
 208                 case 'requestMethod':
 209                     $this->setRequestMethod($value);
 210                     break;
 211                 case 'rsaPrivateKey':
 212                     $this->setRsaPrivateKey($value);
 213                     break;
 214                 case 'rsaPublicKey':
 215                     $this->setRsaPublicKey($value);
 216                     break;
 217             }
 218         }
 219         if (isset($options['requestScheme'])) {
 220             $this->setRequestScheme($options['requestScheme']);
 221         }
 222
 223         return $this;
 224     }
 225
 226     /**
 227      * Set consumer key
 228      *
 229      * @param  string $key
 230      * @return Zend_Oauth_Config
 231      */
 232     public function setConsumerKey($key)
 233     {
 234         $this->_consumerKey = $key;
 235         return $this;
 236     }
 237
 238     /**
 239      * Get consumer key
 240      *
 241      * @return string
 242      */
 243     public function getConsumerKey()
 244     {
 245         return $this->_consumerKey;
 246     }
 247
 248     /**
 249      * Set consumer secret
 250      *
 251      * @param  string $secret
 252      * @return Zend_Oauth_Config
 253      */
 254     public function setConsumerSecret($secret)
 255     {
 256         $this->_consumerSecret = $secret;
 257         return $this;
 258     }
 259
 260     /**
 261      * Get consumer secret
 262      *
 263      * Returns RSA private key if set; otherwise, returns any previously set
 264      * consumer secret.
 265      *
 266      * @return string
 267      */
 268     public function getConsumerSecret()
 269     {
 270         if ($this->_rsaPrivateKey !== null) {
 271             return $this->_rsaPrivateKey;
 272         }
 273         return $this->_consumerSecret;
 274     }
 275
 276     /**
 277      * Set signature method
 278      *
 279      * @param  string $method
 280      * @return Zend_Oauth_Config
 281      * @throws Zend_Oauth_Exception if unsupported signature method specified
 282      */
 283     public function setSignatureMethod($method)
 284     {
 285         $method = strtoupper($method);
 286         if (!in_array($method, array(
 287                 'HMAC-SHA1', 'HMAC-SHA256', 'RSA-SHA1', 'PLAINTEXT'
 288             ))
 289         ) {
 290             require_once 'Zend/Oauth/Exception.php';
 291             throw new Zend_Oauth_Exception('Unsupported signature method: '
 292                 . $method
 293                 . '. Supported are HMAC-SHA1, RSA-SHA1, PLAINTEXT and HMAC-SHA256');
 294         }
 295         $this->_signatureMethod = $method;;
 296         return $this;
 297     }
 298
 299     /**
 300      * Get signature method
 301      *
 302      * @return string
 303      */
 304     public function getSignatureMethod()
 305     {
 306         return $this->_signatureMethod;
 307     }
 308
 309     /**
 310      * Set request scheme
 311      *
 312      * @param  string $scheme
 313      * @return Zend_Oauth_Config
 314      * @throws Zend_Oauth_Exception if invalid scheme specified, or if POSTBODY set when request method of GET is specified
 315      */
 316     public function setRequestScheme($scheme)
 317     {
 318         $scheme = strtolower($scheme);
 319         if (!in_array($scheme, array(
 320                 Zend_Oauth::REQUEST_SCHEME_HEADER,
 321                 Zend_Oauth::REQUEST_SCHEME_POSTBODY,
 322                 Zend_Oauth::REQUEST_SCHEME_QUERYSTRING,
 323             ))
 324         ) {
 325             require_once 'Zend/Oauth/Exception.php';
 326             throw new Zend_Oauth_Exception(
 327                 '\'' . $scheme . '\' is an unsupported request scheme'
 328             );
 329         }
 330         if ($scheme == Zend_Oauth::REQUEST_SCHEME_POSTBODY
 331             && $this->getRequestMethod() == Zend_Oauth::GET
 332         ) {
 333             require_once 'Zend/Oauth/Exception.php';
 334             throw new Zend_Oauth_Exception(
 335                 'Cannot set POSTBODY request method if HTTP method set to GET'
 336             );
 337         }
 338         $this->_requestScheme = $scheme;
 339         return $this;
 340     }
 341
 342     /**
 343      * Get request scheme
 344      *
 345      * @return string
 346      */
 347     public function getRequestScheme()
 348     {
 349         return $this->_requestScheme;
 350     }
 351
 352     /**
 353      * Set version
 354      *
 355      * @param  string $version
 356      * @return Zend_Oauth_Config
 357      */
 358     public function setVersion($version)
 359     {
 360         $this->_version = $version;
 361         return $this;
 362     }
 363
 364     /**
 365      * Get version
 366      *
 367      * @return string
 368      */
 369     public function getVersion()
 370     {
 371         return $this->_version;
 372     }
 373
 374     /**
 375      * Set callback URL
 376      *
 377      * @param  string $url
 378      * @return Zend_Oauth_Config
 379      * @throws Zend_Oauth_Exception for invalid URLs
 380      */
 381     public function setCallbackUrl($url)
 382     {
 383         if (!Zend_Uri::check($url)) {
 384             require_once 'Zend/Oauth/Exception.php';
 385             throw new Zend_Oauth_Exception(
 386                 '\'' . $url . '\' is not a valid URI'
 387             );
 388         }
 389         $this->_callbackUrl = $url;
 390         return $this;
 391     }
 392
 393     /**
 394      * Get callback URL
 395      *
 396      * @return string
 397      */
 398     public function getCallbackUrl()
 399     {
 400         return $this->_callbackUrl;
 401     }
 402
 403     /**
 404      * Set site URL
 405      *
 406      * @param  string $url
 407      * @return Zend_Oauth_Config
 408      * @throws Zend_Oauth_Exception for invalid URLs
 409      */
 410     public function setSiteUrl($url)
 411     {
 412         if (!Zend_Uri::check($url)) {
 413             require_once 'Zend/Oauth/Exception.php';
 414             throw new Zend_Oauth_Exception(
 415                 '\'' . $url . '\' is not a valid URI'
 416             );
 417         }
 418         $this->_siteUrl = $url;
 419         return $this;
 420     }
 421
 422     /**
 423      * Get site URL
 424      *
 425      * @return string
 426      */
 427     public function getSiteUrl()
 428     {
 429         return $this->_siteUrl;
 430     }
 431
 432     /**
 433      * Set request token URL
 434      *
 435      * @param  string $url
 436      * @return Zend_Oauth_Config
 437      * @throws Zend_Oauth_Exception for invalid URLs
 438      */
 439     public function setRequestTokenUrl($url)
 440     {
 441         if (!Zend_Uri::check($url)) {
 442             require_once 'Zend/Oauth/Exception.php';
 443             throw new Zend_Oauth_Exception(
 444                 '\'' . $url . '\' is not a valid URI'
 445             );
 446         }
 447         $this->_requestTokenUrl = rtrim($url, '/');
 448         return $this;
 449     }
 450
 451     /**
 452      * Get request token URL
 453      *
 454      * If no request token URL has been set, but a site URL has, returns the
 455      * site URL with the string "/request_token" appended.
 456      *
 457      * @return string
 458      */
 459     public function getRequestTokenUrl()
 460     {
 461         if (!$this->_requestTokenUrl && $this->_siteUrl) {
 462             return $this->_siteUrl . '/request_token';
 463         }
 464         return $this->_requestTokenUrl;
 465     }
 466
 467     /**
 468      * Set access token URL
 469      *
 470      * @param  string $url
 471      * @return Zend_Oauth_Config
 472      * @throws Zend_Oauth_Exception for invalid URLs
 473      */
 474     public function setAccessTokenUrl($url)
 475     {
 476         if (!Zend_Uri::check($url)) {
 477             require_once 'Zend/Oauth/Exception.php';
 478             throw new Zend_Oauth_Exception(
 479                 '\'' . $url . '\' is not a valid URI'
 480             );
 481         }
 482         $this->_accessTokenUrl = rtrim($url, '/');
 483         return $this;
 484     }
 485
 486     /**
 487      * Get access token URL
 488      *
 489      * If no access token URL has been set, but a site URL has, returns the
 490      * site URL with the string "/access_token" appended.
 491      *
 492      * @return string
 493      */
 494     public function getAccessTokenUrl()
 495     {
 496         if (!$this->_accessTokenUrl && $this->_siteUrl) {
 497             return $this->_siteUrl . '/access_token';
 498         }
 499         return $this->_accessTokenUrl;
 500     }
 501
 502     /**
 503      * Set user authorization URL
 504      *
 505      * @param  string $url
 506      * @return Zend_Oauth_Config
 507      * @throws Zend_Oauth_Exception for invalid URLs
 508      */
 509     public function setUserAuthorizationUrl($url)
 510     {
 511         return $this->setAuthorizeUrl($url);
 512     }
 513
 514     /**
 515      * Set authorization URL
 516      *
 517      * @param  string $url
 518      * @return Zend_Oauth_Config
 519      * @throws Zend_Oauth_Exception for invalid URLs
 520      */
 521     public function setAuthorizeUrl($url)
 522     {
 523         if (!Zend_Uri::check($url)) {
 524             require_once 'Zend/Oauth/Exception.php';
 525             throw new Zend_Oauth_Exception(
 526                 '\'' . $url . '\' is not a valid URI'
 527             );
 528         }
 529         $this->_authorizeUrl = rtrim($url, '/');
 530         return $this;
 531     }
 532
 533     /**
 534      * Get user authorization URL
 535      *
 536      * @return string
 537      */
 538     public function getUserAuthorizationUrl()
 539     {
 540         return $this->getAuthorizeUrl();
 541     }
 542
 543     /**
 544      * Get authorization URL
 545      *
 546      * If no authorization URL has been set, but a site URL has, returns the
 547      * site URL with the string "/authorize" appended.
 548      *
 549      * @return string
 550      */
 551     public function getAuthorizeUrl()
 552     {
 553         if (!$this->_authorizeUrl && $this->_siteUrl) {
 554             return $this->_siteUrl . '/authorize';
 555         }
 556         return $this->_authorizeUrl;
 557     }
 558
 559     /**
 560      * Set request method
 561      *
 562      * @param  string $method
 563      * @return Zend_Oauth_Config
 564      * @throws Zend_Oauth_Exception for invalid request methods
 565      */
 566     public function setRequestMethod($method)
 567     {
 568         $method = strtoupper($method);
 569         if (!in_array($method, array(
 570                 Zend_Oauth::GET,
 571                 Zend_Oauth::POST,
 572                 Zend_Oauth::PUT,
 573                 Zend_Oauth::DELETE,
 574             ))
 575         ) {
 576             require_once 'Zend/Oauth/Exception.php';
 577             throw new Zend_Oauth_Exception('Invalid method: ' . $method);
 578         }
 579         $this->_requestMethod = $method;
 580         return $this;
 581     }
 582
 583     /**
 584      * Get request method
 585      *
 586      * @return string
 587      */
 588     public function getRequestMethod()
 589     {
 590         return $this->_requestMethod;
 591     }
 592
 593     /**
 594      * Set RSA public key
 595      *
 596      * @param  Zend_Crypt_Rsa_Key_Public $key
 597      * @return Zend_Oauth_Config
 598      */
 599     public function setRsaPublicKey(Zend_Crypt_Rsa_Key_Public $key)
 600     {
 601         $this->_rsaPublicKey = $key;
 602         return $this;
 603     }
 604
 605     /**
 606      * Get RSA public key
 607      *
 608      * @return Zend_Crypt_Rsa_Key_Public
 609      */
 610     public function getRsaPublicKey()
 611     {
 612         return $this->_rsaPublicKey;
 613     }
 614
 615     /**
 616      * Set RSA private key
 617      *
 618      * @param  Zend_Crypt_Rsa_Key_Private $key
 619      * @return Zend_Oauth_Config
 620      */
 621     public function setRsaPrivateKey(Zend_Crypt_Rsa_Key_Private $key)
 622     {
 623         $this->_rsaPrivateKey = $key;
 624         return $this;
 625     }
 626
 627     /**
 628      * Get RSA private key
 629      *
 630      * @return Zend_Crypt_Rsa_Key_Private
 631      */
 632     public function getRsaPrivateKey()
 633     {
 634         return $this->_rsaPrivateKey;
 635     }
 636
 637     /**
 638      * Set OAuth token
 639      *
 640      * @param  Zend_Oauth_Token $token
 641      * @return Zend_Oauth_Config
 642      */
 643     public function setToken(Zend_Oauth_Token $token)
 644     {
 645         $this->_token = $token;
 646         return $this;
 647     }
 648
 649     /**
 650      * Get OAuth token
 651      *
 652      * @return Zend_Oauth_Token
 653      */
 654     public function getToken()
 655     {
 656         return $this->_token;
 657     }
 658 }