'update2'

include/dap_common.h

@@ -32,6 +32,8 @@
 #include <stdlib.h>
 #include <time.h>
 
+#include "portable_endian.h"
+
 #define DAP_NEW( a )          ( (a*) malloc(sizeof(a)) )
 #define DAP_NEW_SIZE( a, b )  ( (a*) malloc(b) )
 #define DAP_NEW_Z( a )        ( (a*) calloc(1,sizeof(a)) )
@@ -64,11 +66,35 @@
 #ifndef MAX
   #define MAX(a, b) ((a) > (b) ? (a) : (b))
 #endif
-
 #ifndef MIN
   #define MIN(a, b) ((a) < (b) ? (a) : (b))
 #endif
 
+#ifndef min
+  #define min MIN
+#endif
+#ifndef max
+  #define max MAX
+#endif
+
+#ifndef LOWORD
+  #define LOWORD( l ) ((uint16_t) (((uintptr_t) (l)) & 0xFFFF))
+  #define HIWORD( l ) ((uint16_t) ((((uintptr_t) (l)) >> 16) & 0xFFFF))
+  #define LOBYTE( w ) ((uint8_t) (((uintptr_t) (w)) & 0xFF))
+  #define HIBYTE( w ) ((uint8_t) ((((uintptr_t) (w)) >> 8) & 0xFF))
+#endif
+
+#ifndef RGB
+  #define RGB(r,g,b) ((uint32_t)(((uint8_t)(r)|((uint16_t)((uint8_t)(g))<<8))|(((uint32_t)(uint8_t)(b))<<16)))
+  #define RGBA(r, g, b, a) ((uint32_t) ((uint32_t)RGB(r,g,b) | (uint32_t)(a) << 24))
+  #define GetRValue(rgb) (LOBYTE(rgb))
+  #define GetGValue(rgb) (LOBYTE(((uint16_t)(rgb)) >> 8))
+  #define GetBValue(rgb) (LOBYTE((rgb)>>16))
+  #define GetAValue(rgb) (LOBYTE((rgb)>>24))
+#endif
+
+#define QBYTE RGBA
+
 #define DAP_LOG_HISTORY_STR_SIZE    128
 #define DAP_LOG_HISTORY_MAX_STRINGS 1024
 #define DAP_LOG_HISTORY_BUFFER_SIZE (DAP_LOG_HISTORY_STR_SIZE * DAP_LOG_HISTORY_MAX_STRINGS)
