AbstractConditionMatcher.php

Go to the documentation of this file.

<?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 TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\CMS\Core\Utility\VersionNumberUtility;

abstract class AbstractConditionMatcher
{
    protected $pageId;

    protected $rootline;

    protected $simulateMatchResult = false;

    protected $simulateMatchConditions = [];

    public function setPageId($pageId)
    {
        if (is_int($pageId) && $pageId > 0) {
            $this->pageId = $pageId;
        }
    }

    public function getPageId()
    {
        return $this->pageId;
    }

    public function setRootline(array $rootline)
    {
        if (!empty($rootline)) {
            $this->rootline = $rootline;
        }
    }

    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)
    {
        $normalizedExpression = preg_replace([
            '/\\]\\s*(OR|\\|\\|)?\\s*\\[/i',
            '/\\]\\s*(AND|&&)\\s*\\[/i'
        ], [
            ']||[',
            ']&&['
        ], trim($expression));
        return $normalizedExpression;
    }

    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);
            foreach ($orParts as $orPart) {
                $andParts = explode(']&&[', $orPart);
                foreach ($andParts as $andPart) {
                    $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 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;
                break;
            case 'language':
                if (GeneralUtility::getIndpEnv('HTTP_ACCEPT_LANGUAGE') === $value) {
                    return true;
                }
                $values = GeneralUtility::trimExplode(',', $value, true);
                foreach ($values as $test) {
                    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;
                break;
            case 'IP':
                if ($value === 'devIP') {
                    $value = trim($GLOBALS['TYPO3_CONF_VARS']['SYS']['devIPmask']);
                }

                return (bool)GeneralUtility::cmpIP(GeneralUtility::getIndpEnv('REMOTE_ADDR'), $value);
                break;
            case 'hostname':
                return (bool)GeneralUtility::cmpFQDN(GeneralUtility::getIndpEnv('REMOTE_ADDR'), $value);
                break;
            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;
                break;
            case 'compatVersion':
                return VersionNumberUtility::convertVersionNumberToInteger(TYPO3_branch) >= VersionNumberUtility::convertVersionNumberToInteger($value);
                break;
            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;
                break;
            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;
                break;
            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;
                break;
            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;
                break;
            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;
                break;
        }
        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)
    {
        $result = false;
        if ($haystack === $needle) {
            $result = true;
        } elseif ($needle) {
            if (preg_match('/^\\/.+\\/$/', $needle)) {
                // Regular expression, only "//" is allowed as delimiter
                $regex = $needle;
            } else {
                $needle = str_replace(['*', '?'], ['%%%MANY%%%', '%%%ONE%%%'], $needle);
                $regex = '/^' . preg_quote($needle, '/') . '$/';
                // Replace the marker with .* to match anything (wildcard)
                $regex = str_replace(['%%%MANY%%%', '%%%ONE%%%'], ['.*', '.'], $regex);
            }
            $result = (bool)preg_match($regex, $haystack);
        }
        return $result;
    }

    protected function getGlobal($var, $source = null)
    {
        $vars = explode('|', $var);
        $c = count($vars);
        $k = trim($vars[0]);
        $theVar = isset($source) ? $source[$k] : $GLOBALS[$k];
        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();

    abstract protected function log($message);
}