SReg.php

Go to the documentation of this file.

<?php
 
require_once 'Auth/OpenID/Message.php';
require_once 'Auth/OpenID/Extension.php';
 
// The data fields that are listed in the sreg spec
global $Auth_OpenID_sreg_data_fields;
$Auth_OpenID_sreg_data_fields = array(
                                      'fullname' => 'Full Name',
                                      'nickname' => 'Nickname',
                                      'dob' => 'Date of Birth',
                                      'email' => 'E-mail Address',
                                      'gender' => 'Gender',
                                      'postcode' => 'Postal Code',
                                      'country' => 'Country',
                                      'language' => 'Language',
                                      'timezone' => 'Time Zone');
 
function Auth_OpenID_checkFieldName($field_name)
{
    global $Auth_OpenID_sreg_data_fields;
 
    if (!in_array($field_name, array_keys($Auth_OpenID_sreg_data_fields))) {
        return false;
    }
    return true;
}
 
// URI used in the wild for Yadis documents advertising simple
// registration support
define('Auth_OpenID_SREG_NS_URI_1_0', 'http://openid.net/sreg/1.0');
 
// URI in the draft specification for simple registration 1.1
// <http://openid.net/specs/openid-simple-registration-extension-1_1-01.html>
define('Auth_OpenID_SREG_NS_URI_1_1', 'http://openid.net/extensions/sreg/1.1');
 
// This attribute will always hold the preferred URI to use when
// adding sreg support to an XRDS file or in an OpenID namespace
// declaration.
define('Auth_OpenID_SREG_NS_URI', Auth_OpenID_SREG_NS_URI_1_1);
 
Auth_OpenID_registerNamespaceAlias(Auth_OpenID_SREG_NS_URI_1_1, 'sreg');
 
function Auth_OpenID_supportsSReg($endpoint)
{
    return ($endpoint->usesExtension(Auth_OpenID_SREG_NS_URI_1_1) ||
            $endpoint->usesExtension(Auth_OpenID_SREG_NS_URI_1_0));
}
 
class Auth_OpenID_SRegBase extends Auth_OpenID_Extension {
    static function _getSRegNS($message)
    {
        $alias = null;
        $found_ns_uri = null;
 
        // See if there exists an alias for one of the two defined
        // simple registration types.
        foreach (array(Auth_OpenID_SREG_NS_URI_1_1,
                       Auth_OpenID_SREG_NS_URI_1_0) as $sreg_ns_uri) {
            $alias = $message->namespaces->getAlias($sreg_ns_uri);
            if ($alias !== null) {
                $found_ns_uri = $sreg_ns_uri;
                break;
            }
        }
 
        if ($alias === null) {
            // There is no alias for either of the types, so try to
            // add one. We default to using the modern value (1.1)
            $found_ns_uri = Auth_OpenID_SREG_NS_URI_1_1;
            if ($message->namespaces->addAlias(Auth_OpenID_SREG_NS_URI_1_1,
                                               'sreg') === null) {
                // An alias for the string 'sreg' already exists, but
                // it's defined for something other than simple
                // registration
                return null;
            }
        }
 
        return $found_ns_uri;
    }
}
 
class Auth_OpenID_SRegRequest extends Auth_OpenID_SRegBase {
 
    var $ns_alias = 'sreg';
 
    static function build($required=null, $optional=null,
                   $policy_url=null,
                   $sreg_ns_uri=Auth_OpenID_SREG_NS_URI,
                   $cls='Auth_OpenID_SRegRequest')
    {
        $obj = new $cls();
 
        $obj->required = array();
        $obj->optional = array();
        $obj->policy_url = $policy_url;
        $obj->ns_uri = $sreg_ns_uri;
 
        if ($required) {
            if (!$obj->requestFields($required, true, true)) {
                return null;
            }
        }
 
        if ($optional) {
            if (!$obj->requestFields($optional, false, true)) {
                return null;
            }
        }
 
        return $obj;
    }
 
    static function fromOpenIDRequest($request, $cls='Auth_OpenID_SRegRequest')
    {
 
        $obj = call_user_func_array(array($cls, 'build'),
                 array(null, null, null, Auth_OpenID_SREG_NS_URI, $cls));
 
        // Since we're going to mess with namespace URI mapping, don't
        // mutate the object that was passed in.
        $m = $request->message;
 
        $obj->ns_uri = $obj->_getSRegNS($m);
        $args = $m->getArgs($obj->ns_uri);
 
        if ($args === null || Auth_OpenID::isFailure($args)) {
            return null;
        }
 
        $obj->parseExtensionArgs($args);
 
        return $obj;
    }
 
