friendica-github/library/oauth.php

<?php

//ini_set('display_errors', 1);
//error_reporting(E_ALL | E_STRICT);

// Regex to filter out the client identifier
// (described in Section 2 of IETF draft)
// IETF draft does not prescribe a format for these, however
// I've arbitrarily chosen alphanumeric strings with hyphens and underscores, 3-12 characters long
// Feel free to change.
define("REGEX_CLIENT_ID", "/^[a-z0-9-_]{3,12}$/i");

// Used to define the name of the OAuth access token parameter (POST/GET/etc.)
// IETF Draft sections 5.2 and 5.3 specify that it should be called "oauth_token"
// but other implementations use things like "access_token"
// I won't be heartbroken if you change it, but it might be better to adhere to the spec
define("OAUTH_TOKEN_PARAM_NAME", "oauth_token");

// Client types (for client authorization)
//define("WEB_SERVER_CLIENT_TYPE", "web_server");
//define("USER_AGENT_CLIENT_TYPE", "user_agent");
//define("REGEX_CLIENT_TYPE", "/^(web_server|user_agent)$/");
define("ACCESS_TOKEN_AUTH_RESPONSE_TYPE", "token");
define("AUTH_CODE_AUTH_RESPONSE_TYPE", "code");
define("CODE_AND_TOKEN_AUTH_RESPONSE_TYPE", "code-and-token");
define("REGEX_AUTH_RESPONSE_TYPE", "/^(token|code|code-and-token)$/");

// Grant Types (for token obtaining)
define("AUTH_CODE_GRANT_TYPE", "authorization-code");
define("USER_CREDENTIALS_GRANT_TYPE", "basic-credentials");
define("ASSERTION_GRANT_TYPE", "assertion");
define("REFRESH_TOKEN_GRANT_TYPE", "refresh-token");
define("NONE_GRANT_TYPE", "none");
define("REGEX_TOKEN_GRANT_TYPE", "/^(authorization-code|basic-credentials|assertion|refresh-token|none)$/");

/* Error handling constants */

// HTTP status codes
define("ERROR_NOT_FOUND", "404 Not Found");
define("ERROR_BAD_REQUEST", "400 Bad Request");

// TODO: Extend for i18n

// "Official" OAuth 2.0 errors
define("ERROR_REDIRECT_URI_MISMATCH", "redirect-uri-mismatch");
define("ERROR_INVALID_CLIENT_CREDENTIALS", "invalid-client-credentials");
define("ERROR_UNAUTHORIZED_CLIENT", "unauthorized-client");
define("ERROR_USER_DENIED", "access-denied");
define("ERROR_INVALID_REQUEST", "invalid-request");
define("ERROR_INVALID_CLIENT_ID", "invalid-client-id");
define("ERROR_UNSUPPORTED_RESPONSE_TYPE", "unsupported-response-type");
define("ERROR_INVALID_SCOPE", "invalid-scope");
define("ERROR_INVALID_GRANT", "invalid-grant");

// Protected resource errors
define("ERROR_INVALID_TOKEN", "invalid-token");
define("ERROR_EXPIRED_TOKEN", "expired-token");
define("ERROR_INSUFFICIENT_SCOPE", "insufficient-scope");

// Messages
define("ERROR_INVALID_RESPONSE_TYPE", "Invalid response type.");

// Errors that we made up

// Error for trying to use a grant type that we haven't implemented
define("ERROR_UNSUPPORTED_GRANT_TYPE", "unsupported-grant-type");

abstract class OAuth2 {

    /* Subclasses must implement the following functions */

    // Make sure that the client id is valid
    // If a secret is required, check that they've given the right one
    // Must return false if the client credentials are invalid
    abstract protected function auth_client_credentials($client_id, $client_secret = null);

    // OAuth says we should store request URIs for each registered client
    // Implement this function to grab the stored URI for a given client id
    // Must return false if the given client does not exist or is invalid
    abstract protected function get_redirect_uri($client_id);

    // We need to store and retrieve access token data as we create and verify tokens
    // Implement these functions to do just that

    // Look up the supplied token id from storage, and return an array like:
    //
    //  array(
    //      "client_id" => <stored client id>,
    //      "expires" => <stored expiration timestamp>,
    //      "scope" => <stored scope (may be null)
    //  )
    //
    //  Return null if the supplied token is invalid
    //
    abstract protected function get_access_token($token_id);

