Username: Password: oppure
Beatrix - PcInfo.cpp

PcInfo.cpp

 Caricato da: Piero Tofy
Scarica il programma completo

  1. #include "PcInfo.h"
  2.  
  3. bool isConnect() {
  4.         DWORD dwCb = sizeof(RASCONN);
  5.     DWORD dwErr = ERROR_SUCCESS;
  6.     DWORD dwRetries = 5;
  7.     DWORD dwConnections = 0;
  8.     RASCONN* lpRasConn = NULL;
  9.         RASCONNSTATUS* lpRasStatus = NULL;
  10.  
  11.         while (dwRetries--)
  12.     {
  13.         //
  14.         // If the memory is allocated, free it.
  15.         //
  16.         if (NULL != lpRasConn)
  17.         {
  18.             HeapFree(GetProcessHeap(), 0, lpRasConn);
  19.             lpRasConn = NULL;
  20.         }
  21.  
  22.                 lpRasConn = (RASCONN*) HeapAlloc(GetProcessHeap(), 0, dwCb);
  23.  
  24.         if (NULL == lpRasConn)
  25.         {
  26.             dwErr = ERROR_NOT_ENOUGH_MEMORY;
  27.             break;
  28.         }
  29.  
  30.         // Set the structure size for version checking purposes.
  31.         //
  32.         lpRasConn->dwSize = sizeof(RASCONN);
  33.         //
  34.         // Call the RAS API then exit the loop if we are successful or an unknown
  35.         // error occurs.
  36.         //
  37.         dwErr = RasEnumConnections(
  38.                     lpRasConn,
  39.                     &dwCb,
  40.                     &dwConnections);
  41.                  if (ERROR_BUFFER_TOO_SMALL != dwErr)
  42.         {
  43.             break;
  44.         }
  45.     }
  46.  
  47.  
  48.     if (ERROR_SUCCESS == dwErr)
  49.     {
  50.         for (register unsigned int i = 0; i < dwConnections; i++)
  51.         {
  52.                         RasGetConnectStatus(lpRasConn[i].hrasconn, lpRasStatus);
  53.             if(lpRasStatus->rasconnstate = RASCS_Connected) {
  54.                                 HeapFree(GetProcessHeap(), 0, lpRasConn);
  55.                 lpRasConn = NULL;
  56.                                 return true;
  57.                         }
  58.         }
  59.     }
  60.  
  61.  
  62.     if (NULL != lpRasConn)
  63.     {
  64.         HeapFree(GetProcessHeap(), 0, lpRasConn);
  65.         lpRasConn = NULL;
  66.     }
  67.         return false;
  68. }
  69.  
  70. char* getPercentRamInUse() {
  71.         double bytesBusy = atof(getBytesBusyRam());
  72.         double maxBytes = atof(getBytesMaxRam());
  73.         double percent = (100 * bytesBusy)  / maxBytes;
  74.         return fcvt(percent, 2, NULL, NULL);
  75. }
  76.  
  77. char* getBytesMaxRam() {
  78.         MEMORYSTATUS memory;
  79.     GlobalMemoryStatus(&memory);
  80.         return ultoa(memory.dwTotalPhys/1024, NULL, 10);
  81. }
  82.  
  83. char* getBytesFreeRam() {
  84.         MEMORYSTATUS memory;
  85.     GlobalMemoryStatus(&memory);
  86.         return ultoa(memory.dwAvailPhys/1024, NULL, 10);
  87. }
  88.  
  89. char* getBytesBusyRam() {
  90.         MEMORYSTATUS memory;
  91.     GlobalMemoryStatus(&memory);
  92.         return (getBytesMaxRam() - (memory.dwAvailPhys/1024));
  93. }
  94.  
  95. char* getSystemDirectory() {
  96.         char* systemDir = new char[MAX_PATH];
  97.         GetSystemDirectory(systemDir, 50);
  98.         return systemDir;
  99. }
  100.  
  101. char* getWindowsDirectory() {
  102.         char* winDir = new char[MAX_PATH];
  103.         GetWindowsDirectory(winDir, 50);
  104.         return winDir;
  105. }
  106.  
  107.  
  108. bool isNT() {
  109.         return !(0x80000000 & GetVersion());
  110. }
  111.  
  112.  
  113.  
  114. char* getSerialVolume(char* volume) {
  115.   unsigned long seriale;
  116.   GetVolumeInformation(volume, NULL, 0, &seriale, 0, 0, NULL, 0);
  117.   return ltoa(seriale, NULL, 10);
  118. }
  119.  
  120. //thanks to softzone
  121. char* getvelox() {
  122.         unsigned __int64 x;
  123.  
  124.         unsigned __int64 *dest = &x;
  125.  
  126.         __asm
  127.         {
  128.                 _emit 0xf
  129.                 _emit 0x31
  130.                 mov esi, dest
  131.                 mov [esi], eax
  132.                 mov [esi+4], edx
  133.         }
  134.  
  135.     return _ui64toa(x, NULL, 10);
  136. }
  137.  
  138. char* getSpace(char* volume, int use) {
  139.  
  140.   unsigned __int64 lpFreeBytesAvaibleToCaller, lpTotalNumberOfBytes, lpTotalNumberOfFreeBytes;
  141.   unsigned __int64 space = NULL;
  142.  
  143.   GetDiskFreeSpaceEx(volume, (PULARGE_INTEGER)&lpFreeBytesAvaibleToCaller,
  144.                                     (PULARGE_INTEGER) &lpTotalNumberOfBytes,
  145.                     (PULARGE_INTEGER) &lpTotalNumberOfFreeBytes);
  146.  
  147.  switch(use) {
  148.   case FREE:
  149.         space = lpTotalNumberOfFreeBytes;
  150.         break;
  151.   case USED:
  152.         space = lpTotalNumberOfBytes - lpTotalNumberOfFreeBytes;
  153.         break;
  154.   case TOTAL:
  155.         space = lpTotalNumberOfBytes;
  156.         break;
  157. }
  158.  
  159.  return _ui64toa(space, NULL, 10);
  160. }