Ich wollte eigentlich eine kleine DLL schreiben oder ein kleines Programm (wohl eher ne DLL ^^ ) die mir von der aktuellen *.exe diverse Informationen ausgibt. Im folgenden ist ein Textauszug, wie er mir die Informationen vom Pfad, der Größe, der Version und dem Zeitpunkt wieder gibt.

Hier hätte ich mal meine 1. kleinere Frage. Ist das die aktuelle Zeit im System oder wwirklich die Zeit als die *.exe erstellt wurde. Weil bis jetzt macht er mir ja immer beim Kompilieren eine neue Infobox.exe.

Recht schönen Dank wer sich damit kurz befassen könnte.

Das eigentliche Problem.

Ihr kennt ja vielleicht den Prozess-Explorer. Dieser zeigt ja an welche DLL's die Anwendung gerade alles benutzt. Das wollte ich auch gern haben und diese wieder geben. Allerdings bin ich im Netz nur auf LoadLibrary gekommen und das ist nicht dynamisch, da ich das ja bei verschiedenen *.exe Dateien nutzen will.

Ich wäre wirklich sehr dankbar, wenn mir jemand da einen Ansatz nennen könnte oder gar ein paar Code Fragmente übermitteln könnte. Ich danke jetzt schon mal für die Mühe sich das überhaupt durch gelesen zu haben.
Über Antworten wäre ich natürlich dankbarer

#include <afx.h>
#include <windows.h>
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <string>

#define BUFSIZE 8192

