github_mirrors/ModSecurity
3
0
Fork 1
mirror of https://github.com/owasp-modsecurity/ModSecurity.git synced 2025-08-14 13:56:01 +03:00
Code Issues Packages Projects Releases Wiki Activity

Renames namespace Variables to variables

Browse Source
This commit is contained in:
Felipe Zimmerle 2019-03-06 15:53:20 -03:00
parent b9ed150224
commit 4e76c6adf0
No known key found for this signature in database
GPG Key ID: E6DFB08CE8B11277
138 changed files with 636 additions and 636 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
headers/modsecurity/anchored_set_variable.h
View File

@ -41,7 +41,7 @@ class Transaction;
namespace Utils { namespace Utils {
class Regex; class Regex;
} }
namespace Variables { namespace variables {
class KeyExclusions; class KeyExclusions;
} }
@ -86,7 +86,7 @@ class AnchoredSetVariable : public std::unordered_multimap<std::string,
void resolve(std::vector<const VariableValue *> *l); void resolve(std::vector<const VariableValue *> *l);
void resolve(std::vector<const VariableValue *> *l, void resolve(std::vector<const VariableValue *> *l,
Variables::KeyExclusions &ke); variables::KeyExclusions &ke);
void resolve(const std::string &key, void resolve(const std::string &key,
std::vector<const VariableValue *> *l); std::vector<const VariableValue *> *l);
@ -96,7 +96,7 @@ class AnchoredSetVariable : public std::unordered_multimap<std::string,
void resolveRegularExpression(Utils::Regex *r, void resolveRegularExpression(Utils::Regex *r,
std::vector<const VariableValue *> *l, std::vector<const VariableValue *> *l,
Variables::KeyExclusions &ke); variables::KeyExclusions &ke);
std::unique_ptr<std::string> resolveFirst(const std::string &key); std::unique_ptr<std::string> resolveFirst(const std::string &key);

14
headers/modsecurity/collection/collection.h
View File

