9.5/_abstract_condition_matcher_8php_source.html

<?php

namespace ‪TYPO3\CMS\Core\Configuration\TypoScript\ConditionMatching;


/*

 * 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\Log\LoggerAwareInterface;

use Psr\Log\LoggerAwareTrait;

use Symfony\Component\ExpressionLanguage\SyntaxError;

use ‪TYPO3\CMS\Core\Configuration\Features;

use ‪TYPO3\CMS\Core\Configuration\TypoScript\Exception\InvalidTypoScriptConditionException;

use ‪TYPO3\CMS\Core\Error\Exception;

use ‪TYPO3\CMS\Core\Exception\MissingTsfeException;

use ‪TYPO3\CMS\Core\ExpressionLanguage\Resolver;

use ‪TYPO3\CMS\Core\Log\LogLevel;

use ‪TYPO3\CMS\Core\Utility\GeneralUtility;

use ‪TYPO3\CMS\Core\Utility\StringUtility;

use ‪TYPO3\CMS\Core\Utility\VersionNumberUtility;


abstract class ‪AbstractConditionMatcher implements LoggerAwareInterface

{

    use LoggerAwareTrait;


    protected ‪$pageId;


    protected ‪$rootline;


    protected ‪$simulateMatchResult = false;


    protected ‪$simulateMatchConditions = [];


    protected ‪$expressionLanguageResolver;


    protected ‪$expressionLanguageResolverVariables = [];


    protected function ‪initializeExpressionLanguageResolver(): void

    {

        $this->‪updateExpressionLanguageVariables();

        $this->expressionLanguageResolver = GeneralUtility::makeInstance(

            Resolver::class,

            'typoscript',

            $this->expressionLanguageResolverVariables

        );

    }


    protected function ‪updateExpressionLanguageVariables(): void

    {

        // deliberately empty and not "abstract" due to backwards compatibility

        // implement this method in derived classes

    }


    protected function ‪strictSyntaxEnabled(): bool

    {

        return GeneralUtility::makeInstance(Features::class)->isFeatureEnabled('TypoScript.strictSyntax');

    }


    public function ‪setPageId(‪$pageId)

    {

        if (is_int(‪$pageId) && ‪$pageId > 0) {

            $this->pageId = ‪$pageId;

        }

        $this->‪initializeExpressionLanguageResolver();

    }


    public function ‪getPageId()

    {

        return ‪$this->pageId;

    }


    public function ‪setRootline(array ‪$rootline)

    {

        if (!empty(‪$rootline)) {

            $this->rootline = ‪$rootline;

        }

        $this->‪initializeExpressionLanguageResolver();

    }


    public function ‪getRootline()

    {

        return ‪$this->rootline;

    }


    public function ‪setSimulateMatchResult($simulateMatchResult)

    {

        if (is_bool(‪$simulateMatchResult)) {

            $this->simulateMatchResult = ‪$simulateMatchResult;

        }

    }


    public function ‪setSimulateMatchConditions(array ‪$simulateMatchConditions)

    {

        $this->simulateMatchConditions = ‪$simulateMatchConditions;

    }


    protected function ‪normalizeExpression($expression)

    {

        $removeSpaces = '/

          \\s*

          (                    # subroutine 1

            \\[

              (?:

                [^\\[\\]]      # any character except []

                | (?1)         # recursive subroutine 1 when brackets are around

              )*

            \\]

          )

          \\s*

          /xi';


        $adjacentBrackets = '/

          (                    # subroutine 1

            \\[

              (?:

                [^\\[\\]]      # any character except []

                | (?1)         # recursive subroutine 1 when brackets are around

              )*

            \\]

          )

          (*SKIP)              # avoid backtracking into completed bracket expressions

          \\[                  # match the following [

          /xi';


        return preg_replace(

            [

                $removeSpaces,

                '/\\]AND\\[/i',

                '/\\]OR\\[/i',

                $adjacentBrackets

            ],

            [

                '\\1',

                ']&&[',

                ']||[',

                '\\1||['

            ],

            trim($expression)

        );

    }


    public function ‪match($expression)

    {

        // Return directly if result should be simulated:

        if ($this->simulateMatchResult) {

            return ‪$this->simulateMatchResult;

        }

        // Return directly if matching for specific condition is simulated only:

        if (!empty($this->simulateMatchConditions)) {

            return in_array($expression, $this->simulateMatchConditions);

        }

        // Sets the current pageId if not defined yet:

        if (!isset($this->pageId)) {

            $this->pageId = $this->‪determinePageId();

        }

        // Sets the rootline if not defined yet:

        if (!isset($this->rootline)) {

            $this->rootline = $this->‪determineRootline();

        }

        $result = false;

        $normalizedExpression = $this->‪normalizeExpression($expression);

        // First and last character must be square brackets (e.g. "[A]&&[B]":

        if ($normalizedExpression[0] === '[' && substr($normalizedExpression, -1) === ']') {

            $innerExpression = substr($normalizedExpression, 1, -1);

            $orParts = explode(']||[', $innerExpression);

            if ($this->‪strictSyntaxEnabled() && count($orParts) > 1) {

                trigger_error('Multiple conditions blocks combined with AND, OR, && or || will be removed in TYPO3 v10.0, use the new expression language.', E_USER_DEPRECATED);

            }

            foreach ($orParts as $orPart) {

                $andParts = explode(']&&[', $orPart);

                if ($this->‪strictSyntaxEnabled() && count($andParts) > 1) {

                    trigger_error('Multiple conditions blocks combined with AND, OR, && or || will be removed in TYPO3 v10.0, use the new expression language.', E_USER_DEPRECATED);

                }

                foreach ($andParts as $andPart) {

                    $result = $this->‪evaluateExpression($andPart);

                    if (!is_bool($result)) {

                        $result = $this->‪evaluateCondition($andPart);

                    }

                    // If condition in AND context fails, the whole block is FALSE:

                    if ($result === false) {

                        break;

                    }

                }

                // If condition in OR context succeeds, the whole expression is TRUE:

                if ($result === true) {

                    break;

                }

            }

        }

        return $result;

    }


    protected function ‪evaluateExpression(string $expression): ?bool

    {

        try {

            $result = $this->expressionLanguageResolver->evaluate($expression);

            if ($result !== null) {

                return $result;

            }

        } catch (MissingTsfeException $e) {

            // TSFE is not available in the current context (e.g. TSFE in BE context),

            // we set all conditions false for this case.

            return false;

        } catch (SyntaxError $exception) {

            // SyntaxException means no support, let's try the fallback

            $message = 'Expression could not be parsed, fallback kicks in.';

            if (strpos($exception->getMessage(), 'Unexpected character "="') !== false) {

                $message .= ' It looks like an old condition with only one equal sign.';

            }

            $this->logger->log(

                $this->‪strictSyntaxEnabled() ? ‪LogLevel::WARNING : ‪LogLevel::INFO,

                $message,

                ['expression' => $expression]

            );

        } catch (\Throwable $exception) {

            // The following error handling is required to mitigate a missing type check

            // in the Symfony Expression Language handling. In case a condition

            // use "in" or "not in" check in combination with a non array a PHP Warning

            // is thrown. Example: [1 in "foo"] or ["bar" in "foo,baz"]

            // This conditions are wrong for sure, but they will break the complete installation

            // including the backend. To mitigate the problem we do the following:

            // 1) In FE an InvalidTypoScriptConditionException is thrown (if strictSyntax is enabled)

            // 2) In FE silent catch this error and log it (if strictSyntax is disabled)

            // 3) In BE silent catch this error and log it, but never break the backend.

            $this->logger->error($exception->getMessage(), [

                'expression' => $expression,

                'exception' => $exception

            ]);

            if (TYPO3_MODE === 'FE'

                && $exception instanceof Exception

                && $this->‪strictSyntaxEnabled()

                && strpos($exception->getMessage(), 'in_array() expects parameter 2 to be array') !== false

            ) {

                throw new InvalidTypoScriptConditionException('Invalid expression in condition: [' . $expression . ']', 1536950931);

            }

        }

        return null;

    }


    protected function ‪evaluateConditionCommon($key, $value)

    {

        $keyParts = GeneralUtility::trimExplode('|', $key);

        switch ($keyParts[0]) {

            case 'applicationContext':

                $values = GeneralUtility::trimExplode(',', $value, true);

                $currentApplicationContext = GeneralUtility::getApplicationContext();

                foreach ($values as $applicationContext) {

                    if ($this->‪searchStringWildcard($currentApplicationContext, $applicationContext)) {

                        return true;

                    }

                }

                return false;

            case 'language':

                if (GeneralUtility::getIndpEnv('HTTP_ACCEPT_LANGUAGE') === $value) {

                    return true;

                }

                $values = GeneralUtility::trimExplode(',', $value, true);

                foreach ($values as $test) {

                    // matches a string with asterix in front and back. See https://docs.typo3.org/typo3cms/TyposcriptReference/Conditions/Reference.html#language for use case.

                    if (preg_match('/^\\*.+\\*$/', $test)) {

                        $allLanguages = preg_split('/[,;]/', GeneralUtility::getIndpEnv('HTTP_ACCEPT_LANGUAGE'));

                        if (in_array(substr($test, 1, -1), $allLanguages)) {

                            return true;

                        }

                    } elseif (GeneralUtility::getIndpEnv('HTTP_ACCEPT_LANGUAGE') == $test) {

                        return true;

                    }

                }

                return false;

            case 'IP':

                if ($value === 'devIP') {

                    $value = trim(‪$GLOBALS['TYPO3_CONF_VARS']['SYS']['devIPmask']);

                }


                return (bool)GeneralUtility::cmpIP(GeneralUtility::getIndpEnv('REMOTE_ADDR'), $value);

            case 'hostname':

                return (bool)GeneralUtility::cmpFQDN(GeneralUtility::getIndpEnv('REMOTE_ADDR'), $value);

            case 'hour':

            case 'minute':

            case 'month':

            case 'year':

            case 'dayofweek':

            case 'dayofmonth':

            case 'dayofyear':

                // In order to simulate time properly in templates.

                $theEvalTime = ‪$GLOBALS['SIM_EXEC_TIME'];

                switch ($key) {

                    case 'hour':

                        $theTestValue = date('H', $theEvalTime);

                        break;

                    case 'minute':

                        $theTestValue = date('i', $theEvalTime);

                        break;

                    case 'month':

                        $theTestValue = date('m', $theEvalTime);

                        break;

                    case 'year':

                        $theTestValue = date('Y', $theEvalTime);

                        break;

                    case 'dayofweek':

                        $theTestValue = date('w', $theEvalTime);

                        break;

                    case 'dayofmonth':

                        $theTestValue = date('d', $theEvalTime);

                        break;

                    case 'dayofyear':

                        $theTestValue = date('z', $theEvalTime);

                        break;

                    default:

                        $theTestValue = 0;

                        break;

                }

                $theTestValue = (int)$theTestValue;

                // comp

                $values = GeneralUtility::trimExplode(',', $value, true);

                foreach ($values as $test) {

                    if (\‪TYPO3\CMS\Core\Utility\MathUtility::canBeInterpretedAsInteger($test)) {

                        $test = '=' . $test;

                    }

                    if ($this->‪compareNumber($test, $theTestValue)) {

                        return true;

                    }

                }

                return false;

            case 'compatVersion':

                return ‪VersionNumberUtility::convertVersionNumberToInteger(TYPO3_branch) >= ‪VersionNumberUtility::convertVersionNumberToInteger($value);

            case 'loginUser':

                if ($this->‪isUserLoggedIn()) {

                    $values = GeneralUtility::trimExplode(',', $value, true);

                    foreach ($values as $test) {

                        if ($test === '*' || (string)$this->‪getUserId() === (string)$test) {

                            return true;

                        }

                    }

                } elseif ($value === '') {

                    return true;

                }

                return false;

            case 'page':

                if ($keyParts[1]) {

                    $page = $this->‪getPage();

                    $property = $keyParts[1];

                    if (!empty($page) && isset($page[$property]) && (string)$page[$property] === (string)$value) {

                        return true;

                    }

                }

                return false;

            case 'globalVar':

                $values = GeneralUtility::trimExplode(',', $value, true);

                foreach ($values as $test) {

                    $point = strcspn($test, '!=<>');

                    $theVarName = substr($test, 0, $point);

                    $nv = $this->‪getVariable(trim($theVarName));

                    $testValue = substr($test, $point);

                    if ($this->‪compareNumber($testValue, $nv)) {

                        return true;

                    }

                }

                return false;

            case 'globalString':

                $values = GeneralUtility::trimExplode(',', $value, true);

                foreach ($values as $test) {

                    $point = strcspn($test, '=');

                    $theVarName = substr($test, 0, $point);

                    $nv = (string)$this->‪getVariable(trim($theVarName));

                    $testValue = substr($test, $point + 1);

                    if ($this->‪searchStringWildcard($nv, trim($testValue))) {

                        return true;

                    }

                }

                return false;

            case 'userFunc':

                $matches = [];

                preg_match_all('/^\s*([^\‍(\s]+)\s*(?:\‍((.*)\‍))?\s*$/', $value, $matches);

                $funcName = $matches[1][0];

                $funcValues = trim($matches[2][0]) !== '' ? $this->‪parseUserFuncArguments($matches[2][0]) : [];

                if (is_callable($funcName) && call_user_func_array($funcName, $funcValues)) {

                    return true;

                }

                return false;

        }

        return null;

    }


    protected function ‪evaluateCustomDefinedCondition($condition)

    {

        $conditionResult = null;


        list($conditionClassName, $conditionParameters) = GeneralUtility::trimExplode(' ', $condition, false, 2);


        // Check if the condition class name is a valid class

        // This is necessary to not stop here for the conditions ELSE and GLOBAL

        if (class_exists($conditionClassName)) {

            // Use like this: [MyCompany\MyPackage\ConditionMatcher\MyOwnConditionMatcher = myvalue]

            $conditionObject = GeneralUtility::makeInstance($conditionClassName);

            if (($conditionObject instanceof \‪TYPO3\CMS\Core\Configuration\TypoScript\ConditionMatching\AbstractCondition) === false) {

                throw new \TYPO3\CMS\Core\Configuration\TypoScript\Exception\InvalidTypoScriptConditionException(

                    '"' . $conditionClassName . '" is not a valid TypoScript Condition object.',

                    1410286153

                );

            }


            $conditionParameters = $this->‪parseUserFuncArguments($conditionParameters);

            $conditionObject->setConditionMatcherInstance($this);

            $conditionResult = $conditionObject->matchCondition($conditionParameters);

        }


        return $conditionResult;

    }


    protected function ‪parseUserFuncArguments($arguments)

    {

        $result = [];

        $arguments = trim($arguments);

        while ($arguments !== '') {

            if ($arguments[0] === ',') {

                $result[] = '';

                $arguments = substr($arguments, 1);

            } else {

                $pos = strcspn($arguments, ',\'"');

                if ($pos == 0) {

                    // We hit a quote of some kind

                    $quote = $arguments[0];

                    $segment = preg_replace('/^(.*?[^\\\])' . $quote . '.*$/', '\1', substr($arguments, 1));

                    $segment = str_replace('\\' . $quote, $quote, $segment);

                    $result[] = $segment;

                    // shorten $arguments

                    $arguments = substr($arguments, strlen($segment) + 2);

                    $offset = strpos($arguments, ',');

                    if ($offset === false) {

                        $offset = strlen($arguments);

                    }

                    $arguments = substr($arguments, $offset + 1);

                } else {

                    $result[] = trim(substr($arguments, 0, $pos));

                    $arguments = substr($arguments, $pos + 1);

                }

            }

            $arguments = trim($arguments);

        }

        return $result;

    }


    protected function ‪getVariableCommon(array $vars)

    {

        $value = null;

        $namespace = trim($vars[0]);

        if (count($vars) === 1) {

            $value = $this->‪getGlobal($vars[0]);

        } elseif ($namespace === 'LIT') {

            $value = trim($vars[1]);

        } else {

            $splitAgain = explode('|', $vars[1], 2);

            $k = trim($splitAgain[0]);

            if ($k) {

                switch ($namespace) {

                    case 'GP':

                        $value = GeneralUtility::_GP($k);

                        break;

                    case 'GPmerged':

                        $value = GeneralUtility::_GPmerged($k);

                        break;

                    case 'ENV':

                        $value = getenv($k);

                        break;

                    case 'IENV':

                        $value = GeneralUtility::getIndpEnv($k);

                        break;

                    default:

                        return null;

                }

                // If array:

                if (count($splitAgain) > 1) {

                    if (is_array($value) && trim($splitAgain[1]) !== '') {

                        $value = $this->‪getGlobal($splitAgain[1], $value);

                    } else {

                        $value = '';

                    }

                }

            }

        }

        return $value;

    }


    protected function ‪compareNumber($test, $leftValue)

    {

        if (preg_match('/^(!?=+|<=?|>=?)\\s*([^\\s]*)\\s*$/', $test, $matches)) {

            $operator = $matches[1];

            $rightValue = $matches[2];

            switch ($operator) {

                case '>=':

                    return $leftValue >= (float)$rightValue;

                    break;

                case '<=':

                    return $leftValue <= (float)$rightValue;

                    break;

                case '!=':

                    // multiple values may be split with '|'

                    // see if none matches ("not in list")

                    $found = false;

                    $rightValueParts = GeneralUtility::trimExplode('|', $rightValue);

                    foreach ($rightValueParts as $rightValueSingle) {

                        if ($leftValue == (float)$rightValueSingle) {

                            $found = true;

                            break;

                        }

                    }

                    return $found === false;

                    break;

                case '<':

                    return $leftValue < (float)$rightValue;

                    break;

                case '>':

                    return $leftValue > (float)$rightValue;

                    break;

                default:

                    // nothing valid found except '=', use '='

                    // multiple values may be split with '|'

                    // see if one matches ("in list")

                    $found = false;

                    $rightValueParts = GeneralUtility::trimExplode('|', $rightValue);

                    foreach ($rightValueParts as $rightValueSingle) {

                        if ($leftValue == $rightValueSingle) {

                            $found = true;

                            break;

                        }

                    }

                    return $found;

            }

        }

        return false;

    }


    protected function ‪searchStringWildcard($haystack, $needle)

    {

        return ‪StringUtility::searchStringWildcard($haystack, $needle);

    }


    protected function ‪getGlobal($var, $source = null)

    {

        $vars = explode('|', $var);

        $c = count($vars);

        $k = trim($vars[0]);

        $theVar = isset($source) ? ($source[$k] ?? null) : (‪$GLOBALS[$k] ?? null);

        for ($a = 1; $a < $c; $a++) {

            if (!isset($theVar)) {

                break;

            }

            $key = trim($vars[$a]);

            if (is_object($theVar)) {

                $theVar = $theVar->{$key};

            } elseif (is_array($theVar)) {

                $theVar = $theVar[$key];

            } else {

                return '';

            }

        }

        if (!is_array($theVar) && !is_object($theVar)) {

            return $theVar;

        }

        return '';

    }


    abstract protected function evaluateCondition($string);


    abstract protected function getVariable($name);


    abstract protected function getGroupList();


    abstract protected function determinePageId();


    abstract protected function getPage();


    abstract protected function determineRootline();


    abstract protected function getUserId();


    abstract protected function isUserLoggedIn();

}