Warming up to the remote collections support

Huge refactoring to have the code in shape to later support the
remote collections with different backends.

src/collection/collection.cc

@@ -0,0 +1,125 @@
+/*
+ * ModSecurity, http://www.modsecurity.org/
+ * Copyright (c) 2015 Trustwave Holdings, Inc. (http://www.trustwave.com/)
+ *
+ * You may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * If any of the files related to licensing are missing or if you have any
+ * other questions related to licensing please contact Trustwave Holdings, Inc.
+ * directly using the email address security@modsecurity.org.
+ *
+ */
+
+
+#include "modsecurity/collection/collection.h"
+
+#ifdef __cplusplus
+#include <string>
+#include <iostream>
+#include <unordered_map>
+#include <list>
+#endif
+
+#include "modsecurity/collection/variable.h"
+#include "src/utils.h"
+
+namespace modsecurity {
+namespace collection {
+
+
+Collection::Collection() {
+    this->reserve(1000);
+}
+
+Collection::~Collection() {
+    this->clear();
+}
+
+void Collection::store(std::string key, std::string value) {
+    this->emplace(key, value);
+}
+
+
+bool Collection::storeOrUpdateFirst(const std::string &key,
+    const std::string &value) {
+    if (updateFirst(key, value) == false) {
+        store(key, value);
+    }
+    return true;
+}
+
+
+bool Collection::updateFirst(const std::string &key, const std::string &value) {
+    auto range = this->equal_range(key);
+
+    for (auto it = range.first; it != range.second; ++it) {
+        it->second = value;
+        return true;
+    }
+    return false;
+}
+
+
+void Collection::del(const std::string& key) {
+    this->erase(key);
+}
+
+
+void Collection::resolveSingleMatch(const std::string& var,
+    std::vector<const Variable *> *l) {
+    auto range = this->equal_range(var);
+
+    for (auto it = range.first; it != range.second; ++it) {
+        l->push_back(new Variable(var, it->second));
+    }
+}
+
+
+void Collection::resolveMultiMatches(const std::string& var,
+    std::vector<const 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->insert(l->begin(), new Variable(var, it->second));
+    }
+
+    for (const auto& x : *this) {
+        if (x.first.size() <= keySize + 1) {
+            continue;
+        }
+        if (x.first.at(keySize) != ':') {
+            continue;
+        }
+        if (x.first.compare(0, keySize, var) != 0) {
+            continue;
+        }
+        l->insert(l->begin(), new Variable(x.first, x.second));
+    }
+}
+
+
+void Collection::resolveRegularExpression(const std::string& var,
+    std::vector<const Variable *> *l) {
+    /* Not ready */
+}
+
+
+std::string* Collection::resolveFirst(const std::string& var) {
+    auto range = equal_range(var);
+
+    for (auto it = range.first; it != range.second; ++it) {
+        return &it->second;
+    }
+
+    return NULL;
+}
+
+
+}  // namespace collection
+}  // namespace modsecurity

src/collection/collections.cc

