🚀 go-pugleaf

Hi

I'm writing a similar application where I want to kill another specific 
application from my application.

I get the processID through the enumerattion, I get the process handle, 
  I call GetExitProcessCode to get the process' exitcode but when I call 
TerminateProcess with the handle and the exitcode it always return FALSE.

Then to my surprise I see that you've hardcoded "-9" as exitcode. Is 
there something I should know here ?

Best regards
Mads M Andersen


Colin B Maharaj skrev:
> OK OK, I am seeing your cry for help.  :)
> I have some code here I did some time ago.
> I am cutting and pasting it. You know the drill
> no guarantees and remove global variables in
> production use, not efficient etc......
> 
> Sorry for the mess but I think it works.
> And be careful what you terminate!
> PS: Call The last function ......
> 
> bool AttemptTerminate(char *name);
> 
> // Name is module in memory e.g. AttemptTerminate("MyProg.exe");
> 
> 
> //---------------------------------------------------------------------
> 
> #include <psapi.h>
> 
> typedef BOOLEAN   __stdcall (*PEnumProcessModules)(HANDLE , HMODULE *, 
> DWORD ,  LPDWORD );
> PEnumProcessModules    _EnumProcessModules;
> 
> 
> typedef BOOLEAN   __stdcall (*PGetModuleBaseName)(HANDLE , HMODULE , 
> LPSTR , DWORD);
> PGetModuleBaseName    _GetModuleBaseName;
> 
> //---------------------------------------------------------------------
> 
> void GetTheProcessName(DWORD processID, char * PN)
> {
> 
>     HINSTANCE hDll=LoadLibrary("Psapi.dll");
> 
> _EnumProcessModules=(PEnumProcessModules)GetProcAddress(hDll,"EnumProcessModules"); 
> 
> 
> _GetModuleBaseName=(PGetModuleBaseName)GetProcAddress(hDll,"GetModuleBaseNameA"); 
> 
> 
>     TCHAR szProcessName[MAX_PATH];
>     HANDLE hProcess = OpenProcess( PROCESS_QUERY_INFORMATION |
>                                    PROCESS_VM_READ,
>                                    FALSE, processID );
>     if (NULL != hProcess )
>     {
>         HMODULE hMod;
>         DWORD cbNeeded;
> 
>         if ( _EnumProcessModules( hProcess, &hMod, sizeof(hMod),
>              &cbNeeded) )
>         {
>             _GetModuleBaseName( hProcess, hMod, szProcessName,
>                                sizeof(szProcessName)/sizeof(TCHAR) );
>         }
>     }
>     CloseHandle( hProcess );
>     strcpy(PN, szProcessName);
>     FreeLibrary(hDll);
> 
> }
> 
> //---------------------------------------------------------------------
> 
> int theProcessIDReturned;
> char theProcessName[256];
> 
> //---------------------------------------------------------------------
> 
> bool __stdcall EnumProc(void * hWnd, long)
> {
>    unsigned long* pPid;   //LPDWORD
>    unsigned long result;      //DWORD
>    void *hg;                  //HGLOBAL
>    unsigned long id;
>    if(hWnd==NULL) return false;
> 
>    hg = GlobalAlloc(GMEM_SHARE,sizeof(unsigned long));
>    pPid = (unsigned long *)GlobalLock(hg);
> 
>    result = GetWindowThreadProcessId(hWnd,pPid);
> 
>    if(result)
>    {
>       char title[110];
>       char ProcessName[512];
>       char className[95];
>       char totalStr[256];
>       GetClassName(hWnd,className,95);
>       GetWindowText(hWnd,title,110);
>       id=*pPid;
>       GetTheProcessName(id, ProcessName);
> 
>       itoa(id,totalStr,10);
>       strcat(totalStr,"\t");
>       if(title)
>       {
>          strcat(totalStr,title);
>          strcat(totalStr,"\t");
>       }
>       strcat(totalStr,className);
>       if (strcmp(className, "TApplication")==0)
>       {
>         if (strcmpi(ProcessName, theProcessName)==0)
>         {
>           theProcessIDReturned = id;
>         }
>       }
>    }
>    else
>    {
>       GlobalUnlock(hg);
>       GlobalFree(hg);
>       return false;
>    }
>    GlobalUnlock(hg);
>    GlobalFree(hg);
>    return true;
> }
> 
> //---------------------------------------------------------------------
> 
> int GetProcessID(char *exe)
> {
>    strcpy(theProcessName, exe);
>    long lp=0;
>    theProcessIDReturned = 0;
>    EnumWindows((WNDENUMPROC)EnumProc,lp);
>    return  theProcessIDReturned;
> }
> 
> //---------------------------------------------------------------------
> 
>  bool DoYesNo(char *mes, char *confirm)
>  {
>   int button;
>   AnsiString A;
>   //if (bDeleteConfirm == false) return false;
>   A = (AnsiString)mes;
>   button = Application->MessageBox(A.c_str(), confirm,
>            MB_YESNO +
>            MB_DEFBUTTON2 +
>            MB_ICONEXCLAMATION
>            );
>   if (button == IDYES) return true;
>   if (button == IDNO) return false;
>   return true;
>  }
> 
> //---------------------------------------------------------------------
> 
> bool AttemptTerminate(char *name)
> {
>   int pid = GetProcessID(name);
>   AnsiString A = "ProcessID of ";
>   A += name;
>   if (pid == 0)
>   {
>     A += " could not be found!\nProbably DCOM module";
>     Application->MessageBox(A.c_str(), "Process Error",
>                              MB_OK + MB_ICONSTOP + MB_DEFBUTTON1);
>     return false;
>   }
>   A += " : ";
>   A+= IntToStr(pid);
>   A += "\r\nAttempt to terminate this running process";
> 
>   bool r = DoYesNo(A.c_str(), "Attempt Termination");
>   if (r == true)
>   {
>    HANDLE ps = OpenProcess(1,false,pid);
>    if(ps)
>    {
>       if(!TerminateProcess(ps,-9))
>       {
>          Application->MessageBox("Could not end process specified!",
>                                 "Termination Error",
>                                  MB_OK + MB_ICONSTOP + MB_DEFBUTTON1);
>       }
>       else
>       {
>          Application->MessageBox("Successfully ended process specified!",
>                                 "Termination successful",
>                                  MB_OK + MB_ICONINFORMATION + 
> MB_DEFBUTTON1);
>       }
>    }
>    else
>    {
>       Application->MessageBox("Could not open process requested!",
>                              "Process Error",
>                               MB_OK + MB_ICONSTOP + MB_DEFBUTTON1);
>    }
>   }
>   return false;
> }
> 
> //---------------------------------------------------------------------
> 
> 
> 
> 
> 
>