[TASK] Unify handling of TYPO3_PROCEED_IF_NO_USER
[Packages/TYPO3.CMS.git] / typo3 / sysext / backend / Classes / RequestHandler.php
index 90c929f..e2bae71 100644 (file)
@@ -14,26 +14,15 @@ namespace TYPO3\CMS\Backend;
  * The TYPO3 project - inspiring people to share!
  */
 
-use TYPO3\CMS\Backend\Routing\Exception\RouteNotFoundException;
 use TYPO3\CMS\Core\Core\Bootstrap;
 use TYPO3\CMS\Core\Core\RequestHandlerInterface;
-use TYPO3\CMS\Core\FormProtection\FormProtectionFactory;
-use TYPO3\CMS\Core\Utility\GeneralUtility;
 
 /**
- * General RequestHandler for the TYPO3 Backend. This is used for all backend requests except for CLI, AJAX or
- * calls to mod.php (currently handled by BackendModuleRequestHandler).
- *
- * At first, this request handler serves as a replacement to typo3/init.php. It is called but does not exit
- * so any typical script that is not dispatched, is just running through the handleRequest() method and then
- * calls its own code.
- *
- * However, if a get/post parameter "route" is set, the unified Backend Routing is called and searches for a
- * matching route inside the Router. The corresponding controller / action is called then which returns content.
- *
- * The following get/post parameters are evaluated here:
- *   - route
- *   - token
+ * General RequestHandler for the TYPO3 Backend. This is used for all Backend requests except for CLI
+ * or AJAX calls. Unlike all other RequestHandlers in the TYPO3 CMS Core, the actual logic for choosing
+ * the controller is still done inside places like mod.php and each single file.
+ * This RequestHandler here serves solely to check and set up all requirements needed for a TYPO3 Backend.
+ * This class might be changed in the future.
  */
 class RequestHandler implements RequestHandlerInterface {
 
@@ -55,65 +44,25 @@ class RequestHandler implements RequestHandlerInterface {
        /**
         * Handles any backend request
         *
-        * @throws \Exception
-        * @throws \TYPO3\CMS\Core\Exception
+        * @return void
         */
        public function handleRequest() {
-               // Only enable routing for typo3/index.php
-               $routingEnabled = GeneralUtility::getIndpEnv('SCRIPT_FILENAME') === PATH_typo3 . 'index.php';
-               $pathToRoute = (string)GeneralUtility::getIndpEnv('PATH_INFO');
-
-               // Allow the login page to be displayed if routing is not used and on index.php
-               if ($routingEnabled && empty($pathToRoute)) {
-                       define('TYPO3_PROCEED_IF_NO_USER', 1);
-                       $pathToRoute = '/login';
-               }
-
-               $this->boot();
-
-               // Check if the router has the available route and dispatch.
-               if ($routingEnabled) {
-                       $this->dispatchRoute($pathToRoute);
-                       $this->bootstrap->shutdown();
+               // Evaluate the constant for skipping the BE user check for the bootstrap
+               if (defined('TYPO3_PROCEED_IF_NO_USER') && TYPO3_PROCEED_IF_NO_USER) {
+                       $proceedIfNoUserIsLoggedIn = TRUE;
+               } else {
+                       $proceedIfNoUserIsLoggedIn = FALSE;
                }
 
-               // No route found, so the system proceeds in called entrypoint as fallback.
-       }
-
-       /**
-        * This request handler can handle any backend request (but not CLI).
-        *
-        * @return bool If the request is not a CLI script, TRUE otherwise FALSE
-        */
-       public function canHandleRequest() {
-               return (TYPO3_REQUESTTYPE & TYPO3_REQUESTTYPE_BE && !(TYPO3_REQUESTTYPE & TYPO3_REQUESTTYPE_CLI));
-       }
-
-       /**
-        * Returns the priority - how eager the handler is to actually handle the request.
-        *
-        * @return int The priority of the request handler.
-        */
-       public function getPriority() {
-               return 50;
-       }
-
-       /**
-        * Does the main work for setting up the backend environment for any Backend request
-        *
-        * @return void
-        */
-       protected function boot() {
                $this->bootstrap
                        ->checkLockedBackendAndRedirectOrDie()
                        ->checkBackendIpOrDie()
                        ->checkSslBackendAndRedirectIfNeeded()
                        ->checkValidBrowserOrDie()
-                       ->initializeBackendRouter()
                        ->loadExtensionTables(TRUE)
                        ->initializeSpriteManager()
                        ->initializeBackendUser()
-                       ->initializeBackendAuthentication()
+                       ->initializeBackendAuthentication($proceedIfNoUserIsLoggedIn)
                        ->initializeLanguageObject()
                        ->initializeBackendTemplate()
                        ->endOutputBufferingAndCleanPreviousOutput()
@@ -122,49 +71,21 @@ class RequestHandler implements RequestHandlerInterface {
        }
 
        /**
-        * If the request can be handled by the routing framework, dispatch to the correct
-        * controller and action, and then echo the content.
-        *
-        * @param string $pathToRoute
-        *
-        * @throws RouteNotFoundException
-        * @throws \TYPO3\CMS\Core\Exception
-        */
-       protected function dispatchRoute($pathToRoute) {
-               $route = $this->bootstrap->getEarlyInstance(Routing\Router::class)->match($pathToRoute);
-               $routeToken = (string)GeneralUtility::_GP('token');
-               $routeName = $route->getOption('_identifier');
-               $isPublicRoute = $route->getOption('public') || (defined('TYPO3_PROCEED_IF_NO_USER') && TYPO3_PROCEED_IF_NO_USER > 0);
-               if ($isPublicRoute || $this->isValidRequest($routeToken, $routeName)) {
-                       list($className, $methodName) = $route->getOption('controller');
-                       // parameters can be used at a later point to define the available request parameters
-                       $parameters = array();
-                       echo GeneralUtility::callUserFunction($className . '->' . $methodName, $parameters, $this);
-               } else {
-                       throw new RouteNotFoundException('Invalid request for route "' . $pathToRoute . '"', 1425389455);
-               }
-       }
-
-       /**
-        * Wrapper method for static form protection utility
+        * This request handler can handle any backend request (but not CLI).
         *
-        * @return \TYPO3\CMS\Core\FormProtection\AbstractFormProtection
+        * @return bool If the request is not a CLI script, TRUE otherwise FALSE
         */
-       protected function getFormProtection() {
-               return FormProtectionFactory::get();
+       public function canHandleRequest() {
+               return (TYPO3_REQUESTTYPE & TYPO3_REQUESTTYPE_BE && !(TYPO3_REQUESTTYPE & TYPO3_REQUESTTYPE_CLI));
        }
 
        /**
-        * Checks if the request token is valid. This is checked to see if the route is really
-        * created by the same instance. Should be called for all routes in the backend except
-        * for the ones that don't require a login.
+        * Returns the priority - how eager the handler is to actually handle the
+        * request.
         *
-        * @param string $token
-        * @param string $name
-        * @return bool
-        * @see \TYPO3\CMS\Backend\Routing\Generator\UrlGenerator::generate() where the token is generated.
+        * @return int The priority of the request handler.
         */
-       protected function isValidRequest($token, $name) {
-               return $this->getFormProtection()->validateToken($token, 'route', $name);
+       public function getPriority() {
+               return 50;
        }
 }