¿Cómo terminar proceso?

[darkmir]

Hola escafandra,

si me interesaria ver como asignar mas privilegios a mi debug, quizas se eso los procesos que quiero eliminar son solo procesos de ejecutables simples que se pueden programar en cualquier lenguaje, no son archivos del sistema o de programas instalados, sino que estoy haciendo una prueba ejecutando todos mis ".exe" que he programado y con un programa terminarlos uno por uno, encontre un código que hace exactamente lo que quiero pero funciona en consola nomás, funciona tanto para builder 6 y embarcadero, pero cuando lo llevo a formularios en embarcadero , es en donde me salen esos errores de "const char....", el código es este:

#pragma hdrstop
#pragma argsused

#include <tchar.h>
#include <stdio.h>
#include <windows.h>
#include <Tlhelp32.h>

int KILL_PROC_BY_NAME ( const char *szToTerminate )
{
    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;

    // Transfer Process name into "szToTermUpper" and
    // convert it to upper case
    iLenP=strlen ( szToTerminate ) ;
    if ( iLenP<1 || iLenP>MAX_PATH )  return 632;
    for ( indx=0;indx<iLenP;indx++ )
        szToTermUpper[indx]=toupper ( szToTerminate[indx] ) ;
    szToTermUpper[iLenP]=0;

    // 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 )  ;

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

    // At Present we only support Win/NT/2000/XP or Win/9x/ME
    if (  ( osvi.dwPlatformId != VER_PLATFORM_WIN32_NT )  &&
         ( osvi.dwPlatformId != VER_PLATFORM_WIN32_WINDOWS )  )
        return 607;

     if ( osvi.dwPlatformId == VER_PLATFORM_WIN32_NT )
    {
        // Win/NT or 2000 or XP

            // Load library and get the procedures explicitly. We do
            // this so that we don't have to worry about modules using
            // this code failing to load under Windows 9x, because
            // it can't resolve references to the PSAPI.DLL.
            hInstLib = LoadLibraryA ( "PSAPI.DLL" ) ;
            if ( hInstLib  ==  NULL )
                return 605;

            // 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 700;
                }

        bResult=lpfEnumProcesses ( aiPID,iCb,&iCbneeded ) ;
        if ( !bResult )
        {
            // Unable to get process list, EnumProcesses failed
                FreeLibrary ( hInstLib ) ;
            return 701;
        }

        // How many processes are there?
        iNumProc=iCbneeded/sizeof ( DWORD ) ;

        // Get and match the name of each process
        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, now terminate it
                iFound=1;
                // First open for termination
                hProc=OpenProcess ( PROCESS_TERMINATE,FALSE,aiPID[i] ) ;
                if ( hProc )
                {
                    if ( TerminateProcess ( hProc,0 )  )
                    {
                        // process terminated
                        CloseHandle ( hProc ) ;
                                FreeLibrary ( hInstLib ) ;
                        return 0;
                    }
                    else
                    {
                        // Unable to terminate process
                        CloseHandle ( hProc ) ;
                                FreeLibrary ( hInstLib ) ;
                        return 602;
                    }
                }
                else
                {
                    // Unable to open process for termination
                        FreeLibrary ( hInstLib ) ;
                    return 604;
                }
            }
        }
    }

    if ( osvi.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS )
    {
        // Win/95 or 98 or ME

        hInstLib = LoadLibraryA ( "Kernel32.DLL" ) ;
        if (  hInstLib  ==  NULL  )
            return 702;

        // Get procedure addresses.
        // We are linking to these functions of Kernel32
        // explicitly, because otherwise a module using
        // this code would fail to load under Windows NT,
        // which does not have the Toolhelp32
        // functions in the Kernel 32.
        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 703;
        }

        // 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 704;
        }

        // 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  )
            {
                CloseHandle ( hSnapShot ) ;
                 FreeLibrary ( hInstLib ) ;
                 return 704;
            }
            // 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, now terminate it
                     iFound=1;
                     // First open for termination
                     hProc=OpenProcess ( PROCESS_TERMINATE,FALSE,procentry.th32ProcessID ) ;
                     if ( hProc )
                    {
                         if ( TerminateProcess ( hProc,0 )  )
                        {
                             // process terminated
                            CloseHandle ( hSnapShotm ) ;
                            CloseHandle ( hSnapShot ) ;
                            CloseHandle ( hProc ) ;
                                 FreeLibrary ( hInstLib ) ;
                             return 0;
                        }
                         else
                        {
                             // Unable to terminate process
                            CloseHandle ( hSnapShotm ) ;
                            CloseHandle ( hSnapShot ) ;
                            CloseHandle ( hProc ) ;
                                 FreeLibrary ( hInstLib ) ;
                             return 602;
                        }
                    }
                     else
                    {
                         // Unable to open process for termination
                        CloseHandle ( hSnapShotm ) ;
                        CloseHandle ( hSnapShot ) ;
                            FreeLibrary ( hInstLib ) ;
                         return 604;
                    }
                }
                else
                {// Look for next modules for this process
                    modentry.dwSize=sizeof ( MODULEENTRY32 ) ;
                    bResultm=lpfModule32Next ( hSnapShotm,&modentry ) ;
                }
            }

            //Keep looking
            CloseHandle ( hSnapShotm ) ;
                procentry.dwSize = sizeof ( PROCESSENTRY32 ) ;
                bResult = lpfProcess32Next ( hSnapShot,&procentry ) ;
        }
        CloseHandle ( hSnapShot ) ;
    }
    if ( iFound == 0 )
    {
        FreeLibrary ( hInstLib ) ;
        return 603;
    }
    FreeLibrary ( hInstLib ) ;
    return 0;
}



