Geöffnete Dateien ermitteln

Hallo,

ist es möglich auszulesen, welche Dateien ein Prozess geöffnet hat?
Ich meine keine Module, sondern z.B. Textdateien, etc.
Man bekommt ja ab und zu die Meldung:
"Die Aktion kann nicht abgeschlossen werden, da die Datei in X geöffnet ist. Schließen sie die Datei und wiederholen sie den Vorgang."

Und ich möchte nun wissen, welcher Prozess die Datei offen hält.

Wie ist das umzusetzen?

MfG.

LowFly

hi,
das was du vorhast ist nicht ohne, du must dich in den jeweiligen process hacken und diesen auslesen und gegebenen fals das handle auf die datei in dem process schließen.

ich hab das mit hilfe von einem beispiel von Code Project geschaft. Kucks dir mal an. die datei auf die es ankommt ist die SystemInfo.h/cpp im Projectordner TaskManagerExDll.

wenn du die TaskManagerEx.dll bei dir auf dem pc installierst. (bei mir läuft sie einwandfrei) öffne den Taskmanager, registerblatt Process und klick mit der rechten maustaste auf einen process. im popupmenu, Files... auswählen. dann öffnet ein fenster das alle dateien des ausgewählten processes anzeigt. rechter mausklick auf die datei und du kannst das handel im process entfernen.

das alles läuft über die SystemInfo.h/cpp in dem oben erwänten projectordner.

Wow, scheint genau das zu sein, was ich suche!
Werde ich ausprobierten, danke dir!

Hm...ich versteh es nicht, bzw ich finde das Gesuchte noch nicht einmal...da ist so viel drum herum...
Wäre sehr nett, wenn mir jemand, der etwas Zeit hat, ein Code-Schnipsel geben könnte...

MfG

LowFly

mit diesen 3 funktionen such ich mir den process den ich haben will um ein Handle auf eine bestimmte Datei zu entfernen.

starten tust du mit
ProcessSearch("NameDesProcesses.exe","C:\\Pfad\\der\\Datei.txt")

#include <SystemInfo.h>
#include <tlhelp32.h>

//---------------------------------------------------------------------------------------------------------------------------------------
//Process suche
BOOL ProcessSearch(LPTSTR lpExecutabel,LPTSTR lpPath)
{
	HANDLE			hProcess   = NULL; 
	PROCESSENTRY32  ProcEntry   = { sizeof(PROCESSENTRY32) }; 
	DWORD			dwProcessID;
	hProcess = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0); 

	if (Process32First(hProcess, &ProcEntry)) 
	{ 
		do 
		{ 
		if (!strcmp(ProcEntry.szExeFile, lpExecutabel)) 
			dwProcessID = ProcEntry.th32ProcessID;

		} while (Process32Next(hProcess, &ProcEntry));

	CloseHandle(hProcess); 
	} 

	return	SearchUsedFile(dwProcessID,lpScriptPath,lpMissionPath,lpStringTablePath);
}
//---------------------------------------------------------------------------------------------------------------------------------------
//Datei suche
BOOL SearchUsedFile(DWORD dwProcessID,LPTSTR lpPath)
{

	CString sPath = lpPath;

	SystemHandleInformation hi( dwProcessID, TRUE, _T("File") );

	int iItemCount = hi.m_HandleInfos.GetCount();

	BOOL result = FALSE;
	DWORD dwFuncRetVal = FALSE;

	for ( POSITION pos = hi.m_HandleInfos.GetHeadPosition(); pos != NULL; )
	{
		SystemHandleInformation::SYSTEM_HANDLE& h = hi.m_HandleInfos.GetNext(pos);

		CString strDevice, strPath;
		SystemHandleInformation::GetName( (HANDLE)h.HandleNumber, strDevice, h.ProcessID );
		SystemInfoUtils::GetFsFileName( strDevice, strPath );

		HANDLE pHandle = (HANDLE)h.HandleNumber;

	if(sPath == strPath)
		 result = RemoveFileHandle( dwProcessID, (DWORD)pHandle, "CloseHandle", &dwFuncRetVal );

	}

	return (result && dwFuncRetVal);
}
//---------------------------------------------------------------------------------------------------------------------------------------
//Handle der Datei entfernen
BOOL RemoveFileHandle( DWORD processId, DWORD dwArgument, char* lpszFunction, DWORD* lpdwFuncRetVal )
{
	HANDLE hRemoteThread = NULL;
	BOOL rc = FALSE;
	HMODULE hKernel32 = NULL;
	FARPROC pfnProc = NULL;
	DWORD ThreadId = 0;
	DWORD dwWaitRes;

	// open the process
	HANDLE hProcess = OpenProcess(
		PROCESS_CREATE_THREAD | PROCESS_VM_OPERATION | PROCESS_VM_WRITE | PROCESS_VM_READ,
		FALSE, processId );

	if ( hProcess == NULL )
		goto cleanup;

	hKernel32 = GetModuleHandle(_T("kernel32.dll"));

	if ( hKernel32 == NULL )
		goto cleanup;

	pfnProc = GetProcAddress( hKernel32, lpszFunction );

	if ( pfnProc == NULL )
		goto cleanup;

	hRemoteThread = CreateRemoteThread( hProcess, 0, 0, 
		(LPTHREAD_START_ROUTINE)pfnProc, (LPVOID)dwArgument, 0, (DWORD*)&ThreadId );

	if( lpdwFuncRetVal != NULL )
	{
		dwWaitRes = WaitForSingleObject( hRemoteThread, INFINITE );
		switch ( rc )
		{
		case WAIT_OBJECT_0:
			GetExitCodeThread( hRemoteThread, lpdwFuncRetVal );
			break;

		case WAIT_FAILED:
		case WAIT_TIMEOUT:
		default:
			goto cleanup;
		}
	}

	rc = TRUE;

cleanup:

	if( hProcess != NULL )
	{
		CloseHandle( hProcess );
	}

	if( hRemoteThread != NULL )
	{
		CloseHandle( hRemoteThread );
	}

	return rc;
}

Spitze, danke dir erneut !