core/Classes/Core/Bootstrap.php

Go to the documentation of this file.

<?php
namespace TYPO3\CMS\Core\Core;

/*
 * This file is part of the TYPO3 CMS project.
 *
 * It is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License, either version 2
 * of the License, or any later version.
 *
 * For the full copyright and license information, please read the
 * LICENSE.txt file that was distributed with this source code.
 *
 * The TYPO3 project - inspiring people to share!
 */

use TYPO3\CMS\Core\Utility\ExtensionManagementUtility;
use TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\CMS\Core\Utility\MathUtility;

class Bootstrap
{
    protected static $instance = null;

    protected $requestId;

    protected $applicationContext;

    protected $earlyInstances = array();

    protected $installToolPath;

    protected $availableRequestHandlers = array();

    protected $response;

    protected static $usesComposerClassLoading = false;

    protected function __construct($applicationContext)
    {
        $this->requestId = substr(md5(uniqid('', true)), 0, 13);
        $this->applicationContext = new ApplicationContext($applicationContext);
    }

    public static function usesComposerClassLoading()
    {
        return self::$usesComposerClassLoading;
    }

    protected function __clone()
    {
    }

    public static function getInstance()
    {
        if (is_null(static::$instance)) {
            $applicationContext = getenv('TYPO3_CONTEXT') ?: (getenv('REDIRECT_TYPO3_CONTEXT') ?: 'Production');
            self::$instance = new static($applicationContext);
        }
        return static::$instance;
    }

    public function getRequestId()
    {
        return $this->requestId;
    }

    public function getApplicationContext()
    {
        return $this->applicationContext;
    }

    public function startOutputBuffering()
    {
        ob_start();
        return $this;
    }

    public function configure()
    {
        $this->startOutputBuffering()
            ->loadConfigurationAndInitialize()
            ->loadTypo3LoadedExtAndExtLocalconf(true)
            ->setFinalCachingFrameworkCacheConfiguration()
            ->defineLoggingAndExceptionConstants()
            ->unsetReservedGlobalVariables()
            ->initializeTypo3DbGlobal();

        return $this;
    }

    public function baseSetup($relativePathPart = '')
    {
        SystemEnvironmentBuilder::run($relativePathPart);
        if (!self::$usesComposerClassLoading && ClassLoadingInformation::isClassLoadingInformationAvailable()) {
            ClassLoadingInformation::registerClassLoadingInformation();
        }
        GeneralUtility::presetApplicationContext($this->applicationContext);
        return $this;
    }

    public function initializeClassLoader($classLoader)
    {
        $this->setEarlyInstance(\Composer\Autoload\ClassLoader::class, $classLoader);
        if (defined('TYPO3_COMPOSER_MODE') && TYPO3_COMPOSER_MODE) {
            self::$usesComposerClassLoading = true;
        }
        return $this;
    }

    public function checkIfEssentialConfigurationExists()
    {
        $configurationManager = new \TYPO3\CMS\Core\Configuration\ConfigurationManager;
        $this->setEarlyInstance(\TYPO3\CMS\Core\Configuration\ConfigurationManager::class, $configurationManager);
        return file_exists($configurationManager->getLocalConfigurationFileLocation()) && file_exists(PATH_typo3conf . 'PackageStates.php');
    }

    public function redirectToInstallTool($relativePathPart = '')
    {
        $backPathToSiteRoot = str_repeat('../', count(explode('/', $relativePathPart)) - 1);
        header('Location: ' . $backPathToSiteRoot . 'typo3/sysext/install/Start/Install.php');
        die;
    }

    public function registerRequestHandlerImplementation($requestHandler)
    {
        $this->availableRequestHandlers[] = $requestHandler;
        return $this;
    }

    protected function resolveRequestHandler($request)
    {
        $suitableRequestHandlers = array();
        foreach ($this->availableRequestHandlers as $requestHandlerClassName) {
            $requestHandler = GeneralUtility::makeInstance($requestHandlerClassName, $this);
            if ($requestHandler->canHandleRequest($request)) {
                $priority = $requestHandler->getPriority();
                if (isset($suitableRequestHandlers[$priority])) {
                    throw new \TYPO3\CMS\Core\Exception('More than one request handler with the same priority can handle the request, but only one handler may be active at a time!', 1176471352);
                }
                $suitableRequestHandlers[$priority] = $requestHandler;
            }
        }
        if (empty($suitableRequestHandlers)) {
            throw new \TYPO3\CMS\Core\Exception('No suitable request handler found.', 1225418233);
        }
        ksort($suitableRequestHandlers);
        return array_pop($suitableRequestHandlers);
    }

