Variables resolution results now stored into a std::vector instead of std::list

This commit is contained in:
Felipe Zimmerle 2015-11-04 15:51:22 -03:00
parent 2ee5d4ca8f
commit 5bef19aa4d
40 changed files with 143 additions and 275 deletions

View File

@ -60,26 +60,21 @@ class Collections :
std::string* resolveFirst(const std::string& collectionName, std::string* resolveFirst(const std::string& collectionName,
const std::string& var); const std::string& var);
void resolve(const std::string& var,
std::list<transaction::Variable *> *l);
std::list<transaction::Variable *> *resolve(const std::string& var);
void resolveSingleMatch(const std::string& var, void resolveSingleMatch(const std::string& var,
std::list<transaction::Variable *> *l); std::vector<const transaction::Variable *> *l);
void resolveSingleMatch(const std::string& var, void resolveSingleMatch(const std::string& var,
const std::string& collection, const std::string& collection,
std::list<transaction::Variable *> *l); std::vector<const transaction::Variable *> *l);
void resolveMultiMatches(const std::string& var, void resolveMultiMatches(const std::string& var,
std::list<transaction::Variable *> *l); std::vector<const transaction::Variable *> *l);
void resolveMultiMatches(const std::string& var, void resolveMultiMatches(const std::string& var,
const std::string& collection, const std::string& collection,
std::list<transaction::Variable *> *l); std::vector<const transaction::Variable *> *l);
void resolveRegularExpression(const std::string& var, void resolveRegularExpression(const std::string& var,
std::list<transaction::Variable *> *l); std::vector<const transaction::Variable *> *l);
void resolveRegularExpression(const std::string& var, void resolveRegularExpression(const std::string& var,
const std::string& collection, const std::string& collection,
std::list<transaction::Variable *> *l); std::vector<const transaction::Variable *> *l);
/** /**
* This is a special collection to host the transaction variables. * This is a special collection to host the transaction variables.

View File

@ -19,6 +19,7 @@
#include <iostream> #include <iostream>
#include <unordered_map> #include <unordered_map>
#include <list> #include <list>
#include <vector>
#endif #endif
@ -53,17 +54,13 @@ class Variables :
std::string* resolveFirst(const std::string& collectionName, std::string* resolveFirst(const std::string& collectionName,
const std::string& var); const std::string& var);
std::list<transaction::Variable *> resolve(const std::string& key);
std::list<Variable *> resolve(const std::string& var,
std::list<transaction::Variable *> *l);
void resolveSingleMatch(const std::string& var, void resolveSingleMatch(const std::string& var,
std::list<transaction::Variable *> *l); std::vector<const transaction::Variable *> *l);
void resolveMultiMatches(const std::string& var, void resolveMultiMatches(const std::string& var,
std::list<transaction::Variable *> *l); std::vector<const transaction::Variable *> *l);
void resolveRegularExpression(const std::string& var, void resolveRegularExpression(const std::string& var,
std::list<transaction::Variable *> *l); std::vector<const transaction::Variable *> *l);
}; };

View File

@ -676,8 +676,8 @@ int Assay::processRequestBody() {
* computationally intensive. * computationally intensive.
*/ */
std::string fullRequest; std::string fullRequest;
std::list<transaction::Variable *> l; std::vector<const transaction::Variable *> l;
m_collections.resolve("REQUEST_HEADERS", &l); m_collections.resolveMultiMatches("REQUEST_HEADERS", &l);
for (auto &a : l) { for (auto &a : l) {
fullRequest = fullRequest + \ fullRequest = fullRequest + \
std::string(a->m_key, 16, a->m_key.length() - 16) + ": " \ std::string(a->m_key, 16, a->m_key.length() - 16) + ": " \
@ -685,8 +685,8 @@ int Assay::processRequestBody() {
} }
while (l.empty() == false) { while (l.empty() == false) {
delete l.front(); delete l.back();
l.pop_front(); l.pop_back();
} }
fullRequest = fullRequest + "\n\n"; fullRequest = fullRequest + "\n\n";

View File

@ -21,6 +21,7 @@
#include <iostream> #include <iostream>
#include <unordered_map> #include <unordered_map>
#include <list> #include <list>
#include <vector>
#endif #endif
#include "modsecurity/transaction/variable.h" #include "modsecurity/transaction/variable.h"
@ -115,33 +116,11 @@ std::string* Collections::resolveFirst(const std::string& collectionName,
} }
return NULL; return NULL;
}
void Collections::resolve(const std::string& var,
std::list<transaction::Variable *> *l) {
m_transient.resolve(var, l);
/* It may be a collection */
for (auto &a : *this) {
transaction::Variables *t = a.second;
a.second->resolve(var, l);
}
}
std::list<transaction::Variable *> *
Collections::resolve(const std::string& var) {
std::list<transaction::Variable *> *l =
new std::list<transaction::Variable *>();
resolve(var, l);
} }
void Collections::resolveSingleMatch(const std::string& var, void Collections::resolveSingleMatch(const std::string& var,
std::list<transaction::Variable *> *l) { std::vector<const transaction::Variable *> *l) {
m_transient.resolveSingleMatch(var, l); m_transient.resolveSingleMatch(var, l);
} }
@ -149,7 +128,7 @@ void Collections::resolveSingleMatch(const std::string& var,
void Collections::resolveSingleMatch(const std::string& var, void Collections::resolveSingleMatch(const std::string& var,
const std::string& collection, const std::string& collection,
std::list<transaction::Variable *> *l) { std::vector<const transaction::Variable *> *l) {
try { try {
this->at(collection)->resolveSingleMatch(var, l); this->at(collection)->resolveSingleMatch(var, l);
@ -159,7 +138,7 @@ void Collections::resolveSingleMatch(const std::string& var,
} }
void Collections::resolveMultiMatches(const std::string& var, void Collections::resolveMultiMatches(const std::string& var,
std::list<transaction::Variable *> *l) { std::vector<const transaction::Variable *> *l) {
m_transient.resolveMultiMatches(var, l); m_transient.resolveMultiMatches(var, l);
} }
@ -167,7 +146,7 @@ void Collections::resolveMultiMatches(const std::string& var,
void Collections::resolveMultiMatches(const std::string& var, void Collections::resolveMultiMatches(const std::string& var,
const std::string& collection, const std::string& collection,
std::list<transaction::Variable *> *l) { std::vector<const transaction::Variable *> *l) {
try { try {
this->at(collection)->resolveMultiMatches(var, l); this->at(collection)->resolveMultiMatches(var, l);
} catch (...) { } catch (...) {
@ -176,14 +155,14 @@ void Collections::resolveMultiMatches(const std::string& var,
} }
void Collections::resolveRegularExpression(const std::string& var, void Collections::resolveRegularExpression(const std::string& var,
std::list<transaction::Variable *> *l) { std::vector<const transaction::Variable *> *l) {
m_transient.resolveRegularExpression(var, l); m_transient.resolveRegularExpression(var, l);
} }
void Collections::resolveRegularExpression(const std::string& var, void Collections::resolveRegularExpression(const std::string& var,
const std::string& collection, const std::string& collection,
std::list<transaction::Variable *> *l) { std::vector<const transaction::Variable *> *l) {
try { try {
this->at(collection)->resolveRegularExpression(var, l); this->at(collection)->resolveRegularExpression(var, l);

View File

@ -280,13 +280,12 @@ bool Rule::evaluate(Assay *assay) {
for (int i = 0; i < variables->size(); i++) { for (int i = 0; i < variables->size(); i++) {
Variable *variable = variables->at(i); Variable *variable = variables->at(i);
if (variable->m_isExclusion) { if (variable->m_isExclusion) {
std::list<transaction::Variable *> *z = std::vector<const transaction::Variable *> z;
variable->evaluate(assay); variable->evaluateInternal(assay, &z);
for (auto &y : *z) { for (auto &y : z) {
exclusions.push_back(y->m_key); exclusions.push_back(y->m_key);
} }
exclusions.push_back(variable->m_name); exclusions.push_back(variable->m_name);
delete z;
} }
} }
@ -297,10 +296,10 @@ bool Rule::evaluate(Assay *assay) {
continue; continue;
} }
std::list<transaction::Variable *> *e = std::vector<const transaction::Variable *> e;
variable->evaluate(assay); variable->evaluateInternal(assay, &e);
for (auto &v : *e) { for (auto &v : e) {
if (std::find(exclusions.begin(), exclusions.end(), if (std::find(exclusions.begin(), exclusions.end(),
v->m_key) != exclusions.end()) { v->m_key) != exclusions.end()) {
#ifndef NO_LOGS #ifndef NO_LOGS
@ -312,7 +311,7 @@ bool Rule::evaluate(Assay *assay) {
std::string value = v->m_value; std::string value = v->m_value;
int none = 0; int none = 0;
for (Action *a : this->actions_runtime_pre) { for (Action *a : this->actions_runtime_pre) {
if (a->m_isNone != NULL) { if (a->m_isNone) {
none++; none++;
} }
} }
@ -345,7 +344,7 @@ bool Rule::evaluate(Assay *assay) {
#endif #endif
transformations++; transformations++;
} }
if (a->m_isNone != NULL) { if (a->m_isNone) {
none--; none--;
} }
} }
@ -485,11 +484,11 @@ bool Rule::evaluate(Assay *assay) {
} }
} }
while (e->empty() == false) { while (e.empty() == false) {
delete e->front(); delete e.back();
e->pop_front(); e.pop_back();
} }
delete e; //delete e;
} }
return ret; return ret;
} }

View File

@ -65,9 +65,8 @@ void Variables::del(const std::string& key) {
} }
void Variables::resolveSingleMatch(const std::string& var, void Variables::resolveSingleMatch(const std::string& var,
std::list<transaction::Variable *> *l) { std::vector<const transaction::Variable *> *l) {
auto range = this->equal_range(var); auto range = this->equal_range(var);
for (auto it = range.first; it != range.second; ++it) { for (auto it = range.first; it != range.second; ++it) {
@ -77,16 +76,17 @@ void Variables::resolveSingleMatch(const std::string& var,
void Variables::resolveMultiMatches(const std::string& var, void Variables::resolveMultiMatches(const std::string& var,
std::list<transaction::Variable *> *l) { std::vector<const transaction::Variable *> *l) {
size_t keySize = var.size(); size_t keySize = var.size();
l->reserve(15);
auto range = this->equal_range(var); auto range = this->equal_range(var);
for (auto it = range.first; it != range.second; ++it) { for (auto it = range.first; it != range.second; ++it) {
l->push_back(new transaction::Variable(var, it->second)); l->insert(l->begin(), new transaction::Variable(var, it->second));
} }
for (auto& x : *this) { for (const auto& x : *this) {
if (x.first.size() <= keySize + 1) { if (x.first.size() <= keySize + 1) {
continue; continue;
} }
@ -96,55 +96,18 @@ void Variables::resolveMultiMatches(const std::string& var,
if (x.first.compare(0, keySize, var) != 0) { if (x.first.compare(0, keySize, var) != 0) {
continue; continue;
} }
l->push_back(new transaction::Variable(x.first, x.second)); const transaction::Variable *v = new transaction::Variable(x.first, x.second);
l->insert(l->begin(), v);
} }
} }
void Variables::resolveRegularExpression(const std::string& var, void Variables::resolveRegularExpression(const std::string& var,
std::list<transaction::Variable *> *l) { std::vector<const transaction::Variable *> *l) {
/* Not ready */ /* Not ready */
} }
std::list<transaction::Variable *> Variables::resolve(const std::string& key,
std::list<transaction::Variable *> *l) {
auto range = this->equal_range(key);
for (auto it = range.first; it != range.second; ++it) {
l->push_back(new transaction::Variable(key, it->second));
}
if (key.find(":") == std::string::npos && l->size() == 0) {
size_t keySize = key.size() + 1;
for (auto& x : *this) {
if (x.first.size() <= keySize) {
continue;
}
if (x.first.at(keySize - 1) != ':') {
continue;
}
if (x.first.compare(0, keySize, key + ":") != 0) {
continue;
}
// auto range = this->equal_range(x.first);
// for (auto it = range.first; it != range.second; ++it) {
l->push_back(new transaction::Variable(x.first, x.second));
// }
}
}
return *l;
}
std::list<transaction::Variable *> Variables::resolve(const std::string& key) {
std::list<transaction::Variable *> l;
return resolve(key, &l);
}
std::string* Variables::resolveFirst(const std::string& var) { std::string* Variables::resolveFirst(const std::string& var) {
auto range = equal_range(var); auto range = equal_range(var);

View File

@ -27,19 +27,15 @@
namespace ModSecurity { namespace ModSecurity {
namespace Variables { namespace Variables {
std::list<transaction::Variable *> * void Duration::evaluateInternal(Assay *assay,
Duration::evaluate(Assay *assay) { std::vector<const transaction::Variable *> *l) {
std::list<transaction::Variable *> *resl =
new std::list<transaction::Variable *>();
std::string res; std::string res;
double e = cpu_seconds() - assay->start; double e = cpu_seconds() - assay->start;
res = std::to_string(e); res = std::to_string(e);
resl->push_back(new transaction::Variable("DURATION", std::string(res))); l->push_back(new transaction::Variable("DURATION", std::string(res)));
return resl;
} }

View File

@ -33,8 +33,8 @@ class Duration : public Variable {
explicit Duration(std::string _name) explicit Duration(std::string _name)
: Variable(_name) { } : Variable(_name) { }
std::list<transaction::Variable *> * void evaluateInternal(Assay *assay,
evaluate(Assay *assay) override; std::vector<const transaction::Variable *> *l) override;
}; };

View File

@ -33,11 +33,8 @@ extern char **environ;
namespace ModSecurity { namespace ModSecurity {
namespace Variables { namespace Variables {
std::list<transaction::Variable *> * void Env::evaluateInternal(Assay *assay,
Env::evaluate(Assay *assay) { std::vector<const transaction::Variable *> *l) {
std::list<transaction::Variable *> *resl =
new std::list<transaction::Variable *>();
std::map<std::string, std::string> envs; std::map<std::string, std::string> envs;
for (char **current = environ; *current; current++) { for (char **current = environ; *current; current++) {
std::string env = std::string(*current); std::string env = std::string(*current);
@ -50,8 +47,8 @@ std::list<transaction::Variable *> *
envs.insert(std::pair<std::string, std::string>("ENV:" + key, value)); envs.insert(std::pair<std::string, std::string>("ENV:" + key, value));
if ("env:" + key == m_name) { if ("env:" + key == m_name) {
resl->push_back(new transaction::Variable(m_name, value)); l->push_back(new transaction::Variable(m_name, value));
return resl; return;
} }
} }
@ -60,10 +57,8 @@ std::list<transaction::Variable *> *
&& (x.first != m_name)) { && (x.first != m_name)) {
continue; continue;
} }
resl->push_back(new transaction::Variable(x.first, x.second)); l->push_back(new transaction::Variable(x.first, x.second));
} }
return resl;
} }

View File

@ -33,8 +33,8 @@ class Env : public Variable {
explicit Env(std::string _name) explicit Env(std::string _name)
: Variable(_name) { } : Variable(_name) { }
std::list<transaction::Variable *> * void evaluateInternal(Assay *assay,
evaluate(Assay *assay) override; std::vector<const transaction::Variable *> *l) override;
}; };

View File

@ -26,15 +26,10 @@
namespace ModSecurity { namespace ModSecurity {
namespace Variables { namespace Variables {
std::list<transaction::Variable *> * void HighestSeverity::evaluateInternal(Assay *assay,
HighestSeverity::evaluate(Assay *assay) { std::vector<const transaction::Variable *> *l) {
std::list<transaction::Variable *> *resl = l->push_back(new transaction::Variable("HIGHEST_SEVERITY",
new std::list<transaction::Variable *>();
resl->push_back(new transaction::Variable("HIGHEST_SEVERITY",
std::to_string(assay->highest_severity))); std::to_string(assay->highest_severity)));
return resl;
} }

View File

@ -33,8 +33,8 @@ class HighestSeverity : public Variable {
explicit HighestSeverity(std::string _name) explicit HighestSeverity(std::string _name)
: Variable(_name) { } : Variable(_name) { }
std::list<transaction::Variable *> * void evaluateInternal(Assay *assay,
evaluate(Assay *assay) override; std::vector<const transaction::Variable *> *l) override;
}; };

View File

@ -27,20 +27,15 @@
namespace ModSecurity { namespace ModSecurity {
namespace Variables { namespace Variables {
std::list<transaction::Variable *> * void ModsecBuild::evaluateInternal(Assay *assay,
ModsecBuild::evaluate(Assay *assay) { std::vector<const transaction::Variable *> *l) {
std::list<transaction::Variable *> *resl =
new std::list<transaction::Variable *>();
std::ostringstream ss; std::ostringstream ss;
ss << std::setw(2) << std::setfill('0') << MODSECURITY_MAJOR; ss << std::setw(2) << std::setfill('0') << MODSECURITY_MAJOR;
ss << std::setw(2) << std::setfill('0') << MODSECURITY_MINOR; ss << std::setw(2) << std::setfill('0') << MODSECURITY_MINOR;
ss << std::setw(2) << std::setfill('0') << MODSECURITY_PATCHLEVEL; ss << std::setw(2) << std::setfill('0') << MODSECURITY_PATCHLEVEL;
ss << std::setw(2) << std::setfill('0') << MODSECURITY_TAG_NUM; ss << std::setw(2) << std::setfill('0') << MODSECURITY_TAG_NUM;
resl->push_back(new transaction::Variable("MODSEC_BUILD", ss.str())); l->push_back(new transaction::Variable("MODSEC_BUILD", ss.str()));
return resl;
} }

View File

@ -33,8 +33,8 @@ class ModsecBuild : public Variable {
explicit ModsecBuild(std::string _name) explicit ModsecBuild(std::string _name)
: Variable(_name) { } : Variable(_name) { }
std::list<transaction::Variable *> * void evaluateInternal(Assay *assay,
evaluate(Assay *assay) override; std::vector<const transaction::Variable *> *l) override;
}; };

View File

@ -33,10 +33,8 @@
namespace ModSecurity { namespace ModSecurity {
namespace Variables { namespace Variables {
std::list<transaction::Variable *> * void Time::evaluateInternal(Assay *assay,
Time::evaluate(Assay *assay) { std::vector<const transaction::Variable *> *l) {
std::list<transaction::Variable *> *resl =
new std::list<transaction::Variable *>();
char tstr[200]; char tstr[200];
struct tm timeinfo; struct tm timeinfo;
@ -48,9 +46,7 @@ std::list<transaction::Variable *> *
localtime_r(&timer, &timeinfo); localtime_r(&timer, &timeinfo);
strftime(tstr, 200, "%H:%M:%S", &timeinfo); strftime(tstr, 200, "%H:%M:%S", &timeinfo);
resl->push_back(new transaction::Variable("TIME", std::string(tstr))); l->push_back(new transaction::Variable("TIME", std::string(tstr)));
return resl;
} }

View File

@ -34,8 +34,8 @@ class Time : public Variable {
explicit Time(std::string _name) explicit Time(std::string _name)
: Variable(_name) { } : Variable(_name) { }
std::list<transaction::Variable *> * void evaluateInternal(Assay *assay,
evaluate(Assay *assay) override; std::vector<const transaction::Variable *> *l) override;
}; };
} // namespace Variables } // namespace Variables

View File

@ -33,11 +33,8 @@
namespace ModSecurity { namespace ModSecurity {
namespace Variables { namespace Variables {
std::list<transaction::Variable *> * void TimeDay::evaluateInternal(Assay *assay,
TimeDay::evaluate(Assay *assay) { std::vector<const transaction::Variable *> *l) {
std::list<transaction::Variable *> *resl =
new std::list<transaction::Variable *>();
char tstr[200]; char tstr[200];
struct tm timeinfo; struct tm timeinfo;
time_t timer; time_t timer;
@ -48,9 +45,7 @@ std::list<transaction::Variable *> *
localtime_r(&timer, &timeinfo); localtime_r(&timer, &timeinfo);
strftime(tstr, 200, "%d", &timeinfo); strftime(tstr, 200, "%d", &timeinfo);
resl->push_back(new transaction::Variable("TIME_DAY", std::string(tstr))); l->push_back(new transaction::Variable("TIME_DAY", std::string(tstr)));
return resl;
} }

View File

@ -33,8 +33,8 @@ class TimeDay : public Variable {
explicit TimeDay(std::string _name) explicit TimeDay(std::string _name)
: Variable(_name) { } : Variable(_name) { }
std::list<transaction::Variable *> * void evaluateInternal(Assay *assay,
evaluate(Assay *assay) override; std::vector<const transaction::Variable *> *l) override;
}; };
} // namespace Variables } // namespace Variables

View File

@ -33,15 +33,10 @@
namespace ModSecurity { namespace ModSecurity {
namespace Variables { namespace Variables {
std::list<transaction::Variable *> * void TimeEpoch::evaluateInternal(Assay *assay,
TimeEpoch::evaluate(Assay *assay) { std::vector<const transaction::Variable *> *l) {
std::list<transaction::Variable *> *resl = l->push_back(new transaction::Variable("TIME_EPOCH",
new std::list<transaction::Variable *>();
resl->push_back(new transaction::Variable("TIME_EPOCH",
std::to_string(std::time(nullptr)))); std::to_string(std::time(nullptr))));
return resl;
} }

View File

@ -33,8 +33,8 @@ class TimeEpoch : public Variable {
explicit TimeEpoch(std::string _name) explicit TimeEpoch(std::string _name)
: Variable(_name) { } : Variable(_name) { }
std::list<transaction::Variable *> * void evaluateInternal(Assay *assay,
evaluate(Assay *assay) override; std::vector<const transaction::Variable *> *l) override;
}; };
} // namespace Variables } // namespace Variables

View File

@ -33,11 +33,8 @@
namespace ModSecurity { namespace ModSecurity {
namespace Variables { namespace Variables {
std::list<transaction::Variable *> * void TimeHour::evaluateInternal(Assay *assay,
TimeHour::evaluate(Assay *assay) { std::vector<const transaction::Variable *> *l) {
std::list<transaction::Variable *> *resl =
new std::list<transaction::Variable *>();
char tstr[200]; char tstr[200];
struct tm timeinfo; struct tm timeinfo;
time_t timer; time_t timer;
@ -48,9 +45,7 @@ std::list<transaction::Variable *> *
localtime_r(&timer, &timeinfo); localtime_r(&timer, &timeinfo);
strftime(tstr, 200, "%H", &timeinfo); strftime(tstr, 200, "%H", &timeinfo);
resl->push_back(new transaction::Variable("TIME_HOUR", std::string(tstr))); l->push_back(new transaction::Variable("TIME_HOUR", std::string(tstr)));
return resl;
} }

View File

@ -33,8 +33,8 @@ class TimeHour : public Variable {
explicit TimeHour(std::string _name) explicit TimeHour(std::string _name)
: Variable(_name) { } : Variable(_name) { }
std::list<transaction::Variable *> * void evaluateInternal(Assay *assay,
evaluate(Assay *assay) override; std::vector<const transaction::Variable *> *l) override;
}; };
} // namespace Variables } // namespace Variables

View File

@ -33,11 +33,8 @@
namespace ModSecurity { namespace ModSecurity {
namespace Variables { namespace Variables {
std::list<transaction::Variable *> * void TimeMin::evaluateInternal(Assay *assay,
TimeMin::evaluate(Assay *assay) { std::vector<const transaction::Variable *> *l) {
std::list<transaction::Variable *> *resl =
new std::list<transaction::Variable *>();
char tstr[200]; char tstr[200];
struct tm timeinfo; struct tm timeinfo;
time_t timer; time_t timer;
@ -48,9 +45,7 @@ std::list<transaction::Variable *> *
localtime_r(&timer, &timeinfo); localtime_r(&timer, &timeinfo);
strftime(tstr, 200, "%M", &timeinfo); strftime(tstr, 200, "%M", &timeinfo);
resl->push_back(new transaction::Variable("TIME_MIN", std::string(tstr))); l->push_back(new transaction::Variable("TIME_MIN", std::string(tstr)));
return resl;
} }

View File

@ -33,8 +33,8 @@ class TimeMin : public Variable {
explicit TimeMin(std::string _name) explicit TimeMin(std::string _name)
: Variable(_name) { } : Variable(_name) { }
std::list<transaction::Variable *> * void evaluateInternal(Assay *assay,
evaluate(Assay *assay) override; std::vector<const transaction::Variable *> *l) override;
}; };
} // namespace Variables } // namespace Variables

View File

@ -33,11 +33,8 @@
namespace ModSecurity { namespace ModSecurity {
namespace Variables { namespace Variables {
std::list<transaction::Variable *> * void TimeMon::evaluateInternal(Assay *assay,
TimeMon::evaluate(Assay *assay) { std::vector<const transaction::Variable *> *l) {
std::list<transaction::Variable *> *resl =
new std::list<transaction::Variable *>();
char tstr[200]; char tstr[200];
struct tm timeinfo; struct tm timeinfo;
time_t timer; time_t timer;
@ -50,9 +47,7 @@ std::list<transaction::Variable *> *
int a = atoi(tstr); int a = atoi(tstr);
a--; a--;
resl->push_back(new transaction::Variable("TIME_MON", std::to_string(a))); l->push_back(new transaction::Variable("TIME_MON", std::to_string(a)));
return resl;
} }

View File

@ -33,8 +33,8 @@ class TimeMon : public Variable {
explicit TimeMon(std::string _name) explicit TimeMon(std::string _name)
: Variable(_name) { } : Variable(_name) { }
std::list<transaction::Variable *> * void evaluateInternal(Assay *assay,
evaluate(Assay *assay) override; std::vector<const transaction::Variable *> *l) override;
}; };
} // namespace Variables } // namespace Variables

View File

@ -33,11 +33,8 @@
namespace ModSecurity { namespace ModSecurity {
namespace Variables { namespace Variables {
std::list<transaction::Variable *> * void TimeSec::evaluateInternal(Assay *assay,
TimeSec::evaluate(Assay *assay) { std::vector<const transaction::Variable *> *l) {
std::list<transaction::Variable *> *resl =
new std::list<transaction::Variable *>();
char tstr[200]; char tstr[200];
struct tm timeinfo; struct tm timeinfo;
time_t timer; time_t timer;
@ -48,9 +45,7 @@ std::list<transaction::Variable *> *
localtime_r(&timer, &timeinfo); localtime_r(&timer, &timeinfo);
strftime(tstr, 200, "%S", &timeinfo); strftime(tstr, 200, "%S", &timeinfo);
resl->push_back(new transaction::Variable("TIME_SEC", std::string(tstr))); l->push_back(new transaction::Variable("TIME_SEC", std::string(tstr)));
return resl;
} }

View File

@ -33,8 +33,8 @@ class TimeSec : public Variable {
explicit TimeSec(std::string _name) explicit TimeSec(std::string _name)
: Variable(_name) { } : Variable(_name) { }
std::list<transaction::Variable *> * void evaluateInternal(Assay *assay,
evaluate(Assay *assay) override; std::vector<const transaction::Variable *> *l) override;
}; };
} // namespace Variables } // namespace Variables

View File

@ -33,11 +33,8 @@
namespace ModSecurity { namespace ModSecurity {
namespace Variables { namespace Variables {
std::list<transaction::Variable *> * void TimeWDay::evaluateInternal(Assay *assay,
TimeWDay::evaluate(Assay *assay) { std::vector<const transaction::Variable *> *l) {
std::list<transaction::Variable *> *resl =
new std::list<transaction::Variable *>();
char tstr[200]; char tstr[200];
struct tm timeinfo; struct tm timeinfo;
time_t timer; time_t timer;
@ -50,9 +47,7 @@ std::list<transaction::Variable *> *
int a = atoi(tstr); int a = atoi(tstr);
a--; a--;
resl->push_back(new transaction::Variable("TIME_WDAY", std::to_string(a))); l->push_back(new transaction::Variable("TIME_WDAY", std::to_string(a)));
return resl;
} }

View File

@ -33,8 +33,8 @@ class TimeWDay : public Variable {
explicit TimeWDay(std::string _name) explicit TimeWDay(std::string _name)
: Variable(_name) { } : Variable(_name) { }
std::list<transaction::Variable *> * void evaluateInternal(Assay *assay,
evaluate(Assay *assay) override; std::vector<const transaction::Variable *> *l) override;
}; };
} // namespace Variables } // namespace Variables

View File

@ -33,11 +33,8 @@
namespace ModSecurity { namespace ModSecurity {
namespace Variables { namespace Variables {
std::list<transaction::Variable *> * void TimeYear::evaluateInternal(Assay *assay,
TimeYear::evaluate(Assay *assay) { std::vector<const transaction::Variable *> *l) {
std::list<transaction::Variable *> *resl =
new std::list<transaction::Variable *>();
char tstr[200]; char tstr[200];
struct tm timeinfo; struct tm timeinfo;
time_t timer; time_t timer;
@ -48,9 +45,7 @@ std::list<transaction::Variable *> *
localtime_r(&timer, &timeinfo); localtime_r(&timer, &timeinfo);
strftime(tstr, 200, "%Y", &timeinfo); strftime(tstr, 200, "%Y", &timeinfo);
resl->push_back(new transaction::Variable("TIME_YEAR", std::string(tstr))); l->push_back(new transaction::Variable("TIME_YEAR", std::string(tstr)));
return resl;
} }

View File

@ -33,8 +33,8 @@ class TimeYear : public Variable {
explicit TimeYear(std::string _name) explicit TimeYear(std::string _name)
: Variable(_name) { } : Variable(_name) { }
std::list<transaction::Variable *> * void evaluateInternal(Assay *assay,
evaluate(Assay *assay) override; std::vector<const transaction::Variable *> *l) override;
}; };
} // namespace Variables } // namespace Variables

View File

@ -33,20 +33,16 @@
namespace ModSecurity { namespace ModSecurity {
namespace Variables { namespace Variables {
std::list<transaction::Variable *> *
Tx::evaluate(Assay *assay) {
std::list<transaction::Variable *> *resl =
new std::list<transaction::Variable *>();
void Tx::evaluateInternal(Assay *assay,
std::vector<const transaction::Variable *> *l) {
if (m_type == SingleMatch) { if (m_type == SingleMatch) {
assay->m_collections.resolveSingleMatch(m_name, "TX", resl); assay->m_collections.resolveSingleMatch(m_name, "TX", l);
} else if (m_type == MultipleMatches) { } else if (m_type == MultipleMatches) {
assay->m_collections.resolveMultiMatches(m_name, "TX", resl); assay->m_collections.resolveMultiMatches(m_name, "TX", l);
} else if (m_type == RegularExpression) { } else if (m_type == RegularExpression) {
assay->m_collections.resolveRegularExpression(m_name, "TX", resl); assay->m_collections.resolveRegularExpression(m_name, "TX", l);
} }
return resl;
} }

View File

@ -34,8 +34,8 @@ class Tx : public Variable {
explicit Tx(std::string _name) explicit Tx(std::string _name)
: Variable(_name) { } : Variable(_name) { }
std::list<transaction::Variable *> * void evaluateInternal(Assay *assay,
evaluate(Assay *assay) override; std::vector<const transaction::Variable *> *l) override;
}; };
} // namespace Variables } // namespace Variables

View File

@ -73,11 +73,15 @@ Variable::Variable(std::string name, VariableKind kind)
} }
std::list<transaction::Variable *> * std::vector<const transaction::Variable *> *
Variable::evaluate(Assay *assay) { Variable::evaluate(Assay *assay) {
std::list<transaction::Variable *> *l = std::vector<const transaction::Variable *> *l = new std::vector<const transaction::Variable *>();
new std::list<transaction::Variable *>(); evaluate(assay, l);
return l;
}
void Variable::evaluateInternal(Assay *assay, std::vector<const transaction::Variable *> *l) {
if (m_collectionName.empty() == false) { if (m_collectionName.empty() == false) {
if (m_kind == CollectionVarible && m_type == MultipleMatches) { if (m_kind == CollectionVarible && m_type == MultipleMatches) {
assay->m_collections.resolveMultiMatches(m_name, m_collectionName, l); assay->m_collections.resolveMultiMatches(m_name, m_collectionName, l);
@ -95,8 +99,11 @@ std::list<transaction::Variable *> *
assay->m_collections.resolveSingleMatch(m_name, l); assay->m_collections.resolveSingleMatch(m_name, l);
} }
} }
}
return l;
void Variable::evaluate(Assay *assay, std::vector<const transaction::Variable *> *l) {
evaluateInternal(assay, l);
} }

View File

@ -66,8 +66,10 @@ class Variable {
static std::string to_s(std::vector<Variable *> *variables); static std::string to_s(std::vector<Variable *> *variables);
virtual std::list<transaction::Variable *> *evaluate(Assay *assay); virtual std::vector<const transaction::Variable *> *evaluate(Assay *assay);
//virtual std::list<transaction::Variable *> *eval_int(Assay *assay); virtual void evaluate(Assay *assay, std::vector<const transaction::Variable *> *l);
virtual void evaluateInternal(Assay *assay, std::vector<const transaction::Variable *> *l);
std::string m_name; std::string m_name;
std::string m_collectionName; std::string m_collectionName;

View File

@ -28,11 +28,9 @@ namespace ModSecurity {
namespace Variables { namespace Variables {
namespace Variations { namespace Variations {
std::list<transaction::Variable *> * void Count::evaluateInternal(Assay *assay,
Count::evaluate(Assay *assay) { std::vector<const transaction::Variable *> *l) {
std::list<transaction::Variable *> *reslIn; std::vector<const transaction::Variable *> *reslIn;
std::list<transaction::Variable *> *reslOut =
new std::list<transaction::Variable *>();
int count = 0; int count = 0;
reslIn = var->evaluate(assay); reslIn = var->evaluate(assay);
@ -42,17 +40,15 @@ std::list<transaction::Variable *> *
} }
while (reslIn->empty() == false) { while (reslIn->empty() == false) {
delete reslIn->front(); delete reslIn->back();
reslIn->pop_front(); reslIn->pop_back();
} }
delete reslIn; delete reslIn;
std::string res = std::to_string(count); std::string res = std::to_string(count);
reslOut->push_back(new transaction::Variable(std::string(var->m_name), l->push_back(new transaction::Variable(std::string(var->m_name),
std::string(res))); std::string(res)));
return reslOut;
} }

View File

@ -35,8 +35,8 @@ class Count : public Variable {
: Variable("count(" + v->m_name + ")"), : Variable("count(" + v->m_name + ")"),
var(v) { } var(v) { }
std::list<transaction::Variable *> * void evaluateInternal(Assay *assay,
evaluate(Assay *assay) override; std::vector<const transaction::Variable *> *l) override;
Variable *var; Variable *var;
}; };

View File

@ -29,12 +29,9 @@ namespace Variables {
namespace Variations { namespace Variations {
std::list<transaction::Variable *> * void Exclusion::evaluateInternal(Assay *assay,
Exclusion::evaluate(Assay *assay) { std::vector<const transaction::Variable *> *l) {
std::list<transaction::Variable *> *l = assay->m_collections.resolveMultiMatches(m_name, l);
new std::list<transaction::Variable *>();
assay->m_collections.resolve(this->m_name, l);
return l;
} }

View File

@ -37,8 +37,8 @@ class Exclusion : public Variable {
var(v) var(v)
{ m_isExclusion = true; } { m_isExclusion = true; }
std::list<transaction::Variable *> * void evaluateInternal(Assay *assay,
evaluate(Assay *assay) override; std::vector<const transaction::Variable *> *l) override;
Variable *var; Variable *var;
}; };