Foros Club Delphi - ¿Cómo terminar proceso?

Foros Club Delphi (https://www.clubdelphi.com/foros/index.php)

- C++ Builder (https://www.clubdelphi.com/foros/forumdisplay.php?f=13)

- - ¿Cómo terminar proceso? (https://www.clubdelphi.com/foros/showthread.php?t=84843)

¿Cómo terminar proceso?

Buen dia a todos,

Tengo un problemita al terminar un proceso, siempre lo hacia con taskkill de la consola CMD, pero quiero terminarlo ahora desde c++, para no depender del CMD, encontre una función en builder para terminar procesos pero no me funciona, el código es:

Código:

TerminateProcess(archivo, NULL);

Pero no puedo eliminarlo tras ejecutarlo, "archivo", recibe el nombre del archivo del proceso que quiero terminar, será que algo estoy haciendo mal?, o quizás sea que envió mal el parámetro, porque cuando veo en el administrador de tarea, veo a mi archivo así:

"archivo *32" ,

Será que como envió como parámetro el nombre a terminar, este no lo hace porque en el administrador de tareas figura con "*32"?, ya que estoy en un sistema de 64 bits.

Saludos.

La API TerminateProcess "Mata" un proceso determinado. El primer parámetro no es el nombre del archivo ejecutable sino el Handle del proceso en cuestión que previamente debes conseguir con OpenProcess.

Mira este ejemplo completamente funcional para conseguir matar un proceso conociendo el nombre de su ejecutable:

Código:

// Termina los procesos conociendo el nombre del exe

bool TerminateProcess(char* FileName)

{

   DWORD  Result  = 0;

   HANDLE Process = 0;

   PROCESSENTRY32 proc = { sizeof(proc) };

   HANDLE hSysSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);

   if(hSysSnapshot != INVALID_HANDLE_VALUE && Process32First(hSysSnapshot, &proc)){

     do{

        if(!stricmp(proc.szExeFile, FileName)){

           Result = proc.th32ProcessID;

           if(Result)

              Process = OpenProcess(PROCESS_ALL_ACCESS, false, Result);

              if(Process){

                 Result = TerminateProcess(Process, 0);

                 CloseHandle(Process);

              }   

        }

     }while(Process32Next(hSysSnapshot, &proc));

   }

   CloseHandle(hSysSnapshot);

   return (bool)Result;

}

Saludos.

Error en conversión

Hola escafandra,

probe tu código con la libreria:

Cita:

#include <Tlhelp32.h>

con el cual reconoce toda la estructura, pero me sale un error al momento de compilar:

el error que me muestra es el siguiente:

Te agradeceria que me iluminaras en esta parte, como podría se convertiria a (const char*).

Saludos.

El código lo escribí para C++Builder 6, seguramente estás usando una versión superior que usa Unicode. Cambia stricmp por _wcsicmp que es su equivalente Unicode. Ciertamente debes incluir Tlhelp32.h

Saludos.

Error en conversión

hola escafandra,

bueno, aún me sigue mostrando el casi mismo error:

si encuentro la solucion por ahí para embarcadero xe c++, lo posteo.

Saludos.

Cambia tambien esto

Código:

bool TerminateProcess(char* FileName)

Código:

bool TerminateProcessW(WCHAR* FileName)

Te pongo la versión completa Unicode:

Código:

#include <tlhelp32.h>



// Termina los procesos conociendo el nombre del exe

bool TerminateProcessW(WCHAR* FileName)

{

   DWORD  Result  = 0;

   HANDLE Process = 0;

   PROCESSENTRY32W proc = { sizeof(proc) };

   HANDLE hSysSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);

   if(hSysSnapshot != INVALID_HANDLE_VALUE && Process32FirstW(hSysSnapshot, &proc)){

     do{

        if(!_wcsicmp(proc.szExeFile, FileName)){

           Result = proc.th32ProcessID;

           if(Result)

              Process = OpenProcess(PROCESS_ALL_ACCESS, false, Result);

              if(Process){

                 Result = TerminateProcess(Process, 0);

                 CloseHandle(Process);

              }  

        }

     }while(Process32NextW(hSysSnapshot, &proc));

   }

   CloseHandle(hSysSnapshot);

   return (bool)Result;

}

Saludos.

compilado sin efecto

Hola escafandra,

me compilo correctamente el código pero no me funciona, no elimina el proceso determinado, lo llamo de esta manera:

Cita:

void __fastcall TForm1::Button1Click(TObject *Sender)
{
String proceso = "nombre";
TerminateProcessW(proceso.c_str());
}

pero al momento de ejecutarlo sigue activo el proceso.

Saludos.

Con ese código no puedes terminar con cualquier proceso sin más, Debes tener privilegios y permisos para abrir procesos de otros usuarios. Para ello puede ser necesario ejecutarlo como administrador y, además, tener privilegios "debug": SeDebugPrivilege. Por lo general, los administradores tienen privilegioSeDebugPrivilege pero puede estar anulado.

Otros procesos dererminados no pueden ser terminados ni por un administrador ya que son protegidos por el sistema desde el Kernel. Este es el caso de algunos "nombres sagrados" para windows o ciertos procesos SYSTEM o antivirus. Por último recuerda que ciertos procesos pueden estar protegidos por rootkits desde el kernel.

Piensa que proceso quieres matar y cual es tu caso particular. Si te interesa, te muestro como elevar tus privilegios y asignarte privilegio debug u otro.

Saludos.

Caramba, repetí accidentalmente la publicación anterior... :o

Saludos.

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:

Código:

#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.

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:

Código:

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:

Código:

  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.

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, :o.

Saludos.

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:

Código:

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.

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.