    // Store the supplied values
    abstract protected function store_access_token($token_id, $client_id, $expires, $scope = null);

    /*
     *
     * Stuff that should get overridden by subclasses
     *
     * I don't want to make these abstract, because then subclasses would have
     * to implement all of them, which is too much work.
     *
     * So they're just stubs.  Override the ones you need.
     *
     */

    // You should override this function with something,
    // or else your OAuth provider won't support any grant types!
    protected function get_supported_grant_types() {
        // If you support all grant types, then you'd do:
        // return array(
        //             AUTH_CODE_GRANT_TYPE,
        //             USER_CREDENTIALS_GRANT_TYPE,
        //             ASSERTION_GRANT_TYPE,
        //             REFRESH_TOKEN_GRANT_TYPE,
        //             NONE_GRANT_TYPE
        //     );

        return array();
    }

    // You should override this function with your supported response types
    protected function get_supported_auth_response_types() {
        return array(
            AUTH_CODE_AUTH_RESPONSE_TYPE,
            ACCESS_TOKEN_AUTH_RESPONSE_TYPE,
            CODE_AND_TOKEN_AUTH_RESPONSE_TYPE
        );
    }

    // If you want to support scope use, then have this function return a list
    // of all acceptable scopes (used to throw the invalid-scope error)
    protected function get_supported_scopes() {
        //  Example:
        //  return array("my-friends", "photos", "whatever-else");
        return array();
    }

    // If you want to restrict clients to certain authorization response types,
    // override this function
    // Given a client identifier and auth type, return true or false
    // (auth type would be one of the values contained in REGEX_AUTH_RESPONSE_TYPE)
    protected function authorize_client_response_type($client_id, $response_type) {
        return true;
    }

    // If you want to restrict clients to certain grant types, override this function
    // Given a client identifier and grant type, return true or false
    protected function authorize_client($client_id, $grant_type) {
        return true;
    }

    /* Functions that help grant access tokens for various grant types */

    // Fetch authorization code data (probably the most common grant type)
    // IETF Draft 4.1.1: http://tools.ietf.org/html/draft-ietf-oauth-v2-08#section-4.1.1
    // Required for AUTH_CODE_GRANT_TYPE
    protected function get_stored_auth_code($code) {
        // Retrieve the stored data for the given authorization code
        // Should return:
        //
        // array (
        //  "client_id" => <stored client id>,
        //  "redirect_uri" => <stored redirect URI>,
        //  "expires" => <stored code expiration time>,
        //  "scope" => <stored scope values (space-separated string), or can be omitted if scope is unused>
        // )
        //
        // Return null if the code is invalid.

        return null;
    }

    // Take the provided authorization code values and store them somewhere (db, etc.)
    // Required for AUTH_CODE_GRANT_TYPE
    protected function store_auth_code($code, $client_id, $redirect_uri, $expires, $scope) {
        // This function should be the storage counterpart to get_stored_auth_code

        // If storage fails for some reason, we're not currently checking
        // for any sort of success/failure, so you should bail out of the
        // script and provide a descriptive fail message
    }

    // Grant access tokens for basic user credentials
    // IETF Draft 4.1.2: http://tools.ietf.org/html/draft-ietf-oauth-v2-08#section-4.1.2
    // Required for USER_CREDENTIALS_GRANT_TYPE
    protected function check_user_credentials($client_id, $username, $password) {
        // Check the supplied username and password for validity
        // You can also use the $client_id param to do any checks required
        // based on a client, if you need that
        // If the username and password are invalid, return false

        // If the username and password are valid, and you want to verify the scope of
        // a user's access, return an array with the scope values, like so:
        //
        // array (
        //  "scope" => <stored scope values (space-separated string)>
        // )
        //
        // We'll check the scope you provide against the requested scope before
        // providing an access token.
        //
        // Otherwise, just return true.

        return false;
    }

    // Grant access tokens for assertions
    // IETF Draft 4.1.3: http://tools.ietf.org/html/draft-ietf-oauth-v2-08#section-4.1.3
    // Required for ASSERTION_GRANT_TYPE
    protected function check_assertion($client_id, $assertion_type, $assertion) {
        // Check the supplied assertion for validity
        // You can also use the $client_id param to do any checks required
        // based on a client, if you need that
        // If the assertion is invalid, return false

        // If the assertion is valid, and you want to verify the scope of
        // an access request, return an array with the scope values, like so:
        //
        // array (
        //  "scope" => <stored scope values (space-separated string)>
        // )
        //
        // We'll check the scope you provide against the requested scope before
        // providing an access token.
        //
        // Otherwise, just return true.

        return false;
    }

