Unlock / Release file (handle)?

unit untdefs;
 
interface
 
uses Windows, SysUtils, PSApi;
 
type
 NTSTATUS=cardinal;
 POBJECT=pointer;
 
 USHORT=word;
 
 SYSTEM_HANDLE=packed record
	uIdProcess:ULONG;
	ObjectType:UCHAR;    // OB_TYPE_* (OB_TYPE_TYPE, etc.)
	Flags:UCHAR;         // HANDLE_FLAG_* (HANDLE_FLAG_INHERIT, etc.)
	Handle:USHORT;
	pObject:PObject;
	GrantedAccess:ACCESS_MASK;
 end;
 PSYSTEM_HANDLE=^SYSTEM_HANDLE;
 SYSTEM_HANDLE_ARRAY=array[0..0] of SYSTEM_HANDLE;
 PSYSTEM_HANDLE_ARRAY=^SYSTEM_HANDLE_ARRAY;
 
 SYSTEM_HANDLE_INFORMATION=packed record
	uCount:ULONG;
	Handles:SYSTEM_HANDLE_ARRAY;
 end;
 PSYSTEM_HANDLE_INFORMATION=^SYSTEM_HANDLE_INFORMATION;
 
 UNICODE_STRING=packed record
    Length:USHORT;
    MaximumLength:USHORT;
    Buffer:PWideChar;
 end;
 PUNICODE_STRING=^UNICODE_STRING;
 
 OBJECT_NAME_INFORMATION=UNICODE_STRING;
 POBJECT_NAME_INFORMATION=^OBJECT_NAME_INFORMATION;
 
 SYSTEM_INFORMATION_CLASS=(
  SystemBasicInformation,       // 0x002C
  SystemProcessorInformation,     // 0x000C
  SystemPerformanceInformation,    // 0x0138
  SystemTimeInformation,       // 0x0020
  SystemPathInformation,       // not implemented
  SystemProcessInformation,      // 0x00F8+ per process
  SystemCallInformation,       // 0x0018 + (n * 0x0004)
  SystemConfigurationInformation,   // 0x0018
  SystemProcessorCounters,      // 0x0030 per cpu
  SystemGlobalFlag,          // 0x0004
  SystemInfo10,            // not implemented
  SystemModuleInformation,      // 0x0004 + (n * 0x011C)
  SystemLockInformation,       // 0x0004 + (n * 0x0024)
  SystemInfo13,            // not implemented
  SystemPagedPoolInformation,     // checked build only
  SystemNonPagedPoolInformation,   // checked build only
  SystemHandleInformation,      // 0x0004 + (n * 0x0010)
  SystemObjectInformation,      // 0x0038+ + (n * 0x0030+)
  SystemPagefileInformation,     // 0x0018+ per page file
  SystemInstemulInformation,     // 0x0088
  SystemInfo20,            // invalid info class
  SystemCacheInformation,       // 0x0024
  SystemPoolTagInformation,      // 0x0004 + (n * 0x001C)
  SystemProcessorStatistics,     // 0x0000, or 0x0018 per cpu
  SystemDpcInformation,        // 0x0014
  SystemMemoryUsageInformation1,   // checked build only
  SystemLoadImage,          // 0x0018, set mode only
  SystemUnloadImage,         // 0x0004, set mode only
  SystemTimeAdjustmentInformation,  // 0x000C, 0x0008 writeable
  SystemMemoryUsageInformation2,   // checked build only
  SystemInfo30,            // checked build only
  SystemInfo31,            // checked build only
  SystemCrashDumpInformation,     // 0x0004
  SystemExceptionInformation,     // 0x0010
  SystemCrashDumpStateInformation,  // 0x0008
  SystemDebuggerInformation,     // 0x0002
  SystemThreadSwitchInformation,   // 0x0030
  SystemRegistryQuotaInformation,   // 0x000C
  SystemLoadDriver,          // 0x0008, set mode only
  SystemPrioritySeparationInformation,// 0x0004, set mode only
  SystemInfo40,            // not implemented
  SystemInfo41,            // not implemented
  SystemInfo42,            // invalid info class
  SystemInfo43,            // invalid info class
  SystemTimeZoneInformation,     // 0x00AC
  SystemLookasideInformation,     // n * 0x0020
// info classes specific to Windows 2000
// WTS = Windows Terminal Server
  SystemSetTimeSlipEvent,       // set mode only
  SystemCreateSession,        // WTS, set mode only
  SystemDeleteSession,        // WTS, set mode only
  SystemInfo49,            // invalid info class
  SystemRangeStartInformation,    // 0x0004
  SystemVerifierInformation,     // 0x0068
  SystemAddVerifier,         // set mode only
  SystemSessionProcessesInformation // WTS
  );
 
 OBJECT_INFORMATION_CLASS = (
	ObjectBasicInformation,
	ObjectNameInformation,
	ObjectTypeInformation,
	ObjectAllTypesInformation,
	ObjectHandleInformation
 );
 
 TNTQuerySystemInformation=function
  (SystemInformationClass:DWORD;
   SystemInformation:pointer;
   SystemInformationLength:DWORD;
   ReturnLength:PDWORD
   ):NTSTATUS; stdcall;
 
 TNTQueryObject=function(
  ObjectHandle:cardinal;
  ObjectInformationClass:OBJECT_INFORMATION_CLASS;
  ObjectInformation:pointer;
  Length:ULONG;
  ResultLength:PDWORD
  ):NTSTATUS;stdcall;  
 
