Source for file Discover.php

Documentation is available at Discover.php

  1. <?php
  2. /**
  3.  * OpenID_Discover
  4.  * 
  5.  * PHP Version 5.2.0+
  6.  * 
  7.  * @category  Auth
  8.  * @package   OpenID
  9.  * @author    Rich Schumacher <rich.schu@gmail.com>
  10.  * @copyright 2009 Rich Schumacher
  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.php';
  19. require_once 'Services/Yadis.php';
  20. require_once 'Validate.php';
  21. require_once 'OpenID/ServiceEndpoint.php';
  22. require_once 'OpenID/ServiceEndpoints.php';
  23. require_once 'OpenID/Discover/Exception.php';
  24. require_once 'Date.php';
  25.  
  26. /**
  27.  * OpenID_Discover
  28.  *
  29.  * Implements OpenID discovery ({@link }
  30.  * http://openid.net/specs/openid-authentication-2_0.html#discovery 7.3} of the 2.0
  31.  * spec).  Discovery is driver based, and currently supports YADIS discovery
  32.  * (via Services_Yadis), and HTML discovery ({@link OpenID_Discover_HTML}).  Once
  33.  * completed, it will also support {@link }
  34.  * http://www.hueniverse.com/hueniverse/2009/03/the-discovery-protocol-stack.html
  35.  * XRD/LRDD}.
  36.  * 
  37.  * Example usage for determining the OP Endpoint URL:
  38.  * <code>
  39.  * $id = 'http://user.example.com';
  40.  * 
  41.  * $discover = new OpenID_Discover($id);
  42.  * $result   = $discover->discover();
  43.  * 
  44.  * if (!$result) {
  45.  *     echo "Discovery failed\n";
  46.  * } else {
  47.  *     // Grab the highest priority service, and get it's first URI.
  48.  *     $endpoint      = $discover->services[0];
  49.  *     $opEndpointURL = array_shift($serviceEndpoint->getURIs());
  50.  * }
  51.  * </code>
  52.  * 
  53.  * @category  Auth
  54.  * @package   OpenID
  55.  * @author    Bill Shupp <hostmaster@shupp.org>
  56.  * @author    Rich Schumacher <rich.schu@gmail.com>
  57.  * @copyright 2009 Bill Shupp
  58.  * @license   http://www.opensource.org/licenses/bsd-license.php FreeBSD
  59.  * @link      http://pearopenid.googlecode.com
  60.  */
  61. class OpenID_Discover
  62. {
  63.     const TYPE_YADIS = 'Yadis';
  64.     const TYPE_HTML  = 'HTML';
  65.  
  66.     /**
  67.      * List of supported discover types
  68.      * 
  69.      * @var array 
  70.      */
  71.     protected $supportedTypes = array(
  72.         self::TYPE_YADIS,
  73.         self::TYPE_HTML
  74.     );
  75.  
  76.     /**
  77.      * Order that discover should be performed
  78.      *
  79.      * @var array 
  80.      */
  81.     static public $discoveryOrder = array(
  82.         0  => OpenID_Discover::TYPE_YADIS,
  83.         10 => OpenID_Discover::TYPE_HTML
  84.     );
  85.  
  86.     /**
  87.      * The normalized version of the user supplied identifier
  88.      * 
  89.      * @var string 
  90.      */
  91.     protected $identifier = null;
  92.  
  93.     /**
  94.      * HTTP_Request2 options
  95.      * 
  96.      * @var array 
  97.      */
  98.     protected $requestOptions = array(
  99.         'adapter'          => 'curl',
  100.         'follow_redirects' => true,
  101.         'timeout'          => 3,
  102.         'connect_timeout'  => 3
  103.     );
  104.  
  105.     /**
  106.      * Instance of OpenID_ServiceEndpoints
  107.      * 
  108.      * @var OpenID_ServiceEndpoints 
  109.      */
  110.     protected $services = null;
  111.  
  112.     /**
  113.      * Constructor.  Enables libxml internal errors, normalized the identifier.
  114.      * 
  115.      * @param mixed $identifier The user supplied identifier
  116.      * 
  117.      * @return void 
  118.      */
  119.     public function __construct($identifier)
  120.     {
  121.         libxml_use_internal_errors(true);
  122.         $this->identifier = OpenID::normalizeIdentifier($identifier);
  123.     }
  124.  
  125.     /**
  126.      * Gets member variables
  127.      * 
  128.      * @param string $name Name of the member variable to get
  129.      * 
  130.      * @return mixed The member variable if it exists
  131.      */
  132.     public function __get($name)
  133.     {
  134.         if (property_exists($this, $name)) {
  135.             return $this->$name;
  136.         }
  137.         return null;
  138.     }
  139.  
  140.     /**
  141.      * Sets the HTTP_Request2 options to use
  142.      * 
  143.      * @param array $options Array of HTTP_Request2 options
  144.      * 
  145.      * @return OpenID_Discover for fluent interface
  146.      */
  147.     public function setRequestOptions(array $options)
  148.     {
  149.         $this->requestOptions = $options;
  150.         return $this;
  151.     }
  152.  
  153.     /**
  154. /**
  155.      * Performs discovery
  156.      * 
  157.      * @return bool true on success, false on failure
  158.      */
  159.     public function discover()
  160.     {
  161.         // Sort ascending
  162.         ksort(self::$discoveryOrder);
  163.  
  164.         foreach (self::$discoveryOrder as $service) {
  165.             try {
  166.                 $discover = self::_factory($service, $this->identifier);
  167.                 $result   = $discover->discover();
  168.             } catch (OpenID_Discover_Exception $e) {
  169.                 continue;
  170.             }
  171.  
  172.             if ($result instanceof OpenID_ServiceEndpoints && isset($result[0])) {
  173.                 $this->services = $result;
  174.                 return true;
  175.             }
  176.         }
  177.  
  178.         return false;
  179.     }
  180.  
  181.     /**
  182.      * Provides the standard factory pattern for loading discovery drivers.
  183.      * 
  184.      * @param string $discoverType The discovery type (driver) to load
  185.      * @param string $identifier   The user supplied identifier
  186.      * 
  187.      * @return void 
  188.      */
  189.     static private function _factory($discoverType, $identifier)
  190.     {
  191.         $file  = 'OpenID/Discover/' . $discoverType . '.php';
  192.         $class = 'OpenID_Discover_' . $discoverType;
  193.  
  194.         include_once $file;
  195.  
  196.         if (!class_exists($class)) {
  197.             throw new OpenID_Discover_Exception(
  198.                 'Unable to load driver: ' . $discoverType
  199.             );
  200.         }
  201.  
  202.         $object = new $class($identifier);
  203.  
  204.         if (!$object instanceof OpenID_Discover_Interface) {
  205.             throw new OpenID_Discover_Exception(
  206.                 'Requested driver does not conform to Discover interface'
  207.             );
  208.         }
  209.  
  210.         return $object;
  211.     }
  212.  
  213.     /**
  214.      * Determines if dicovered information supports a given OpenID extension
  215.      * 
  216.      * @param string $extension The name of the extension to check, (SREG10, AX, etc)
  217.      * 
  218.      * @return bool 
  219.      */
  220.     public function extensionSupported($extension)
  221.     {
  222.         $class = 'OpenID_Extension_' . $extension;
  223.         $file  = str_replace('_', '/', $class) . '.php';
  224.  
  225.         include_once $file;
  226.  
  227.         if (!class_exists($class, false)) {
  228.             throw new OpenID_Discover_Exception(
  229.                 'Unknown extension: ' . $class
  230.             );
  231.         }
  232.  
  233.         $instance = new $class(OpenID_Extension::REQUEST);
  234.  
  235.         foreach ($this->services as $service) {
  236.             if (in_array($instance->getNamespace(), $service->getTypes())) {
  237.                 return true;
  238.             }
  239.         }
  240.  
  241.         return false;
  242.     }
  243.  
  244.     /**
  245.      * Static helper method for retrieving discovered information from cache if it
  246.      * exists, otherwise executing discovery and storing results if they are
  247.      * positive.
  248.      * 
  249.      * @param string       $id    URI Identifier to discover
  250.      * @param OpenID_Store $store Instance of OpenID_Store
  251.      * 
  252.      * @return OpenID_Discover|falseOpenID_Discover on success, false on failure
  253.      */
  254.     static public function getDiscover($id, OpenID_Store_Interface $store)
  255.     {
  256.         $discoverCache = $store->getDiscover($id);
  257.  
  258.         if ($discoverCache instanceof OpenID_Discover) {
  259.             return $discoverCache;
  260.         }
  261.  
  262.         $discover = new OpenID_Discover($id);
  263.         $result   = $discover->discover();
  264.         if ($result === false) {
  265.             // @codeCoverageIgnoreStart
  266.             return false;
  267.             // @codeCoverageIgnoreEnd
  268.         }
  269.  
  270.         $expireTime = null;
  271.         if ($discover->services->getExpiresHeader()) {
  272.             $tz  = new Date_TimeZone(date_default_timezone_get());
  273.             $now = new Date();
  274.             $now->setTZ($tz);
  275.  
  276.             $expireDate = new Date(strtotime($discover->services
  277.                                                       ->getExpiresHeader()));
  278.             $span       = new Date_Span($now, $expireDate);
  279.             $expire     = (int)$span->toSeconds();
  280.         }
  281.  
  282.         $store->setDiscover($discover, $expireTime);
  283.  
  284.         return $discover;
  285.     }
  286. }
  287.  
  288. ?>

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