    // Grant refresh access tokens
    // IETF Draft 4.1.4: http://tools.ietf.org/html/draft-ietf-oauth-v2-08#section-4.1.4
    // Required for REFRESH_TOKEN_GRANT_TYPE
    protected function get_refresh_token($refresh_token) {
        // Retrieve the stored data for the given refresh token
        // Should return:
        //
        // array (
        //  "client_id" => <stored client id>,
        //  "expires" => <refresh token expiration time>,
        //  "scope" => <stored scope values (space-separated string), or can be omitted if scope is unused>
        // )
        //
        // Return null if the token id is invalid.

        return null;
    }

    // Store refresh access tokens
    // Required for REFRESH_TOKEN_GRANT_TYPE
    protected function store_refresh_token($token, $client_id, $expires, $scope = null) {
        // If storage fails for some reason, we're not currently checking
        // for any sort of success/failure, so you should bail out of the
        // script and provide a descriptive fail message

        return;
    }

    // Grant access tokens for the "none" grant type
    // Not really described in the IETF Draft, so I just left a method stub...do whatever you want!
    // Required for NONE_GRANT_TYPE
    protected function check_none_access($client_id) {
        return false;
    }

    protected function get_default_authentication_realm() {
        // Change this to whatever authentication realm you want to send in a WWW-Authenticate header
        return "Service";
    }

    /* End stuff that should get overridden */

    private $access_token_lifetime = 3600;
    private $auth_code_lifetime = 30;
    private $refresh_token_lifetime = 1209600; // Two weeks

    public function __construct($access_token_lifetime = 3600, $auth_code_lifetime = 30, $refresh_token_lifetime = 1209600) {
        $this->access_token_lifetime = $access_token_lifetime;
        $this->auth_code_lifetime = $auth_code_lifetime;
        $this->refresh_token_lifetime = $refresh_token_lifetime;
    }

    /* Resource protecting (Section 5) */

    // Check that a valid access token has been provided
    //
    // The scope parameter defines any required scope that the token must have
    // If a scope param is provided and the token does not have the required scope,
    // we bounce the request
    //
    // Some implementations may choose to return a subset of the protected resource
    // (i.e. "public" data) if the user has not provided an access token
    // or if the access token is invalid or expired
    //
    // The IETF spec says that we should send a 401 Unauthorized header and bail immediately
    // so that's what the defaults are set to
    //
    // Here's what each parameter does:
    // $scope = A space-separated string of required scope(s), if you want to check for scope
    // $exit_not_present = If true and no access token is provided, send a 401 header and exit, otherwise return false
    // $exit_invalid = If true and the implementation of get_access_token returns null, exit, otherwise return false
    // $exit_expired = If true and the access token has expired, exit, otherwise return false
    // $exit_scope = If true the access token does not have the required scope(s), exit, otherwise return false
    // $realm = If you want to specify a particular realm for the WWW-Authenticate header, supply it here
    public function verify_access_token($scope = null, $exit_not_present = true, $exit_invalid = true, $exit_expired = true, $exit_scope = true, $realm = null) {
        $token_param = $this->get_access_token_param();
        if ($token_param === false) // Access token was not provided
            return $exit_not_present ? $this->send_401_unauthorized($realm, $scope) : false;

        // Get the stored token data (from the implementing subclass)
        $token = $this->get_access_token($token_param);
        if ($token === null)
            return $exit_invalid ? $this->send_401_unauthorized($realm, $scope, ERROR_INVALID_TOKEN) : false;

        // Check token expiration (I'm leaving this check separated, later we'll fill in better error messages)
        if (isset($token["expires"]) && time() > $token["expires"])
            return $exit_expired ? $this->send_401_unauthorized($realm, $scope, ERROR_EXPIRED_TOKEN) : false;

        // Check scope, if provided
        // If token doesn't have a scope, it's null/empty, or it's insufficient, then throw an error
        if ($scope &&
                (!isset($token["scope"]) || !$token["scope"] || !$this->check_scope($scope, $token["scope"])))
            return $exit_scope ? $this->send_401_unauthorized($realm, $scope, ERROR_INSUFFICIENT_SCOPE) : false;

        return true;
    }


