Ver Mensaje Individual
  #10  
Antiguo 15-12-2013
darkmir darkmir is offline
Miembro
NULL
 
Registrado: abr 2013
Posts: 28
Reputación: 0
darkmir Va por buen camino
Procesos

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.
Responder Con Cita