source: extensions/oAuth/include/hybridauth/Hybrid/Endpoint.php @ 20293

<?php
/*!
* HybridAuth
* http://hybridauth.sourceforge.net | http://github.com/hybridauth/hybridauth
* (c) 2009-2012, HybridAuth authors | http://hybridauth.sourceforge.net/licenses.html
*/

/**
 * Hybrid_Endpoint class
 * 
 * Hybrid_Endpoint class provides a simple way to handle the OpenID and OAuth endpoint.
 */
class Hybrid_Endpoint {
        public static $request = NULL;
        public static $initDone = FALSE;

        /**
        * Process the current request
        *
        * $request - The current request parameters. Leave as NULL to default to use $_REQUEST.
        */
        public static function process( $request = NULL )
        {
                // Setup request variable
                Hybrid_Endpoint::$request = $request;

                if ( is_null(Hybrid_Endpoint::$request) ){
                        // Fix a strange behavior when some provider call back ha endpoint
                        // with /index.php?hauth.done={provider}?{args}... 
                        // >here we need to recreate the $_REQUEST
                        if ( strrpos( $_SERVER["QUERY_STRING"], '?' ) ) {
                                $_SERVER["QUERY_STRING"] = str_replace( "?", "&", $_SERVER["QUERY_STRING"] );

                                parse_str( $_SERVER["QUERY_STRING"], $_REQUEST );
                        }

                        Hybrid_Endpoint::$request = $_REQUEST;
                }

                // If openid_policy requested, we return our policy document
                if ( isset( Hybrid_Endpoint::$request["get"] ) && Hybrid_Endpoint::$request["get"] == "openid_policy" ) {
                        Hybrid_Endpoint::processOpenidPolicy();
                }

                // If openid_xrds requested, we return our XRDS document
                if ( isset( Hybrid_Endpoint::$request["get"] ) && Hybrid_Endpoint::$request["get"] == "openid_xrds" ) {
                        Hybrid_Endpoint::processOpenidXRDS();
                }

                // If we get a hauth.start
                if ( isset( Hybrid_Endpoint::$request["hauth_start"] ) && Hybrid_Endpoint::$request["hauth_start"] ) {
                        Hybrid_Endpoint::processAuthStart();
                }
                // Else if hauth.done
                elseif ( isset( Hybrid_Endpoint::$request["hauth_done"] ) && Hybrid_Endpoint::$request["hauth_done"] ) {
                        Hybrid_Endpoint::processAuthDone();
                }
                // Else we advertise our XRDS document, something supposed to be done from the Realm URL page
                else {
                        Hybrid_Endpoint::processOpenidRealm();
                }
        }

        /**
        * Process OpenID policy request
        */
        public static function processOpenidPolicy()
        {
                $output = file_get_contents( dirname(__FILE__) . "/resources/openid_policy.html" ); 
                print $output;
                die();
        }

        /**
        * Process OpenID XRDS request
        */
        public static function processOpenidXRDS()
        {
                header("Content-Type: application/xrds+xml");

                $output = str_replace
                (
                        "{RETURN_TO_URL}",
                        str_replace(
                                array("<", ">", "\"", "'", "&"), array("&lt;", "&gt;", "&quot;", "&apos;", "&amp;"), 
                                Hybrid_Auth::getCurrentUrl( false )
                        ),
                        file_get_contents( dirname(__FILE__) . "/resources/openid_xrds.xml" )
                );
                print $output;
                die();
        }

        /**
        * Process OpenID realm request
        */
        public static function processOpenidRealm()
        {
                $output = str_replace
                (
                        "{X_XRDS_LOCATION}",
                        htmlentities( Hybrid_Auth::getCurrentUrl( false ), ENT_QUOTES, 'UTF-8' ) . "?get=openid_xrds&v=" . Hybrid_Auth::$version,
                        file_get_contents( dirname(__FILE__) . "/resources/openid_realm.html" )
                ); 
                print $output;
                die();
        }

        /**
        * define:endpoint step 3.
        */
        public static function processAuthStart()
        {
                Hybrid_Endpoint::authInit();

                $provider_id = trim( strip_tags( Hybrid_Endpoint::$request["hauth_start"] ) );

                # check if page accessed directly
                if( ! Hybrid_Auth::storage()->get( "hauth_session.$provider_id.hauth_endpoint" ) ) {
                        Hybrid_Logger::error( "Endpoint: hauth_endpoint parameter is not defined on hauth_start, halt login process!" );

                        header( "HTTP/1.0 404 Not Found" );
                        die( "You cannot access this page directly." );
                }

                # define:hybrid.endpoint.php step 2.
                $hauth = Hybrid_Auth::setup( $provider_id );

                # if REQUESTed hauth_idprovider is wrong, session not created, etc. 
                if( ! $hauth ) {
                        Hybrid_Logger::error( "Endpoint: Invalid parameter on hauth_start!" );

                        header( "HTTP/1.0 404 Not Found" );
                        die( "Invalid parameter! Please return to the login page and try again." );
                }

                try {
                        Hybrid_Logger::info( "Endpoint: call adapter [{$provider_id}] loginBegin()" );

                        $hauth->adapter->loginBegin();
                }
                catch ( Exception $e ) {
                        Hybrid_Logger::error( "Exception:" . $e->getMessage(), $e );
                        Hybrid_Error::setError( $e->getMessage(), $e->getCode(), $e->getTraceAsString(), $e );

                        $hauth->returnToCallbackUrl();
                }

                die();
        }

        /**
        * define:endpoint step 3.1 and 3.2
        */
        public static function processAuthDone()
        {
                Hybrid_Endpoint::authInit();

                $provider_id = trim( strip_tags( Hybrid_Endpoint::$request["hauth_done"] ) );

                $hauth = Hybrid_Auth::setup( $provider_id );

                if( ! $hauth ) {
                        Hybrid_Logger::error( "Endpoint: Invalid parameter on hauth_done!" ); 

                        $hauth->adapter->setUserUnconnected();

                        header("HTTP/1.0 404 Not Found"); 
                        die( "Invalid parameter! Please return to the login page and try again." );
                }

                try {
                        Hybrid_Logger::info( "Endpoint: call adapter [{$provider_id}] loginFinish() " );

                        $hauth->adapter->loginFinish(); 
                }
                catch( Exception $e ){
                        Hybrid_Logger::error( "Exception:" . $e->getMessage(), $e );
                        Hybrid_Error::setError( $e->getMessage(), $e->getCode(), $e->getTraceAsString(), $e );

                        $hauth->adapter->setUserUnconnected(); 
                }

                Hybrid_Logger::info( "Endpoint: job done. retrun to callback url." );

                $hauth->returnToCallbackUrl();
                die();
        }

        public static function authInit()
        {
                if ( ! Hybrid_Endpoint::$initDone) {
                        Hybrid_Endpoint::$initDone = TRUE;

                        # Init Hybrid_Auth
                        try {
                                require_once realpath( dirname( __FILE__ ) )  . "/Storage.php";
                                
                                $storage = new Hybrid_Storage(); 
        
                                // Check if Hybrid_Auth session already exist
                                if ( ! $storage->config( "CONFIG" ) ) { 
                                        header( "HTTP/1.0 404 Not Found" );
                                        die( "You cannot access this page directly.2" );
                                }

                                Hybrid_Auth::initialize( $storage->config( "CONFIG" ) ); 
                        }
                        catch ( Exception $e ){
                                Hybrid_Logger::error( "Endpoint: Error while trying to init Hybrid_Auth" ); 

                                header( "HTTP/1.0 404 Not Found" );
                                die( "Oophs. Error!" );
                        }
                }
        }
}