Bootstrap.php

Go to the documentation of this file.

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

use TYPO3\CMS\Core\Utility;

class Bootstrap {

    static protected $instance = NULL;

    protected $requestId;

    protected $applicationContext;

    protected $earlyInstances = array();

    protected $installToolPath;

    protected $activeExceptionHandlerClassName;

    protected $activeErrorHandlerClassName;

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

    protected function __clone() {

    }

    static public function getInstance() {
        if (is_null(static::$instance)) {
            require_once(__DIR__ . '/../Exception.php');
            require_once(__DIR__ . '/ApplicationContext.php');
            $applicationContext = getenv('TYPO3_CONTEXT') ?: (getenv('REDIRECT_TYPO3_CONTEXT') ?: 'Production');
            self::$instance = new static($applicationContext);
            // Establish an alias for Flow/Package interoperability
            class_alias(get_class(static::$instance), 'TYPO3\\Flow\\Core\\Bootstrap');
        }
        return static::$instance;
    }

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

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

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

    public function baseSetup($relativePathPart = '') {
        $composerClassLoader = $this->initializeComposerClassLoader();
        $this->setEarlyInstance('Composer\\Autoload\\ClassLoader', $composerClassLoader);
        SystemEnvironmentBuilder::run($relativePathPart);
        Utility\GeneralUtility::presetApplicationContext($this->applicationContext);
        return $this;
    }

    protected function initializeComposerClassLoader() {
        $respectComposerPackagesForClassLoading = getenv('TYPO3_COMPOSER_AUTOLOAD') ?: (getenv('REDIRECT_TYPO3_COMPOSER_AUTOLOAD') ?: NULL);
        $possiblePaths = array();
        if (!empty($respectComposerPackagesForClassLoading)) {
            $possiblePaths['distribution'] = __DIR__ . '/../../../../../../Packages/Libraries/autoload.php';
        }
        $possiblePaths['fallback'] = __DIR__ . '/../../../../contrib/vendor/autoload.php';
        foreach ($possiblePaths as $possiblePath) {
            if (file_exists($possiblePath)) {
                return include $possiblePath;
            }
        }
        throw new \LogicException('No class loading information found for TYPO3 CMS. Please make sure you installed TYPO3 with composer or the typo3/contrib/vendor folder is present.', 1425153762);
    }

    public function redirectToInstallerIfEssentialConfigurationDoesNotExist($pathUpToDocumentRoot = '') {
        $configurationManager = new \TYPO3\CMS\Core\Configuration\ConfigurationManager;
        $this->setEarlyInstance('TYPO3\\CMS\\Core\\Configuration\\ConfigurationManager', $configurationManager);
        if (!file_exists($configurationManager->getLocalConfigurationFileLocation()) || !file_exists(PATH_typo3conf . 'PackageStates.php')) {
            define('TYPO3_enterInstallScript', '1');
            $this->defineTypo3RequestTypes();
            require_once __DIR__ . '/../Utility/HttpUtility.php';
            Utility\HttpUtility::redirect($pathUpToDocumentRoot . 'typo3/sysext/install/Start/Install.php');
        }
        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') {
        $this->initializeClassLoader()
            ->populateLocalConfiguration();
        if (!$allowCaching) {
            $this->disableCoreAndClassesCache();
        }
        $this->initializeCachingFramework()
            ->initializeClassLoaderCaches()
            ->initializePackageManagement($packageManagerClassName)
            ->initializeRuntimeActivatedPackagesFromConfiguration();

        $this->defineDatabaseConstants()
            ->defineUserAgentConstant()
            ->registerExtDirectComponents()
            ->transferDeprecatedCurlSettings()
            ->setCacheHashOptions()
            ->setDefaultTimezone()
            ->initializeL10nLocales()
            ->convertPageNotFoundHandlingToBoolean()
            ->registerGlobalDebugFunctions()
            // SwiftMailerAdapter is
            // @deprecated since 6.1, will be removed two versions later - will be removed together with \TYPO3\CMS\Core\Utility\MailUtility::mail()
            ->registerSwiftMailer()
            ->configureExceptionHandling()
            ->initializeExceptionHandling()
            ->setMemoryLimit()
            ->defineTypo3RequestTypes();
        return $this;
    }