    public function handleRequest($request)
    {

        // Resolve request handler that were registered based on the Application
        $requestHandler = $this->resolveRequestHandler($request);

        // Execute the command which returns a Response object or NULL
        $this->response = $requestHandler->handleRequest($request);
        return $this;
    }

    protected function sendResponse()
    {
        if ($this->response instanceof \Psr\Http\Message\ResponseInterface) {
            if (!headers_sent()) {
                foreach ($this->response->getHeaders() as $name => $values) {
                    header($name . ': ' . implode(', ', $values));
                }
                // If the response code was not changed by legacy code (still is 200)
                // then allow the PSR-7 response object to explicitly set it.
                // Otherwise let legacy code take precedence.
                // This code path can be deprecated once we expose the response object to third party code
                if (http_response_code() === 200) {
                    header('HTTP/' . $this->response->getProtocolVersion() . ' ' . $this->response->getStatusCode() . ' ' . $this->response->getReasonPhrase());
                }
            }
            echo $this->response->getBody()->__toString();
        }
        return $this;
    }

    public function setEarlyInstance($objectName, $instance)
    {
        $this->earlyInstances[$objectName] = $instance;
    }

    public function getEarlyInstance($objectName)
    {
        if (!isset($this->earlyInstances[$objectName])) {
            throw new \TYPO3\CMS\Core\Exception('Unknown early instance "' . $objectName . '"', 1365167380);
        }
        return $this->earlyInstances[$objectName];
    }

    public function getEarlyInstances()
    {
        return $this->earlyInstances;
    }

    public function loadConfigurationAndInitialize($allowCaching = true, $packageManagerClassName = \TYPO3\CMS\Core\Package\PackageManager::class)
    {
        $this->populateLocalConfiguration()
            ->initializeErrorHandling();
        if (!$allowCaching) {
            $this->disableCoreCache();
        }
        $this->initializeCachingFramework()
            ->initializePackageManagement($packageManagerClassName)
            ->initializeRuntimeActivatedPackagesFromConfiguration()
            ->defineDatabaseConstants()
            ->defineUserAgentConstant()
            ->registerExtDirectComponents()
            ->setCacheHashOptions()
            ->setDefaultTimezone()
            ->initializeL10nLocales()
            ->convertPageNotFoundHandlingToBoolean()
            ->setMemoryLimit()
            ->defineTypo3RequestTypes();
        if ($allowCaching) {
            $this->ensureClassLoadingInformationExists();
        }
        return $this;
    }

    public function initializePackageManagement($packageManagerClassName)
    {
        $packageManager = new $packageManagerClassName();
        $this->setEarlyInstance(\TYPO3\CMS\Core\Package\PackageManager::class, $packageManager);
        ExtensionManagementUtility::setPackageManager($packageManager);
        $packageManager->injectCoreCache($this->getEarlyInstance(\TYPO3\CMS\Core\Cache\CacheManager::class)->getCache('cache_core'));
        $dependencyResolver = GeneralUtility::makeInstance(\TYPO3\CMS\Core\Package\DependencyResolver::class);
        $dependencyResolver->injectDependencyOrderingService(GeneralUtility::makeInstance(\TYPO3\CMS\Core\Service\DependencyOrderingService::class));
        $packageManager->injectDependencyResolver($dependencyResolver);
        $packageManager->initialize($this);
        GeneralUtility::setSingletonInstance(\TYPO3\CMS\Core\Package\PackageManager::class, $packageManager);
        return $this;
    }

    public function ensureClassLoadingInformationExists()
    {
        if (!self::$usesComposerClassLoading && !ClassLoadingInformation::isClassLoadingInformationAvailable()) {
            ClassLoadingInformation::dumpClassLoadingInformation();
            ClassLoadingInformation::registerClassLoadingInformation();
        }
        return $this;
    }

    protected function initializeRuntimeActivatedPackagesFromConfiguration()
    {
        if (!empty($GLOBALS['TYPO3_CONF_VARS']['EXT']['runtimeActivatedPackages']) && is_array($GLOBALS['TYPO3_CONF_VARS']['EXT']['runtimeActivatedPackages'])) {
            $packageManager = $this->getEarlyInstance(\TYPO3\CMS\Core\Package\PackageManager::class);
            foreach ($GLOBALS['TYPO3_CONF_VARS']['EXT']['runtimeActivatedPackages'] as $runtimeAddedPackageKey) {
                $packageManager->activatePackageDuringRuntime($runtimeAddedPackageKey);
            }
        }
        return $this;
    }