@ -37,7 +37,7 @@ typedef struct Variable_t Variables;
#ifdef __cplusplus #ifdef __cplusplus
namespace modsecurity { namespace modsecurity {
namespace Variables { namespace variables {
class KeyExclusions; class KeyExclusions;
} }
namespace collection { namespace collection {
@ -63,10 +63,10 @@ class Collection {
std::vector<const VariableValue *> *l) = 0; std::vector<const VariableValue *> *l) = 0;
virtual void resolveMultiMatches(const std::string& var, virtual void resolveMultiMatches(const std::string& var,
std::vector<const VariableValue *> *l, std::vector<const VariableValue *> *l,
Variables::KeyExclusions &ke) = 0; variables::KeyExclusions &ke) = 0;
virtual void resolveRegularExpression(const std::string& var, virtual void resolveRegularExpression(const std::string& var,
std::vector<const VariableValue *> *l, std::vector<const VariableValue *> *l,
Variables::KeyExclusions &ke) = 0; variables::KeyExclusions &ke) = 0;
/* store */ /* store */
@ -163,7 +163,7 @@ class Collection {
/* resolveMultiMatches */ /* resolveMultiMatches */
virtual void resolveMultiMatches(const std::string& var, virtual void resolveMultiMatches(const std::string& var,
std::string compartment, std::vector<const VariableValue *> *l, std::string compartment, std::vector<const VariableValue *> *l,
Variables::KeyExclusions &ke) { variables::KeyExclusions &ke) {
std::string nkey = compartment + "::" + var; std::string nkey = compartment + "::" + var;
resolveMultiMatches(nkey, l, ke); resolveMultiMatches(nkey, l, ke);
} }
@ -172,7 +172,7 @@ class Collection {
virtual void resolveMultiMatches(const std::string& var, virtual void resolveMultiMatches(const std::string& var,
std::string compartment, std::string compartment2, std::string compartment, std::string compartment2,
std::vector<const VariableValue *> *l, std::vector<const VariableValue *> *l,
Variables::KeyExclusions &ke) { variables::KeyExclusions &ke) {
std::string nkey = compartment + "::" + compartment2 + "::" + var; std::string nkey = compartment + "::" + compartment2 + "::" + var;
resolveMultiMatches(nkey, l, ke); resolveMultiMatches(nkey, l, ke);
} }
@ -181,7 +181,7 @@ class Collection {
/* resolveRegularExpression */ /* resolveRegularExpression */
virtual void resolveRegularExpression(const std::string& var, virtual void resolveRegularExpression(const std::string& var,
std::string compartment, std::vector<const VariableValue *> *l, std::string compartment, std::vector<const VariableValue *> *l,
Variables::KeyExclusions &ke) { variables::KeyExclusions &ke) {
std::string nkey = compartment + "::" + var; std::string nkey = compartment + "::" + var;
resolveRegularExpression(nkey, l, ke); resolveRegularExpression(nkey, l, ke);
} }
@ -189,7 +189,7 @@ class Collection {
virtual void resolveRegularExpression(const std::string& var, virtual void resolveRegularExpression(const std::string& var,
std::string compartment, std::string compartment2, std::string compartment, std::string compartment2,
std::vector<const VariableValue *> *l, Variables::KeyExclusions &ke) { std::vector<const VariableValue *> *l, variables::KeyExclusions &ke) {
std::string nkey = compartment + "::" + compartment2 + "::" + var; std::string nkey = compartment + "::" + compartment2 + "::" + var;
resolveRegularExpression(nkey, l, ke); resolveRegularExpression(nkey, l, ke);
} }

12
headers/modsecurity/rule.h
View File

@ -32,7 +32,7 @@
#ifdef __cplusplus #ifdef __cplusplus
namespace modsecurity { namespace modsecurity {
namespace Variables { namespace variables {
class Variable; class Variable;
class Variables; class Variables;
} }
@ -52,7 +52,7 @@ class Operator;
class Rule { class Rule {
public: public:
Rule(operators::Operator *_op, Rule(operators::Operator *_op,
Variables::Variables *_variables, variables::Variables *_variables,
std::vector<actions::Action *> *_actions, std::vector<actions::Action *> *_actions,
std::string fileName, std::string fileName,
int lineNumber); int lineNumber);
@ -77,9 +77,9 @@ class Rule {
int *nth); int *nth);
void getVariablesExceptions(Transaction *t, void getVariablesExceptions(Transaction *t,
Variables::Variables *exclusion, Variables::Variables *addition); variables::Variables *exclusion, variables::Variables *addition);
inline void getFinalVars(Variables::Variables *vars, inline void getFinalVars(variables::Variables *vars,
Variables::Variables *eclusion, Transaction *trans); variables::Variables *eclusion, Transaction *trans);
void executeActionsAfterFullMatch(Transaction *trasn, void executeActionsAfterFullMatch(Transaction *trasn,
bool containsDisruptive, std::shared_ptr<RuleMessage> ruleMessage); bool containsDisruptive, std::shared_ptr<RuleMessage> ruleMessage);
@ -138,7 +138,7 @@ class Rule {
int m_lineNumber; int m_lineNumber;
int m_maturity; int m_maturity;
int m_phase; int m_phase;
modsecurity::Variables::Variables *m_variables; modsecurity::variables::Variables *m_variables;
operators::Operator *m_op; operators::Operator *m_op;
Rule *m_chainedRuleChild; Rule *m_chainedRuleChild;
Rule *m_chainedRuleParent; Rule *m_chainedRuleParent;

14
headers/modsecurity/rules_exceptions.h
View File

@ -38,7 +38,7 @@ namespace modsecurity {
namespace actions { namespace actions {
class Action; class Action;
} }
namespace Variables { namespace variables {
class Variable; class Variable;
} }
@ -57,15 +57,15 @@ class RulesExceptions {
bool loadRemoveRuleByTag(const std::string &msg, std::string *error); bool loadRemoveRuleByTag(const std::string &msg, std::string *error);
bool loadUpdateTargetByMsg(const std::string &msg, bool loadUpdateTargetByMsg(const std::string &msg,
std::unique_ptr<std::vector<std::unique_ptr<Variables::Variable> > > v, std::unique_ptr<std::vector<std::unique_ptr<variables::Variable> > > v,
std::string *error); std::string *error);
bool loadUpdateTargetByTag(const std::string &tag, bool loadUpdateTargetByTag(const std::string &tag,
std::unique_ptr<std::vector<std::unique_ptr<Variables::Variable> > > v, std::unique_ptr<std::vector<std::unique_ptr<variables::Variable> > > v,
std::string *error); std::string *error);
bool loadUpdateTargetById(double id, bool loadUpdateTargetById(double id,
std::unique_ptr<std::vector<std::unique_ptr<Variables::Variable> > > v, std::unique_ptr<std::vector<std::unique_ptr<variables::Variable> > > v,
std::string *error); std::string *error);
bool loadUpdateActionById(double id, bool loadUpdateActionById(double id,
@ -73,11 +73,11 @@ class RulesExceptions {
std::string *error); std::string *error);
std::unordered_multimap<std::shared_ptr<std::string>, std::unordered_multimap<std::shared_ptr<std::string>,
std::shared_ptr<Variables::Variable>> m_variable_update_target_by_tag; std::shared_ptr<variables::Variable>> m_variable_update_target_by_tag;
std::unordered_multimap<std::shared_ptr<std::string>, std::unordered_multimap<std::shared_ptr<std::string>,
std::shared_ptr<Variables::Variable>> m_variable_update_target_by_msg; std::shared_ptr<variables::Variable>> m_variable_update_target_by_msg;
std::unordered_multimap<double, std::unordered_multimap<double,
std::shared_ptr<Variables::Variable>> m_variable_update_target_by_id; std::shared_ptr<variables::Variable>> m_variable_update_target_by_id;
std::unordered_multimap<double, std::unordered_multimap<double,
std::shared_ptr<actions::Action>> m_action_pre_update_target_by_id; std::shared_ptr<actions::Action>> m_action_pre_update_target_by_id;
std::unordered_multimap<double, std::unordered_multimap<double,

24
src/actions/set_var.cc
View File

@ -52,18 +52,18 @@ bool SetVar::evaluate(Rule *rule, Transaction *t) {
std::vector<const VariableValue *> l; std::vector<const VariableValue *> l;
auto *v = m_variable.get(); auto *v = m_variable.get();
Variables::Tx_DynamicElement *tx = dynamic_cast< variables::Tx_DynamicElement *tx = dynamic_cast<
Variables::Tx_DynamicElement *> (v); variables::Tx_DynamicElement *> (v);
Variables::Session_DynamicElement *session = dynamic_cast< variables::Session_DynamicElement *session = dynamic_cast<
Variables::Session_DynamicElement *> (v); variables::Session_DynamicElement *> (v);
Variables::Ip_DynamicElement *ip = dynamic_cast< variables::Ip_DynamicElement *ip = dynamic_cast<
Variables::Ip_DynamicElement *> (v); variables::Ip_DynamicElement *> (v);
Variables::Resource_DynamicElement *resource = dynamic_cast< variables::Resource_DynamicElement *resource = dynamic_cast<
Variables::Resource_DynamicElement *> (v); variables::Resource_DynamicElement *> (v);
Variables::Global_DynamicElement *global = dynamic_cast< variables::Global_DynamicElement *global = dynamic_cast<
Variables::Global_DynamicElement *> (v); variables::Global_DynamicElement *> (v);
Variables::User_DynamicElement *user = dynamic_cast< variables::User_DynamicElement *user = dynamic_cast<
Variables::User_DynamicElement *> (v); variables::User_DynamicElement *> (v);
if (tx) { if (tx) {
m_variableNameExpanded = tx->m_string->evaluate(t, rule); m_variableNameExpanded = tx->m_string->evaluate(t, rule);
} else if (session) { } else if (session) {

6
src/actions/set_var.h
View File

@ -45,7 +45,7 @@ enum SetVarOperation {
class SetVar : public Action { class SetVar : public Action {
public: public:
SetVar(SetVarOperation operation, SetVar(SetVarOperation operation,
std::unique_ptr<modsecurity::Variables::Variable> variable, std::unique_ptr<modsecurity::variables::Variable> variable,
std::unique_ptr<RunTimeString> predicate) std::unique_ptr<RunTimeString> predicate)
: Action("setvar"), : Action("setvar"),
m_operation(operation), m_operation(operation),
@ -53,7 +53,7 @@ class SetVar : public Action {
m_string(std::move(predicate)) { } m_string(std::move(predicate)) { }
SetVar(SetVarOperation operation, SetVar(SetVarOperation operation,
std::unique_ptr<modsecurity::Variables::Variable> variable) std::unique_ptr<modsecurity::variables::Variable> variable)
: Action("setvar"), : Action("setvar"),
m_operation(operation), m_operation(operation),
m_variable(std::move(variable)) { } m_variable(std::move(variable)) { }
@ -63,7 +63,7 @@ class SetVar : public Action {
private: private:
SetVarOperation m_operation; SetVarOperation m_operation;
std::unique_ptr<modsecurity::Variables::Variable> m_variable; std::unique_ptr<modsecurity::variables::Variable> m_variable;
std::unique_ptr<RunTimeString> m_string; std::unique_ptr<RunTimeString> m_string;
}; };

4
src/anchored_set_variable.cc
View File

@ -91,7 +91,7 @@ void AnchoredSetVariable::resolve(
void AnchoredSetVariable::resolve( void AnchoredSetVariable::resolve(
std::vector<const VariableValue *> *l, std::vector<const VariableValue *> *l,
Variables::KeyExclusions &ke) { variables::KeyExclusions &ke) {
for (const auto& x : *this) { for (const auto& x : *this) {
if (!ke.toOmit(x.first)) { if (!ke.toOmit(x.first)) {
l->insert(l->begin(), new VariableValue(x.second)); l->insert(l->begin(), new VariableValue(x.second));
@ -138,7 +138,7 @@ void AnchoredSetVariable::resolveRegularExpression(Utils::Regex *r,
void AnchoredSetVariable::resolveRegularExpression(Utils::Regex *r, void AnchoredSetVariable::resolveRegularExpression(Utils::Regex *r,
std::vector<const VariableValue *> *l, std::vector<const VariableValue *> *l,
Variables::KeyExclusions &ke) { variables::KeyExclusions &ke) {
for (const auto& x : *this) { for (const auto& x : *this) {
int ret = Utils::regex_search(x.first, *r); int ret = Utils::regex_search(x.first, *r);
if (ret <= 0) { if (ret <= 0) {

4
src/collection/backend/in_memory-per_process.cc
View File

@ -96,7 +96,7 @@ void InMemoryPerProcess::resolveSingleMatch(const std::string& var,
void InMemoryPerProcess::resolveMultiMatches(const std::string& var, void InMemoryPerProcess::resolveMultiMatches(const std::string& var,
std::vector<const VariableValue *> *l, Variables::KeyExclusions &ke) { std::vector<const VariableValue *> *l, variables::KeyExclusions &ke) {
size_t keySize = var.size(); size_t keySize = var.size();
l->reserve(15); l->reserve(15);
@ -122,7 +122,7 @@ void InMemoryPerProcess::resolveMultiMatches(const std::string& var,
void InMemoryPerProcess::resolveRegularExpression(const std::string& var, void InMemoryPerProcess::resolveRegularExpression(const std::string& var,
std::vector<const VariableValue *> *l, Variables::KeyExclusions &ke) { std::vector<const VariableValue *> *l, variables::KeyExclusions &ke) {
//if (var.find(":") == std::string::npos) { //if (var.find(":") == std::string::npos) {
// return; // return;

4
src/collection/backend/in_memory-per_process.h
View File

@ -90,10 +90,10 @@ class InMemoryPerProcess :
std::vector<const VariableValue *> *l) override; std::vector<const VariableValue *> *l) override;
void resolveMultiMatches(const std::string& var, void resolveMultiMatches(const std::string& var,
std::vector<const VariableValue *> *l, std::vector<const VariableValue *> *l,
Variables::KeyExclusions &ke) override; variables::KeyExclusions &ke) override;
void resolveRegularExpression(const std::string& var, void resolveRegularExpression(const std::string& var,
std::vector<const VariableValue *> *l, std::vector<const VariableValue *> *l,
Variables::KeyExclusions &ke) override; variables::KeyExclusions &ke) override;
private: private:
pthread_mutex_t m_lock; pthread_mutex_t m_lock;

4
src/collection/backend/lmdb.cc
View File

@ -467,7 +467,7 @@ end_txn:
void LMDB::resolveMultiMatches(const std::string& var, void LMDB::resolveMultiMatches(const std::string& var,
std::vector<const VariableValue *> *l, std::vector<const VariableValue *> *l,
Variables::KeyExclusions &ke) { variables::KeyExclusions &ke) {
MDB_val key, data; MDB_val key, data;
MDB_txn *txn = NULL; MDB_txn *txn = NULL;
MDB_dbi dbi; MDB_dbi dbi;
@ -529,7 +529,7 @@ end_txn:
void LMDB::resolveRegularExpression(const std::string& var, void LMDB::resolveRegularExpression(const std::string& var,
std::vector<const VariableValue *> *l, std::vector<const VariableValue *> *l,
Variables::KeyExclusions &ke) { variables::KeyExclusions &ke) {
MDB_val key, data; MDB_val key, data;
MDB_txn *txn = NULL; MDB_txn *txn = NULL;
MDB_dbi dbi; MDB_dbi dbi;

4
src/collection/backend/lmdb.h
View File

@ -69,10 +69,10 @@ class LMDB :
std::vector<const VariableValue *> *l) override; std::vector<const VariableValue *> *l) override;
void resolveMultiMatches(const std::string& var, void resolveMultiMatches(const std::string& var,
std::vector<const VariableValue *> *l, std::vector<const VariableValue *> *l,
Variables::KeyExclusions &ke) override; variables::KeyExclusions &ke) override;
void resolveRegularExpression(const std::string& var, void resolveRegularExpression(const std::string& var,
std::vector<const VariableValue *> *l, std::vector<const VariableValue *> *l,
Variables::KeyExclusions &ke) override; variables::KeyExclusions &ke) override;
private: private:
void string2val(const std::string& str, MDB_val *val); void string2val(const std::string& str, MDB_val *val);

4
src/engine/lua.cc
View File

@ -258,7 +258,7 @@ int Lua::getvar(lua_State *L) {
z = const_cast<void *>(lua_topointer(L, -1)); z = const_cast<void *>(lua_topointer(L, -1));
t = reinterpret_cast<Transaction *>(z); t = reinterpret_cast<Transaction *>(z);
std::string var = Variables::Variable::stringMatchResolve(t, varname); std::string var = variables::Variable::stringMatchResolve(t, varname);
var = applyTransformations(L, t, 2, var); var = applyTransformations(L, t, 2, var);
if (var.size() == 0) { if (var.size() == 0) {
@ -286,7 +286,7 @@ int Lua::getvars(lua_State *L) {
z = const_cast<void *>(lua_topointer(L, -1)); z = const_cast<void *>(lua_topointer(L, -1));
t = reinterpret_cast<Transaction *>(z); t = reinterpret_cast<Transaction *>(z);
Variables::Variable::stringMatchResolveMulti(t, varname, &l); variables::Variable::stringMatchResolveMulti(t, varname, &l);
lua_newtable(L); lua_newtable(L);
for (auto i : l) { for (auto i : l) {

318
src/parser/seclang-parser.cc
View File

File diff suppressed because it is too large Load Diff

2
src/parser/seclang-parser.hh
View File

@ -296,7 +296,7 @@ class Driver;
using namespace modsecurity; using namespace modsecurity;
using namespace modsecurity::Variables; using namespace modsecurity::variables;
using namespace modsecurity::Utils; using namespace modsecurity::Utils;
using namespace modsecurity::operators; using namespace modsecurity::operators;

320
src/parser/seclang-parser.yy
View File

@ -258,7 +258,7 @@ class Driver;
using namespace modsecurity; using namespace modsecurity;
using namespace modsecurity::Variables; using namespace modsecurity::variables;
using namespace modsecurity::Utils; using namespace modsecurity::Utils;
using namespace modsecurity::operators; using namespace modsecurity::operators;
@ -1063,7 +1063,7 @@ expression:
for (auto &i : *$4.get()) { for (auto &i : *$4.get()) {
a->push_back(i.release()); a->push_back(i.release());
} }
Variables::Variables *v = new Variables::Variables(); variables::Variables *v = new variables::Variables();
for (auto &i : *$2.get()) { for (auto &i : *$2.get()) {
v->push_back(i.release()); v->push_back(i.release());
} }
@ -1084,7 +1084,7 @@ expression:
} }
| DIRECTIVE variables op | DIRECTIVE variables op
{ {
Variables::Variables *v = new Variables::Variables(); variables::Variables *v = new variables::Variables();
for (auto &i : *$2.get()) { for (auto &i : *$2.get()) {
v->push_back(i.release()); v->push_back(i.release());
} }
@ -1829,635 +1829,635 @@ variables_may_be_quoted:
var: var:
VARIABLE_ARGS DICT_ELEMENT VARIABLE_ARGS DICT_ELEMENT
{ {
VARIABLE_CONTAINER($$, new Variables::Args_DictElement($2)); VARIABLE_CONTAINER($$, new variables::Args_DictElement($2));
} }
| VARIABLE_ARGS DICT_ELEMENT_REGEXP | VARIABLE_ARGS DICT_ELEMENT_REGEXP
{ {
VARIABLE_CONTAINER($$, new Variables::Args_DictElementRegexp($2)); VARIABLE_CONTAINER($$, new variables::Args_DictElementRegexp($2));
} }
| VARIABLE_ARGS | VARIABLE_ARGS
{ {
VARIABLE_CONTAINER($$, new Variables::Args_NoDictElement()); VARIABLE_CONTAINER($$, new variables::Args_NoDictElement());
} }
| VARIABLE_ARGS_POST DICT_ELEMENT | VARIABLE_ARGS_POST DICT_ELEMENT
{ {
VARIABLE_CONTAINER($$, new Variables::ArgsPost_DictElement($2)); VARIABLE_CONTAINER($$, new variables::ArgsPost_DictElement($2));
} }
| VARIABLE_ARGS_POST DICT_ELEMENT_REGEXP | VARIABLE_ARGS_POST DICT_ELEMENT_REGEXP
{ {
VARIABLE_CONTAINER($$, new Variables::ArgsPost_DictElementRegexp($2)); VARIABLE_CONTAINER($$, new variables::ArgsPost_DictElementRegexp($2));
} }
| VARIABLE_ARGS_POST | VARIABLE_ARGS_POST
{ {
VARIABLE_CONTAINER($$, new Variables::ArgsPost_NoDictElement()); VARIABLE_CONTAINER($$, new variables::ArgsPost_NoDictElement());
} }
| VARIABLE_ARGS_GET DICT_ELEMENT | VARIABLE_ARGS_GET DICT_ELEMENT
{ {
VARIABLE_CONTAINER($$, new Variables::ArgsGet_DictElement($2)); VARIABLE_CONTAINER($$, new variables::ArgsGet_DictElement($2));
} }
| VARIABLE_ARGS_GET DICT_ELEMENT_REGEXP | VARIABLE_ARGS_GET DICT_ELEMENT_REGEXP
{ {
VARIABLE_CONTAINER($$, new Variables::ArgsGet_DictElementRegexp($2)); VARIABLE_CONTAINER($$, new variables::ArgsGet_DictElementRegexp($2));
} }
| VARIABLE_ARGS_GET | VARIABLE_ARGS_GET
{ {
VARIABLE_CONTAINER($$, new Variables::ArgsGet_NoDictElement()); VARIABLE_CONTAINER($$, new variables::ArgsGet_NoDictElement());
} }
| VARIABLE_FILES_SIZES DICT_ELEMENT | VARIABLE_FILES_SIZES DICT_ELEMENT
{ {
VARIABLE_CONTAINER($$, new Variables::FilesSizes_DictElement($2)); VARIABLE_CONTAINER($$, new variables::FilesSizes_DictElement($2));
} }
| VARIABLE_FILES_SIZES DICT_ELEMENT_REGEXP | VARIABLE_FILES_SIZES DICT_ELEMENT_REGEXP
{ {
VARIABLE_CONTAINER($$, new Variables::FilesSizes_DictElementRegexp($2)); VARIABLE_CONTAINER($$, new variables::FilesSizes_DictElementRegexp($2));
} }
| VARIABLE_FILES_SIZES | VARIABLE_FILES_SIZES
{ {
VARIABLE_CONTAINER($$, new Variables::FilesSizes_NoDictElement()); VARIABLE_CONTAINER($$, new variables::FilesSizes_NoDictElement());
} }
| VARIABLE_FILES_NAMES DICT_ELEMENT | VARIABLE_FILES_NAMES DICT_ELEMENT
{ {
VARIABLE_CONTAINER($$, new Variables::FilesNames_DictElement($2)); VARIABLE_CONTAINER($$, new variables::FilesNames_DictElement($2));
} }
| VARIABLE_FILES_NAMES DICT_ELEMENT_REGEXP | VARIABLE_FILES_NAMES DICT_ELEMENT_REGEXP
{ {
VARIABLE_CONTAINER($$, new Variables::FilesNames_DictElementRegexp($2)); VARIABLE_CONTAINER($$, new variables::FilesNames_DictElementRegexp($2));
} }
| VARIABLE_FILES_NAMES | VARIABLE_FILES_NAMES
{ {
VARIABLE_CONTAINER($$, new Variables::FilesNames_NoDictElement()); VARIABLE_CONTAINER($$, new variables::FilesNames_NoDictElement());
} }
| VARIABLE_FILES_TMP_CONTENT DICT_ELEMENT | VARIABLE_FILES_TMP_CONTENT DICT_ELEMENT
{ {
VARIABLE_CONTAINER($$, new Variables::FilesTmpContent_DictElement($2)); VARIABLE_CONTAINER($$, new variables::FilesTmpContent_DictElement($2));
} }
| VARIABLE_FILES_TMP_CONTENT DICT_ELEMENT_REGEXP | VARIABLE_FILES_TMP_CONTENT DICT_ELEMENT_REGEXP
{ {
VARIABLE_CONTAINER($$, new Variables::FilesTmpContent_DictElementRegexp($2)); VARIABLE_CONTAINER($$, new variables::FilesTmpContent_DictElementRegexp($2));
} }
| VARIABLE_FILES_TMP_CONTENT | VARIABLE_FILES_TMP_CONTENT
{ {
VARIABLE_CONTAINER($$, new Variables::FilesTmpContent_NoDictElement()); VARIABLE_CONTAINER($$, new variables::FilesTmpContent_NoDictElement());
} }
| VARIABLE_MULTIPART_FILENAME DICT_ELEMENT | VARIABLE_MULTIPART_FILENAME DICT_ELEMENT
{ {
VARIABLE_CONTAINER($$, new Variables::MultiPartFileName_DictElement($2)); VARIABLE_CONTAINER($$, new variables::MultiPartFileName_DictElement($2));
} }
| VARIABLE_MULTIPART_FILENAME DICT_ELEMENT_REGEXP | VARIABLE_MULTIPART_FILENAME DICT_ELEMENT_REGEXP
{ {
VARIABLE_CONTAINER($$, new Variables::MultiPartFileName_DictElementRegexp($2)); VARIABLE_CONTAINER($$, new variables::MultiPartFileName_DictElementRegexp($2));
} }
| VARIABLE_MULTIPART_FILENAME | VARIABLE_MULTIPART_FILENAME
{ {
VARIABLE_CONTAINER($$, new Variables::MultiPartFileName_NoDictElement()); VARIABLE_CONTAINER($$, new variables::MultiPartFileName_NoDictElement());
} }
| VARIABLE_MULTIPART_NAME DICT_ELEMENT | VARIABLE_MULTIPART_NAME DICT_ELEMENT
{ {
VARIABLE_CONTAINER($$, new Variables::MultiPartName_DictElement($2)); VARIABLE_CONTAINER($$, new variables::MultiPartName_DictElement($2));
} }
| VARIABLE_MULTIPART_NAME DICT_ELEMENT_REGEXP | VARIABLE_MULTIPART_NAME DICT_ELEMENT_REGEXP
{ {
VARIABLE_CONTAINER($$, new Variables::MultiPartName_DictElementRegexp($2)); VARIABLE_CONTAINER($$, new variables::MultiPartName_DictElementRegexp($2));
} }
| VARIABLE_MULTIPART_NAME | VARIABLE_MULTIPART_NAME
{ {
VARIABLE_CONTAINER($$, new Variables::MultiPartName_NoDictElement()); VARIABLE_CONTAINER($$, new variables::MultiPartName_NoDictElement());
} }
| VARIABLE_MATCHED_VARS_NAMES DICT_ELEMENT | VARIABLE_MATCHED_VARS_NAMES DICT_ELEMENT
{ {
VARIABLE_CONTAINER($$, new Variables::MatchedVarsNames_DictElement($2)); VARIABLE_CONTAINER($$, new variables::MatchedVarsNames_DictElement($2));
} }
| VARIABLE_MATCHED_VARS_NAMES DICT_ELEMENT_REGEXP | VARIABLE_MATCHED_VARS_NAMES DICT_ELEMENT_REGEXP
{ {
VARIABLE_CONTAINER($$, new Variables::MatchedVarsNames_DictElementRegexp($2)); VARIABLE_CONTAINER($$, new variables::MatchedVarsNames_DictElementRegexp($2));
} }
| VARIABLE_MATCHED_VARS_NAMES | VARIABLE_MATCHED_VARS_NAMES
{ {
VARIABLE_CONTAINER($$, new Variables::MatchedVarsNames_NoDictElement()); VARIABLE_CONTAINER($$, new variables::MatchedVarsNames_NoDictElement());
} }
| VARIABLE_MATCHED_VARS DICT_ELEMENT | VARIABLE_MATCHED_VARS DICT_ELEMENT
{ {
VARIABLE_CONTAINER($$, new Variables::MatchedVars_DictElement($2)); VARIABLE_CONTAINER($$, new variables::MatchedVars_DictElement($2));
} }
| VARIABLE_MATCHED_VARS DICT_ELEMENT_REGEXP | VARIABLE_MATCHED_VARS DICT_ELEMENT_REGEXP
{ {
VARIABLE_CONTAINER($$, new Variables::MatchedVars_DictElementRegexp($2)); VARIABLE_CONTAINER($$, new variables::MatchedVars_DictElementRegexp($2));
} }
| VARIABLE_MATCHED_VARS | VARIABLE_MATCHED_VARS
{ {
VARIABLE_CONTAINER($$, new Variables::MatchedVars_NoDictElement()); VARIABLE_CONTAINER($$, new variables::MatchedVars_NoDictElement());
} }
| VARIABLE_FILES DICT_ELEMENT | VARIABLE_FILES DICT_ELEMENT
{ {
VARIABLE_CONTAINER($$, new Variables::Files_DictElement($2)); VARIABLE_CONTAINER($$, new variables::Files_DictElement($2));
} }
| VARIABLE_FILES DICT_ELEMENT_REGEXP | VARIABLE_FILES DICT_ELEMENT_REGEXP
{ {
VARIABLE_CONTAINER($$, new Variables::Files_DictElementRegexp($2)); VARIABLE_CONTAINER($$, new variables::Files_DictElementRegexp($2));
} }
| VARIABLE_FILES | VARIABLE_FILES
{ {
VARIABLE_CONTAINER($$, new Variables::Files_NoDictElement()); VARIABLE_CONTAINER($$, new variables::Files_NoDictElement());
} }
| VARIABLE_REQUEST_COOKIES DICT_ELEMENT | VARIABLE_REQUEST_COOKIES DICT_ELEMENT
{ {
VARIABLE_CONTAINER($$, new Variables::RequestCookies_DictElement($2)); VARIABLE_CONTAINER($$, new variables::RequestCookies_DictElement($2));
} }
| VARIABLE_REQUEST_COOKIES DICT_ELEMENT_REGEXP | VARIABLE_REQUEST_COOKIES DICT_ELEMENT_REGEXP
{ {
VARIABLE_CONTAINER($$, new Variables::RequestCookies_DictElementRegexp($2)); VARIABLE_CONTAINER($$, new variables::RequestCookies_DictElementRegexp($2));
} }
| VARIABLE_REQUEST_COOKIES | VARIABLE_REQUEST_COOKIES
{ {
VARIABLE_CONTAINER($$, new Variables::RequestCookies_NoDictElement()); VARIABLE_CONTAINER($$, new variables::RequestCookies_NoDictElement());
} }
| VARIABLE_REQUEST_HEADERS DICT_ELEMENT | VARIABLE_REQUEST_HEADERS DICT_ELEMENT
{ {
VARIABLE_CONTAINER($$, new Variables::RequestHeaders_DictElement($2)); VARIABLE_CONTAINER($$, new variables::RequestHeaders_DictElement($2));
} }
| VARIABLE_REQUEST_HEADERS DICT_ELEMENT_REGEXP | VARIABLE_REQUEST_HEADERS DICT_ELEMENT_REGEXP
{ {
VARIABLE_CONTAINER($$, new Variables::RequestHeaders_DictElementRegexp($2)); VARIABLE_CONTAINER($$, new variables::RequestHeaders_DictElementRegexp($2));
} }
| VARIABLE_REQUEST_HEADERS | VARIABLE_REQUEST_HEADERS
{ {
VARIABLE_CONTAINER($$, new Variables::RequestHeaders_NoDictElement()); VARIABLE_CONTAINER($$, new variables::RequestHeaders_NoDictElement());
} }
| VARIABLE_RESPONSE_HEADERS DICT_ELEMENT | VARIABLE_RESPONSE_HEADERS DICT_ELEMENT
{ {
VARIABLE_CONTAINER($$, new Variables::ResponseHeaders_DictElement($2)); VARIABLE_CONTAINER($$, new variables::ResponseHeaders_DictElement($2));
} }
| VARIABLE_RESPONSE_HEADERS DICT_ELEMENT_REGEXP | VARIABLE_RESPONSE_HEADERS DICT_ELEMENT_REGEXP
{ {
VARIABLE_CONTAINER($$, new Variables::ResponseHeaders_DictElementRegexp($2)); VARIABLE_CONTAINER($$, new variables::ResponseHeaders_DictElementRegexp($2));
} }
| VARIABLE_RESPONSE_HEADERS | VARIABLE_RESPONSE_HEADERS
{ {
VARIABLE_CONTAINER($$, new Variables::ResponseHeaders_NoDictElement()); VARIABLE_CONTAINER($$, new variables::ResponseHeaders_NoDictElement());
} }
| VARIABLE_GEO DICT_ELEMENT | VARIABLE_GEO DICT_ELEMENT
{ {
VARIABLE_CONTAINER($$, new Variables::Geo_DictElement($2)); VARIABLE_CONTAINER($$, new variables::Geo_DictElement($2));
} }
| VARIABLE_GEO DICT_ELEMENT_REGEXP | VARIABLE_GEO DICT_ELEMENT_REGEXP
{ {
VARIABLE_CONTAINER($$, new Variables::Geo_DictElementRegexp($2)); VARIABLE_CONTAINER($$, new variables::Geo_DictElementRegexp($2));
} }
| VARIABLE_GEO | VARIABLE_GEO
{ {
VARIABLE_CONTAINER($$, new Variables::Geo_NoDictElement()); VARIABLE_CONTAINER($$, new variables::Geo_NoDictElement());
} }
| VARIABLE_REQUEST_COOKIES_NAMES DICT_ELEMENT | VARIABLE_REQUEST_COOKIES_NAMES DICT_ELEMENT
{ {
VARIABLE_CONTAINER($$, new Variables::RequestCookiesNames_DictElement($2)); VARIABLE_CONTAINER($$, new variables::RequestCookiesNames_DictElement($2));
} }
| VARIABLE_REQUEST_COOKIES_NAMES DICT_ELEMENT_REGEXP | VARIABLE_REQUEST_COOKIES_NAMES DICT_ELEMENT_REGEXP
{ {
VARIABLE_CONTAINER($$, new Variables::RequestCookiesNames_DictElementRegexp($2)); VARIABLE_CONTAINER($$, new variables::RequestCookiesNames_DictElementRegexp($2));
} }
| VARIABLE_REQUEST_COOKIES_NAMES | VARIABLE_REQUEST_COOKIES_NAMES
{ {
VARIABLE_CONTAINER($$, new Variables::RequestCookiesNames_NoDictElement()); VARIABLE_CONTAINER($$, new variables::RequestCookiesNames_NoDictElement());
} }
| VARIABLE_RULE DICT_ELEMENT | VARIABLE_RULE DICT_ELEMENT
{ {
VARIABLE_CONTAINER($$, new Variables::Rule_DictElement($2)); VARIABLE_CONTAINER($$, new variables::Rule_DictElement($2));
} }
| VARIABLE_RULE DICT_ELEMENT_REGEXP | VARIABLE_RULE DICT_ELEMENT_REGEXP
{ {
VARIABLE_CONTAINER($$, new Variables::Rule_DictElementRegexp($2)); VARIABLE_CONTAINER($$, new variables::Rule_DictElementRegexp($2));
} }
| VARIABLE_RULE | VARIABLE_RULE
{ {
VARIABLE_CONTAINER($$, new Variables::Rule_NoDictElement()); VARIABLE_CONTAINER($$, new variables::Rule_NoDictElement());
} }
| RUN_TIME_VAR_ENV DICT_ELEMENT | RUN_TIME_VAR_ENV DICT_ELEMENT
{ {
VARIABLE_CONTAINER($$, new Variables::Env("ENV:" + $2)); VARIABLE_CONTAINER($$, new variables::Env("ENV:" + $2));
} }
| RUN_TIME_VAR_ENV DICT_ELEMENT_REGEXP | RUN_TIME_VAR_ENV DICT_ELEMENT_REGEXP
{ {
VARIABLE_CONTAINER($$, new Variables::Env("ENV:" + $2)); VARIABLE_CONTAINER($$, new variables::Env("ENV:" + $2));
} }
| RUN_TIME_VAR_ENV | RUN_TIME_VAR_ENV
{ {
VARIABLE_CONTAINER($$, new Variables::Env("ENV")); VARIABLE_CONTAINER($$, new variables::Env("ENV"));
} }
| RUN_TIME_VAR_XML DICT_ELEMENT | RUN_TIME_VAR_XML DICT_ELEMENT
{ {
VARIABLE_CONTAINER($$, new Variables::XML("XML:" + $2)); VARIABLE_CONTAINER($$, new variables::XML("XML:" + $2));
} }
| RUN_TIME_VAR_XML DICT_ELEMENT_REGEXP | RUN_TIME_VAR_XML DICT_ELEMENT_REGEXP
{ {
VARIABLE_CONTAINER($$, new Variables::XML("XML:" + $2)); VARIABLE_CONTAINER($$, new variables::XML("XML:" + $2));
} }
| RUN_TIME_VAR_XML | RUN_TIME_VAR_XML
{ {
VARIABLE_CONTAINER($$, new Variables::XML_NoDictElement()); VARIABLE_CONTAINER($$, new variables::XML_NoDictElement());
} }
| VARIABLE_FILES_TMP_NAMES DICT_ELEMENT | VARIABLE_FILES_TMP_NAMES DICT_ELEMENT
{ {
VARIABLE_CONTAINER($$, new Variables::FilesTmpNames_DictElement($2)); VARIABLE_CONTAINER($$, new variables::FilesTmpNames_DictElement($2));
} }
| VARIABLE_FILES_TMP_NAMES DICT_ELEMENT_REGEXP | VARIABLE_FILES_TMP_NAMES DICT_ELEMENT_REGEXP
{ {
VARIABLE_CONTAINER($$, new Variables::FilesTmpNames_DictElementRegexp($2)); VARIABLE_CONTAINER($$, new variables::FilesTmpNames_DictElementRegexp($2));
} }
| VARIABLE_FILES_TMP_NAMES | VARIABLE_FILES_TMP_NAMES
{ {
VARIABLE_CONTAINER($$, new Variables::FilesTmpNames_NoDictElement()); VARIABLE_CONTAINER($$, new variables::FilesTmpNames_NoDictElement());
} }
| VARIABLE_RESOURCE run_time_string | VARIABLE_RESOURCE run_time_string
{ {
VARIABLE_CONTAINER($$, new Variables::Resource_DynamicElement(std::move($2))); VARIABLE_CONTAINER($$, new variables::Resource_DynamicElement(std::move($2)));
} }
| VARIABLE_RESOURCE DICT_ELEMENT | VARIABLE_RESOURCE DICT_ELEMENT
{ {
VARIABLE_CONTAINER($$, new Variables::Resource_DictElement($2)); VARIABLE_CONTAINER($$, new variables::Resource_DictElement($2));
} }
| VARIABLE_RESOURCE DICT_ELEMENT_REGEXP | VARIABLE_RESOURCE DICT_ELEMENT_REGEXP
{ {
VARIABLE_CONTAINER($$, new Variables::Resource_DictElementRegexp($2)); VARIABLE_CONTAINER($$, new variables::Resource_DictElementRegexp($2));
} }
| VARIABLE_RESOURCE | VARIABLE_RESOURCE
{ {
VARIABLE_CONTAINER($$, new Variables::Resource_NoDictElement()); VARIABLE_CONTAINER($$, new variables::Resource_NoDictElement());
} }
| VARIABLE_IP run_time_string | VARIABLE_IP run_time_string
{ {
VARIABLE_CONTAINER($$, new Variables::Ip_DynamicElement(std::move($2))); VARIABLE_CONTAINER($$, new variables::Ip_DynamicElement(std::move($2)));
} }
| VARIABLE_IP DICT_ELEMENT | VARIABLE_IP DICT_ELEMENT
{ {
VARIABLE_CONTAINER($$, new Variables::Ip_DictElement($2)); VARIABLE_CONTAINER($$, new variables::Ip_DictElement($2));
} }
| VARIABLE_IP DICT_ELEMENT_REGEXP | VARIABLE_IP DICT_ELEMENT_REGEXP
{ {
VARIABLE_CONTAINER($$, new Variables::Ip_DictElementRegexp($2)); VARIABLE_CONTAINER($$, new variables::Ip_DictElementRegexp($2));
} }
| VARIABLE_IP | VARIABLE_IP
{ {
VARIABLE_CONTAINER($$, new Variables::Ip_NoDictElement()); VARIABLE_CONTAINER($$, new variables::Ip_NoDictElement());
} }
| VARIABLE_GLOBAL run_time_string | VARIABLE_GLOBAL run_time_string
{ {
VARIABLE_CONTAINER($$, new Variables::Global_DynamicElement(std::move($2))); VARIABLE_CONTAINER($$, new variables::Global_DynamicElement(std::move($2)));
} }
| VARIABLE_GLOBAL DICT_ELEMENT | VARIABLE_GLOBAL DICT_ELEMENT
{ {
VARIABLE_CONTAINER($$, new Variables::Global_DictElement($2)); VARIABLE_CONTAINER($$, new variables::Global_DictElement($2));
} }
| VARIABLE_GLOBAL DICT_ELEMENT_REGEXP | VARIABLE_GLOBAL DICT_ELEMENT_REGEXP
{ {
VARIABLE_CONTAINER($$, new Variables::Global_DictElementRegexp($2)); VARIABLE_CONTAINER($$, new variables::Global_DictElementRegexp($2));
} }
| VARIABLE_GLOBAL | VARIABLE_GLOBAL
{ {
VARIABLE_CONTAINER($$, new Variables::Global_NoDictElement()); VARIABLE_CONTAINER($$, new variables::Global_NoDictElement());
} }
| VARIABLE_USER run_time_string | VARIABLE_USER run_time_string
{ {
VARIABLE_CONTAINER($$, new Variables::User_DynamicElement(std::move($2))); VARIABLE_CONTAINER($$, new variables::User_DynamicElement(std::move($2)));
} }
| VARIABLE_USER DICT_ELEMENT | VARIABLE_USER DICT_ELEMENT
{ {
VARIABLE_CONTAINER($$, new Variables::User_DictElement($2)); VARIABLE_CONTAINER($$, new variables::User_DictElement($2));
} }
| VARIABLE_USER DICT_ELEMENT_REGEXP | VARIABLE_USER DICT_ELEMENT_REGEXP
{ {
VARIABLE_CONTAINER($$, new Variables::User_DictElementRegexp($2)); VARIABLE_CONTAINER($$, new variables::User_DictElementRegexp($2));
} }
| VARIABLE_USER | VARIABLE_USER
{ {
VARIABLE_CONTAINER($$, new Variables::User_NoDictElement()); VARIABLE_CONTAINER($$, new variables::User_NoDictElement());
} }
| VARIABLE_TX run_time_string | VARIABLE_TX run_time_string
{ {
VARIABLE_CONTAINER($$, new Variables::Tx_DynamicElement(std::move($2))); VARIABLE_CONTAINER($$, new variables::Tx_DynamicElement(std::move($2)));
} }
| VARIABLE_TX DICT_ELEMENT | VARIABLE_TX DICT_ELEMENT
{ {
VARIABLE_CONTAINER($$, new Variables::Tx_DictElement($2)); VARIABLE_CONTAINER($$, new variables::Tx_DictElement($2));
} }
| VARIABLE_TX DICT_ELEMENT_REGEXP | VARIABLE_TX DICT_ELEMENT_REGEXP
{ {
VARIABLE_CONTAINER($$, new Variables::Tx_DictElementRegexp($2)); VARIABLE_CONTAINER($$, new variables::Tx_DictElementRegexp($2));
} }
| VARIABLE_TX | VARIABLE_TX
{ {
VARIABLE_CONTAINER($$, new Variables::Tx_NoDictElement()); VARIABLE_CONTAINER($$, new variables::Tx_NoDictElement());
} }
| VARIABLE_SESSION run_time_string | VARIABLE_SESSION run_time_string
{ {
VARIABLE_CONTAINER($$, new Variables::Session_DynamicElement(std::move($2))); VARIABLE_CONTAINER($$, new variables::Session_DynamicElement(std::move($2)));
} }
| VARIABLE_SESSION DICT_ELEMENT | VARIABLE_SESSION DICT_ELEMENT
{ {
VARIABLE_CONTAINER($$, new Variables::Session_DictElement($2)); VARIABLE_CONTAINER($$, new variables::Session_DictElement($2));
} }
| VARIABLE_SESSION DICT_ELEMENT_REGEXP | VARIABLE_SESSION DICT_ELEMENT_REGEXP
{ {
VARIABLE_CONTAINER($$, new Variables::Session_DictElementRegexp($2)); VARIABLE_CONTAINER($$, new variables::Session_DictElementRegexp($2));
} }
| VARIABLE_SESSION | VARIABLE_SESSION
{ {
VARIABLE_CONTAINER($$, new Variables::Session_NoDictElement()); VARIABLE_CONTAINER($$, new variables::Session_NoDictElement());
} }
| VARIABLE_ARGS_NAMES DICT_ELEMENT | VARIABLE_ARGS_NAMES DICT_ELEMENT
{ {
VARIABLE_CONTAINER($$, new Variables::ArgsNames_DictElement($2)); VARIABLE_CONTAINER($$, new variables::ArgsNames_DictElement($2));
} }
| VARIABLE_ARGS_NAMES DICT_ELEMENT_REGEXP | VARIABLE_ARGS_NAMES DICT_ELEMENT_REGEXP
{ {
VARIABLE_CONTAINER($$, new Variables::ArgsNames_DictElementRegexp($2)); VARIABLE_CONTAINER($$, new variables::ArgsNames_DictElementRegexp($2));
} }
| VARIABLE_ARGS_NAMES | VARIABLE_ARGS_NAMES
{ {
VARIABLE_CONTAINER($$, new Variables::ArgsNames_NoDictElement()); VARIABLE_CONTAINER($$, new variables::ArgsNames_NoDictElement());
} }
| VARIABLE_ARGS_GET_NAMES DICT_ELEMENT | VARIABLE_ARGS_GET_NAMES DICT_ELEMENT
{ {
VARIABLE_CONTAINER($$, new Variables::ArgsGetNames_DictElement($2)); VARIABLE_CONTAINER($$, new variables::ArgsGetNames_DictElement($2));
} }
| VARIABLE_ARGS_GET_NAMES DICT_ELEMENT_REGEXP | VARIABLE_ARGS_GET_NAMES DICT_ELEMENT_REGEXP
{ {
VARIABLE_CONTAINER($$, new Variables::ArgsGetNames_DictElementRegexp($2)); VARIABLE_CONTAINER($$, new variables::ArgsGetNames_DictElementRegexp($2));
} }
| VARIABLE_ARGS_GET_NAMES | VARIABLE_ARGS_GET_NAMES
{ {
VARIABLE_CONTAINER($$, new Variables::ArgsGetNames_NoDictElement()); VARIABLE_CONTAINER($$, new variables::ArgsGetNames_NoDictElement());
} }
| VARIABLE_ARGS_POST_NAMES DICT_ELEMENT | VARIABLE_ARGS_POST_NAMES DICT_ELEMENT
{ {
VARIABLE_CONTAINER($$, new Variables::ArgsPostNames_DictElement($2)); VARIABLE_CONTAINER($$, new variables::ArgsPostNames_DictElement($2));
} }
| VARIABLE_ARGS_POST_NAMES DICT_ELEMENT_REGEXP | VARIABLE_ARGS_POST_NAMES DICT_ELEMENT_REGEXP
{ {
VARIABLE_CONTAINER($$, new Variables::ArgsPostNames_DictElementRegexp($2)); VARIABLE_CONTAINER($$, new variables::ArgsPostNames_DictElementRegexp($2));
} }
| VARIABLE_ARGS_POST_NAMES | VARIABLE_ARGS_POST_NAMES
{ {
VARIABLE_CONTAINER($$, new Variables::ArgsPostNames_NoDictElement()); VARIABLE_CONTAINER($$, new variables::ArgsPostNames_NoDictElement());
} }
| VARIABLE_REQUEST_HEADERS_NAMES DICT_ELEMENT | VARIABLE_REQUEST_HEADERS_NAMES DICT_ELEMENT
{ {
VARIABLE_CONTAINER($$, new Variables::RequestHeadersNames_DictElement($2)); VARIABLE_CONTAINER($$, new variables::RequestHeadersNames_DictElement($2));
} }
| VARIABLE_REQUEST_HEADERS_NAMES DICT_ELEMENT_REGEXP | VARIABLE_REQUEST_HEADERS_NAMES DICT_ELEMENT_REGEXP
{ {
VARIABLE_CONTAINER($$, new Variables::RequestHeadersNames_DictElementRegexp($2)); VARIABLE_CONTAINER($$, new variables::RequestHeadersNames_DictElementRegexp($2));
} }
| VARIABLE_REQUEST_HEADERS_NAMES | VARIABLE_REQUEST_HEADERS_NAMES
{ {
VARIABLE_CONTAINER($$, new Variables::RequestHeadersNames_NoDictElement()); VARIABLE_CONTAINER($$, new variables::RequestHeadersNames_NoDictElement());
} }
| VARIABLE_RESPONSE_CONTENT_TYPE | VARIABLE_RESPONSE_CONTENT_TYPE
{ {
VARIABLE_CONTAINER($$, new Variables::ResponseContentType()); VARIABLE_CONTAINER($$, new variables::ResponseContentType());
} }
| VARIABLE_RESPONSE_HEADERS_NAMES DICT_ELEMENT | VARIABLE_RESPONSE_HEADERS_NAMES DICT_ELEMENT
{ {
VARIABLE_CONTAINER($$, new Variables::ResponseHeadersNames_DictElement($2)); VARIABLE_CONTAINER($$, new variables::ResponseHeadersNames_DictElement($2));
} }
| VARIABLE_RESPONSE_HEADERS_NAMES DICT_ELEMENT_REGEXP | VARIABLE_RESPONSE_HEADERS_NAMES DICT_ELEMENT_REGEXP
{ {
VARIABLE_CONTAINER($$, new Variables::ResponseHeadersNames_DictElementRegexp($2)); VARIABLE_CONTAINER($$, new variables::ResponseHeadersNames_DictElementRegexp($2));
} }
| VARIABLE_RESPONSE_HEADERS_NAMES | VARIABLE_RESPONSE_HEADERS_NAMES
{ {
VARIABLE_CONTAINER($$, new Variables::ResponseHeadersNames_NoDictElement()); VARIABLE_CONTAINER($$, new variables::ResponseHeadersNames_NoDictElement());
} }
| VARIABLE_ARGS_COMBINED_SIZE | VARIABLE_ARGS_COMBINED_SIZE
{ {
VARIABLE_CONTAINER($$, new Variables::ArgsCombinedSize()); VARIABLE_CONTAINER($$, new variables::ArgsCombinedSize());
} }
| VARIABLE_AUTH_TYPE | VARIABLE_AUTH_TYPE
{ {
VARIABLE_CONTAINER($$, new Variables::AuthType()); VARIABLE_CONTAINER($$, new variables::AuthType());
} }
| VARIABLE_FILES_COMBINED_SIZE | VARIABLE_FILES_COMBINED_SIZE
{ {
VARIABLE_CONTAINER($$, new Variables::FilesCombinedSize()); VARIABLE_CONTAINER($$, new variables::FilesCombinedSize());
} }
| VARIABLE_FULL_REQUEST | VARIABLE_FULL_REQUEST
{ {
VARIABLE_CONTAINER($$, new Variables::FullRequest()); VARIABLE_CONTAINER($$, new variables::FullRequest());
} }
| VARIABLE_FULL_REQUEST_LENGTH | VARIABLE_FULL_REQUEST_LENGTH
{ {
VARIABLE_CONTAINER($$, new Variables::FullRequestLength()); VARIABLE_CONTAINER($$, new variables::FullRequestLength());
} }
| VARIABLE_INBOUND_DATA_ERROR | VARIABLE_INBOUND_DATA_ERROR
{ {
VARIABLE_CONTAINER($$, new Variables::InboundDataError()); VARIABLE_CONTAINER($$, new variables::InboundDataError());
} }
| VARIABLE_MATCHED_VAR | VARIABLE_MATCHED_VAR
{ {
VARIABLE_CONTAINER($$, new Variables::MatchedVar()); VARIABLE_CONTAINER($$, new variables::MatchedVar());
} }
| VARIABLE_MATCHED_VAR_NAME | VARIABLE_MATCHED_VAR_NAME
{ {
VARIABLE_CONTAINER($$, new Variables::MatchedVarName()); VARIABLE_CONTAINER($$, new variables::MatchedVarName());
} }
| VARIABLE_MULTIPART_BOUNDARY_QUOTED | VARIABLE_MULTIPART_BOUNDARY_QUOTED
{ {
VARIABLE_CONTAINER($$, new Variables::MultipartBoundaryQuoted()); VARIABLE_CONTAINER($$, new variables::MultipartBoundaryQuoted());
} }
| VARIABLE_MULTIPART_BOUNDARY_WHITESPACE | VARIABLE_MULTIPART_BOUNDARY_WHITESPACE
{ {
VARIABLE_CONTAINER($$, new Variables::MultipartBoundaryWhiteSpace()); VARIABLE_CONTAINER($$, new variables::MultipartBoundaryWhiteSpace());
} }
| VARIABLE_MULTIPART_CRLF_LF_LINES | VARIABLE_MULTIPART_CRLF_LF_LINES
{ {
VARIABLE_CONTAINER($$, new Variables::MultipartCrlfLFLines()); VARIABLE_CONTAINER($$, new variables::MultipartCrlfLFLines());
} }
| VARIABLE_MULTIPART_DATA_AFTER | VARIABLE_MULTIPART_DATA_AFTER
{ {
VARIABLE_CONTAINER($$, new Variables::MultipartDateAfter()); VARIABLE_CONTAINER($$, new variables::MultipartDateAfter());
} }
| VARIABLE_MULTIPART_DATA_BEFORE | VARIABLE_MULTIPART_DATA_BEFORE
{ {
VARIABLE_CONTAINER($$, new Variables::MultipartDateBefore()); VARIABLE_CONTAINER($$, new variables::MultipartDateBefore());
} }
| VARIABLE_MULTIPART_FILE_LIMIT_EXCEEDED | VARIABLE_MULTIPART_FILE_LIMIT_EXCEEDED
{ {
VARIABLE_CONTAINER($$, new Variables::MultipartFileLimitExceeded()); VARIABLE_CONTAINER($$, new variables::MultipartFileLimitExceeded());
} }
| VARIABLE_MULTIPART_HEADER_FOLDING | VARIABLE_MULTIPART_HEADER_FOLDING
{ {
VARIABLE_CONTAINER($$, new Variables::MultipartHeaderFolding()); VARIABLE_CONTAINER($$, new variables::MultipartHeaderFolding());
} }
| VARIABLE_MULTIPART_INVALID_HEADER_FOLDING | VARIABLE_MULTIPART_INVALID_HEADER_FOLDING
{ {
VARIABLE_CONTAINER($$, new Variables::MultipartInvalidHeaderFolding()); VARIABLE_CONTAINER($$, new variables::MultipartInvalidHeaderFolding());
} }
| VARIABLE_MULTIPART_INVALID_PART | VARIABLE_MULTIPART_INVALID_PART
{ {
VARIABLE_CONTAINER($$, new Variables::MultipartInvalidPart()); VARIABLE_CONTAINER($$, new variables::MultipartInvalidPart());
} }
| VARIABLE_MULTIPART_INVALID_QUOTING | VARIABLE_MULTIPART_INVALID_QUOTING
{ {
VARIABLE_CONTAINER($$, new Variables::MultipartInvalidQuoting()); VARIABLE_CONTAINER($$, new variables::MultipartInvalidQuoting());
} }
| VARIABLE_MULTIPART_LF_LINE | VARIABLE_MULTIPART_LF_LINE
{ {
VARIABLE_CONTAINER($$, new Variables::MultipartLFLine()); VARIABLE_CONTAINER($$, new variables::MultipartLFLine());
} }
| VARIABLE_MULTIPART_MISSING_SEMICOLON | VARIABLE_MULTIPART_MISSING_SEMICOLON
{ {
VARIABLE_CONTAINER($$, new Variables::MultipartMissingSemicolon()); VARIABLE_CONTAINER($$, new variables::MultipartMissingSemicolon());
} }
| VARIABLE_MULTIPART_SEMICOLON_MISSING | VARIABLE_MULTIPART_SEMICOLON_MISSING
{ {
VARIABLE_CONTAINER($$, new Variables::MultipartMissingSemicolon()); VARIABLE_CONTAINER($$, new variables::MultipartMissingSemicolon());
} }
| VARIABLE_MULTIPART_STRICT_ERROR | VARIABLE_MULTIPART_STRICT_ERROR
{ {
VARIABLE_CONTAINER($$, new Variables::MultipartStrictError()); VARIABLE_CONTAINER($$, new variables::MultipartStrictError());
} }
| VARIABLE_MULTIPART_UNMATCHED_BOUNDARY | VARIABLE_MULTIPART_UNMATCHED_BOUNDARY
{ {
VARIABLE_CONTAINER($$, new Variables::MultipartUnmatchedBoundary()); VARIABLE_CONTAINER($$, new variables::MultipartUnmatchedBoundary());
} }
| VARIABLE_OUTBOUND_DATA_ERROR | VARIABLE_OUTBOUND_DATA_ERROR
{ {
VARIABLE_CONTAINER($$, new Variables::OutboundDataError()); VARIABLE_CONTAINER($$, new variables::OutboundDataError());
} }
| VARIABLE_PATH_INFO | VARIABLE_PATH_INFO
{ {
VARIABLE_CONTAINER($$, new Variables::PathInfo()); VARIABLE_CONTAINER($$, new variables::PathInfo());
} }
| VARIABLE_QUERY_STRING | VARIABLE_QUERY_STRING
{ {
VARIABLE_CONTAINER($$, new Variables::QueryString()); VARIABLE_CONTAINER($$, new variables::QueryString());
} }
| VARIABLE_REMOTE_ADDR | VARIABLE_REMOTE_ADDR
{ {
VARIABLE_CONTAINER($$, new Variables::RemoteAddr()); VARIABLE_CONTAINER($$, new variables::RemoteAddr());
} }
| VARIABLE_REMOTE_HOST | VARIABLE_REMOTE_HOST
{ {
VARIABLE_CONTAINER($$, new Variables::RemoteHost()); VARIABLE_CONTAINER($$, new variables::RemoteHost());
} }
| VARIABLE_REMOTE_PORT | VARIABLE_REMOTE_PORT
{ {
VARIABLE_CONTAINER($$, new Variables::RemotePort()); VARIABLE_CONTAINER($$, new variables::RemotePort());
} }
| VARIABLE_REQBODY_ERROR | VARIABLE_REQBODY_ERROR
{ {
VARIABLE_CONTAINER($$, new Variables::ReqbodyError()); VARIABLE_CONTAINER($$, new variables::ReqbodyError());
} }
| VARIABLE_REQBODY_ERROR_MSG | VARIABLE_REQBODY_ERROR_MSG
{ {
VARIABLE_CONTAINER($$, new Variables::ReqbodyErrorMsg()); VARIABLE_CONTAINER($$, new variables::ReqbodyErrorMsg());
} }
| VARIABLE_REQBODY_PROCESSOR | VARIABLE_REQBODY_PROCESSOR
{ {
VARIABLE_CONTAINER($$, new Variables::ReqbodyProcessor()); VARIABLE_CONTAINER($$, new variables::ReqbodyProcessor());
} }
| VARIABLE_REQBODY_PROCESSOR_ERROR | VARIABLE_REQBODY_PROCESSOR_ERROR
{ {
VARIABLE_CONTAINER($$, new Variables::ReqbodyProcessorError()); VARIABLE_CONTAINER($$, new variables::ReqbodyProcessorError());
} }
| VARIABLE_REQBODY_PROCESSOR_ERROR_MSG | VARIABLE_REQBODY_PROCESSOR_ERROR_MSG
{ {
VARIABLE_CONTAINER($$, new Variables::ReqbodyProcessorErrorMsg()); VARIABLE_CONTAINER($$, new variables::ReqbodyProcessorErrorMsg());
} }
| VARIABLE_REQUEST_BASENAME | VARIABLE_REQUEST_BASENAME
{ {
VARIABLE_CONTAINER($$, new Variables::RequestBasename()); VARIABLE_CONTAINER($$, new variables::RequestBasename());
} }
| VARIABLE_REQUEST_BODY | VARIABLE_REQUEST_BODY
{ {
VARIABLE_CONTAINER($$, new Variables::RequestBody()); VARIABLE_CONTAINER($$, new variables::RequestBody());
} }
| VARIABLE_REQUEST_BODY_LENGTH | VARIABLE_REQUEST_BODY_LENGTH
{ {
VARIABLE_CONTAINER($$, new Variables::RequestBodyLength()); VARIABLE_CONTAINER($$, new variables::RequestBodyLength());
} }
| VARIABLE_REQUEST_FILE_NAME | VARIABLE_REQUEST_FILE_NAME
{ {
VARIABLE_CONTAINER($$, new Variables::RequestFilename()); VARIABLE_CONTAINER($$, new variables::RequestFilename());
} }
| VARIABLE_REQUEST_LINE | VARIABLE_REQUEST_LINE
{ {
VARIABLE_CONTAINER($$, new Variables::RequestLine()); VARIABLE_CONTAINER($$, new variables::RequestLine());
} }
| VARIABLE_REQUEST_METHOD | VARIABLE_REQUEST_METHOD
{ {
VARIABLE_CONTAINER($$, new Variables::RequestMethod()); VARIABLE_CONTAINER($$, new variables::RequestMethod());
} }
| VARIABLE_REQUEST_PROTOCOL | VARIABLE_REQUEST_PROTOCOL
{ {
VARIABLE_CONTAINER($$, new Variables::RequestProtocol()); VARIABLE_CONTAINER($$, new variables::RequestProtocol());
} }
| VARIABLE_REQUEST_URI | VARIABLE_REQUEST_URI
{ {
VARIABLE_CONTAINER($$, new Variables::RequestURI()); VARIABLE_CONTAINER($$, new variables::RequestURI());
} }
| VARIABLE_REQUEST_URI_RAW | VARIABLE_REQUEST_URI_RAW
{ {
VARIABLE_CONTAINER($$, new Variables::RequestURIRaw()); VARIABLE_CONTAINER($$, new variables::RequestURIRaw());
} }
| VARIABLE_RESPONSE_BODY | VARIABLE_RESPONSE_BODY
{ {
VARIABLE_CONTAINER($$, new Variables::ResponseBody()); VARIABLE_CONTAINER($$, new variables::ResponseBody());
} }
| VARIABLE_RESPONSE_CONTENT_LENGTH | VARIABLE_RESPONSE_CONTENT_LENGTH
{ {
VARIABLE_CONTAINER($$, new Variables::ResponseContentLength()); VARIABLE_CONTAINER($$, new variables::ResponseContentLength());
} }
| VARIABLE_RESPONSE_PROTOCOL | VARIABLE_RESPONSE_PROTOCOL
{ {
VARIABLE_CONTAINER($$, new Variables::ResponseProtocol()); VARIABLE_CONTAINER($$, new variables::ResponseProtocol());
} }
| VARIABLE_RESPONSE_STATUS | VARIABLE_RESPONSE_STATUS
{ {
VARIABLE_CONTAINER($$, new Variables::ResponseStatus()); VARIABLE_CONTAINER($$, new variables::ResponseStatus());
} }
| VARIABLE_SERVER_ADDR | VARIABLE_SERVER_ADDR
{ {
VARIABLE_CONTAINER($$, new Variables::ServerAddr()); VARIABLE_CONTAINER($$, new variables::ServerAddr());
} }
| VARIABLE_SERVER_NAME | VARIABLE_SERVER_NAME
{ {
VARIABLE_CONTAINER($$, new Variables::ServerName()); VARIABLE_CONTAINER($$, new variables::ServerName());
} }
| VARIABLE_SERVER_PORT | VARIABLE_SERVER_PORT
{ {
VARIABLE_CONTAINER($$, new Variables::ServerPort()); VARIABLE_CONTAINER($$, new variables::ServerPort());
} }
| VARIABLE_SESSION_ID | VARIABLE_SESSION_ID
{ {
VARIABLE_CONTAINER($$, new Variables::SessionID()); VARIABLE_CONTAINER($$, new variables::SessionID());
} }
| VARIABLE_UNIQUE_ID | VARIABLE_UNIQUE_ID
{ {
VARIABLE_CONTAINER($$, new Variables::UniqueID()); VARIABLE_CONTAINER($$, new variables::UniqueID());
} }
| VARIABLE_URL_ENCODED_ERROR | VARIABLE_URL_ENCODED_ERROR
{ {
VARIABLE_CONTAINER($$, new Variables::UrlEncodedError()); VARIABLE_CONTAINER($$, new variables::UrlEncodedError());
} }
| VARIABLE_USER_ID | VARIABLE_USER_ID
{ {
VARIABLE_CONTAINER($$, new Variables::UserID()); VARIABLE_CONTAINER($$, new variables::UserID());
} }
| VARIABLE_STATUS | VARIABLE_STATUS
{ {
VARIABLE_CONTAINER($$, new Variables::Status()); VARIABLE_CONTAINER($$, new variables::Status());
} }
| VARIABLE_STATUS_LINE | VARIABLE_STATUS_LINE
{ {
VARIABLE_CONTAINER($$, new Variables::Status()); VARIABLE_CONTAINER($$, new variables::Status());
} }
| VARIABLE_WEB_APP_ID | VARIABLE_WEB_APP_ID
{ {
VARIABLE_CONTAINER($$, new Variables::WebAppId()); VARIABLE_CONTAINER($$, new variables::WebAppId());
} }
| RUN_TIME_VAR_DUR | RUN_TIME_VAR_DUR
{ {

30
src/rule.cc
View File

@ -47,7 +47,7 @@ namespace modsecurity {
using operators::Operator; using operators::Operator;
using actions::Action; using actions::Action;
using Variables::Variable; using variables::Variable;
using actions::transformations::None; using actions::transformations::None;
@ -82,7 +82,7 @@ Rule::Rule(std::string marker)
Rule::Rule(Operator *_op, Rule::Rule(Operator *_op,
Variables::Variables *_variables, variables::Variables *_variables,
std::vector<Action *> *actions, std::vector<Action *> *actions,
std::string fileName, std::string fileName,
int lineNumber) int lineNumber)
@ -459,15 +459,15 @@ std::list<std::pair<std::shared_ptr<std::string>,
void Rule::getVariablesExceptions(Transaction *t, void Rule::getVariablesExceptions(Transaction *t,
Variables::Variables *exclusion, Variables::Variables *addition) { variables::Variables *exclusion, variables::Variables *addition) {
for (auto &a : t->m_rules->m_exceptions.m_variable_update_target_by_tag) { for (auto &a : t->m_rules->m_exceptions.m_variable_update_target_by_tag) {
if (containsTag(*a.first.get(), t) == false) { if (containsTag(*a.first.get(), t) == false) {
continue; continue;
} }
Variable *b = a.second.get(); Variable *b = a.second.get();
if (dynamic_cast<Variables::VariableModificatorExclusion*>(b)) { if (dynamic_cast<variables::VariableModificatorExclusion*>(b)) {
exclusion->push_back( exclusion->push_back(
dynamic_cast<Variables::VariableModificatorExclusion*>( dynamic_cast<variables::VariableModificatorExclusion*>(
b)->m_base.get()); b)->m_base.get());
} else { } else {
addition->push_back(b); addition->push_back(b);
@ -479,9 +479,9 @@ void Rule::getVariablesExceptions(Transaction *t,
continue; continue;
} }
Variable *b = a.second.get(); Variable *b = a.second.get();
if (dynamic_cast<Variables::VariableModificatorExclusion*>(b)) { if (dynamic_cast<variables::VariableModificatorExclusion*>(b)) {
exclusion->push_back( exclusion->push_back(
dynamic_cast<Variables::VariableModificatorExclusion*>( dynamic_cast<variables::VariableModificatorExclusion*>(
b)->m_base.get()); b)->m_base.get());
} else { } else {
addition->push_back(b); addition->push_back(b);
@ -493,9 +493,9 @@ void Rule::getVariablesExceptions(Transaction *t,
continue; continue;
} }
Variable *b = a.second.get(); Variable *b = a.second.get();
if (dynamic_cast<Variables::VariableModificatorExclusion*>(b)) { if (dynamic_cast<variables::VariableModificatorExclusion*>(b)) {
exclusion->push_back( exclusion->push_back(
dynamic_cast<Variables::VariableModificatorExclusion*>( dynamic_cast<variables::VariableModificatorExclusion*>(
b)->m_base.get()); b)->m_base.get());
} else { } else {
addition->push_back(b); addition->push_back(b);
@ -504,9 +504,9 @@ void Rule::getVariablesExceptions(Transaction *t,
} }
inline void Rule::getFinalVars(Variables::Variables *vars, inline void Rule::getFinalVars(variables::Variables *vars,
Variables::Variables *exclusion, Transaction *trans) { variables::Variables *exclusion, Transaction *trans) {
Variables::Variables addition; variables::Variables addition;
getVariablesExceptions(trans, exclusion, &addition); getVariablesExceptions(trans, exclusion, &addition);
@ -620,14 +620,14 @@ void Rule::executeActionsAfterFullMatch(Transaction *trans,
bool Rule::evaluate(Transaction *trans, bool Rule::evaluate(Transaction *trans,
std::shared_ptr<RuleMessage> ruleMessage) { std::shared_ptr<RuleMessage> ruleMessage) {
bool globalRet = false; bool globalRet = false;
Variables::Variables *variables = this->m_variables; variables::Variables *variables = this->m_variables;
bool recursiveGlobalRet; bool recursiveGlobalRet;
bool containsBlock = m_containsStaticBlockAction; bool containsBlock = m_containsStaticBlockAction;
std::vector<std::unique_ptr<VariableValue>> finalVars; std::vector<std::unique_ptr<VariableValue>> finalVars;
std::string eparam; std::string eparam;
Variables::Variables vars; variables::Variables vars;
vars.reserve(4); vars.reserve(4);
Variables::Variables exclusion; variables::Variables exclusion;
if (ruleMessage == NULL) { if (ruleMessage == NULL) {
ruleMessage = std::shared_ptr<RuleMessage>( ruleMessage = std::shared_ptr<RuleMessage>(

18
src/rules_exceptions.cc
View File

@ -74,12 +74,12 @@ bool RulesExceptions::loadRemoveRuleByTag(const std::string &msg,
bool RulesExceptions::loadUpdateTargetByMsg(const std::string &msg, bool RulesExceptions::loadUpdateTargetByMsg(const std::string &msg,
std::unique_ptr<std::vector<std::unique_ptr<Variables::Variable> > > var, std::unique_ptr<std::vector<std::unique_ptr<variables::Variable> > > var,
std::string *error) { std::string *error) {
for (auto &i : *var) { for (auto &i : *var) {
m_variable_update_target_by_msg.emplace( m_variable_update_target_by_msg.emplace(
std::pair<std::shared_ptr<std::string>, std::pair<std::shared_ptr<std::string>,
std::unique_ptr<Variables::Variable>>( std::unique_ptr<variables::Variable>>(
std::make_shared<std::string>(msg), std::make_shared<std::string>(msg),
std::move(i))); std::move(i)));
} }
@ -89,13 +89,13 @@ bool RulesExceptions::loadUpdateTargetByMsg(const std::string &msg,
bool RulesExceptions::loadUpdateTargetByTag(const std::string &tag, bool RulesExceptions::loadUpdateTargetByTag(const std::string &tag,
std::unique_ptr<std::vector<std::unique_ptr<Variables::Variable> > > var, std::unique_ptr<std::vector<std::unique_ptr<variables::Variable> > > var,
std::string *error) { std::string *error) {
for (auto &i : *var) { for (auto &i : *var) {
m_variable_update_target_by_tag.emplace( m_variable_update_target_by_tag.emplace(
std::pair<std::shared_ptr<std::string>, std::pair<std::shared_ptr<std::string>,
std::unique_ptr<Variables::Variable>>( std::unique_ptr<variables::Variable>>(
std::make_shared<std::string>(tag), std::make_shared<std::string>(tag),
std::move(i))); std::move(i)));
} }
@ -105,13 +105,13 @@ bool RulesExceptions::loadUpdateTargetByTag(const std::string &tag,
bool RulesExceptions::loadUpdateTargetById(double id, bool RulesExceptions::loadUpdateTargetById(double id,
std::unique_ptr<std::vector<std::unique_ptr<Variables::Variable> > > var, std::unique_ptr<std::vector<std::unique_ptr<variables::Variable> > > var,
std::string *error) { std::string *error) {
for (auto &i : *var) { for (auto &i : *var) {
m_variable_update_target_by_id.emplace( m_variable_update_target_by_id.emplace(
std::pair<double, std::pair<double,
std::unique_ptr<Variables::Variable>>(id, std::unique_ptr<variables::Variable>>(id,
std::move(i))); std::move(i)));
} }
@ -222,21 +222,21 @@ bool RulesExceptions::merge(RulesExceptions *from) {
for (auto &p : from->m_variable_update_target_by_tag) { for (auto &p : from->m_variable_update_target_by_tag) {
m_variable_update_target_by_tag.emplace( m_variable_update_target_by_tag.emplace(
std::pair<std::shared_ptr<std::string>, std::pair<std::shared_ptr<std::string>,
std::shared_ptr<Variables::Variable>>(p.first, std::shared_ptr<variables::Variable>>(p.first,
p.second)); p.second));
} }
for (auto &p : from->m_variable_update_target_by_msg) { for (auto &p : from->m_variable_update_target_by_msg) {
m_variable_update_target_by_msg.emplace( m_variable_update_target_by_msg.emplace(
std::pair<std::shared_ptr<std::string>, std::pair<std::shared_ptr<std::string>,
std::shared_ptr<Variables::Variable>>(p.first, std::shared_ptr<variables::Variable>>(p.first,
p.second)); p.second));
} }
for (auto &p : from->m_variable_update_target_by_id) { for (auto &p : from->m_variable_update_target_by_id) {
m_variable_update_target_by_id.emplace( m_variable_update_target_by_id.emplace(
std::pair<double, std::pair<double,
std::shared_ptr<Variables::Variable>>(p.first, std::shared_ptr<variables::Variable>>(p.first,
p.second)); p.second));
} }

2
src/run_time_string.cc
View File

@ -38,7 +38,7 @@ void RunTimeString::appendText(std::string text) {
void RunTimeString::appendVar( void RunTimeString::appendVar(
std::unique_ptr<modsecurity::Variables::Variable> var) { std::unique_ptr<modsecurity::variables::Variable> var) {
std::unique_ptr<RunTimeElementHolder> r(new RunTimeElementHolder); std::unique_ptr<RunTimeElementHolder> r(new RunTimeElementHolder);
r->m_var = std::move(var); r->m_var = std::move(var);
m_elements.push_back(std::move(r)); m_elements.push_back(std::move(r));

4
src/run_time_string.h
View File

@ -38,7 +38,7 @@ class RunTimeElementHolder {
m_string("") { m_string("") {
m_var.reset(NULL); m_var.reset(NULL);
} }
std::unique_ptr<modsecurity::Variables::Variable> m_var; std::unique_ptr<modsecurity::variables::Variable> m_var;
std::string m_string; std::string m_string;
}; };
@ -47,7 +47,7 @@ class RunTimeString {
RunTimeString() : RunTimeString() :
m_containsMacro(false) { } m_containsMacro(false) { }
void appendText(std::string text); void appendText(std::string text);
void appendVar(std::unique_ptr<modsecurity::Variables::Variable> var); void appendVar(std::unique_ptr<modsecurity::variables::Variable> var);
std::string evaluate(Transaction *t); std::string evaluate(Transaction *t);
std::string evaluate(Transaction *t, Rule *r); std::string evaluate(Transaction *t, Rule *r);
std::string evaluate() { std::string evaluate() {

2
src/transaction.cc
View File

@ -1359,7 +1359,7 @@ std::string Transaction::toOldAuditLogFormatIndex(const std::string &filename,
<< " "; << " ";
ss << utils::string::dash_if_empty(this->m_clientIpAddress.c_str()) << " "; ss << utils::string::dash_if_empty(this->m_clientIpAddress.c_str()) << " ";
/** TODO: Check variable */ /** TODO: Check variable */
Variables::RemoteUser *r = new Variables::RemoteUser("REMOTE_USER"); variables::RemoteUser *r = new variables::RemoteUser("REMOTE_USER");
std::vector<const VariableValue *> l; std::vector<const VariableValue *> l;
r->evaluate(this, NULL, &l); r->evaluate(this, NULL, &l);
delete r; delete r;

4
src/variables/args.h
View File

@ -27,12 +27,12 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE_DICT(Args, ARGS, m_variableArgs) DEFINE_VARIABLE_DICT(Args, ARGS, m_variableArgs)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_ARGS_H_ #endif // SRC_VARIABLES_ARGS_H_

4
src/variables/args_combined_size.h
View File

@ -27,14 +27,14 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE(ArgsCombinedSize, ARGS_COMBINED_SIZE, DEFINE_VARIABLE(ArgsCombinedSize, ARGS_COMBINED_SIZE,
m_variableARGScombinedSize) m_variableARGScombinedSize)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_ARGS_COMBINED_SIZE_H_ #endif // SRC_VARIABLES_ARGS_COMBINED_SIZE_H_

4
src/variables/args_get.h
View File

@ -27,13 +27,13 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE_DICT(ArgsGet, ARGS_GET, m_variableArgsGet) DEFINE_VARIABLE_DICT(ArgsGet, ARGS_GET, m_variableArgsGet)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_ARGS_GET_H_ #endif // SRC_VARIABLES_ARGS_GET_H_

4
src/variables/args_get_names.h
View File

@ -27,13 +27,13 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE_DICT(ArgsGetNames, ARGS_GET_NAMES, m_variableArgsGetNames) DEFINE_VARIABLE_DICT(ArgsGetNames, ARGS_GET_NAMES, m_variableArgsGetNames)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_ARGS_GET_NAMES_H_ #endif // SRC_VARIABLES_ARGS_GET_NAMES_H_

4
src/variables/args_names.h
View File

@ -27,13 +27,13 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE_DICT(ArgsNames, ARGS_NAMES, m_variableArgsNames) DEFINE_VARIABLE_DICT(ArgsNames, ARGS_NAMES, m_variableArgsNames)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_ARGS_NAMES_H_ #endif // SRC_VARIABLES_ARGS_NAMES_H_

4
src/variables/args_post.h
View File

@ -27,13 +27,13 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE_DICT(ArgsPost, ARGS_POST, m_variableArgsPost) DEFINE_VARIABLE_DICT(ArgsPost, ARGS_POST, m_variableArgsPost)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_ARGS_POST_H_ #endif // SRC_VARIABLES_ARGS_POST_H_

4
src/variables/args_post_names.h
View File

@ -27,13 +27,13 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE_DICT(ArgsPostNames, ARGS_POST_NAMES, m_variableArgsPostNames) DEFINE_VARIABLE_DICT(ArgsPostNames, ARGS_POST_NAMES, m_variableArgsPostNames)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_ARGS_POST_NAMES_H_ #endif // SRC_VARIABLES_ARGS_POST_NAMES_H_

4
src/variables/auth_type.h
View File

@ -27,13 +27,13 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE(AuthType, AUTH_TYPE, m_variableAuthType) DEFINE_VARIABLE(AuthType, AUTH_TYPE, m_variableAuthType)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_AUTH_TYPE_H_ #endif // SRC_VARIABLES_AUTH_TYPE_H_

4
src/variables/duration.cc
View File

@ -25,7 +25,7 @@
#include "src/utils/system.h" #include "src/utils/system.h"
namespace modsecurity { namespace modsecurity {
namespace Variables { namespace variables {
void Duration::evaluate(Transaction *transaction, void Duration::evaluate(Transaction *transaction,
Rule *rule, Rule *rule,
@ -39,5 +39,5 @@ void Duration::evaluate(Transaction *transaction,
} }
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity

4
src/variables/duration.h
View File

@ -26,7 +26,7 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
class Duration : public Variable { class Duration : public Variable {
public: public:
@ -41,7 +41,7 @@ class Duration : public Variable {
}; };
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_DURATION_H_ #endif // SRC_VARIABLES_DURATION_H_

4
src/variables/env.cc
View File

@ -30,7 +30,7 @@
extern char **environ; extern char **environ;
namespace modsecurity { namespace modsecurity {
namespace Variables { namespace variables {
void Env::evaluate(Transaction *transaction, void Env::evaluate(Transaction *transaction,
Rule *rule, Rule *rule,
@ -59,5 +59,5 @@ void Env::evaluate(Transaction *transaction,
} }
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity

4
src/variables/env.h
View File

@ -26,7 +26,7 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
class Env : public Variable { class Env : public Variable {
public: public:
@ -38,7 +38,7 @@ class Env : public Variable {
std::vector<const VariableValue *> *l) override; std::vector<const VariableValue *> *l) override;
}; };
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_ENV_H_ #endif // SRC_VARIABLES_ENV_H_

4
src/variables/files.h
View File

@ -27,13 +27,13 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE_DICT(Files, FILES, m_variableFiles) DEFINE_VARIABLE_DICT(Files, FILES, m_variableFiles)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_FILES_H_ #endif // SRC_VARIABLES_FILES_H_

4
src/variables/files_combined_size.h
View File

@ -27,14 +27,14 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE(FilesCombinedSize, FILES_COMBINED_SIZE, DEFINE_VARIABLE(FilesCombinedSize, FILES_COMBINED_SIZE,
m_variableFilesCombinedSize) m_variableFilesCombinedSize)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_FILES_COMBINED_SIZE_H_ #endif // SRC_VARIABLES_FILES_COMBINED_SIZE_H_

4
src/variables/files_names.h
View File

@ -27,13 +27,13 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE_DICT(FilesNames, FILES_NAMES, m_variableFilesNames) DEFINE_VARIABLE_DICT(FilesNames, FILES_NAMES, m_variableFilesNames)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_FILES_NAMES_H_ #endif // SRC_VARIABLES_FILES_NAMES_H_

4
src/variables/files_sizes.h
View File

@ -27,13 +27,13 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE_DICT(FilesSizes, FILES_SIZES, m_variableFilesSizes) DEFINE_VARIABLE_DICT(FilesSizes, FILES_SIZES, m_variableFilesSizes)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_FILES_SIZES_H_ #endif // SRC_VARIABLES_FILES_SIZES_H_

4
src/variables/files_tmp_content.h
View File

@ -27,14 +27,14 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE_DICT(FilesTmpContent, FILES_TMP_CONTENT, DEFINE_VARIABLE_DICT(FilesTmpContent, FILES_TMP_CONTENT,
m_variableFilesTmpContent) m_variableFilesTmpContent)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_FILES_TMP_CONTENT_H_ #endif // SRC_VARIABLES_FILES_TMP_CONTENT_H_

4
src/variables/files_tmp_names.h
View File

@ -27,13 +27,13 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE_DICT(FilesTmpNames, FILES_TMPNAMES, m_variableFilesTmpNames) DEFINE_VARIABLE_DICT(FilesTmpNames, FILES_TMPNAMES, m_variableFilesTmpNames)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_FILES_TMP_NAMES_H_ #endif // SRC_VARIABLES_FILES_TMP_NAMES_H_

4
src/variables/full_request.h
View File

@ -27,13 +27,13 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE(FullRequest, FULL_REQUEST, m_variableFullRequest) DEFINE_VARIABLE(FullRequest, FULL_REQUEST, m_variableFullRequest)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_FULL_REQUEST_H_ #endif // SRC_VARIABLES_FULL_REQUEST_H_

4
src/variables/full_request_length.h
View File

@ -27,14 +27,14 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE(FullRequestLength, FULL_REQUEST_LENGTH, DEFINE_VARIABLE(FullRequestLength, FULL_REQUEST_LENGTH,
m_variableFullRequestLength) m_variableFullRequestLength)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_FULL_REQUEST_LENGTH_H_ #endif // SRC_VARIABLES_FULL_REQUEST_LENGTH_H_

4
src/variables/geo.h
View File

@ -27,13 +27,13 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE_DICT(Geo, GEO, m_variableGeo) DEFINE_VARIABLE_DICT(Geo, GEO, m_variableGeo)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_GEO_H_ #endif // SRC_VARIABLES_GEO_H_

4
src/variables/global.h
View File

@ -29,7 +29,7 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
class Global_DictElement : public Variable { class Global_DictElement : public Variable {
@ -118,7 +118,7 @@ class Global_DynamicElement : public Variable {
}; };
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_GLOBAL_H_ #endif // SRC_VARIABLES_GLOBAL_H_

4
src/variables/highest_severity.cc
View File

@ -24,7 +24,7 @@
#include "modsecurity/transaction.h" #include "modsecurity/transaction.h"
namespace modsecurity { namespace modsecurity {
namespace Variables { namespace variables {
void HighestSeverity::evaluate(Transaction *transaction, void HighestSeverity::evaluate(Transaction *transaction,
Rule *rule, Rule *rule,
@ -36,5 +36,5 @@ void HighestSeverity::evaluate(Transaction *transaction,
} }
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity

4
src/variables/highest_severity.h
View File

@ -26,7 +26,7 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
class HighestSeverity : public Variable { class HighestSeverity : public Variable {
public: public:
@ -41,7 +41,7 @@ class HighestSeverity : public Variable {
}; };
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_HIGHEST_SEVERITY_H_ #endif // SRC_VARIABLES_HIGHEST_SEVERITY_H_

4
src/variables/inbound_data_error.h
View File

@ -27,14 +27,14 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE(InboundDataError, INBOUND_DATA_ERROR, DEFINE_VARIABLE(InboundDataError, INBOUND_DATA_ERROR,
m_variableInboundDataError) m_variableInboundDataError)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_INBOUND_DATA_ERROR_H_ #endif // SRC_VARIABLES_INBOUND_DATA_ERROR_H_

4
src/variables/ip.h
View File

@ -29,7 +29,7 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
class Ip_DictElement : public Variable { class Ip_DictElement : public Variable {
@ -117,7 +117,7 @@ class Ip_DynamicElement : public Variable {
}; };
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_IP_H_ #endif // SRC_VARIABLES_IP_H_

4
src/variables/matched_var.h
View File

@ -27,13 +27,13 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE(MatchedVar, MATCHED_VAR, m_variableMatchedVar) DEFINE_VARIABLE(MatchedVar, MATCHED_VAR, m_variableMatchedVar)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_MATCHED_VAR_H_ #endif // SRC_VARIABLES_MATCHED_VAR_H_

4
src/variables/matched_var_name.h
View File

@ -27,13 +27,13 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE(MatchedVarName, MATCHED_VAR_NAME, m_variableMatchedVarName) DEFINE_VARIABLE(MatchedVarName, MATCHED_VAR_NAME, m_variableMatchedVarName)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_MATCHED_VAR_NAME_H_ #endif // SRC_VARIABLES_MATCHED_VAR_NAME_H_

4
src/variables/matched_vars.h
View File

@ -27,13 +27,13 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE_DICT(MatchedVars, MATCHED_VARS, m_variableMatchedVars) DEFINE_VARIABLE_DICT(MatchedVars, MATCHED_VARS, m_variableMatchedVars)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_MATCHED_VARS_H_ #endif // SRC_VARIABLES_MATCHED_VARS_H_

4
src/variables/matched_vars_names.h
View File

@ -27,14 +27,14 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE_DICT(MatchedVarsNames, MATCHED_VARS_NAMES, DEFINE_VARIABLE_DICT(MatchedVarsNames, MATCHED_VARS_NAMES,
m_variableMatchedVarsNames) m_variableMatchedVarsNames)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_MATCHED_VARS_NAMES_H_ #endif // SRC_VARIABLES_MATCHED_VARS_NAMES_H_

4
src/variables/modsec_build.cc
View File

@ -22,7 +22,7 @@
#include "modsecurity/transaction.h" #include "modsecurity/transaction.h"
namespace modsecurity { namespace modsecurity {
namespace Variables { namespace variables {
void ModsecBuild::evaluate(Transaction *transaction, void ModsecBuild::evaluate(Transaction *transaction,
Rule *rule, Rule *rule,
@ -32,5 +32,5 @@ void ModsecBuild::evaluate(Transaction *transaction,
} }
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity

4
src/variables/modsec_build.h
View File

@ -28,7 +28,7 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
class ModsecBuild : public Variable { class ModsecBuild : public Variable {
public: public:
@ -52,7 +52,7 @@ class ModsecBuild : public Variable {
}; };
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_MODSEC_BUILD_H_ #endif // SRC_VARIABLES_MODSEC_BUILD_H_

4
src/variables/multipart_boundary_quoted.h
View File

@ -27,14 +27,14 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE(MultipartBoundaryQuoted, MULTIPART_BOUNDARY_QUOTED, DEFINE_VARIABLE(MultipartBoundaryQuoted, MULTIPART_BOUNDARY_QUOTED,
m_variableMultipartBoundaryQuoted) m_variableMultipartBoundaryQuoted)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_MULTIPART_BOUNDARY_QUOTED_H_ #endif // SRC_VARIABLES_MULTIPART_BOUNDARY_QUOTED_H_

4
src/variables/multipart_boundary_whitespace.h
View File

@ -27,14 +27,14 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE(MultipartBoundaryWhiteSpace, MULTIPART_BOUNDARY_WHITESPACE, DEFINE_VARIABLE(MultipartBoundaryWhiteSpace, MULTIPART_BOUNDARY_WHITESPACE,
m_variableMultipartBoundaryWhiteSpace) m_variableMultipartBoundaryWhiteSpace)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_MULTIPART_BOUNDARY_WHITESPACE_H_ #endif // SRC_VARIABLES_MULTIPART_BOUNDARY_WHITESPACE_H_

4
src/variables/multipart_crlf_lf_lines.h
View File

@ -27,14 +27,14 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE(MultipartCrlfLFLines, MULTIPART_CRLF_LF_LINES, DEFINE_VARIABLE(MultipartCrlfLFLines, MULTIPART_CRLF_LF_LINES,
m_variableMultipartCrlfLFLines) m_variableMultipartCrlfLFLines)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_MULTIPART_CRLF_LF_LINES_H_ #endif // SRC_VARIABLES_MULTIPART_CRLF_LF_LINES_H_

4
src/variables/multipart_data_after.h
View File

@ -27,14 +27,14 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE(MultipartDateAfter, MULTIPART_DATA_AFTER, DEFINE_VARIABLE(MultipartDateAfter, MULTIPART_DATA_AFTER,
m_variableMultipartDataAfter) m_variableMultipartDataAfter)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_MULTIPART_DATA_AFTER_H_ #endif // SRC_VARIABLES_MULTIPART_DATA_AFTER_H_

4
src/variables/multipart_data_before.h
View File

@ -27,14 +27,14 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE(MultipartDateBefore, MULTIPART_DATA_BEFORE, DEFINE_VARIABLE(MultipartDateBefore, MULTIPART_DATA_BEFORE,
m_variableMultipartDataBefore) m_variableMultipartDataBefore)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_MULTIPART_DATA_BEFORE_H_ #endif // SRC_VARIABLES_MULTIPART_DATA_BEFORE_H_

4
src/variables/multipart_file_limit_exceeded.h
View File

@ -27,14 +27,14 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE(MultipartFileLimitExceeded, MULTIPART_FILE_LIMIT_EXCEEDED, DEFINE_VARIABLE(MultipartFileLimitExceeded, MULTIPART_FILE_LIMIT_EXCEEDED,
m_variableMultipartFileLimitExceeded) m_variableMultipartFileLimitExceeded)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_MULTIPART_FILE_LIMIT_EXCEEDED_H_ #endif // SRC_VARIABLES_MULTIPART_FILE_LIMIT_EXCEEDED_H_

4
src/variables/multipart_file_name.h
View File

@ -27,14 +27,14 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE_DICT(MultiPartFileName, MULTIPART_FILENAME, DEFINE_VARIABLE_DICT(MultiPartFileName, MULTIPART_FILENAME,
m_variableMultipartFileName) m_variableMultipartFileName)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_MULTIPART_FILE_NAME_H_ #endif // SRC_VARIABLES_MULTIPART_FILE_NAME_H_

4
src/variables/multipart_header_folding.h
View File

@ -27,14 +27,14 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE(MultipartHeaderFolding, MULTIPART_HEADER_FOLDING, DEFINE_VARIABLE(MultipartHeaderFolding, MULTIPART_HEADER_FOLDING,
m_variableMultipartHeaderFolding) m_variableMultipartHeaderFolding)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_MULTIPART_HEADER_FOLDING_H_ #endif // SRC_VARIABLES_MULTIPART_HEADER_FOLDING_H_

4
src/variables/multipart_invalid_header_folding.h
View File

@ -27,13 +27,13 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE(MultipartInvalidHeaderFolding, MULTIPART_INVALID_HEADER_FOLDING, m_variableMultipartInvalidHeaderFolding) DEFINE_VARIABLE(MultipartInvalidHeaderFolding, MULTIPART_INVALID_HEADER_FOLDING, m_variableMultipartInvalidHeaderFolding)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_MULTIPART_INVALID_HEADER_FOLDING_H_ #endif // SRC_VARIABLES_MULTIPART_INVALID_HEADER_FOLDING_H_

4
src/variables/multipart_invalid_part.h
View File

@ -27,14 +27,14 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE(MultipartInvalidPart, MULTIPART_INVALID_PART, DEFINE_VARIABLE(MultipartInvalidPart, MULTIPART_INVALID_PART,
m_variableMultipartInvalidHeaderFolding) m_variableMultipartInvalidHeaderFolding)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_MULTIPART_INVALID_PART_H_ #endif // SRC_VARIABLES_MULTIPART_INVALID_PART_H_

4
src/variables/multipart_invalid_quoting.h
View File

@ -27,14 +27,14 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE(MultipartInvalidQuoting, MULTIPART_INVALID_QUOTING, DEFINE_VARIABLE(MultipartInvalidQuoting, MULTIPART_INVALID_QUOTING,
m_variableMultipartInvalidQuoting) m_variableMultipartInvalidQuoting)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_MULTIPART_INVALID_QUOTING_H_ #endif // SRC_VARIABLES_MULTIPART_INVALID_QUOTING_H_

4
src/variables/multipart_lf_line.h
View File

@ -27,13 +27,13 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE(MultipartLFLine, MULTIPART_LF_LINE, m_variableMultipartLFLine) DEFINE_VARIABLE(MultipartLFLine, MULTIPART_LF_LINE, m_variableMultipartLFLine)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_MULTIPART_LF_LINE_H_ #endif // SRC_VARIABLES_MULTIPART_LF_LINE_H_

4
src/variables/multipart_missing_semicolon.h
View File

@ -27,14 +27,14 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE(MultipartMissingSemicolon, MULTIPART_MISSING_SEMICOLON, DEFINE_VARIABLE(MultipartMissingSemicolon, MULTIPART_MISSING_SEMICOLON,
m_variableMultipartMissingSemicolon) m_variableMultipartMissingSemicolon)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_MULTIPART_MISSING_SEMICOLON_H_ #endif // SRC_VARIABLES_MULTIPART_MISSING_SEMICOLON_H_

4
src/variables/multipart_name.h
View File

@ -27,13 +27,13 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE_DICT(MultiPartName, MULTIPART_NAME, m_variableMultipartName) DEFINE_VARIABLE_DICT(MultiPartName, MULTIPART_NAME, m_variableMultipartName)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_MULTIPART_NAME_H_ #endif // SRC_VARIABLES_MULTIPART_NAME_H_

4
src/variables/multipart_strict_error.h
View File

@ -27,14 +27,14 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE(MultipartStrictError, MULTIPART_STRICT_ERROR, DEFINE_VARIABLE(MultipartStrictError, MULTIPART_STRICT_ERROR,
m_variableMultipartStrictError) m_variableMultipartStrictError)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_MULTIPART_STRICT_ERROR_H_ #endif // SRC_VARIABLES_MULTIPART_STRICT_ERROR_H_

4
src/variables/multipart_unmatched_boundary.h
View File

@ -27,14 +27,14 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE(MultipartUnmatchedBoundary, MULTIPART_UNMATCHED_BOUNDARY, DEFINE_VARIABLE(MultipartUnmatchedBoundary, MULTIPART_UNMATCHED_BOUNDARY,
m_variableMultipartUnmatchedBoundary) m_variableMultipartUnmatchedBoundary)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_MULTIPART_UNMATCHED_BOUNDARY_H_ #endif // SRC_VARIABLES_MULTIPART_UNMATCHED_BOUNDARY_H_

4
src/variables/outbound_data_error.h
View File

@ -27,14 +27,14 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE(OutboundDataError, OUTBOUND_DATA_ERROR, DEFINE_VARIABLE(OutboundDataError, OUTBOUND_DATA_ERROR,
m_variableOutboundDataError) m_variableOutboundDataError)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_OUTBOUND_DATA_ERROR_H_ #endif // SRC_VARIABLES_OUTBOUND_DATA_ERROR_H_

4
src/variables/path_info.h
View File

@ -27,13 +27,13 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE(PathInfo, PATH_INFO, m_variablePathInfo) DEFINE_VARIABLE(PathInfo, PATH_INFO, m_variablePathInfo)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_PATH_INFO_H_ #endif // SRC_VARIABLES_PATH_INFO_H_

4
src/variables/query_string.h
View File

@ -27,13 +27,13 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE(QueryString, QUERY_STRING, m_variableQueryString) DEFINE_VARIABLE(QueryString, QUERY_STRING, m_variableQueryString)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_QUERY_STRING_H_ #endif // SRC_VARIABLES_QUERY_STRING_H_

4
src/variables/remote_addr.h
View File

@ -27,13 +27,13 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE(RemoteAddr, REMOTE_ADDR, m_variableRemoteAddr) DEFINE_VARIABLE(RemoteAddr, REMOTE_ADDR, m_variableRemoteAddr)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_REMOTE_ADDR_H_ #endif // SRC_VARIABLES_REMOTE_ADDR_H_

4
src/variables/remote_host.h
View File

@ -27,13 +27,13 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE(RemoteHost, REMOTE_HOST, m_variableRemoteHost) DEFINE_VARIABLE(RemoteHost, REMOTE_HOST, m_variableRemoteHost)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_REMOTE_HOST_H_ #endif // SRC_VARIABLES_REMOTE_HOST_H_

4
src/variables/remote_port.h
View File

@ -27,13 +27,13 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE(RemotePort, REMOTE_PORT, m_variableRemotePort) DEFINE_VARIABLE(RemotePort, REMOTE_PORT, m_variableRemotePort)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_REMOTE_PORT_H_ #endif // SRC_VARIABLES_REMOTE_PORT_H_

4
src/variables/remote_user.cc
View File

@ -33,7 +33,7 @@
#include "src/utils/base64.h" #include "src/utils/base64.h"
namespace modsecurity { namespace modsecurity {
namespace Variables { namespace variables {
void RemoteUser::evaluate(Transaction *transaction, void RemoteUser::evaluate(Transaction *transaction,
@ -86,5 +86,5 @@ clear:
} }
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity

4
src/variables/remote_user.h
View File

@ -27,7 +27,7 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
class RemoteUser : public Variable { class RemoteUser : public Variable {
@ -43,7 +43,7 @@ class RemoteUser : public Variable {
}; };
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_REMOTE_USER_H_ #endif // SRC_VARIABLES_REMOTE_USER_H_

4
src/variables/reqbody_error.h
View File

@ -27,13 +27,13 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE(ReqbodyError, REQBODY_ERROR, m_variableReqbodyError) DEFINE_VARIABLE(ReqbodyError, REQBODY_ERROR, m_variableReqbodyError)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_REQBODY_ERROR_H_ #endif // SRC_VARIABLES_REQBODY_ERROR_H_

4
src/variables/reqbody_error_msg.h
View File

@ -27,13 +27,13 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE(ReqbodyErrorMsg, REQBODY_ERROR_MSG, m_variableReqbodyErrorMsg) DEFINE_VARIABLE(ReqbodyErrorMsg, REQBODY_ERROR_MSG, m_variableReqbodyErrorMsg)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_REQBODY_ERROR_MSG_H_ #endif // SRC_VARIABLES_REQBODY_ERROR_MSG_H_

4
src/variables/reqbody_processor.h
View File

@ -27,13 +27,13 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE(ReqbodyProcessor, REQBODY_PROCESSOR, m_variableReqbodyProcessor) DEFINE_VARIABLE(ReqbodyProcessor, REQBODY_PROCESSOR, m_variableReqbodyProcessor)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_REQBODY_PROCESSOR_H_ #endif // SRC_VARIABLES_REQBODY_PROCESSOR_H_

4
src/variables/reqbody_processor_error.h
View File

@ -27,14 +27,14 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE(ReqbodyProcessorError, REQBODY_PROCESSOR_ERROR, DEFINE_VARIABLE(ReqbodyProcessorError, REQBODY_PROCESSOR_ERROR,
m_variableReqbodyProcessorError) m_variableReqbodyProcessorError)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_REQBODY_PROCESSOR_ERROR_H_ #endif // SRC_VARIABLES_REQBODY_PROCESSOR_ERROR_H_

4
src/variables/reqbody_processor_error_msg.h
View File

@ -27,14 +27,14 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE(ReqbodyProcessorErrorMsg, PROCESSOR_ERROR_MSG, DEFINE_VARIABLE(ReqbodyProcessorErrorMsg, PROCESSOR_ERROR_MSG,
m_variableReqbodyProcessorErrorMsg) m_variableReqbodyProcessorErrorMsg)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_REQBODY_PROCESSOR_ERROR_MSG_H_ #endif // SRC_VARIABLES_REQBODY_PROCESSOR_ERROR_MSG_H_

4
src/variables/request_base_name.h
View File

@ -27,13 +27,13 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE(RequestBasename, REQUEST_BASENAME, m_variableRequestBasename) DEFINE_VARIABLE(RequestBasename, REQUEST_BASENAME, m_variableRequestBasename)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_REQUEST_BASE_NAME_H_ #endif // SRC_VARIABLES_REQUEST_BASE_NAME_H_

4
src/variables/request_body.h
View File

@ -27,13 +27,13 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE(RequestBody, REQUEST_BODY, m_variableRequestBody) DEFINE_VARIABLE(RequestBody, REQUEST_BODY, m_variableRequestBody)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_REQUEST_BODY_H_ #endif // SRC_VARIABLES_REQUEST_BODY_H_

4
src/variables/request_body_length.h
View File

@ -27,14 +27,14 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE(RequestBodyLength, REQUEST_BODY_LENGTH, DEFINE_VARIABLE(RequestBodyLength, REQUEST_BODY_LENGTH,
m_variableRequestBodyLength) m_variableRequestBodyLength)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_REQUEST_BODY_LENGTH_H_ #endif // SRC_VARIABLES_REQUEST_BODY_LENGTH_H_

4
src/variables/request_cookies.h
View File

@ -27,13 +27,13 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE_DICT(RequestCookies, REQUEST_COOKIES, m_variableRequestCookies) DEFINE_VARIABLE_DICT(RequestCookies, REQUEST_COOKIES, m_variableRequestCookies)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_REQUEST_COOKIES_H_ #endif // SRC_VARIABLES_REQUEST_COOKIES_H_

4
src/variables/request_cookies_names.h
View File

@ -27,14 +27,14 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE_DICT(RequestCookiesNames, REQUEST_COOKIES_NAMES, DEFINE_VARIABLE_DICT(RequestCookiesNames, REQUEST_COOKIES_NAMES,
m_variableRequestCookiesNames) m_variableRequestCookiesNames)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_REQUEST_COOKIES_NAMES_H_ #endif // SRC_VARIABLES_REQUEST_COOKIES_NAMES_H_

4
src/variables/request_file_name.h
View File

@ -27,13 +27,13 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE(RequestFilename, REQUEST_FILENAME, m_variableRequestFilename) DEFINE_VARIABLE(RequestFilename, REQUEST_FILENAME, m_variableRequestFilename)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_REQUEST_FILE_NAME_H_ #endif // SRC_VARIABLES_REQUEST_FILE_NAME_H_

4
src/variables/request_headers.h
View File

@ -27,13 +27,13 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE_DICT(RequestHeaders, REQUEST_HEADERS, m_variableRequestHeaders) DEFINE_VARIABLE_DICT(RequestHeaders, REQUEST_HEADERS, m_variableRequestHeaders)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_REQUEST_HEADERS_H_ #endif // SRC_VARIABLES_REQUEST_HEADERS_H_

4
src/variables/request_headers_names.h
View File

@ -27,14 +27,14 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE_DICT(RequestHeadersNames, REQUEST_HEADERS_NAMES, DEFINE_VARIABLE_DICT(RequestHeadersNames, REQUEST_HEADERS_NAMES,
m_variableRequestHeadersNames) m_variableRequestHeadersNames)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_REQUEST_HEADERS_NAMES_H_ #endif // SRC_VARIABLES_REQUEST_HEADERS_NAMES_H_

4
src/variables/request_line.h
View File

@ -27,13 +27,13 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE(RequestLine, REQUEST_LINE, m_variableRequestLine) DEFINE_VARIABLE(RequestLine, REQUEST_LINE, m_variableRequestLine)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_REQUEST_LINE_H_ #endif // SRC_VARIABLES_REQUEST_LINE_H_

4
src/variables/request_method.h
View File

@ -27,13 +27,13 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE(RequestMethod, REQUEST_METHOD, m_variableRequestMethod) DEFINE_VARIABLE(RequestMethod, REQUEST_METHOD, m_variableRequestMethod)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_REQUEST_METHOD_H_ #endif // SRC_VARIABLES_REQUEST_METHOD_H_

4
src/variables/request_protocol.h
View File

@ -27,13 +27,13 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE(RequestProtocol, REQUEST_PROTOCOL, m_variableRequestProtocol) DEFINE_VARIABLE(RequestProtocol, REQUEST_PROTOCOL, m_variableRequestProtocol)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_REQUEST_PROTOCOL_H_ #endif // SRC_VARIABLES_REQUEST_PROTOCOL_H_

4
src/variables/request_uri.h
View File

@ -27,13 +27,13 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE(RequestURI, REQUEST_URI, m_variableRequestURI) DEFINE_VARIABLE(RequestURI, REQUEST_URI, m_variableRequestURI)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_REQUEST_URI_H_ #endif // SRC_VARIABLES_REQUEST_URI_H_

4
src/variables/request_uri_raw.h
View File

@ -27,13 +27,13 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE(RequestURIRaw, REQUEST_URI_RAW, m_variableRequestURIRaw) DEFINE_VARIABLE(RequestURIRaw, REQUEST_URI_RAW, m_variableRequestURIRaw)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_REQUEST_URI_RAW_H_ #endif // SRC_VARIABLES_REQUEST_URI_RAW_H_

4
src/variables/resource.h
View File

@ -29,7 +29,7 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
class Resource_DictElement : public Variable { class Resource_DictElement : public Variable {
@ -116,7 +116,7 @@ class Resource_DynamicElement : public Variable {
}; };
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_RESOURCE_H_ #endif // SRC_VARIABLES_RESOURCE_H_

4
src/variables/response_body.h
View File

@ -27,13 +27,13 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE(ResponseBody, RESPONSE_BODY, m_variableResponseBody) DEFINE_VARIABLE(ResponseBody, RESPONSE_BODY, m_variableResponseBody)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_RESPONSE_BODY_H_ #endif // SRC_VARIABLES_RESPONSE_BODY_H_

4
src/variables/response_content_length.h
View File

@ -27,14 +27,14 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE(ResponseContentLength, RESPONSE_CONTENT_LENGTH, DEFINE_VARIABLE(ResponseContentLength, RESPONSE_CONTENT_LENGTH,
m_variableResponseContentLength) m_variableResponseContentLength)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_RESPONSE_CONTENT_LENGTH_H_ #endif // SRC_VARIABLES_RESPONSE_CONTENT_LENGTH_H_

4
src/variables/response_content_type.h
View File

@ -27,14 +27,14 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE(ResponseContentType, RESPONSE_CONTENT_TYPE, DEFINE_VARIABLE(ResponseContentType, RESPONSE_CONTENT_TYPE,
m_variableResponseContentType) m_variableResponseContentType)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_RESPONSE_CONTENT_TYPE_H_ #endif // SRC_VARIABLES_RESPONSE_CONTENT_TYPE_H_

4
src/variables/response_headers.h
View File

@ -27,14 +27,14 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE_DICT(ResponseHeaders, RESPONSE_HEADERS, DEFINE_VARIABLE_DICT(ResponseHeaders, RESPONSE_HEADERS,
m_variableResponseHeaders) m_variableResponseHeaders)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_RESPONSE_HEADERS_H_ #endif // SRC_VARIABLES_RESPONSE_HEADERS_H_

4
src/variables/response_headers_names.h
View File

@ -27,14 +27,14 @@
namespace modsecurity { namespace modsecurity {
class Transaction; class Transaction;
namespace Variables { namespace variables {
DEFINE_VARIABLE_DICT(ResponseHeadersNames, RESPONSE_HEADERS_NAMES, DEFINE_VARIABLE_DICT(ResponseHeadersNames, RESPONSE_HEADERS_NAMES,
m_variableResponseHeadersNames) m_variableResponseHeadersNames)
} // namespace Variables } // namespace variables
} // namespace modsecurity } // namespace modsecurity
#endif // SRC_VARIABLES_RESPONSE_HEADERS_NAMES_H_ #endif // SRC_VARIABLES_RESPONSE_HEADERS_NAMES_H_

Some files were not shown because too many files have changed in this diff Show More