AbstractConditionMatcher.php

Go to the documentation of this file.

<?php
namespace TYPO3\CMS\Core\Configuration\TypoScript\ConditionMatching;

use TYPO3\CMS\Core\Utility\GeneralUtility;

abstract class AbstractConditionMatcher {

    protected $pageId;

    protected $rootline;

    protected $simulateMatchResult = FALSE;

    protected $simulateMatchConditions = array();

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

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

    public function setRootline(array $rootline) {
        if (count($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(array(
            '/\\]\\s*(OR|\\|\\|)?\\s*\\[/i',
            '/\\]\\s*(AND|&&)\\s*\\[/i'
        ), array(
            ']||[',
            ']&&['
        ), 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 (count($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) {
        if (GeneralUtility::inList('browser,version,system,useragent', strtolower($key))) {
            $browserInfo = $this->getBrowserInfo(GeneralUtility::getIndpEnv('HTTP_USER_AGENT'));
        }
        $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;
                    }
                }
                break;
            case 'browser':
                $values = GeneralUtility::trimExplode(',', $value, TRUE);
                // take all identified browsers into account, eg chrome deliver
                // webkit=>532.5, chrome=>4.1, safari=>532.5
                // so comparing string will be
                // "webkit532.5 chrome4.1 safari532.5"
                $all = '';
                foreach ($browserInfo['all'] as $key => $value) {
                    $all .= $key . $value . ' ';
                }
                foreach ($values as $test) {
                    if (stripos($all, $test) !== FALSE) {
                        return TRUE;
                    }
                }
                break;
            case 'version':
                $values = GeneralUtility::trimExplode(',', $value, TRUE);
                foreach ($values as $test) {
                    if (strcspn($test, '=<>') == 0) {
                        switch ($test[0]) {
                            case '=':
                                if (doubleval(substr($test, 1)) == $browserInfo['version']) {
                                    return TRUE;
                                }
                                break;
                            case '<':
                                if (doubleval(substr($test, 1)) > $browserInfo['version']) {
                                    return TRUE;
                                }
                                break;
                            case '>':
                                if (doubleval(substr($test, 1)) < $browserInfo['version']) {
                                    return TRUE;
                                }
                                break;
                        }
                    } elseif (strpos(' ' . $browserInfo['version'], $test) == 1) {
                        return TRUE;
                    }
                }
                break;
            case 'system':
                $values = GeneralUtility::trimExplode(',', $value, TRUE);
                // Take all identified systems into account, e.g. mac for iOS, Linux
                // for android and Windows NT for Windows XP
                $allSystems = ' ' . implode(' ', $browserInfo['all_systems']);
                foreach ($values as $test) {
                    if (stripos($allSystems, $test) !== FALSE) {
                        return TRUE;
                    }
                }
                break;
            case 'device':
                if (!isset($this->deviceInfo)) {
                    $this->deviceInfo = $this->getDeviceType(GeneralUtility::getIndpEnv('HTTP_USER_AGENT'));
                }
                $values = GeneralUtility::trimExplode(',', $value, TRUE);
                foreach ($values as $test) {
                    if ($this->deviceInfo == $test) {
                        return TRUE;
                    }
                }
                break;
            case 'useragent':
                $test = trim($value);
                if ($test !== '') {
                    return $this->searchStringWildcard((string)$browserInfo['useragent'], $test);
                }
                break;
            case 'language':
                $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;
                    }
                }
                break;
            case 'IP':
                if ($value === 'devIP') {
                    $value = trim($GLOBALS['TYPO3_CONF_VARS']['SYS']['devIPmask']);
                }

                if (GeneralUtility::cmpIP(GeneralUtility::getIndpEnv('REMOTE_ADDR'), $value)) {
                    return TRUE;
                }
                break;
            case 'hostname':
                if (GeneralUtility::cmpFQDN(GeneralUtility::getIndpEnv('REMOTE_ADDR'), $value)) {
                    return TRUE;
                }
                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;
                }
                $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;
                    }
                }
                break;
            case 'compatVersion':
                return GeneralUtility::compat_version($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;
                }
                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;
                    }
                }
                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;
                    }
                }
                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;
                    }
                }
                break;
            case 'userFunc':
                $matches = array();
                preg_match_all('/^\s*([^\(\s]+)\s*(?:\((.*)\))?\s*$/', $value, $matches);
                $funcName = $matches[1][0];
                $funcValues = trim($matches[2][0]) !== '' ? $this->parseUserFuncArguments($matches[2][0]) : array();
                if (is_callable($funcName) && call_user_func_array($funcName, $funcValues)) {
                    return TRUE;
                }
                break;
        }
        return NULL;
    }

    protected function parseUserFuncArguments($arguments) {
        $result = array();
        $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;
        if (count($vars) == 1) {
            $value = $this->getGlobal($vars[0]);
        } else {
            $splitAgain = explode('|', $vars[1], 2);
            $k = trim($splitAgain[0]);
            if ($k) {
                switch ((string) trim($vars[0])) {
                    case 'GP':
                        $value = GeneralUtility::_GP($k);
                        break;
                    case 'ENV':
                        $value = getenv($k);
                        break;
                    case 'IENV':
                        $value = GeneralUtility::getIndpEnv($k);
                        break;
                    case 'LIT':
                        return trim($vars[1]);
                        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 >= doubleval($rightValue);
                    break;
                case '<=':
                    return $leftValue <= doubleval($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 == doubleval($rightValueSingle)) {
                            $found = TRUE;
                            break;
                        }
                    }
                    return $found === FALSE;
                    break;
                case '<':
                    return $leftValue < doubleval($rightValue);
                    break;
                case '>':
                    return $leftValue > doubleval($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(array('*', '?'), array('###MANY###', '###ONE###'), $needle);
                $regex = '/^' . preg_quote($needle, '/') . '$/';
                // Replace the marker with .* to match anything (wildcard)
                $regex = str_replace(array('###MANY###', '###ONE###'), array('.*', '.'), $regex);
            }
            $result = (bool)preg_match($regex, $haystack);
        }
        return $result;
    }

    protected function getBrowserInfo($userAgent) {
        return \TYPO3\CMS\Core\Utility\ClientUtility::getBrowserInfo($userAgent);
    }

    protected function getDeviceType($userAgent) {
        return \TYPO3\CMS\Core\Utility\ClientUtility::getDeviceType($userAgent);
    }

    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;
        } else {
            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);

}