Collection class was changed to be a simple interface

InMomoryPerProcess class was added to be used where the old Collection
was used.

headers/modsecurity/collection/collection.h

@@ -0,0 +1,66 @@
+/*
+ * 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.
+ *
+ */
+
+
+#ifdef __cplusplus
+#include <string>
+#include <iostream>
+#include <unordered_map>
+#include <list>
+#include <vector>
+#include <algorithm>
+#endif
+
+
+#include "modsecurity/collection/variable.h"
+
+#ifndef HEADERS_MODSECURITY_TRANSACTION_COLLECTION_H_
+#define HEADERS_MODSECURITY_TRANSACTION_COLLECTION_H_
+
+#ifndef __cplusplus
+typedef struct Variable_t Variables;
+#endif
+
+#ifdef __cplusplus
+namespace modsecurity {
+namespace collection {
+
+class Collection {
+ public:
+    virtual void store(std::string key, std::string value) = 0;
+
+    virtual bool storeOrUpdateFirst(const std::string &key,
+        const std::string &value) = 0;
+
+    virtual bool updateFirst(const std::string &key, const std::string &value) = 0;
+
+    virtual void del(const std::string& key) = 0;
+
+    virtual std::string* resolveFirst(const std::string& var) = 0;
+
+    virtual void resolveSingleMatch(const std::string& var,
+        std::vector<const Variable *> *l) = 0;
+    virtual void resolveMultiMatches(const std::string& var,
+        std::vector<const Variable *> *l) = 0;
+    virtual void resolveRegularExpression(const std::string& var,
+        std::vector<const Variable *> *l) = 0;
+};
+
+}  // namespace collection
+}  // namespace modsecurity
+#endif
+
+
+#endif  // HEADERS_MODSECURITY_TRANSACTION_COLLECTION_H_

headers/modsecurity/collection/collections.h

@@ -0,0 +1,102 @@
+/*
+ * 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.
+ *
+ */
+
+
+#ifdef __cplusplus
+#include <ctime>
+#include <iostream>
+#include <unordered_map>
+#include <fstream>
+#include <vector>
+#include <iomanip>
+#include <set>
+#include <cstdio>
+#include <string>
+#include <list>
+#endif
+
+#include "modsecurity/collection/global_collection.h"
+#include "modsecurity/collection/collection.h"
+#include "modsecurity/collection/variable.h"
+
+#ifndef HEADERS_MODSECURITY_TRANSACTION_COLLECTIONS_H_
+#define HEADERS_MODSECURITY_TRANSACTION_COLLECTIONS_H_
+
+#ifndef __cplusplus
+typedef struct Collections_t Collections;
+#endif
+
+#ifdef __cplusplus
+
+namespace modsecurity {
+namespace collection {
+
+class Collections :
+    public std::unordered_map<std::string, Collection *> {
+ public:
+    Collections(GlobalCollection *global, GlobalCollection *ip);
+    ~Collections();
+
+    void store(std::string key, std::string value);
+    void storeOrUpdateFirst(const std::string& collectionName,
+        const std::string& variableName,
+        const std::string& targetValue);
+    bool storeOrUpdateFirst(const std::string &key, const std::string &value);
+    bool updateFirst(const std::string &key, const std::string &value);
+    void del(const std::string& key);
+    std::string* resolveFirst(const std::string& var);
+    std::string* resolveFirst(const std::string& collectionName,
+        const std::string& var);
+
+    void resolveSingleMatch(const std::string& var,
+        std::vector<const Variable *> *l);
+    void resolveSingleMatch(const std::string& var,
+        const std::string& collection,
+        std::vector<const Variable *> *l);
+    void resolveMultiMatches(const std::string& var,
+        std::vector<const Variable *> *l);
+    void resolveMultiMatches(const std::string& var,
+        const std::string& collection,
+        std::vector<const Variable *> *l);
+    void resolveRegularExpression(const std::string& var,
+        std::vector<const Variable *> *l);
+    void resolveRegularExpression(const std::string& var,
+        const std::string& collection,
+        std::vector<const Variable *> *l);
+
+    /**
+     * This is a special collection to host the transaction variables.
+     *
+     * It exists independent of initialization and it is only valid during a transaction.
+     *
+     * Notice that it is not the TX collection.
+     */
+    Collection *m_transient;
+
+    std::string m_global_collection_key;
+    std::string m_ip_collection_key;
+
+    GlobalCollection *m_global_collection;
+    GlobalCollection *m_ip_collection;
+};
+
+}  // namespace collection
+}  // namespace modsecurity
+#endif
+
+
+#endif  // HEADERS_MODSECURITY_TRANSACTION_COLLECTIONS_H_
+
+