    // Returns true if everything in required scope is contained in available scope
    // False if something in required scope is not in available scope
    private function check_scope($required_scope, $available_scope) {
        // The required scope should match or be a subset of the available scope
        if (!is_array($required_scope))
            $required_scope = explode(" ", $required_scope);

        if (!is_array($available_scope))
            $available_scope = explode(" ", $available_scope);

        return (count(array_diff($required_scope, $available_scope)) == 0);
    }

    // Send a 401 unauthorized header with the given realm
    // and an error, if provided
    private function send_401_unauthorized($realm, $scope, $error = null) {
        $realm = $realm === null ? $this->get_default_authentication_realm() : $realm;

        $auth_header = "WWW-Authenticate: Token realm='".$realm."'";

        if ($scope)
            $auth_header .= ", scope='".$scope."'";

        if ($error !== null)
            $auth_header .= ", error='".$error."'";

        header("HTTP/1.1 401 Unauthorized");
        header($auth_header);

        exit;
    }

    // Pulls the access token out of the HTTP request
    // Either from the Authorization header or GET/POST/etc.
    // Returns false if no token is present
    // TODO: Support POST or DELETE
    private function get_access_token_param() {
        $auth_header = $this->get_authorization_header();

        if ($auth_header !== false) {
            // Make sure only the auth header is set
            if (isset($_GET[OAUTH_TOKEN_PARAM_NAME]) || isset($_POST[OAUTH_TOKEN_PARAM_NAME]))
                $this->error(ERROR_BAD_REQUEST, ERROR_INVALID_REQUEST);

            $auth_header = trim($auth_header);

            // Make sure it's Token authorization
            if (strcmp(substr($auth_header, 0, 6),"Token ") !== 0)
                $this->error(ERROR_BAD_REQUEST, ERROR_INVALID_REQUEST);

            // Parse the rest of the header
            if (preg_match('/\s*token\s*="(.+)"/', substr($auth_header, 6), $matches) == 0 || count($matches) < 2)
                $this->error(ERROR_BAD_REQUEST, ERROR_INVALID_REQUEST);

            return $matches[1];
        }

        if (isset($_GET[OAUTH_TOKEN_PARAM_NAME]))  {
            if (isset($_POST[OAUTH_TOKEN_PARAM_NAME])) // Both GET and POST are not allowed
                $this->error(ERROR_BAD_REQUEST, ERROR_INVALID_REQUEST);

            return $_GET[OAUTH_TOKEN_PARAM_NAME];
        }

        if (isset($_POST[OAUTH_TOKEN_PARAM_NAME]))
            return $_POST[OAUTH_TOKEN_PARAM_NAME];

        return false;
    }

    /* Access token granting (Section 4) */

