SWAT/SWAT.php5

<?php
class SWAT extends SObject {    
    protected $options = array();
    protected $session = null;

    protected $eventHandler = null;

    private $authError = array();

    /* -------------------------------------------- */
    /* Event Handling                               */
    /* -------------------------------------------- */

    public function getEventHandler() {
        if ($this->eventHandler == null) {
            $this->eventHandler = new SEventHandler();
        }
        return $this->eventHandler;
    }

    public function setEventHandler($eh) {
        $this->eventHandler = $eh;
    }

    public function handleEvents() {
        # ACTION HANDLING
        # if there are any POST requests, include the classes to handle them

        if (count($_POST) > 0 && isset($_POST['action'])){
            //print "Handling events...<br />\n";
            $peh = new SPOSTEventHandler();
            $peh->setEventHandler($this->getEventHandler());
            $peh->setSWAT($this);
            $peh->handleEvents();

            if ($peh->hasError()) {
                $this->setPrettyError('handleEvents', 'Event handler had an error');
                $this->getErrorFrom($peh);
                return false;
            }
            $this->getWarningFrom($peh);

            # If there have been no errors in performing this
            # action, then redirect to this page.
            if (!($peh->hasWarning() || $peh->hasError())) {
                SWATFunctions::redirect($_SERVER['REQUEST_URI']);
            }
        }
        return true;
    }

    /* -------------------------------------------- */
    /* Transactions                                 */
    /* -------------------------------------------- */

    function getTransaction() {
        if ($this->session == null) return null;
        return $this->session->getTransaction()->getTransaction();
    }

    /* -------------------------------------------- */
    /* Sessions                                     */
    /* -------------------------------------------- */

    public function startSession() {

        # Set all the session options based on the options/defaults
        # set on the SWAT object
        ini_set("session.cache_expire", SConfig::getOption('swat.sessionCacheExpire'));
        ini_set("session.gc_maxlifetime", SConfig::getOption('swat.sessionGcMaxLifetime'));
        ini_set("session.use_only_cookies", SConfig::getOption('swat.sessionUseOnlyCookies'));

        # Set the session name based on the options set on the SWAT object
        session_name(SConfig::getOption('swat.sessionName'));
        if(!isset($_SESSION))
            session_start();

        # If we've not yet stored the SWAT information in the session...
        if (!isset($_SESSION['SWAT'])) {
            # If we don't have the SWAT mirror of the session initialized on
            # this object, then go ahead and initialize that.
            $this->session = new SWATSession($this);

            # Otherwise, just copy this object's session mirror directly
            # into the session variable.
            $this->syncSession();
        } else {
        # If we HAVE already stored the SWAT information in the session...
            # simply mirror the information from the session into this object
            $this->session = unserialize($_SESSION['SWAT']);
            $this->session->setSWAT($this);
        }

        register_shutdown_function(array(&$this, "shutdownSession"));

        return true;
    }

    public function shutdownSession() {
        $this->syncSession();
    }

    public function syncSession() {
        if ($this->session == null) return;
        # Write a serialized version of the SWATSession object to the
        # PHP session.

        # Remove the link to the SWAT parent for serialization
        $this->session->setSWAT("");
        $this->session->sync();
        $_SESSION['SWAT'] = serialize($this->session);
        $this->session->setSWAT($this);
    }

    public function getSession() {
        return $this->session;
    }

    /* -------------------------------------------- */
    /* Session User Objects                         */
    /* -------------------------------------------- */

    public function getGlobalUser() {
        if ($this->getSession() == null) return null;
        return $this->getSession()->getGlobalUser();
    }

    public function getProjectUser() {
        if ($this->getSession() == null) return null;
        return $this->getSession()->getProjectUser();
    }

    public function setProjectUser($user, $project = "") {
        if ($this->getSession() == null) return false;
        return $this->getSession()->setProjectUser($user, $project);
    }

    public function __sleep() {
        $this->syncSession();
        return array_keys(get_object_vars($this));
    }

    /* -------------------------------------------- */
    /* Authentication/Login                         */
    /* -------------------------------------------- */

    protected function buildTKLoginForm($prm, $submitTo, $cameFrom, $retriesLeft, $message) {
        $form = new TKForm();
        $ftab = $form->addTable();
        $ftab->addText("Username:");
        $ftab->addFormInput('text', 'swat_username');
        $ftab->addRow();
        $ftab->addText("Password:");
        $ftab->addFormInput('password', 'swat_password');
        $form->addFormInput('hidden', 'swat_retries', $retriesLeft);
        $form->addFormInput('submit', 'swat_authenticate', SConfig::getOption('swat.string.loginButton'));
        $vbox = new TKVBox();
        $vbox->setClass(array('SWATLoginForm'));
        $vbox->addText($message);
        $vbox->add($form);
        $prm->add($vbox);
    }

