Source for file Extension.php

Documentation is available at Extension.php

  1. <?php
  2. /**
  3.  * OpenID_Extension
  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/Extension/Exception.php';
  19.  
  20. /**
  21.  * OpenID_Extension
  22.  * 
  23.  * Base class for creating OpenID message extensions.
  24.  * 
  25.  * @category  Auth
  26.  * @package   OpenID
  27.  * @author    Bill Shupp <hostmaster@shupp.org>
  28.  * @copyright 2009 Bill Shupp
  29.  * @license   http://www.opensource.org/licenses/bsd-license.php FreeBSD
  30.  * @link      http://pearopenid.googlecode.com
  31.  */
  32. abstract class OpenID_Extension
  33. {
  34.     const REQUEST  = 'request';
  35.     const RESPONSE = 'response';
  36.  
  37.     /**
  38.      *  @var array Array of reserved message keys
  39.      */
  40.     static protected $reserved = array(
  41.         'assoc_handle',
  42.         'assoc_type',
  43.         'claimed_id',
  44.         'contact',
  45.         'delegate',
  46.         'dh_consumer_public',
  47.         'dh_gen',
  48.         'dh_modulus',
  49.         'error',
  50.         'identity',
  51.         'invalidate_handle',
  52.         'mode',
  53.         'ns',
  54.         'op_endpoint',
  55.         'openid',
  56.         'realm',
  57.         'reference',
  58.         'response_nonce',
  59.         'return_to',
  60.         'server',
  61.         'session_type',
  62.         'sig',
  63.         'signed',
  64.         'trust_root ',
  65.     );
  66.  
  67.     /**
  68.      * Whether or not to use namespace alias assignments (for SREG 1.0 mostly)
  69.      * 
  70.      * @var bool 
  71.      */
  72.     protected $useNamespaceAlias = true;
  73.  
  74.     /**
  75.      * Type of message - 'request' or 'response'
  76.      * 
  77.      * @var string 
  78.      */
  79.     protected $type = self::REQUEST;
  80.  
  81.     /**
  82.      * Namespace URI
  83.      * 
  84.      * @see getNamespace()
  85.      * @var string 
  86.      */
  87.     protected $namespace = null;
  88.  
  89.     /**
  90.      * Namespace text, "sreg" or "ax" for example
  91.      * 
  92.      * @var string 
  93.      */
  94.     protected $alias = null;
  95.  
  96.     /**
  97.      * Keys appropriate for a request.  Leave empty to allow any keys.
  98.      * 
  99.      * @var array 
  100.      */
  101.     protected $requestKeys = array();
  102.  
  103.     /**
  104.      * Keys appropriate for a response.  Leave empty to allow any keys.
  105.      * 
  106.      * @var array 
  107.      */
  108.     protected $responseKeys = array();
  109.  
  110.     /**
  111.      * values
  112.      * 
  113.      * @var array 
  114.      */
  115.     protected $values = array();
  116.  
  117.     /**
  118.      * Sets the message type, request or response
  119.      * 
  120.      * @param string $type type response or type request
  121.      * 
  122.      * @throws OpenID_Extension_Exception on invalid type argument
  123.      * @return void 
  124.      */
  125.     public function __construct($type)
  126.     {
  127.         if ($type != self::REQUEST && $type != self::RESPONSE) {
  128.             throw new OpenID_Extension_Exception('Invalid message type: ' . $type);
  129.         }
  130.         $this->type = $type;
  131.     }
  132.  
  133.     /**
  134.      * Sets a key value pair
  135.      * 
  136.      * @param string $key   Key
  137.      * @param string $value Value
  138.      * 
  139.      * @throws OpenID_Extension_Exception on invalid key argument
  140.      * @return void 
  141.      */
  142.     public function set($key, $value)
  143.     {
  144.         $keys = $this->responseKeys;
  145.         if ($this->type == self::REQUEST) {
  146.             $keys = $this->requestKeys;
  147.         }
  148.  
  149.         if (count($keys) && !in_array($key, $keys)) {
  150.             throw new OpenID_Extension_Exception('Invalid key: ' . $key);
  151.         }
  152.         $this->values[$key] = $value;
  153.     }
  154.  
  155.     /**
  156.      * Gets a key's value
  157.      * 
  158.      * @param string $key Key
  159.      * 
  160.      * @return mixed Key's value
  161.      */
  162.     public function get($key)
  163.     {
  164.         if (isset($this->values[$key])) {
  165.             return $this->values[$key];
  166.         }
  167.         return null;
  168.     }
  169.  
  170.     /**
  171.      * Adds the extension contents to an OpenID_Message
  172.      * 
  173.      * @param OpenID_Message $message Message to add the extension contents to
  174.      * 
  175.      * @throws OpenID_Extension_Exception on error
  176.      * @return void 
  177.      */
  178.     public function toMessage(OpenID_Message $message)
  179.     {
  180.         // Make sure we have a valid alias name
  181.         if (empty($this->alias) || in_array($this->alias, self::$reserved)) {
  182.             throw new OpenID_Extension_Exception(
  183.                 'Invalid extension alias' . $this->alias
  184.             );
  185.         }
  186.  
  187.         $namespaceAlias = 'openid.ns.' . $this->alias;
  188.  
  189.         // Make sure the alias doesn't collide
  190.         if ($message->get($namespaceAlias) !== null) {
  191.             throw new OpenID_Extension_Exception(
  192.                 'Extension alias ' . $this->alias . ' is already set'
  193.             );
  194.         }
  195.  
  196.         // Add alias assignment? (SREG 1.0 Doesn't use one)
  197.         if ($this->useNamespaceAlias) {
  198.             $message->set($namespaceAlias, $this->namespace);
  199.         }
  200.  
  201.         foreach ($this->values as $key => $value) {
  202.             $message->set('openid.' . $this->alias . '.' . $key, $value);
  203.         }
  204.     }
  205.  
  206.     /**
  207.      * Extracts extension contents from an OpenID_Message
  208.      * 
  209.      * @param OpenID_Message $message OpenID_Message to extract the extension
  210.      *                                 contents from
  211.      * 
  212.      * @return array An array of the extension's key/value pairs
  213.      */
  214.     public function fromMessageResponse(OpenID_Message $message)
  215.     {
  216.         $values = array();
  217.         $alias  = null;
  218.  
  219.         foreach ($message->getArrayFormat() as $ns => $value) {
  220.             if (!preg_match('/^openid[.]ns[.]([^.].*)$/', $ns, $matches)) {
  221.                 continue;
  222.             }
  223.             $nsFromMessage = $message->get('openid.ns.' . $matches[1]);
  224.             if ($nsFromMessage !== null && $nsFromMessage != $this->namespace) {
  225.                 continue;
  226.             }
  227.             $alias = $matches[1];
  228.         }
  229.  
  230.         if ($alias === null) {
  231.             return $values;
  232.         }
  233.  
  234.         if (count($this->responseKeys)) {
  235.             // Only use allowed response keys
  236.             foreach ($this->responseKeys as $key) {
  237.                 $value = $message->get('openid.' . $alias . '.' . $key);
  238.                 if ($value !== null) {
  239.                     $values[$key] = $value;
  240.                 }
  241.             }
  242.         } else {
  243.             // Just grab all message components
  244.             foreach ($message->getArrayFormat() as $key => $value) {
  245.                 if (!preg_match('/^openid[.]' . $this->alias . '[.]/', $key)) {
  246.                     $values[$key] = $value;
  247.                 }
  248.             }
  249.         }
  250.         return $values;
  251.     }
  252.  
  253.     /**
  254.      * Gets the namespace of this extension
  255.      * 
  256.      * @see $namespace
  257.      * @return string 
  258.      */
  259.     public function getNamespace()
  260.     {
  261.         return $this->namespace;
  262.     }
  263. }
  264. ?>

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