Fix assorted memory and static analysis errors

src/variables/args.h

@@ -31,13 +31,13 @@ namespace Variables {
 
 class Args_DictElement : public Variable {
  public:
-    Args_DictElement(std::string dictElement)
+    explicit Args_DictElement(std::string dictElement)
         : Variable("ARGS" + std::string(":") + std::string(dictElement)),
         m_dictElement(dictElement) { }
 
     void evaluate(Transaction *transaction,
         Rule *rule,
-        std::vector<const collection::Variable *> *l) {
+        std::vector<const collection::Variable *> *l) override {
         transaction->m_variableArgs.resolve(m_dictElement, l);
     }
 
@@ -52,7 +52,7 @@ class Args_NoDictElement : public Variable {
 
     void evaluate(Transaction *transaction,
         Rule *rule,
-        std::vector<const collection::Variable *> *l) {
+        std::vector<const collection::Variable *> *l) override {
         transaction->m_variableArgs.resolve(l);
     }
 };
@@ -60,7 +60,7 @@ class Args_NoDictElement : public Variable {
 
 class Args_DictElementRegexp : public Variable {
  public:
-    Args_DictElementRegexp(std::string dictElement)
+    explicit Args_DictElementRegexp(std::string dictElement)
         : Variable("ARGS:regex(" + dictElement + ")"),
         m_r(dictElement) {
     }

src/variables/args_get.h

@@ -31,13 +31,13 @@ namespace Variables {
 
 class ArgsGet_DictElement : public Variable {
  public:
-    ArgsGet_DictElement(std::string dictElement)
+    explicit ArgsGet_DictElement(std::string dictElement)
         : Variable("ARGS_GET" + std::string(":") + std::string(dictElement)),
         m_dictElement(dictElement) { }
 
     void evaluate(Transaction *transaction,
         Rule *rule,
-        std::vector<const collection::Variable *> *l) {
+        std::vector<const collection::Variable *> *l) override {
         transaction->m_variableArgsGet.resolve(m_dictElement, l);
     }
 
@@ -52,7 +52,7 @@ class ArgsGet_NoDictElement : public Variable {
 
     void evaluate(Transaction *transaction,
         Rule *rule,
-        std::vector<const collection::Variable *> *l) {
+        std::vector<const collection::Variable *> *l) override {
         transaction->m_variableArgsGet.resolve(l);
     }
 };
@@ -60,7 +60,7 @@ class ArgsGet_NoDictElement : public Variable {
 
 class ArgsGet_DictElementRegexp : public Variable {
  public:
-    ArgsGet_DictElementRegexp(std::string dictElement)
+    explicit ArgsGet_DictElementRegexp(std::string dictElement)
         : Variable("ARGS_GET"),
         m_r(dictElement) { }
 

src/variables/args_post.h

@@ -31,13 +31,13 @@ namespace Variables {
 
 class ArgsPost_DictElement : public Variable {
  public:
-    ArgsPost_DictElement(std::string dictElement)
+    explicit ArgsPost_DictElement(std::string dictElement)
         : Variable("ARGS_POST" + std::string(":") + std::string(dictElement)),
         m_dictElement(dictElement) { }
 
     void evaluate(Transaction *transaction,
         Rule *rule,
-        std::vector<const collection::Variable *> *l) {
+        std::vector<const collection::Variable *> *l) override {
         transaction->m_variableArgsPost.resolve(m_dictElement, l);
     }
 
@@ -52,7 +52,7 @@ class ArgsPost_NoDictElement : public Variable {
 
     void evaluate(Transaction *transaction,
         Rule *rule,
-        std::vector<const collection::Variable *> *l) {
+        std::vector<const collection::Variable *> *l) override {
         transaction->m_variableArgsPost.resolve(l);
     }
 };
@@ -60,7 +60,7 @@ class ArgsPost_NoDictElement : public Variable {
 
 class ArgsPost_DictElementRegexp : public Variable {
  public:
-    ArgsPost_DictElementRegexp(std::string dictElement)
+    explicit ArgsPost_DictElementRegexp(std::string dictElement)
         : Variable("ARGS_POST"),
         m_r(dictElement) { }
 

src/variables/files.h

@@ -31,14 +31,14 @@ namespace Variables {
 
 class Files_DictElement : public Variable {
  public:
-    Files_DictElement(std::string dictElement)
+    explicit Files_DictElement(std::string dictElement)
         : Variable("FILES" + std::string(":") +
             std::string(dictElement)),
         m_dictElement(dictElement) { }
 
     void evaluate(Transaction *transaction,
         Rule *rule,
-        std::vector<const collection::Variable *> *l) {
+        std::vector<const collection::Variable *> *l) override {
         transaction->m_variableFiles.resolve(m_dictElement, l);
     }
 
@@ -53,7 +53,7 @@ class Files_NoDictElement : public Variable {
 
     void evaluate(Transaction *transaction,
         Rule *rule,
-        std::vector<const collection::Variable *> *l) {
+        std::vector<const collection::Variable *> *l) override {
         transaction->m_variableFiles.resolve(l);
     }
 };
@@ -61,7 +61,7 @@ class Files_NoDictElement : public Variable {
 
 class Files_DictElementRegexp : public Variable {
  public:
-    Files_DictElementRegexp(std::string dictElement)
+    explicit Files_DictElementRegexp(std::string dictElement)
         : Variable("FILES"),
         m_r(dictElement) { }
 

src/variables/files_names.h

@@ -31,14 +31,14 @@ namespace Variables {
 
 class FilesNames_DictElement : public Variable {
  public:
-    FilesNames_DictElement(std::string dictElement)
+    explicit FilesNames_DictElement(std::string dictElement)
         : Variable("FILES_NAMES" + std::string(":") +
             std::string(dictElement)),
         m_dictElement(dictElement) { }
 
     void evaluate(Transaction *transaction,
         Rule *rule,
-        std::vector<const collection::Variable *> *l) {
+        std::vector<const collection::Variable *> *l) override {
         transaction->m_variableFilesNames.resolve(m_dictElement, l);
     }
 
@@ -53,7 +53,7 @@ class FilesNames_NoDictElement : public Variable {
 
     void evaluate(Transaction *transaction,
         Rule *rule,
-        std::vector<const collection::Variable *> *l) {
+        std::vector<const collection::Variable *> *l) override {
         transaction->m_variableFilesNames.resolve(l);
     }
 };
@@ -61,8 +61,8 @@ class FilesNames_NoDictElement : public Variable {
 
 class FilesNames_DictElementRegexp : public Variable {
  public:
-    FilesNames_DictElementRegexp(std::string dictElement)
-        : Variable("FILES_NAMES"), 
+    explicit FilesNames_DictElementRegexp(std::string dictElement)
+        : Variable("FILES_NAMES"),
         m_r(dictElement) { }
 
 

src/variables/files_sizes.h

@@ -31,14 +31,14 @@ namespace Variables {
 
 class FilesSizes_DictElement : public Variable {
  public:
-    FilesSizes_DictElement(std::string dictElement)
+    explicit FilesSizes_DictElement(std::string dictElement)
         : Variable("FILES_SIZES" + std::string(":") +
             std::string(dictElement)),
         m_dictElement(dictElement) { }
 
     void evaluate(Transaction *transaction,
         Rule *rule,
-        std::vector<const collection::Variable *> *l) {
+        std::vector<const collection::Variable *> *l) override {
         transaction->m_variableFilesSizes.resolve(m_dictElement, l);
     }
 
@@ -53,7 +53,7 @@ class FilesSizes_NoDictElement : public Variable {
 
     void evaluate(Transaction *transaction,
         Rule *rule,
-        std::vector<const collection::Variable *> *l) {
+        std::vector<const collection::Variable *> *l) override {
         transaction->m_variableFilesSizes.resolve(l);
     }
 };
@@ -61,7 +61,7 @@ class FilesSizes_NoDictElement : public Variable {
 
 class FilesSizes_DictElementRegexp : public Variable {
  public:
-    FilesSizes_DictElementRegexp(std::string dictElement)
+    explicit FilesSizes_DictElementRegexp(std::string dictElement)
         : Variable("FILES_SIZES"),
         m_r(dictElement) { }
 

src/variables/files_tmp_content.h

@@ -31,14 +31,14 @@ namespace Variables {
 
 class FilesTmpContent_DictElement : public Variable {
  public:
-    FilesTmpContent_DictElement(std::string dictElement)
+    explicit FilesTmpContent_DictElement(std::string dictElement)
         : Variable("FILES_TMP_CONTENT" + std::string(":") +
             std::string(dictElement)),
         m_dictElement(dictElement) { }
 
     void evaluate(Transaction *transaction,
         Rule *rule,
-        std::vector<const collection::Variable *> *l) {
+        std::vector<const collection::Variable *> *l) override {
         transaction->m_variableFilesTmpContent.resolve(m_dictElement, l);
     }
 
@@ -53,7 +53,7 @@ class FilesTmpContent_NoDictElement : public Variable {
 
     void evaluate(Transaction *transaction,
         Rule *rule,
-        std::vector<const collection::Variable *> *l) {
+        std::vector<const collection::Variable *> *l) override {
         transaction->m_variableFilesTmpContent.resolve(l);
     }
 };
@@ -61,7 +61,7 @@ class FilesTmpContent_NoDictElement : public Variable {
 
 class FilesTmpContent_DictElementRegexp : public Variable {
  public:
-    FilesTmpContent_DictElementRegexp(std::string dictElement)
+    explicit FilesTmpContent_DictElementRegexp(std::string dictElement)
         : Variable("FILES_TMP_CONTENT"),
         m_r(dictElement) { }
 

src/variables/files_tmp_names.h

@@ -30,14 +30,14 @@ class Transaction;
 namespace Variables {
 class FilesTmpNames_DictElement : public Variable {
  public:
-    FilesTmpNames_DictElement(std::string dictElement)
+    explicit FilesTmpNames_DictElement(std::string dictElement)
         : Variable("FILES_TMPNAMES" + std::string(":") +
             std::string(dictElement)),
         m_dictElement(dictElement) { }
 
     void evaluate(Transaction *transaction,
         Rule *rule,
-        std::vector<const collection::Variable *> *l) {
+        std::vector<const collection::Variable *> *l) override {
         transaction->m_variableFilesTmpNames.resolve(m_dictElement, l);
     }
 
@@ -52,7 +52,7 @@ class FilesTmpNames_NoDictElement : public Variable {
 
     void evaluate(Transaction *transaction,
         Rule *rule,
-        std::vector<const collection::Variable *> *l) {
+        std::vector<const collection::Variable *> *l) override {
         transaction->m_variableFilesTmpNames.resolve(l);
     }
 };
@@ -60,7 +60,7 @@ class FilesTmpNames_NoDictElement : public Variable {
 
 class FilesTmpNames_DictElementRegexp : public Variable {
  public:
-    FilesTmpNames_DictElementRegexp(std::string dictElement)
+    explicit FilesTmpNames_DictElementRegexp(std::string dictElement)
         : Variable("FILES_TMPNAMES"),
         m_r(dictElement) { }
 

src/variables/geo.h

@@ -31,14 +31,14 @@ namespace Variables {
 
 class Geo_DictElement : public Variable {
  public:
-    Geo_DictElement(std::string dictElement)
+    explicit Geo_DictElement(std::string dictElement)
         : Variable("GEO" + std::string(":") +
             std::string(dictElement)),
         m_dictElement(dictElement) { }
 
     void evaluate(Transaction *transaction,
         Rule *rule,
-        std::vector<const collection::Variable *> *l) {
+        std::vector<const collection::Variable *> *l) override {
         transaction->m_variableGeo.resolve(m_dictElement, l);
     }
 
@@ -53,7 +53,7 @@ class Geo_NoDictElement : public Variable {
 
     void evaluate(Transaction *transaction,
         Rule *rule,
-        std::vector<const collection::Variable *> *l) {
+        std::vector<const collection::Variable *> *l) override {
         transaction->m_variableGeo.resolve(l);
     }
 };
@@ -61,7 +61,7 @@ class Geo_NoDictElement : public Variable {
 
 class Geo_DictElementRegexp : public Variable {
  public:
-    Geo_DictElementRegexp(std::string dictElement)
+    explicit Geo_DictElementRegexp(std::string dictElement)
         : Variable("GEO"),
         m_r(dictElement) { }
 

src/variables/global.h

@@ -39,7 +39,8 @@ class Global_DictElement : public Variable {
     void evaluate(Transaction *transaction,
         Rule *rule,
         std::vector<const collection::Variable *> *l) override {
-        transaction->m_collections.resolveMultiMatches(m_dictElement, "GLOBAL", l);
+        transaction->m_collections.resolveMultiMatches(m_dictElement,
+		"GLOBAL", l);
     }
 
     std::string m_dictElement;
@@ -48,7 +49,7 @@ class Global_DictElement : public Variable {
 
 class Global_NoDictElement : public Variable {
  public:
-    explicit Global_NoDictElement()
+    Global_NoDictElement()
         : Variable("GLOBAL") { }
 
     void evaluate(Transaction *transaction,
@@ -61,7 +62,7 @@ class Global_NoDictElement : public Variable {
 
 class Global_DictElementRegexp : public Variable {
  public:
-    Global_DictElementRegexp(std::string dictElement)
+    explicit Global_DictElementRegexp(std::string dictElement)
         : Variable("GLOBAL"),
         m_r(dictElement),
         m_dictElement("GLOBAL:" + dictElement) { }

src/variables/ip.h

@@ -48,7 +48,7 @@ class Ip_DictElement : public Variable {
 
 class Ip_NoDictElement : public Variable {
  public:
-    explicit Ip_NoDictElement()
+    Ip_NoDictElement()
         : Variable("IP") { }
 
     void evaluate(Transaction *transaction,
@@ -61,7 +61,7 @@ class Ip_NoDictElement : public Variable {
 
 class Ip_DictElementRegexp : public Variable {
  public:
-    Ip_DictElementRegexp(std::string dictElement)
+    explicit Ip_DictElementRegexp(std::string dictElement)
         : Variable("IP"),
         m_r(dictElement),
         m_dictElement("IP:" + dictElement) { }

src/variables/matched_var_name.h

@@ -36,7 +36,7 @@ class MatchedVarName : public Variable {
 
     void evaluate(Transaction *transaction,
         Rule *rule,
-        std::vector<const collection::Variable *> *l) {
+        std::vector<const collection::Variable *> *l) override {
         transaction->m_variableMatchedVarName.evaluate(l);
     }
 };

src/variables/matched_vars.h

@@ -31,14 +31,14 @@ namespace Variables {
 
 class MatchedVars_DictElement : public Variable {
  public:
-    MatchedVars_DictElement(std::string dictElement)
+    explicit MatchedVars_DictElement(std::string dictElement)
         : Variable("MATCHED_VARS" + std::string(":") +
             std::string(dictElement)),
         m_dictElement(dictElement) { }
 
     void evaluate(Transaction *transaction,
         Rule *rule,
-        std::vector<const collection::Variable *> *l) {
+        std::vector<const collection::Variable *> *l) override {
         transaction->m_variableMatchedVars.resolve(m_dictElement, l);
     }
 
@@ -53,7 +53,7 @@ class MatchedVars_NoDictElement : public Variable {
 
     void evaluate(Transaction *transaction,
         Rule *rule,
-        std::vector<const collection::Variable *> *l) {
+        std::vector<const collection::Variable *> *l) override {
         transaction->m_variableMatchedVars.resolve(l);
     }
 };
@@ -61,7 +61,7 @@ class MatchedVars_NoDictElement : public Variable {
 
 class MatchedVars_DictElementRegexp : public Variable {
  public:
-    MatchedVars_DictElementRegexp(std::string dictElement)
+    explicit MatchedVars_DictElementRegexp(std::string dictElement)
         : Variable("MATCHED_VARS"),
         m_r(dictElement) { }
 

src/variables/matched_vars_names.h

@@ -31,14 +31,14 @@ namespace Variables {
 
 class MatchedVarsNames_DictElement : public Variable {
  public:
-    MatchedVarsNames_DictElement(std::string dictElement)
+    explicit MatchedVarsNames_DictElement(std::string dictElement)
         : Variable("MATCHED_VARS_NAMES" + std::string(":") +
             std::string(dictElement)),
         m_dictElement(dictElement) { }
 
     void evaluate(Transaction *transaction,
         Rule *rule,
-        std::vector<const collection::Variable *> *l) {
+        std::vector<const collection::Variable *> *l) override {
         transaction->m_variableMatchedVarsNames.resolve(m_dictElement, l);
     }
 
@@ -53,7 +53,7 @@ class MatchedVarsNames_NoDictElement : public Variable {
 
     void evaluate(Transaction *transaction,
         Rule *rule,
-        std::vector<const collection::Variable *> *l) {
+        std::vector<const collection::Variable *> *l) override {
         transaction->m_variableMatchedVarsNames.resolve(l);
     }
 };
@@ -61,13 +61,13 @@ class MatchedVarsNames_NoDictElement : public Variable {
 
 class MatchedVarsNames_DictElementRegexp : public Variable {
  public:
-    MatchedVarsNames_DictElementRegexp(std::string dictElement)
+    explicit MatchedVarsNames_DictElementRegexp(std::string dictElement)
         : Variable("MATCHED_VARS_NAMES"),
         m_r(dictElement) { }
 
     void evaluate(Transaction *transaction,
         Rule *rule,
-        std::vector<const collection::Variable *> *l) {
+        std::vector<const collection::Variable *> *l) override {
         transaction->m_variableMatchedVarsNames.resolveRegularExpression(
             &m_r, l);
     }

src/variables/multipart_file_name.h

@@ -19,8 +19,8 @@
 #include <list>
 #include <utility>
 
-#ifndef SRC_VARIABLES_MULTIPART_FILENAME_H_
-#define SRC_VARIABLES_MULTIPART_FILENAME_H_
+#ifndef SRC_VARIABLES_MULTIPART_FILE_NAME_H_
+#define SRC_VARIABLES_MULTIPART_FILE_NAME_H_
 
 #include "src/variables/variable.h"
 
@@ -31,14 +31,14 @@ namespace Variables {
 
 class MultiPartFileName_DictElement : public Variable {
  public:
-    MultiPartFileName_DictElement(std::string dictElement)
+    explicit MultiPartFileName_DictElement(std::string dictElement)
         : Variable("MULTIPART_FILENAME" + std::string(":") +
             std::string(dictElement)),
         m_dictElement(dictElement) { }
 
     void evaluate(Transaction *transaction,
         Rule *rule,
-        std::vector<const collection::Variable *> *l) {
+        std::vector<const collection::Variable *> *l) override {
         transaction->m_variableMultiPartFileName.resolve(m_dictElement, l);
     }
 
@@ -53,7 +53,7 @@ class MultiPartFileName_NoDictElement : public Variable {
 
     void evaluate(Transaction *transaction,
         Rule *rule,
-        std::vector<const collection::Variable *> *l) {
+        std::vector<const collection::Variable *> *l) override {
         transaction->m_variableMultiPartFileName.resolve(l);
     }
 };
@@ -61,7 +61,7 @@ class MultiPartFileName_NoDictElement : public Variable {
 
 class MultiPartFileName_DictElementRegexp : public Variable {
  public:
-    MultiPartFileName_DictElementRegexp(std::string dictElement)
+    explicit MultiPartFileName_DictElementRegexp(std::string dictElement)
         : Variable("MULTIPART_FILENAME"),
         m_r(dictElement) { }
 
@@ -79,5 +79,5 @@ class MultiPartFileName_DictElementRegexp : public Variable {
 }  // namespace Variables
 }  // namespace modsecurity
 
-#endif  // SRC_VARIABLES_MULTIPART_FILENAME_H_
+#endif  // SRC_VARIABLES_MULTIPART_FILE_NAME_H_
 

src/variables/multipart_name.h

@@ -31,14 +31,14 @@ namespace Variables {
 
 class MultiPartName_DictElement : public Variable {
  public:
-    MultiPartName_DictElement(std::string dictElement)
+    explicit MultiPartName_DictElement(std::string dictElement)
         : Variable("MULTIPART_NAME" + std::string(":") +
             std::string(dictElement)),
         m_dictElement(dictElement) { }
 
     void evaluate(Transaction *transaction,
         Rule *rule,
-        std::vector<const collection::Variable *> *l) {
+        std::vector<const collection::Variable *> *l) override {
         transaction->m_variableMultiPartName.resolve(m_dictElement, l);
     }
 
@@ -53,7 +53,7 @@ class MultiPartName_NoDictElement : public Variable {
 
     void evaluate(Transaction *transaction,
         Rule *rule,
-        std::vector<const collection::Variable *> *l) {
+        std::vector<const collection::Variable *> *l) override {
         transaction->m_variableMultiPartName.resolve(l);
     }
 };
@@ -61,7 +61,7 @@ class MultiPartName_NoDictElement : public Variable {
 
 class MultiPartName_DictElementRegexp : public Variable {
  public:
-    MultiPartName_DictElementRegexp(std::string dictElement)
+    explicit MultiPartName_DictElementRegexp(std::string dictElement)
         : Variable("MULTIPART_NAME"),
         m_r(dictElement) { }
 
@@ -79,5 +79,5 @@ class MultiPartName_DictElementRegexp : public Variable {
 }  // namespace Variables
 }  // namespace modsecurity
 
-#endif  // SRC_VARIABLES_MULTIPART_FILENAME_H_
+#endif  // SRC_VARIABLES_MULTIPART_NAME_H_
 

src/variables/remote_user.cc

@@ -27,6 +27,7 @@
 #include <vector>
 #include <list>
 #include <utility>
+#include <memory>
 
 #include "modsecurity/transaction.h"
 #include "src/utils/base64.h"
@@ -41,8 +42,8 @@ void RemoteUser::evaluate(Transaction *transaction,
     size_t pos;
     std::string base64;
 
-    std::unique_ptr<std::string> header = std::move(transaction->m_variableRequestHeaders.resolveFirst(
-        "Authorization"));
+    std::unique_ptr<std::string> header = std::move(
+	transaction->m_variableRequestHeaders.resolveFirst("Authorization"));
 
     if (header == NULL) {
         return;
@@ -62,7 +63,6 @@ void RemoteUser::evaluate(Transaction *transaction,
 
     l->push_back(new collection::Variable(&m_retName,
         &transaction->m_variableRemoteUser));
-
 }
 
 

src/variables/request_cookies.h

@@ -31,14 +31,14 @@ namespace Variables {
 
 class RequestCookies_DictElement : public Variable {
  public:
-    RequestCookies_DictElement(std::string dictElement)
+    explicit RequestCookies_DictElement(std::string dictElement)
         : Variable("REQUEST_COOKIES" + std::string(":") +
             std::string(dictElement)),
         m_dictElement(dictElement) { }
 
     void evaluate(Transaction *transaction,
         Rule *rule,
-        std::vector<const collection::Variable *> *l) {
+        std::vector<const collection::Variable *> *l) override {
         transaction->m_variableRequestCookies.resolve(m_dictElement, l);
     }
 
@@ -53,7 +53,7 @@ class RequestCookies_NoDictElement : public Variable {
 
     void evaluate(Transaction *transaction,
         Rule *rule,
-        std::vector<const collection::Variable *> *l) {
+        std::vector<const collection::Variable *> *l) override {
         transaction->m_variableRequestCookies.resolve(l);
     }
 };
@@ -61,13 +61,13 @@ class RequestCookies_NoDictElement : public Variable {
 
 class RequestCookies_DictElementRegexp : public Variable {
  public:
-    RequestCookies_DictElementRegexp(std::string dictElement)
+    explicit RequestCookies_DictElementRegexp(std::string dictElement)
         : Variable("REQUEST_COOKIES"),
         m_r(dictElement) { }
 
     void evaluate(Transaction *transaction,
         Rule *rule,
-        std::vector<const collection::Variable *> *l) {
+        std::vector<const collection::Variable *> *l) override {
         transaction->m_variableRequestCookies.resolveRegularExpression(
             &m_r, l);
     }

src/variables/request_cookies_names.h

@@ -31,14 +31,14 @@ namespace Variables {
 
 class RequestCookiesNames_DictElement : public Variable {
  public:
-    RequestCookiesNames_DictElement(std::string dictElement)
+    explicit RequestCookiesNames_DictElement(std::string dictElement)
         : Variable("REQUEST_COOKIES_NAMES" + std::string(":") +
             std::string(dictElement)),
         m_dictElement(dictElement) { }
 
     void evaluate(Transaction *transaction,
         Rule *rule,
-        std::vector<const collection::Variable *> *l) {
+        std::vector<const collection::Variable *> *l) override {
         transaction->m_variableRequestCookiesNames.resolve(m_dictElement, l);
     }
 
@@ -53,7 +53,7 @@ class RequestCookiesNames_NoDictElement : public Variable {
 
     void evaluate(Transaction *transaction,
         Rule *rule,
-        std::vector<const collection::Variable *> *l) {
+        std::vector<const collection::Variable *> *l) override {
         transaction->m_variableRequestCookiesNames.resolve(l);
     }
 };
@@ -61,7 +61,7 @@ class RequestCookiesNames_NoDictElement : public Variable {
 
 class RequestCookiesNames_DictElementRegexp : public Variable {
  public:
-    RequestCookiesNames_DictElementRegexp(std::string dictElement)
+    explicit RequestCookiesNames_DictElementRegexp(std::string dictElement)
         : Variable("REQUEST_COOKIES_NAMES"),
         m_r(dictElement) { }
 

src/variables/request_headers.h

@@ -31,14 +31,14 @@ namespace Variables {
 
 class RequestHeaders_DictElement : public Variable {
  public:
-    RequestHeaders_DictElement(std::string dictElement)
+    explicit RequestHeaders_DictElement(std::string dictElement)
         : Variable("REQUEST_HEADERS" + std::string(":") +
             std::string(dictElement)),
         m_dictElement(dictElement) { }
 
     void evaluate(Transaction *transaction,
         Rule *rule,
-        std::vector<const collection::Variable *> *l) {
+        std::vector<const collection::Variable *> *l) override {
         transaction->m_variableRequestHeaders.resolve(m_dictElement, l);
     }
 
@@ -53,7 +53,7 @@ class RequestHeaders_NoDictElement : public Variable {
 
     void evaluate(Transaction *transaction,
         Rule *rule,
-        std::vector<const collection::Variable *> *l) {
+        std::vector<const collection::Variable *> *l) override {
         transaction->m_variableRequestHeaders.resolve(l);
     }
 };
@@ -61,7 +61,7 @@ class RequestHeaders_NoDictElement : public Variable {
 
 class RequestHeaders_DictElementRegexp : public Variable {
  public:
-    RequestHeaders_DictElementRegexp(std::string dictElement)
+    explicit RequestHeaders_DictElementRegexp(std::string dictElement)
         : Variable("REQUEST_HEADERS"),
         m_r(dictElement) { }
 

src/variables/response_headers.h

@@ -31,14 +31,14 @@ namespace Variables {
 
 class ResponseHeaders_DictElement : public Variable {
  public:
-    ResponseHeaders_DictElement(std::string dictElement)
+    explicit ResponseHeaders_DictElement(std::string dictElement)
         : Variable("RESPONSE_HEADERS" + std::string(":") +
             std::string(dictElement)),
         m_dictElement(dictElement) { }
 
     void evaluate(Transaction *transaction,
         Rule *rule,
-        std::vector<const collection::Variable *> *l) {
+        std::vector<const collection::Variable *> *l) override {
         transaction->m_variableResponseHeaders.resolve(m_dictElement, l);
     }
 
@@ -53,7 +53,7 @@ class ResponseHeaders_NoDictElement : public Variable {
 
     void evaluate(Transaction *transaction,
         Rule *rule,
-        std::vector<const collection::Variable *> *l) {
+        std::vector<const collection::Variable *> *l) override {
         transaction->m_variableResponseHeaders.resolve(l);
     }
 };
@@ -61,7 +61,7 @@ class ResponseHeaders_NoDictElement : public Variable {
 
 class ResponseHeaders_DictElementRegexp : public Variable {
  public:
-    ResponseHeaders_DictElementRegexp(std::string dictElement)
+    explicit ResponseHeaders_DictElementRegexp(std::string dictElement)
         : Variable("RESPONSE_HEADERS"),
         m_r(dictElement) { }
 

src/variables/rule.h

@@ -29,14 +29,14 @@ namespace Variables {
 
 class Rule_DictElement : public Variable {
  public:
-    Rule_DictElement(std::string dictElement)
+    explicit Rule_DictElement(std::string dictElement)
         : Variable("RULE" + std::string(":") +
             std::string(dictElement)),
         m_dictElement(dictElement) { }
 
     void evaluate(Transaction *transaction,
         Rule *rule,
-        std::vector<const collection::Variable *> *l) {
+        std::vector<const collection::Variable *> *l) override {
         transaction->m_variableRule.resolve(m_dictElement, l);
     }
 
@@ -51,7 +51,7 @@ class Rule_NoDictElement : public Variable {
 
     void evaluate(Transaction *transaction,
         Rule *rule,
-        std::vector<const collection::Variable *> *l) {
+        std::vector<const collection::Variable *> *l) override {
         transaction->m_variableRule.resolve(l);
     }
 };
@@ -59,7 +59,7 @@ class Rule_NoDictElement : public Variable {
 
 class Rule_DictElementRegexp : public Variable {
  public:
-    Rule_DictElementRegexp(std::string dictElement)
+    explicit Rule_DictElementRegexp(std::string dictElement)
         : Variable("RULE"),
         m_r(dictElement) { }
 

src/variables/session.h

@@ -39,7 +39,8 @@ class Session_DictElement : public Variable {
     void evaluate(Transaction *transaction,
         Rule *rule,
         std::vector<const collection::Variable *> *l) override {
-        transaction->m_collections.resolveMultiMatches(m_dictElement, "SESSION", l);
+        transaction->m_collections.resolveMultiMatches(m_dictElement,
+            "SESSION", l);
     }
 
     std::string m_dictElement;
@@ -48,7 +49,7 @@ class Session_DictElement : public Variable {
 
 class Session_NoDictElement : public Variable {
  public:
-    explicit Session_NoDictElement()
+    Session_NoDictElement()
         : Variable("SESSION") { }
 
     void evaluate(Transaction *transaction,
@@ -61,7 +62,7 @@ class Session_NoDictElement : public Variable {
 
 class Session_DictElementRegexp : public Variable {
  public:
-    Session_DictElementRegexp(std::string dictElement)
+    explicit Session_DictElementRegexp(std::string dictElement)
         : Variable("SESSION"),
         m_r(dictElement),
         m_dictElement("SESSION:" + dictElement) { }

src/variables/time_wday.cc

@@ -45,8 +45,6 @@ void TimeWDay::evaluate(Transaction *transaction,
 
     localtime_r(&timer, &timeinfo);
     strftime(tstr, 200, "%u", &timeinfo);
-    int a = atoi(tstr);
-    a--;
 
     transaction->m_variableTimeWDay.assign(tstr);
 

src/variables/tx.h

@@ -48,7 +48,7 @@ class Tx_DictElement : public Variable {
 
 class Tx_NoDictElement : public Variable {
  public:
-    explicit Tx_NoDictElement()
+    Tx_NoDictElement()
         : Variable("TX") { }
 
     void evaluate(Transaction *transaction,
@@ -61,7 +61,7 @@ class Tx_NoDictElement : public Variable {
 
 class Tx_DictElementRegexp : public Variable {
  public:
-    Tx_DictElementRegexp(std::string dictElement)
+    explicit Tx_DictElementRegexp(std::string dictElement)
         : Variable("TX"),
         m_r(dictElement),
         m_dictElement("TX:" + dictElement) { }

src/variables/variable.cc

@@ -122,7 +122,7 @@ Variable::Variable(std::string name, VariableKind kind)
 
 std::vector<const collection::Variable *> *
     Variable::evaluate(Transaction *transaction) {
-    std::vector<const collection::Variable *> *l = NULL;
+    std::vector<const collection::Variable *> *l;
     l = new std::vector<const collection::Variable *>();
     evaluate(transaction, NULL, l);
 
@@ -170,7 +170,8 @@ std::string Variable::to_s(
     std::string except("");
     for (int i = 0; i < variables->size() ; i++) {
         std::string name = variables->at(i)->m_name;
-        VariableModificatorExclusion *e =  dynamic_cast<VariableModificatorExclusion *>(variables->at(i));
+        VariableModificatorExclusion *e =
+            dynamic_cast<VariableModificatorExclusion *>(variables->at(i));
         if (e != NULL) {
             if (except.empty()) {
                 except = except + name;

src/variables/variable.h

@@ -17,6 +17,8 @@
 #include <string>
 #include <list>
 #include <utility>
+#include <memory>
+
 #include "modsecurity/transaction.h"
 #include "modsecurity/rule.h"
 #include "src/utils/string.h"
@@ -96,7 +98,7 @@ class Variable {
 
 class VariableModificatorExclusion : public Variable {
  public:
-    VariableModificatorExclusion(std::unique_ptr<Variable> var)
+    explicit VariableModificatorExclusion(std::unique_ptr<Variable> var)
         : Variable(var->m_name),
         m_var(std::move(var)) {
             m_isExclusion = true;
@@ -114,7 +116,7 @@ class VariableModificatorExclusion : public Variable {
 
 class VariableModificatorCount : public Variable {
  public:
-    VariableModificatorCount(std::unique_ptr<Variable> var)
+    explicit VariableModificatorCount(std::unique_ptr<Variable> var)
         : Variable(var->m_name),
         m_var(std::move(var)) {
             m_isCount = true;

src/variables/xml.cc

@@ -112,7 +112,7 @@ void XML::evaluate(Transaction *t,
     }
     /* Create one variable for each node in the result. */
     for (i = 0; i < nodes->nodeNr; i++) {
-        char *content = NULL;
+        char *content;
         content = reinterpret_cast<char *>(
             xmlNodeGetContent(nodes->nodeTab[i]));
         if (content != NULL) {

src/variables/xml.h

@@ -36,7 +36,7 @@ namespace Variables {
  */
 class XML_NoDictElement : public Variable {
  public:
-    explicit XML_NoDictElement()
+    XML_NoDictElement()
         : Variable("XML"),
         m_plain("[XML document tree]"),
         m_var(&m_name, &m_plain) {
@@ -46,7 +46,7 @@ class XML_NoDictElement : public Variable {
 
     void evaluate(Transaction *transaction,
         Rule *rule,
-        std::vector<const collection::Variable *> *l) {
+        std::vector<const collection::Variable *> *l) override {
         l->push_back(&m_var);
     }
 
@@ -62,7 +62,7 @@ class XML : public Variable {
 
     void evaluate(Transaction *transaction,
         Rule *rule,
-        std::vector<const collection::Variable *> *l);
+        std::vector<const collection::Variable *> *l) override;
 };