    public function loadTypo3LoadedExtAndExtLocalconf($allowCaching = true)
    {
        ExtensionManagementUtility::loadExtLocalconf($allowCaching);
        return $this;
    }

    public function populateLocalConfiguration()
    {
        try {
            $configurationManager = $this->getEarlyInstance(\TYPO3\CMS\Core\Configuration\ConfigurationManager::class);
        } catch (\TYPO3\CMS\Core\Exception $exception) {
            $configurationManager = new \TYPO3\CMS\Core\Configuration\ConfigurationManager();
            $this->setEarlyInstance(\TYPO3\CMS\Core\Configuration\ConfigurationManager::class, $configurationManager);
        }
        $configurationManager->exportConfiguration();
        return $this;
    }

    public function disableCoreCache()
    {
        $GLOBALS['TYPO3_CONF_VARS']['SYS']['caching']['cacheConfigurations']['cache_core']['backend']
            = \TYPO3\CMS\Core\Cache\Backend\NullBackend::class;
        unset($GLOBALS['TYPO3_CONF_VARS']['SYS']['caching']['cacheConfigurations']['cache_core']['options']);
        return $this;
    }

    protected function defineDatabaseConstants()
    {
        define('TYPO3_db', $GLOBALS['TYPO3_CONF_VARS']['DB']['database']);
        define('TYPO3_db_username', $GLOBALS['TYPO3_CONF_VARS']['DB']['username']);
        define('TYPO3_db_password', $GLOBALS['TYPO3_CONF_VARS']['DB']['password']);
        define('TYPO3_db_host', $GLOBALS['TYPO3_CONF_VARS']['DB']['host']);
        // Constant TYPO3_extTableDef_script is deprecated since TYPO3 CMS 7 and will be dropped with TYPO3 CMS 8
        define('TYPO3_extTableDef_script',
            isset($GLOBALS['TYPO3_CONF_VARS']['DB']['extTablesDefinitionScript'])
            ? $GLOBALS['TYPO3_CONF_VARS']['DB']['extTablesDefinitionScript']
            : 'extTables.php');
        return $this;
    }

    protected function defineUserAgentConstant()
    {
        define('TYPO3_user_agent', 'User-Agent: ' . $GLOBALS['TYPO3_CONF_VARS']['HTTP']['userAgent']);
        return $this;
    }

    protected function registerExtDirectComponents()
    {
        if (TYPO3_MODE === 'BE') {
            ExtensionManagementUtility::registerExtDirectComponent(
                'TYPO3.Components.PageTree.DataProvider',
                \TYPO3\CMS\Backend\Tree\Pagetree\ExtdirectTreeDataProvider::class
            );
            ExtensionManagementUtility::registerExtDirectComponent(
                'TYPO3.Components.PageTree.Commands',
                \TYPO3\CMS\Backend\Tree\Pagetree\ExtdirectTreeCommands::class
            );
            ExtensionManagementUtility::registerExtDirectComponent(
                'TYPO3.Components.PageTree.ContextMenuDataProvider',
                \TYPO3\CMS\Backend\ContextMenu\Pagetree\Extdirect\ContextMenuConfiguration::class
            );
            ExtensionManagementUtility::registerExtDirectComponent(
                'TYPO3.ExtDirectStateProvider.ExtDirect',
                \TYPO3\CMS\Backend\InterfaceState\ExtDirect\DataProvider::class
            );
            ExtensionManagementUtility::registerExtDirectComponent(
                'TYPO3.Components.DragAndDrop.CommandController',
                ExtensionManagementUtility::extPath('backend') . 'Classes/View/PageLayout/Extdirect/ExtdirectPageCommands.php:' . \TYPO3\CMS\Backend\View\PageLayout\ExtDirect\ExtdirectPageCommands::class
            );
        }
        return $this;
    }

    public function initializeCachingFramework()
    {
        $cacheManager = new \TYPO3\CMS\Core\Cache\CacheManager();
        $cacheManager->setCacheConfigurations($GLOBALS['TYPO3_CONF_VARS']['SYS']['caching']['cacheConfigurations']);
        GeneralUtility::setSingletonInstance(\TYPO3\CMS\Core\Cache\CacheManager::class, $cacheManager);

        $cacheFactory = new \TYPO3\CMS\Core\Cache\CacheFactory('production', $cacheManager);
        GeneralUtility::setSingletonInstance(\TYPO3\CMS\Core\Cache\CacheFactory::class, $cacheFactory);

        $this->setEarlyInstance(\TYPO3\CMS\Core\Cache\CacheManager::class, $cacheManager);
        return $this;
    }