int main(int argc, char* argv[])
{

//////////////////////////////////////////////////////////////////////////////////
//	LPTSTR lpszSystemInfo;		// Pointer auf den System Informations String   //
//	DWORD cchBuff = BUFSIZE;	// Größe für den Namen                          //
//	TCHAR tchBuffer[BUFSIZE];	// Buffer für den String                        //
//	DWORD fehler;                                                               //
//	CString	csFileVersion;                                                      //
//	CString csFileTime;                                                         //
//	CString csFileSize;                                                         //
//	lpszSystemInfo = tchBuffer;                                                 //
//                                                                              //
//                                                                              //
// erstellt Nutzernamen und Computernamen                                       //
//                                                                              //
//	if( GetComputerName(lpszSystemInfo, &cchBuff) )                             //
//	printf("Computer Name: %s\n ", lpszSystemInfo);                             //
//                                                                              //
//	cchBuff = BUFSIZE;                                                          //
//                                                                              //
//		if( GetUserName(lpszSystemInfo, &cchBuff) )                             //
//		printf("User name: %s\n ", lpszSystemInfo);                             //
//		else                                                                    //
//		{                                                                       //
//			fehler = GetLastError();                                            //
//			printf("Fehler : %d\n",fehler);                                     //
//		}                                                                       //
//////////////////////////////////////////////////////////////////////////////////

			CString	csFileVersion;                                                      
			CString csFileTime;                                                         
			CString csFileSize; 

			//////////////////////////////////////////////////////////////////////
			//------------------------------------------------------------------//
			// Get file name                                                    //
			//------------------------------------------------------------------//
			//////////////////////////////////////////////////////////////////////

			char appPath[MAX_PATH];    
			::GetModuleFileName(NULL, appPath, MAX_PATH); // der Programmpfad mit programm.exe namen    
			std::string Path(appPath);    
			Path = Path.substr(0, Path.rfind('\\')); // ohne programm.exe namen

			//////////////////////////////////////////////////////////////////////
			//------------------------------------------------------------------//
			// Get file version                                                 //
			//------------------------------------------------------------------//
			//////////////////////////////////////////////////////////////////////
			DWORD	dwLen = 0;
			LPVOID	plVerBuffer = NULL;
			UINT	uiVerBufferLen = 0;
			BOOL	bRetCode = FALSE;
			DWORD	dwDummy = 0;
			PBYTE	pData = NULL;
			VS_FIXEDFILEINFO uFileInfo;
			BOOL	bRet = FALSE;

			dwLen = GetFileVersionInfoSize(appPath, &dwDummy);
			if ( dwLen > 0 )
			{
				pData = new BYTE[dwLen];
				if ( pData )
				{
					bRetCode = GetFileVersionInfo(appPath, 0, dwLen, pData);
					bRetCode = VerQueryValue(pData, "\\", &plVerBuffer, &uiVerBufferLen);

					RtlMoveMemory(&uFileInfo, plVerBuffer, uiVerBufferLen);

					csFileVersion.Format("%d.%d.%d.%d",
						((uFileInfo.dwProductVersionMS >> 16) & 0xFF),
						(uFileInfo.dwProductVersionMS & 0xFF),
						((uFileInfo.dwProductVersionLS >> 16) & 0xFF),
						(uFileInfo.dwProductVersionLS & 0xFF) );

					delete [] pData;
					bRet = true;
				}
			}

			//////////////////////////////////////////////////////////////////////
			//------------------------------------------------------------------//
			// Get file time                                                    //
			//------------------------------------------------------------------//
			//////////////////////////////////////////////////////////////////////

				HANDLE hFile = CreateFile(appPath, GENERIC_READ, FILE_SHARE_READ, NULL,
				OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
			if ( (hFile != 0) && (hFile != INVALID_HANDLE_VALUE) )
			{
				SYSTEMTIME tSystemTime;
				FILETIME tLastWriteTime;

				if ( GetFileTime(hFile, NULL, NULL, &tLastWriteTime) )
				{
					if ( FileTimeToSystemTime(&tLastWriteTime, &tSystemTime) )
					{
						tSystemTime.wHour++;
						if ( _daylight == 1 )
						{
							tSystemTime.wHour++;
						}
						csFileTime.Format("%02d.%02d.%04d %02d:%02d:%02d",
							tSystemTime.wDay,
							tSystemTime.wMonth,
							tSystemTime.wYear,
							tSystemTime.wHour,
							tSystemTime.wMinute,
							tSystemTime.wSecond);
					}
				}
			}

			//////////////////////////////////////////////////////////////////////
			//------------------------------------------------------------------//
			// Get file size                                                    //
			//------------------------------------------------------------------//
			//////////////////////////////////////////////////////////////////////

			DWORD dwSize = 0;
			if ( (hFile != 0) && (hFile != INVALID_HANDLE_VALUE) )
			{
				dwSize = GetFileSize(hFile, NULL);
				if ( dwSize != INVALID_FILE_SIZE )
				{
					csFileSize.Format("%ld", dwSize);

					int iConvTemp;
					iConvTemp = csFileSize.GetLength();
					if (iConvTemp > 3)
						csFileSize = csFileSize.Left(iConvTemp-3) + "." + csFileSize.Right(3);
					iConvTemp = csFileSize.GetLength();
					if (iConvTemp > 7)
						csFileSize = csFileSize.Left(iConvTemp-7) + "." + csFileSize.Right(7);
					iConvTemp = csFileSize.GetLength();
					if (iConvTemp > 11)
						csFileSize = csFileSize.Left(iConvTemp-11) + "." + csFileSize.Right(11);
				}
			}

			//////////////////////////////////////////////////////////////////////
			//------------------------------------------------------------------//
			// Close file handle                                                //
			//------------------------------------------------------------------//
			//////////////////////////////////////////////////////////////////////

			if ( (hFile != 0) && (hFile != INVALID_HANDLE_VALUE) )
			{
				CloseHandle(hFile);
			}

//			WriteInfo((CString) "      Modul:		" + szFileName);
//			WriteInfo((CString) "      Größe:		" + csFileSize + " Bytes");
//			WriteInfo((CString) "      Datum:		" + csFileTime);
//			WriteInfo((CString) "      Version:		" + csFileVersion);

				printf(appPath); 
				printf("\n");
				printf(csFileSize + " Bytes");
				printf("\n");
				printf(csFileTime);
				printf("\n");
				printf(csFileVersion);

				return 0;
}

Du hast mir den Tag gerettet oder zerstört. Je nachdem wie ich mich anstelle.

Er gibt mir jetzt zwar die exe aus und die dazugehörigen Module mit ProcessID, Pfad und größe wieder, aber er macht das von allen *.exe Dateien die gerade aktiv im System sind.

Ich vermute, dass der Parameter in diesem Code- Fragment geändert werden muss.

BOOL GetProcessList( )
{
  HANDLE hProcessSnap;
  HANDLE hProcess;
  PROCESSENTRY32 pe32;
  DWORD dwPriorityClass;

  hProcessSnap = CreateToolhelp32Snapshot( TH32CS_SNAPPROCESS, 0 );
  if( hProcessSnap == INVALID_HANDLE_VALUE )
  {
    printError( TEXT("CreateToolhelp32Snapshot (of processes)") );
    return( FALSE );
  }

  pe32.dwSize = sizeof( PROCESSENTRY32 );

Allerdings ist bei CreateToolhelp32Snapshot die 0. Soweit ich mich entsinne, ist die 0 für den aktuellen Prozess.

Schon mal danke für eventuelle Einfälle. Ansonsten wird das eine üppige Prozessauflistung und das letzte ist dann, die aktuelle Datei

Hier übrigens der Code, falls jemand aus all seinen aktiven *.exe Dateien die zugehörigen Module auslesen will.

BOOL GetProcessList( )
{
  HANDLE hProcessSnap;
  HANDLE hProcess;
  PROCESSENTRY32 pe32;
  DWORD dwPriorityClass;

  // erstellt "Snapshot" von den Prozessen (*.exe)
  hProcessSnap = CreateToolhelp32Snapshot( TH32CS_SNAPPROCESS, 0 );
  if( hProcessSnap == INVALID_HANDLE_VALUE )
  {
    printError( TEXT("CreateToolhelp32Snapshot (of processes)") );
    return( FALSE );
  }

  // Größe bestimmen
  pe32.dwSize = sizeof( PROCESSENTRY32 );

  // Informationen über den ersten Prozess ermitteln, beim scheitern verlassen
  if( !Process32First( hProcessSnap, &pe32 ) )
  {
    printError( TEXT("Process32First") ); // Anzeige bei Fehler
    CloseHandle( hProcessSnap );          // Snapshot Objekt bereinigen
    return( FALSE );
  }

  //bei Erfolg Ausgabe
  do
  {
    printf( "\n\n=====================================================" );
    _tprintf( TEXT("\nPROCESS NAME:  %s"), pe32.szExeFile );
    printf( "\n-----------------------------------------------------" );

    // Priority Class erhalten
    dwPriorityClass = 0;
    hProcess = OpenProcess( PROCESS_ALL_ACCESS, FALSE, pe32.th32ProcessID );
    if( hProcess == NULL )
      printError( TEXT("OpenProcess") );
    else
    {
      dwPriorityClass = GetPriorityClass( hProcess );
      if( !dwPriorityClass )
        printError( TEXT("GetPriorityClass") );
      CloseHandle( hProcess );
    }

    printf( "\n  Process ID        = 0x%08X", pe32.th32ProcessID );
    printf( "\n  Thread count      = %d",   pe32.cntThreads );
    printf( "\n  Parent process ID = 0x%08X", pe32.th32ParentProcessID );
    printf( "\n  Priority base     = %d", pe32.pcPriClassBase );
    if( dwPriorityClass )
      printf( "\n  Priority class    = %d", dwPriorityClass );

    // Auflistung der Module und Threads die mit dem Prozess zusammenhängen
    ListProcessModules( pe32.th32ProcessID );
    ListProcessThreads( pe32.th32ProcessID );

  } while( Process32Next( hProcessSnap, &pe32 ) );

  CloseHandle( hProcessSnap );
  return( TRUE );
}

BOOL ListProcessModules( DWORD dwPID )
{
  HANDLE hModuleSnap = INVALID_HANDLE_VALUE;
  MODULEENTRY32 me32;

  // "Snapshot" von den Modulen (Dll) erstellen
  hModuleSnap = CreateToolhelp32Snapshot( TH32CS_SNAPMODULE, dwPID );
  if( hModuleSnap == INVALID_HANDLE_VALUE )
  {
    printError( TEXT("CreateToolhelp32Snapshot (of modules)") );
    return( FALSE );
  }

  // Größe bestimmen
  me32.dwSize = sizeof( MODULEENTRY32 );

  // Informationen über das 1. Modul 
  if( !Module32First( hModuleSnap, &me32 ) )
  {
    printError( TEXT("Module32First") );  // Anzeige beim Fehler
    CloseHandle( hModuleSnap );           // Snapshot Objekt bereinigen
    return( FALSE );
  }

  // verschiedene Informationen der Module wieder geben
  do
  {
    _tprintf( TEXT("\n\n     MODULE NAME:     %s"),   me32.szModule );
    _tprintf( TEXT("\n     Executable     = %s"),     me32.szExePath );
    printf( "\n     Process ID     = 0x%08X",         me32.th32ProcessID );
    printf( "\n     Ref count (g)  = 0x%04X",     me32.GlblcntUsage );
    printf( "\n     Ref count (p)  = 0x%04X",     me32.ProccntUsage );
    printf( "\n     Base address   = 0x%08X", (DWORD) me32.modBaseAddr );
    printf( "\n     Base size      = %d",             me32.modBaseSize );

  } while( Module32Next( hModuleSnap, &me32 ) );

  CloseHandle( hModuleSnap );
  return( TRUE );
}

BOOL ListProcessThreads( DWORD dwOwnerPID ) 
{ 
  HANDLE hThreadSnap = INVALID_HANDLE_VALUE; 
  THREADENTRY32 te32; 

  // Snapshot von allen laufenden Threads 
  hThreadSnap = CreateToolhelp32Snapshot( TH32CS_SNAPTHREAD, 0 ); 
  if( hThreadSnap == INVALID_HANDLE_VALUE ) 
    return( FALSE ); 

  // Größe ermitteln 
  te32.dwSize = sizeof(THREADENTRY32 ); 

  // Informationen über den 1. Thread 
  if( !Thread32First( hThreadSnap, &te32 ) ) 
  {
    printError( TEXT("Thread32First") ); // Anzeige beim Fehler
    CloseHandle( hThreadSnap );          // Snapshot Objekt bereinigen
    return( FALSE );
  }

  // Threadliste des Systems durchgehen und Informationen über jeden thread wiedergeben, der mit dem jeweiligen Prozess zu tun hat
  do 
  { 
    if( te32.th32OwnerProcessID == dwOwnerPID )
    {
      printf( "\n\n     THREAD ID      = 0x%08X", te32.th32ThreadID ); 
      printf( "\n     Base priority  = %d", te32.tpBasePri ); 
      printf( "\n     Delta priority = %d", te32.tpDeltaPri ); 
    }
  } while( Thread32Next(hThreadSnap, &te32 ) ); 

  CloseHandle( hThreadSnap );
  return( TRUE );
}

void printError( TCHAR* msg )
{
  DWORD eNum;
  TCHAR sysMsg[256];
  TCHAR* p;

  eNum = GetLastError( );
  FormatMessage( FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
         NULL, eNum,
         MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
         sysMsg, 256, NULL );

  // Das Ende der Linie trimmen und mit 0 schließen
  p = sysMsg;
  while( ( *p > 31 ) || ( *p == 9 ) )
    ++p;
  do { *p-- = 0; } while( ( p >= sysMsg ) &&
                          ( ( *p == '.' ) || ( *p < 33 ) ) );

  // Nachricht ausgeben
  _tprintf( TEXT("\n  WARNING: %s failed with error %d (%s)"), msg, eNum, sysMsg );
}

Mir ist der Gedanke gekommen, dass ich mit GetCurrentProcessId das irgendwie abfangen könnte. Allerdings bekomme ich das nicht hin. Der gibt mir dann immer noch die ganze Liste aus

Man fügt nur

if(pe32.th32ProcessID == GetCurrentProcessId())

hier

//bei Erfolg Ausgabe
  do
  {
    printf( "\n\n=====================================================" );
    _tprintf( TEXT("\nPROCESS NAME:  %s"), pe32.szExeFile );
    printf( "\n-----------------------------------------------------" );

ein.

Sieht dann so

//bei Erfolg Ausgabe
  do
  if(pe32.th32ProcessID == GetCurrentProcessId())
  {
    printf( "\n\n=====================================================" );
    _tprintf( TEXT("\nPROCESS NAME:  %s"), pe32.szExeFile );
    printf( "\n-----------------------------------------------------" );

aus