legal_log_mgr.h

Go to the documentation of this file.

// Copyright (C) 2020-2025 Internet Systems Consortium, Inc. ("ISC")
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
#ifndef LEGAL_LOG_MGR_H
#define LEGAL_LOG_MGR_H

 
#include <asiolink/io_service.h>
#include <database/database_connection.h>
#include <eval/token.h>
#include <exceptions/exceptions.h>
 
#include <boost/shared_ptr.hpp>
 
#include <fstream>
#include <string>
 
namespace isc {
namespace dhcp {

class LegalLogMgrError : public isc::Exception {
public:
    LegalLogMgrError(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what)
    {}
};
 
class LegalLogMgr;

typedef boost::shared_ptr<LegalLogMgr> LegalLogMgrPtr;

class LegalLogMgr {
public:
    LegalLogMgr(const isc::db::DatabaseConnection::ParameterMap parameters) :
        timestamp_format_("%Y-%m-%d %H:%M:%S %Z"),
        parameters_(parameters) {
    }

    virtual ~LegalLogMgr() = default;

    static std::string getLogPath(bool reset = false,
                                  const std::string explicit_path = "");

    static std::string validatePath(const std::string logpath);

    static void parseConfig(const isc::data::ConstElementPtr& parameters, isc::db::DatabaseConnection::ParameterMap& map);

    static void parseDatabase(const isc::data::ConstElementPtr& parameters, isc::db::DatabaseConnection::ParameterMap& map);

    static void parseFile(const isc::data::ConstElementPtr& parameters, isc::db::DatabaseConnection::ParameterMap& map);

    static void parseSyslog(const isc::data::ConstElementPtr& parameters, isc::db::DatabaseConnection::ParameterMap& map);

    static void parseExtraParameters(const isc::data::ConstElementPtr& parameters, isc::db::DatabaseConnection::ParameterMap& map);

    virtual void open() = 0;

    virtual void close() = 0;

    virtual void writeln(const std::string& text, const std::string& addr) = 0;

    virtual std::string getType() const = 0;

    virtual struct tm currentTimeInfo() const;

    virtual struct timespec now() const;

    virtual std::string getNowString() const;

    virtual std::string getNowString(const std::string& format) const;

    static std::string getTimeString(const struct timespec& time, const std::string& format);

    static std::string genDurationString(const uint32_t secs);

    static std::string vectorHexDump(const std::vector<uint8_t>& bytes,
                                     const std::string& delimiter = ":");

    static std::string vectorDump(const std::vector<uint8_t>& bytes);

    void setRequestFormatExpression(const std::string& extended_format);

    isc::dhcp::ExpressionPtr getRequestFormatExpression() {
        return (request_expression_);
    }

    void setResponseFormatExpression(const std::string& extended_format);

    isc::dhcp::ExpressionPtr getResponseFormatExpression() {
        return (response_expression_);
    }

    void setTimestampFormat(const std::string& timestamp_format);

    std::string getTimestampFormat() {
        return (timestamp_format_);
    }

    virtual isc::db::DatabaseConnection::ParameterMap getParameters() const {
        return (parameters_);
    }

    virtual void setParameters(isc::db::DatabaseConnection::ParameterMap parameters) {
        parameters_ = parameters;
    }

    virtual bool isUnusable() {
        return (false);
    }
 
private:

    isc::dhcp::ExpressionPtr request_expression_;

    isc::dhcp::ExpressionPtr response_expression_;

    std::string timestamp_format_;

    isc::db::DatabaseConnection::ParameterMap parameters_;
};

typedef uint64_t ManagerID;

typedef std::map<ManagerID, std::pair<isc::db::DatabaseConnection::ParameterMap, LegalLogMgrPtr>> LegalLogMgrPool;

enum class Action { ASSIGN, RELEASE };

const std::string actionToVerb(Action action);
 
} // namespace dhcp
} // namespace isc
 
#endif // LEGAL_LOG_MGR_H