You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

369 lines
10 KiB

1 year ago
<?php declare(strict_types = 0);
/*
** Zabbix
** Copyright (C) 2001-2023 Zabbix SIA
**
** This program is free software; you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation; either version 2 of the License, or
** (at your option) any later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program; if not, write to the Free Software
** Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
**/
/**
* Class for validating trigger expressions and calculated item formulas.
*/
class CExpressionValidator extends CValidator {
/**
* An options array.
*
* Supported options:
* 'usermacros' => false Enable user macros usage in function parameters.
* 'lldmacros' => false Enable low-level discovery macros usage in function parameters.
* 'calculated' => false Validate expression as part of calculated item formula.
* 'partial' => false Validate partial expression (relaxed requirements).
*
* @var array
*/
private $options = [
'usermacros' => false,
'lldmacros' => false,
'calculated' => false,
'partial' => false
];
/**
* Provider of information on math functions.
*
* @var CMathFunctionData
*/
private $math_function_data;
/**
* Known math functions along with number or range of required parameters.
*
* @var array
*/
private $math_function_parameters = [];
/**
* Known math functions along with additional requirements for usage in expressions.
*
* @var array
*/
private $math_function_expression_rules = [];
/**
* Provider of information on history functions.
*
* @var CHistFunctionData
*/
private $hist_function_data;
/**
* Known history functions along with definition of parameters.
*
* @var array
*/
private $hist_function_parameters = [];
/**
* Known history functions along with additional requirements for usage in expressions.
*
* @var array
*/
private $hist_function_expression_rules = [];
/**
* @param array $options
*/
public function __construct(array $options = []) {
$this->options = $options + $this->options;
$this->math_function_data = new CMathFunctionData(['calculated' => $this->options['calculated']]);
$this->math_function_parameters = $this->math_function_data->getParameters();
$this->math_function_expression_rules = $this->math_function_data->getExpressionRules();
$this->hist_function_data = new CHistFunctionData(['calculated' => $this->options['calculated']]);
$this->hist_function_parameters = $this->hist_function_data->getParameters();
$this->hist_function_expression_rules = $this->hist_function_data->getExpressionRules();
}
/**
* Validate expression.
*
* @param array $tokens A hierarchy of tokens of parsed expression.
*
* @return bool
*/
public function validate($tokens) {
if (!$this->validateRecursively($tokens, null, null)) {
return false;
}
if (!$this->options['calculated']) {
if (!$this->options['partial'] && !self::hasHistoryFunctions($tokens)) {
$this->setError(_('trigger expression must contain at least one /host/key reference'));
return false;
}
}
return true;
}
/**
* Validate expression (recursive helper).
*
* @param array $tokens A hierarchy of tokens.
* @param array|null $parent_token Parent token containing the hierarchy of tokens.
* @param int|null $position The parameter number in the math function.
*
* @return bool
*/
private function validateRecursively(array $tokens, ?array $parent_token, ?int $position): bool {
foreach ($tokens as $token) {
switch ($token['type']) {
case CExpressionParserResult::TOKEN_TYPE_MATH_FUNCTION:
if (!$this->math_function_data->isKnownFunction($token['data']['function'])
&& $this->hist_function_data->isKnownFunction($token['data']['function'])) {
$this->setError(_s('incorrect usage of function "%1$s"', $token['data']['function']));
return false;
}
$math_function_validator = new CMathFunctionValidator([
'parameters' => $this->math_function_parameters
]);
if (!$math_function_validator->validate($token)) {
$this->setError($math_function_validator->getError());
return false;
}
if (!$this->validateMathFunctionExpressionRules($token)) {
$this->setError(_s('incorrect usage of function "%1$s"', $token['data']['function']));
return false;
}
foreach ($token['data']['parameters'] as $position => $parameter) {
if (!$this->validateRecursively($parameter['data']['tokens'], $token, $position)) {
return false;
}
}
break;
case CExpressionParserResult::TOKEN_TYPE_HIST_FUNCTION:
if (!$this->hist_function_data->isKnownFunction($token['data']['function'])
&& $this->math_function_data->isKnownFunction($token['data']['function'])) {
$this->setError(_s('incorrect usage of function "%1$s"', $token['data']['function']));
return false;
}
$options = [
'parameters' => $this->hist_function_parameters,
'usermacros' => $this->options['usermacros'],
'lldmacros' => $this->options['lldmacros'],
'calculated' => $this->options['calculated']
];
if ($this->options['calculated']) {
$options['aggregating'] = $this->hist_function_data->isAggregating($token['data']['function']);
}
$hist_function_validator = new CHistFunctionValidator($options);
if (!$hist_function_validator->validate($token)) {
$this->setError($hist_function_validator->getError());
return false;
}
if (!$this->validateHistFunctionExpressionRules($token, $parent_token, $position)) {
$this->setError(_s('incorrect usage of function "%1$s"', $token['data']['function']));
return false;
}
break;
}
}
return true;
}
/**
* @param array $token
*
* @return bool
*/
private function validateMathFunctionExpressionRules(array $token): bool {
if (!array_key_exists($token['data']['function'], $this->math_function_expression_rules)) {
return true;
}
foreach ($this->math_function_expression_rules[$token['data']['function']] as $rule_set) {
if (array_key_exists('if', $rule_set)) {
if (array_key_exists('parameters', $rule_set['if'])) {
if (array_key_exists('count', $rule_set['if']['parameters'])
&& count($token['data']['parameters']) != $rule_set['if']['parameters']['count']) {
continue;
}
if (array_key_exists('min', $rule_set['if']['parameters'])
&& count($token['data']['parameters']) < $rule_set['if']['parameters']['min']) {
continue;
}
if (array_key_exists('max', $rule_set['if']['parameters'])
&& count($token['data']['parameters']) > $rule_set['if']['parameters']['max']) {
continue;
}
}
}
foreach ($rule_set['rules'] as $rule) {
switch ($rule['type']) {
case 'require_history_child':
$tokens = $token['data']['parameters'][$rule['position']]['data']['tokens'];
if (count($tokens) != 1
|| $tokens[0]['type'] != CExpressionParserResult::TOKEN_TYPE_HIST_FUNCTION) {
return false;
}
if (array_key_exists('in', $rule) && !in_array($tokens[0]['data']['function'], $rule['in'])) {
return false;
}
break;
case 'regexp':
$tokens = $token['data']['parameters'][$rule['position']]['data']['tokens'];
if (preg_match($rule['pattern'], CHistFunctionParser::unquoteParam($tokens[0]['match'])) != 1) {
return false;
}
break;
default:
return false;
}
}
}
return true;
}
/**
* @param array $token
* @param array|null $parent_token
* @param int|null $position
*
* @return bool
*/
private function validateHistFunctionExpressionRules(array $token, ?array $parent_token, ?int $position): bool {
if (!array_key_exists($token['data']['function'], $this->hist_function_expression_rules)) {
return true;
}
$is_valid = true;
foreach ($this->hist_function_expression_rules[$token['data']['function']] as $rule) {
switch ($rule['type']) {
case 'require_math_parent':
if ($parent_token === null
|| $parent_token['type'] != CExpressionParserResult::TOKEN_TYPE_MATH_FUNCTION) {
$is_valid = false;
break;
}
if (array_key_exists('in', $rule) && !in_array($parent_token['data']['function'], $rule['in'])) {
$is_valid = false;
break;
}
if (array_key_exists('parameters', $rule)) {
if (array_key_exists('count', $rule['parameters'])
&& count($parent_token['data']['parameters']) != $rule['parameters']['count']) {
$is_valid = false;
break;
}
if (array_key_exists('min', $rule['parameters'])
&& count($parent_token['data']['parameters']) < $rule['parameters']['min']) {
$is_valid = false;
break;
}
if (array_key_exists('max', $rule['parameters'])
&& count($parent_token['data']['parameters']) > $rule['parameters']['max']) {
$is_valid = false;
break;
}
}
if (array_key_exists('position', $rule) && $position != $rule['position']) {
$is_valid = false;
break;
}
return true;
default:
$is_valid = false;
break;
}
}
return $is_valid;
}
/**
* Check if there are history function tokens within the hierarchy of given tokens.
*
* @param array $tokens
*
* @static
*
* @return bool
*/
private static function hasHistoryFunctions(array $tokens): bool {
foreach ($tokens as $token) {
switch ($token['type']) {
case CExpressionParserResult::TOKEN_TYPE_MATH_FUNCTION:
foreach ($token['data']['parameters'] as $parameter) {
if (self::hasHistoryFunctions($parameter['data']['tokens'])) {
return true;
}
}
break;
case CExpressionParserResult::TOKEN_TYPE_HIST_FUNCTION:
return true;
case CExpressionParserResult::TOKEN_TYPE_EXPRESSION:
return self::hasHistoryFunctions($token['data']['tokens']);
}
}
return false;
}
}