Festplattenzugriffe

[w3seek]

Stichwort: storage filter driver
damit kann man alle lese/schreibzugriffe auf die platte protokollieren, unabhaengig ob man direkt als datei auf die festplatte oder partition schreibt und auch egal welches dateisystem verwendet wird.

[Kernel32.DLL]

Zitat:

Zitat von w3seek

Stichwort: storage filter driver
damit kann man alle lese/schreibzugriffe auf die platte protokollieren, unabhaengig ob man direkt als datei auf die festplatte oder partition schreibt und auch egal welches dateisystem verwendet wird.

Hast du konkrete beispiele, auf die man von delphi aus zugreifen könnte, ohne großartig mit C/C++ arbeiten zu müssen?

(evtl. fertigkompiliert?)

[w3seek]

dazu braucht man erst mal einen filter treiber den man schreiben muss. Das Zugreifen auf den Treiber mit CreateFile und DeviceIoControl ist dann eine leichtigkeit.

[Kernel32.DLL]

Zitat:

Zitat von w3seek

dazu braucht man erst mal einen filter treiber den man schreiben muss.

Mönsch, wenns weiter nichts is... :mrgreen: *zu googeln anfang*

[Slavik]

So, nach langem hin und her habe ich die ganze sache nun komplett einfach gelöst:

Ich habe die eine Festplatte in einen Wechselrahmen verfrachtet und syncronisiere sie wöchentlich 1 mal mit der anderen Platte. Zwar kein 100% Schutz aber ich denke für mich reichts.

THX Slavik

[Luckie]

Ich habe jetzt mal Christian Seehases Thread benutzt, um ein Netzwerklaufwerk zu überwachen. Die Aufgabe besteht darin neue Dateien in ein lokales Verzeichnis zu kopieren. Allerdings habe ich mit seinem Code etwas Probleme:

Delphi-Quellcode:

procedure TcsDirThread.Execute;

var
  pBuf              : Pointer;
  dwBufLen          : DWORD;
  dwRead            : DWORD;
  FNI               : FILE_NOTIFY_INFORMATION;
  pWork             : Pointer;
  sFileName         : Widestring;