    protected function setCacheHashOptions()
    {
        $GLOBALS['TYPO3_CONF_VARS']['FE']['cacheHash'] = array(
            'cachedParametersWhiteList' => GeneralUtility::trimExplode(',', $GLOBALS['TYPO3_CONF_VARS']['FE']['cHashOnlyForParameters'], true),
            'excludedParameters' => GeneralUtility::trimExplode(',', $GLOBALS['TYPO3_CONF_VARS']['FE']['cHashExcludedParameters'], true),
            'requireCacheHashPresenceParameters' => GeneralUtility::trimExplode(',', $GLOBALS['TYPO3_CONF_VARS']['FE']['cHashRequiredParameters'], true)
        );
        if (trim($GLOBALS['TYPO3_CONF_VARS']['FE']['cHashExcludedParametersIfEmpty']) === '*') {
            $GLOBALS['TYPO3_CONF_VARS']['FE']['cacheHash']['excludeAllEmptyParameters'] = true;
        } else {
            $GLOBALS['TYPO3_CONF_VARS']['FE']['cacheHash']['excludedParametersIfEmpty'] = GeneralUtility::trimExplode(',', $GLOBALS['TYPO3_CONF_VARS']['FE']['cHashExcludedParametersIfEmpty'], true);
        }
        return $this;
    }

    protected function setDefaultTimezone()
    {
        $timeZone = $GLOBALS['TYPO3_CONF_VARS']['SYS']['phpTimeZone'];
        if (empty($timeZone)) {
            // Time zone from the server environment (TZ env or OS query)
            $defaultTimeZone = @date_default_timezone_get();
            if ($defaultTimeZone !== '') {
                $timeZone = $defaultTimeZone;
            } else {
                $timeZone = 'UTC';
            }
        }
        // Set default to avoid E_WARNINGs with PHP > 5.3
        date_default_timezone_set($timeZone);
        return $this;
    }

    protected function initializeL10nLocales()
    {
        \TYPO3\CMS\Core\Localization\Locales::initialize();
        return $this;
    }

    protected function convertPageNotFoundHandlingToBoolean()
    {
        if (!strcasecmp($GLOBALS['TYPO3_CONF_VARS']['FE']['pageNotFound_handling'], 'TRUE')) {
            $GLOBALS['TYPO3_CONF_VARS']['FE']['pageNotFound_handling'] = true;
        }
        return $this;
    }

    protected function initializeErrorHandling()
    {
        $productionExceptionHandlerClassName = $GLOBALS['TYPO3_CONF_VARS']['SYS']['productionExceptionHandler'];
        $debugExceptionHandlerClassName = $GLOBALS['TYPO3_CONF_VARS']['SYS']['debugExceptionHandler'];

        $errorHandlerClassName = $GLOBALS['TYPO3_CONF_VARS']['SYS']['errorHandler'];
        $errorHandlerErrors = $GLOBALS['TYPO3_CONF_VARS']['SYS']['errorHandlerErrors'];
        $exceptionalErrors = $GLOBALS['TYPO3_CONF_VARS']['SYS']['exceptionalErrors'];

        $displayErrorsSetting = (int)$GLOBALS['TYPO3_CONF_VARS']['SYS']['displayErrors'];
        switch ($displayErrorsSetting) {
            case 2:
                GeneralUtility::deprecationLog('The option "$TYPO3_CONF_VARS[SYS][displayErrors]" is set to "2" which is deprecated as of TYPO3 CMS 7, and will be removed with TYPO3 CMS 8. Please change the value to "-1"');
                // intentionally fall through
            case -1:
                $ipMatchesDevelopmentSystem = GeneralUtility::cmpIP(GeneralUtility::getIndpEnv('REMOTE_ADDR'), $GLOBALS['TYPO3_CONF_VARS']['SYS']['devIPmask']);
                $exceptionHandlerClassName = $ipMatchesDevelopmentSystem ? $debugExceptionHandlerClassName : $productionExceptionHandlerClassName;
                $displayErrors = $ipMatchesDevelopmentSystem ? 1 : 0;
                $exceptionalErrors = $ipMatchesDevelopmentSystem ? $exceptionalErrors : 0;
                break;
            case 0:
                $exceptionHandlerClassName = $productionExceptionHandlerClassName;
                $displayErrors = 0;
                break;
            case 1:
                $exceptionHandlerClassName = $debugExceptionHandlerClassName;
                $displayErrors = 1;
                break;
            default:
                // Throw exception if an invalid option is set.
                throw new \RuntimeException('The option $TYPO3_CONF_VARS[SYS][displayErrors] is not set to "-1", "0" or "1".');
        }
        @ini_set('display_errors', $displayErrors);

        if (!empty($errorHandlerClassName)) {
            // Register an error handler for the given errorHandlerError
            $errorHandler = GeneralUtility::makeInstance($errorHandlerClassName, $errorHandlerErrors);
            $errorHandler->setExceptionalErrors($exceptionalErrors);
            if (is_callable(array($errorHandler, 'setDebugMode'))) {
                $errorHandler->setDebugMode($displayErrors === 1);
            }
        }
        if (!empty($exceptionHandlerClassName)) {
            // Registering the exception handler is done in the constructor
            GeneralUtility::makeInstance($exceptionHandlerClassName);
        }
        return $this;
    }