const
 STATUS_SUCCESS:NTSTATUS	= $00000000;
 STATUS_INFO_LENGTH_MISMATCH:NTSTATUS = $C0000004;
 STATUS_BUFFER_OVERFLOW:NTSTATUS	= $80000005;
 
function EnableDebugPrivilege:boolean;
function GetObjectInfo(hObject:cardinal;
 objInfoClass:OBJECT_INFORMATION_CLASS):LPWSTR;
function  GetFileNameFromHandle(hFile:Cardinal):string;
 
var
 NTQueryObject:TNTQueryObject;
 NTQuerySystemInformation:TNTQuerySystemInformation;
 
 
implementation
 
function EnableDebugPrivilege:boolean;
var
	hToken:cardinal;
	tokenPriv:TOKEN_PRIVILEGES;
	luidDebug:TLargeInteger;
  rlen:cardinal;
begin
  result:=false;
	if OpenProcessToken(GetCurrentProcess(),
      TOKEN_ADJUST_PRIVILEGES,
      hToken) then begin
		if LookupPrivilegeValue( nil , 'SeDebugPrivilege', luidDebug) then
		begin
			tokenPriv.PrivilegeCount := 1;
			tokenPriv.Privileges[0].Luid := luidDebug;
			tokenPriv.Privileges[0].Attributes := SE_PRIVILEGE_ENABLED;
			result:=AdjustTokenPrivileges(hToken, FALSE, tokenPriv,
        sizeof(tokenPriv), nil, rlen);
		end;
	end;
end;
 
function GetObjectInfo(hObject:cardinal;
 objInfoClass:OBJECT_INFORMATION_CLASS):LPWSTR;
var
 dwSize:DWORD;
 pObjectInfo:POBJECT_NAME_INFORMATION;
 ntReturn:NTSTATUS;
begin
  result:=nil;
	if(@NTQuerySystemInformation<>nil) then begin
		dwSize := sizeof(OBJECT_NAME_INFORMATION);
		pObjectInfo := AllocMem(dwSize);
		ntReturn := NTQueryObject(hObject, objInfoClass, pObjectInfo,
     dwSize, @dwSize);
		if((ntReturn = STATUS_BUFFER_OVERFLOW) or
       (ntReturn = STATUS_INFO_LENGTH_MISMATCH)) then begin
			FreeMem(pObjectInfo);
			pObjectInfo := AllocMem(dwSize);
			ntReturn := NTQueryObject(hObject, objInfoClass, pObjectInfo,
       dwSize, @dwSize);
		end;
		if((ntReturn >= STATUS_SUCCESS) and (pObjectInfo.Buffer <> nil)) then
		begin
			result := AllocMem(pObjectInfo.Length + sizeof(WCHAR));
			CopyMemory(result, pObjectInfo.Buffer, pObjectInfo.Length);
		end;
		FreeMem(pObjectInfo);
	end;
end;
 
