4. frage zu..doppeltes öffnen eines programmes vermeiden aus faq

frage zu..doppeltes öffnen eines programmes vermeiden aus faq

  • S

    Wenn Du doch eh nur deine eigenen Programme starten willst mit ShellExecute, was hindert Dich denn daran, in jedem Programm einen eindeutig bezeichneten MUTEX zu kreieren?

    **was is wenn ich aus meinem programm prüfen will ob icq.exe schon gestartet ist? so ist das bei mir das fall!! wenn nein dann soll icq.exe gestartet werde....so mein ich das.....
    **

    cu

    0
  • F

    Sag doch gleich, was du suchst 🙄
    Wenn du schauen willst, ob eine fremde Anwendung bereits läuft musst du entweder die laufenden Prozesse durchgehen oder nach dem Fenster der Anwendung suchen, falls du die Fensterklasse, oder den Titel weißt

    0
  • S

    sorry hab ich mich vielleicht falsch ausgedürckt;-(

    ich will einfach schaun ober eine fremdanwendung läuft...zb.: icq.exe fensternahme usw kenn ich nicht!! nur den namen der exe datei...
    wie geht man das an? hab e schon vorher gemeint...alle prozess instanzen durchsteppen oder so...

    cu

    0
  • H
     

    // Diese Funktion funktioniert in dieser Form
// nur unter WindowsNT 4.0, Windows2000 und WindowsXP!

#include <Psapi.h>
#pragma comment(lib, "psapi.lib") //nur für Visual Studio! Bei anderem Compiler
// auskommentieren und die LIB manuell dem Linker mitteilen...

void GetPathFromHandle(HWND hWnd, LPTSTR szPathFromHandle)
{
	DWORD lpdwProcessId; 
	HANDLE hProcessHandle;
	GetWindowThreadProcessId(hWnd, &lpdwProcessId);	
	hProcessHandle = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, TRUE, lpdwProcessId);
	GetModuleFileNameEx(hProcessHandle, NULL, szPathFromHandle, MAX_PATH);
	CloseHandle(hProcessHandle);
}

    Mit EnumWindows alle Fenster abklappern, in der EnumWindowsProc rufst Du dann obige Funktion auf

    GetPathFromHandle(hWnd, szPath);

    Dann vergleichst Du szPath eben mit "C:\\Programme\\ICQ\\Icq.exe" und wenn ICQ nicht läuft startest Du es eben....

    0
  • F

    oder mit Process32First & Co. 🙂

    0
  • S

    ich hab da was gefunden:

    http://msdn.microsoft.com/library/en-us/perfmon/base/taking_a_snapshot_and_viewing_processes.asp?frame=true

    http://msdn.microsoft.com/library/default.asp?url=/library/en-us/perfmon/base/process_walking.asp

    versteh nicht was da abgeht...so viel code für das?

    cu

    0
  • H

    Na hörmal, du pfuscht da ja schließlich auch unter der Motorhaube rum, sowas braucht schonmal ein paar mehr Zeilen Code....

    Es gibt nunmal keine

    StarteIcqWennEsNochNichtLäuft();

    Funktion... aber Du kannst uns ja eine schreiben.... 😉

    0
  • S

    ja!!
    ich will einfach C:\Programm.exe eingeben...dann soll er schaun ob der process schon läuft...kannst ja mir bissi helfen..;-)

    ich versteh da mit der msdn nicht so viel...erklärungen sind auch keine dabei;-(

    was machen die da mit....Process32First
    hat jemand da eine example vielleicht wo man das besser sieht???
    wär fein...

    cu

    0
  • S
     

    //  test the routine KILL_PROC_BY_NAME to terminate a process

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

#ifdef BORLANDC
  #include <string.h>
  #include <ctype.h>
#endif

int KILL_PROC_BY_NAME(const char *);

int main(int argc,char *argv[])
{
//  Terminate a running process
    char szName[100]="notepad.exe";   // Name of process to terminate
	int iRes;

	iRes=KILL_PROC_BY_NAME(szName);

	cout << "Result code=" << iRes << endl;
	return 0;
}

int KILL_PROC_BY_NAME(const char *szToTerminate)
// Created: 6/23/2000  (RK)
// Last modified: 3/10/2002  (RK)
// Please report any problems or bugs to kochhar@physiology.wisc.edu
// The latest version of this routine can be found at:
//     http://www.neurophys.wisc.edu/ravi/software/killproc/
// Terminate the process "szToTerminate" if it is currently running
// This works for Win/95/98/ME and also Win/NT/2000/XP
// The process name is case-insensitive, i.e. "notepad.exe" and "NOTEPAD.EXE"
// will both work (for szToTerminate)
// Return codes are as follows:
//   0   = Process was successfully terminated
//   603 = Process was not currently running
//   604 = No permission to terminate process
//   605 = Unable to load PSAPI.DLL
//   602 = Unable to terminate process for some other reason
//   606 = Unable to identify system type
//   607 = Unsupported OS
//   632 = Invalid process name
//   700 = Unable to get procedure address from PSAPI.DLL
//   701 = Unable to get process list, EnumProcesses failed
//   702 = Unable to load KERNEL32.DLL
//   703 = Unable to get procedure address from KERNEL32.DLL
//   704 = CreateToolhelp32Snapshot failed
// Change history:
//   modified 3/8/2002  - Borland-C compatible if BORLANDC is defined as
//                        suggested by Bob Christensen
//   modified 3/10/2002 - Removed memory leaks as suggested by
//					      Jonathan Richard-Brochu (handles to Proc and Snapshot
//                        were not getting closed properly in some cases)
{
	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);
			// We will match regardless of lower or upper case
#ifdef BORLANDC
            if(strcmp(strupr(szName),szToTermUpper)==0)
#else
			if(strcmp(_strupr(szName),szToTermUpper)==0)
#endif
			{
				// 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;
}

    jetzt muss ich halt das mittn terminate raus tun??? was meinst du soll ich das auf meine vorstellungen anpassen, so viel is ja net zu ändern??

    cu surf.

    0
  • F

    Also ich weiß nicht, ob das nicht auch einfacher geht - bei mir klappt das nämlich mit FindWindow wunderbar:

    if(FindWindow(NULL,"123456789") == NULL) MessageBox(NULL,"ICQ is not running","",0);

    Für 123456789 musst du eben noch deine ICQ-Nummer eintragen! Teste mal, ob das so bei dir nicht auch klappt 😉
    Ansonsten kannst du ja mal mit Winspector ein wenig rumschnüffeln 🤡

    0
  • S

    das sollte ja nicht nur für icq gehn*gg*

    ich will ja auch schaun ob zb.: microsoft messanger.exe gestartet wurde...da werd ich lieber den code umbauen da obn oder was meinst??

    cu

    0
  • S
     

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

#ifdef __BORLANDC__
  #include <string.h> 
  #include <ctype.h> 
#endif 

int Process_Search(const char *Proc_Search); 

int main(int argc,char *argv[]) 
{ 
//  Looking for a running process 
    char szName[100]="icq.exe";   // Name of process to terminate 
    int iRes; 

    iRes=Process_Search(szName); 

    cout << "Result code=" << iRes << endl; 
    return 0; 
} 

int Process_Search(const char *Proc_Search) 
// Return codes are as follows: 
//   0   = Process is currently running
//   603 = Process is not currently running 
//   605 = Unable to load PSAPI.DLL 
//   606 = Unable to identify system type 
//   607 = Unsupported OS 
//   632 = Invalid process name 
//   700 = Unable to get procedure address from PSAPI.DLL 
//   701 = Unable to get process list, EnumProcesses failed 
//   702 = Unable to load KERNEL32.DLL 
//   703 = Unable to get procedure address from KERNEL32.DLL 
//   704 = CreateToolhelp32Snapshot failed 

{ 
    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(Proc_Search); 
    if(iLenP<1 || iLenP>MAX_PATH) return 632; 
    for(indx=0;indx<iLenP;indx++) 
        szToTermUpper[indx]=toupper(Proc_Search[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); 
            // We will match regardless of lower or upper case 
#ifdef __BORLANDC__
            if(strcmp(strupr(szName),szToTermUpper)==0) 
#else 
            if(strcmp(_strupr(szName),szToTermUpper)==0) 
#endif 
            { 
                // Process found, now terminate it 
                iFound=1; 
                return 0;

            } 
        } 
    } 

    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; 
                    return 0;

                } 

            } 

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

    ich hab den code mal optimiert...was meint ihr??? schaut nicht so schlecht aus???

    mfg surf.

    0
  • ?
     

    //Test the routine FIND_PROC_BY_NAME to find a running process

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

