SystemUtils.h

Go to the documentation of this file.

#pragma once
 
#include "DeprecationUtils.h"
 
#include <cstdint>
#include <string>
#include <vector>
 
 
// @todo Change to constexpr when C++17 is minimum supported version
enum : uint8_t
{
    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];
    };
 
    using CoreMask = uint32_t;
 
    int getNumOfCores();
 
    CoreMask getCoreMaskForAllMachineCores();
 
    CoreMask createCoreMaskFromCoreVector(const std::vector<SystemCore>& cores);
 
    CoreMask createCoreMaskFromCoreIds(const 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);
 
    PCPP_DEPRECATED("Please use std::this_thread::sleep_for(std::chrono::seconds(seconds)) instead")
    void multiPlatformSleep(uint32_t seconds);
 
    PCPP_DEPRECATED("Please use std::this_thread::sleep_for(std::chrono::milliseconds(milliseconds)) instead")
    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:
        // cppcheck-suppress constParameter
        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
            lastPos = m_AppName.rfind('.');
            if (lastPos != std::string::npos)
            {
                m_AppName.resize(lastPos);
            }
        }
 
        static const std::string& get()
        {
            return m_AppName;
        }
    };
 
    class ApplicationEventHandler
    {
    public:
        using EventHandlerCallback = void (*)(void*);
 
        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