Adds support to the operator @ipMatchFromFile and @ipMatchF

src/operators/ip_match.h

@@ -33,9 +33,9 @@ class IpMatch : public Operator {
 
     bool evaluate(Assay *assay, const std::string &input);
 
-    bool init(const char **error);
+    virtual bool init(const char **error);
 
- private:
+ protected:
     Utils::IpTree m_tree;
 };
 

src/operators/ip_match_f.cc

@@ -22,21 +22,6 @@
 namespace ModSecurity {
 namespace operators {
 
-bool IpMatchF::evaluate(Assay *assay) {
-    /**
-     * @todo Implement the operator IpMatchF.
-     *       Reference: https://github.com/SpiderLabs/ModSecurity/wiki/Reference-Manual#ipmatchf
-     */
-    return true;
-}
-
-
-IpMatchF::IpMatchF(std::string op, std::string param,
-    bool negation)
-    : Operator() {
-    this->op = op;
-    this->param = param;
-}
 
 }  // namespace operators
 }  // namespace ModSecurity

src/operators/ip_match_f.h

@@ -18,17 +18,16 @@
 
 #include <string>
 
-#include "operators/operator.h"
+#include "operators/ip_match_from_file.h"
 
 #ifdef __cplusplus
 namespace ModSecurity {
 namespace operators {
 
-class IpMatchF : public Operator {
+class IpMatchF : public IpMatchFromFile {
  public:
-    /** @ingroup ModSecurity_Operator */
-    IpMatchF(std::string p, std::string o, bool i);
-    bool evaluate(Assay *assay);
+    IpMatchF(std::string op, std::string param, bool negation)
+        : IpMatchFromFile(op, param, negation) { }
 };
 
 }  // namespace operators

src/operators/ip_match_from_file.cc

@@ -22,21 +22,24 @@
 namespace ModSecurity {
 namespace operators {
 
-bool IpMatchFromFile::evaluate(Assay *assay) {
-    /**
-     * @todo Implement the operator IpMatchFromFile.
-     *       Reference: https://github.com/SpiderLabs/ModSecurity/wiki/Reference-Manual#ipmatchfromfile
-     */
-    return true;
+
+bool IpMatchFromFile::init(const char **error) {
+    std::string e("");
+    bool res = false;
+
+    if (param.compare(0, 8, "https://") == 0) {
+        res = m_tree.addFromUrl(param, &e);
+    } else {
+        res = m_tree.addFromFile(param, &e);
+    }
+
+    if (res == false) {
+        *error = e.c_str();
+    }
+
+    return res;
 }
 
 
-IpMatchFromFile::IpMatchFromFile(std::string op, std::string param,
-    bool negation)
-    : Operator() {
-    this->op = op;
-    this->param = param;
-}
-
 }  // namespace operators
 }  // namespace ModSecurity

src/operators/ip_match_from_file.h

@@ -17,17 +17,19 @@
 
 #include <string>
 
-#include "operators/operator.h"
+#include "operators/ip_match.h"
 
 #ifdef __cplusplus
 namespace ModSecurity {
 namespace operators {
 
-class IpMatchFromFile : public Operator {
+class IpMatchFromFile : public IpMatch {
  public:
     /** @ingroup ModSecurity_Operator */
-    IpMatchFromFile(std::string o, std::string p, bool i);
-    bool evaluate(Assay *assay);
+    IpMatchFromFile(std::string op, std::string param, bool negation)
+        : IpMatch(op, param, negation) { }
+
+    bool init(const char **error) override;
 };
 
 }  // namespace operators

src/utils/ip_tree.cc

@@ -25,6 +25,7 @@
 #include <iostream>
 
 #include "utils/geo_lookup.h"
+#include "utils/https_client.h"
 
 namespace ModSecurity {
 namespace Utils {
@@ -77,16 +78,12 @@ IpTree::~IpTree() {
     }
 }
 
-
-bool IpTree::addFromBuffer(const std::string& buffer, std::string *error) {
+bool IpTree::addFromBuffer(std::istream *ss, std::string *error) {
     char *error_msg = NULL;
-    std::stringstream ss;
-    std::string line;
-    ss << buffer;
     int res = 0;
 
-    for (std::string line; std::getline(ss, line); ) {
-        res = ip_tree_from_param(buffer.c_str(), &m_tree, &error_msg);
+    for (std::string line; std::getline(*ss, line); ) {
+        res = ip_tree_from_param(line.c_str(), &m_tree, &error_msg);
         if (res != 0) {
             if (error_msg != NULL) {
                 error->assign(error_msg);
@@ -99,6 +96,40 @@ bool IpTree::addFromBuffer(const std::string& buffer, std::string *error) {
 }
 
 
+bool IpTree::addFromBuffer(const std::string& buffer, std::string *error) {
+    std::stringstream ss;
+    ss << buffer;
+
+    return addFromBuffer(&ss, error);
+}
+
+
+bool IpTree::addFromFile(const std::string& file, std::string *error) {
+    std::ifstream myfile(file, std::ios::in);
+
+    if (myfile.is_open() == false) {
+        error->assign("Failed to open file: " + file);
+        return false;
+    }
+
+    return addFromBuffer(&myfile, error);
+}
+
+
+bool IpTree::addFromUrl(const std::string& url, std::string *error) {
+    HttpsClient c;
+    bool ret = c.download(url);
+
+    if (ret == false) {
+        error->assign(c.error);
+    } else {
+        ret = addFromBuffer(c.content, error);
+    }
+
+    return ret;
+}
+
+
 bool IpTree::contains(const std::string& ip) {
     int res = 0;
     char *error_msg = NULL;

src/utils/ip_tree.h

@@ -37,8 +37,11 @@ class IpTree {
     ~IpTree();
 
     bool contains(const std::string &ip);
-    bool addFromBuffer(const std::string& buffer, std::string *error);
     void postOrderTraversal(TreeNode *node);
+    bool addFromBuffer(std::istream *ss, std::string *error);
+    bool addFromBuffer(const std::string& buffer, std::string *error);
+    bool addFromFile(const std::string& file, std::string *error);
+    bool addFromUrl(const std::string& url, std::string *error);
  private:
     TreeRoot *m_tree;
 };