    public function displayLoginPage($prm, $submitTo, $cameFrom, $retriesLeft) {
        # Set the page name
        if ($prm->getPage()->getSlot('PageName') == "") {
            $prm->getPage()->setSlot('PageName', SConfig::getOption('swat.string.loginRequestTitle'));
        } else {
            $prm->getPage()->appendToSlot('PageName', ' &mdash; ' . SConfig::getOption('swat.string.loginRequestTitle'));
        }
        # Display the form with the proper message
        $form = $this->buildTKLoginForm($prm, $submitTo, $cameFrom,
                $retriesLeft, SConfig::getOption('swat.string.loginRequest'));
    }

    public function displayLoginFailurePage($prm, $submitTo, $cameFrom, $retriesLeft) {
        # Set the page name
        $prm->getPage()->setSlot('PageName', SConfig::getOption('swat.string.loginFailureTitle'));
        # Display the form with the proper message
        $form = $this->buildTKLoginForm($prm, $submitTo, $cameFrom,
                $retriesLeft, SConfig::getOption('swat.string.loginFailure'));
    }

    public function authenticate($realms, $prm, $cameFrom = "", $retryCount = 3) {
        # reset authentication errors
        $this->resetAuthError();

        # If we're not using a secure connection yet, redirect.
        if($_SERVER['SERVER_PORT'] != 443) {
            if (SConfig::getOption('swat.useHTTPSLogin')){
                SWATFunctions::redirectHTTPS();
            }
        }

        # Set up came from and global user vars
        if($cameFrom == "") { $cameFrom = $_SERVER['REQUEST_URI']; }
        $guser = $this->getGlobalUser();

        # Check to see if the user is already authenticated.
        foreach($realms as $realm) {
            if($guser->isAuthenticatedFor($realm)) {
                return true;
            }
        }

        # If they have not sent username/password yet, just display the login page.
        if (!isset($_REQUEST['swat_authenticate'])) {
            $this->displayLoginPage($prm, $_SERVER['REQUEST_URI'], $cameFrom,
                $retryCount);
            $prm->renderPrint();
            exit;
        }

        # If we have a login attempt, try to process it
        $username = $_REQUEST['swat_username'];
        $password = $_REQUEST['swat_password'];
        $retriesLeft = $_REQUEST['swat_retries'];
        $isAuth = false;
        
    
        # Try to authenticate with each realm requested
        foreach($realms as $realm) {
            # Ask the global user to authenticate with a realm
            if($guser->authenticateWith($realm, $username, $password)) {
                $isAuth = true;
                #Log into HPCU forums if logging into HPCU account
                global $HPCU_SECTION;
                if ($HPCU_SECTION === 'login' || $HPCU_SECTION === 'user') {
                    if ($HPCU_SECTION === 'login')
                        require_once("../../../hpcu/plugins/phpBB3/login_helper.php");
                    else
                        require_once("../../../../hpcu/plugins/phpBB3/login_helper.php");
                    $auth->login($username, $password, true, 1, 0);
                    $HPCU_SECTION = '';
                }
            }
        }
    
        # If authentication succeeded, then synchronize - write the session
        # variable back to the actual session and redirect to came from.
        if ($isAuth) {
            $this->syncSession();
            SWATFunctions::redirect($cameFrom);
            return true;
        }

        # If authentication failed with these credentials,
        # If they are past the number of tries, bump them altogether
        # should remove the old retry system after we move to the authentication database
        if(!in_array('global', $realms) && $retriesLeft <= 0) {
            return false;
        }
        if(!empty($this->authError)) {
            return false;
        }

        # Display a login failure page (allow another attempt)
        $this->displayLoginFailurePage($prm, $_SERVER['REQUEST_URI'],
            $cameFrom, $retriesLeft - 1);
        $prm->renderPrint();
        sleep(1);
        exit;
    }

    public function deAuthenticate($cameFrom = "/") {
        $this->getGlobalUser()->deAuthenticateAll();
        $this->syncSession();
        SWATFunctions::redirect($cameFrom);
    }

    public function getAuthError() {
        return $this->authError;
    }

    public function authError($message) {
        array_push($this->authError, $message);
    }

    public function resetAuthError() {
        $this->authError = array();
    }
}

?>

---