    protected function setMemoryLimit()
    {
        if ((int)$GLOBALS['TYPO3_CONF_VARS']['SYS']['setMemoryLimit'] > 16) {
            @ini_set('memory_limit', ((int)$GLOBALS['TYPO3_CONF_VARS']['SYS']['setMemoryLimit'] . 'm'));
        }
        return $this;
    }

    protected function defineTypo3RequestTypes()
    {
        define('TYPO3_REQUESTTYPE_FE', 1);
        define('TYPO3_REQUESTTYPE_BE', 2);
        define('TYPO3_REQUESTTYPE_CLI', 4);
        define('TYPO3_REQUESTTYPE_AJAX', 8);
        define('TYPO3_REQUESTTYPE_INSTALL', 16);
        define('TYPO3_REQUESTTYPE', (TYPO3_MODE == 'FE' ? TYPO3_REQUESTTYPE_FE : 0) | (TYPO3_MODE == 'BE' ? TYPO3_REQUESTTYPE_BE : 0) | (defined('TYPO3_cliMode') && TYPO3_cliMode ? TYPO3_REQUESTTYPE_CLI : 0) | (defined('TYPO3_enterInstallScript') && TYPO3_enterInstallScript ? TYPO3_REQUESTTYPE_INSTALL : 0) | ($GLOBALS['TYPO3_AJAX'] ? TYPO3_REQUESTTYPE_AJAX : 0));
        return $this;
    }

    public function setFinalCachingFrameworkCacheConfiguration()
    {
        $this->getEarlyInstance(\TYPO3\CMS\Core\Cache\CacheManager::class)->setCacheConfigurations($GLOBALS['TYPO3_CONF_VARS']['SYS']['caching']['cacheConfigurations']);
        return $this;
    }

    public function defineLoggingAndExceptionConstants()
    {
        define('TYPO3_DLOG', $GLOBALS['TYPO3_CONF_VARS']['SYS']['enable_DLOG']);
        define('TYPO3_ERROR_DLOG', $GLOBALS['TYPO3_CONF_VARS']['SYS']['enable_errorDLOG']);
        define('TYPO3_EXCEPTION_DLOG', $GLOBALS['TYPO3_CONF_VARS']['SYS']['enable_exceptionDLOG']);
        return $this;
    }

    public function unsetReservedGlobalVariables()
    {
        unset($GLOBALS['PAGES_TYPES']);
        unset($GLOBALS['TCA']);
        unset($GLOBALS['TBE_MODULES']);
        unset($GLOBALS['TBE_STYLES']);
        unset($GLOBALS['BE_USER']);
        // Those set otherwise:
        unset($GLOBALS['TBE_MODULES_EXT']);
        unset($GLOBALS['TCA_DESCR']);
        unset($GLOBALS['LOCAL_LANG']);
        unset($GLOBALS['TYPO3_AJAX']);
        return $this;
    }

