<?php



/**

 * XML-parsing classes to wrap the domxml and DOM extensions for PHP 4

 * and 5, respectively.

 *

 * @package OpenID

 */



// Do not allow direct access

defined( '_JEXEC' ) or die( 'Restricted access' );



/**

 * The base class for wrappers for available PHP XML-parsing

 * extensions.  To work with this Yadis library, subclasses of this

 * class MUST implement the API as defined in the remarks for this

 * class.  Subclasses of Auth_Yadis_XMLParser are used to wrap

 * particular PHP XML extensions such as 'domxml'.  These are used

 * internally by the library depending on the availability of

 * supported PHP XML extensions.

 *

 * @package OpenID

 */

class Auth_Yadis_XMLParser {

    /**

     * Initialize an instance of Auth_Yadis_XMLParser with some

     * XML and namespaces.  This SHOULD NOT be overridden by

     * subclasses.

     *

     * @param string $xml_string A string of XML to be parsed.

     * @param array $namespace_map An array of ($ns_name => $ns_uri)

     * to be registered with the XML parser.  May be empty.

     * @return boolean $result True if the initialization and

     * namespace registration(s) succeeded; false otherwise.

     */

    function init($xml_string, $namespace_map)

    {

        if (!$this->setXML($xml_string)) {

            return false;

        }



        foreach ($namespace_map as $prefix => $uri) {

            if (!$this->registerNamespace($prefix, $uri)) {

                return false;

            }

        }



        return true;

    }



    /**

     * Register a namespace with the XML parser.  This should be

     * overridden by subclasses.

     *

     * @param string $prefix The namespace prefix to appear in XML tag

     * names.

     *

     * @param string $uri The namespace URI to be used to identify the

     * namespace in the XML.

     *

     * @return boolean $result True if the registration succeeded;

     * false otherwise.

     */

    function registerNamespace($prefix, $uri)

    {

        // Not implemented.

    }



    /**

     * Set this parser object's XML payload.  This should be

     * overridden by subclasses.

     *

     * @param string $xml_string The XML string to pass to this

     * object's XML parser.

     *

     * @return boolean $result True if the initialization succeeded;

     * false otherwise.

     */

    function setXML($xml_string)

    {

        // Not implemented.

    }



    /**

     * Evaluate an XPath expression and return the resulting node

     * list.  This should be overridden by subclasses.

     *

     * @param string $xpath The XPath expression to be evaluated.

     *

     * @param mixed $node A node object resulting from a previous

     * evalXPath call.  This node, if specified, provides the context

     * for the evaluation of this xpath expression.

     *

     * @return array $node_list An array of matching opaque node

     * objects to be used with other methods of this parser class.

     */

    function evalXPath($xpath, $node = null)

    {

        // Not implemented.

    }



    /**

     * Return the textual content of a specified node.

     *

     * @param mixed $node A node object from a previous call to

     * $this->evalXPath().

     *

     * @return string $content The content of this node.

     */

    function content($node)

    {

        // Not implemented.

    }



    /**

     * Return the attributes of a specified node.

     *

     * @param mixed $node A node object from a previous call to

     * $this->evalXPath().

     *

     * @return array $attrs An array mapping attribute names to

     * values.

     */

    function attributes($node)

    {

        // Not implemented.

    }

}



/**

 * This concrete implementation of Auth_Yadis_XMLParser implements

 * the appropriate API for the 'domxml' extension which is typically

 * packaged with PHP 4.  This class will be used whenever the 'domxml'

 * extension is detected.  See the Auth_Yadis_XMLParser class for

 * details on this class's methods.

 *

 * @package OpenID

 */

class Auth_Yadis_domxml extends Auth_Yadis_XMLParser {

    function Auth_Yadis_domxml()

    {

        $this->xml = null;

        $this->doc = null;

        $this->xpath = null;

        $this->errors = array();

    }



    function setXML($xml_string)

    {

        $this->xml = $xml_string;

        $this->doc = @domxml_open_mem($xml_string, DOMXML_LOAD_PARSING,

                                      $this->errors);



        if (!$this->doc) {

            return false;

        }



        $this->xpath = $this->doc->xpath_new_context();



        return true;

    }



    function registerNamespace($prefix, $uri)

    {

        return xpath_register_ns($this->xpath, $prefix, $uri);

    }



    function &evalXPath($xpath, $node = null)

    {

        if ($node) {

            $result = @$this->xpath->xpath_eval($xpath, $node);

        } else {

            $result = @$this->xpath->xpath_eval($xpath);

        }



        if (!$result) {

            $n = array();

            return $n;

        }



        if (!$result->nodeset) {

            $n = array();

            return $n;

        }



        return $result->nodeset;

    }



