Support Joomla!

Joomla! 1.5 Documentation

Packages

Package: Yadis

Developer Network License

The Joomla! Developer Network content is © copyright 2006 by the individual contributors and can be used in accordance with the Creative Commons License, Attribution- NonCommercial- ShareAlike 2.5
Source code for file /openid/Services/Yadis/XRDS.php

Documentation is available at XRDS.php

  1. <?php
  2.  
  3. /**
  4.  * This module contains the XRDS parsing code.
  5.  *
  6.  * PHP versions 4 and 5
  7.  *
  8.  * LICENSE: See the COPYING file included in this distribution.
  9.  *
  10.  * @package Yadis
  11.  * @author JanRain, Inc. <[email protected]>
  12.  * @copyright 2005 Janrain, Inc.
  13.  * @license http://www.gnu.org/copyleft/lesser.html LGPL
  14.  */
  15.  
  16. /**
  17.  * Require the XPath implementation.
  18.  */
  19. require_once 'Services/Yadis/XML.php';
  20.  
  21. /**
  22.  * This match mode means a given service must match ALL filters passed
  23.  * to the Services_Yadis_XRDS::services() call.
  24.  */
  25. define('SERVICES_YADIS_MATCH_ALL', 101);
  26.  
  27. /**
  28.  * This match mode means a given service must match ANY filters (at
  29.  * least one) passed to the Services_Yadis_XRDS::services() call.
  30.  */
  31. define('SERVICES_YADIS_MATCH_ANY', 102);
  32.  
  33. global $_Services_Yadis_ns_map;
  34. $_Services_Yadis_ns_map = array('xrds' => 'xri://$xrds',
  35.                                 'xrd' => 'xri://$xrd*($v*2.0)');
  36.  
  37. define('SERVICES_YADIS_MAX_PRIORITY', pow(2, 30));
  38.  
  39. /**
  40.  * @access private
  41.  */
  42. function Services_Yadis_array_scramble($arr)
  43. {
  44.     $result = array();
  45.  
  46.     while (count($arr)) {
  47.         $index = array_rand($arr, 1);
  48.         $result[] = $arr[$index];
  49.         unset($arr[$index]);
  50.     }
  51.  
  52.     return $result;
  53. }
  54.  
  55. /**
  56.  * This class represents a <Service> element in an XRDS document.
  57.  * Objects of this type are returned by
  58.  * Services_Yadis_XRDS::services() and
  59.  * Services_Yadis_Yadis::services().  Each object corresponds directly
  60.  * to a <Service> element in the XRDS and supplies a
  61.  * getElements($name) method which you should use to inspect the
  62.  * element's contents.  See {@link Services_Yadis_Yadis} for more
  63.  * information on the role this class plays in Yadis discovery.
  64.  *
  65.  * @package Yadis
  66.  */
  67. class Services_Yadis_Service {
  68.  
  69.     /**
  70.      * Creates an empty service object.
  71.      */
  72.     function Services_Yadis_Service()
  73.     {
  74.         $this->element = null;
  75.         $this->parser = null;
  76.     }
  77.  
  78.     /**
  79.      * Return the URIs in the "Type" elements, if any, of this Service
  80.      * element.
  81.      *
  82.      * @return array $type_uris An array of Type URI strings.
  83.      */
  84.     function getTypes()
  85.     {
  86.         $t = array();
  87.         foreach ($this->getElements('xrd:Type') as $elem) {
  88.             $c = $this->parser->content($elem);
  89.             if ($c) {
  90.                 $t[] = $c;
  91.             }
  92.         }
  93.         return $t;
  94.     }
  95.  
  96.     /**
  97.      * Return the URIs in the "URI" elements, if any, of this Service
  98.      * element.  The URIs are returned sorted in priority order.
  99.      *
  100.      * @return array $uris An array of URI strings.
  101.      */
  102.     function getURIs()
  103.     {
  104.         $uris = array();
  105.         $last = array();
  106.  
  107.         foreach ($this->getElements('xrd:URI') as $elem) {
  108.             $uri_string = $this->parser->content($elem);
  109.             $attrs = $this->parser->attributes($elem);
  110.             if ($attrs &&
  111.                 array_key_exists('priority', $attrs)) {
  112.                 $priority = intval($attrs['priority']);
  113.                 if (!array_key_exists($priority, $uris)) {
  114.                     $uris[$priority] = array();
  115.                 }
  116.  
  117.                 $uris[$priority][] = $uri_string;
  118.             } else {
  119.                 $last[] = $uri_string;
  120.             }
  121.         }
  122.  
  123.         $keys = array_keys($uris);
  124.         sort($keys);
  125.  
  126.         // Rebuild array of URIs.
  127.         $result = array();
  128.         foreach ($keys as $k) {
  129.             $new_uris = Services_Yadis_array_scramble($uris[$k]);
  130.             $result = array_merge($result, $new_uris);
  131.         }
  132.  
  133.         $result = array_merge($result,
  134.                               Services_Yadis_array_scramble($last));
  135.  
  136.         return $result;
  137.     }
  138.  
  139.     /**
  140.      * Returns the "priority" attribute value of this <Service>
  141.      * element, if the attribute is present.  Returns null if not.
  142.      *
  143.      * @return mixed $result Null or integer, depending on whether
  144.      *  this Service element has a 'priority' attribute.
  145.      */
  146.     function getPriority()
  147.     {
  148.         $attributes = $this->parser->attributes($this->element);
  149.  
  150.         if (array_key_exists('priority', $attributes)) {
  151.             return intval($attributes['priority']);
  152.         }
  153.  
  154.         return null;
  155.     }
  156.  
  157.     /**
  158.      * Used to get XML elements from this object's <Service> element.
  159.      *
  160.      * This is what you should use to get all custom information out
  161.      * of this element. This is used by service filter functions to
  162.      * determine whether a service element contains specific tags,
  163.      * etc.  NOTE: this only considers elements which are direct
  164.      * children of the <Service> element for this object.
  165.      *
  166.      * @param string $name The name of the element to look for
  167.      * @return array $list An array of elements with the specified
  168.      *  name which are direct children of the <Service> element.  The
  169.      *  nodes returned by this function can be passed to $this->parser
  170.      *  methods (see {@link Services_Yadis_XMLParser}).
  171.      */
  172.     function getElements($name)
  173.     {
  174.         return $this->parser->evalXPath($name, $this->element);
  175.     }
  176. }
  177.  
  178. /**
  179.  * This class performs parsing of XRDS documents.
  180.  *
  181.  * You should not instantiate this class directly; rather, call
  182.  * parseXRDS statically:
  183.  *
  184.  * <pre>  $xrds = Services_Yadis_XRDS::parseXRDS($xml_string);</pre>
  185.  *
  186.  * If the XRDS can be parsed and is valid, an instance of
  187.  * Services_Yadis_XRDS will be returned.  Otherwise, null will be
  188.  * returned.  This class is used by the Services_Yadis_Yadis::discover
  189.  * method.
  190.  *
  191.  * @package Yadis
  192.  */
  193. class Services_Yadis_XRDS {
  194.  
  195.     /**
  196.      * Instantiate a Services_Yadis_XRDS object.  Requires an XPath
  197.      * instance which has been used to parse a valid XRDS document.
  198.      */
  199.     function Services_Yadis_XRDS(&$xmlParser, &$xrdNodes)
  200.     {
  201.         $this->parser =& $xmlParser;
  202.         $this->xrdNode = $xrdNodes[count($xrdNodes) - 1];
  203.         $this->allXrdNodes =& $xrdNodes;
  204.         $this->serviceList = array();
  205.         $this->_parse();
  206.     }
  207.  
  208.     /**
  209.      * Parse an XML string (XRDS document) and return either a
  210.      * Services_Yadis_XRDS object or null, depending on whether the
  211.      * XRDS XML is valid.
  212.      *
  213.      * @param string $xml_string An XRDS XML string.
  214.      * @return mixed $xrds An instance of Services_Yadis_XRDS or null,
  215.      *  depending on the validity of $xml_string
  216.      */
  217.     function parseXRDS($xml_string, $extra_ns_map = null)
  218.     {
  219.         global $_Services_Yadis_ns_map;
  220.  
  221.         if (!$xml_string) {
  222.             return null;
  223.         }
  224.  
  225.         $parser = Services_Yadis_getXMLParser();
  226.  
  227.         $ns_map = $_Services_Yadis_ns_map;
  228.  
  229.         if ($extra_ns_map && is_array($extra_ns_map)) {
  230.             $ns_map = array_merge($ns_map, $extra_ns_map);
  231.         }
  232.  
  233.         if (!($parser && $parser->init($xml_string, $ns_map))) {
  234.             return null;
  235.         }
  236.  
  237.         // Try to get root element.
  238.         $root = $parser->evalXPath('/xrds:XRDS[1]');
  239.         if (!$root) {
  240.             return null;
  241.         }
  242.  
  243.         if (is_array($root)) {
  244.             $root = $root[0];
  245.         }
  246.  
  247.         $attrs = $parser->attributes($root);
  248.  
  249.         if (array_key_exists('xmlns:xrd', $attrs) &&
  250.             $attrs['xmlns:xrd'] != 'xri://$xrd*($v*2.0)') {
  251.             return null;
  252.         } else if (array_key_exists('xmlns', $attrs) &&
  253.                    preg_match('/xri/', $attrs['xmlns']) &&
  254.                    $attrs['xmlns'] != 'xri://$xrd*($v*2.0)') {
  255.             return null;
  256.         }
  257.  
  258.         // Get the last XRD node.
  259.         $xrd_nodes = $parser->evalXPath('/xrds:XRDS[1]/xrd:XRD');
  260.  
  261.         if (!$xrd_nodes) {
  262.             return null;
  263.         }
  264.  
  265.         $xrds = new Services_Yadis_XRDS($parser, $xrd_nodes);
  266.         return $xrds;
  267.     }
  268.  
  269.     /**
  270.      * @access private
  271.      */
  272.     function _addService($priority, $service)
  273.     {
  274.         $priority = intval($priority);
  275.  
  276.         if (!array_key_exists($priority, $this->serviceList)) {
  277.             $this->serviceList[$priority] = array();
  278.         }
  279.  
  280.         $this->serviceList[$priority][] = $service;
  281.     }
  282.  
  283.     /**
  284.      * Creates the service list using nodes from the XRDS XML
  285.      * document.
  286.      *
  287.      * @access private
  288.      */
  289.     function _parse()
  290.     {
  291.         $this->serviceList = array();
  292.  
  293.         $services = $this->parser->evalXPath('xrd:Service', $this->xrdNode);
  294.  
  295.         foreach ($services as $node) {
  296.             $s =& new Services_Yadis_Service();
  297.             $s->element = $node;
  298.             $s->parser =& $this->parser;
  299.  
  300.             $priority = $s->getPriority();
  301.  
  302.             if ($priority === null) {
  303.                 $priority = SERVICES_YADIS_MAX_PRIORITY;
  304.             }
  305.  
  306.             $this->_addService($priority, $s);
  307.         }
  308.     }
  309.  
  310.     /**
  311.      * Returns a list of service objects which correspond to <Service>
  312.      * elements in the XRDS XML document for this object.
  313.      *
  314.      * Optionally, an array of filter callbacks may be given to limit
  315.      * the list of returned service objects.  Furthermore, the default
  316.      * mode is to return all service objects which match ANY of the
  317.      * specified filters, but $filter_mode may be
  318.      * SERVICES_YADIS_MATCH_ALL if you want to be sure that the
  319.      * returned services match all the given filters.  See {@link }
  320.      * Services_Yadis_Yadis} for detailed usage information on filter
  321.      * functions.
  322.      *
  323.      * @param mixed $filters An array of callbacks to filter the
  324.      *  returned services, or null if all services are to be returned.
  325.      * @param integer $filter_mode SERVICES_YADIS_MATCH_ALL or
  326.      *  SERVICES_YADIS_MATCH_ANY, depending on whether the returned
  327.      *  services should match ALL or ANY of the specified filters,
  328.      *  respectively.
  329.      * @return mixed $services An array of {@link }
  330.      *  Services_Yadis_Service} objects if $filter_mode is a valid
  331.      *  mode; null if $filter_mode is an invalid mode (i.e., not
  332.      *  SERVICES_YADIS_MATCH_ANY or SERVICES_YADIS_MATCH_ALL).
  333.      */
  334.     function services($filters = null,
  335.                       $filter_mode = SERVICES_YADIS_MATCH_ANY)
  336.     {
  337.  
  338.         $pri_keys = array_keys($this->serviceList);
  339.         sort($pri_keys, SORT_NUMERIC);
  340.  
  341.         // If no filters are specified, return the entire service
  342.         // list, ordered by priority.
  343.         if (!$filters ||
  344.             (!is_array($filters))) {
  345.  
  346.             $result = array();
  347.             foreach ($pri_keys as $pri) {
  348.                 $result = array_merge($result, $this->serviceList[$pri]);
  349.             }
  350.  
  351.             return $result;
  352.         }
  353.  
  354.         // If a bad filter mode is specified, return null.
  355.         if (!in_array($filter_mode, array(SERVICES_YADIS_MATCH_ANY,
  356.                                           SERVICES_YADIS_MATCH_ALL))) {
  357.             return null;
  358.         }
  359.  
  360.         // Otherwise, use the callbacks in the filter list to
  361.         // determine which services are returned.
  362.         $filtered = array();
  363.  
  364.         foreach ($pri_keys as $priority_value) {
  365.             $service_obj_list = $this->serviceList[$priority_value];
  366.  
  367.             foreach ($service_obj_list as $service) {
  368.  
  369.                 $matches = 0;
  370.  
  371.                 foreach ($filters as $filter) {
  372.                     if (call_user_func_array($filter, array($service))) {
  373.                         $matches++;
  374.  
  375.                         if ($filter_mode == SERVICES_YADIS_MATCH_ANY) {
  376.                             $pri = $service->getPriority();
  377.                             if ($pri === null) {
  378.                                 $pri = SERVICES_YADIS_MAX_PRIORITY;
  379.                             }
  380.  
  381.                             if (!array_key_exists($pri, $filtered)) {
  382.                                 $filtered[$pri] = array();
  383.                             }
  384.  
  385.                             $filtered[$pri][] = $service;
  386.                             break;
  387.                         }
  388.                     }
  389.                 }
  390.  
  391.                 if (($filter_mode == SERVICES_YADIS_MATCH_ALL) &&
  392.                     ($matches == count($filters))) {
  393.  
  394.                     $pri = $service->getPriority();
  395.                     if ($pri === null) {
  396.                         $pri = SERVICES_YADIS_MAX_PRIORITY;
  397.                     }
  398.  
  399.                     if (!array_key_exists($pri, $filtered)) {
  400.                         $filtered[$pri] = array();
  401.                     }
  402.                     $filtered[$pri][] = $service;
  403.                 }
  404.             }
  405.         }
  406.  
  407.         $pri_keys = array_keys($filtered);
  408.         sort($pri_keys, SORT_NUMERIC);
  409.  
  410.         $result = array();
  411.         foreach ($pri_keys as $pri) {
  412.             $result = array_merge($result, $filtered[$pri]);
  413.         }
  414.  
  415.         return $result;
  416.     }
  417. }
  418.  
  419. ?>
Documentation generated on Mon, 05 Mar 2007 21:33:05 +0000 by phpDocumentor 1.3.1