    public function initializeTypo3DbGlobal()
    {
        $databaseConnection = GeneralUtility::makeInstance(\TYPO3\CMS\Core\Database\DatabaseConnection::class);
        $databaseConnection->setDatabaseName(TYPO3_db);
        $databaseConnection->setDatabaseUsername(TYPO3_db_username);
        $databaseConnection->setDatabasePassword(TYPO3_db_password);

        $databaseHost = TYPO3_db_host;
        if (isset($GLOBALS['TYPO3_CONF_VARS']['DB']['port'])) {
            $databaseConnection->setDatabasePort($GLOBALS['TYPO3_CONF_VARS']['DB']['port']);
        } elseif (strpos($databaseHost, ':') > 0) {
            // @TODO: Find a way to handle this case in the install tool and drop this
            list($databaseHost, $databasePort) = explode(':', $databaseHost);
            $databaseConnection->setDatabasePort($databasePort);
        }
        if (isset($GLOBALS['TYPO3_CONF_VARS']['DB']['socket'])) {
            $databaseConnection->setDatabaseSocket($GLOBALS['TYPO3_CONF_VARS']['DB']['socket']);
        }
        $databaseConnection->setDatabaseHost($databaseHost);

        $databaseConnection->debugOutput = $GLOBALS['TYPO3_CONF_VARS']['SYS']['sqlDebug'];

        if (
            isset($GLOBALS['TYPO3_CONF_VARS']['SYS']['no_pconnect'])
            && !$GLOBALS['TYPO3_CONF_VARS']['SYS']['no_pconnect']
        ) {
            $databaseConnection->setPersistentDatabaseConnection(true);
        }

        $isDatabaseHostLocalHost = $databaseHost === 'localhost' || $databaseHost === '127.0.0.1' || $databaseHost === '::1';
        if (
            isset($GLOBALS['TYPO3_CONF_VARS']['SYS']['dbClientCompress'])
            && $GLOBALS['TYPO3_CONF_VARS']['SYS']['dbClientCompress']
            && !$isDatabaseHostLocalHost
        ) {
            $databaseConnection->setConnectionCompression(true);
        }

        if (!empty($GLOBALS['TYPO3_CONF_VARS']['SYS']['setDBinit'])) {
            $commandsAfterConnect = GeneralUtility::trimExplode(
                LF,
                str_replace('\' . LF . \'', LF, $GLOBALS['TYPO3_CONF_VARS']['SYS']['setDBinit']),
                true
            );
            $databaseConnection->setInitializeCommandsAfterConnect($commandsAfterConnect);
        }

        $GLOBALS['TYPO3_DB'] = $databaseConnection;
        // $GLOBALS['TYPO3_DB'] needs to be defined first in order to work for DBAL
        $GLOBALS['TYPO3_DB']->initialize();

        return $this;
    }

    public function checkLockedBackendAndRedirectOrDie($forceProceeding = false)
    {
        if ($GLOBALS['TYPO3_CONF_VARS']['BE']['adminOnly'] < 0) {
            throw new \RuntimeException('TYPO3 Backend locked: Backend and Install Tool are locked for maintenance. [BE][adminOnly] is set to "' . (int)$GLOBALS['TYPO3_CONF_VARS']['BE']['adminOnly'] . '".', 1294586847);
        }
        if (@is_file(PATH_typo3conf . 'LOCK_BACKEND') && $forceProceeding === false) {
            $fileContent = GeneralUtility::getUrl(PATH_typo3conf . 'LOCK_BACKEND');
            if ($fileContent) {
                header('Location: ' . $fileContent);
            } else {
                throw new \RuntimeException('TYPO3 Backend locked: Browser backend is locked for maintenance. Remove lock by removing the file "typo3conf/LOCK_BACKEND" or use CLI-scripts.', 1294586848);
            }
            die;
        }
        return $this;
    }

    public function checkBackendIpOrDie()
    {
        if (trim($GLOBALS['TYPO3_CONF_VARS']['BE']['IPmaskList'])) {
            if (!GeneralUtility::cmpIP(GeneralUtility::getIndpEnv('REMOTE_ADDR'), $GLOBALS['TYPO3_CONF_VARS']['BE']['IPmaskList'])) {
                throw new \RuntimeException('TYPO3 Backend access denied: The IP address of your client does not match the list of allowed IP addresses.', 1389265900);
            }
        }
        return $this;
    }

    public function checkSslBackendAndRedirectIfNeeded()
    {
        if ((int)$GLOBALS['TYPO3_CONF_VARS']['BE']['lockSSL']) {
            if (!GeneralUtility::getIndpEnv('TYPO3_SSL')) {
                if ((int)$GLOBALS['TYPO3_CONF_VARS']['BE']['lockSSL'] === 2) {
                    if ((int)$GLOBALS['TYPO3_CONF_VARS']['BE']['lockSSLPort']) {
                        $sslPortSuffix = ':' . (int)$GLOBALS['TYPO3_CONF_VARS']['BE']['lockSSLPort'];
                    } else {
                        $sslPortSuffix = '';
                    }
                    list(, $url) = explode('://', GeneralUtility::getIndpEnv('TYPO3_SITE_URL') . TYPO3_mainDir, 2);
                    list($server, $address) = explode('/', $url, 2);
                    header('Location: https://' . $server . $sslPortSuffix . '/' . $address);
                    die;
                } else {
                    throw new \RuntimeException('TYPO3 Backend not accessed via SSL: TYPO3 Backend is configured to only be accessible through SSL. Change the URL in your browser and try again.', 1389265726);
                }
            }
        }
        return $this;
    }