    function content($node)

    {

        if ($node) {

            return $node->get_content();

        }

    }



    function attributes($node)

    {

        if ($node) {

            $arr = $node->attributes();

            $result = array();



            if ($arr) {

                foreach ($arr as $attrnode) {

                    $result[$attrnode->name] = $attrnode->value;

                }

            }



            return $result;

        }

    }

}



/**

 * This concrete implementation of Auth_Yadis_XMLParser implements

 * the appropriate API for the 'dom' extension which is typically

 * packaged with PHP 5.  This class will be used whenever the 'dom'

 * extension is detected.  See the Auth_Yadis_XMLParser class for

 * details on this class's methods.

 *

 * @package OpenID

 */

class Auth_Yadis_dom extends Auth_Yadis_XMLParser {

    function Auth_Yadis_dom()

    {

        $this->xml = null;

        $this->doc = null;

        $this->xpath = null;

        $this->errors = array();

    }



    function setXML($xml_string)

    {

        $this->xml = $xml_string;

        $this->doc = new DOMDocument;



        if (!$this->doc) {

            return false;

        }



        if (!@$this->doc->loadXML($xml_string)) {

            return false;

        }



        $this->xpath = new DOMXPath($this->doc);



        if ($this->xpath) {

            return true;

        } else {

            return false;

        }

    }



    function registerNamespace($prefix, $uri)

    {

        return $this->xpath->registerNamespace($prefix, $uri);

    }



    function &evalXPath($xpath, $node = null)

    {

        if ($node) {

            $result = @$this->xpath->query($xpath, $node);

        } else {

            $result = @$this->xpath->query($xpath);

        }



        $n = array();



        if (!$result) {

            return $n;

        }



        for ($i = 0; $i < $result->length; $i++) {

            $n[] = $result->item($i);

        }



        return $n;

    }



    function content($node)

    {

        if ($node) {

            return $node->textContent;

        }

    }



    function attributes($node)

    {

        if ($node) {

            $arr = $node->attributes;

            $result = array();



            if ($arr) {

                for ($i = 0; $i < $arr->length; $i++) {

                    $node = $arr->item($i);

                    $result[$node->nodeName] = $node->nodeValue;

                }

            }



            return $result;

        }

    }

}



global $__Auth_Yadis_defaultParser;

$__Auth_Yadis_defaultParser = null;



/**

 * Set a default parser to override the extension-driven selection of

 * available parser classes.  This is helpful in a test environment or

 * one in which multiple parsers can be used but one is more

 * desirable.

 *

 * @param Auth_Yadis_XMLParser $parser An instance of a

 * Auth_Yadis_XMLParser subclass.

 */

function Auth_Yadis_setDefaultParser(&$parser)

{

    global $__Auth_Yadis_defaultParser;

    $__Auth_Yadis_defaultParser =& $parser;

}



function Auth_Yadis_getSupportedExtensions()

{

    return array(

                 'dom' => array('classname' => 'Auth_Yadis_dom',

                       'libname' => array('dom.so', 'dom.dll')),

                 'domxml' => array('classname' => 'Auth_Yadis_domxml',

                       'libname' => array('domxml.so', 'php_domxml.dll')),

                 );

}



/**

 * Returns an instance of a Auth_Yadis_XMLParser subclass based on

 * the availability of PHP extensions for XML parsing.  If

 * Auth_Yadis_setDefaultParser has been called, the parser used in

 * that call will be returned instead.

 */

function &Auth_Yadis_getXMLParser()

{

    global $__Auth_Yadis_defaultParser;



    if (isset($__Auth_Yadis_defaultParser)) {

        return $__Auth_Yadis_defaultParser;

    }



    $p = null;

    $classname = null;



    $extensions = Auth_Yadis_getSupportedExtensions();



    // Return a wrapper for the resident implementation, if any.

    foreach ($extensions as $name => $params) {

        if (!extension_loaded($name)) {

            foreach ($params['libname'] as $libname) {

                if (@dl($libname)) {

                    $classname = $params['classname'];

                }

            }

        } else {

            $classname = $params['classname'];

        }

        if (isset($classname)) {

            $p = new $classname();

            return $p;

        }

    }



    if (!isset($p)) {

        trigger_error('No XML parser was found', E_USER_ERROR);

    } else {

        Auth_Yadis_setDefaultParser($p);

    }



    return $p;

}



?>