    public function initializeClassLoader() {
        $classLoader = new ClassLoader($this->applicationContext);
        $this->setEarlyInstance('TYPO3\\CMS\\Core\\Core\\ClassLoader', $classLoader);
        $classLoader->setRuntimeClassLoadingInformationFromAutoloadRegistry((array) include __DIR__ . '/../../ext_autoload.php');
        $classAliasMap = new ClassAliasMap();
        $classAliasMap->injectClassLoader($classLoader);
        $classAliasMap->injectComposerClassLoader($this->getEarlyInstance('Composer\\Autoload\\ClassLoader'));
        $this->setEarlyInstance('TYPO3\\CMS\\Core\\Core\\ClassAliasMap', $classAliasMap);
        $classLoader->injectClassAliasMap($classAliasMap);
        spl_autoload_register(array($classLoader, 'loadClass'), TRUE, FALSE);
        return $this;
    }

    public function unregisterClassLoader() {
        $currentClassLoader = $this->getEarlyInstance('TYPO3\\CMS\\Core\\Core\\ClassLoader');
        spl_autoload_unregister(array($currentClassLoader, 'loadClass'));
        return $this;
    }

    public function initializeClassLoaderCaches() {
        $classLoader = $this->getEarlyInstance('TYPO3\\CMS\\Core\\Core\\ClassLoader');
        $classLoader->injectCoreCache($this->getEarlyInstance('TYPO3\\CMS\\Core\\Cache\\CacheManager')->getCache('cache_core'));
        $classLoader->injectClassesCache($this->getEarlyInstance('TYPO3\\CMS\\Core\\Cache\\CacheManager')->getCache('cache_classes'));
        return $this;
    }

