Logger.h

Go to the documentation of this file.

#ifndef PCAPPP_LOGGER
#define PCAPPP_LOGGER

#include <stdio.h>
#include <iostream>
#include <sstream>
#include <iomanip>
#include <stdint.h>

#ifndef LOG_MODULE
#define LOG_MODULE UndefinedLogModule
#endif


namespace pcpp
{

    enum LogModule
    {
        UndefinedLogModule,
        CommonLogModuleIpUtils, 
        CommonLogModuleTablePrinter, 
        CommonLogModuleGenericUtils, 
        PacketLogModuleRawPacket, 
        PacketLogModulePacket, 
        PacketLogModuleLayer, 
        PacketLogModuleArpLayer, 
        PacketLogModuleEthLayer, 
        PacketLogModuleIPv4Layer, 
        PacketLogModuleIPv6Layer, 
        PacketLogModulePayloadLayer, 
        PacketLogModuleTcpLayer, 
        PacketLogModuleUdpLayer, 
        PacketLogModuleVlanLayer, 
        PacketLogModuleHttpLayer, 
        PacketLogModulePPPoELayer, 
        PacketLogModuleDnsLayer, 
        PacketLogModuleMplsLayer, 
        PacketLogModuleIcmpLayer, 
        PacketLogModuleGreLayer, 
        PacketLogModuleSSLLayer, 
        PacketLogModuleSllLayer, 
        PacketLogModuleDhcpLayer, 
        PacketLogModuleDhcpV6Layer, 
        PacketLogModuleIgmpLayer, 
        PacketLogModuleSipLayer, 
        PacketLogModuleSdpLayer, 
        PacketLogModuleRadiusLayer, 
        PacketLogModuleGtpLayer, 
        PacketLogModuleBgpLayer, 
        PacketLogModuleSSHLayer, 
        PacketLogModuleTcpReassembly, 
        PacketLogModuleIPReassembly, 
        PacketLogModuleIPSecLayer, 
        PcapLogModuleWinPcapLiveDevice, 
        PcapLogModuleRemoteDevice, 
        PcapLogModuleLiveDevice, 
        PcapLogModuleFileDevice, 
        PcapLogModulePfRingDevice, 
        PcapLogModuleMBufRawPacket, 
        PcapLogModuleDpdkDevice, 
        PcapLogModuleKniDevice, 
        NetworkUtils, 
        NumOfLogModules
    };

    class Logger
    {
    public:

        enum LogLevel
        {
            Error, 
            Info, 
            Debug 
        };

        typedef void (*LogPrinter)(LogLevel logLevel, const std::string& logMessage, const std::string& file, const std::string& method, const int line);

        static std::string logLevelAsString(LogLevel logLevel);

        LogLevel getLogLevel(LogModule module) { return m_LogModulesArray[module]; }

        void setLogLevel(LogModule module, LogLevel level) { m_LogModulesArray[module] = level; }

        bool isDebugEnabled(LogModule module) const { return m_LogModulesArray[module] == Debug; }

        void setAllModlesToLogLevel(LogLevel level) { for (int i=1; i<NumOfLogModules; i++) m_LogModulesArray[i] = level; }

        void setLogPrinter(LogPrinter printer) { m_LogPrinter = printer; }

        void resetLogPrinter() { m_LogPrinter = &defaultLogPrinter; }

        std::string getLastError() { return m_LastError; }

        void suppressLogs() { m_LogsEnabled = false; }

        void enableLogs() { m_LogsEnabled = true; }

        bool logsEnabled() const { return m_LogsEnabled; }

        template<class T>
        Logger& operator<<(const T& msg)
        {
            (*m_LogStream) << msg;
            return *this;
        }

        Logger& internalLog();

        void internalPrintLogMessage(Logger::LogLevel logLevel, const char* file, const char* method, int line);

        static Logger& getInstance()
        {
            static Logger instance;
            return instance;
        }
    private:
        bool m_LogsEnabled;
        Logger::LogLevel m_LogModulesArray[NumOfLogModules];
        LogPrinter m_LogPrinter;
        std::string m_LastError;
        std::ostringstream* m_LogStream;

        // private c'tor - this class is a singleton
        Logger();

        static void defaultLogPrinter(LogLevel logLevel, const std::string& logMessage, const std::string& file, const std::string& method, const int line);
    };

#define LOG_DEBUG(message) do \
    { \
        if (pcpp::Logger::getInstance().logsEnabled() && pcpp::Logger::getInstance().isDebugEnabled(LOG_MODULE)) \
        { \
            pcpp::Logger::getInstance().internalLog() << message; \
            pcpp::Logger::getInstance().internalPrintLogMessage(pcpp::Logger::Debug, __FILE__, __FUNCTION__, __LINE__); \
        } \
    } while(0)

#define LOG_ERROR(message) do \
    { \
        pcpp::Logger::getInstance().internalLog() << message; \
        pcpp::Logger::getInstance().internalPrintLogMessage(pcpp::Logger::Error, __FILE__, __FUNCTION__, __LINE__); \
    } while (0)

} // namespace pcpp

#endif /* PCAPPP_LOGGER */