int _tmain()
{
   KILL_PROC_BY_NAME ("RGRG.exe");
return 0;
}

el mismo problema con el código anterior, a pesar que me funciona bien en la consola del embarcadero, que es donde trabajo, el problema es cuando lo mirgro a formularios....pondria el link pero no me permiten poner enlaces, pero en teoria es está: portalhacker.net + /index.php?topic=105302.0

Saludos.

[[escafandra]]

El código debería funcionar independientemente de si se ejecuta en una consola o en GUI.

Esta es la forma de asignar privilegios al proceso actual:

BOOL EnablePrivilege (PCSTR name, BOOL Enable = TRUE)
{
   BOOL Result;
   HANDLE hToken;
   TOKEN_PRIVILEGES priv = {1, {0, 0, SE_PRIVILEGE_ENABLED}};
   if(!Enable) priv.Privileges[0].Attributes = 0;
   LookupPrivilegeValue(0, name, &priv.Privileges[0].Luid);
   OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES, &hToken);
   AdjustTokenPrivileges (hToken, FALSE, &priv, sizeof priv, 0, 0);
   Result = (GetLastError() == ERROR_SUCCESS);
   CloseHandle (hToken);

   return Result;
}

El uso para matar procesos sería el siguiente:

  EnablePrivilege("SeDebugPrivilege", TRUE);   // Nos asignamos privilegios debug
  TerminateProcessW(L"cmd.exe");  //Matamos la consola, por ejemplo
  EnablePrivilege("SeDebugPrivilege", FALSE);  // Nos quitamos el privilegio, si queremos...

Si ejecutas como administrador debería ser capaz de matar "casi" cualquier proceso.



Saludos.

[darkmir]

Hola escafandra,

Gracias por el código de privilegios, tambien em funciono, como mencionaste, sobre " El código debería funcionar independientemente de si se ejecuta en una consola o en GUI", me parecio raro, así que decidí indagar por ahí, ya que a simple vista algo estaba mal, y no encontraba la solución a "porque funciona en consola y no en GUI", así que compare ambos proyectos, tanto el de consola como el de GUI, buscando opciones , librerias, etc.

y encontre una pequeña diferencia pero obvia quizas para algunos, novedosa para mi como principiante.

Cuando creas un proyecto en consola (embarcadero XE) por defecto te se crea con "char" en Project->Options-> _TCHAR maps to = "char".

pero cuando creas un proyecto en GUI, por defecto se crea así: Project->Options-> _TCHAR maps to = "wchar_t".

solo cambie el "wchar_t" por "char" y listo todos los códigos que mencionaste anteriormente funcionan sin problemas, sin necesidad de cambiarlos como en el UNICODE, te corre normal, ahora buscando un poco mas sobre eso, encontre sobre los standares del C++, siendo el último el C++11, donde cambia por el standard anterior por el nuevo (hasta donde entendí , quizas me equivoque), y el cual es el que trabaja por defecto el embarcadero XE, bueno les dejo el link para que indague mas el que desee:

no se me permiten link pero esta en wikipedia, solo pongan C++11.

Gracias por los códigos escafandra, si funcionaban, sino que el error era mío, ahora si recien podre cerrar los ojos, .

Saludos.

[[escafandra]]

No deberías cambiar la opción por defecto de usar wchar_t (WCHAR) en GUI pues es la tendencia de todos los compiladores y del mismo Windows. Lo correcto es saber cuando usas UNICODE (WCHAR) y cuando no y controlar ese aspecto para no tener más dolores de cabeza con este tema.

Revisa esto para comprender las formas de conversión y recuerda asignar a un String de esta forma:

String Texto = TEXT("mi texto");

El tema del UNICODE y la coexistencia con las cadenas clásicas char[] es un verdadero quebradero de cabeza para compatibilizar código antiguo y moderno. Cuando tengas problemas usa el debugger, viendo el contenido real de las cadenas verás donde tienes el fallo.


Saludos.

[darkmir]

Hola escafandra,

Ok, lo tendre en cuenta, si ahora que lo mencionas, es la tendencia, y es mejor saber cuando utilizar las conversiones, ya que por lo que veo, actualmente la tendencia es a "wchar_t".

Saludos.