Logger.h

Go to the documentation of this file.

#pragma once
 
#include <stdio.h>
#include <iostream>
#include <sstream>
#include <iomanip>
#include <stdint.h>
 
#ifndef LOG_MODULE
#   define LOG_MODULE UndefinedLogModule
#endif
 
// Use __FILE_NAME__ to avoid leaking complete full path
#ifdef __FILE_NAME__
#   define PCAPPP_FILENAME __FILE_NAME__
#else
#   define PCAPPP_FILENAME __FILE__
#endif
 
#define PCPP_LOG(level, message)                                                                                       \
    do                                                                                                                 \
    {                                                                                                                  \
        std::ostringstream* sstream = pcpp::Logger::getInstance().internalCreateLogStream();                           \
        (*sstream) << message;                                                                                         \
        pcpp::Logger::getInstance().internalPrintLogMessage(sstream, level, PCAPPP_FILENAME, __FUNCTION__, __LINE__);  \
    } while (0)
 
#define PCPP_LOG_DEBUG(message)                                                                                        \
    do                                                                                                                 \
    {                                                                                                                  \
        if (pcpp::Logger::getInstance().logsEnabled() && pcpp::Logger::getInstance().isDebugEnabled(LOG_MODULE))       \
        {                                                                                                              \
            PCPP_LOG(pcpp::Logger::Debug, message);                                                                    \
        }                                                                                                              \
    } while (0)
 
#define PCPP_LOG_ERROR(message)                                                                                        \
    do                                                                                                                 \
    {                                                                                                                  \
        PCPP_LOG(pcpp::Logger::Error, message);                                                                        \
    } while (0)
 
 
namespace pcpp
{
 
    enum LogModule
    {
        UndefinedLogModule,
        CommonLogModuleIpUtils,          
        CommonLogModuleTablePrinter,     
        CommonLogModuleGenericUtils,     
        PacketLogModuleRawPacket,        
        PacketLogModulePacket,           
        PacketLogModuleLayer,            
        PacketLogModuleAsn1Codec,        
        PacketLogModuleArpLayer,         
        PacketLogModuleEthLayer,         
        PacketLogModuleIPv4Layer,        
        PacketLogModuleIPv6Layer,        
        PacketLogModulePayloadLayer,     
        PacketLogModuleTcpLayer,         
        PacketLogModuleUdpLayer,         
        PacketLogModuleVlanLayer,        
        PacketLogModuleHttpLayer,        
        PacketLogModulePPPoELayer,       
        PacketLogModuleDnsLayer,         
        PacketLogModuleMplsLayer,        
        PacketLogModuleIcmpLayer,        
        PacketLogModuleIcmpV6Layer,      
        PacketLogModuleGreLayer,         
        PacketLogModuleSSLLayer,         
        PacketLogModuleSllLayer,         
        PacketLogModuleNflogLayer,       
        PacketLogModuleDhcpLayer,        
        PacketLogModuleDhcpV6Layer,      
        PacketLogModuleIgmpLayer,        
        PacketLogModuleSipLayer,         
        PacketLogModuleSdpLayer,         
        PacketLogModuleRadiusLayer,      
        PacketLogModuleGtpLayer,         
        PacketLogModuleBgpLayer,         
        PacketLogModuleSSHLayer,         
        PacketLogModuleVrrpLayer,        
        PacketLogModuleTcpReassembly,    
        PacketLogModuleIPReassembly,     
        PacketLogModuleIPSecLayer,       
        PacketLogModuleNtpLayer,         
        PacketLogModuleTelnetLayer,      
        PacketLogModuleStpLayer,         
        PacketLogModuleLLCLayer,         
        PacketLogModuleNdpLayer,         
        PacketLogModuleFtpLayer,         
        PacketLogModuleSomeIpLayer,      
        PacketLogModuleSomeIpSdLayer,    
        PacketLogModuleWakeOnLanLayer,   
        PacketLogModuleSmtpLayer,        
        PacketLogModuleWireGuardLayer,   
        PcapLogModuleWinPcapLiveDevice,  
        PcapLogModuleRemoteDevice,       
        PcapLogModuleLiveDevice,         
        PcapLogModuleFileDevice,         
        PcapLogModulePfRingDevice,       
        PcapLogModuleMBufRawPacket,      
        PcapLogModuleDpdkDevice,         
        PcapLogModuleKniDevice,          
        PcapLogModuleXdpDevice,          
        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 setAllModulesToLogLevel(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;
        }
 
        std::ostringstream* internalCreateLogStream();
 
        void internalPrintLogMessage(std::ostringstream* logStream, 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);
    };
}  // namespace pcpp