ModSecurity/src/operators/ip_match.cc
Felipe Zimmerle 9f47f1473c
Removes memory leaks on the parse
- Parser location is now a custom class. It holds a shared pointer
  with the file name; If the parser fails, the resource is deleted.

 - To follow the parser change, the Rule class now holds the file
  name in a shared pointer instead of a unique pointer. As a shared
  pointer we avoid duplication of the file name in memory, plus,
  it frees itself when not in use anymore.

 - Operator init also accepting the filename as a shared pointer.

 - Driver is treating m_location was privative. Now it holds a
  std::list<std::shared_ptr<yy::seclang_parser::location_type>>
  instead of: std::list<yy::seclang_parser::location_type *>.

 - Fix: addSecRule on Driver() was changed from RuleWithAction to
  RuleWithOperator.

 - Minor changes on the regression and rules-check utility to force
  deletion of resources even when they fail.

 - Couple of virtual destructors were placed to force the shared
  pointer decrementing on shared variables.

 - Deleted constructors for copy were placed for the sake of
  readability.
2021-01-12 13:01:26 -03:00

50 lines
1.2 KiB
C++

/*
* ModSecurity, http://www.modsecurity.org/
* Copyright (c) 2015 - 2020 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 "src/operators/ip_match.h"
#include <string.h>
#include <string>
#include "src/utils/msc_tree.h"
#include "src/operators/operator.h"
namespace modsecurity {
namespace operators {
bool IpMatch::init(std::shared_ptr<std::string> file, std::string *error) {
std::string e("");
bool res = m_tree.addFromBuffer(m_param, &e);
if (res == false) {
error->assign(e);
}
return res;
}
bool IpMatch::evaluate(Transaction *transaction,
const RuleWithActions *rule,
const bpstd::string_view &str,
RuleMessage *ruleMessage) {
return m_tree.contains(str.c_str());
}
} // namespace operators
} // namespace modsecurity