TYPO3 Core

* Auth_Yadis_Yadis, depending on whether the discovery

* succeeded.

*/

$extra_ns_map = null, $timeout = 20)

{

$result = new Auth_Yadis_DiscoveryResult($uri);

require_once 'Auth/Yadis/XRI.php';

class Auth_Yadis_ProxyResolver {

{

$this->fetcher =& $fetcher;

$this->proxy_url = $proxy_url;

* Instantiate a Auth_Yadis_XRDS object. Requires an XPath

* instance which has been used to parse a valid XRDS document.

*/

{

$this->parser =& $xmlParser;

$this->xrdNode = $xrdNodes[count($xrdNodes) - 1];

$services = $this->parser->evalXPath('xrd:Service', $this->xrdNode);

foreach ($services as $node) {

$s->element = $node;

$s->parser =& $this->parser;

$matches = 0;

foreach ($filters as $filter) {

$matches++;

if ($filter_mode == SERVICES_YADIS_MATCH_ANY) {

* when creating the internal consumer object. This is used for

* testing.

*/

$consumer_cls = null)

{

if ($session === null) {

$this->session =& $session;

if ($consumer_cls !== null) {

} else {

}

$this->_token_key = $this->session_key_prefix . $this->_token_suffix;

*

* @access private

*/

$session_key_prefix)

{

return new Auth_Yadis_Discovery($session, $openid_url,

* in the module description. The default value is False, which

* disables immediate mode.

*/

{

$this->store =& $store;

$this->negotiator =& Auth_OpenID_getDefaultNegotiator();

$method = Auth_OpenID::arrayGet($mode_methods, $mode,

'_completeInvalid');

array($message, $endpoint, $return_to));

}

/**

* @access private

*/

{

$mode = $message->getArg(Auth_OpenID_OPENID_NS, 'mode',

'<No mode set>');

/**

* @access private

*/

{

return new Auth_OpenID_CancelResponse($endpoint);

}

/**

* @access private

*/

{

$error = $message->getArg(Auth_OpenID_OPENID_NS, 'error');

$contact = $message->getArg(Auth_OpenID_OPENID_NS, 'contact');

/**

* @access private

*/

{

if (!$message->isOpenID2()) {

return $this->_completeInvalid($message, $endpoint);

/**

* @access private

*/

{

$user_setup_url = $message->getArg(Auth_OpenID_OPENID1_NS,

'user_setup_url');

*/

function _discoverAndVerify($claimed_id, $to_match_endpoints)

{

// oidutil.log('Performing discovery on %s' % (claimed_id,))

list($unused, $services) = call_user_func($this->discoverMethod,

$claimed_id,

* @access private

*/

function _verifyDiscoveryServices($claimed_id,

{

// Search the services resulting from discovery to find one

// that matches the information from the assertion

*

* @access private

*/

$assoc_type)

{

// Any error message whose code is not 'unsupported-type'

/**

* @access private

*/

{

// Extract the common fields from the response, raising an

// exception if they are not found

* class. Instances of this class are created by the library when

* needed.

*/

{

$this->assoc = $assoc;

$this->endpoint =& $endpoint;

* $extension_request: An object that implements the extension

* request interface for adding arguments to an OpenID message.

*/

{

$extension_request->toMessage($this->message);

}

}

}

in OpenID 1.x immediate mode.');

}

$this->identity,

$this->return_to,

$this->trust_root,

function Auth_OpenID_Server(&$store, $op_endpoint=null)

{

$this->store =& $store;

$this->op_endpoint = $op_endpoint;

$this->negotiator =& Auth_OpenID_getDefaultNegotiator();

}

}

}

* return null If an alias is present in the list of aliases but

* is not present in the namespace map.

*/

{

$uris = array();

* @param type_uri: The URI for the attribute

* @param values: A list of values to send for this attribute.

*/

{

$this->data[$type_uri] =& $values;

}

*

* @access private

*/

{

if ($aliases === null) {

$aliases = new Auth_OpenID_NamespaceMap();

$ax_args['update_url'] = $update_url;

}

return $ax_args;

}

{

$ax_args = $this->_newArgs();

$kv_args = $this->_getExtensionKVArgs($aliases);

return $ax_args;

}

}

function Auth_OpenID_detectMathLibrary($exts)

{

$loaded = false;

foreach ($exts as $extension) {

// See if the extension specified is already loaded.

}

// Try to load dynamic modules.

foreach ($extension['modules'] as $module) {

if (@dl($module . "." . PHP_SHLIB_SUFFIX)) {

$loaded = true;

*

* @access private

*/

{

$signed = $message->getArg(Auth_OpenID_OPENID_NS, 'signed');

if (!$signed || Auth_OpenID::isFailure($signed)) {

*

* @access private

*/

{

$pairs = $this->_makePairs($message);

return base64_encode($this->sign($pairs));

*

* @access private

*/

{

$sig = $message->getArg(Auth_OpenID_OPENID_NS,

'sig');

return $local_id;

}

{

$uris = $service->getTypes();

return $s;

}

$endpoint_filter='Auth_OpenID_getOPOrUserServices',

$discover_function=null)

{

$openid_services = array();

$response = call_user_func_array($discover_function,

$yadis_url = $response->normalized_uri;

$yadis_services = array();

}

$openid_services = call_user_func_array($endpoint_filter,

return array($yadis_url, $openid_services);

}

{

$uri = Auth_OpenID::normalizeUrl($uri);

return Auth_OpenID_discoverWithYadis($uri, $fetcher);

}

{

$http_resp = @$fetcher->get($uri);

return array($identity_url, $openid_services);

}

{

$resolver = new Auth_Yadis_ProxyResolver($fetcher);

list($canonicalID, $yadis_services) =

return array($iname, $openid_services);

}

{

// If the fetcher (i.e., PHP) doesn't support SSL, we can't do

// discovery on an HTTPS URL.

// TODO Change this to a TYPO3-specific database-based store in future.

// File-based store is ineffective and insecure. After changing

// get rid of the FileStore include in includePHPOpenIDLibrary()

// For now we just prevent any web access to these files

if (!file_exists($openIDStorePath . '/.htaccess')) {

file_put_contents($openIDStorePath . '/.htaccess', 'deny from all');