    function parseExtensionArgs($args, $strict=false)
    {
        foreach (array('required', 'optional') as $list_name) {
            $required = ($list_name == 'required');
            $items = Auth_OpenID::arrayGet($args, $list_name);
            if ($items) {
                foreach (explode(',', $items) as $field_name) {
                    if (!$this->requestField($field_name, $required, $strict)) {
                        if ($strict) {
                            return false;
                        }
                    }
                }
            }
        }
 
        $this->policy_url = Auth_OpenID::arrayGet($args, 'policy_url');
 
        return true;
    }
 
    function allRequestedFields()
    {
        return array_merge($this->required, $this->optional);
    }
 
    function wereFieldsRequested()
    {
        return count($this->allRequestedFields());
    }
 
    function contains($field_name)
    {
        return (in_array($field_name, $this->required) ||
                in_array($field_name, $this->optional));
    }
 
    function requestField($field_name,
                          $required=false, $strict=false)
    {
        if (!Auth_OpenID_checkFieldName($field_name)) {
            return false;
        }
 
        if ($strict) {
            if ($this->contains($field_name)) {
                return false;
            }
        } else {
            if (in_array($field_name, $this->required)) {
                return true;
            }
 
            if (in_array($field_name, $this->optional)) {
                if ($required) {
                    unset($this->optional[array_search($field_name,
                                                       $this->optional)]);
                } else {
                    return true;
                }
            }
        }
 
        if ($required) {
            $this->required[] = $field_name;
        } else {
            $this->optional[] = $field_name;
        }
 
        return true;
    }
 
    function requestFields($field_names, $required=false, $strict=false)
    {
        if (!is_array($field_names)) {
            return false;
        }
 
        foreach ($field_names as $field_name) {
            if (!$this->requestField($field_name, $required, $strict=$strict)) {
                return false;
            }
        }
 
        return true;
    }
 
    function getExtensionArgs()
    {
        $args = array();
 
        if ($this->required) {
            $args['required'] = implode(',', $this->required);
        }
 
        if ($this->optional) {
            $args['optional'] = implode(',', $this->optional);
        }
 
        if ($this->policy_url) {
            $args['policy_url'] = $this->policy_url;
        }
 
        return $args;
    }
}
 
class Auth_OpenID_SRegResponse extends Auth_OpenID_SRegBase {
 
    var $ns_alias = 'sreg';
 
    function Auth_OpenID_SRegResponse($data=null,
                                      $sreg_ns_uri=Auth_OpenID_SREG_NS_URI)
    {
        if ($data === null) {
            $this->data = array();
        } else {
            $this->data = $data;
        }
 
        $this->ns_uri = $sreg_ns_uri;
    }
 
    static function extractResponse($request, $data)
    {
        $obj = new Auth_OpenID_SRegResponse();
        $obj->ns_uri = $request->ns_uri;
 
        foreach ($request->allRequestedFields() as $field) {
            $value = Auth_OpenID::arrayGet($data, $field);
            if ($value !== null) {
                $obj->data[$field] = $value;
            }
        }
 
        return $obj;
    }
 
    static function fromSuccessResponse($success_response, $signed_only=true)
    {
        global $Auth_OpenID_sreg_data_fields;
 
        $obj = new Auth_OpenID_SRegResponse();
        $obj->ns_uri = $obj->_getSRegNS($success_response->message);
 
        if ($signed_only) {
            $args = $success_response->getSignedNS($obj->ns_uri);
        } else {
            $args = $success_response->message->getArgs($obj->ns_uri);
        }
 
        if ($args === null || Auth_OpenID::isFailure($args)) {
            return null;
        }
 
        foreach ($Auth_OpenID_sreg_data_fields as $field_name => $desc) {
            if (in_array($field_name, array_keys($args))) {
                $obj->data[$field_name] = $args[$field_name];
            }
        }
 
        return $obj;
    }
 
    function getExtensionArgs()
    {
        return $this->data;
    }
 
    // Read-only dictionary interface
    function get($field_name, $default=null)
    {
        if (!Auth_OpenID_checkFieldName($field_name)) {
            return null;
        }
 
        return Auth_OpenID::arrayGet($this->data, $field_name, $default);
    }
 
    function contents()
    {
        return $this->data;
    }
}