GESTION DE LE MÉMOIRE UTILISÉE PAR UN PROCESSUS

#include <iostream>
#include <cstdio>
#include <windows.h>
#include <tlhelp32.h>
#include <psapi.h>

using namespace std;


int fileExist(const char* fileName)
{
    return (0 <= (INT_PTR)GetFileAttributesA(fileName));
}

void SetDebugPrivilege(){
TOKEN_PRIVILEGES privilege;
LUID Luid;
HANDLE handle1;
HANDLE handle2;
handle1 = OpenProcess(PROCESS_ALL_ACCESS, FALSE, GetCurrentProcessId());
OpenProcessToken(handle1, TOKEN_ALL_ACCESS, &handle2);
LookupPrivilegeValue(NULL, SE_DEBUG_NAME, &Luid);
privilege.PrivilegeCount = 1;
privilege.Privileges[0].Luid = Luid;
privilege.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
AdjustTokenPrivileges(handle2, FALSE, &privilege, sizeof(privilege), NULL, NULL);
CloseHandle(handle2);
CloseHandle(handle1);
}
 
int main(int argc, char *argv[])
{
    
    char ProcessName[20];
    cout<<"\nProcess : "; //On récupère le nom du processus
    cin>>ProcessName;
    
    int limit = 0;
    cout << "\nBytes limit :"; //On récupère la limite en bytes de l'utilisation de la mémoire
    cin >> limit; 
    
    HANDLE hSnapShot; //Handle de la liste de processus
    PROCESSENTRY32 uProcess;
    
    SetDebugPrivilege();
                                      
    hSnapShot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0); //On créé une liste des processus
    uProcess.dwSize = (DWORD) sizeof(PROCESSENTRY32);
    
    int p;
    short PID = 0;
    
    p = Process32First(hSnapShot, &uProcess); //On se positionne sur le premier processus
    
    do
    {
        if(strstr(uProcess.szExeFile, ProcessName)) //On recherche le nom de notre processus dans la liste
        {
                                      FILE * fichier; //On place les informations dans un fichier log
                                      char FileName[30] = "";
                                      strcat(FileName, uProcess.szExeFile);
                                      strcat(FileName, ".log");
                                      if(fileExist(FileName))//Si il existe déjà un fichier log pour le meme processus on le supprime
                                      {
                                                            DeleteFile(FileName);
                                      }
                                      fichier = fopen(FileName, "a+");
                                      fprintf(fichier, "**************Looking at %s *************\n", uProcess.szExeFile);
                                      
                                      cout<<"\n\nProcess found : "<<uProcess.szExeFile<<"\n";
                                      
                                      PID = (short) uProcess.th32ProcessID; //On récupere le PID de notre processus
                                      
                                      HANDLE hTemp; //Handle du processus
                                      PROCESS_MEMORY_COUNTERS pmc;
                                      

                                      hTemp = OpenProcess(PROCESS_QUERY_INFORMATION|PROCESS_ALL_ACCESS, 0, (DWORD) PID);//On accede au processus en récupérant les informations le concernant et en gardant tout accès dessus
                                      
                                      
                                      system("pause");
                                      system("cls");
                                      while(GetProcessMemoryInfo(hTemp, &pmc, sizeof(pmc)))//On récupere des informations sur l'utilisation de la mémoire pas notre processus
                                      {
                                             long work = pmc.WorkingSetSize / 1024;
                                             fprintf(fichier , "\nProcessus using %ld bytes ", work);
                                             cout<<"Process "<<uProcess.szExeFile<<" is using "<<work<<" bytes";
                                             Sleep(1000);                                            
                                             
                                             if(work > limit) //Si le processus utilise plus de mémoire que la limite on le termine
                                             {
         
                                                     TerminateProcess(hTemp, 0);
                                                     cout<<"\nProcess Killed\n";
                                                     goto s;
                                             }
                                             system("cls");
                                             
                                      }
        }
        
        p = Process32Next(hSnapShot, &uProcess);//On se positionne sur le processus suivant
    }while(p);

    
    s:
      system("pause");
      return 0; 
}