645 lines
14 KiB
Plaintext
645 lines
14 KiB
Plaintext
unit FileHandleListUnit;
|
|
|
|
interface
|
|
|
|
uses
|
|
Winapi.Windows, System.SysUtils, System.Generics.Collections, System.Classes,
|
|
System.Character, System.StrUtils,
|
|
BsoneDebug,
|
|
BsoneUtil;
|
|
|
|
|
|
const
|
|
MIN_BUFFERSIZE = 40;
|
|
HISTORY_FILE_LISTMAX = 30;
|
|
|
|
type
|
|
TFILE_BUFFER = record
|
|
buf: array[0..MIN_BUFFERSIZE - 1] of Byte;
|
|
size: DWORD;
|
|
end;
|
|
PFILE_BUFFER = ^TFILE_BUFFER;
|
|
|
|
TFileHandle = class
|
|
public
|
|
path: string;
|
|
drivetype: DWORD;
|
|
h: THandle;
|
|
hash: array[0..31] of Byte;
|
|
cnt: DWORD;
|
|
dwDesiredAccess: DWORD;
|
|
dwShareMode: DWORD;
|
|
dwCreationDisposition: DWORD;
|
|
dwFlagsAndAttributes: DWORD;
|
|
dwOffset: DWORD;
|
|
lbuf: TList<TFILE_BUFFER>;
|
|
constructor Create;
|
|
destructor Destroy; override;
|
|
|
|
procedure Assign(ASource: TFileHandle);
|
|
end;
|
|
|
|
TFileHandleList = class
|
|
private
|
|
|
|
public
|
|
lFile: TObjectList<TFileHandle>;
|
|
lHisFile: TObjectList<TFileHandle>;
|
|
cs, lHcs: TRTLCriticalSection;
|
|
state: boolean;
|
|
HistoryFileCnt: DWORD;
|
|
|
|
constructor Create;
|
|
destructor Destroy; override;
|
|
|
|
procedure Lock(var ACS: TRTLCriticalSection);
|
|
procedure UnLock(var ACS: TRTLCriticalSection);
|
|
function IsHandleOutPath(h: THandle; out sPath: string): BOOL;
|
|
function FindHandle(h: THandle): TFileHandle;
|
|
function ChangeHandle(h: THandle; const path: string; dwDesiredAccess: DWORD = 0;
|
|
dwShareMode: DWORD = 0; dwCreationDisposition: DWORD = 0;
|
|
dwFlagsAndAttributes: DWORD = 0): Boolean;
|
|
|
|
function IsHandle(h: THandle; out HandleInfo: TFileHandle): BOOL;
|
|
|
|
procedure Cleanup;
|
|
procedure ClearHistory;
|
|
|
|
function InsertHandle(h: THandle; const path: string;
|
|
dwDesiredAccess, dwShareMode, dwCreationDisposition, dwFlagsAndAttributes: DWORD): BOOL;
|
|
function IsEmptyBuffer(lpBuffer: PByte; size: DWORD): BOOL;
|
|
function InsertBufferForHandle(h: THandle; const path: string; buf: PByte; size: DWORD): BOOL;
|
|
function InsertBuffer(h: THandle; const path: string; buf: PByte; size: DWORD): BOOL;
|
|
function SetHistoryFile(f: TFileHandle): BOOL;
|
|
function IsHistoryFileBufferCompare(const path: string; lpBuffer: PByte; size: DWORD;
|
|
out fileHandle: TFileHandle): BOOL; overload;
|
|
function IsBufferCompare(const path: string; buffer: PByte; size: DWORD;
|
|
out fileHandle: TFileHandle; bInterNetWriteFile: BOOL = FALSE): BOOL; overload;
|
|
|
|
function DelHandle(h: THandle): BOOL;
|
|
end;
|
|
|
|
|
|
implementation
|
|
|
|
|
|
constructor TFileHandle.Create;
|
|
begin
|
|
inherited Create;
|
|
lbuf := TList<TFILE_BUFFER>.Create;
|
|
FillChar(hash, SizeOf(hash), 0);
|
|
|
|
end;
|
|
|
|
destructor TFileHandle.Destroy;
|
|
begin
|
|
lbuf.Free;
|
|
inherited Destroy;
|
|
end;
|
|
|
|
|
|
procedure TFileHandle.Assign(ASource: TFileHandle);
|
|
begin
|
|
if ASource = nil then Exit;
|
|
Self.path := ASource.path;
|
|
Self.drivetype := ASource.drivetype;
|
|
Self.h := ASource.h;
|
|
Self.hash := ASource.hash;
|
|
Self.cnt := ASource.cnt;
|
|
Self.dwDesiredAccess := ASource.dwDesiredAccess;
|
|
Self.dwShareMode := ASource.dwShareMode;
|
|
Self.dwCreationDisposition := ASource.dwCreationDisposition;
|
|
Self.dwFlagsAndAttributes := ASource.dwFlagsAndAttributes;
|
|
Self.dwOffset := ASource.dwOffset;
|
|
|
|
end;
|
|
|
|
|
|
constructor TFileHandleList.Create;
|
|
begin
|
|
InitializeCriticalSection(cs);
|
|
InitializeCriticalSection(lHcs);
|
|
lFile := TObjectList<TFileHandle>.Create(True);
|
|
lHisFile := TObjectList<TFileHandle>.Create(True);
|
|
HistoryFileCnt := 0;
|
|
state := true;
|
|
|
|
end;
|
|
|
|
destructor TFileHandleList.Destroy;
|
|
begin
|
|
Cleanup;
|
|
inherited Destroy;
|
|
end;
|
|
|
|
procedure TFileHandleList.Lock(var ACS: TRTLCriticalSection);
|
|
begin
|
|
EnterCriticalSection(ACS);
|
|
end;
|
|
|
|
procedure TFileHandleList.UnLock(var ACS: TRTLCriticalSection);
|
|
begin
|
|
LeaveCriticalSection(ACS);
|
|
end;
|
|
|
|
function TFileHandleList.FindHandle(h: THandle): TFileHandle;
|
|
var
|
|
ch: TFileHandle;
|
|
begin
|
|
Result := nil;
|
|
if not state then
|
|
Exit;
|
|
if lFile.Count = 0 then
|
|
Exit;
|
|
|
|
for ch in lFile do
|
|
begin
|
|
if ch.h = h then
|
|
begin
|
|
Result := ch;
|
|
Exit;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
function TFileHandleList.ChangeHandle(h: THandle; const path: string;
|
|
dwDesiredAccess: DWORD; dwShareMode: DWORD; dwCreationDisposition: DWORD;
|
|
dwFlagsAndAttributes: DWORD): Boolean;
|
|
var
|
|
fh: TFileHandle;
|
|
begin
|
|
Result := False;
|
|
if not state then
|
|
Exit;
|
|
if lFile.Count = 0 then
|
|
Exit;
|
|
|
|
for fh in lFile do
|
|
begin
|
|
if fh.h = h then
|
|
begin
|
|
if path = '' then
|
|
Break;
|
|
if (path <> '') and (not StartsText(path, fh.path)) then
|
|
begin
|
|
fh.path := path;
|
|
fh.dwDesiredAccess := dwDesiredAccess;
|
|
fh.dwCreationDisposition := dwCreationDisposition;
|
|
fh.dwFlagsAndAttributes := dwFlagsAndAttributes;
|
|
fh.dwShareMode := dwShareMode;
|
|
fh.lbuf.Clear;
|
|
fh.drivetype := UtilGetDriveTypeEx(path);
|
|
end;
|
|
Result := True;
|
|
Exit;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure TFileHandleList.Cleanup;
|
|
begin
|
|
|
|
if not state then Exit;
|
|
state := false;
|
|
Lock(cs);
|
|
FreeAndNil(lFile);
|
|
UnLock(cs);
|
|
Lock(lHcs);
|
|
FreeAndNil(lHisFile);
|
|
UnLock(lHcs);
|
|
DeleteCriticalSection(cs);
|
|
DeleteCriticalSection(lHcs);
|
|
end;
|
|
|
|
procedure TFileHandleList.ClearHistory;
|
|
begin
|
|
Lock(lHcs);
|
|
try
|
|
lHisFile.Clear;
|
|
finally
|
|
UnLock(lHcs);
|
|
end;
|
|
end;
|
|
|
|
function TFileHandleList.InsertHandle(h: THandle; const path: string;
|
|
dwDesiredAccess, dwShareMode, dwCreationDisposition,
|
|
dwFlagsAndAttributes: DWORD): BOOL;
|
|
var
|
|
fh: TFileHandle;
|
|
drivetype: DWORD;
|
|
isType: Boolean;
|
|
begin
|
|
isType:= False;
|
|
Result := FALSE;
|
|
|
|
// DVLOG('InsertHandle: state(%d)', [DWORD(state)]);
|
|
if not state then
|
|
Exit;
|
|
|
|
Lock(cs);
|
|
try
|
|
drivetype:= UtilGetDriveTypeEx(path);
|
|
case drivetype of
|
|
DRIVE_NO_ROOT_DIR,
|
|
DRIVE_REMOTE,
|
|
DRIVE_FIXED:
|
|
isType:= True;
|
|
end;
|
|
|
|
// DVLOG('InsertHandle: drivetype(%d)', [drivetype]);
|
|
if not isType then
|
|
Exit;
|
|
|
|
if not ChangeHandle(h, path, dwDesiredAccess, dwShareMode, dwCreationDisposition, dwFlagsAndAttributes) then
|
|
begin
|
|
fh := TFileHandle.Create;
|
|
fh.h := h;
|
|
fh.dwDesiredAccess := dwDesiredAccess;
|
|
fh.dwCreationDisposition := dwCreationDisposition;
|
|
fh.dwFlagsAndAttributes := dwFlagsAndAttributes;
|
|
fh.dwShareMode := dwShareMode;
|
|
fh.path := path;
|
|
fh.drivetype := drivetype;
|
|
lFile.Insert(0, fh);
|
|
// DVLOG('InsertHandle: (%s)', [path]);
|
|
end;
|
|
|
|
finally
|
|
UnLock(cs);
|
|
end;
|
|
Result := TRUE;
|
|
end;
|
|
|
|
function TFileHandleList.IsEmptyBuffer(lpBuffer: PByte; size: DWORD): BOOL;
|
|
var
|
|
i: DWORD;
|
|
begin
|
|
Result := TRUE;
|
|
if lpBuffer = nil then Exit;
|
|
for i := 0 to size - 1 do
|
|
begin
|
|
if lpBuffer[i] <> 0 then
|
|
begin
|
|
Result := FALSE;
|
|
Break;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
function TFileHandleList.InsertBufferForHandle(h: THandle; const path: string; buf: PByte; size: DWORD): BOOL;
|
|
var
|
|
fh: TFileHandle;
|
|
fbuf: TFILE_BUFFER;
|
|
max: Integer;
|
|
begin
|
|
Result := FALSE;
|
|
if not state then
|
|
Exit;
|
|
|
|
if IsEmptyBuffer(buf, 32) then
|
|
Exit;
|
|
|
|
// DVLOG('InsertBufferForHandle: ++',[]);
|
|
Lock(cs);
|
|
try
|
|
fh := FindHandle(h);
|
|
|
|
// DVLOG('InsertBufferForHandle: fh(%p) ++',[Pointer(fh)]);
|
|
if fh = nil then
|
|
begin
|
|
|
|
if path = '' then
|
|
Exit;
|
|
|
|
fh := TFileHandle.Create;
|
|
fh.h := h;
|
|
fh.path := path;
|
|
|
|
// DVLOG('InsertBufferForHandle: UtilGetDriveTypeEx ++', []);
|
|
fh.drivetype := UtilGetDriveTypeEx(path);
|
|
fh.cnt := 0;
|
|
if size > 0 then
|
|
begin
|
|
FillChar(fbuf, SizeOf(fbuf), 0);
|
|
if size > SizeOf(fbuf.buf) then
|
|
max := SizeOf(fbuf.buf)
|
|
else
|
|
max := size;
|
|
|
|
DVLOG('InsertBufferForHandle: New max(%d)', [max]);
|
|
Move(buf^, fbuf.buf, max);
|
|
fbuf.size := max;
|
|
fh.lbuf.Add(fbuf);
|
|
end;
|
|
// DVLOG('InsertBufferForHandle: Insert++', []);
|
|
lFile.Insert(0, fh);
|
|
end
|
|
else
|
|
begin
|
|
|
|
// DVLOG('InsertBufferForHandle: path(%s)(%s), size(%d)', [PChar(path), PChar(fh.path), size]);
|
|
if (path <> '') and (not StartsText(path, fh.path)) then
|
|
begin
|
|
fh.path := path;
|
|
end;
|
|
|
|
if fh.lbuf.Count <> 0 then
|
|
Exit;
|
|
// fh.lbuf.Clear;
|
|
|
|
if size > 0 then
|
|
begin
|
|
FillChar(fbuf, SizeOf(fbuf), 0);
|
|
if size > SizeOf(fbuf.buf) then
|
|
max := SizeOf(fbuf.buf)
|
|
else
|
|
max := size;
|
|
|
|
DVLOG('InsertBufferForHandle: max(%d)', [max]);
|
|
Move(buf^, fbuf.buf, max);
|
|
fbuf.size := max;
|
|
fh.lbuf.Add(fbuf);
|
|
end;
|
|
end;
|
|
finally
|
|
UnLock(cs);
|
|
end;
|
|
Result := TRUE;
|
|
end;
|
|
|
|
function TFileHandleList.InsertBuffer(h: THandle; const path: string; buf: PByte;
|
|
size: DWORD): BOOL;
|
|
var
|
|
ch: TFileHandle;
|
|
fbuf: TFILE_BUFFER;
|
|
max: Integer;
|
|
begin
|
|
Result := FALSE;
|
|
if not state then Exit;
|
|
if IsEmptyBuffer(buf, 32) then Exit;
|
|
Lock(cs);
|
|
try
|
|
ch := FindHandle(h);
|
|
if ch <> nil then
|
|
begin
|
|
if (path <> '') and (not StartsText(path, ch.path)) then
|
|
begin
|
|
ch.path := path;
|
|
end;
|
|
ch.lbuf.Clear;
|
|
if (size > 0) and (ch.lbuf.Count = 0) then
|
|
begin
|
|
FillChar(fbuf, SizeOf(fbuf), 0);
|
|
if size > SizeOf(fbuf.buf) then max := SizeOf(fbuf.buf) else max := size;
|
|
Move(buf^, fbuf.buf, max);
|
|
fbuf.size := max;
|
|
ch.lbuf.Insert(0, fbuf);
|
|
end;
|
|
end;
|
|
finally
|
|
UnLock(cs);
|
|
end;
|
|
Result := TRUE;
|
|
end;
|
|
|
|
function TFileHandleList.SetHistoryFile(f: TFileHandle): BOOL;
|
|
begin
|
|
Result := FALSE;
|
|
if not state then Exit;
|
|
if f = nil then Exit;
|
|
Lock(lHcs);
|
|
try
|
|
if lHisFile.Count >= HISTORY_FILE_LISTMAX then
|
|
begin
|
|
lHisFile.Delete(lHisFile.Count - 1);
|
|
end;
|
|
lHisFile.Insert(0, f);
|
|
finally
|
|
UnLock(lHcs);
|
|
end;
|
|
Result := TRUE;
|
|
end;
|
|
|
|
function TFileHandleList.DelHandle(h: THandle): BOOL;
|
|
var
|
|
ch: TFileHandle;
|
|
remain: TFileHandle;
|
|
i: Integer;
|
|
begin
|
|
Result := FALSE;
|
|
remain := nil;
|
|
if not state then Exit;
|
|
|
|
Lock(cs);
|
|
try
|
|
for i := lFile.Count - 1 downto 0 do
|
|
begin
|
|
ch := lFile[i];
|
|
if ch.h = h then
|
|
begin
|
|
if ch.cnt > 0 then
|
|
begin
|
|
ch.cnt := ch.cnt - 1;
|
|
end
|
|
else
|
|
begin
|
|
remain := lFile.Extract(ch);
|
|
// DVLOG('DelHandle: (%p)', [Pointer(ch.h)]);
|
|
Break;
|
|
end;
|
|
end;
|
|
end;
|
|
finally
|
|
UnLock(cs);
|
|
end;
|
|
if remain = nil then Exit;
|
|
|
|
// DVLOG('SetHistoryFile: (%p)', [Pointer(remain.h)]);
|
|
Result := SetHistoryFile(remain);
|
|
end;
|
|
|
|
|
|
function TFileHandleList.IsHandle(h: THandle; out HandleInfo: TFileHandle): BOOL;
|
|
var
|
|
fh: TFileHandle;
|
|
begin
|
|
Result := FALSE;
|
|
HandleInfo := nil;
|
|
|
|
if not state then Exit;
|
|
if lFile.Count = 0 then Exit;
|
|
|
|
Lock(cs);
|
|
try
|
|
for fh in lFile do
|
|
begin
|
|
if fh.h = h then
|
|
begin
|
|
|
|
HandleInfo:= TFileHandle.Create;
|
|
HandleInfo.Assign(fh);
|
|
Result := TRUE;
|
|
Break;
|
|
end;
|
|
end;
|
|
finally
|
|
UnLock(cs);
|
|
end;
|
|
end;
|
|
|
|
|
|
function TFileHandleList.IsHandleOutPath(h: THandle; out sPath: string): BOOL;
|
|
var
|
|
fh: TFileHandle;
|
|
begin
|
|
Result := FALSE;
|
|
|
|
if not state then Exit;
|
|
if lFile.Count = 0 then Exit;
|
|
|
|
Lock(cs);
|
|
try
|
|
for fh in lFile do
|
|
begin
|
|
if fh.h = h then
|
|
begin
|
|
|
|
sPath:= fh.path;
|
|
Result := TRUE;
|
|
Break;
|
|
end;
|
|
end;
|
|
finally
|
|
UnLock(cs);
|
|
end;
|
|
end;
|
|
|
|
|
|
|
|
function TFileHandleList.IsHistoryFileBufferCompare(const path: string; lpBuffer: PByte; size: DWORD;
|
|
out fileHandle: TFileHandle): BOOL;
|
|
var
|
|
fb: TFILE_BUFFER;
|
|
fh: TFileHandle;
|
|
i, nPos: Integer;
|
|
sBuff: string;
|
|
srcname, dstname: string;
|
|
begin
|
|
nPos := 0;
|
|
Result := FALSE;
|
|
|
|
//DVLOG('IsHistoryFileBufferCompare: lHisFile.Count(%d), %d', [lHisFile.Count, DWORD(state)]);
|
|
if not state then
|
|
Exit;
|
|
|
|
if lHisFile.Count = 0 then
|
|
Exit;
|
|
|
|
Lock(lHcs);
|
|
try
|
|
for fh in lHisFile do
|
|
begin
|
|
|
|
if (path <> '') and (fh.path <> '') then
|
|
begin
|
|
srcname := ExtractFileName(path);
|
|
dstname := ExtractFileName(fh.path);
|
|
var diff:= SameText(srcname, dstname);
|
|
DVLOG('IsHistoryFileBufferCompare: srcname(%s), dstname(%s), diff(%d)', [PChar(srcname), PChar(dstname), DWORD(diff)]);
|
|
if not diff then
|
|
Continue;
|
|
end;
|
|
|
|
for fb in fh.lbuf do
|
|
begin
|
|
|
|
// for i := 0 to fb.size - 1 do
|
|
// sBuff := sBuff + IntToHex(fb.buf[i], 2);
|
|
|
|
//DVLOG('IsHistoryFileBufferCompare: sBuff(%s)', [sBuff]);
|
|
if UtilFindCode(lpBuffer, size, @fb.buf, fb.size, nPos) = nil then
|
|
Continue;
|
|
|
|
fileHandle := TFileHandle.Create;
|
|
fileHandle.Assign(fh);
|
|
Result := TRUE;
|
|
Exit;
|
|
end;
|
|
end;
|
|
finally
|
|
UnLock(lHcs);
|
|
end;
|
|
end;
|
|
|
|
|
|
|
|
function TFileHandleList.IsBufferCompare(const path: string; buffer: PByte;
|
|
size: DWORD; out fileHandle: TFileHandle; bInterNetWriteFile: BOOL): BOOL;
|
|
var
|
|
fh: TFileHandle;
|
|
fb: TFILE_BUFFER;
|
|
i, nPos: Integer;
|
|
srcname, dstname: string;
|
|
sBuff: string;
|
|
|
|
begin
|
|
Result := FALSE;
|
|
|
|
// DVLOG('IsBufferCompare: lFile.Count(%d), %d', [lFile.Count, DWORD(state)]);
|
|
|
|
// if lFile.Count = 0 then
|
|
// Exit;
|
|
|
|
if not state then
|
|
Exit;
|
|
|
|
Lock(cs);
|
|
try
|
|
for fh in lFile do
|
|
begin
|
|
|
|
if (path <> '') and (fh.path <> '') then
|
|
begin
|
|
srcname := ExtractFileName(path);
|
|
dstname := ExtractFileName(fh.path);
|
|
var diff:= SameText(srcname, dstname);
|
|
DVLOG('IsBufferCompare: srcname(%s), dstname(%s), diff(%d)', [PChar(srcname), PChar(dstname), DWORD(diff)]);
|
|
if not diff then
|
|
begin
|
|
Continue;
|
|
// fileHandle := TFileHandle.Create;
|
|
// fileHandle.Assign(fh);
|
|
//
|
|
// ClearHistory;
|
|
// Result := TRUE;
|
|
// Exit;
|
|
end;
|
|
end;
|
|
|
|
for fb in fh.lbuf do
|
|
begin
|
|
|
|
if UtilFindCode(buffer, size, @fb.buf, fb.size, nPos) = nil then
|
|
Continue;
|
|
|
|
fileHandle := TFileHandle.Create;
|
|
fileHandle.Assign(fh);
|
|
|
|
ClearHistory;
|
|
Result := TRUE;
|
|
// DVLOG('IsBufferCompare: (%s)', [fh.path]);
|
|
Exit;
|
|
end;
|
|
end;
|
|
finally
|
|
UnLock(cs);
|
|
end;
|
|
|
|
if IsHistoryFileBufferCompare(path, buffer, size, fileHandle) then
|
|
begin
|
|
Result := TRUE;
|
|
end;
|
|
end;
|
|
|
|
end.
|