    // Grant or deny a requested access token
    // This would be called from the "/token" endpoint as defined in the spec
    // Obviously, you can call your endpoint whatever you want
    public function grant_access_token() {
        $filters = array(
            "grant_type" => array("filter" => FILTER_VALIDATE_REGEXP, "options" => array("regexp" => REGEX_TOKEN_GRANT_TYPE), "flags" => FILTER_REQUIRE_SCALAR),
            "scope" => array("flags" => FILTER_REQUIRE_SCALAR),
            "code" => array("flags" => FILTER_REQUIRE_SCALAR),
            "redirect_uri" => array("filter" => FILTER_VALIDATE_URL, "flags" => array(FILTER_FLAG_SCHEME_REQUIRED, FILTER_REQUIRE_SCALAR)),
            "username" => array("flags" => FILTER_REQUIRE_SCALAR),
            "password" => array("flags" => FILTER_REQUIRE_SCALAR),
            "assertion_type" => array("flags" => FILTER_REQUIRE_SCALAR),
            "assertion" => array("flags" => FILTER_REQUIRE_SCALAR),
            "refresh_token" => array("flags" => FILTER_REQUIRE_SCALAR),
        );

        $input = filter_input_array(INPUT_POST, $filters);

        // Grant Type must be specified.
        if (!$input["grant_type"])
            $this->error(ERROR_BAD_REQUEST, ERROR_INVALID_REQUEST);

        // Make sure we've implemented the requested grant type
        if (!in_array($input["grant_type"], $this->get_supported_grant_types()))
            $this->error(ERROR_BAD_REQUEST, ERROR_UNSUPPORTED_GRANT_TYPE);

        // Authorize the client
        $client = $this->get_client_credentials();

        if ($this->auth_client_credentials($client[0], $client[1]) === false)
            $this->error(ERROR_BAD_REQUEST, ERROR_INVALID_CLIENT_CREDENTIALS);

        if (!$this->authorize_client($client[0], $input["grant_type"]))
            $this->error(ERROR_BAD_REQUEST, ERROR_UNAUTHORIZED_CLIENT);

        // Do the granting
        switch ($input["grant_type"]) {
            case AUTH_CODE_GRANT_TYPE:
                if (!$input["code"] || !$input["redirect_uri"])
                    $this->error(ERROR_BAD_REQUEST, ERROR_INVALID_REQUEST);

                $stored = $this->get_stored_auth_code($input["code"]);

                if ($stored === null || $input["redirect_uri"] != $stored["redirect_uri"] || $client[0] != $stored["client_id"])
                    $this->error(ERROR_BAD_REQUEST, ERROR_INVALID_GRANT);

                if ($stored["expires"] > time())
                    $this->error(ERROR_BAD_REQUEST, ERROR_INVALID_GRANT);

                break;
            case USER_CREDENTIALS_GRANT_TYPE:
                if (!$input["username"] || !$input["password"])
                    $this->error(ERROR_BAD_REQUEST, ERROR_INVALID_REQUEST);

                $stored = $this->check_user_credentials($client[0], $input["username"], $input["password"]);

                if ($stored === false)
                    $this->error(ERROR_BAD_REQUEST, ERROR_INVALID_GRANT);

                break;
            case ASSERTION_GRANT_TYPE:
                if (!$input["assertion_type"] || !$input["assertion"])
                    $this->error(ERROR_BAD_REQUEST, ERROR_INVALID_REQUEST);

                $stored = $this->check_assertion($client[0], $input["assertion_type"], $input["assertion"]);

                if ($stored === false)
                    $this->error(ERROR_BAD_REQUEST, ERROR_INVALID_GRANT);

                break;
            case REFRESH_TOKEN_GRANT_TYPE:
                if (!$input["refresh_token"])
                    $this->error(ERROR_BAD_REQUEST, ERROR_INVALID_REQUEST);

                $stored = $this->get_refresh_token($input["refresh_token"]);

                if ($stored === null || $client[0] != $stored["client_id"])
                    $this->error(ERROR_BAD_REQUEST, ERROR_INVALID_GRANT);

                if ($stored["expires"] > time())
                    $this->error(ERROR_BAD_REQUEST, ERROR_INVALID_GRANT);

                break;
            case NONE_GRANT_TYPE:
                $stored = $this->check_none_access($client[0]);

                if ($stored === false)
                    $this->error(ERROR_BAD_REQUEST, ERROR_INVALID_REQUEST);
        }

        // Check scope, if provided
        if ($input["scope"] && (!is_array($stored) || !isset($stored["scope"]) || !$this->check_scope($input["scope"], $stored["scope"])))
            $this->error(ERROR_BAD_REQUEST, ERROR_INVALID_SCOPE);

        if (!$input["scope"])
            $input["scope"] = null;

        $token = $this->create_access_token($client[0], $input["scope"]);

        $this->send_json_headers();
        echo json_encode($token);
    }

    // Internal function used to get the client credentials from HTTP basic auth or POST data
    // See http://tools.ietf.org/html/draft-ietf-oauth-v2-08#section-2
    private function get_client_credentials() {
        if (isset($_SERVER["PHP_AUTH_USER"]) && $_POST && isset($_POST["client_id"]))
            $this->error(ERROR_BAD_REQUEST, ERROR_INVALID_CLIENT_CREDENTIALS);

        // Try basic auth
        if (isset($_SERVER["PHP_AUTH_USER"]))
            return array($_SERVER["PHP_AUTH_USER"], $_SERVER["PHP_AUTH_PW"]);

        // Try POST
        if ($_POST && isset($_POST["client_id"])) {
            if (isset($_POST["client_secret"]))
                return array($_POST["client_id"], $_POST["client_secret"]);

            return array($_POST["client_id"], NULL);
        }

        // No credentials were specified
        $this->error(ERROR_BAD_REQUEST, ERROR_INVALID_CLIENT_CREDENTIALS);
    }