begin
  FhFile := CreateFile(PChar(FsDirPath), FILE_LIST_DIRECTORY or GENERIC_READ,
    FILE_SHARE_READ or FILE_SHARE_WRITE or FILE_SHARE_DELETE, nil,
    OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0);
  if (FhFile = INVALID_HANDLE_VALUE) or (FhFile = 0) then
    exit;
  dwBufLen := 65536;
  pBuf := AllocMem(dwBufLen);
  try
    while true do
    begin
      if ReadDirectoryChangesW(FhFile, pBuf, dwBufLen, true,
        FILE_NOTIFY_CHANGE_FILE_NAME or
        FILE_NOTIFY_CHANGE_DIR_NAME or
        FILE_NOTIFY_CHANGE_ATTRIBUTES or
        FILE_NOTIFY_CHANGE_SIZE or
        FILE_NOTIFY_CHANGE_LAST_WRITE or
        FILE_NOTIFY_CHANGE_LAST_ACCESS or
        FILE_NOTIFY_CHANGE_CREATION or
        FILE_NOTIFY_CHANGE_SECURITY,
        @dwRead, nil, nil) then
      begin
        pWork := pBuf;
        repeat
          StrMove(@FNI, pWork, 12);
          PChar(pWork) := PChar(pWork) + 12;
          sFileName := StringOfChar(#00, FNI.dwFileNameLength);
          StrMove(@sFileName[1], pWork, FNI.dwFileNameLength);
          FsFileName := WideCharToString(PWideChar(sFileName));
          FsFileName := copy(FsFileName, 1, length(FsFileName) shl 1);
          FsReason := GetReason(FNI.dwAction);

          if FNI.dwAction = FILE_ACTION_ADDED then
          begin
            Synchronize(AddReasonToMemo);
            Synchronize(AddFileToMemo);
            FError := MoveChangedFiles(FFPATH + FsFileName);
            if FError <> 0 then
              Synchronize(AddErrorToMemo);
          end;

          PChar(pWork) := PChar(pBuf) + FNI.dwNextEntryOffset;
        until FNI.dwNextEntryOffset = 0;
        Create(FFPATH);
      end
      else
      begin
        break;
      end;
    end;
  finally
    FreeMem(pBuf, dwBufLen);
  end;
end;

Es wird aber immer nur die letzte Datei verschoben. Und ich bekomme Fehlermeldungen, dass auf die Datei nicht zugegriffen werden kann.

[Luckie]

Hm. Kopiere ich jede Datei einzeln geht es wie gewünscht. Ich kann mir aber leider nicht sicher sein, dass sie in einem so schönen abstand in dem Verzeichnis abegelegt werden. Und kopiere ich dann mal meherere Dateien gleichzeitig, dann schreibt er an dauernd ins Memo, dass eine von den Dateien andauernd geändert wird und nicht geht mehr :gruebel:

[Luckie]

Ich muss das noch mal nach oben holen, weil es wichtig wird.

[Christian Seehase]

Moin Luckie,

vielleicht klappt es asynchron besser.

Hier mal ein, leicht zusammengestrichenes Beispiel (was Du für Deinen Zweck wohl auch noch umsortieren müsstest:

Delphi-Quellcode:

const
  _iFilenameLength = MAX_PATH*2;

type
  PFILE_NOTIFY_INFORMATION = ^FILE_NOTIFY_INFORMATION;

  FILE_NOTIFY_INFORMATION = packed record
    dwNextEntryOffset : DWORD;
    dwAction          : DWORD;
    dwFileNameLength  : DWORD;
    wFilename         : array [1.._iFilenameLength] of WCHAR;
  end;

var
  pBuf     : Pointer;
  pWork    : Pointer;
  dwBufLen : DWORD;
  dwDummy  : DWORD;
  sResult   : string;
  FNI       : FILE_NOTIFY_INFORMATION;
  dwRead    : DWORD;
  dwKey     : DWORD;
  pOVL      : POVERLAPPED;
  iCopyLen  : integer;  // Prevent Buffer Overflow


begin
  // Normalerweise im Konstruktor erzeugt
  FhDir     := CreateFile(PChar(FsPath),FILE_LIST_DIRECTORY,FILE_SHARE_READ or FILE_SHARE_DELETE or FILE_SHARE_WRITE,nil,OPEN_EXISTING,FILE_FLAG_BACKUP_SEMANTICS or FILE_FLAG_OVERLAPPED,0);
  FhComPort := CreateIoCompletionPort(FhDir,0,$1234ABCD,0);
  FillChar(Fovl,SizeOf(Fovl),0);
  // Execute
  pOVL     := @Fovl;
  dwBufLen := 65536;
  GetMem(pBuf,dwBufLen);
  try
    while not Terminated do begin
      ZeroMemory(pBuf,dwBufLen);
      if not ReadDirectoryChangesW(FhDir,pBuf,dwBufLen,true,FILE_NOTIFY_CHANGE_LAST_WRITE,@dwDummy,@Fovl,nil) then Terminate;
      if Terminated then break;
      if not GetQueuedCompletionStatus(FhComPort,dwRead,dwKey,pOVL,INFINITE) then begin
        Terminate;
      end else begin
        if Terminated then break;
        pWork := pBuf;
        repeat
          CopyMemory(@FNI,pWork,12);
          iCopyLen := FNI.dwFileNameLength;
          if iCopyLen > _iFilenameLength then iCopyLen := _iFilenameLength;
          CopyMemory(@FNI.wFilename[1],PChar(pWork)+12,iCopyLen);
          PChar(pWork) := PChar(pWork)+FNI.dwNextEntryOffset;
        until FNI.dwNextEntryOffset = 0;
        SetLength(sResult,iCopyLen);
        ZeroMemory(@sResult[1],length(sResult));
        if WideCharToMultiByte(GetACP,WC_NO_BEST_FIT_CHARS,@FNI.wFilename,iCopyLen,@sResult[1],iCopyLen,nil,nil) <> 0 then begin
        end;
      end;
    end;
  finally
    FreeMem(pBuf,dwBufLen);
  end;
  // Destruktor
  if (FhDir <> INVALID_HANDLE_VALUE) and (FhDir <> 0) then CloseHandle(FhDir);
  if FhComPort <> 0 then CloseHandle(FhComPort);

Ausserdem solltest Du auch einmal prüfen, welche Pfade/Dateien in der Schleife angezeigt werden.

Dass Du auf die Datei nicht zugreifen kannst, wird wohl daran liegen, dass Du sie verschieben willst, sie aber noch von einem anderen Prozess im Zugriff ist (Explorer?)
Ausserdem solltest Du einmal prüfen, ob bei Dir das ReadDirectoryChangesW für jede Veränderung doppelt aufgerufen wird (dazu habe ich hier auch einen Thread offen :?)

Ich habe mir die asynchrone Lösung erstellt, da ich den Thread ansonsten nicht sauber beenden konnte, wenn ReadDirectoryChangesW auf eine Veränderung gewartet hat.

[Luckie]

Dank dir. Ich werde das morgen mal an der Arbheit ausprobieren.