openprocess3.cpp

linux下的终端管理工具源码

// OpenProcess2.cpp : Defines the entry point for the application.
//

#include <windows.h>
#include <stdio.h>
#include <tlhelp32.h>

static char * commandLine;
static char processName[500]={"notepad.exe"};

static DWORD arrayOfProcesses[20]={0};

bool processIsToKill(int , char **);
void killProcesses(DWORD *);

// PSAPI Function Pointers.
   BOOL  (WINAPI *lpfEnumProcesses)( DWORD *, DWORD cb, DWORD * );
   BOOL  (WINAPI *lpfEnumProcessModules)( HANDLE, HMODULE *,DWORD, LPDWORD );
   DWORD (WINAPI *lpfGetModuleBaseName)( HANDLE, HMODULE,LPTSTR, DWORD );


// ToolHelp Function Pointers.
   HANDLE (WINAPI *lpfCreateToolhelp32Snapshot)(DWORD,DWORD);
   BOOL   (WINAPI *lpfProcess32First)(HANDLE,LPPROCESSENTRY32);
   BOOL   (WINAPI *lpfProcess32Next)(HANDLE,LPPROCESSENTRY32);
   BOOL   (WINAPI *lpfModule32First)(HANDLE,LPMODULEENTRY32);
   BOOL   (WINAPI *lpfModule32Next)(HANDLE,LPMODULEENTRY32);


// The entry point returns the follow codes:
// 0 process not running.
// 101 process running
// 102 process was running and not succesly terminated
// 103 process was running and succesly terminated
// 104 generic error

bool processIsToKill(char * cmdl)
{
   bool ret = false;
   
   char seps[]=" ";
   
   char *  token = strtok(cmdl, seps );

   while( token != NULL)
   {
    if(strcmp("kill",token) == 0) 
    {
      ret = true;
      break;
    }

    strcpy(processName , token);
    token = strtok( NULL, seps );
   }
   return ret;
}

int APIENTRY WinMain(HINSTANCE hInstance,
                     HINSTANCE hPrevInstance,
                     LPSTR     lpCmdLine,
                     int       nCmdShow)


