SiteMatcher.php

Go to the documentation of this file.

<?php
declare(strict_types = 1);
 
namespace ‪TYPO3\CMS\Core\Routing;
 
/*
 * 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 Psr\Http\Message\ServerRequestInterface;
use Symfony\Component\Routing\Exception\NoConfigurationException;
use Symfony\Component\Routing\Exception\ResourceNotFoundException;
use Symfony\Component\Routing\Matcher\UrlMatcher;
use Symfony\Component\Routing\RequestContext;
use ‪TYPO3\CMS\Core\Cache\CacheManager;
use ‪TYPO3\CMS\Core\Exception\SiteNotFoundException;
use ‪TYPO3\CMS\Core\SingletonInterface;
use ‪TYPO3\CMS\Core\Site\Entity\PseudoSite;
use ‪TYPO3\CMS\Core\Site\Entity\SiteInterface;
use ‪TYPO3\CMS\Core\Site\Entity\SiteLanguage;
use ‪TYPO3\CMS\Core\Site\PseudoSiteFinder;
use ‪TYPO3\CMS\Core\Site\SiteFinder;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use ‪TYPO3\CMS\Core\Utility\HttpUtility;
use ‪TYPO3\CMS\Core\Utility\MathUtility;
use ‪TYPO3\CMS\Core\Utility\RootlineUtility;
use ‪TYPO3\CMS\Frontend\Page\PageRepository;
 
class ‪SiteMatcher implements ‪SingletonInterface
{
    protected ‪$finder;
 
    protected ‪$pseudoSiteFinder;
 
    public function ‪__construct(‪SiteFinder ‪$finder = null)
    {
        $this->finder = ‪$finder ?? GeneralUtility::makeInstance(SiteFinder::class);
        $this->pseudoSiteFinder = GeneralUtility::makeInstance(PseudoSiteFinder::class);
    }
 
    public function ‪refresh()
    {
        ‪RootlineUtility::purgeCaches();
        GeneralUtility::makeInstance(CacheManager::class)->getCache('cache_rootline')->flush();
        $this->pseudoSiteFinder = GeneralUtility::makeInstance(PseudoSiteFinder::class);
        $this->pseudoSiteFinder->refresh();
    }
 
    public function ‪matchRequest(ServerRequestInterface $request): ‪RouteResultInterface
    {
        $site = null;
        $language = null;
        $defaultLanguage = null;
 
        $pageId = $request->getQueryParams()['id'] ?? $request->getParsedBody()['id'] ?? 0;
 
        if (!empty($pageId) && !‪MathUtility::canBeInterpretedAsInteger($pageId)) {
            $pageId = (int)GeneralUtility::makeInstance(PageRepository::class)->getPageIdFromAlias($pageId);
        }
        // First, check if we have a _GET/_POST parameter for "id", then a site information can be resolved based.
        if ($pageId > 0) {
            // Loop over the whole rootline without permissions to get the actual site information
            try {
                $site = $this->finder->getSiteByPageId((int)$pageId);
                // If a "L" parameter is given, we take that one into account.
                $languageId = $request->getQueryParams()['L'] ?? $request->getParsedBody()['L'] ?? null;
                if ($languageId !== null) {
                    $language = $site->getLanguageById((int)$languageId);
                } else {
                    // Use this later below
                    $defaultLanguage = $site->getDefaultLanguage();
                }
            } catch (‪SiteNotFoundException $e) {
                // No site found by the given page
            } catch (\InvalidArgumentException $e) {
                // The language fetched by getLanguageById() was not available, now the PSR-15 middleware
                // redirects to the default page.
            }
        }
 
        // No language found at this point means that the URL was not used with a valid "?id=1&L=2" parameter
        // which resulted in a site / language combination that was found. Now, the matching is done
        // on the incoming URL.
        if (!($language instanceof ‪SiteLanguage)) {
            $collection = $this->‪getRouteCollectionForAllSites();
            $context = new RequestContext(
                '',
                $request->getMethod(),
                ‪HttpUtility::idn_to_ascii($request->getUri()->getHost()),
                $request->getUri()->getScheme(),
                // Ports are only necessary for URL generation in Symfony which is not used by TYPO3
                80,
                443,
                $request->getUri()->getPath()
            );
            $matcher = new UrlMatcher($collection, $context);
            try {
                $result = $matcher->match($request->getUri()->getPath());
                return new ‪SiteRouteResult(
                    $request->getUri(),
                    $result['site'],
                    // if no language is found, this usually results due to "/" called instead of "/fr/"
                    // but it could also be the reason that "/index.php?id=23" was called, so the default
                    // language is used as a fallback here then.
                    $result['language'] ?? $defaultLanguage,
                    $result['tail']
                );
            } catch (NoConfigurationException | ResourceNotFoundException $e) {
                // No site+language combination found so far
            }
            // At this point we discard a possible found site via ?id=123
            // Because ?id=123 _can_ only work if the actual domain/site base works
            // so www.domain-without-site-configuration/index.php?id=123 (where 123 is a page referring
            // to a page within a site configuration will never be resolved here) properly
            $site = null;
        }
 
        // Check against any sys_domain records
        $collection = $this->‪getRouteCollectionForVisibleSysDomains();
        $context = new RequestContext('/', $request->getMethod(), $request->getUri()->getHost());
        $matcher = new UrlMatcher($collection, $context);
        if ((bool)‪$GLOBALS['TYPO3_CONF_VARS']['SYS']['recursiveDomainSearch']) {
            $host = explode('.', $request->getUri()->getHost());
            while (count($host)) {
                $context->setHost(implode('.', $host));
                try {
                    $result = $matcher->match($request->getUri()->getPath());
                    return new ‪SiteRouteResult(
                        $request->getUri(),
                        $result['site'],
                        $result['language'],
                        $result['tail']
                    );
                } catch (NoConfigurationException | ResourceNotFoundException $e) {
                    array_shift($host);
                }
            }
        } else {
            try {
                $result = $matcher->match($request->getUri()->getPath());
                return new ‪SiteRouteResult($request->getUri(), $result['site'], $result['language'], $result['tail']);
            } catch (NoConfigurationException | ResourceNotFoundException $e) {
                // No domain record found
            }
        }
        // No domain record found, try resolving "pseudo-site" again
        if ($site == null) {
            try {
                // use the matching "pseudo-site" for $pageId
                $site = $this->pseudoSiteFinder->getSiteByPageId((int)$pageId);
            } catch (‪SiteNotFoundException $exception) {
                // use the first "pseudo-site" found
                $allPseudoSites = $this->pseudoSiteFinder->findAll();
                $site = reset($allPseudoSites);
            }
        }
        return new ‪SiteRouteResult($request->getUri(), $site, $language);
    }
 
    public function ‪matchByPageId(int $pageId, array $rootLine = null): ‪SiteInterface
    {
        try {
            return $this->finder->getSiteByPageId($pageId, $rootLine);
        } catch (‪SiteNotFoundException $e) {
            // Check for a pseudo / null site
            return $this->pseudoSiteFinder->getSiteByPageId($pageId, $rootLine);
        }
    }
 
    protected function ‪getRouteCollectionForAllSites(): ‪RouteCollection
    {
        $groupedRoutes = [];
        foreach ($this->finder->getAllSites() as $site) {
            // Add the site as entrypoint
            $uri = $site->getBase();
            $route = new ‪Route(
                ($uri->getPath() ?: '/') . '{tail}',
                ['site' => $site, 'language' => null, 'tail' => ''],
                array_filter(['tail' => '.*', 'port' => (string)$uri->getPort()]),
                ['utf8' => true],
                $uri->getHost() ?: '',
                $uri->getScheme()
            );
            $identifier = 'site_' . $site->getIdentifier();
            $groupedRoutes[($uri->getScheme() ?: '-') . ($uri->getHost() ?: '-')][$uri->getPath() ?: '/'][$identifier] = $route;
            // Add all languages
            foreach ($site->getAllLanguages() as $siteLanguage) {
                $uri = $siteLanguage->getBase();
                $route = new ‪Route(
                    ($uri->getPath() ?: '/') . '{tail}',
                    ['site' => $site, 'language' => $siteLanguage, 'tail' => ''],
                    array_filter(['tail' => '.*', 'port' => (string)$uri->getPort()]),
                    ['utf8' => true],
                    ‪HttpUtility::idn_to_ascii($uri->getHost()) ?: '',
                    $uri->getScheme()
                );
                $identifier = 'site_' . $site->getIdentifier() . '_' . $siteLanguage->getLanguageId();
                $groupedRoutes[($uri->getScheme() ?: '-') . ($uri->getHost() ?: '-')][$uri->getPath() ?: '/'][$identifier] = $route;
            }
        }
        return $this->‪createRouteCollectionFromGroupedRoutes($groupedRoutes);
    }
 
    protected function ‪getRouteCollectionForVisibleSysDomains(): ‪RouteCollection
    {
        $sites = $this->pseudoSiteFinder->findAll();
        $groupedRoutes = [];
        foreach ($sites as $site) {
            if (!$site instanceof ‪PseudoSite) {
                continue;
            }
            foreach ($site->getEntryPoints() as $uri) {
                // Site has no sys_domain record, it is not valid for a routing entrypoint, but only available
                // via "id" GET parameter which is handled separately
                if (!$uri->getHost()) {
                    continue;
                }
                $route = new ‪Route(
                    ($uri->getPath() ?: '/') . '{tail}',
                    ['site' => $site, 'language' => null, 'tail' => ''],
                    array_filter(['tail' => '.*', 'port' => (string)$uri->getPort()]),
                    ['utf8' => true],
                    $uri->getHost(),
                    $uri->getScheme()
                );
                $identifier = 'site_' . $site->getIdentifier() . '_' . (string)$uri;
                $groupedRoutes[($uri->getScheme() ?: '-') . ($uri->getHost() ?: '-')][$uri->getPath() ?: '/'][$identifier] = $route;
            }
        }
        return $this->‪createRouteCollectionFromGroupedRoutes($groupedRoutes);
    }
 
    protected function ‪createRouteCollectionFromGroupedRoutes(array $groupedRoutes): ‪RouteCollection
    {
        $collection = new ‪RouteCollection();
        // Ensure more generic routes containing '-' in host identifier, processed at last
        krsort($groupedRoutes);
        foreach ($groupedRoutes as $groupedRoutesPerHost) {
            krsort($groupedRoutesPerHost);
            foreach ($groupedRoutesPerHost as $groupedRoutesPerPath) {
                krsort($groupedRoutesPerPath);
                foreach ($groupedRoutesPerPath as $identifier => $route) {
                    $collection->add($identifier, $route);
                }
            }
        }
        return $collection;
    }
}