Source for file Request.php

Documentation is available at Request.php

  1. <?php
  2. /**
  3.  * OpenID_Auth_Request
  4.  * 
  5.  * PHP Version 5.2.0+
  6.  * 
  7.  * @category  Auth
  8.  * @package   OpenID
  9.  * @author    Bill Shupp <hostmaster@shupp.org>
  10.  * @copyright 2009 Bill Shupp
  11.  * @license   http://www.opensource.org/licenses/bsd-license.php FreeBSD
  12.  * @link      http://pearopenid.googlecode.com
  13.  */
  14.  
  15. /**
  16.  * Required files
  17.  */
  18. require_once 'Net/URL2.php';
  19. require_once 'OpenID.php';
  20. require_once 'OpenID/Auth/Exception.php';
  21. require_once 'OpenID/Message.php';
  22. require_once 'OpenID/Nonce.php';
  23.  
  24. /**
  25.  * Creates an OpenID authorization request of type "checkid_setup" or
  26.  * "checkid_immediate".
  27.  * 
  28.  * Example:
  29.  * <code>
  30.  * // First perform discovery on the user supplied identifier
  31.  * $discover = new OpenID_Discover($identifier);
  32.  * $discover->discover();
  33.  * 
  34.  * // Optionally get association (from cache in this example)
  35.  * $opEndpointURL = array_shift($discover->services[0]->getURIs());
  36.  * $assocHandle   = OpenID::getStore()->getAssociation($opEndpointURL)->assocHandle;
  37.  * 
  38.  * // Now create the auth request object
  39.  * $auth = new OpenID_Auth_Request($discover,     // OpenID_Discover object
  40.  *                                 $returnTo,     // openid.return_to
  41.  *                                 $realm,        // openid.realm
  42.  *                                 $assocHandle); // openid.assoc_handle
  43.  * 
  44.  * // Optionally add an extension
  45.  *  $sreg = new OpenID_Extension_SREG11(OpenID_Extension::REQUEST);
  46.  *  $sreg->set('required', 'email');
  47.  *  $sreg->set('optional', 'nickname,gender,dob');
  48.  *
  49.  *  // Add it to an existing instance of OpenID_Auth_Request
  50.  *  $auth->addExtension($sreg);
  51.  * 
  52.  * // Optionally make this a checkid_immediate request
  53.  * $auth->setMode(OpenID::MODE_CHECKID_IMMEDIATE);
  54.  * 
  55.  * // Send user to the OP
  56.  * header('Location: ' . $auth->getAuthorizeURL());
  57.  * </code>
  58.  * 
  59.  * @category  Auth
  60.  * @package   OpenID
  61.  * @author    Bill Shupp <hostmaster@shupp.org>
  62.  * @copyright 2009 Bill Shupp
  63.  * @license   http://www.opensource.org/licenses/bsd-license.php FreeBSD
  64.  * @link      http://pearopenid.googlecode.com
  65.  */
  66. class OpenID_Auth_Request
  67. {
  68.     /**
  69.      * The normalized identifier
  70.      * 
  71.      * @var string 
  72.      */
  73.     protected $identifier = null;
  74.  
  75.     /**
  76.      * The request message
  77.      * 
  78.      * @var OpenID_Message 
  79.      */
  80.     protected $message = null;
  81.  
  82.     /**
  83.      * The OP Endpoint we are communicating with
  84.      * 
  85.      * @var OpenID_ServiceEndpoint 
  86.      */
  87.     protected $serviceEndpoint = null;
  88.  
  89.     /**
  90.      * Nonce class in case we are in 1.1 mode and need to embed it in the return_to
  91.      * 
  92.      * @var OpenID_Nonce 
  93.      */
  94.     protected $nonce = null;
  95.  
  96.  
  97.     /**
  98.      * Sets the basic information used in the message.
  99.      * 
  100.      * @param OpenID_Discover $discover    Discover object
  101.      * @param string          $returnTo    The return_to URL
  102.      * @param string          $realm       The realm
  103.      * @param string          $assocHandle The optional association handle
  104.      * 
  105.      * @return void 
  106.      */
  107.     public function __construct(OpenID_Discover $discover,
  108.                                 $returnTo,
  109.                                 $realm,
  110.                                 $assocHandle = null)
  111.     {
  112.         $this->identifier      = $discover->identifier;
  113.         $this->serviceEndpoint = $discover->services[0];
  114.         $this->message         = new OpenID_Message();
  115.  
  116.         // Only set NS for 2.0
  117.         $versionFromMap = OpenID::$versionMap[$this->serviceEndpoint->getVersion()];
  118.         if ($versionFromMap == OpenID::NS_2_0) {
  119.             $this->message->set('openid.ns', $versionFromMap);
  120.         }
  121.         $this->message->set('openid.return_to', $returnTo);
  122.         $this->message->set('openid.realm', $realm);
  123.  
  124.         if (!empty($assocHandle)) {
  125.             $this->message->set('openid.assoc_handle', $assocHandle);
  126.         }
  127.  
  128.         // Default to checkid_setup
  129.         $this->setMode(OpenID::MODE_CHECKID_SETUP);
  130.     }
  131.  
  132.     /**
  133.      * Adds an extension to the message.
  134.      * 
  135.      * @param OpenID_Extension $extension Extension instance
  136.      * 
  137.      * @return void 
  138.      */
  139.     public function addExtension(OpenID_Extension $extension)
  140.     {
  141.         $this->message->addExtension($extension);
  142.     }
  143.  
  144.     /**
  145.      * Sets the openid.mode parameter.  Can be either "checkid_setup" or
  146.      * "checkid_immediate"
  147.      * 
  148.      * @param mixed $mode Value for 'openid.mode'
  149.      * 
  150.      * @throws OpenID_Auth_Exception on an invalid mode
  151.      * @return void 
  152.      */
  153.     public function setMode($mode)
  154.     {
  155.         switch ($mode) {
  156.         case OpenID::MODE_CHECKID_SETUP:
  157.         case OpenID::MODE_CHECKID_IMMEDIATE:
  158.             $this->message->set('openid.mode', $mode);
  159.             break;
  160.         default:
  161.             throw new OpenID_Auth_Exception(
  162.                 'Invalid openid.mode: ' . $mode
  163.             );
  164.         }
  165.     }
  166.  
  167.     /**
  168.      * Gets the current openid.mode value
  169.      * 
  170.      * @return string 
  171.      */
  172.     public function getMode()
  173.     {
  174.         return $this->message->get('openid.mode');
  175.     }
  176.  
  177.     /**
  178.      * Gets the auth request message in a URL format suitable for redirection.  The
  179.      * decision about whether to use directed identity or not id done here.
  180.      * 
  181.      * @return string The URL to redirect the User-Agent to
  182.      */
  183.     public function getAuthorizeURL()
  184.     {
  185.         $version = OpenID::$versionMap[$this->serviceEndpoint->getVersion()];
  186.  
  187.         if ($this->serviceEndpoint->getVersion() == OpenID::SERVICE_2_0_SERVER) {
  188.             $this->message->set('openid.claimed_id', OpenID::NS_2_0_ID_SELECT);
  189.             $this->message->set('openid.identity', OpenID::NS_2_0_ID_SELECT);
  190.         } else {
  191.             $localID = $this->serviceEndpoint->getLocalID();
  192.             if (!empty($localID)) {
  193.                 if ($version == OpenID::NS_2_0) {
  194.                     $this->message->set('openid.claimed_id', $this->identifier);
  195.                 }
  196.                 $this->message->set('openid.identity', $localID);
  197.             } else {
  198.                 if ($version == OpenID::NS_2_0) {
  199.                     $this->message->set('openid.claimed_id', $this->identifier);
  200.                 }
  201.                 $this->message->set('openid.identity', $this->identifier);
  202.             }
  203.         }
  204.  
  205.         if ($version == OpenID::NS_1_1) {
  206.             $this->addNonce();
  207.         }
  208.  
  209.         $urls   = $this->serviceEndpoint->getURIs();
  210.         $url    = $urls[0] . '?' . $this->message->getHTTPFormat();
  211.         $netURL = new Net_URL2($url);
  212.  
  213.         return $netURL->getURL();
  214.     }
  215.  
  216.     /**
  217.      * Sets the instance of OpenID_Nonce for use with 1.1 return_to nonces
  218.      * 
  219.      * @param OpenID_Nonce $nonce Custom instance of OpenID_Nonce
  220.      * 
  221.      * @return void 
  222.      */
  223.     public function setNonce(OpenID_Nonce $nonce)
  224.     {
  225.         $this->nonce = $nonce;
  226.     }
  227.  
  228.     /**
  229.      * Gets the OpenID_Nonce instance if set, otherwise instantiates one.
  230.      * 
  231.      * @return OpenID_Nonce 
  232.      */
  233.     protected function getNonce()
  234.     {
  235.         if ($this->nonce instanceof OpenID_Nonce) {
  236.             return $this->nonce;
  237.         }
  238.         return new OpenID_Nonce(array_shift($this->serviceEndpoint->getURIs()));
  239.     }
  240.  
  241.     /**
  242.      * Adds a nonce to the openid.return_to URL parameter.  Only used in OpenID 1.1
  243.      * 
  244.      * @return void 
  245.      */
  246.     protected function addNonce()
  247.     {
  248.         $nonce       = $this->getNonce()->createNonceAndStore();
  249.         $returnToURL = new Net_URL2($this->message->get('openid.return_to'));
  250.         $returnToURL->setQueryVariable(OpenID_Nonce::RETURN_TO_NONCE,
  251.                                        urlencode($nonce));
  252.  
  253.         $this->message->set('openid.return_to', $returnToURL->getURL());
  254.  
  255.         // Observing
  256.         $logMessage  = "Nonce: $nonce\n";
  257.         $logMessage  = 'New ReturnTo: ' . $returnToURL->getURL() . "\n";
  258.         $logMessage .= 'OP URIs: ' . print_r($this->serviceEndpoint->getURIs(),
  259.                                              true);
  260.         OpenID::setLastEvent(__METHOD__, $logMessage);
  261.     }
  262. }
  263. ?>

Documentation generated on Tue, 15 Dec 2009 19:00:58 -0800 by phpDocumentor 1.4.3