Places the classes related to audit log into a separate namespace

src/audit_log/writer/parallel.cc

@@ -0,0 +1,142 @@
+/*
+ * 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 "audit_log/writer/parallel.h"
+
+#include <time.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+#include <fstream>
+
+#include "audit_log/audit_log.h"
+#include "modsecurity/transaction.h"
+#include "src/utils.h"
+#include "utils/md5.h"
+
+namespace modsecurity {
+namespace audit_log {
+namespace writer {
+
+Parallel::~Parallel() {
+    if (log1.is_open()) {
+        log1.close();
+    }
+
+    if (log2.is_open()) {
+        log2.close();
+    }
+}
+
+
+inline std::string Parallel::logFilePath(time_t *t,
+    int part) {
+    struct tm timeinfo;
+    char tstr[300];
+    std::string name("");
+
+    localtime_r(t, &timeinfo);
+
+    if (part & YearMonthDayDirectory) {
+        memset(tstr, '\0', 300);
+        strftime(tstr, 299, "/%Y%m%d", &timeinfo);
+        name = tstr;
+    }
+
+    if (part & YearMonthDayAndTimeDirectory) {
+        memset(tstr, '\0', 300);
+        strftime(tstr, 299, "/%Y%m%d-%H%M", &timeinfo);
+        name = name + tstr;
+    }
+
+    if (part & YearMonthDayAndTimeFileName) {
+        memset(tstr, '\0', 300);
+        strftime(tstr, 299, "/%Y%m%d-%H%M%S", &timeinfo);
+        name = name + tstr;
+    }
+
+    return name;
+}
+
+
+bool Parallel::init() {
+    /** TODO:: Check if the directory exists. */
+    /** TODO:: Checking if we have permission to write in the target dir */
+
+    if (!m_audit->m_path1.empty()) {
+        log1.open(m_audit->m_path1, std::fstream::out | std::fstream::app);
+    }
+
+    if (!m_audit->m_path2.empty()) {
+        log2.open(m_audit->m_path2, std::fstream::out | std::fstream::app);
+    }
+
+    return true;
+}
+
+
+bool Parallel::write(Transaction *transaction, int parts) {
+    FILE *fp;
+    int fd;
+    std::string log = transaction->toJSON(parts);
+    std::string fileName = logFilePath(&transaction->m_timeStamp,
+        YearMonthDayDirectory | YearMonthDayAndTimeDirectory
+        | YearMonthDayAndTimeFileName);
+
+    std::string logPath = m_audit->m_storage_dir;
+    fileName = logPath + fileName + "-" + transaction->m_id;
+
+    if (logPath.empty()) {
+      return false;
+    }
+
+    createDir((logPath +
+        logFilePath(&transaction->m_timeStamp, YearMonthDayDirectory)).c_str(),
+        m_audit->directoryPermission);
+    createDir((logPath +
+        logFilePath(&transaction->m_timeStamp, YearMonthDayDirectory
+            | YearMonthDayAndTimeDirectory)).c_str(),
+        m_audit->directoryPermission);
+
+    fd = open(fileName.c_str(), O_CREAT | O_WRONLY, m_audit->filePermission);
+    if (fd < 0) {
+        return false;
+    }
+    fp = fdopen(fd, "w");
+    fwrite(log.c_str(), log.length(), 1, fp);
+    fclose(fp);
+
+    if (log1.is_open() && log2.is_open()) {
+        log2 << transaction->toOldAuditLogFormatIndex(fileName, log.length(),
+            md5(log));
+    }
+    if (log1.is_open() && !log2.is_open()) {
+        log1 << transaction->toOldAuditLogFormatIndex(fileName, log.length(),
+            md5(log));
+    }
+    if (!log1.is_open() && log2.is_open()) {
+        log2 << transaction->toOldAuditLogFormatIndex(fileName, log.length(),
+            md5(log));
+    }
+
+    return true;
+}
+
+}  // namespace writer
+}  // namespace audit_log
+}  // namespace modsecurity

src/audit_log/writer/parallel.h