    public function initializePackageManagement($packageManagerClassName) {
        $packageManager = new $packageManagerClassName();
        $this->setEarlyInstance('TYPO3\\Flow\\Package\\PackageManager', $packageManager);
        Utility\ExtensionManagementUtility::setPackageManager($packageManager);
        $packageManager->injectClassLoader($this->getEarlyInstance('TYPO3\\CMS\\Core\\Core\\ClassLoader'));
        $packageManager->injectCoreCache($this->getEarlyInstance('TYPO3\\CMS\\Core\\Cache\\CacheManager')->getCache('cache_core'));
        $packageManager->injectDependencyResolver(Utility\GeneralUtility::makeInstance('TYPO3\\CMS\\Core\\Package\\DependencyResolver'));
        $packageManager->initialize($this);
        Utility\GeneralUtility::setSingletonInstance('TYPO3\\CMS\\Core\\Package\\PackageManager', $packageManager);
        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\\Flow\\Package\\PackageManager');
            foreach ($GLOBALS['TYPO3_CONF_VARS']['EXT']['runtimeActivatedPackages'] as $runtimeAddedPackageKey) {
                $packageManager->activatePackageDuringRuntime($runtimeAddedPackageKey);
            }
        }
        return $this;
    }

    public function loadTypo3LoadedExtAndExtLocalconf($allowCaching = TRUE) {
        $this->loadAdditionalConfigurationFromExtensions($allowCaching);
        return $this;
    }

    public function applyAdditionalConfigurationSettings() {
        $this->initializeExceptionHandling()
            ->setFinalCachingFrameworkCacheConfiguration()
            ->defineLoggingAndExceptionConstants()
            ->unsetReservedGlobalVariables();
        return $this;
    }

    public function checkValidBrowserOrDie() {
        // Checks for proper browser
        if (empty($GLOBALS['CLIENT']['BROWSER'])) {
            throw new \RuntimeException('Browser Error: Your browser version looks incompatible with this TYPO3 version!', 1294587023);
        }
        return $this;
    }

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

    public function disableCoreAndClassesCache() {
        $GLOBALS['TYPO3_CONF_VARS']['SYS']['caching']['cacheConfigurations']['cache_core']['backend']
            = 'TYPO3\\CMS\\Core\\Cache\\Backend\\NullBackend';
        unset($GLOBALS['TYPO3_CONF_VARS']['SYS']['caching']['cacheConfigurations']['cache_core']['options']);
        $GLOBALS['TYPO3_CONF_VARS']['SYS']['caching']['cacheConfigurations']['cache_classes']['backend']
            = 'TYPO3\\CMS\\Core\\Cache\\Backend\\TransientMemoryBackend';
        unset($GLOBALS['TYPO3_CONF_VARS']['SYS']['caching']['cacheConfigurations']['cache_classes']['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']);
        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') {
            Utility\ExtensionManagementUtility::registerExtDirectComponent('TYPO3.Components.PageTree.DataProvider', 'TYPO3\\CMS\\Backend\\Tree\\Pagetree\\ExtdirectTreeDataProvider', 'web', 'user,group');
            Utility\ExtensionManagementUtility::registerExtDirectComponent('TYPO3.Components.PageTree.Commands', 'TYPO3\\CMS\\Backend\\Tree\\Pagetree\\ExtdirectTreeCommands', 'web', 'user,group');
            Utility\ExtensionManagementUtility::registerExtDirectComponent('TYPO3.Components.PageTree.ContextMenuDataProvider', 'TYPO3\\CMS\\Backend\\ContextMenu\\Pagetree\\Extdirect\\ContextMenuConfiguration', 'web', 'user,group');
            Utility\ExtensionManagementUtility::registerExtDirectComponent('TYPO3.LiveSearchActions.ExtDirect', 'TYPO3\\CMS\\Backend\\Search\\LiveSearch\\ExtDirect\\LiveSearchDataProvider', 'web_list', 'user,group');
            Utility\ExtensionManagementUtility::registerExtDirectComponent('TYPO3.BackendUserSettings.ExtDirect', 'TYPO3\\CMS\\Backend\\User\\ExtDirect\\BackendUserSettingsDataProvider');
            if (Utility\ExtensionManagementUtility::isLoaded('context_help')) {
                Utility\ExtensionManagementUtility::registerExtDirectComponent('TYPO3.CSH.ExtDirect', 'TYPO3\\CMS\\ContextHelp\\ExtDirect\\ContextHelpDataProvider');
            }
            Utility\ExtensionManagementUtility::registerExtDirectComponent('TYPO3.ExtDirectStateProvider.ExtDirect', 'TYPO3\\CMS\\Backend\\InterfaceState\\ExtDirect\\DataProvider');
            Utility\ExtensionManagementUtility::registerExtDirectComponent(
                'TYPO3.Components.DragAndDrop.CommandController',
                Utility\ExtensionManagementUtility::extPath('backend') . 'Classes/View/PageLayout/Extdirect/ExtdirectPageCommands.php:TYPO3\\CMS\\Backend\\View\\PageLayout\\ExtDirect\\ExtdirectPageCommands', 'web', 'user,group'
            );
        }
        return $this;
    }

    public function initializeCachingFramework() {
        $this->setEarlyInstance('TYPO3\\CMS\\Core\\Cache\\CacheManager', \TYPO3\CMS\Core\Cache\Cache::initializeCachingFramework());
        // @deprecated since 6.2 will be removed in two versions
        $GLOBALS['typo3CacheManager'] = new \TYPO3\CMS\Core\Compatibility\GlobalObjectDeprecationDecorator('TYPO3\\CMS\\Core\\Cache\\CacheManager');
        $GLOBALS['typo3CacheFactory'] = new \TYPO3\CMS\Core\Compatibility\GlobalObjectDeprecationDecorator('TYPO3\\CMS\\Core\\Cache\\CacheFactory');
        return $this;
    }

    protected function transferDeprecatedCurlSettings() {
        if (!empty($GLOBALS['TYPO3_CONF_VARS']['SYS']['curlProxyServer']) && empty($GLOBALS['TYPO3_CONF_VARS']['HTTP']['proxy_host'])) {
            $curlProxy = rtrim(preg_replace('#^https?://#', '', $GLOBALS['TYPO3_CONF_VARS']['SYS']['curlProxyServer']), '/');
            $proxyParts = Utility\GeneralUtility::revExplode(':', $curlProxy, 2);
            $GLOBALS['TYPO3_CONF_VARS']['HTTP']['proxy_host'] = $proxyParts[0];
            $GLOBALS['TYPO3_CONF_VARS']['HTTP']['proxy_port'] = $proxyParts[1];
        }
        if (!empty($GLOBALS['TYPO3_CONF_VARS']['SYS']['curlProxyUserPass']) && empty($GLOBALS['TYPO3_CONF_VARS']['HTTP']['proxy_user'])) {
            $userPassParts = explode(':', $GLOBALS['TYPO3_CONF_VARS']['SYS']['curlProxyUserPass'], 2);
            $GLOBALS['TYPO3_CONF_VARS']['HTTP']['proxy_user'] = $userPassParts[0];
            $GLOBALS['TYPO3_CONF_VARS']['HTTP']['proxy_password'] = $userPassParts[1];
        }
        if ($GLOBALS['TYPO3_CONF_VARS']['SYS']['curlUse']) {
            $GLOBALS['TYPO3_CONF_VARS']['HTTP']['adapter'] = 'curl';
        }
        return $this;
    }

    protected function setCacheHashOptions() {
        $GLOBALS['TYPO3_CONF_VARS']['FE']['cacheHash'] = array(
            'cachedParametersWhiteList' => Utility\GeneralUtility::trimExplode(',', $GLOBALS['TYPO3_CONF_VARS']['FE']['cHashOnlyForParameters'], TRUE),
            'excludedParameters' => Utility\GeneralUtility::trimExplode(',', $GLOBALS['TYPO3_CONF_VARS']['FE']['cHashExcludedParameters'], TRUE),
            'requireCacheHashPresenceParameters' => Utility\GeneralUtility::trimExplode(',', $GLOBALS['TYPO3_CONF_VARS']['FE']['cHashRequiredParameters'], TRUE),
            'includePageId' => $GLOBALS['TYPO3_CONF_VARS']['FE']['cHashIncludePageId']
        );
        if (trim($GLOBALS['TYPO3_CONF_VARS']['FE']['cHashExcludedParametersIfEmpty']) === '*') {
            $GLOBALS['TYPO3_CONF_VARS']['FE']['cacheHash']['excludeAllEmptyParameters'] = TRUE;
        } else {
            $GLOBALS['TYPO3_CONF_VARS']['FE']['cacheHash']['excludedParametersIfEmpty'] = Utility\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 registerGlobalDebugFunctions() {
        require_once('GlobalDebugFunctions.php');
        return $this;
    }

    protected function registerSwiftMailer() {
        $GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/utility/class.t3lib_utility_mail.php']['substituteMailDelivery'][] =
            'TYPO3\\CMS\\Core\\Mail\\SwiftMailerAdapter';
        return $this;
    }

    protected function configureExceptionHandling() {
        $GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['errors']['exceptionHandler'] = $GLOBALS['TYPO3_CONF_VARS']['SYS']['productionExceptionHandler'];
        $GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['errors']['exceptionalErrors'] = $GLOBALS['TYPO3_CONF_VARS']['SYS']['exceptionalErrors'];
        $doesIpMatch = Utility\GeneralUtility::cmpIP(Utility\GeneralUtility::getIndpEnv('REMOTE_ADDR'), $GLOBALS['TYPO3_CONF_VARS']['SYS']['devIPmask']);
        $displayErrors = (int)$GLOBALS['TYPO3_CONF_VARS']['SYS']['displayErrors'];
        // Turn error logging on/off.
        if ($displayErrors !== -1) {
            // Special value "2" enables this feature only if $GLOBALS['TYPO3_CONF_VARS'][SYS][devIPmask] matches
            if ($displayErrors === 2) {
                $displayErrors = (int)$doesIpMatch;
            }
            if ($displayErrors === 0) {
                $GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['errors']['exceptionalErrors'] = 0;
            }
            if ($displayErrors === 1) {
                $GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['errors']['exceptionHandler'] = $GLOBALS['TYPO3_CONF_VARS']['SYS']['debugExceptionHandler'];
                define('TYPO3_ERRORHANDLER_MODE', 'debug');
            }
            @ini_set('display_errors', $displayErrors);
        } elseif ($doesIpMatch) {
            // With displayErrors = -1 (default), turn on debugging if devIPmask matches:
            $GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['errors']['exceptionHandler'] = $GLOBALS['TYPO3_CONF_VARS']['SYS']['debugExceptionHandler'];
        }
        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;
    }

    protected function loadAdditionalConfigurationFromExtensions($allowCaching = TRUE) {
        Utility\ExtensionManagementUtility::loadExtLocalconf($allowCaching);
        return $this;
    }

    protected function initializeExceptionHandling() {
        if (!empty($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['errors']['exceptionHandler'])) {
            if (!empty($GLOBALS['TYPO3_CONF_VARS']['SYS']['errorHandler'])) {
                if ($GLOBALS['TYPO3_CONF_VARS']['SYS']['errorHandler'] !== $this->activeErrorHandlerClassName) {
                    $this->activeErrorHandlerClassName = $GLOBALS['TYPO3_CONF_VARS']['SYS']['errorHandler'];
                    // Register an error handler for the given errorHandlerErrors
                    $errorHandler = Utility\GeneralUtility::makeInstance($this->activeErrorHandlerClassName, $GLOBALS['TYPO3_CONF_VARS']['SYS']['errorHandlerErrors']);
                    // Set errors which will be converted in an exception
                    $errorHandler->setExceptionalErrors($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['errors']['exceptionalErrors']);
                }
            } elseif (!empty($this->activeErrorHandlerClassName)) {
                // Restore error handler in case extensions have unset the configuration in ext_localconf.php
                restore_error_handler();
            }
            if ($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['errors']['exceptionHandler'] !== $this->activeExceptionHandlerClassName) {
                $this->activeExceptionHandlerClassName = $GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['errors']['exceptionHandler'];
                // Registering the exception handler is done in the constructor
                Utility\GeneralUtility::makeInstance($this->activeExceptionHandlerClassName);
            }
        } elseif (!empty($this->activeExceptionHandlerClassName)) {
            // Restore exception handler in case extensions have unset the configuration in ext_localconf.php
            restore_exception_handler();
        }
        return $this;
    }

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

    protected 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;
    }

    protected function unsetReservedGlobalVariables() {
        unset($GLOBALS['PAGES_TYPES']);
        unset($GLOBALS['TCA']);
        unset($GLOBALS['TBE_MODULES']);
        unset($GLOBALS['TBE_STYLES']);
        unset($GLOBALS['FILEICONS']);
        // Those set in init.php:
        unset($GLOBALS['WEBMOUNTS']);
        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 = Utility\GeneralUtility::makeInstance('TYPO3\\CMS\\Core\\Database\\DatabaseConnection');
        $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 = \TYPO3\CMS\Core\Utility\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() {
        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'))) {
            if (TYPO3_PROCEED_IF_NO_USER === 2) {

            } else {
                $fileContent = Utility\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 (!Utility\GeneralUtility::cmpIP(Utility\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 ((int)$GLOBALS['TYPO3_CONF_VARS']['BE']['lockSSLPort']) {
                $sslPortSuffix = ':' . (int)$GLOBALS['TYPO3_CONF_VARS']['BE']['lockSSLPort'];
            } else {
                $sslPortSuffix = '';
            }
            if ((int)$GLOBALS['TYPO3_CONF_VARS']['BE']['lockSSL'] === 3) {
                $requestStr = substr(Utility\GeneralUtility::getIndpEnv('TYPO3_REQUEST_SCRIPT'), strlen(Utility\GeneralUtility::getIndpEnv('TYPO3_SITE_URL') . TYPO3_mainDir));
                if ($requestStr === 'index.php' && !Utility\GeneralUtility::getIndpEnv('TYPO3_SSL')) {
                    list(, $url) = explode('://', Utility\GeneralUtility::getIndpEnv('TYPO3_REQUEST_URL'), 2);
                    list($server, $address) = explode('/', $url, 2);
                    header('Location: https://' . $server . $sslPortSuffix . '/' . $address);
                    die;
                }
            } elseif (!Utility\GeneralUtility::getIndpEnv('TYPO3_SSL')) {
                if ((int)$GLOBALS['TYPO3_CONF_VARS']['BE']['lockSSL'] === 2) {
                    list(, $url) = explode('://', Utility\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')->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) {
        Utility\ExtensionManagementUtility::loadBaseTca($allowCaching);
        Utility\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, $FILEICONS;
        global $_EXTKEY;
        // Load additional ext tables script if the file exists
        $extTablesFile = PATH_typo3conf . TYPO3_extTableDef_script;
        if (file_exists($extTablesFile) && is_file($extTablesFile)) {
            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 = Utility\GeneralUtility::getUserObj($classReference);
                if (!$hookObject instanceof \TYPO3\CMS\Core\Database\TableConfigurationPostProcessingHookInterface) {
                    throw new \UnexpectedValueException('$hookObject must implement interface TYPO3\\CMS\\Core\\Database\\TableConfigurationPostProcessingHookInterface', 1320585902);
                }
                $hookObject->processData();
            }
        }
    }

    public function initializeSpriteManager() {
        \TYPO3\CMS\Backend\Sprite\SpriteManager::initialize();
        return $this;
    }

    public function initializeBackendUser() {
        $backendUser = Utility\GeneralUtility::makeInstance('TYPO3\\CMS\\Core\\Authentication\\BackendUserAuthentication');
        $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'];
        $backendUser->OS = TYPO3_OS;
        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() {
        $GLOBALS['BE_USER']->checkCLIuser();
        $GLOBALS['BE_USER']->backendCheckLogin();
        return $this;
    }

    public function initializeBackendUserMounts() {
        // Includes deleted mount pages as well! @TODO: Figure out why ...
        $GLOBALS['WEBMOUNTS'] = $GLOBALS['BE_USER']->returnWebmounts();
        return $this;
    }

    public function initializeLanguageObject() {
        $GLOBALS['LANG'] = Utility\GeneralUtility::makeInstance('TYPO3\CMS\Lang\LanguageService');
        $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 (Utility\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() {
        return $this;
    }

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