ElggSession.php

Go to the documentation of this file.

<?php

use Elgg\Config;
use Elgg\Database;
use Elgg\Http\DatabaseSessionHandler;
use Elgg\Traits\Debug\Profilable;
use Symfony\Component\HttpFoundation\Session\Session;
use Symfony\Component\HttpFoundation\Session\SessionInterface;
use Symfony\Component\HttpFoundation\Session\Storage\MockArraySessionStorage;
use Symfony\Component\HttpFoundation\Session\Storage\NativeSessionStorage;

class ElggSession {
    
    use Profilable;

    protected $storage;

    protected $logged_in_user;

    protected $ignore_access = false;

    protected $show_disabled_entities = false;

    public function __construct(SessionInterface $storage) {
        $this->storage = $storage;
    }
    
    public function boot(): void {
    
        $this->beginTimer([__METHOD__]);
    
        $this->start();
    
        // test whether we have a user session
        if ($this->has('guid')) {
            $user = _elgg_services()->entityTable->get($this->get('guid'), 'user');
            if (!$user instanceof ElggUser) {
                // OMG user has been deleted.
                $this->invalidate();
                
                // redirect to homepage
                $this->endTimer([__METHOD__]);
                _elgg_services()->responseFactory->redirect('');
            }
        } else {
            $user = _elgg_services()->persistentLogin->bootSession();
            if ($user instanceof ElggUser) {
                _elgg_services()->persistentLogin->updateTokenUsage($user);
            }
        }
    
        if ($user instanceof ElggUser) {
            $this->setLoggedInUser($user);
            $user->setLastAction();
    
            // logout a user with open session who has been banned
            if ($user->isBanned()) {
                logout();
            }
        }
    
        $this->endTimer([__METHOD__]);
    }

    public function start() {
        
        if ($this->storage->getId()) {
            return true;
        }

        $result = $this->storage->start();
        $this->generateSessionToken();
        return $result;
    }

    public function migrate($destroy = false) {
        return $this->storage->migrate($destroy);
    }

    public function invalidate() {
        $this->storage->clear();
        $this->logged_in_user = null;
        $result = $this->migrate(true);
        $this->generateSessionToken();
        _elgg_services()->sessionCache->clear();
        return $result;
    }

    public function save() {
        $this->storage->save();
    }

    public function isStarted() {
        return $this->storage->isStarted();
    }

    public function getID() {
        return $this->storage->getId();
    }

    public function setId($id) {
        $this->storage->setId($id);
    }

    public function getName() {
        return $this->storage->getName();
    }

    public function setName($name) {
        $this->storage->setName($name);
    }

    public function get($name, $default = null) {
        return $this->storage->get($name, $default);
    }

    public function set($name, $value) {
        $this->storage->set($name, $value);
    }

    public function remove($name) {
        return $this->storage->remove($name);
    }

    public function has($name) {
        return $this->storage->has($name);
    }

    public function setLoggedInUser(\ElggUser $user) {
        $current_user = $this->getLoggedInUser();
        if ($current_user != $user) {
            $this->set('guid', $user->guid);
            $this->logged_in_user = $user;
            _elgg_services()->sessionCache->clear();
            _elgg_services()->entityCache->save($user);
            _elgg_services()->translator->setCurrentLanguage($user->language);
        }
    }

    public function getLoggedInUser() {
        return $this->logged_in_user;
    }

    public function getLoggedInUserGuid() {
        $user = $this->getLoggedInUser();
        return $user ? $user->guid : 0;
    }
    
    public function isAdminLoggedIn() {
        $user = $this->getLoggedInUser();
    
        return $user && $user->isAdmin();
    }
    
    public function isLoggedIn() {
        return (bool) $this->getLoggedInUser();
    }

    public function removeLoggedInUser() {
        $this->logged_in_user = null;
        $this->remove('guid');
        _elgg_services()->sessionCache->clear();
    }

    public function getIgnoreAccess() {
        return $this->ignore_access;
    }

    public function setIgnoreAccess($ignore = true) {
//      debug_print_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 5);
        $prev = $this->ignore_access;
        $this->ignore_access = $ignore;

        return $prev;
    }

    public function getDisabledEntityVisibility() {
        return $this->show_disabled_entities;
    }

    public function setDisabledEntityVisibility($show = true) {
        $prev = $this->show_disabled_entities;
        $this->show_disabled_entities = $show;

        return $prev;
    }

    protected function generateSessionToken() {
        // Generate a simple token that we store server side
        if (!$this->has('__elgg_session')) {
            $this->set('__elgg_session', _elgg_services()->crypto->getRandomString(22));
        }
    }

    public static function getMock() {
        $storage = new MockArraySessionStorage();
        $session = new Session($storage);
        return new self($session);
    }

    public static function fromDatabase(Config $config, Database $db) {
        $params = $config->getCookieConfig()['session'];
        $options = [
            // session.cache_limiter is unfortunately set to "" by the NativeSessionStorage
            // constructor, so we must capture and inject it directly.
            'cache_limiter' => session_cache_limiter(),

            'name' => $params['name'],
            'cookie_path' => $params['path'],
            'cookie_domain' => $params['domain'],
            'cookie_secure' => $params['secure'],
            'cookie_httponly' => $params['httponly'],
            'cookie_lifetime' => $params['lifetime'],
        ];

        $handler = new DatabaseSessionHandler($db);
        $storage = new NativeSessionStorage($options, $handler);
        $session = new Session($storage);
        return new self($session);
    }

    public static function fromFiles(Config $config) {
        $params = $config->getCookieConfig()['session'];
        $options = [
            // session.cache_limiter is unfortunately set to "" by the NativeSessionStorage
            // constructor, so we must capture and inject it directly.
            'cache_limiter' => session_cache_limiter(),

            'name' => $params['name'],
            'cookie_path' => $params['path'],
            'cookie_domain' => $params['domain'],
            'cookie_secure' => $params['secure'],
            'cookie_httponly' => $params['httponly'],
            'cookie_lifetime' => $params['lifetime'],
        ];

        $storage = new NativeSessionStorage($options);
        $session = new Session($storage);
        return new self($session);
    }
}