    public function loadCachedTca()
    {
        $cacheIdentifier = 'tca_fe_' . sha1((TYPO3_version . PATH_site . 'tca_fe'));
        $codeCache = $this->getEarlyInstance(\TYPO3\CMS\Core\Cache\CacheManager::class)->getCache('cache_core');
        if ($codeCache->has($cacheIdentifier)) {
            // substr is necessary, because the php frontend wraps php code around the cache value
            $GLOBALS['TCA'] = unserialize(substr($codeCache->get($cacheIdentifier), 6, -2));
        } else {
            $this->loadExtensionTables(true);
            $codeCache->set($cacheIdentifier, serialize($GLOBALS['TCA']));
        }
        return $this;
    }

    public function loadExtensionTables($allowCaching = true)
    {
        ExtensionManagementUtility::loadBaseTca($allowCaching);
        ExtensionManagementUtility::loadExtTables($allowCaching);
        $this->executeExtTablesAdditionalFile();
        $this->runExtTablesPostProcessingHooks();
        return $this;
    }

    protected function executeExtTablesAdditionalFile()
    {
        // It is discouraged to use those global variables directly, but we
        // can not prohibit this without breaking backwards compatibility
        global $T3_SERVICES, $T3_VAR, $TYPO3_CONF_VARS;
        global $TBE_MODULES, $TBE_MODULES_EXT, $TCA;
        global $PAGES_TYPES, $TBE_STYLES;
        global $_EXTKEY;
        // Load additional ext tables script if the file exists
        $extTablesFile = PATH_typo3conf . TYPO3_extTableDef_script;
        if (file_exists($extTablesFile) && is_file($extTablesFile)) {
            GeneralUtility::deprecationLog(
                'Using typo3conf/' . TYPO3_extTableDef_script . ' is deprecated and will be removed with TYPO3 CMS 8. Please move your TCA overrides'
                . ' to Configuration/TCA/Overrides of your project specific extension, or slot the signal "tcaIsBeingBuilt" for further processing.'
            );
            include $extTablesFile;
        }
    }

    protected function runExtTablesPostProcessingHooks()
    {
        if (is_array($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['GLOBAL']['extTablesInclusion-PostProcessing'])) {
            foreach ($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['GLOBAL']['extTablesInclusion-PostProcessing'] as $classReference) {
                $hookObject = GeneralUtility::getUserObj($classReference);
                if (!$hookObject instanceof \TYPO3\CMS\Core\Database\TableConfigurationPostProcessingHookInterface) {
                    throw new \UnexpectedValueException(
                        '$hookObject "' . $classReference . '" must implement interface TYPO3\\CMS\\Core\\Database\\TableConfigurationPostProcessingHookInterface',
                        1320585902
                    );
                }
                $hookObject->processData();
            }
        }
    }

    public function initializeSpriteManager()
    {
        // This method is deprecated since TYPO3 CMS 7, will be removed with TYPO3 CMS 8
        // This method does not log a deprecation message, because it is used only in the request handlers
        // and would break icons from IconUtility::getSpriteIcon() if we remove it yet.
        \TYPO3\CMS\Backend\Sprite\SpriteManager::initialize();
        return $this;
    }