@@ -0,0 +1,239 @@
+/*
+ * ModSecurity, http://www.modsecurity.org/
+ * Copyright (c) 2015 Trustwave Holdings, Inc. (http://www.trustwave.com/)
+ *
+ * You may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * If any of the files related to licensing are missing or if you have any
+ * other questions related to licensing please contact Trustwave Holdings, Inc.
+ * directly using the email address security@modsecurity.org.
+ *
+ */
+
+
+#include "modsecurity/collection/collections.h"
+
+#ifdef __cplusplus
+#include <string>
+#include <iostream>
+#include <unordered_map>
+#include <list>
+#include <vector>
+#endif
+
+#include "modsecurity/collection/variable.h"
+#include "modsecurity/collection/collection.h"
+#include "src/utils.h"
+
+namespace modsecurity {
+namespace collection {
+
+
+Collections::Collections(GlobalCollection *global,
+    GlobalCollection *ip)
+    : m_global_collection_key(""),
+    m_ip_collection_key(""),
+    m_global_collection(global),
+    m_ip_collection(ip) {
+    /* Create collection TX */
+    this->emplace("TX", new Collection());
+}
+
+
+Collections::~Collections() {
+    for (const auto &thing : *this) {
+        delete thing.second;
+    }
+    this->clear();
+}
+
+void Collections::storeOrUpdateFirst(const std::string& collectionName,
+    const std::string& variableName,
+    const std::string& targetValue) {
+    if (tolower(collectionName) == "ip"
+        && !m_ip_collection_key.empty()) {
+        m_ip_collection->storeOrUpdateFirst(collectionName + ":"
+            + variableName, m_ip_collection_key, targetValue);
+        return;
+    }
+
+    if (tolower(collectionName) == "global"
+        && !m_global_collection_key.empty()) {
+        m_global_collection->storeOrUpdateFirst(collectionName + ":"
+            + variableName, m_global_collection_key, targetValue);
+        return;
+    }
+
+    try {
+        Collection *collection;
+        collection = this->at(collectionName);
+        collection->storeOrUpdateFirst(collectionName + ":"
+            + variableName, targetValue);
+    } catch (...) {
+#if 0
+        debug(9, "don't know any collection named: "
+            + collectionName + ". it was created?");
+#endif
+    }
+}
+
+
+void Collections::store(std::string key, std::string value) {
+    m_transient.store(key, value);
+}
+
+
+bool Collections::storeOrUpdateFirst(const std::string &key,
+    const std::string &value) {
+    return m_transient.storeOrUpdateFirst(key, value);
+}
+
+
+bool Collections::updateFirst(const std::string &key,
+    const std::string &value) {
+    return m_transient.updateFirst(key, value);
+}
+
+
+void Collections::del(const std::string& key) {
+    return m_transient.del(key);
+}
+
+
+std::string* Collections::resolveFirst(const std::string& var) {
+    std::string *transientVar = m_transient.resolveFirst(var);
+
+    if (transientVar != NULL) {
+        return transientVar;
+    }
+
+    for (auto &a : *this) {
+        auto range = a.second->equal_range(var);
+        for (auto it = range.first; it != range.second; ++it) {
+            return & it->second;
+        }
+    }
+
+    return NULL;
+}
+
+
+std::string* Collections::resolveFirst(const std::string& collectionName,
+        const std::string& var) {
+        if (tolower(collectionName) == "ip"
+            && !m_ip_collection_key.empty()) {
+            return m_ip_collection->resolveFirst(toupper(collectionName)
+                    + ":" + var, m_ip_collection_key);
+        }
+
+        if (tolower(collectionName) == "global"
+            && !m_global_collection_key.empty()) {
+            return m_global_collection->resolveFirst(toupper(collectionName)
+                    + ":" + var, m_global_collection_key);
+        }
+
+        for (auto &a : *this) {
+            if (tolower(a.first) == tolower(collectionName)) {
+                Collection *t = a.second;
+                auto range = t->equal_range(toupper(collectionName)
+                    + ":" + var);
+                for (auto it = range.first; it != range.second; ++it) {
+                    return &it->second;
+                }
+            }
+        }
+
+        return NULL;
+}
+
+
+void Collections::resolveSingleMatch(const std::string& var,
+    std::vector<const Variable *> *l) {
+
+    m_transient.resolveSingleMatch(var, l);
+}
+
+
+void Collections::resolveSingleMatch(const std::string& var,
+    const std::string& collection,
+    std::vector<const Variable *> *l) {
+
+    if (tolower(collection) == "ip"
+        && !m_ip_collection_key.empty()) {
+        m_ip_collection->resolveSingleMatch(var, m_ip_collection_key, l);
+        return;
+    }
+
+    if (tolower(collection) == "global"
+        && !m_global_collection_key.empty()) {
+        m_global_collection->resolveSingleMatch(var,
+            m_global_collection_key, l);
+        return;
+    }
+
+    try {
+        this->at(collection)->resolveSingleMatch(var, l);
+    } catch (...) { }
+}
+
+void Collections::resolveMultiMatches(const std::string& var,
+    std::vector<const Variable *> *l) {
+
+    m_transient.resolveMultiMatches(var, l);
+}
+
+
+void Collections::resolveMultiMatches(const std::string& var,
+    const std::string& collection,
+    std::vector<const Variable *> *l) {
+    if (tolower(collection) == "ip"
+        && !m_ip_collection_key.empty()) {
+        m_ip_collection->resolveMultiMatches(var, m_ip_collection_key, l);
+        return;
+    }
+
+    if (tolower(collection) == "global"
+        && !m_global_collection_key.empty()) {
+        m_global_collection->resolveMultiMatches(var,
+            m_global_collection_key, l);
+        return;
+    }
+
+    try {
+        this->at(collection)->resolveMultiMatches(var, l);
+    } catch (...) { }
+}
+
+void Collections::resolveRegularExpression(const std::string& var,
+    std::vector<const Variable *> *l) {
+    m_transient.resolveRegularExpression(var, l);
+}
+
+
+void Collections::resolveRegularExpression(const std::string& var,
+    const std::string& collection,
+    std::vector<const Variable *> *l) {
+    if (tolower(collection) == "ip"
+        && !m_ip_collection_key.empty()) {
+        m_ip_collection->resolveRegularExpression(toupper(collection)
+            + ":" + var, m_ip_collection_key, l);
+        return;
+    }
+
+    if (tolower(collection) == "global"
+        && !m_global_collection_key.empty()) {
+        m_global_collection->resolveRegularExpression(toupper(collection)
+            + ":" + var, m_global_collection_key, l);
+        return;
+    }
+
+    try {
+        this->at(collection)->resolveRegularExpression(var, l);
+    } catch (...) { }
+}
+
+}  // namespace collection
+}  // namespace modsecurity