SystemUtils.h

Go to the documentation of this file.

#ifndef PCAPPP_SYSTEM_UTILS
#define PCAPPP_SYSTEM_UTILS

#include <stdint.h>
#include <string>
#include <vector>
#if defined(WIN32) || defined(WINx64) || defined(PCAPPP_MINGW_ENV)
#include <windows.h>
#else
#include <pthread.h>
#endif


#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(std::string dirPath);

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

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

            m_AppName = argv[0];

            // remove Linux/Unix path
            while (m_AppName.find("/") != std::string::npos)
            {
                m_AppName = m_AppName.substr(m_AppName.find("/")+1);
            }

            // remove Windows path
            while (m_AppName.find("\\") != std::string::npos)
            {
                m_AppName = m_AppName.substr(m_AppName.find("\\")+1);
            }

            // remove file extension
            m_AppName = m_AppName.substr(0, m_AppName.find("."));
        }

        static 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();

#ifdef WIN32
        static BOOL WINAPI handlerRoutine(DWORD fdwCtrlType);
#else
        pthread_mutex_t m_HandlerRoutineMutex;
        static void handlerRoutine(int signum);
#endif
    };

} // namespace pcpp

#endif /* PCAPPP_SYSTEM_UTILS */