Yadis.php

Go to the documentation of this file.

<?php
 
require_once "Auth/Yadis/PlainHTTPFetcher.php";
require_once "Auth/Yadis/ParanoidHTTPFetcher.php";
 
require_once "Auth/Yadis/ParseHTML.php";
 
require_once "Auth/Yadis/XRDS.php";
 
define('Auth_Yadis_CONTENT_TYPE', 'application/xrds+xml');
 
define('Auth_Yadis_HEADER_NAME', 'X-XRDS-Location');
 
class Auth_Yadis_DiscoveryResult {
 
    // The URI that was passed to the fetcher
    var $request_uri = null;
 
    // The result of following redirects from the request_uri
    var $normalized_uri = null;
 
    // The URI from which the response text was returned (set to
    // None if there was no XRDS document found)
    var $xrds_uri = null;
 
    var $xrds = null;
 
    // The content-type returned with the response_text
    var $content_type = null;
 
    // The document returned from the xrds_uri
    var $response_text = null;
 
    // Did the discovery fail miserably?
    var $failed = false;
 
    function Auth_Yadis_DiscoveryResult($request_uri)
    {
        // Initialize the state of the object
        // sets all attributes to None except the request_uri
        $this->request_uri = $request_uri;
    }
 
    function fail()
    {
        $this->failed = true;
    }
 
    function isFailure()
    {
        return $this->failed;
    }
 
    function services()
    {
        if ($this->xrds) {
            return $this->xrds->services();
        }
 
        return null;
    }
 
    function usedYadisLocation()
    {
        // Was the Yadis protocol's indirection used?
        return ($this->xrds_uri && $this->normalized_uri != $this->xrds_uri);
    }
 
    function isXRDS()
    {
        // Is the response text supposed to be an XRDS document?
        return ($this->usedYadisLocation() ||
                $this->content_type == Auth_Yadis_CONTENT_TYPE);
    }
}
 
function Auth_Yadis_getServiceEndpoints($input_url, $xrds_parse_func,
                                        $discover_func=null, $fetcher=null)
{
    if ($discover_func === null) {
        $discover_function = array('Auth_Yadis_Yadis', 'discover');
    }
 
    $yadis_result = call_user_func_array($discover_func,
                                         array($input_url, &$fetcher));
 
    if ($yadis_result === null) {
        return array($input_url, array());
    }
 
    $endpoints = call_user_func_array($xrds_parse_func,
                      array($yadis_result->normalized_uri,
                            $yadis_result->response_text));
 
    if ($endpoints === null) {
        $endpoints = array();
    }
 
    return array($yadis_result->normalized_uri, $endpoints);
}
 
class Auth_Yadis_Yadis {
 
    static function getHTTPFetcher($timeout = 20)
    {
        if (Auth_Yadis_Yadis::curlPresent() &&
            (!defined('Auth_Yadis_CURL_OVERRIDE'))) {
            $fetcher = new Auth_Yadis_ParanoidHTTPFetcher($timeout);
        } else {
            $fetcher = new Auth_Yadis_PlainHTTPFetcher($timeout);
        }
        return $fetcher;
    }
 
    static function curlPresent()
    {
        return function_exists('curl_init');
    }
 
   static function _getHeader($header_list, $names)
    {
        foreach ($header_list as $name => $value) {
            foreach ($names as $n) {
                if (strtolower($name) == strtolower($n)) {
                    return $value;
                }
            }
        }
 
        return null;
    }
 
    static function _getContentType($content_type_header)
    {
        if ($content_type_header) {
            $parts = explode(";", $content_type_header);
            return strtolower($parts[0]);
        }
    }
 
    static function discover($uri, $fetcher,
                      $extra_ns_map = null, $timeout = 20)
    {
        $result = new Auth_Yadis_DiscoveryResult($uri);
 
        $request_uri = $uri;
        $headers = array("Accept: " . Auth_Yadis_CONTENT_TYPE .
                         ', text/html; q=0.3, application/xhtml+xml; q=0.5');
 
        if ($fetcher === null) {
            $fetcher = Auth_Yadis_Yadis::getHTTPFetcher($timeout);
        }
 
        $response = $fetcher->get($uri, $headers);
 
        if (!$response || ($response->status != 200 and
                           $response->status != 206)) {
            $result->fail();
            return $result;
        }
 
        $result->normalized_uri = $response->final_url;
        $result->content_type = Auth_Yadis_Yadis::_getHeader(
                                       $response->headers,
                                       array('content-type'));
 
        if ($result->content_type &&
            (Auth_Yadis_Yadis::_getContentType($result->content_type) ==
             Auth_Yadis_CONTENT_TYPE)) {
            $result->xrds_uri = $result->normalized_uri;
        } else {
            $yadis_location = Auth_Yadis_Yadis::_getHeader(
                                                 $response->headers,
                                                 array(Auth_Yadis_HEADER_NAME));
 
            if (!$yadis_location) {
                $parser = new Auth_Yadis_ParseHTML();
                $yadis_location = $parser->getHTTPEquiv($response->body);
            }
 
            if ($yadis_location) {
                $result->xrds_uri = $yadis_location;
 
                $response = $fetcher->get($yadis_location);
 
                if ((!$response) || ($response->status != 200 and
                                     $response->status != 206)) {
                    $result->fail();
                    return $result;
                }
 
                $result->content_type = Auth_Yadis_Yadis::_getHeader(
                                                         $response->headers,
                                                         array('content-type'));
            }
        }
 
        $result->response_text = $response->body;
        return $result;
    }
}