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

[marcell]

int WINAPI WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,PSTR szCmdLine,int iShowCmd)
{
	hMutex = CreateMutex(0,true,TEXT("BinaryStudiosToolBruni"));

	if(GetLastError() == ERROR_ALREADY_EXISTS) {
		SetLastError(0);
		MessageBox(0,TEXT("Mei, Bruno, des Programm is doch schon offen !\nAlso echt ;)"),TEXT("Bruni!"),MB_ICONINFORMATION|MB_OK);
		CloseHandle(hMutex);
		return 0;
	}
}

//HANDLE hMutex sollte global sein

case WM_DESTROY:{
	ReleaseMutex(hMutex);
	CloseHandle(hMutex);
	PostQuitMessage(0);
	return 0;
}

[flenders]

@marcell: Du kontrollierst den Rückgabewert jetzt gar nicht mehr!

Hast du schonmal ausprobiert, ob es funktioniert, wenn du (wie -King- im FAQ-Beitrag vorschlug) den 2. Parameter auf FALSE setzt?

Kann es sein, dass bei ShellExecute irgend etwas an den neuen Prozess vererbt wird und es damit zusammenhängt
Hast du die Anwendung mal manuell ein 2. Mal gestartet, oder immer nur mit ShellExecute?

Gewöhne dir außerdem mal an, deine Fehler (bzw. das Nicht-Funktionieren) etwas genauer zu beschreiben und dir vor allem erstmal die Threads etwas genauer durchzulesen! Nicht wir suchen Hilfe, sondern DU! :p

btw: ich hab den Fehler im Code aus den FAQ-Beitrag jetzt auch mal korrigiert

[Hepi]

surf. schrieb:

ich probiere die gepostetem code aus

Glaub ich Dir nicht.

Ich rede nicht von fremden Code, sondern von Deinem!

Ständig postest Du hier Code und fragst gleichzeitig:
"...könnte sowas gehen?" oder "...funktioniert sowas?"

Probier's doch selber aus, ob "sowas geht" bzw. ob "sowas funktioniert"!

surf. schrieb:

freund

...bin ich nicht.

[Surfman]

Hast du schonmal ausprobiert, ob es funktioniert, wenn du (wie -King- im FAQ-Beitrag vorschlug) den 2. Parameter auf FALSE setzt? ^

ja hab ich grad probiert...den gleichen code wie king ausgebesserte version!!

Kann es sein, dass bei ShellExecute irgend etwas an den neuen Prozess vererbt wird und es damit zusammenhängt
Hast du die Anwendung mal manuell ein 2. Mal gestartet, oder immer nur mit ShellExecute?

ja habs manuell und automatisch mit shellexecute gestartet....leider war das nit der fehler;-(

cu

[Surfman]

__fastcall TKeyForm::TKeyForm(TComponent* Owner)
   : TForm(Owner), Zeilen(0), umschalt(false), altgr(false)
{
  //Überprüfen welche exe Datei gestartet wurde
   GetModuleFileName(NULL,buf,1000);
   FileName = strrchr(buf,'\\');
   FileName++;
   s=FileName;

   int vergleich = s.compare("mp3.exe");

   if(vergleich==0)
   {
    //doppeltes öffnen eines Programmes vermeiden
    HANDLE mHandle;

    mHandle=CreateMutex(NULL,true,"Prog.exe");
    if (mHandle!=NULL)
    {
       if (GetLastError()==ERROR_ALREADY_EXISTS)
       {
          MessageBox(NULL, "is gestartet", "Info", MB_OK | MB_ICONINFORMATION);
          // Anwendung bereits einmal gestartet
          CloseHandle(mHandle);
          exit (0);
       }
    }

    //Programm Prog.exe starten
    ShellExecute(0, "open", "C:\\Prog.exe", 0, 0, SW_HIDE);

    //exe beenden
    exit (0);
   }
}

[Hepi]

Damit wir uns richtig verstehen:

HANDLE mHandle;
mHandle=CreateMutex(NULL,true,"Prog.exe");
if (mHandle!=NULL)
{
   if (GetLastError()==ERROR_ALREADY_EXISTS)
   {
      MessageBox(NULL, "is gestartet", "Info", MB_OK | MB_ICONINFORMATION);
      // Anwendung bereits einmal gestartet
      CloseHandle(mHandle);
      exit (0);
   }
}

erstellt einen MUTEX.
Ein MUTEX kann nur einmal mit gleichem Namen im System existieren.
Normalerweise verwendet man einen MUTEX, um zu testen, ob das EIGENE Programm schon läuft.

Beispiel:
Ich starte mein Programm TEST.EXE
Dieses TEST.EXE erstellt einen MUTEX.
Versuche ich nun, genau die selbe TEST.EXE nochmal zu starten, geht das nicht, weil ja der MUTEX bereits existiert...

Was passiert denn, wenn Du dein Programm (dessen Quelltext-Ausschnitt Du hier gerade gepostet hast) versuchst ein zweites Mal zu starten?

[Surfman]

Beispiel:
Ich starte mein Programm TEST.EXE
Dieses TEST.EXE erstellt einen MUTEX.
Versuche ich nun, genau die selbe TEST.EXE nochmal zu starten, geht das nicht, weil ja der MUTEX bereits existiert...
[/b]ja...aber wie macht man das wenn man wissen will ob eine andere exe datei schon gestartet ist??? **hab gehört das man alle prozessinstanzen durchsteppen muss!?

Was passiert denn, wenn Du dein Programm (dessen Quelltext-Ausschnitt Du hier gerade gepostet hast) versuchst ein zweites Mal zu starten?**dann wird das Prog.exe noch mal gestartet....dann sehe ich im taskmanager 2 mal Proxy.exe[b]

cu

[Hepi]

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?

[Surfman]

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

[flenders]

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

[Surfman]

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

[Hepi]

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

[flenders]

oder mit Process32First & Co.

[Surfman]

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

[Hepi]

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

[Surfman]

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

[Surfman]

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

[flenders]

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

[Surfman]

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

[Surfman]

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