@@ -83,7 +109,7 @@ typedef enum dap_log_level {
   L_DEBUG     = 0,
   L_INFO      = 1,
   L_NOTICE    = 2,
-  L_MESSAGE   = 3,
+  L_MSG       = 3,
   L_DAP       = 4,
   L_WARNING   = 5,
   L_ATT       = 6,
@@ -144,7 +170,9 @@ static const uint16_t s_ascii_table_data[256] = {
 #define dap_ascii_isspace(c) (s_ascii_table_data[(unsigned char) (c)] & DAP_ASCII_SPACE) != 0
 #define dap_ascii_isalpha(c) (s_ascii_table_data[(unsigned char) (c)] & DAP_ASCII_ALPHA) != 0
 
-int dap_common_init( const char * a_log_file );
+//int dap_common_init( const char * a_log_file );
+int dap_common_init( const char *console_title, const char *a_log_file );
+
 void dap_common_deinit(void);
 
 // set max items in log list

include/portable_endian.h

+
+// "License": Public Domain
+// I, Mathias Panzenb?ck, place this file hereby into the public domain. Use it at your own risk for whatever you like.
+// In case there are jurisdictions that don't support putting things in the public domain you can also consider it to
+// be "dual licensed" under the BSD, MIT and Apache licenses, if you want to. This code is trivial anyway. Consider it
+// an example on how to get the endian conversion functions on different platforms.
+
+#ifndef PORTABLE_ENDIAN_H__
+#define PORTABLE_ENDIAN_H__
+
+#if (defined(_WIN16) || defined(_WIN32) || defined(_WIN64)) && !defined(__WINDOWS__)
+
+# define __WINDOWS__
+
+#endif
+
+#if defined(__linux__) || defined(__CYGWIN__)
+
+# include <endian.h>
+
+#elif defined(__APPLE__)
+
+# include <libkern/OSByteOrder.h>
+
+# define htobe16(x) OSSwapHostToBigInt16(x)
+# define htole16(x) OSSwapHostToLittleInt16(x)
+# define be16toh(x) OSSwapBigToHostInt16(x)
+# define le16toh(x) OSSwapLittleToHostInt16(x)
+ 
+# define htobe32(x) OSSwapHostToBigInt32(x)
+# define htole32(x) OSSwapHostToLittleInt32(x)
+# define be32toh(x) OSSwapBigToHostInt32(x)
+# define le32toh(x) OSSwapLittleToHostInt32(x)
+ 
+# define htobe64(x) OSSwapHostToBigInt64(x)
+# define htole64(x) OSSwapHostToLittleInt64(x)
+# define be64toh(x) OSSwapBigToHostInt64(x)
+# define le64toh(x) OSSwapLittleToHostInt64(x)
+
+# define __BYTE_ORDER    BYTE_ORDER
+# define __BIG_ENDIAN    BIG_ENDIAN
+# define __LITTLE_ENDIAN LITTLE_ENDIAN
+# define __PDP_ENDIAN    PDP_ENDIAN
+
+#elif defined(__OpenBSD__)
+
+# include <sys/endian.h>
+
+#elif defined(__NetBSD__) || defined(__FreeBSD__) || defined(__DragonFly__)
+
+# include <sys/endian.h>
+
+# define be16toh(x) betoh16(x)
+# define le16toh(x) letoh16(x)
+
+# define be32toh(x) betoh32(x)
+# define le32toh(x) letoh32(x)
+
+# define be64toh(x) betoh64(x)
+# define le64toh(x) letoh64(x)
+
+#elif defined(__WINDOWS__)
+
+# include <windows.h>
+
+# if BYTE_ORDER == LITTLE_ENDIAN
+
+#               if defined(_MSC_VER)
+#                       include <stdlib.h>
+#     define htobe16(x) _byteswap_ushort(x)
+#     define htole16(x) (x)
+#     define be16toh(x) _byteswap_ushort(x)
+#     define le16toh(x) (x)
+                  
+#     define htobe32(x) _byteswap_ulong(x)
+#     define htole32(x) (x)
+#     define be32toh(x) _byteswap_ulong(x)
+#     define le32toh(x) (x)
+                  
+#     define htobe64(x) _byteswap_uint64(x)
+#     define htole64(x) (x)
+#     define be64toh(x) _byteswap_uint64(x)
+#     define le64toh(x) (x)
+
+#               elif defined(__GNUC__) || defined(__clang__)
+
+#     define htobe16(x) __builtin_bswap16(x)
+#     define htole16(x) (x)
+#     define be16toh(x) __builtin_bswap16(x)
+#     define le16toh(x) (x)
+                  
+#     define htobe32(x) __builtin_bswap32(x)
+#     define htole32(x) (x)
+#     define be32toh(x) __builtin_bswap32(x)
+#     define le32toh(x) (x)
+                  
+#     define htobe64(x) __builtin_bswap64(x)
+#     define htole64(x) (x)
+#     define be64toh(x) __builtin_bswap64(x)
+#     define le64toh(x) (x)
+#               else
+#                       error platform not supported
+#               endif
+
+# else
+
+#   error byte order not supported
+
+# endif
+
+# define __BYTE_ORDER    BYTE_ORDER
+# define __BIG_ENDIAN    BIG_ENDIAN
+# define __LITTLE_ENDIAN LITTLE_ENDIAN
+# define __PDP_ENDIAN    PDP_ENDIAN
+
+#else
+
+# error platform not supported
+
+#endif
+
+#endif

src/dap_common.c

@@ -40,17 +40,14 @@
   #include <pthread.h>
   #include <syslog.h>
 
-  // Quick and dirty, I'm not sure but afair somewhere it was in UNIX systems too
-  #define min(a,b) (((a)<(b))?(a):(b))
-  #define max(a,b) (((a)>(b))?(a):(b))
-
 #else // WIN32
 
   #include <stdlib.h>
   #include <windows.h>
   #include <process.h>
   #include <pthread.h>
-  ///typedef HANDLE pthread_mutex_t;
+
+  #include "win32/dap_console_manager.h"
 
   #define popen _popen
   #define pclose _pclose
@@ -186,10 +183,14 @@ void dap_set_log_tag_width(size_t width) {
  * @param[in] a_log_file
  * @return
  */
-int dap_common_init( const char *a_log_file )
+int dap_common_init( const char *console_title, const char *a_log_file )
 {
   srand( (unsigned int)time(NULL) );
 
+  #ifdef _WIN32
+    SetupConsole( console_title, L"Lucida Console", 12, 20 );
+  #endif
+
   // init default log tag 8 width
   strcpy( log_tag_fmt_str, "[%8s]\t");
 
@@ -254,6 +255,8 @@ err:
  */
 void dap_common_deinit( )
 {
+  printf("dap_common_deinit( )\n");
+
   if ( s_log_file )
     fclose( s_log_file );
 
@@ -450,7 +453,7 @@ void _log_it( const char *log_tag, enum dap_log_level ll, const char *fmt,... )
 {
   static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
   uint8_t   *buf0 = temp_buffer;
-  uint32_t  len,
+  uint32_t  len, tmp,
             time_offset,
             tag_offset,
             msg_offset;
@@ -501,22 +504,16 @@ void _log_it( const char *log_tag, enum dap_log_level ll, const char *fmt,... )
   log_log( (char *)(buf0 + time_offset), len - time_offset, t );
 
   #ifdef _WIN32
-//    if ( !bUseANSIEscapeSequences )
+  //    if ( !bUseANSIEscapeSequences )
     SetConsoleTextAttribute( hWin32ConOut, log_level_colors[ll] );
-  //  printf( "%s", (char *)(buf0 + time_offset) );
+  //  WriteConsole( hWin32ConOut, buf0 + time_offset, len - time_offset, &tmp, NULL );
+  //  fwrite( buf0 + time_offset, len - time_offset, 1, stdout );
+    WriteFile( hWin32ConOut, buf0 + time_offset, len - time_offset, (LPDWORD)&tmp, NULL );
   #else
-
-//    memcpy( buf0, len, 
-//    printf( "%s", (char *)buf0 );
     fwrite( buf0, len, 1, stdout );
-
   #endif
 
-///stdout
-
 //    printf("\x1b[0m\n");
-//  "\x1b[0;37;40m",   // L_DEBUG     = 0 
-
 
   pthread_mutex_unlock( &mutex );
 }
@@ -601,7 +598,9 @@ int dap_time_to_str_rfc822(char * out, size_t out_size_max, time_t t)
 
 static int breaker_set[2] = { -1, -1 };
 static int initialized = 0;
+#ifndef _WIN32
 static struct timespec break_latency = { 0, BREAK_LATENCY * 1000 * 1000 };
+#endif
 
 int get_select_breaker( )
 {

src/win32/dap_console_manager.c

+/*
+ Copyright (c) 2017-2019 (c) Project "DeM Labs Inc" https://github.com/demlabsinc
+  All rights reserved.
+
+ This file is part of DAP (Deus Applications Prototypes) the open source project
+
+    DAP (Deus Applicaions Prototypes) is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    DAP is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with any DAP based project.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <memory.h>
+
+#include <windows.h>
+
+#define WM_SETCONSOLEINFO (WM_USER + 201) 
+
+#pragma pack(push, 1) 
+typedef struct _CONSOLE_INFO
+{
+  DWORD Length;
+  COORD ScreenBufferSize;
+  COORD WindowSize;
+  DWORD WindowPosX;
+  DWORD WindowPosY;
+  COORD FontSize;
+  DWORD FontFamily;
+  DWORD FontWeight;
+  WCHAR FaceName[32];
+  DWORD CursorSize;
+  DWORD FullScreen;
+  DWORD QuickEdit;
+  DWORD AutoPosition;
+  DWORD InsertMode;
+  USHORT ScreenColors;
+  USHORT PopupColors;
+  DWORD HistoryNoDup;
+  DWORD HistoryBufferSize;
+  DWORD NumberOfHistoryBuffers;
+  COLORREF ColorTable[16];
+  DWORD CodePage;
+  HWND Hwnd;
+  WCHAR ConsoleTitle[0x100];
+} CONSOLE_INFO;
+#pragma pack(pop) 
+
+static uint32_t palette[ 16 ] =  {
+
+  RGB(   0,   0,   0 ), // 0   black
+  RGB(   0,   0, 170 ), // 1   blue
+  RGB( 0,   170,   0 ), // 2   green
+  RGB( 170, 170,   0 ), // 3   cyan 
+  RGB( 170,   0,   0 ), // 4   red
+  RGB( 170,   0, 170 ), // 5   magenta
+  RGB(   0,  85, 170 ), // 6   yellow / brown
+  RGB( 170, 170, 170 ), // 7   white / light gray
+  RGB( 85,  85,   85 ), // 8   dark gray / bright black
+  RGB(  85,  85, 255 ), // 9   bright blue
+  RGB(   0, 255,   0 ), // 10  bright green
+  RGB(   0, 255, 255 ), // 11  bright cyan
+  RGB( 255,  0,    0 ), // 12  bright red
+  RGB( 255,  85, 255 ), // 13  bright magenta
+  RGB( 255, 255,  85 ), // 14  bright yellow
+  RGB( 255, 255, 255 )  // 15  bright white
+};
+
+static void GetConsoleSizeInfo( CONSOLE_INFO *pci, HANDLE hConOut )
+{
+  CONSOLE_SCREEN_BUFFER_INFO csbi;
+
+  GetConsoleScreenBufferInfo( hConOut, &csbi );
+
+  pci->ScreenBufferSize = csbi.dwSize;
+  pci->WindowSize.X = csbi.srWindow.Right - csbi.srWindow.Left + 1;
+  pci->WindowSize.Y = csbi.srWindow.Bottom - csbi.srWindow.Top + 1;
+  pci->WindowPosX = csbi.srWindow.Left;
+  pci->WindowPosY = csbi.srWindow.Top;
+}
+
+static BOOL SetConsoleInfo( HWND hwndConsole, CONSOLE_INFO *pci )
+{
+  DWORD dwConsoleOwnerPid;
+  HANDLE hProcess;
+  HANDLE hSection, hDupSection;
+  PVOID ptrView = 0;
+  HANDLE hThread;
+  
+  GetWindowThreadProcessId( hwndConsole, &dwConsoleOwnerPid );
+
+  hProcess = OpenProcess( MAXIMUM_ALLOWED, FALSE, dwConsoleOwnerPid );
+  hSection = CreateFileMapping( INVALID_HANDLE_VALUE, 0, PAGE_READWRITE, 0, pci->Length, 0 );
+  ptrView  = MapViewOfFile( hSection, FILE_MAP_WRITE|FILE_MAP_READ, 0, 0, pci->Length );
+
+  memcpy( ptrView, pci, pci->Length );
+  UnmapViewOfFile( ptrView );
+
+  DuplicateHandle( GetCurrentProcess(), hSection, hProcess, &hDupSection, 0, FALSE, DUPLICATE_SAME_ACCESS );
+
+  SendMessage( hwndConsole, WM_SETCONSOLEINFO, (WPARAM)hDupSection, 0 );
+
+  hThread = CreateRemoteThread( hProcess, 0, 0, (LPTHREAD_START_ROUTINE)CloseHandle, hDupSection, 0, 0 );
+
+  CloseHandle( hThread );
+  CloseHandle( hSection );
+  CloseHandle( hProcess );
+
+  return TRUE;
+}
+
+typedef BOOL (WINAPI *PGetCurrentConsoleFontEx)(HANDLE hConsoleOutput, BOOL bMaximumWindow, PCONSOLE_FONT_INFOEX lpConsoleCurrentFontEx);
+typedef BOOL (WINAPI *PSetCurrentConsoleFontEx)(HANDLE hConsoleOutput, BOOL bMaximumWindow, PCONSOLE_FONT_INFOEX lpConsoleCurrentFontEx);
+typedef BOOL (WINAPI *PGetConsoleScreenBufferInfoEx)(HANDLE hConsoleOutput, PCONSOLE_SCREEN_BUFFER_INFOEX lpConsoleScreenBufferInfoEx);
+typedef BOOL (WINAPI *PSetConsoleScreenBufferInfoEx)(HANDLE hConsoleOutput, PCONSOLE_SCREEN_BUFFER_INFOEX lpConsoleScreenBufferInfoEx);
+
+////Lucida Console 12 20
+
+void SetupConsole( const char *title, const uint16_t *fontName, int fontx, int fonty )
+{
+  HANDLE hConOut;
+  HANDLE hConIn;
+
+  HWND hwndConsole = GetConsoleWindow( );
+  if ( !hwndConsole ) { // daemon ?
+    return;
+  }
+
+  uint32_t console_owner_proc_id;
+
+  GetWindowThreadProcessId( hwndConsole, (LPDWORD)&console_owner_proc_id );
+
+  if ( console_owner_proc_id != GetCurrentProcessId() ) {
+//    return;
+  }
+
+  SetConsoleTitleA( (LPCSTR)title );
+
+  hConOut = GetStdHandle( STD_OUTPUT_HANDLE );
+  hConIn  = GetStdHandle( STD_INPUT_HANDLE );
+
+  int sx = GetSystemMetrics( SM_CXSCREEN );
+  int sy = GetSystemMetrics( SM_CYSCREEN );
+
+//  COORD conmax = GetLargestConsoleWindowSize( hConOut );
+
+  PGetCurrentConsoleFontEx pGetCurrentConsoleFontEx = (PGetCurrentConsoleFontEx)
+    GetProcAddress( GetModuleHandleA("kernel32.dll"), "GetCurrentConsoleFontEx" );
+  PSetCurrentConsoleFontEx pSetCurrentConsoleFontEx = (PSetCurrentConsoleFontEx)
+    GetProcAddress( GetModuleHandleA("kernel32.dll"), "SetCurrentConsoleFontEx" );
+  PGetConsoleScreenBufferInfoEx pGetConsoleScreenBufferInfoEx = (PGetConsoleScreenBufferInfoEx)
+    GetProcAddress( GetModuleHandleA("kernel32.dll"), "GetConsoleScreenBufferInfoEx" );
+  PSetConsoleScreenBufferInfoEx pSetConsoleScreenBufferInfoEx = (PSetConsoleScreenBufferInfoEx)
+    GetProcAddress( GetModuleHandleA("kernel32.dll"), "SetConsoleScreenBufferInfoEx" );
+
+  if ( pGetCurrentConsoleFontEx && pSetCurrentConsoleFontEx &&
+      pGetConsoleScreenBufferInfoEx && pSetConsoleScreenBufferInfoEx )
+  {
+    CONSOLE_SCREEN_BUFFER_INFOEX conBufferInfo; 
+    CONSOLE_FONT_INFOEX conFontInfo = {sizeof(CONSOLE_FONT_INFOEX)};
+
+    conFontInfo.cbSize = sizeof( CONSOLE_FONT_INFOEX );
+    pGetCurrentConsoleFontEx( hConOut, TRUE, &conFontInfo );
+
+//    printf("conFontInfo.nFont %u \n", conFontInfo.nFont );
+//    printf("conFontInfo.dwFontSize.X %u \n", conFontInfo.dwFontSize.X );
+//    printf("conFontInfo.dwFontSize.Y %u \n", conFontInfo.dwFontSize.Y );
+//    printf("conFontInfo.FontFamily %u \n", conFontInfo.FontFamily );
+//    printf("conFontInfo.FontWeight %u \n", conFontInfo.FontWeight );
+
+    conFontInfo.nFont = 20;
+    conFontInfo.dwFontSize.X = 12;
+    conFontInfo.dwFontSize.Y = 20;
+    conFontInfo.FontFamily = 0;
+    conFontInfo.FontWeight = 0;
+    lstrcpyW( conFontInfo.FaceName, fontName );
+
+    pSetCurrentConsoleFontEx( hConOut, TRUE, &conFontInfo );
+
+    conBufferInfo.cbSize = sizeof( CONSOLE_SCREEN_BUFFER_INFOEX );
+    pGetConsoleScreenBufferInfoEx( hConOut, &conBufferInfo );
+
+    memcpy( &conBufferInfo.ColorTable[0], &palette[0], 4 * 16 );
+    pSetConsoleScreenBufferInfoEx( hConOut, &conBufferInfo );
+  }
+  else {
+//    printf("XP ?...\n" );
+
+    CONSOLE_INFO ci = { sizeof(ci) };
+
+    GetConsoleSizeInfo( &ci, hConOut );
+
+    ci.FontSize.X = 12;
+    ci.FontSize.Y = 20;
+    ci.FontFamily = 0;
+    ci.FontWeight = 0;
+
+    lstrcpyW( ci.FaceName, fontName );
+
+//    ci.CursorSize = 100;
+    ci.FullScreen = FALSE;
+    ci.QuickEdit = FALSE;
+    ci.AutoPosition = 0x10000;
+    ci.InsertMode = TRUE;
+    ci.ScreenColors = MAKEWORD(0x7, 0x0);
+    ci.PopupColors = MAKEWORD(0x5, 0xf); 
+    ci.HistoryNoDup = TRUE; 
+    ci.HistoryBufferSize = 50; 
+    ci.NumberOfHistoryBuffers = 4; 
+
+    memcpy( &ci.ColorTable[0], &palette[0], 4 * 16 );
+
+    ci.CodePage = 0; 
+    ci.Hwnd = hwndConsole;
+
+    SetConsoleInfo( hwndConsole, &ci ); 
+  }
+
+  int bx = sx / 12;
+  int by = sy / 20;
+
+  SMALL_RECT Rect = { 0, 0, bx, by };
+  COORD coord = { bx, by };
+
+  SetConsoleWindowInfo( hConOut, TRUE, &Rect );
+  SetConsoleScreenBufferSize( hConOut, coord );
+
+  SetWindowPos( hwndConsole, HWND_TOP, 0, 0, sx-1, sy-1, SWP_NOSIZE );
+  ShowWindow( hwndConsole, SW_MAXIMIZE );
+}

src/win32/dap_console_manager.h

+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void SetupConsole( const char *title, const uint16_t *fontName, int fontx, int fonty );
+
+#ifdef __cplusplus
+}
+#endif

src/win32/dap_cpu_monitor.c

+/*
+ Copyright (c) 2017-2019 (c) Project "DeM Labs Inc" https://github.com/demlabsinc
+  All rights reserved.
+
+ This file is part of DAP (Deus Applications Prototypes) the open source project
+
+    DAP (Deus Applicaions Prototypes) is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    DAP is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with any DAP based project.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <windows.h>
+#include <winnt.h>
+#include <winternl.h>
+
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include "dap_cpu_monitor.h"
+#include "dap_common.h"
+
+#define LOG_TAG "dap_cpu_monitor"
+
+//static FILE * _proc_stat = NULL;
+static dap_cpu_stats_t _cpu_stats = {0};
+
+static dap_cpu_t _cpu_old_stats[MAX_CPU_COUNT] = {0};
+static dap_cpu_t _cpu_summary_old = {0};
+
+typedef struct proc_stat_line
+{
+    /* http://man7.org/linux/man-pages/man5/proc.5.html */
+    char cpu[10];
+    uint64_t user;
+    uint64_t nice;
+    uint64_t system;
+    uint64_t idle;
+    uint64_t iowait;
+    uint64_t irq;
+    uint64_t softirq;
+    uint64_t steal;
+    uint64_t guest;
+    uint64_t guest_nice;
+    uint64_t total; // summary all parameters
+} proc_stat_line_t;
+
+int dap_cpu_monitor_init()
+{
+  SYSTEM_INFO si;
+
+  GetSystemInfo( &si );
+  _cpu_stats.cpu_cores_count = si.dwNumberOfProcessors;
+
+  log_it( L_DEBUG, "dap_cpu_monitor_init(): Cpu core count: %d", _cpu_stats.cpu_cores_count );
+
+  dap_cpu_get_stats( ); // init prev parameters
+
+  return 0;
+}
+
+void dap_cpu_monitor_deinit()
+{
+
+}
+/*
+static void _deserealize_proc_stat(char *line, proc_stat_line_t *stat)
+{
+    sscanf(line,"%s %zu %zu %zu %zu %zu %zu %zu %zu %zu %zu",
+           stat->cpu, &stat->user, &stat->nice, &stat->system, &stat->idle,
+           &stat->iowait, &stat->irq, &stat->softirq, &stat->steal,
+           &stat->guest, &stat->guest_nice);
+
+    stat->total = stat->user + stat->system + stat->idle +
+            stat->iowait + stat->irq + stat->softirq +
+            stat->steal + stat->guest + stat->guest_nice;
+}
+*/
+static float _calculate_load( uint64_t idle_time, uint64_t prev_idle_time,
+                      uint64_t total_time, uint64_t prev_total_time ) {
+  return ( 1 - (1.0 * idle_time - prev_idle_time) / (total_time - prev_total_time) ) * 100.0;
+}
+
+dap_cpu_stats_t dap_cpu_get_stats()
+{
+  FILETIME idleTime, kernelTime, userTime;
+  GetSystemTimes( &idleTime, &kernelTime, &userTime );
+
+  #define WINNT_FILETIME_TO_UINT64(t) (((uint64_t)(t.dwHighDateTime)<<32) | (uint64_t)(t.dwLowDateTime))
+  _cpu_stats.cpu_summary.idle_time  = WINNT_FILETIME_TO_UINT64(idleTime);
+  _cpu_stats.cpu_summary.total_time = WINNT_FILETIME_TO_UINT64(kernelTime) + WINNT_FILETIME_TO_UINT64(userTime);
+
+  /*********************************************/
+
+  SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION pinfo[64];
+  ULONG outsize;
+  uint32_t ntstatus_error;
+
+  ntstatus_error = NtQuerySystemInformation( SystemProcessorPerformanceInformation, &pinfo, 
+                              sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION) * 64, &outsize );
+
+  if ( ntstatus_error ) {
+    log_it(L_ERROR, "NtQuerySystemInformation returned an error %u", ntstatus_error );
+    return (dap_cpu_stats_t){0};
+  }
+
+  if ( outsize < sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION) * _cpu_stats.cpu_cores_count ) {
+    log_it(L_WARNING, "NtQuerySystemInformation: data size less than expected");
+  }
+
+  for( uint32_t i = 0; i < _cpu_stats.cpu_cores_count; i++ ) {
+
+    _cpu_stats.cpus[i].idle_time = pinfo[i].IdleTime.QuadPart;
+    _cpu_stats.cpus[i].total_time = pinfo[i].KernelTime.QuadPart + pinfo[i].UserTime.QuadPart;
+    _cpu_stats.cpus[i].ncpu = i;
+
+    _cpu_stats.cpus[i].load = _calculate_load(_cpu_stats.cpus[i].idle_time,
+                                                  _cpu_old_stats[i].idle_time,
+                                                  _cpu_stats.cpus[i].total_time,
+                                                  _cpu_old_stats[i].total_time);
+
+       // log_it(L_WARNING, "CPU %d %f", i, _cpu_stats.cpus[i].load);
+  }
+
+  _cpu_stats.cpu_summary.load = _calculate_load(_cpu_stats.cpu_summary.idle_time,
+                    _cpu_summary_old.idle_time,
+                    _cpu_stats.cpu_summary.total_time,
+                    _cpu_summary_old.total_time);
+
+  //  log_it(L_WARNING, "%f", _cpu_stats.cpu_summary.load);
+
+  memcpy(&_cpu_summary_old, &_cpu_stats.cpu_summary, sizeof (dap_cpu_t));
+
+  memcpy(_cpu_old_stats, _cpu_stats.cpus,
+           sizeof (dap_cpu_t) * _cpu_stats.cpu_cores_count);
+
+  return _cpu_stats;
+}

src/win32/dap_cpu_monitor.h

+#pragma once
+
+#define MAX_CPU_COUNT 64
+
+typedef struct dap_cpu {
+    uint32_t ncpu; // number of cpu core
+    float load; // percent of load
+    uint64_t total_time;
+    uint64_t idle_time;
+} dap_cpu_t;
+
+typedef struct dap_cpu_stats
+{
+    uint32_t cpu_cores_count;
+    dap_cpu_t cpu_summary; // average statistic for all cpu
+    dap_cpu_t cpus[MAX_CPU_COUNT]; // list of cpu with stat
+} dap_cpu_stats_t;
+
+/**
+ * @brief dap_cpu_monitor_init Monitor CPU initialization
+ * @return
+ */
+int dap_cpu_monitor_init(void);
+
+/**
+ * @brief dap_cpu_monitor_deinit Monitor CPU deinitialization
+ */
+void dap_cpu_monitor_deinit(void);
+
+/**
+ * @brief dap_cpu_get_stats Getting processor information
+ * @return
+ */
+dap_cpu_stats_t dap_cpu_get_stats(void);

src/win32/dap_network_monitor.h

+/*
+ * Authors:
+ * Anatolii Kurotych <akurotych@gmail.com>
+ * DeM Labs Inc.   https://demlabs.net
+ * DeM Labs Open source community https://github.com/demlabsinc
+ * Copyright  (c) 2017-2019
+ * All rights reserved.
+
+ This file is part of DAP (Deus Applications Prototypes) the open source project
+
+    DAP (Deus Applicaions Prototypes) is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    DAP is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with any DAP based project.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#pragma once
+
+#include <stdint.h>
+#include <stdbool.h>
+
+//#include <net/if.h>
+//#include <linux/rtnetlink.h>
+
+#define MAX_IP_STR_LEN 15
+#define DAP_ADRESS_UNDEFINED (uint64_t)-1
+
+typedef enum {
+    // like in rtnetlink defines
+    IP_ADDR_ADD,
+    IP_ADDR_REMOVE,
+    IP_ROUTE_ADD,
+    IP_ROUTE_REMOVE,
+    IP_LINK_NEW,
+    IP_LINK_DEL
+} dap_network_monitor_notification_type_t;
+
+
+typedef struct {
+    dap_network_monitor_notification_type_t type;
+    union {
+        struct {
+            char interface_name[IF_NAMESIZE];
+            char s_ip[MAX_IP_STR_LEN + 1];
+            uint32_t ip; // inet_ntoa(*((struct in_addr *)&ipaddr)) for cast to char*
+        } addr; // for IP_ADDR_ADD, IP_ADDR_REMOVE
+        struct {
+            uint64_t destination_address; // 64 bit for checking -1 like not filled variable
+            char s_destination_address[MAX_IP_STR_LEN + 1];
+            uint64_t gateway_address;
+            char s_gateway_address[MAX_IP_STR_LEN + 1];
+            uint8_t protocol;
+            uint8_t netmask;
+        } route; // for IP_ROUTE_ADD, IP_ROUTE_REMOVE
+        struct {
+            char interface_name[IF_NAMESIZE];
+            bool is_up;
+            bool is_running;
+        } link; // for RTM_NEWLINK, RTM_DELLINK
+    };
+} dap_network_notification_t;
+
+typedef void (*dap_network_monitor_notification_callback_t)
+              (const dap_network_notification_t notification);
+
+/**
+ * @brief dap_network_monitor_init
+ * @param callback
+ * @details starts network monitorting
+ * @return 0 if successful
+ */
+int dap_network_monitor_init(dap_network_monitor_notification_callback_t callback);
+
+/**
+ * @brief dap_network_monitor_deinit
+ */
+void dap_network_monitor_deinit(void);
+
+#ifdef __cplusplus
+}
+#endif

src/win32/dap_process_manager.c

+/*
+ Copyright (c) 2017-2019 (c) Project "DeM Labs Inc" https://github.com/demlabsinc
+  All rights reserved.
+
+ This file is part of DAP (Deus Applications Prototypes) the open source project
+
+    DAP (Deus Applicaions Prototypes) is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    DAP is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with any DAP based project.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <windows.h>
+#include <winnt.h>
+#include <winternl.h>
+
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdbool.h>
+
+#include "dap_process_manager.h"
+#include "dap_common.h"
+
+#undef LOG_TAG
+#define LOG_TAG "dap_process_manager"
+
+/**
+ * @brief is_process_running Check whether the process is running
+ * @param[in] pid PID
+ * @return
+ */
+bool is_process_running( pid_t pid ) {
+
+  DWORD ExitCode = 0;
+
+  HANDLE hProcess = OpenProcess( PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, pid );
+
+  if ( !hProcess ) 
+    return false;
+
+  if ( !GetExitCodeProcess( hProcess, &ExitCode ) || ExitCode != STILL_ACTIVE ) {
+    CloseHandle( hProcess );
+    return false;
+  }
+
+  CloseHandle( hProcess );
+
+  return true;
+}
+
+/**
+ * @brief save_process_pid_in_file Saves process pid into file by file_path
+ * @param[in] file_path File path
+ * @return Execution result
+ *
+ * Saves process pid into file by file_path.
+ * If file exists he will be overwritten
+ */
+bool save_process_pid_in_file( const char* file_path )
+{
+  FILE *fpid = fopen( file_path, "wb" );
+
+  if ( fpid == NULL ) {
+    log_it( L_ERROR, "Cant create/open file by path %s",file_path );
+    return false;
+  }
+
+  fprintf( fpid, "%u", GetCurrentProcessId() );
+  fclose( fpid );
+
+  return true;
+}
+
+/**
+ * @brief get_pid_from_file File must consist only PID. Return 0 if file is clear.
+ * @param[in] file_path File path
+ * @return Execution result
+ */
+pid_t get_pid_from_file( const char* file_path ) {
+
+  FILE *fpid = fopen( file_path, "rb");
+
+  if ( fpid == NULL ) {
+    log_it( L_ERROR, "Cant create/open file by path %s", file_path );
+    return false;
+  }
+
+  pid_t f_pid = 0;
+
+  fscanf( fpid, "%u", &f_pid );
+  fclose( fpid );
+
+  return f_pid;
+}
+
+/**
+ * @brief daemonize_process Demonizes current process and exit from program
+ * @return
+ */
+bool daemonize_process( ) {
+
+  STARTUPINFO start_info;
+  PROCESS_INFORMATION proc_info;
+  char fn_exe[256];
+  DWORD status;
+
+  memset( &start_info, 0, sizeof(STARTUPINFO) );
+  memset( &proc_info, 0, sizeof(PROCESS_INFORMATION) );
+  memset( &fn_exe[0], 0, 256 );
+
+  status = GetModuleFileName( NULL, fn_exe, sizeof(fn_exe) );
+
+  if ( !status || status == sizeof(fn_exe) ) {
+    return false;
+  }
+
+  GetStartupInfo( &start_info );
+
+  if ( CreateProcess(fn_exe, NULL, NULL, NULL, FALSE, CREATE_NO_WINDOW, NULL, NULL, &start_info, &proc_info) ) {
+
+    CloseHandle( proc_info.hThread );
+    CloseHandle( proc_info.hProcess );
+    ExitProcess( 0 );
+  }
+
+  return false;
+}
+
+/**
+ * @brief kill_process Sends SIGKILL to process
+ * @param[in] pid
+ * @return
+ */
+bool kill_process( pid_t pid ) {
+
+  DWORD ExitCode;
+  bool rezult = false;
+
+  HANDLE hProcess = OpenProcess( PROCESS_QUERY_INFORMATION | PROCESS_TERMINATE, FALSE, pid );
+
+  if ( !hProcess ) {
+
+    return false;
+  }
+
+  if ( !GetExitCodeProcess( hProcess, &ExitCode ) ) {
+
+    return false;
+    CloseHandle( hProcess );
+  }
+
+  if ( ExitCode == STILL_ACTIVE ) {
+    rezult = TerminateProcess( hProcess, 0 );
+  }
+
+  CloseHandle( hProcess );
+
+  return rezult;
+}

src/win32/dap_process_manager.h

+
+#include <stdbool.h>
+#include <unistd.h>
+#include <stdint.h>
+
+/* Saves process pid into file by file_path.
+ * If file exists he will be overwritten */
+extern bool save_process_pid_in_file( const char* file_path );
+
+/* File must consist only PID. Return 0 if file is clear. */
+extern pid_t get_pid_from_file( const char* file_path );
+
+/* Return true if process running */
+extern bool is_process_running( pid_t pid );
+
+/* Demonizes current process and exit from program */
+extern bool daemonize_process( void );
+
+/* Sends SIGKILL to process */
+extern bool kill_process( pid_t pid );
+

src/win32/dap_process_memory.c

+/*
+ Copyright (c) 2017-2019 (c) Project "DeM Labs Inc" https://github.com/demlabsinc
+  All rights reserved.
+
+ This file is part of DAP (Deus Applications Prototypes) the open source project
+
+    DAP (Deus Applicaions Prototypes) is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    DAP is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with any DAP based project.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <windows.h>
+#include <winnt.h>
+#include <winternl.h>
+#include <stdint.h>
+#include <pdh.h>
+#include <stdio.h>
+#include <psapi.h>
+
+#include "dap_process_memory.h"
+#include "dap_common.h"
+
+#define LOG_TAG "dap_process_mem"
+
+static dap_process_memory_t _get_process_memory( uint32_t pid )
+{
+  HANDLE hProcess;
+  PROCESS_MEMORY_COUNTERS pmc;
+  dap_process_memory_t proc_mem = { 0, 0 };
+
+  hProcess = OpenProcess( PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, pid );
+  if ( !hProcess )
+      return proc_mem;
+
+  if ( !GetProcessMemoryInfo( hProcess, &pmc, sizeof(pmc)) ) {
+    CloseHandle( hProcess );
+    return proc_mem;
+  }
+
+  proc_mem.vsz = pmc.PagefileUsage;
+  proc_mem.rss = pmc.WorkingSetSize;
+
+  CloseHandle( hProcess );
+  return proc_mem;
+}
+
+dap_process_memory_t get_proc_mem_current( void )
+{
+  return _get_process_memory( GetCurrentProcessId() );
+}
+
+dap_process_memory_t get_proc_mem_by_pid( uint32_t pid )
+{
+  return _get_process_memory( pid );
+}

src/win32/dap_process_memory.h

+
+//#include <stdint.h>
+//#include <sys/types.h>
+
+
+typedef struct dap_process_memory {
+    size_t vsz; // virtual memory (kb)
+    size_t rss; // physical memory (kb)
+} dap_process_memory_t;
+
+
+/**
+ * @brief get_proc_mem_current Get information about the amount of RAM consumed for the current process
+ * @return
+ */
+dap_process_memory_t get_proc_mem_current(void);
+
+/**
+ * @brief get_proc_mem_by_pid Obtain information about the amount of RAM consumed for a particular process
+ * @param[in] pid PID
+ * @return
+ */
+dap_process_memory_t get_proc_mem_by_pid( uint32_t pid );