Source for file OpenID.php

Documentation is available at OpenID.php

  1. <?php
  2. /**
  3.  * OpenID
  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 'OpenID/Exception.php';
  19. require_once 'HTTP/Request2.php';
  20. require_once 'Validate.php';
  21. require_once 'OpenID/Message.php';
  22. require_once 'OpenID/Store.php';
  23.  
  24. /**
  25.  * OpenID
  26.  * 
  27.  * Base OpenID class.  Contains common constants and helper static methods, as well
  28.  * as the directRequest() method, which handles direct communications.  It also
  29.  * is a common place to assign your custom Storage class and Observers.
  30.  * 
  31.  * @category  Auth
  32.  * @package   OpenID
  33.  * @author    Bill Shupp <hostmaster@shupp.org>
  34.  * @copyright 2009 Bill Shupp
  35.  * @license   http://www.opensource.org/licenses/bsd-license.php FreeBSD
  36.  * @link      http://pearopenid.googlecode.com
  37.  * @see       OpenID_Observer_Common
  38.  * @see       OpenID_Store
  39.  */
  40. class OpenID
  41. {
  42.     /**
  43.      *  OP identifier constants
  44.      */
  45.     const NS_2_0 = 'http://specs.openid.net/auth/2.0';
  46.     const NS_1_1 = 'http://openid.net/signon/1.1';
  47.  
  48.     const NS_2_0_ID_SELECT = 'http://specs.openid.net/auth/2.0/identifier_select';
  49.  
  50.     const SERVICE_2_0_SERVER = 'http://specs.openid.net/auth/2.0/server';
  51.     const SERVICE_2_0_SIGNON = 'http://specs.openid.net/auth/2.0/signon';
  52.     const SERVICE_1_1_SIGNON = 'http://openid.net/signon/1.1';
  53.     const SERVICE_1_0_SIGNON = 'http://openid.net/signon/1.0';
  54.  
  55.     /**
  56.      * A map of which service types (versions) map to which protocol version.  1.0
  57.      * is mapped to 1.1.  This is mostly helpful to see if openid.ns is supported.
  58.      *
  59.      * @var $versionMap 
  60.      */
  61.     static public $versionMap = array(
  62.         self::SERVICE_2_0_SERVER => self::NS_2_0,
  63.         self::SERVICE_2_0_SIGNON => self::NS_2_0,
  64.         self::SERVICE_1_1_SIGNON => self::NS_1_1,
  65.         self::SERVICE_1_0_SIGNON => self::NS_1_1,
  66.     );
  67.  
  68.     /**
  69.      * Supported Association Hash Algorithms (preferred)
  70.      */
  71.     const HASH_ALGORITHM_2_0 = 'SHA256';
  72.     const HASH_ALGORITHM_1_1 = 'SHA1';
  73.  
  74.     /**
  75.      * OpenID Modes
  76.      */
  77.     const MODE_ASSOCIATE            = 'associate';
  78.     const MODE_CHECKID_SETUP        = 'checkid_setup';
  79.     const MODE_CHECKID_IMMEDIATE    = 'checkid_immediate';
  80.     const MODE_CHECK_AUTHENTICATION = 'check_authentication';
  81.     const MODE_ID_RES               = 'id_res';
  82.     const MODE_CANCEL               = 'cancel';
  83.     const MODE_SETUP_NEEDED         = 'setup_needed';
  84.     const MODE_ERROR                = 'error';
  85.  
  86.     /*
  87.      * Association constants
  88.      */
  89.     const SESSION_TYPE_NO_ENCRYPTION = 'no-encryption';
  90.     const SESSION_TYPE_DH_SHA1       = 'DH-SHA1';
  91.     const SESSION_TYPE_DH_SHA256     = 'DH-SHA256';
  92.  
  93.     const ASSOC_TYPE_HMAC_SHA1   = 'HMAC-SHA1';
  94.     const ASSOC_TYPE_HMAC_SHA256 = 'HMAC-SHA256';
  95.  
  96.     /**
  97.      * Instance of OpenID_Store_Interface
  98.      *
  99.      * @var $store 
  100.      * @see setStore()
  101.      */
  102.     static protected $store = null;
  103.  
  104.     /**
  105.      * Array of attached observers
  106.      *
  107.      * @var $observers 
  108.      */
  109.     static protected $observers = array();
  110.  
  111.     /**
  112.      * Stores the last event
  113.      *  
  114.      * @var $lastEvent 
  115.      */
  116.     static protected $lastEvent = array(
  117.         'name' => 'start',
  118.         'data' => null
  119.     );
  120.  
  121.     /**
  122.      * Attaches an observer
  123.      * 
  124.      * @param OpenID_Observer_Common $observer Observer object
  125.      * 
  126.      * @see OpenID_Observer_Log
  127.      * @return void 
  128.      */
  129.     static public function attach(OpenID_Observer_Common $observer)
  130.     {
  131.         foreach (self::$observers as $attached) {
  132.             if ($attached === $observer) {
  133.                 return;
  134.             }
  135.         }
  136.         self::$observers[] = $observer;
  137.     }
  138.  
  139.     /**
  140.      * Detaches the observer
  141.      * 
  142.      * @param OpenID_Observer_Common $observer Observer object
  143.      * 
  144.      * @return void 
  145.      */
  146.     static public function detach(OpenID_Observer_Common $observer)
  147.     {
  148.         foreach (self::$observers as $key => $attached) {
  149.             if ($attached === $observer) {
  150.                 unset(self::$observers[$key]);
  151.                 return;
  152.             }
  153.         }
  154.     }
  155.  
  156.     /**
  157.      * Notifies all observers of an event
  158.      * 
  159.      * @return void 
  160.      */
  161.     static public function notify()
  162.     {
  163.         foreach (self::$observers as $observer) {
  164.             $observer->update(self::getLastEvent());
  165.         }
  166.     }
  167.  
  168.     /**
  169.      * Sets the last event and notifies the observers
  170.      * 
  171.      * @param string $name Name of the event
  172.      * @param mixed  $data The event's data
  173.      * 
  174.      * @return void 
  175.      */
  176.     static public function setLastEvent($name, $data)
  177.     {
  178.         self::$lastEvent = array(
  179.             'name' => $name,
  180.             'data' => $data
  181.         );
  182.         self::notify();
  183.     }
  184.  
  185.     /**
  186.      * Gets the last event
  187.      * 
  188.      * @return void 
  189.      */
  190.     static public function getLastEvent()
  191.     {
  192.         return self::$lastEvent;
  193.     }
  194.  
  195.     /**
  196.      * Sets a custom OpenID_Store_Interface object
  197.      * 
  198.      * @param OpenID_Store_Interface $store Custom storage instance
  199.      * 
  200.      * @return void 
  201.      */
  202.     static public function setStore(OpenID_Store_Interface $store)
  203.     {
  204.         self::$store = $store;
  205.     }
  206.  
  207.     /**
  208.      * Gets the OpenID_Store_Interface instance.  If none has been set, then the
  209.      * default store is used (CacheLite).
  210.      * 
  211.      * @return OpenID_Store_Interface 
  212.      */
  213.     static public function getStore()
  214.     {
  215.         if (!self::$store instanceof OpenID_Store_Interface) {
  216.             self::$store = OpenID_Store::factory();
  217.         }
  218.  
  219.         return self::$store;
  220.     }
  221.  
  222.     /**
  223.      * Sends a direct HTTP request.
  224.      * 
  225.      * @param string         $url     URL to send the request to
  226.      * @param OpenID_Message $message Contains message contents
  227.      * @param array          $options Options to pass to HTTP_Request2
  228.      * 
  229.      * @see getHTTPRequest2Instance()
  230.      * @throws OpenID_Exception if send() fails
  231.      * @return HTTP_Request2_Response 
  232.      */
  233.     public function directRequest($url,
  234.                                   OpenID_Message $message, 
  235.                                   array $options = array())
  236.     {
  237.         $request = $this->getHTTPRequest2Instance();
  238.         $request->setConfig($options);
  239.         $request->setURL($url);
  240.         // Require POST, per the spec
  241.         $request->setMethod(HTTP_Request2::METHOD_POST);
  242.         $request->setBody($message->getHTTPFormat());
  243.         try {
  244.             return $request->send();
  245.         } catch (HTTP_Request2_Exception $e) {
  246.             throw new OpenID_Exception($e->getMessage(), $e->getCode());
  247.         }
  248.     }
  249.  
  250.     /**
  251.      * Instantiates HTTP_Request2.  Abstracted for testing.
  252.      * 
  253.      * @see directRequest()
  254.      * @return HTTP_Request2_Response 
  255.      */
  256.     protected function getHTTPRequest2Instance()
  257.     {
  258.         // @codeCoverageIgnoreStart
  259.         $request = new HTTP_Request2();
  260.         $request->setAdapter('curl');
  261.         return $request;
  262.         // @codeCoverageIgnoreEnd
  263.     }
  264.  
  265.     /**
  266.      * Returns an array of the 5 XRI globals symbols
  267.      * 
  268.      * @return void 
  269.      */
  270.     static public function getXRIGlobalSymbols()
  271.     {
  272.         return array('=', '@', '+', '$', '!');
  273.     }
  274.  
  275.     /**
  276.      * Normalizes an identifier (URI or XRI)
  277.      * 
  278.      * @param mixed $identifier URI or XRI to be normalized
  279.      * 
  280.      * @throws OpenID_Exception on invalid identifier
  281.      * @return string Normalized Identifier.
  282.      */
  283.     static public function normalizeIdentifier($identifier)
  284.     {
  285.         // XRI
  286.         if (preg_match('@^xri://@i', $identifier)) {
  287.             return preg_replace('@^xri://@i', '', $identifier);
  288.         }
  289.  
  290.         if (in_array($identifier[0], self::getXRIGlobalSymbols())) {
  291.             return $identifier;
  292.         }
  293.  
  294.         // URL
  295.         if (!preg_match('@^http[s]?://@i', $identifier)) {
  296.             $identifier = 'http://' . $identifier;
  297.         }
  298.         if (Validate::uri($identifier)) {
  299.             return $identifier;
  300.         }
  301.         throw new OpenID_Exception('Invalid URI Identifier');
  302.     }
  303.  
  304. }
  305. ?>

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