headers/modsecurity/collection/global_collection.h

@@ -0,0 +1,119 @@
+/*
+ * 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.
+ *
+ */
+
+
+#ifdef __cplusplus
+#include <algorithm>
+#include <iostream>
+#include <list>
+#include <string>
+#include <unordered_map>
+#include <vector>
+#endif
+
+#include "modsecurity/collection/collection.h"
+#include "modsecurity/collection/variable.h"
+
+
+#ifndef HEADERS_MODSECURITY_TRANSACTION_GLOBAL_COLLECTION_H_
+#define HEADERS_MODSECURITY_TRANSACTION_GLOBAL_COLLECTION_H_
+
+#ifndef __cplusplus
+typedef struct GlobalCollection_t GlobalCollection;
+#endif
+
+#ifdef __cplusplus
+namespace modsecurity {
+namespace collection {
+
+class CollectionKey {
+ public:
+    CollectionKey()
+        : m_compartiment(""),
+        m_name("") { }
+    explicit CollectionKey(std::string name)
+        : m_compartiment(""),
+        m_name(name) { }
+    CollectionKey(std::string name, std::string compartiment)
+        : m_compartiment(compartiment),
+        m_name(name) { }
+
+    std::string m_name;
+    std::string m_compartiment;
+};
+
+
+class collection_hash {
+ public:
+    size_t operator()(const CollectionKey *v) const {
+        size_t h = 0;
+        std::for_each(v->m_name.begin(), v->m_name.end(), [&](char c) {
+            h += tolower(c);
+        });
+        std::for_each(v->m_compartiment.begin(),
+            v->m_compartiment.end(), [&](char c) {
+            h += tolower(c);
+        });
+
+        return h;
+    }
+};
+
+
+class collection_equal {
+ public:
+    bool operator()(const CollectionKey *u, const CollectionKey *v) const {
+        return u->m_name == v->m_name
+            && u->m_compartiment == v->m_compartiment;
+    }
+};
+
+
+class GlobalCollection :
+    public std::unordered_multimap<CollectionKey *, std::string,
+        collection_hash, collection_equal> {
+ public:
+    GlobalCollection();
+    ~GlobalCollection();
+    void store(std::string key, std::string compartment, std::string value);
+
+    bool storeOrUpdateFirst(const std::string &key, std::string compartment,
+        const std::string &value);
+
+    bool updateFirst(const std::string &key, std::string compartment,
+        const std::string &value);
+
+    void del(const std::string& key, std::string compartment);
+
+    std::string* resolveFirst(const std::string& var, std::string compartment);
+    void resolveSingleMatch(const std::string& var, std::string compartment,
+        std::vector<const Variable *> *l);
+    void resolveMultiMatches(const std::string& var, std::string compartment,
+        std::vector<const Variable *> *l);
+
+    void resolveRegularExpression(const std::string& var,
+        std::string compartment,
+        std::vector<const Variable *> *l);
+};
+
+}  // namespace collection
+}  // namespace modsecurity
+
+#endif
+
+
+#endif  // HEADERS_MODSECURITY_TRANSACTION_GLOBAL_COLLECTION_H_
+
+

headers/modsecurity/collection/variable.h

@@ -0,0 +1,47 @@
+/*
+ * 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.
+ *
+ */
+
+
+#ifdef __cplusplus
+#include <string>
+#endif
+
+
+#ifndef HEADERS_MODSECURITY_TRANSACTION_VARIABLE_H_
+#define HEADERS_MODSECURITY_TRANSACTION_VARIABLE_H_
+
+
+#ifndef __cplusplus
+typedef struct Variable_t Variable;
+#endif
+
+#ifdef __cplusplus
+namespace modsecurity {
+namespace collection {
+
+class Variable {
+ public:
+     Variable(const std::string& key, const std::string& value) :
+        m_key(key),
+        m_value(value) { }
+     std::string m_key;
+     std::string m_value;
+};
+
+}  // namespace collection
+}  // namespace modsecurity
+#endif
+
+#endif  // HEADERS_MODSECURITY_TRANSACTION_VARIABLE_H_