function  GetFileNameFromHandle(hFile:Cardinal):string;
const
 BUFSIZE=512;
var
 bFound:boolean;
 pszFilename,
 szTemp,
 szDrive,
 szName:PAnsiChar;
 p:PAnsiChar;
 hFileMap,uNameLen:Cardinal;
 dwFileSizeHi, dwFileSizeLo:DWORD;
 pMem:pointer;
begin
   result:='';
   //  Get  the  file  size.
   dwFileSizeHi  :=  0;
   dwFileSizeLo  :=  GetFileSize(hFile,  @dwFileSizeHi);
 
   if ((dwFileSizeLo  =  0)  and  (dwFileSizeHi  =  0)) then exit;
 
   pszFilename:=AllocMem(MAX_PATH*2+2);
   szTemp:=AllocMem(BUFSIZE);
   szName:=AllocMem(MAX_PATH);
 
   //  Create  a  file  mapping  object.
   hFileMap  :=  CreateFileMapping(hFile,
                     nil,
                     PAGE_READONLY,
                     0,
                     1,
                     nil);
 
    if  (hFileMap<>0) then begin
    //  Create  a  file  mapping  to  get  the  file  name.
    pMem  :=  MapViewOfFile(hFileMap,  FILE_MAP_READ,  0,  0,  1);
     if  (pMem<>nil) then begin
       if  GetMappedFileName (GetCurrentProcess(),  
                              pMem,  
                              pszFilename, 
                              MAX_PATH)<>0 then
       begin
          //  Translate  path  with  device  name  to  drive  letters. 
          if  (GetLogicalDriveStrings(BUFSIZE-1,  szTemp)<>0) then begin
           bFound  :=  FALSE;
           p  :=  szTemp;
           repeat
             //  Copy  the  drive  letter  to  the  template  string
             szDrive  :=  p; 
             //  Look  up  each  device  name
             if  QueryDosDevice(szDrive,  szName,  BUFSIZE)<>0 then begin
              uNameLen  :=  length(szName);
              if  (uNameLen  <  MAX_PATH) then begin
                bFound  := AnsiStrLComp(pszFilename, szName,uNameLen)=0;
 
                if  (bFound) then begin
                   //  Reconstruct  pszFilename  using  szTemp
                   //  Replace  device  path  with  DOS  path
                   result:=Format('%s%s',
                             [szDrive,
                             PAnsiChar(cardinal(pszFilename)+
                             uNameLen)]);
                end;
              end;
             end;
 
            //  Go  to  the  next  NULL  character.
            while ( p^<>#0 ) do inc(p);
           until bFound or (p^=#0);
         end;
       end;
       UnmapViewOfFile(pMem); 
     end;  
 
      CloseHandle(hFileMap); 
   end;
 
   FreeMem(pszFilename);
   FreeMem(szTemp);
   FreeMem(szName);
end;
 
begin
 NTQueryObject := GetProcAddress(
  GetModuleHandle('NTDLL.DLL'), 'NtQueryObject');
 NTQuerySystemInformation := GetProcAddress(
  GetModuleHandle('NTDLL.DLL'), 'NtQuerySystemInformation');
end.

                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202:
203:
204:
205:
206:
207:
208:
209:
210:
211:
212:
213:
214:
215:
216:
217:
218:
219:
220:
221:
222:
223:
224:
225:
226:
227:
228:
229:
230:
231:
232:
233:
234:
235:
236:
237:
238:
239:
240:
241:
242:
243:
244:
245:
246:
247:
248:
249:
250:
251:
252:
253:
254:
255:
256:
257:
258:
259:
260:
261:
262:
263:
264:
265:
266:
267:
268:
269:
270:
271:
272:
273:
274:
275:
276:
277:
278:

function IsFileInUse(const fName: TFileName): Boolean;
var
    HFileRes: HFILE;
 
begin
    Result := False;
    HFileRes := CreateFile(PChar(fName),
                GENERIC_READ or GENERIC_WRITE,
                0,
                nil,
                OPEN_EXISTING,
                FILE_ATTRIBUTE_NORMAL,
                0);
 
   Result := (HFileRes = INVALID_HANDLE_VALUE);
 
   if not Result then
       CloseHandle(HFileRes);
 
end;

                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20: