Manager.php

Go to the documentation of this file.

<?php
 
class Auth_Yadis_PHPSession {
    function set($name, $value)
    {
        $_SESSION[$name] = $value;
    }
 
    function get($name, $default=null)
    {
        if (array_key_exists($name, $_SESSION)) {
            return $_SESSION[$name];
        } else {
            return $default;
        }
    }
 
    function del($name)
    {
        unset($_SESSION[$name]);
    }
 
    function contents()
    {
        return $_SESSION;
    }
}
 
class Auth_Yadis_SessionLoader {
    function check($data)
    {
        return true;
    }
 
    function fromSession($data)
    {
        if (!$data) {
            return null;
        }
 
        $required = $this->requiredKeys();
 
        foreach ($required as $k) {
            if (!array_key_exists($k, $data)) {
                return null;
            }
        }
 
        if (!$this->check($data)) {
            return null;
        }
 
        $data = array_merge($data, $this->prepareForLoad($data));
        $obj = $this->newObject($data);
 
        if (!$obj) {
            return null;
        }
 
        foreach ($required as $k) {
            $obj->$k = $data[$k];
        }
 
        return $obj;
    }
 
    function prepareForLoad($data)
    {
        return array();
    }
 
    function newObject($data)
    {
        return null;
    }
 
    function toSession($obj)
    {
        $data = array();
        foreach ($obj as $k => $v) {
            $data[$k] = $v;
        }
 
        $extra = $this->prepareForSave($obj);
 
        if ($extra && is_array($extra)) {
            foreach ($extra as $k => $v) {
                $data[$k] = $v;
            }
        }
 
        return $data;
    }
 
    function prepareForSave($obj)
    {
        return array();
    }
}
 
class Auth_OpenID_ServiceEndpointLoader extends Auth_Yadis_SessionLoader {
    function newObject($data)
    {
        return new Auth_OpenID_ServiceEndpoint();
    }
 
    function requiredKeys()
    {
        $obj = new Auth_OpenID_ServiceEndpoint();
        $data = array();
        foreach ($obj as $k => $v) {
            $data[] = $k;
        }
        return $data;
    }
 
    function check($data)
    {
        return is_array($data['type_uris']);
    }
}
 
class Auth_Yadis_ManagerLoader extends Auth_Yadis_SessionLoader {
    function requiredKeys()
    {
        return array('starting_url',
                     'yadis_url',
                     'services',
                     'session_key',
                     '_current',
                     'stale');
    }
 
    function newObject($data)
    {
        return new Auth_Yadis_Manager($data['starting_url'],
                                          $data['yadis_url'],
                                          $data['services'],
                                          $data['session_key']);
    }
 
    function check($data)
    {
        return is_array($data['services']);
    }
 
    function prepareForLoad($data)
    {
        $loader = new Auth_OpenID_ServiceEndpointLoader();
        $services = array();
        foreach ($data['services'] as $s) {
            $services[] = $loader->fromSession($s);
        }
        return array('services' => $services);
    }
 
    function prepareForSave($obj)
    {
        $loader = new Auth_OpenID_ServiceEndpointLoader();
        $services = array();
        foreach ($obj->services as $s) {
            $services[] = $loader->toSession($s);
        }
        return array('services' => $services);
    }
}
 
class Auth_Yadis_Manager {
 
    function Auth_Yadis_Manager($starting_url, $yadis_url,
                                    $services, $session_key)
    {
        // The URL that was used to initiate the Yadis protocol
        $this->starting_url = $starting_url;
 
        // The URL after following redirects (the identifier)
        $this->yadis_url = $yadis_url;
 
        // List of service elements
        $this->services = $services;
 
        $this->session_key = $session_key;
 
        // Reference to the current service object
        $this->_current = null;
 
        // Stale flag for cleanup if PHP lib has trouble.
        $this->stale = false;
    }
 
    function length()
    {
        // How many untried services remain?
        return count($this->services);
    }
 
    function nextService()
    {
 
        if ($this->services) {
            $this->_current = array_shift($this->services);
        } else {
            $this->_current = null;
        }
 
        return $this->_current;
    }
 
    function current()
    {
        // Return the current service.
        // Returns None if there are no services left.
        return $this->_current;
    }
 
    function forURL($url)
    {
        return in_array($url, array($this->starting_url, $this->yadis_url));
    }
 
    function started()
    {
        // Has the first service been returned?
        return $this->_current !== null;
    }
}
 
class Auth_Yadis_Discovery {
 
    var $DEFAULT_SUFFIX = 'auth';
 
    var $PREFIX = '_yadis_services_';
 
    function Auth_Yadis_Discovery($session, $url,
                                      $session_key_suffix = null)
    {
        $this->session = $session;
        $this->url = $url;
        if ($session_key_suffix === null) {
            $session_key_suffix = $this->DEFAULT_SUFFIX;
        }
 
        $this->session_key_suffix = $session_key_suffix;
        $this->session_key = $this->PREFIX . $this->session_key_suffix;
    }
 
    function getNextService($discover_cb, $fetcher)
    {
        $manager = $this->getManager();
        if (!$manager || (!$manager->services)) {
            $this->destroyManager();
 
            list($yadis_url, $services) = call_user_func($discover_cb,
                                                         $this->url,
                                                         $fetcher);
 
            $manager = $this->createManager($services, $yadis_url);
        }
 
        if ($manager) {
            $loader = new Auth_Yadis_ManagerLoader();
            $service = $manager->nextService();
            $this->session->set($this->session_key,
                                serialize($loader->toSession($manager)));
        } else {
            $service = null;
        }
 
        return $service;
    }
 
    function cleanup($force=false)
    {
        $manager = $this->getManager($force);
        if ($manager) {
            $service = $manager->current();
            $this->destroyManager($force);
        } else {
            $service = null;
        }
 
        return $service;
    }
 
    function getSessionKey()
    {
        // Get the session key for this starting URL and suffix
        return $this->PREFIX . $this->session_key_suffix;
    }
 
    function getManager($force=false)
    {
        // Extract the YadisServiceManager for this object's URL and
        // suffix from the session.
 
        $manager_str = $this->session->get($this->getSessionKey());
        $manager = null;
 
        if ($manager_str !== null) {
            $loader = new Auth_Yadis_ManagerLoader();
            $manager = $loader->fromSession(unserialize($manager_str));
        }
 
        if ($manager && ($manager->forURL($this->url) || $force)) {
            return $manager;
        }
    }
 
    function createManager($services, $yadis_url = null)
    {
        $key = $this->getSessionKey();
        if ($this->getManager()) {
            return $this->getManager();
        }
 
        if ($services) {
            $loader = new Auth_Yadis_ManagerLoader();
            $manager = new Auth_Yadis_Manager($this->url, $yadis_url,
                                              $services, $key);
            $this->session->set($this->session_key,
                                serialize($loader->toSession($manager)));
            return $manager;
        }
    }
 
    function destroyManager($force=false)
    {
        if ($this->getManager($force) !== null) {
            $key = $this->getSessionKey();
            $this->session->del($key);
        }
    }
}