Linux fixes (#7)

* fixing app memory & boot time calculation

* fixed error event, fixed procstat reading

* compilation error in getSysMemoryUsage

* static member definition

* connection status for linux

* missing include

* removed const

* fixed compilation errors

* include path for uuid on linux

* added STDLIB guid to avoid dependencies

* link with standard library for linux

* updated cmake for linux

* updated cmake for linux

* getConnection for linux

Author: dorin-ga

CMakeLists.txt

@@ -165,7 +165,12 @@ elseif(APPLE)
     create_source_groups(MACOS_SOURCES)
 
 elseif(LINUX)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DGUID_LIBUUID")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DGUID_STDLIB -std=c++17")
+
+    if(CLANG)
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libc++")
+    endif()
+    
 endif()
 
 if(${GA_BUILD_SAMPLE})

sample/CMakeLists.txt

@@ -5,7 +5,16 @@ set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_RELEASE	"${CMAKE_BINARY_DIR}/Release")
 set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_DEBUG	"${CMAKE_BINARY_DIR}/Debug")
 set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_RELEASE	"${CMAKE_BINARY_DIR}/Release")
 
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17 -stdlib=libc++")
+set(CMAKE_CXX_STANDARD 17)
+
+if(LINUX)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17")
+
+    if(CLANG)
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libc++")
+    endif()
+    
+endif()
 
 set(GA_ROOT_DIR "..")
 

source/dependencies/crossguid/guid.cpp

@@ -42,6 +42,12 @@ THE SOFTWARE.
 #include <cassert>
 #endif
 
+#ifdef GUID_STDLIB
+#include <random>
+#include <vector>
+#include <string>
+#endif
+
 BEGIN_XG_NAMESPACE
 
 #ifdef GUID_ANDROID
@@ -279,6 +285,53 @@ Guid newGuid()
 }
 #endif
 
+#ifdef GUID_STDLIB
+unsigned char random_char()
+{
+    std::random_device rd;
+    std::mt19937 gen(rd());
+    std::uniform_int_distribution<> dis(0,255);
+    return static_cast<unsigned char>(dis(gen));
+}
+
+void generate_hex(size_t len, std::vector<char>& out)
+{
+    for(size_t i = 0; i < len; ++i)
+    {
+        const auto rc = random_char();
+        char s[3];
+        snprintf(s, 3, "%02x", int(rc));
+        
+        out.push_back(s[0]);
+        out.push_back(s[1]);
+    }
+}
+
+Guid newGuid()
+{
+    std::vector<char> result;
+    generate_hex(4, result);
+    result.push_back('-');
+    generate_hex(2, result);
+    result.push_back('-');
+    generate_hex(2, result);
+    result.push_back('-');
+    generate_hex(2, result);
+    result.push_back('-');
+    generate_hex(4, result);
+    result.push_back('\0');
+
+    std::array<unsigned char, 16> data;
+    const int size = std::min<int>(16, result.size());
+    for(int i = 0; i < size; ++i)
+    {
+        data[i] = result[i];
+    }
+
+    return Guid(std::move(data));
+}
+#endif
+
 // this is the mac and ios version
 #ifdef GUID_CFUUID
 Guid newGuid()
@@ -400,4 +453,4 @@ namespace std
     {
         lhs.swap(rhs);
     }
-}
+}

source/gameanalytics/Platform/GALinux.cpp

@@ -4,11 +4,71 @@
 
 #include "GAState.h"
 
+#include <errno.h>
+#include <linux/unistd.h>
+#include <linux/kernel.h>
 #include <execinfo.h>
 #include <sys/utsname.h>
 #include <sys/stat.h>
 #include <unistd.h>
 #include <sys/sysinfo.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <linux/wireless.h>