@@ -0,0 +1,85 @@
+/*
+ * 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 <string>
+
+#ifndef SRC_AUDIT_LOG_WRITER_PARALLEL_H_
+#define SRC_AUDIT_LOG_WRITER_PARALLEL_H_
+
+#include "audit_log/writer.h"
+#include "modsecurity/transaction.h"
+
+#ifdef __cplusplus
+
+namespace modsecurity {
+namespace audit_log {
+namespace writer {
+
+/** @ingroup ModSecurity_CPP_API */
+class Parallel : public audit_log::Writer {
+ public:
+    explicit Parallel(AuditLog *audit)
+        : audit_log::Writer(audit) { }
+
+    ~Parallel() override;
+    bool init() override;
+    bool write(Transaction *transaction, int parts) override;
+
+    void refCountIncrease() override {
+        m_refereceCount++;
+    }
+
+
+    void refCountDecreaseAndCheck() override {
+        m_refereceCount--;
+        if (m_refereceCount == 0) {
+            delete this;
+        }
+    }
+
+    /**
+     *
+     * Audit log file is saved into a directory structure. This directory
+     * structure is based on the timestamp of the transaction creation, at
+     * the exact moment that ModSecurity be aware of a particular
+     * request/transaction.
+     * The expect fromat is:
+     *
+     * [...]/YearMonthDay/YearMonthDayAndTime/YearMonthDayAndTime-RequestId
+     *
+     * Example:
+     *
+     * /20150710/20150710-1353/20150710-135353-143654723362.584244
+     *
+     * This enumeration describes the subpaths of this structure.
+     *
+     */
+    enum AuditLogFilePath {
+     YearMonthDayDirectory = 2,
+     YearMonthDayAndTimeDirectory = 4,
+     YearMonthDayAndTimeFileName = 8,
+    };
+
+    std::ofstream log1;
+    std::ofstream log2;
+    inline std::string logFilePath(time_t *t, int part);
+};
+
+}  // namespace writer
+}  // namespace audit_log
+}  // namespace modsecurity
+#endif
+
+#endif  // SRC_AUDIT_LOG_WRITER_PARALLEL_H_

src/audit_log/writer/serial.cc

@@ -0,0 +1,68 @@
+/*
+ * 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 "audit_log/writer/serial.h"
+
+// #include <mutex>
+
+#include "audit_log/audit_log.h"
+
+namespace modsecurity {
+namespace audit_log {
+namespace writer {
+// static std::mutex serialLoggingMutex;
+
+
+Serial::~Serial() {
+    m_log.close();
+}
+
+
+void Serial::generateBoundary(std::string *boundary) {
+    static const char alphanum[] =
+        "0123456789"
+        "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+        "abcdefghijklmnopqrstuvwxyz";
+
+    for (int i = 0; i < SERIAL_AUDIT_LOG_BOUNDARY_LENGTH; ++i) {
+        boundary->append(1, alphanum[rand() % (sizeof(alphanum) - 1)]);
+    }
+}
+
+
+bool Serial::init() {
+    m_log.open(m_audit->m_path1, std::fstream::out | std::fstream::app);
+    return true;
+}
+
+
+bool Serial::write(Transaction *transaction, int parts) {
+    std::string boundary;
+
+    generateBoundary(&boundary);
+
+    // serialLoggingMutex.lock();
+
+    m_log << transaction->toOldAuditLogFormat(parts, "-" + boundary + "--");
+    m_log.flush();
+
+    // serialLoggingMutex.unlock();
+
+    return true;
+}
+
+}  // namespace writer
+}  // namespace audit_log
+}  // namespace modsecurity

src/audit_log/writer/serial.h

@@ -0,0 +1,75 @@
+/*
+ * 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 <iostream>
+#include <fstream>
+#include <string>
+#endif
+
+#ifndef SRC_AUDIT_LOG_WRITER_SERIAL_H_
+#define SRC_AUDIT_LOG_WRITER_SERIAL_H_
+
+#include "audit_log/writer.h"
+#include "modsecurity/transaction.h"
+
+#ifdef __cplusplus
+
+namespace modsecurity {
+namespace audit_log {
+namespace writer {
+
+#define SERIAL_AUDIT_LOG_BOUNDARY_LENGTH 8
+
+/** @ingroup ModSecurity_CPP_API */
+class Serial : public audit_log::Writer {
+ public:
+    explicit Serial(audit_log::AuditLog *audit)
+        : audit_log::Writer(audit) { }
+
+    ~Serial() override;
+
+    void refCountIncrease() override {
+        m_refereceCount++;
+    }
+
+
+    void refCountDecreaseAndCheck() override {
+        /*
+        m_refereceCount--;
+
+
+        if (m_refereceCount == 0) {
+        */
+        delete this;
+        /*
+        /}
+        */
+    }
+
+    bool init() override;;
+    bool write(Transaction *transaction, int parts) override;
+
+ private:
+    std::ofstream m_log;
+    void generateBoundary(std::string *boundary);
+};
+
+}  // namespace writer
+}  // namespace audit_log
+}  // namespace modsecurity
+#endif
+
+#endif  // SRC_AUDIT_LOG_WRITER_SERIAL_H_