    public function initializeBackendRouter()
    {
        $packageManager = $this->getEarlyInstance(\TYPO3\CMS\Core\Package\PackageManager::class);

        // See if the Routes.php from all active packages have been built together already
        $cacheIdentifier = 'BackendRoutesFromPackages_' . sha1((TYPO3_version . PATH_site . 'BackendRoutesFromPackages'));

        $codeCache = $this->getEarlyInstance(\TYPO3\CMS\Core\Cache\CacheManager::class)->getCache('cache_core');
        $routesFromPackages = array();
        if ($codeCache->has($cacheIdentifier)) {
            // substr is necessary, because the php frontend wraps php code around the cache value
            $routesFromPackages = unserialize(substr($codeCache->get($cacheIdentifier), 6, -2));
        } else {
            // Loop over all packages and check for a Configuration/Backend/Routes.php file
            $packages = $packageManager->getActivePackages();
            foreach ($packages as $package) {
                $routesFileNameForPackage = $package->getPackagePath() . 'Configuration/Backend/Routes.php';
                if (file_exists($routesFileNameForPackage)) {
                    $definedRoutesInPackage = require $routesFileNameForPackage;
                    if (is_array($definedRoutesInPackage)) {
                        $routesFromPackages += $definedRoutesInPackage;
                    }
                }
                $routesFileNameForPackage = $package->getPackagePath() . 'Configuration/Backend/AjaxRoutes.php';
                if (file_exists($routesFileNameForPackage)) {
                    $definedRoutesInPackage = require $routesFileNameForPackage;
                    if (is_array($definedRoutesInPackage)) {
                        foreach ($definedRoutesInPackage as $routeIdentifier => $routeOptions) {
                            // prefix the route with "ajax_" as "namespace"
                            $routeOptions['path'] = '/ajax' . $routeOptions['path'];
                            $routesFromPackages['ajax_' . $routeIdentifier] = $routeOptions;
                            $routesFromPackages['ajax_' . $routeIdentifier]['ajax'] = true;
                        }
                    }
                }
            }
            // Store the data from all packages in the cache
            $codeCache->set($cacheIdentifier, serialize($routesFromPackages));
        }

        // Build Route objects from the data
        $router = GeneralUtility::makeInstance(\TYPO3\CMS\Backend\Routing\Router::class);
        foreach ($routesFromPackages as $name => $options) {
            $path = $options['path'];
            unset($options['path']);
            $route = GeneralUtility::makeInstance(\TYPO3\CMS\Backend\Routing\Route::class, $path, $options);
            $router->addRoute($name, $route);
        }
        return $this;
    }

    public function initializeBackendUser()
    {
        $backendUser = GeneralUtility::makeInstance(\TYPO3\CMS\Core\Authentication\BackendUserAuthentication::class);
        $backendUser->warningEmail = $GLOBALS['TYPO3_CONF_VARS']['BE']['warning_email_addr'];
        $backendUser->lockIP = $GLOBALS['TYPO3_CONF_VARS']['BE']['lockIP'];
        $backendUser->auth_timeout_field = (int)$GLOBALS['TYPO3_CONF_VARS']['BE']['sessionTimeout'];
        if (TYPO3_REQUESTTYPE & TYPO3_REQUESTTYPE_CLI) {
            $backendUser->dontSetCookie = true;
        }
        // The global must be available very early, because methods below
        // might trigger code which relies on it. See: #45625
        $GLOBALS['BE_USER'] = $backendUser;
        $backendUser->start();
        return $this;
    }

    public function initializeBackendAuthentication($proceedIfNoUserIsLoggedIn = false)
    {
        $GLOBALS['BE_USER']->backendCheckLogin($proceedIfNoUserIsLoggedIn);
        return $this;
    }

    public function initializeLanguageObject()
    {
        $GLOBALS['LANG'] = GeneralUtility::makeInstance(\TYPO3\CMS\Lang\LanguageService::class);
        $GLOBALS['LANG']->init($GLOBALS['BE_USER']->uc['lang']);
        return $this;
    }

    public function endOutputBufferingAndCleanPreviousOutput()
    {
        ob_clean();
        return $this;
    }

    public function initializeOutputCompression()
    {
        if (extension_loaded('zlib') && $GLOBALS['TYPO3_CONF_VARS']['BE']['compressionLevel']) {
            if (MathUtility::canBeInterpretedAsInteger($GLOBALS['TYPO3_CONF_VARS']['BE']['compressionLevel'])) {
                @ini_set('zlib.output_compression_level', $GLOBALS['TYPO3_CONF_VARS']['BE']['compressionLevel']);
            }
            ob_start('ob_gzhandler');
        }
        return $this;
    }

    public function sendHttpHeaders()
    {
        if (!empty($GLOBALS['TYPO3_CONF_VARS']['BE']['HTTP']['Response']['Headers']) && is_array($GLOBALS['TYPO3_CONF_VARS']['BE']['HTTP']['Response']['Headers'])) {
            foreach ($GLOBALS['TYPO3_CONF_VARS']['BE']['HTTP']['Response']['Headers'] as $header) {
                header($header);
            }
        }
        return $this;
    }

    public function shutdown()
    {
        $this->sendResponse();
        return $this;
    }

    public function initializeBackendTemplate()
    {
        $GLOBALS['TBE_TEMPLATE'] = GeneralUtility::makeInstance(\TYPO3\CMS\Backend\Template\DocumentTemplate::class);
        return $this;
    }
}