+#include <ifaddrs.h>
+
+struct sigaction gameanalytics::GAPlatformLinux::prevSigAction;
+
+struct ProcessStat 
+{
+    int pid;
+    std::string comm;
+    char state;
+    long ppid;
+    long pgrp;
+    long session;
+    long tty_nr;
+    long tpgid;
+    unsigned long flags;
+    unsigned long minflt;
+    unsigned long cminflt;
+    unsigned long majflt;
+    unsigned long cmajflt;
+    unsigned long utime;
+    unsigned long stime;
+    long cutime;
+    long cstime;
+    long priority;
+    long nice;
+    long num_threads;
+    long itrealvalue;
+    long starttime;
+    long vsize;
+    long rss;
+};
+
+ProcessStat readProcessStat() 
+{
+    ProcessStat stat{};
+    std::ifstream statFile("/proc/self/stat");
+    
+    if (!statFile.is_open()) 
+    {
+        return {};
+    }
+
+    std::string line;
+    std::getline(statFile, line);
+    std::istringstream iss(line);
+
+    iss >> stat.pid >> stat.comm >> stat.state >> stat.ppid >> stat.pgrp >> stat.session
+        >> stat.tty_nr >> stat.tpgid >> stat.flags >> stat.minflt >> stat.cminflt
+        >> stat.majflt >> stat.cmajflt >> stat.utime >> stat.stime
+        >> stat.cutime >> stat.cstime >> stat.priority >> stat.nice
+        >> stat.num_threads >> stat.itrealvalue >> stat.starttime >> stat.vsize >> stat.rss;
+
+    return stat;
+}
 
 std::string gameanalytics::GAPlatformLinux::getOSVersion()
 {
@@ -156,7 +216,7 @@ void gameanalytics::GAPlatformLinux::signalHandler(int sig, siginfo_t* info, voi
         if (errorCount <= MAX_ERROR_TYPE_COUNT)
         {
             errorCount++;
-            events::GAEvents::addErrorEvent(EGAErrorSeverity::Critical, stackTrace, {}, false, false);
+            events::GAEvents::addErrorEvent(EGAErrorSeverity::Critical, stackTrace, "", -1, {}, false, false);
             events::GAEvents::processEvents("error", false);
         }
 
@@ -180,6 +240,51 @@ std::string gameanalytics::GAPlatformLinux::getCpuModel() const
     return systemInfo.machine;
 }
 
+std::string gameanalytics::GAPlatformLinux::getConnectionType()
+{
+    struct ifaddrs* list = nullptr;
+    struct ifaddrs* current = nullptr;
+
+    std::string connection = CONNECTION_OFFLINE;
+
+    if(getifaddrs(&list) == -1)
+    {
+        return connection;
+    }
+
+    current = list;
+    while(current)
+    {
+        int sock = -1;
+        if (!current->ifa_addr || current->ifa_addr->sa_family != AF_PACKET) 
+        {
+            struct iwreq req = {};
+            strncpy(req.ifr_name, current->ifa_name, IFNAMSIZ);
+
+            int sock = socket(AF_INET, SOCK_STREAM, 0);
+            if (sock == -1) 
+            {
+                connection = CONNECTION_LAN;
+            }
+            else
+            {
+                if (ioctl(sock, SIOCGIWNAME, &req) != -1) 
+                {
+                    connection = CONNECTION_WIFI;
+                }
+            }
+        }
+
+        if(sock != -1)
+            close(sock);
+
+        current = current->ifa_next;
+    }
+
+    freeifaddrs(list);
+    return connection;
+}
+
 std::string gameanalytics::GAPlatformLinux::getGpuModel() const 
 {
     return UNKNOWN_VALUE;
@@ -203,59 +308,42 @@ int64_t gameanalytics::GAPlatformLinux::getTotalDeviceMemory() const
 
 int64_t gameanalytics::GAPlatformLinux::getAppMemoryUsage() const
 {
-    struct task_basic_info info;
-    
-    mach_msg_type_number_t infoSize = TASK_BASIC_INFO_COUNT;
-    kern_return_t result = task_info(mach_task_self(), TASK_BASIC_INFO, (task_info_t)&info, &infoSize);
-    
-    if(result == KERN_SUCCESS) 
-    {
-        return utilities::convertBytesToMB(info.resident_size);
-    }
+    constexpr int k_pageSize = 1024;
+    ProcessStat proc = readProcessStat();
 
-    return 0;
+    int64_t vmUsage      = proc.vsize / k_pageSize;
+    int64_t resident     = proc.rss * (sysconf(_SC_PAGE_SIZE) / k_pageSize);
+
+    int64_t inBytes = (vmUsage + resident) * 1024;
+
+    return utilities::convertBytesToMB(inBytes);
 }
 
 int64_t gameanalytics::GAPlatformLinux::getSysMemoryUsage() const
 {
-    mach_port_t port = mach_host_self();
-    mach_msg_type_number_t hostSize = sizeof(vm_statistics_data_t) / sizeof(integer_t);
-    
-    vm_size_t pageSize;
-    host_page_size(port, &pageSize);
-    
-    vm_statistics_data_t stats;
-    
-    if(host_statistics(port, HOST_VM_INFO, (host_info_t)&stats, &hostSize) == KERN_SUCCESS)
+    struct sysinfo info = {};
+    if(sysinfo(&info) == 0)
     {
-        const int64_t freeMemory = (stats.free_count + stats.inactive_count) * pageSize;
-        return getTotalDeviceMemory() - utilities::convertBytesToMB(freeMemory);
+        return utilities::convertBytesToMB(info.totalram - info.freeram);
     }
 
     return 0;
 }
 
 int64_t gameanalytics::GAPlatformLinux::getBootTime() const
 {
-    const size_t len = 4;
-    int mib[len] = {0,0,0,0};
-    struct kinfo_proc kp = {};
+    ProcessStat procStat = readProcessStat();
 
-    const size_t pidId = 3;
-    
-    size_t num = len;
-    sysctlnametomib("kern.proc.pid", mib, &num);
-    mib[pidId] = getpid();
-    
-    num = sizeof(kp);
-    sysctl(mib, len, &kp, &num, NULL, 0);
+    struct sysinfo info = {};
+    if(sysinfo(&info) != 0)
+    {
+        return 0;
+    }
 
-    struct timeval startTime = kp.kp_proc.p_un.__p_starttime;
-    struct timeval currentTime = {};
-    
-    gettimeofday(&currentTime, NULL);
-    
-    return currentTime.tv_sec - startTime.tv_sec;
+    int64_t startTime = procStat.starttime / sysconf(_SC_CLK_TCK);
+    int64_t bootTime = info.uptime - startTime;
+
+    return bootTime;
 }
 
 #endif