{
	 int result = 0;
   
   commandLine = (char *) GetCommandLine();
   
   bool processToKill = processIsToKill(commandLine);
   
   BOOL bResult,bResultm;
	 DWORD aiPID[1000],iCb=1000,iNumProc,iV2000=0;
	 DWORD iCbneeded,i,iFound=0;
	 
   char szName[MAX_PATH],
        szToTermUpper[MAX_PATH];
	 
   HANDLE hProc,
          hSnapShot,
          hSnapShotm;
	 
   OSVERSIONINFO osvi;
   HINSTANCE hInstLib;
	 
   int iLen,
       iLenP,
       indx;
   
   HMODULE hMod;
	 PROCESSENTRY32 procentry;      
	 MODULEENTRY32  modentry;
	 
   int Cntr=0;

	 iLenP=strlen(processName);
	 
   if(iLenP<1 || iLenP>MAX_PATH) return 104;
	 
   for(indx=0;indx<iLenP;indx++)
		szToTermUpper[indx]=toupper(processName[indx]);
	 szToTermUpper[iLenP]=0;

   //First check what version of Windows we're in
	 osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
     bResult=GetVersionEx(&osvi);
	 if(!bResult)     // Unable to identify system version
	    return 104;

 	 //At Present we only support Win/NT/2000 or Win/9x
	 if((osvi.dwPlatformId != VER_PLATFORM_WIN32_NT) &&
		 (osvi.dwPlatformId != VER_PLATFORM_WIN32_WINDOWS)) return 104;
   
   if(osvi.dwPlatformId==VER_PLATFORM_WIN32_NT)
   {
     hInstLib = LoadLibraryA("PSAPI.DLL");
  
     if(hInstLib == NULL) return 104;

     // Get procedure addresses.
     lpfEnumProcesses = (BOOL(WINAPI *)(DWORD *,DWORD,DWORD*)) GetProcAddress( hInstLib, "EnumProcesses");
     lpfEnumProcessModules = (BOOL(WINAPI *)(HANDLE, HMODULE *,DWORD, LPDWORD)) GetProcAddress( hInstLib,"EnumProcessModules");
     lpfGetModuleBaseName =(DWORD (WINAPI *)(HANDLE, HMODULE,LPTSTR, DWORD )) GetProcAddress( hInstLib,"GetModuleBaseNameA");

     if( lpfEnumProcesses == NULL ||
         lpfEnumProcessModules == NULL ||
         lpfGetModuleBaseName == NULL)
         {
           FreeLibrary(hInstLib);
           return 104;
         }

      
		 bResult=lpfEnumProcesses(aiPID,iCb,&iCbneeded);
		 if(!bResult)
     {
			 FreeLibrary(hInstLib);
			 return 104;
     }
    
    // How many processes are there?
		iNumProc=iCbneeded/sizeof(DWORD);

		// Get and match the name of each process
		Cntr=0;
		for(i=0;i<iNumProc;i++)
		{
			// Get the (module) name for this process
      strcpy(szName,"Unknown");
			
      // First, get a handle to the process
	    hProc=OpenProcess(PROCESS_QUERY_INFORMATION|PROCESS_VM_READ,FALSE,aiPID[i]);
	    
      // Now, get the process name
	    if(hProc)
			{
         if(lpfEnumProcessModules(hProc,&hMod,sizeof(hMod),&iCbneeded) )
			   {
           iLen=lpfGetModuleBaseName(hProc,hMod,szName,MAX_PATH);
			   }
			}
	    CloseHandle(hProc);
			

			if(strcmp(_strupr(szName),szToTermUpper)==0)
			{
				// Process found.
				arrayOfProcesses[iFound] = aiPID[i];
        iFound++;
			}
		}
   }
   //here
  if(osvi.dwPlatformId==VER_PLATFORM_WIN32_WINDOWS)
	{
		// Win/95 or 98 or ME
			
		hInstLib = LoadLibraryA("Kernel32.DLL");
		if( hInstLib == NULL )
			return 104;

		lpfCreateToolhelp32Snapshot=(HANDLE(WINAPI *)(DWORD,DWORD)) GetProcAddress( hInstLib,"CreateToolhelp32Snapshot" ) ;
		lpfProcess32First=(BOOL(WINAPI *)(HANDLE,LPPROCESSENTRY32))GetProcAddress( hInstLib, "Process32First" ) ;
		lpfProcess32Next=(BOOL(WINAPI *)(HANDLE,LPPROCESSENTRY32))GetProcAddress( hInstLib, "Process32Next" ) ;
		lpfModule32First=(BOOL(WINAPI *)(HANDLE,LPMODULEENTRY32))GetProcAddress( hInstLib, "Module32First" ) ;
		lpfModule32Next=(BOOL(WINAPI *)(HANDLE,LPMODULEENTRY32))GetProcAddress( hInstLib, "Module32Next" ) ;
		
    if( lpfProcess32Next == NULL ||
			  lpfProcess32First == NULL ||
		    lpfModule32Next == NULL ||
			  lpfModule32First == NULL ||
			  lpfCreateToolhelp32Snapshot == NULL )
		{
			FreeLibrary(hInstLib);
			return 104;
		}
			
		// The Process32.. and Module32.. routines return names in all uppercase

		// Get a handle to a Toolhelp snapshot of all the systems processes.

		hSnapShot = lpfCreateToolhelp32Snapshot(
			TH32CS_SNAPPROCESS, 0 ) ;
		if( hSnapShot == INVALID_HANDLE_VALUE )
		{
			FreeLibrary(hInstLib);
			return 104;
		}
		
        // Get the first process' information.
        procentry.dwSize = sizeof(PROCESSENTRY32);
        bResult=lpfProcess32First(hSnapShot,&procentry);

        // While there are processes, keep looping and checking.
        while(bResult)
        {
		    // Get a handle to a Toolhelp snapshot of this process.
		    hSnapShotm = lpfCreateToolhelp32Snapshot(
			    TH32CS_SNAPMODULE, procentry.th32ProcessID) ;
		    if( hSnapShotm == INVALID_HANDLE_VALUE )
			{
			    FreeLibrary(hInstLib);
			    return 104;
			}
			// Get the module list for this process
			modentry.dwSize=sizeof(MODULEENTRY32);
			bResultm=lpfModule32First(hSnapShotm,&modentry);

			// While there are modules, keep looping and checking
			while(bResultm)
			{
		    if(strcmp(modentry.szModule,szToTermUpper)==0)
				{
				  // Process found.
					arrayOfProcesses[iFound] = procentry.th32ProcessID;
          iFound++;				
        }
				
        modentry.dwSize=sizeof(MODULEENTRY32);
				bResultm=lpfModule32Next(hSnapShotm,&modentry);
      }

		  	//Keep looking
        procentry.dwSize = sizeof(PROCESSENTRY32);
        bResult = lpfProcess32Next(hSnapShot,&procentry);
     }
	}
	
  
  if(iFound > 0 )
  {
    if(processToKill)
    {
      killProcesses(arrayOfProcesses);
      result = 0;
    }
    else
      result = 101;
  }
  else
    result = 0;
  
  
  FreeLibrary(hInstLib);
  
  if(osvi.dwPlatformId==VER_PLATFORM_WIN32_WINDOWS)
  {
    //free the handles.
    CloseHandle(hSnapShot);
    CloseHandle(hSnapShotm);
  }

  return result;
}


void killProcesses(DWORD *arrayP)
{
   for(int i=0;i<20;i++)
   {
     if(arrayP[i] != 0)
     {
       HANDLE hProc=OpenProcess(PROCESS_TERMINATE,FALSE,arrayP[i]);
       if(hProc)
       {
        TerminateProcess(hProc,0);
        CloseHandle(hProc);
       }
     }
   }
}