int FIND_PROC_BY_NAME(const char *);

int main(int argc, char *argv[])
{
    //Check whether a process is currently running, or not
    char szName[100]="icq.exe";   // Name of process to find
    int iRes;
    AnsiString Result;

    iRes=FIND_PROC_BY_NAME(szName);

    //Convert Integer into Ansistring....Borland C++ Builder needed
    Result = IntToStr (iRes);

    if(iRes==0)
    {
      MessageBox(NULL, Prozess not found! Returnvalue:Res.c_str(), "Info", MB_OK | MB_ICONINFORMATION);
    }
    else if(iRes==1)
    {
      MessageBox(NULL, Prozess found! Returnvalue:Res.c_str(), "Info", MB_OK | MB_ICONINFORMATION);
    }

    return 0;
}

int FIND_PROC_BY_NAME(const char *szToFind)
// Check whether the process "szToFind" is currently running in memory
// This works for Win/95/98/ME and also Win/NT/2000/XP
// The process name is case-insensitive, i.e. "notepad.exe" and "NOTEPAD.EXE"
// will both work (for szToFind)
// Return codes are as follows:
//   0   = Process was not found
//   1   = Process was found
//   605 = Unable to search for process
//   606 = Unable to identify system type
//   607 = Unsupported OS
//   632 = Process name is invalid
{
	BOOL bResult,bResultm;
	DWORD aiPID[1000],iCb=1000,iNumProc,iV2000=0;
	DWORD iCbneeded,i;
	char szName[MAX_PATH],szToFindUpper[MAX_PATH];
	HANDLE hProc,hSnapShot,hSnapShotm;
	OSVERSIONINFO osvi;
    HINSTANCE hInstLib;
	int iLen,iLenP,indx;
    HMODULE hMod;
	PROCESSENTRY32 procentry;      
	MODULEENTRY32 modentry;

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

	// Transfer Process name into "szToFindUpper" and
	// convert it to upper case
	iLenP=strlen(szToFind);
	if(iLenP<1 || iLenP>MAX_PATH) return 632;
	for(indx=0;indx<iLenP;indx++)
		szToFindUpper[indx]=toupper(szToFind[indx]);
	szToFindUpper[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 606;

	// At Present we only support Win/NT/2000 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 95, 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 605;
            }

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

		// 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);
			// Match regardless of lower or upper case
			if(strcmp(_strupr(szName),szToFindUpper)==0)
			{
				// Process found
				FreeLibrary(hInstLib);
				return 1;
			}
		}
	}

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

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

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

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

        // 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 605;
			}
			// 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,szToFindUpper)==0)
				{
					// Process found
					CloseHandle(hSnapShotm);
					CloseHandle(hSnapShot);
					FreeLibrary(hInstLib);
					return 1;
				}
				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);
	}
	FreeLibrary(hInstLib);
	return 0;
}

    ich würd mal sagn das soll in die faq *fg*

    cu surf;-)

    0
  • H

    surfman. schrieb:

    if(iRes==0) 
{ 
  MessageBox(NULL, Prozess not found! Returnvalue:Res.c_str(), "Info", MB_OK | MB_ICONINFORMATION); 
} 
else if(iRes==1) 
{ 
  MessageBox(NULL, Prozess found! Returnvalue:Res.c_str(), "Info", MB_OK | MB_ICONINFORMATION); 
}

    Ich würde sagen das darf auf keinen Fall in die FAQ, es läuft ja nicht mal durch nen Compiler, ohne das der (zu Recht) Fehler ausgibt...

    Außerdem ist es für das simple Auffinden von laufenden Programmen ein mordsmäßiger Overhead, mit 'nem Viertel der Codezeilen geht es auch, Funktionen hast Du genug genannt bekommen hier im Thread...

    0
  • ?

    hi!! ich werds heute noch für visual c++ optimieren!!

    mfg surf.

    0
  • F

    surf. schrieb:

    ich werds heute noch für visual c++ optimieren!!

    Das hat überhaupt nichts mit Optimierung für einen speziellen Compiler zu tun! Der Auszug, den Hepi zitiert hat ist schlichtweg falsch und wird von deinem Compiler mit Sicherheit auch nicht akzeptiert 👎
    So langsam habe ich irgendwei das Gefühl, du willst uns hier nur veralbern 😞 (um mich noch einigermaßen gepflegt auszudrücken 😉 )

    0
  • H

    surf. schrieb:

    hi!! ich werds heute noch für visual c++ optimieren!!

    mfg surf.

    Wenn ich mir deine Quelltexte hier so ansehe, dann zucke ich irgendwie zusammen, wenn ich auch nur dran denke, das Du nun auch noch etwas für einen bestimmten Compiler "optimieren" willst...

    Geh mal folgende Schritte systematisch durch:

    1.) C bzw. C++ richtig lernen. Ich sehe da gravierende Grundlagenmängel!
    2.) Kauf Dir "Windows Programmierung, 5. Auflage" von Charles Petzold
    3.) Lies es durch!
    4.) Schreibe erste, kleine Programme mit der WinAPI.
    5.) Kauf Dir "Microsoft Windows Programmierung für Experten" von Jeffrey Richter
    6.) Lies es ebenfalls durch, schlag zur Not im Petzold nach, falls Dir Grundlagen entfallen sind...
    7.) Sieh Dir deinen obigen Quelltext an, vielleicht kannst Du mittlerweile auch drüber lachen...

    0
Anmelden zum Antworten