Logger.h

Go to the documentation of this file.

#ifndef PCAPPP_LOGGER
#define PCAPPP_LOGGER
 
#include <stdio.h>
#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, 
        PacketLogModuleIgmpLayer, 
        PacketLogModuleSipLayer, 
        PacketLogModuleSdpLayer, 
        PacketLogModuleRadiusLayer, 
        PacketLogModuleGtpLayer, 
        PacketLogModuleTcpReassembly, 
        PacketLogModuleIPReassembly, 
        PcapLogModuleWinPcapLiveDevice, 
        PcapLogModuleRemoteDevice, 
        PcapLogModuleLiveDevice, 
        PcapLogModuleFileDevice, 
        PcapLogModulePfRingDevice, 
        PcapLogModuleMBufRawPacket, 
        PcapLogModuleDpdkDevice, 
        PcapLogModuleKniDevice, 
        NetworkUtils, 
        NumOfLogModules
    };
 
    class LoggerPP
    {
    public:
        enum LogLevel
        {
            Normal, 
            Debug 
        };
 
        void setLogLevel(LogModule module, LogLevel level) { m_LogModulesArray[module] = level; }
 
        void setAllModlesToLogLevel(LogLevel level) { for (int i=1; i<NumOfLogModules; i++) m_LogModulesArray[i] = level; }
 
        bool isDebugEnabled(LogModule module) const { return m_LogModulesArray[module] == Debug; }
 
        const LogLevel* getLogModulesArr() const { return m_LogModulesArray; }
 
        bool isErrorStringSet() const { return m_ErrorString != NULL; }
 
        char* getErrorString() const { return m_ErrorString; }
 
        void setErrorString(char* errString, int len) { m_ErrorString = errString; m_ErrorStringLen = len; }
 
        int getErrorStringLength() const { return m_ErrorStringLen; }
 
        void supressErrors() { m_SuppressErrors = true; }
 
        void enableErrors() { m_SuppressErrors = false; }
 
        bool isSupressErrors() const { return m_SuppressErrors; }
 
        static LoggerPP& getInstance()
        {
            static LoggerPP instance;
            return instance;
        }
    private:
        char* m_ErrorString;
        int m_ErrorStringLen;
        bool m_SuppressErrors;
        LoggerPP::LogLevel m_LogModulesArray[NumOfLogModules];
        LoggerPP();
    };
 
#define LOG_DEBUG(format, ...) do { \
            if(pcpp::LoggerPP::getInstance().isDebugEnabled(LOG_MODULE)) { \
                printf("[%-35s: %-25s: line:%-4d] " format "\n", __FILE__, __FUNCTION__, __LINE__, ## __VA_ARGS__); \
            } \
    } while(0)
 
#define LOG_ERROR(format, ...) do { \
            if (!pcpp::LoggerPP::getInstance().isSupressErrors()) {\
                if(pcpp::LoggerPP::getInstance().isErrorStringSet()) \
                    snprintf(pcpp::LoggerPP::getInstance().getErrorString(), pcpp::LoggerPP::getInstance().getErrorStringLength(), format "\n", ## __VA_ARGS__); \
                else \
                    fprintf(stderr, format "\n", ## __VA_ARGS__); \
            } \
        } while (0)
 
#define IS_DEBUG pcpp::LoggerPP::getInstance().isDebugEnabled(LOG_MODULE)
 
} // namespace pcpp
 
#endif /* PCAPPP_LOGGER */