    /* End-user/client Authorization (Section 3 of IETF Draft) */

    // Pull the authorization request data out of the HTTP request
    // and return it so the authorization server can prompt the user
    // for approval
    public function get_authorize_params() {
        $filters = array(
            "client_id" => array("filter" => FILTER_VALIDATE_REGEXP, "options" => array("regexp" => REGEX_CLIENT_ID), "flags" => FILTER_REQUIRE_SCALAR),
            "response_type" => array("filter" => FILTER_VALIDATE_REGEXP, "options" => array("regexp" => REGEX_AUTH_RESPONSE_TYPE), "flags" => FILTER_REQUIRE_SCALAR),
            "redirect_uri" => array("filter" => FILTER_VALIDATE_URL, "flags" => array(FILTER_FLAG_SCHEME_REQUIRED, FILTER_REQUIRE_SCALAR)),
            "state" => array("flags" => FILTER_REQUIRE_SCALAR),
            "scope" => array("flags" => FILTER_REQUIRE_SCALAR),
        );

        $input = filter_input_array(INPUT_GET, $filters);

        // Make sure a valid client id was supplied
        if (!$input["client_id"]) {
            if ($input["redirect_uri"])
                $this->callback_error($input["redirect_uri"], ERROR_INVALID_CLIENT_ID, $input["state"]);

            $this->error(ERROR_BAD_REQUEST, ERROR_INVALID_CLIENT_ID); // We don't have a good URI to use
        }

        // redirect_uri is not required if already established via other channels
        // check an existing redirect URI against the one supplied
        $redirect_uri = $this->get_redirect_uri($input["client_id"]);

        // At least one of: existing redirect URI or input redirect URI must be specified
        if (!$redirect_uri && !$input["redirect_uri"])
            $this->error(ERROR_BAD_REQUEST, ERROR_INVALID_REQUEST);

        // get_redirect_uri should return false if the given client ID is invalid
        // this probably saves us from making a separate db call, and simplifies the method set
        if ($redirect_uri === false)
            $this->callback_error($input["redirect_uri"], ERROR_INVALID_CLIENT_ID, $input["state"]);

        // If there's an existing uri and one from input, verify that they match
        if ($redirect_uri && $input["redirect_uri"]) {
            // Ensure that the input uri starts with the stored uri
            if (strcasecmp(substr($input["redirect_uri"], 0, strlen($redirect_uri)),$redirect_uri) !== 0)
                $this->callback_error($input["redirect_uri"], ERROR_REDIRECT_URI_MISMATCH, $input["state"]);
        } elseif ($redirect_uri) { // They did not provide a uri from input, so use the stored one
            $input["redirect_uri"] = $redirect_uri;
        }

        // type and client_id are required
        if (!$input["response_type"])
            $this->callback_error($input["redirect_uri"], ERROR_INVALID_REQUEST, $input["state"], ERROR_INVALID_RESPONSE_TYPE);

        // Check requested auth response type against the list of supported types
        if (array_search($input["response_type"], $this->get_supported_auth_response_types()) === false)
            $this->callback_error($input["redirect_uri"], ERROR_UNSUPPORTED_RESPONSE_TYPE, $input["state"]);

        // Validate that the requested scope is supported
        if ($input["scope"] && !$this->check_scope($input["scope"], $this->get_supported_scopes()))
            $this->callback_error($input["redirect_uri"], ERROR_INVALID_SCOPE, $input["state"]);

        return $input;
    }

    // After the user has approved or denied the access request
    // the authorization server should call this function to redirect
    // the user appropriately

    // The params all come from the results of get_authorize_params
    // except for $is_authorized -- this is true or false depending on whether
    // the user authorized the access
    public function finish_client_authorization($is_authorized, $type, $client_id, $redirect_uri, $state, $scope = null) {
        if ($state !== null)
            $result["query"]["state"] = $state;

        if ($is_authorized === false) {
            $result["query"]["error"] = ERROR_USER_DENIED;
        } else {
            if ($type == AUTH_CODE_AUTH_RESPONSE_TYPE || $type == CODE_AND_TOKEN_AUTH_RESPONSE_TYPE)
                $result["query"]["code"] = $this->create_auth_code($client_id, $redirect_uri, $scope);

            if ($type == ACCESS_TOKEN_AUTH_RESPONSE_TYPE || $type == CODE_AND_TOKEN_AUTH_RESPONSE_TYPE)
                $result["fragment"] = $this->create_access_token($client_id, $scope);
        }

        $this->do_redirect_uri_callback($redirect_uri, $result);
    }

