TYPO3_6-2/_manager_8php_source.html

 <?php

 class Auth_Yadis_PHPSession {
     function set($name, $value)
     {
         $_SESSION[$name] = $value;
     }

     function get($name, $default=null)
     {
         if (isset($_SESSION) && 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_array($discover_cb,
                                                                array(
                                                                 $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);
         }
     }
 }

Auth_Yadis_PHPSession
Definition: Manager.php:17

Auth_OpenID_ServiceEndpoint
Definition: Discover.php:63

Auth_Yadis_Manager
Definition: Manager.php:276

Auth_Yadis_ManagerLoader\check
check($data)
Definition: Manager.php:242

Auth_Yadis_Discovery\getSessionKey
getSessionKey()
Definition: Manager.php:459

Auth_Yadis_SessionLoader
Definition: Manager.php:76

Auth_Yadis_Manager\current
current()
Definition: Manager.php:334

Auth_Yadis_Discovery
Definition: Manager.php:369

Auth_Yadis_ManagerLoader
Definition: Manager.php:223

Auth_Yadis_SessionLoader\prepareForSave
prepareForSave($obj)
Definition: Manager.php:185

Auth_Yadis_Discovery\Auth_Yadis_Discovery
Auth_Yadis_Discovery($session, $url, $session_key_suffix=null)
Definition: Manager.php:390

Auth_Yadis_ManagerLoader\requiredKeys
requiredKeys()
Definition: Manager.php:224

Auth_Yadis_SessionLoader\check
check($data)
Definition: Manager.php:82

Auth_Yadis_Discovery\cleanup
cleanup($force=false)
Definition: Manager.php:443

Auth_Yadis_PHPSession\del
del($name)
Definition: Manager.php:52

Auth_Yadis_ManagerLoader\prepareForSave
prepareForSave($obj)
Definition: Manager.php:257

Auth_Yadis_Manager\Auth_Yadis_Manager
Auth_Yadis_Manager($starting_url, $yadis_url, $services, $session_key)
Definition: Manager.php:283

Auth_Yadis_Discovery\getNextService
getNextService($discover_cb, $fetcher)
Definition: Manager.php:408

Auth_Yadis_Discovery\destroyManager
destroyManager($force=false)
Definition: Manager.php:515

Auth_Yadis_Manager\nextService
nextService()
Definition: Manager.php:319

Auth_OpenID_ServiceEndpointLoader
Definition: Manager.php:196

Auth_Yadis_SessionLoader\prepareForLoad
prepareForLoad($data)
Definition: Manager.php:136

Auth_Yadis_Manager\length
length()
Definition: Manager.php:307

Auth_OpenID_ServiceEndpointLoader\newObject
newObject($data)
Definition: Manager.php:197

Auth_Yadis_PHPSession\contents
contents()
Definition: Manager.php:60

Auth_OpenID_ServiceEndpointLoader\requiredKeys
requiredKeys()
Definition: Manager.php:202

Auth_Yadis_SessionLoader\fromSession
fromSession($data)
Definition: Manager.php:97

Auth_Yadis_ManagerLoader\prepareForLoad
prepareForLoad($data)
Definition: Manager.php:247

Auth_Yadis_ManagerLoader\newObject
newObject($data)
Definition: Manager.php:234

Auth_Yadis_SessionLoader\toSession
toSession($obj)
Definition: Manager.php:162

Auth_Yadis_Discovery\getManager
getManager($force=false)
Definition: Manager.php:471

Auth_Yadis_Manager\started
started()
Definition: Manager.php:352

Auth_Yadis_Manager\forURL
forURL($url)
Definition: Manager.php:344

Auth_Yadis_Discovery\createManager
createManager($services, $yadis_url=null)
Definition: Manager.php:492

Auth_OpenID_ServiceEndpointLoader\check
check($data)
Definition: Manager.php:212

Auth_Yadis_SessionLoader\newObject
newObject($data)
Definition: Manager.php:149