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

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

Browse Source
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
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
headers/modsecurity/transaction/collections.h
View File

@ -60,26 +60,21 @@ class Collections :
std::string* resolveFirst(const std::string& collectionName,
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,
std::list<transaction::Variable *> *l);
std::vector<const transaction::Variable *> *l);
void resolveSingleMatch(const std::string& var,
const std::string& collection,
std::list<transaction::Variable *> *l);
std::vector<const transaction::Variable *> *l);
void resolveMultiMatches(const std::string& var,
std::list<transaction::Variable *> *l);
std::vector<const transaction::Variable *> *l);
void resolveMultiMatches(const std::string& var,
const std::string& collection,
std::list<transaction::Variable *> *l);
std::vector<const transaction::Variable *> *l);
void resolveRegularExpression(const std::string& var,
std::list<transaction::Variable *> *l);
std::vector<const transaction::Variable *> *l);
void resolveRegularExpression(const std::string& var,
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.

11
headers/modsecurity/transaction/variables.h
View File

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

8
src/assay.cc
View File

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

35
src/collections.cc
View File

@ -21,6 +21,7 @@
#include <iostream>
#include <unordered_map>
#include <list>
#include <vector>
#endif
#include "modsecurity/transaction/variable.h"
@ -115,33 +116,11 @@ std::string* Collections::resolveFirst(const std::string& collectionName,
}
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,
std::list<transaction::Variable *> *l) {
std::vector<const transaction::Variable *> *l) {
m_transient.resolveSingleMatch(var, l);
}
@ -149,7 +128,7 @@ void Collections::resolveSingleMatch(const std::string& var,
void Collections::resolveSingleMatch(const std::string& var,
const std::string& collection,
std::list<transaction::Variable *> *l) {
std::vector<const transaction::Variable *> *l) {
try {
this->at(collection)->resolveSingleMatch(var, l);
@ -159,7 +138,7 @@ void Collections::resolveSingleMatch(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);
}
@ -167,7 +146,7 @@ void Collections::resolveMultiMatches(const std::string& var,
void Collections::resolveMultiMatches(const std::string& var,
const std::string& collection,
std::list<transaction::Variable *> *l) {
std::vector<const transaction::Variable *> *l) {
try {
this->at(collection)->resolveMultiMatches(var, l);
} catch (...) {
@ -176,14 +155,14 @@ void Collections::resolveMultiMatches(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);
}
void Collections::resolveRegularExpression(const std::string& var,
const std::string& collection,
std::list<transaction::Variable *> *l) {
std::vector<const transaction::Variable *> *l) {
try {
this->at(collection)->resolveRegularExpression(var, l);

25
src/rule.cc
View File

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

53
src/variables.cc
View File

@ -65,9 +65,8 @@ void Variables::del(const std::string& key) {
}
void Variables::resolveSingleMatch(const std::string& var,
std::list<transaction::Variable *> *l) {
std::vector<const transaction::Variable *> *l) {
auto range = this->equal_range(var);
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,
std::list<transaction::Variable *> *l) {
std::vector<const transaction::Variable *> *l) {
size_t keySize = var.size();
l->reserve(15);
auto range = this->equal_range(var);
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) {
continue;
}
@ -96,55 +96,18 @@ void Variables::resolveMultiMatches(const std::string& var,
if (x.first.compare(0, keySize, var) != 0) {
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,
std::list<transaction::Variable *> *l) {
std::vector<const transaction::Variable *> *l) {
/* 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) {
auto range = equal_range(var);

10
src/variables/duration.cc
View File

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

4
src/variables/duration.h
View File

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

15
src/variables/env.cc
View File

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

4
src/variables/env.h
View File

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

11
src/variables/highest_severity.cc
View File

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

4
src/variables/highest_severity.h
View File

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

11
src/variables/modsec_build.cc
View File

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

4
src/variables/modsec_build.h
View File

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

10
src/variables/time.cc
View File

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

4
src/variables/time.h
View File

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

11
src/variables/time_day.cc
View File

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

4
src/variables/time_day.h
View File

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

11
src/variables/time_epoch.cc
View File

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

4
src/variables/time_epoch.h
View File

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

11
src/variables/time_hour.cc
View File

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

4
src/variables/time_hour.h
View File

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

11
src/variables/time_min.cc
View File

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

4
src/variables/time_min.h
View File

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

11
src/variables/time_mon.cc
View File

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

4
src/variables/time_mon.h
View File

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

11
src/variables/time_sec.cc
View File

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

4
src/variables/time_sec.h
View File

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

11
src/variables/time_wday.cc
View File

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

4
src/variables/time_wday.h
View File

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

11
src/variables/time_year.cc
View File

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

4
src/variables/time_year.h
View File

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

14
src/variables/tx.cc
View File

@ -33,20 +33,16 @@
namespace ModSecurity {
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) {
assay->m_collections.resolveSingleMatch(m_name, "TX", resl);
assay->m_collections.resolveSingleMatch(m_name, "TX", l);
} 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) {
assay->m_collections.resolveRegularExpression(m_name, "TX", resl);
assay->m_collections.resolveRegularExpression(m_name, "TX", l);
}
return resl;
}

4
src/variables/tx.h
View File

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

15
src/variables/variable.cc
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) {
std::list<transaction::Variable *> *l =
new std::list<transaction::Variable *>();
std::vector<const transaction::Variable *> *l = new std::vector<const 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_kind == CollectionVarible && m_type == MultipleMatches) {
assay->m_collections.resolveMultiMatches(m_name, m_collectionName, l);
@ -95,8 +99,11 @@ std::list<transaction::Variable *> *
assay->m_collections.resolveSingleMatch(m_name, l);
}
}
}
return l;
void Variable::evaluate(Assay *assay, std::vector<const transaction::Variable *> *l) {
evaluateInternal(assay, l);
}

6
src/variables/variable.h
View File

@ -66,8 +66,10 @@ class Variable {
static std::string to_s(std::vector<Variable *> *variables);
virtual std::list<transaction::Variable *> *evaluate(Assay *assay);
//virtual std::list<transaction::Variable *> *eval_int(Assay *assay);
virtual std::vector<const transaction::Variable *> *evaluate(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_collectionName;

16
src/variables/variations/count.cc
View File

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

4
src/variables/variations/count.h
View File

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

9
src/variables/variations/exclusion.cc
View File

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

4
src/variables/variations/exclusion.h
View File

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