    /* Other/utility functions */

    private function do_redirect_uri_callback($redirect_uri, $result) {
        header("HTTP/1.1 302 Found");
        header("Location: " . $this->build_uri($redirect_uri, $result));
        exit;
    }

    private function build_uri($uri, $data) {
        $parse_url = parse_url($uri);

        // Add our data to the parsed uri
        foreach ($data as $k => $v) {
            if (isset($parse_url[$k]))
                $parse_url[$k] .= "&" . http_build_query($v);
            else
                $parse_url[$k] = http_build_query($v);
        }

        // Put humpty dumpty back together
        return
             ((isset($parse_url["scheme"])) ? $parse_url["scheme"] . "://" : "")
            .((isset($parse_url["user"])) ? $parse_url["user"] . ((isset($parse_url["pass"])) ? ":" . $parse_url["pass"] : "") ."@" : "")
            .((isset($parse_url["host"])) ? $parse_url["host"] : "")
            .((isset($parse_url["port"])) ? ":" . $parse_url["port"] : "")
            .((isset($parse_url["path"])) ? $parse_url["path"] : "")
            .((isset($parse_url["query"])) ? "?" . $parse_url["query"] : "")
            .((isset($parse_url["fragment"])) ? "#" . $parse_url["fragment"] : "");
    }

    // This belongs in a separate factory, but to keep it simple, I'm just keeping it here.
    private function create_access_token($client_id, $scope) {
        $token = array(
            "access_token" => $this->gen_access_token(),
            "expires_in" => $this->access_token_lifetime,
            "scope" => $scope
        );

        $this->store_access_token($token["access_token"], $client_id, time() + $this->access_token_lifetime, $scope);

        // Issue a refresh token also, if we support them
        if (in_array(REFRESH_TOKEN_GRANT_TYPE, $this->get_supported_grant_types())) {
            $token["refresh_token"] = $this->gen_access_token();
            $this->store_refresh_token($token["refresh_token"], $client_id, time() + $this->refresh_token_lifetime, $scope);
        }

        return $token;
    }

    private function create_auth_code($client_id, $redirect_uri, $scope) {
        $code = $this->gen_auth_code();
        $this->store_auth_code($code, $client_id, $redirect_uri, time() + $this->auth_code_lifetime, $scope);
        return $code;
    }

    // Implementing classes may want to override these two functions
    // to implement other access token or auth code generation schemes
    private function gen_access_token() {
        return base64_encode(pack('N6', mt_rand(), mt_rand(), mt_rand(), mt_rand(), mt_rand(), mt_rand()));
    }

    private function gen_auth_code() {
        return base64_encode(pack('N6', mt_rand(), mt_rand(), mt_rand(), mt_rand(), mt_rand(), mt_rand()));
    }

    // Implementing classes may need to override this function for use on non-Apache web servers
    // Just pull out the Authorization HTTP header and return it
    // Return false if the Authorization header does not exist
    private function get_authorization_header() {
        if (array_key_exists("HTTP_AUTHORIZATION", $_SERVER))
            return $_SERVER["HTTP_AUTHORIZATION"];

        if (function_exists("apache_request_headers")) {
            $headers = apache_request_headers();

            if (array_key_exists("Authorization", $headers))
                return $headers["Authorization"];
        }

        return false;
    }

    private function send_json_headers() {
        header("Content-Type: application/json");
        header("Cache-Control: no-store");
    }

    public function error($code, $message = null) {
        header("HTTP/1.1 " . $code);

        if ($message) {
            $this->send_json_headers();
            echo json_encode(array("error" => $message));
        }

        exit;
    }

    public function callback_error($redirect_uri, $error, $state, $message = null, $error_uri = null) {
        $result["query"]["error"] = $error;

        if ($state)
            $result["query"]["state"] = $state;

        if ($message)
            $result["query"]["error_description"] = $message;

        if ($error_uri)
            $result["query"]["error_uri"] = $error_uri;

        $this->do_redirect_uri_callback($redirect_uri, $result);
    }
}