SystemUtils.h

Go to the documentation of this file.

#ifndef PCAPPP_SYSTEM_UTILS
#define PCAPPP_SYSTEM_UTILS

#include <stdint.h>
#include <string>
#include <vector>


#define MAX_NUM_OF_CORES 32

#ifdef _MSC_VER
int gettimeofday(struct timeval * tp, struct timezone * tzp);
#endif

namespace pcpp
{

    struct SystemCore
    {
        uint32_t Mask;

        uint8_t Id;

        bool operator==(const SystemCore& other) const { return Id == other.Id; }
    };

    struct SystemCores
    {
        static const SystemCore Core0;
        static const SystemCore Core1;
        static const SystemCore Core2;
        static const SystemCore Core3;
        static const SystemCore Core4;
        static const SystemCore Core5;
        static const SystemCore Core6;
        static const SystemCore Core7;
        static const SystemCore Core8;
        static const SystemCore Core9;
        static const SystemCore Core10;
        static const SystemCore Core11;
        static const SystemCore Core12;
        static const SystemCore Core13;
        static const SystemCore Core14;
        static const SystemCore Core15;
        static const SystemCore Core16;
        static const SystemCore Core17;
        static const SystemCore Core18;
        static const SystemCore Core19;
        static const SystemCore Core20;
        static const SystemCore Core21;
        static const SystemCore Core22;
        static const SystemCore Core23;
        static const SystemCore Core24;
        static const SystemCore Core25;
        static const SystemCore Core26;
        static const SystemCore Core27;
        static const SystemCore Core28;
        static const SystemCore Core29;
        static const SystemCore Core30;
        static const SystemCore Core31;

        static const SystemCore IdToSystemCore[MAX_NUM_OF_CORES];
    };

    typedef uint32_t CoreMask;

    int getNumOfCores();

    CoreMask getCoreMaskForAllMachineCores();


    CoreMask createCoreMaskFromCoreVector(std::vector<SystemCore> cores);


    CoreMask createCoreMaskFromCoreIds(std::vector<int> coreIds);


    void createCoreVectorFromCoreMask(CoreMask coreMask, std::vector<SystemCore>& resultVec);

    std::string executeShellCommand(const std::string &command);

    bool directoryExists(const std::string &dirPath);

    int clockGetTime(long& sec, long& nsec);

    void multiPlatformSleep(uint32_t seconds);

    void multiPlatformMSleep(uint32_t milliseconds);

    uint16_t hostToNet16(uint16_t host);

    uint16_t netToHost16(uint16_t net);

    uint32_t hostToNet32(uint32_t host);

    uint32_t netToHost32(uint32_t net);

    class AppName
    {
    private:
        static std::string m_AppName;

    public:
        static void init(int argc, char* argv[])
        {
            if (argc == 0)
            {
                m_AppName.clear();
                return;
            }

            m_AppName = argv[0];

            // remove Linux/Unix path
            size_t lastPos = m_AppName.rfind('/');
            if (lastPos != std::string::npos)
            {
                m_AppName = m_AppName.substr(lastPos + 1);
            }

            // remove Windows path
            lastPos = m_AppName.rfind('\\');
            if (lastPos != std::string::npos)
            {
                m_AppName = m_AppName.substr(lastPos + 1);
            }

            // remove file extension
            m_AppName = m_AppName.substr(0, m_AppName.rfind('.'));
        }

        static const std::string& get() { return m_AppName; }
    };

    class ApplicationEventHandler
    {
    public:
        typedef void (*EventHandlerCallback)(void* cookie);

        static ApplicationEventHandler& getInstance()
        {
            static ApplicationEventHandler instance;
            return instance;
        }

        void onApplicationInterrupted(EventHandlerCallback handler, void* cookie);

    private:
        EventHandlerCallback m_ApplicationInterruptedHandler;
        void* m_ApplicationInterruptedCookie;

        // private c'tor
        ApplicationEventHandler();

#if defined(_WIN32)
        static int handlerRoutine(unsigned long fdwCtrlType);
#else
        static void handlerRoutine(int signum);
#endif
    };

} // namespace pcpp

#endif /* PCAPPP_SYSTEM_UTILS */