408 lines
17 KiB
PHP
408 lines
17 KiB
PHP
<?php
|
|
|
|
declare(strict_types=1);
|
|
|
|
/*
|
|
* 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!
|
|
*/
|
|
|
|
namespace TYPO3\CMS\Core\Core;
|
|
|
|
use Composer\Autoload\ClassLoader;
|
|
use Composer\InstalledVersions;
|
|
use Psr\Container\ContainerInterface;
|
|
use Psr\EventDispatcher\EventDispatcherInterface;
|
|
use Psr\Http\Message\ServerRequestInterface;
|
|
use TYPO3\CMS\Core\Authentication\BackendUserAuthentication;
|
|
use TYPO3\CMS\Core\Cache\Backend\BackendInterface;
|
|
use TYPO3\CMS\Core\Cache\Backend\NullBackend;
|
|
use TYPO3\CMS\Core\Cache\Backend\Typo3DatabaseBackend;
|
|
use TYPO3\CMS\Core\Cache\Exception\InvalidBackendException;
|
|
use TYPO3\CMS\Core\Cache\Exception\InvalidCacheException;
|
|
use TYPO3\CMS\Core\Cache\Frontend\FrontendInterface;
|
|
use TYPO3\CMS\Core\Cache\Frontend\PhpFrontend;
|
|
use TYPO3\CMS\Core\Cache\Frontend\VariableFrontend;
|
|
use TYPO3\CMS\Core\Configuration\ConfigurationManager;
|
|
use TYPO3\CMS\Core\Configuration\Extension\ExtLocalconfFactory;
|
|
use TYPO3\CMS\Core\Configuration\Tca\TcaFactory;
|
|
use TYPO3\CMS\Core\Core\Event\BootCompletedEvent;
|
|
use TYPO3\CMS\Core\DependencyInjection\Cache\ContainerBackend;
|
|
use TYPO3\CMS\Core\DependencyInjection\ContainerBuilder;
|
|
use TYPO3\CMS\Core\Http\NormalizedParams;
|
|
use TYPO3\CMS\Core\Log\LogManager;
|
|
use TYPO3\CMS\Core\Package\Cache\ComposerPackageArtifact;
|
|
use TYPO3\CMS\Core\Package\Cache\PackageCacheInterface;
|
|
use TYPO3\CMS\Core\Package\Cache\PackageStatesPackageCache;
|
|
use TYPO3\CMS\Core\Package\FailsafePackageManager;
|
|
use TYPO3\CMS\Core\Package\PackageManager;
|
|
use TYPO3\CMS\Core\Schema\TcaSchemaFactory;
|
|
use TYPO3\CMS\Core\Service\DependencyOrderingService;
|
|
use TYPO3\CMS\Core\Utility\ExtensionManagementUtility;
|
|
use TYPO3\CMS\Core\Utility\GeneralUtility;
|
|
|
|
/**
|
|
* This class encapsulates bootstrap related methods.
|
|
* It is required directly as the very first thing in entry scripts and
|
|
* used to define all base things like constants and paths and so on.
|
|
*
|
|
* Most methods in this class have dependencies to each other. They can
|
|
* not be called in arbitrary order. The methods are ordered top down, so
|
|
* a method at the beginning has lower dependencies than a method further
|
|
* down. Do not fiddle with the load order in own scripts except you know
|
|
* exactly what you are doing!
|
|
*/
|
|
readonly class Bootstrap
|
|
{
|
|
/**
|
|
* Bootstrap TYPO3 and return a Container that may be used
|
|
* to initialize an Application class.
|
|
*
|
|
* @param ClassLoader $classLoader an instance of the class loader
|
|
* @param bool $failsafe true if no caching and a failsafe package manager should be used
|
|
*/
|
|
public static function init(
|
|
ClassLoader $classLoader,
|
|
bool $failsafe = false
|
|
): ContainerInterface {
|
|
$requestId = new RequestId();
|
|
|
|
static::initializeClassLoader($classLoader);
|
|
if (!Environment::isComposerMode() && ClassLoadingInformation::isClassLoadingInformationAvailable()) {
|
|
ClassLoadingInformation::registerClassLoadingInformation();
|
|
}
|
|
|
|
// We need an early instance of the configuration manager.
|
|
// Since makeInstance relies on the object configuration, we create it here with new instead.
|
|
$configurationManager = new ConfigurationManager();
|
|
if (!static::checkIfEssentialConfigurationExists($configurationManager)) {
|
|
$failsafe = true;
|
|
}
|
|
// TYPO3_CONF_VARS is now loaded by settings.php and additional.php
|
|
$configurationManager->exportConfiguration();
|
|
|
|
$logManager = new LogManager($requestId);
|
|
// LogManager is used by the core ErrorHandler (using GeneralUtility::makeInstance),
|
|
// therefore we have to push the LogManager to GeneralUtility, in case there
|
|
// happen errors before we call GeneralUtility::setContainer().
|
|
GeneralUtility::setSingletonInstance(LogManager::class, $logManager);
|
|
|
|
static::initializeErrorHandling();
|
|
|
|
$disableCaching = $failsafe ? true : false;
|
|
/** @var PhpFrontend $coreCache */
|
|
$coreCache = static::createCache('core', $disableCaching);
|
|
$packageCache = static::createPackageCache($coreCache);
|
|
$packageManager = static::createPackageManager(
|
|
$failsafe ? FailsafePackageManager::class : PackageManager::class,
|
|
$packageCache
|
|
);
|
|
|
|
static::setDefaultTimezone();
|
|
static::setMemoryLimit();
|
|
|
|
$dependencyInjectionContainerCache = static::createCache('di');
|
|
|
|
$bootState = new \stdClass();
|
|
$bootState->complete = false;
|
|
$bootState->cacheDisabled = $disableCaching;
|
|
|
|
$builder = new ContainerBuilder([
|
|
ClassLoader::class => $classLoader,
|
|
ApplicationContext::class => Environment::getContext(),
|
|
ConfigurationManager::class => $configurationManager,
|
|
LogManager::class => $logManager,
|
|
RequestId::class => $requestId,
|
|
'cache.di' => $dependencyInjectionContainerCache,
|
|
'cache.core' => $coreCache,
|
|
PackageManager::class => $packageManager,
|
|
|
|
// @internal
|
|
'boot.state' => $bootState,
|
|
]);
|
|
|
|
$container = $builder->createDependencyInjectionContainer($packageManager, $dependencyInjectionContainerCache, $failsafe);
|
|
|
|
// Push the container to GeneralUtility as we want to make sure its
|
|
// makeInstance() method creates classes using the container from now on.
|
|
GeneralUtility::setContainer($container);
|
|
|
|
// Reset LogManager singleton instance in order for GeneralUtility::makeInstance()
|
|
// to proxy LogManager retrieval to ContainerInterface->get() from now on.
|
|
GeneralUtility::removeSingletonInstance(LogManager::class, $logManager);
|
|
|
|
// Push PackageManager instance to ExtensionManagementUtility
|
|
ExtensionManagementUtility::setPackageManager($packageManager);
|
|
|
|
if ($failsafe) {
|
|
$bootState->complete = true;
|
|
return $container;
|
|
}
|
|
|
|
// The encryption key is part of the system configuration and must be set up
|
|
// before any extension code is executed.
|
|
static::checkEncryptionKey();
|
|
|
|
$eventDispatcher = $container->get(EventDispatcherInterface::class);
|
|
$container->get(ExtLocalconfFactory::class)->load();
|
|
$tca = $container->get(TcaFactory::class)->get();
|
|
$bootState->complete = true;
|
|
// $GLOBALS['TCA'] is only published once the schema is built, so consumers
|
|
// triggered by the schema factory can not work with a half-initialized state.
|
|
$container->get(TcaSchemaFactory::class)->load($tca);
|
|
$GLOBALS['TCA'] = $tca;
|
|
$eventDispatcher->dispatch(new BootCompletedEvent(true));
|
|
|
|
return $container;
|
|
}
|
|
|
|
/**
|
|
* Sets the class loader to the bootstrap
|
|
*
|
|
* @param ClassLoader $classLoader an instance of the class loader
|
|
* @internal This is not a public API method, do not use in own extensions
|
|
*/
|
|
public static function initializeClassLoader(ClassLoader $classLoader): void
|
|
{
|
|
ClassLoadingInformation::setClassLoader($classLoader);
|
|
}
|
|
|
|
/**
|
|
* checks if config/system/settings.php or PackageStates.php is missing,
|
|
* used to see if a redirect to the installer is needed
|
|
*
|
|
* All file_exists checks are delayed as far as possible to avoid I/O impact
|
|
*
|
|
* @return bool TRUE when the essential configuration is available, otherwise FALSE
|
|
* @internal This is not a public API method, do not use in own extensions
|
|
*/
|
|
public static function checkIfEssentialConfigurationExists(ConfigurationManager $configurationManager): bool
|
|
{
|
|
if (!Environment::isComposerMode()
|
|
&& !file_exists(Environment::getPackageStatesFile())
|
|
) {
|
|
// Early return in case system is not properly set up
|
|
return false;
|
|
}
|
|
|
|
// The system configuration file (settings.php) is mandatory, the additional configuration
|
|
// file (additional.php) is optional.
|
|
return file_exists($configurationManager->getSystemConfigurationFileLocation());
|
|
}
|
|
|
|
/**
|
|
* Initializes the package system and loads the package configuration and settings
|
|
* provided by the packages.
|
|
*
|
|
* @param string $packageManagerClassName Define an alternative package manager implementation (usually for the installer)
|
|
* @internal This is not a public API method, do not use in own extensions
|
|
*/
|
|
public static function createPackageManager($packageManagerClassName, PackageCacheInterface $packageCache): PackageManager
|
|
{
|
|
$dependencyOrderingService = GeneralUtility::makeInstance(DependencyOrderingService::class);
|
|
/** @var PackageManager $packageManager */
|
|
$packageManager = new $packageManagerClassName($dependencyOrderingService);
|
|
$packageManager->setPackageCache($packageCache);
|
|
$packageManager->initialize();
|
|
|
|
return $packageManager;
|
|
}
|
|
|
|
/**
|
|
* @internal
|
|
*/
|
|
public static function createPackageCache(FrontendInterface $coreCache): PackageCacheInterface
|
|
{
|
|
if (!Environment::isComposerMode()) {
|
|
return new PackageStatesPackageCache(Environment::getPackageStatesFile(), $coreCache);
|
|
}
|
|
|
|
$composerInstallersPath = InstalledVersions::getInstallPath('typo3/cms-composer-installers');
|
|
if ($composerInstallersPath === null) {
|
|
throw new \RuntimeException('Package "typo3/cms-composer-installers" not found. Replacing the package is not allowed. Fork the package instead and pull in the fork with the same name.', 1636145677);
|
|
}
|
|
|
|
return new ComposerPackageArtifact(dirname($composerInstallersPath));
|
|
}
|
|
|
|
/**
|
|
* Instantiates an early cache instance
|
|
*
|
|
* Creates a cache instances independently of the CacheManager.
|
|
* The is used to create the core cache during early bootstrap when the CacheManager
|
|
* is not yet available (i.e. configuration is not yet loaded).
|
|
*
|
|
* @param class-string<BackendInterface>|null $enforcedCacheBackend
|
|
* @internal
|
|
*/
|
|
public static function createCache(
|
|
string $identifier,
|
|
bool $disableCaching = false,
|
|
?string $enforcedCacheBackend = null
|
|
): FrontendInterface {
|
|
$cacheConfigurations = $GLOBALS['TYPO3_CONF_VARS']['SYS']['caching']['cacheConfigurations'] ?? [];
|
|
$cacheConfigurations['di']['frontend'] = PhpFrontend::class;
|
|
$cacheConfigurations['di']['backend'] = ContainerBackend::class;
|
|
$cacheConfigurations['di']['options'] = [];
|
|
$configuration = $cacheConfigurations[$identifier] ?? [];
|
|
|
|
$frontend = $configuration['frontend'] ?? VariableFrontend::class;
|
|
$backend = $enforcedCacheBackend ?? $configuration['backend'] ?? Typo3DatabaseBackend::class;
|
|
$options = $configuration['options'] ?? [];
|
|
|
|
if ($disableCaching) {
|
|
$backend = NullBackend::class;
|
|
$options = [];
|
|
}
|
|
|
|
$backendInstance = new $backend($options);
|
|
if (!$backendInstance instanceof BackendInterface) {
|
|
throw new InvalidBackendException('"' . $backend . '" is not a valid cache backend object.', 1545260108);
|
|
}
|
|
if (is_callable([$backendInstance, 'initializeObject'])) {
|
|
$backendInstance->initializeObject();
|
|
}
|
|
|
|
$frontendInstance = new $frontend($identifier, $backendInstance);
|
|
if (!$frontendInstance instanceof FrontendInterface) {
|
|
throw new InvalidCacheException('"' . $frontend . '" is not a valid cache frontend object.', 1545260109);
|
|
}
|
|
if (is_callable([$frontendInstance, 'initializeObject'])) {
|
|
$frontendInstance->initializeObject();
|
|
}
|
|
|
|
return $frontendInstance;
|
|
}
|
|
|
|
/**
|
|
* Set default timezone
|
|
*/
|
|
protected static function setDefaultTimezone(): void
|
|
{
|
|
$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);
|
|
}
|
|
|
|
/**
|
|
* Configure and set up exception and error handling
|
|
*/
|
|
protected static function initializeErrorHandling(): void
|
|
{
|
|
$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'] | E_USER_DEPRECATED;
|
|
$exceptionalErrors = $GLOBALS['TYPO3_CONF_VARS']['SYS']['exceptionalErrors'];
|
|
|
|
$displayErrorsSetting = (int)$GLOBALS['TYPO3_CONF_VARS']['SYS']['displayErrors'];
|
|
switch ($displayErrorsSetting) {
|
|
case -1:
|
|
$ipMatchesDevelopmentSystem = GeneralUtility::cmpIP(NormalizedParams::createFromServerParams($_SERVER)->getRemoteAddress(), $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. A default for displayErrors is set
|
|
// in very early install tool, coming from DefaultConfiguration.php. It is safe here
|
|
// to just throw if there is no value for whatever reason.
|
|
throw new \RuntimeException(
|
|
'The option $TYPO3_CONF_VARS[SYS][displayErrors] is not set to "-1", "0" or "1".',
|
|
1476046290
|
|
);
|
|
}
|
|
@ini_set('display_errors', (string)$displayErrors);
|
|
|
|
if (!empty($errorHandlerClassName)) {
|
|
// Register an error handler for the given errorHandlerError
|
|
$errorHandler = GeneralUtility::makeInstance($errorHandlerClassName, $errorHandlerErrors);
|
|
$errorHandler->setExceptionalErrors($exceptionalErrors);
|
|
if (is_callable([$errorHandler, 'setDebugMode'])) {
|
|
$errorHandler->setDebugMode($displayErrors === 1);
|
|
}
|
|
if (is_callable([$errorHandler, 'registerErrorHandler'])) {
|
|
$errorHandler->registerErrorHandler();
|
|
}
|
|
}
|
|
if (!empty($exceptionHandlerClassName)) {
|
|
// Registering the exception handler is done in the constructor
|
|
GeneralUtility::makeInstance($exceptionHandlerClassName);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Set PHP memory limit depending on value of
|
|
* $GLOBALS['TYPO3_CONF_VARS']['SYS']['setMemoryLimit']
|
|
*/
|
|
protected static function setMemoryLimit(): void
|
|
{
|
|
if ((int)$GLOBALS['TYPO3_CONF_VARS']['SYS']['setMemoryLimit'] > 16) {
|
|
@ini_set('memory_limit', (string)((int)$GLOBALS['TYPO3_CONF_VARS']['SYS']['setMemoryLimit'] . 'm'));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Check if a configuration key has been configured
|
|
*/
|
|
protected static function checkEncryptionKey(): void
|
|
{
|
|
if (empty($GLOBALS['TYPO3_CONF_VARS']['SYS']['encryptionKey'])) {
|
|
throw new \RuntimeException(
|
|
'TYPO3 Encryption is empty. $GLOBALS[\'TYPO3_CONF_VARS\'][\'SYS\'][\'encryptionKey\'] needs to be set for TYPO3 to work securely',
|
|
1502987245
|
|
);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Initialize backend user object in globals
|
|
*
|
|
* @param string $className usually \TYPO3\CMS\Core\Authentication\BackendUserAuthentication::class but can be used for CLI
|
|
*/
|
|
public static function initializeBackendUser($className = BackendUserAuthentication::class, ?ServerRequestInterface $request = null): BackendUserAuthentication
|
|
{
|
|
/** @var BackendUserAuthentication $backendUser */
|
|
$backendUser = GeneralUtility::makeInstance($className);
|
|
// 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($request);
|
|
return $backendUser;
|
|
}
|
|
|
|
/**
|
|
* Initializes and ensures authenticated access
|
|
*/
|
|
public static function initializeBackendAuthentication(): void
|
|
{
|
|
$GLOBALS['BE_USER']->backendCheckLogin();
|
|
}
|
|
}
|