]>
Commit | Line | Data |
---|---|---|
ff7c6d11 XL |
1 | // Licensed under the Apache License, Version 2.0 |
2 | // <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license | |
3 | // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option. | |
4 | // All files in the project carrying such notice may not be copied, modified, or distributed | |
5 | // except according to those terms. | |
6 | //! ApiSet Contract for api-ms-win-core-file-l1 | |
7 | use shared::minwindef::{ | |
8 | BOOL, DWORD, FILETIME, LPCVOID, LPDWORD, LPFILETIME, LPVOID, PDWORD, PUCHAR, UCHAR, UINT, | |
9 | ULONG, WORD, | |
10 | }; | |
11 | use um::minwinbase::{ | |
12 | FILE_INFO_BY_HANDLE_CLASS, FINDEX_INFO_LEVELS, FINDEX_SEARCH_OPS, GET_FILEEX_INFO_LEVELS, | |
13 | LPOVERLAPPED, LPOVERLAPPED_COMPLETION_ROUTINE, LPSECURITY_ATTRIBUTES, LPWIN32_FIND_DATAA, | |
14 | LPWIN32_FIND_DATAW | |
15 | }; | |
16 | use um::winnt::{ | |
17 | BOOLEAN, CCHAR, FILE_ID_128, FILE_SEGMENT_ELEMENT, HANDLE, LARGE_INTEGER, LONG, LONGLONG, | |
18 | LPCSTR, LPCWSTR, LPSTR, LPWCH, LPWSTR, PLARGE_INTEGER, PLONG, PULARGE_INTEGER, PWSTR, | |
19 | ULONGLONG, WCHAR, | |
20 | }; | |
21 | pub const CREATE_NEW: DWORD = 1; | |
22 | pub const CREATE_ALWAYS: DWORD = 2; | |
23 | pub const OPEN_EXISTING: DWORD = 3; | |
24 | pub const OPEN_ALWAYS: DWORD = 4; | |
25 | pub const TRUNCATE_EXISTING: DWORD = 5; | |
26 | pub const INVALID_FILE_SIZE: DWORD = 0xFFFFFFFF; | |
27 | pub const INVALID_SET_FILE_POINTER: DWORD = 0xFFFFFFFF; | |
28 | pub const INVALID_FILE_ATTRIBUTES: DWORD = 0xFFFFFFFF; | |
29 | STRUCT!{struct WIN32_FILE_ATTRIBUTE_DATA { | |
30 | dwFileAttributes: DWORD, | |
31 | ftCreationTime: FILETIME, | |
32 | ftLastAccessTime: FILETIME, | |
33 | ftLastWriteTime: FILETIME, | |
34 | nFileSizeHigh: DWORD, | |
35 | nFileSizeLow: DWORD, | |
36 | }} | |
37 | pub type LPWIN32_FILE_ATTRIBUTE_DATA = *mut WIN32_FILE_ATTRIBUTE_DATA; | |
38 | STRUCT!{struct BY_HANDLE_FILE_INFORMATION { | |
39 | dwFileAttributes: DWORD, | |
40 | ftCreationTime: FILETIME, | |
41 | ftLastAccessTime: FILETIME, | |
42 | ftLastWriteTime: FILETIME, | |
43 | dwVolumeSerialNumber: DWORD, | |
44 | nFileSizeHigh: DWORD, | |
45 | nFileSizeLow: DWORD, | |
46 | nNumberOfLinks: DWORD, | |
47 | nFileIndexHigh: DWORD, | |
48 | nFileIndexLow: DWORD, | |
49 | }} | |
50 | pub type PBY_HANDLE_FILE_INFORMATION = *mut BY_HANDLE_FILE_INFORMATION; | |
51 | pub type LPBY_HANDLE_FILE_INFORMATION = *mut BY_HANDLE_FILE_INFORMATION; | |
52 | STRUCT!{struct CREATEFILE2_EXTENDED_PARAMETERS { | |
53 | dwSize: DWORD, | |
54 | dwFileAttributes: DWORD, | |
55 | dwFileFlags: DWORD, | |
56 | dwSecurityQosFlags: DWORD, | |
57 | lpSecurityAttributes: LPSECURITY_ATTRIBUTES, | |
58 | hTemplateFile: HANDLE, | |
59 | }} | |
60 | pub type PCREATEFILE2_EXTENDED_PARAMETERS = *mut CREATEFILE2_EXTENDED_PARAMETERS; | |
61 | pub type LPCREATEFILE2_EXTENDED_PARAMETERS = *mut CREATEFILE2_EXTENDED_PARAMETERS; | |
62 | ENUM!{enum PRIORITY_HINT { | |
63 | IoPriorityHintVeryLow = 0, | |
64 | IoPriorityHintLow = 1, | |
65 | IoPriorityHintNormal = 2, | |
66 | MaximumIoPriorityHintType = 3, | |
67 | }} | |
68 | STRUCT!{struct FILE_BASIC_INFO { | |
69 | CreationTime: LARGE_INTEGER, | |
70 | LastAccessTime: LARGE_INTEGER, | |
71 | LastWriteTime: LARGE_INTEGER, | |
72 | ChangeTime: LARGE_INTEGER, | |
73 | FileAttributes: DWORD, | |
74 | }} | |
75 | STRUCT!{struct FILE_STANDARD_INFO { | |
76 | AllocationSize: LARGE_INTEGER, | |
77 | EndOfFile: LARGE_INTEGER, | |
78 | NumberOfLinks: DWORD, | |
79 | DeletePending: BOOLEAN, | |
80 | Directory: BOOLEAN, | |
81 | }} | |
82 | STRUCT!{struct FILE_NAME_INFO { | |
83 | FileNameLength: DWORD, | |
8faf50e0 | 84 | FileName: [WCHAR; 1], |
ff7c6d11 XL |
85 | }} |
86 | STRUCT!{struct FILE_RENAME_INFO { | |
87 | ReplaceIfExists: BOOL, | |
88 | RootDirectory: HANDLE, | |
89 | FileNameLength: DWORD, | |
8faf50e0 | 90 | FileName: [WCHAR; 1], |
ff7c6d11 XL |
91 | }} |
92 | STRUCT!{struct FILE_DISPOSITION_INFO { | |
8faf50e0 | 93 | DeleteFile: BOOLEAN, |
ff7c6d11 XL |
94 | }} |
95 | STRUCT!{struct FILE_ALLOCATION_INFO { | |
96 | AllocationSize: LARGE_INTEGER, | |
97 | }} | |
98 | STRUCT!{struct FILE_END_OF_FILE_INFO { | |
99 | EndOfFile: LARGE_INTEGER, | |
100 | }} | |
101 | STRUCT!{struct FILE_STREAM_INFO { | |
102 | NextEntryOffset: DWORD, | |
103 | StreamNameLength: DWORD, | |
8faf50e0 XL |
104 | StreamSize: LARGE_INTEGER, |
105 | StreamAllocationSize: LARGE_INTEGER, | |
106 | StreamName: [WCHAR; 1], | |
ff7c6d11 XL |
107 | }} |
108 | STRUCT!{struct FILE_COMPRESSION_INFO { | |
109 | CompressedFileSize: LARGE_INTEGER, | |
110 | CompressionFormat: WORD, | |
111 | CompressionUnitShift: UCHAR, | |
112 | ChunkShift: UCHAR, | |
113 | ClusterShift: UCHAR, | |
114 | Reserved: [UCHAR; 3], | |
115 | }} | |
116 | STRUCT!{struct FILE_ATTRIBUTE_TAG_INFO { | |
117 | NextEntryOffset: DWORD, | |
118 | ReparseTag: DWORD, | |
119 | }} | |
120 | STRUCT!{struct FILE_ID_BOTH_DIR_INFO { | |
121 | NextEntryOffset: DWORD, | |
122 | FileIndex: DWORD, | |
123 | CreationTime: LARGE_INTEGER, | |
124 | LastAccessTime: LARGE_INTEGER, | |
125 | LastWriteTime: LARGE_INTEGER, | |
126 | ChangeTime: LARGE_INTEGER, | |
127 | EndOfFile: LARGE_INTEGER, | |
128 | AllocationSize: LARGE_INTEGER, | |
129 | FileAttributes: DWORD, | |
130 | FileNameLength: DWORD, | |
131 | EaSize: DWORD, | |
132 | ShortNameLength: CCHAR, | |
133 | ShortName: [WCHAR; 12], | |
134 | FileId: LARGE_INTEGER, | |
8faf50e0 | 135 | FileName: [WCHAR; 1], |
ff7c6d11 XL |
136 | }} |
137 | STRUCT!{struct FILE_IO_PRIORITY_HINT_INFO { | |
138 | PriorityHint: PRIORITY_HINT, | |
139 | }} | |
140 | STRUCT!{struct FILE_FULL_DIR_INFO { | |
141 | NextEntryOffset: ULONG, | |
142 | FileIndex: ULONG, | |
143 | CreationTime: LARGE_INTEGER, | |
144 | LastAccessTime: LARGE_INTEGER, | |
145 | LastWriteTime: LARGE_INTEGER, | |
146 | ChangeTime: LARGE_INTEGER, | |
147 | EndOfFile: LARGE_INTEGER, | |
148 | AllocationSize: LARGE_INTEGER, | |
149 | FileAttributes: ULONG, | |
150 | FileNameLength: ULONG, | |
151 | EaSize: ULONG, | |
8faf50e0 | 152 | FileName: [WCHAR; 1], |
ff7c6d11 XL |
153 | }} |
154 | STRUCT!{struct FILE_STORAGE_INFO { | |
155 | LogicalBytesPerSector: ULONG, | |
156 | PhysicalBytesPerSectorForAtomicity: ULONG, | |
157 | PhysicalBytesPerSectorForPerformance: ULONG, | |
158 | FileSystemEffectivePhysicalBytesPerSectorForAtomicity: ULONG, | |
159 | Flags: ULONG, | |
160 | ByteOffsetForSectorAlignment: ULONG, | |
161 | ByteOffsetForPartitionAlignment: ULONG, | |
162 | }} | |
163 | STRUCT!{struct FILE_ALIGNMENT_INFO { | |
164 | AlignmentRequirement: ULONG, | |
165 | }} | |
166 | STRUCT!{struct FILE_ID_INFO { | |
167 | VolumeSerialNumber: ULONGLONG, | |
168 | FileId: FILE_ID_128, | |
169 | }} | |
170 | extern "system" { | |
171 | pub fn CompareFileTime( | |
172 | lpFileTime1: *const FILETIME, | |
60c5eb7d | 173 | lpFileTime2: *const FILETIME, |
ff7c6d11 XL |
174 | ) -> LONG; |
175 | pub fn CreateDirectoryA( | |
176 | lpPathName: LPCSTR, | |
177 | lpSecurityAttributes: LPSECURITY_ATTRIBUTES, | |
178 | ) -> BOOL; | |
179 | pub fn CreateDirectoryW( | |
180 | lpPathName: LPCWSTR, | |
181 | lpSecurityAttributes: LPSECURITY_ATTRIBUTES, | |
182 | ) -> BOOL; | |
183 | pub fn CreateFileA( | |
184 | lpFileName: LPCSTR, | |
185 | dwDesiredAccess: DWORD, | |
186 | dwShareMode: DWORD, | |
187 | lpSecurityAttributes: LPSECURITY_ATTRIBUTES, | |
188 | dwCreationDisposition: DWORD, | |
189 | dwFlagsAndAttributes: DWORD, | |
190 | hTemplateFile: HANDLE, | |
191 | ) -> HANDLE; | |
192 | pub fn CreateFileW( | |
193 | lpFileName: LPCWSTR, | |
194 | dwDesiredAccess: DWORD, | |
195 | dwShareMode: DWORD, | |
196 | lpSecurityAttributes: LPSECURITY_ATTRIBUTES, | |
197 | dwCreationDisposition: DWORD, | |
198 | dwFlagsAndAttributes: DWORD, | |
199 | hTemplateFile: HANDLE, | |
200 | ) -> HANDLE; | |
201 | pub fn DefineDosDeviceW( | |
202 | dwFlags: DWORD, | |
203 | lpDeviceName: LPCWSTR, | |
60c5eb7d | 204 | lpTargetPath: LPCWSTR, |
ff7c6d11 XL |
205 | ) -> BOOL; |
206 | pub fn DeleteFileA( | |
60c5eb7d | 207 | lpFileName: LPCSTR, |
ff7c6d11 XL |
208 | ) -> BOOL; |
209 | pub fn DeleteFileW( | |
60c5eb7d | 210 | lpFileName: LPCWSTR, |
ff7c6d11 XL |
211 | ) -> BOOL; |
212 | pub fn DeleteVolumeMountPointW( | |
60c5eb7d | 213 | lpszVolumeMountPoint: LPCWSTR, |
ff7c6d11 XL |
214 | ) -> BOOL; |
215 | pub fn FileTimeToLocalFileTime( | |
216 | lpFileTime: *const FILETIME, | |
217 | lpLocalFileTime: LPFILETIME, | |
218 | ) -> BOOL; | |
219 | pub fn FindClose( | |
60c5eb7d | 220 | hFindFile: HANDLE, |
ff7c6d11 XL |
221 | ) -> BOOL; |
222 | pub fn FindCloseChangeNotification( | |
60c5eb7d | 223 | hChangeHandle: HANDLE, |
ff7c6d11 XL |
224 | ) -> BOOL; |
225 | pub fn FindFirstChangeNotificationA( | |
226 | lpPathName: LPCSTR, | |
227 | bWatchSubtree: BOOL, | |
228 | dwNotifyFilter: DWORD, | |
229 | ) -> HANDLE; | |
230 | pub fn FindFirstChangeNotificationW( | |
231 | lpPathName: LPCWSTR, | |
232 | bWatchSubtree: BOOL, | |
233 | dwNotifyFilter: DWORD, | |
234 | ) -> HANDLE; | |
235 | pub fn FindFirstFileA( | |
236 | lpFileName: LPCSTR, | |
60c5eb7d | 237 | lpFindFileData: LPWIN32_FIND_DATAA, |
ff7c6d11 XL |
238 | ) -> HANDLE; |
239 | pub fn FindFirstFileW( | |
240 | lpFileName: LPCWSTR, | |
60c5eb7d | 241 | lpFindFileData: LPWIN32_FIND_DATAW, |
ff7c6d11 XL |
242 | ) -> HANDLE; |
243 | pub fn FindFirstFileExA( | |
244 | lpFileName: LPCSTR, | |
245 | fInfoLevelId: FINDEX_INFO_LEVELS, | |
246 | lpFindFileData: LPVOID, | |
247 | fSearchOp: FINDEX_SEARCH_OPS, | |
248 | lpSearchFilter: LPVOID, | |
249 | dwAdditionalFlags: DWORD, | |
250 | ) -> HANDLE; | |
251 | pub fn FindFirstFileExW( | |
252 | lpFileName: LPCWSTR, | |
253 | fInfoLevelId: FINDEX_INFO_LEVELS, | |
254 | lpFindFileData: LPVOID, | |
255 | fSearchOp: FINDEX_SEARCH_OPS, | |
256 | lpSearchFilter: LPVOID, | |
257 | dwAdditionalFlags: DWORD, | |
258 | ) -> HANDLE; | |
259 | pub fn FindFirstVolumeW( | |
260 | lpszVolumeName: LPWSTR, | |
60c5eb7d | 261 | cchBufferLength: DWORD, |
ff7c6d11 XL |
262 | ) -> HANDLE; |
263 | pub fn FindNextChangeNotification( | |
60c5eb7d | 264 | hChangeHandle: HANDLE, |
ff7c6d11 XL |
265 | ) -> BOOL; |
266 | pub fn FindNextFileA( | |
267 | hFindFile: HANDLE, | |
60c5eb7d | 268 | lpFindFileData: LPWIN32_FIND_DATAA, |
ff7c6d11 XL |
269 | ) -> BOOL; |
270 | pub fn FindNextFileW( | |
271 | hFindFile: HANDLE, | |
60c5eb7d | 272 | lpFindFileData: LPWIN32_FIND_DATAW, |
ff7c6d11 XL |
273 | ) -> BOOL; |
274 | pub fn FindNextVolumeW( | |
275 | hFindVolume: HANDLE, | |
276 | lpszVolumeName: LPWSTR, | |
277 | cchBufferLength: DWORD, | |
278 | ) -> BOOL; | |
279 | pub fn FindVolumeClose( | |
60c5eb7d | 280 | hFindVolume: HANDLE, |
ff7c6d11 XL |
281 | ) -> BOOL; |
282 | pub fn FlushFileBuffers( | |
60c5eb7d | 283 | hFile: HANDLE, |
ff7c6d11 XL |
284 | ) -> BOOL; |
285 | pub fn GetDiskFreeSpaceA( | |
286 | lpRootPathName: LPCSTR, | |
287 | lpSectorsPerCluster: LPDWORD, | |
288 | lpBytesPerSector: LPDWORD, | |
289 | lpNumberOfFreeClusters: LPDWORD, | |
290 | lpTotalNumberOfClusters: LPDWORD, | |
291 | ) -> BOOL; | |
292 | pub fn GetDiskFreeSpaceW( | |
293 | lpRootPathName: LPCWSTR, | |
294 | lpSectorsPerCluster: LPDWORD, | |
295 | lpBytesPerSector: LPDWORD, | |
296 | lpNumberOfFreeClusters: LPDWORD, | |
297 | lpTotalNumberOfClusters: LPDWORD, | |
298 | ) -> BOOL; | |
299 | pub fn GetDiskFreeSpaceExA( | |
300 | lpDirectoryName: LPCSTR, | |
301 | lpFreeBytesAvailableToCaller: PULARGE_INTEGER, | |
302 | lpTotalNumberOfBytes: PULARGE_INTEGER, | |
303 | lpTotalNumberOfFreeBytes: PULARGE_INTEGER, | |
304 | ) -> BOOL; | |
305 | pub fn GetDiskFreeSpaceExW( | |
306 | lpDirectoryName: LPCWSTR, | |
307 | lpFreeBytesAvailableToCaller: PULARGE_INTEGER, | |
308 | lpTotalNumberOfBytes: PULARGE_INTEGER, | |
309 | lpTotalNumberOfFreeBytes: PULARGE_INTEGER, | |
310 | ) -> BOOL; | |
311 | pub fn GetDriveTypeA( | |
60c5eb7d | 312 | lpRootPathName: LPCSTR, |
ff7c6d11 XL |
313 | ) -> UINT; |
314 | pub fn GetDriveTypeW( | |
60c5eb7d | 315 | lpRootPathName: LPCWSTR, |
ff7c6d11 XL |
316 | ) -> UINT; |
317 | pub fn GetFileAttributesA( | |
60c5eb7d | 318 | lpFileName: LPCSTR, |
ff7c6d11 XL |
319 | ) -> DWORD; |
320 | pub fn GetFileAttributesW( | |
60c5eb7d | 321 | lpFileName: LPCWSTR, |
ff7c6d11 XL |
322 | ) -> DWORD; |
323 | pub fn GetFileAttributesExA( | |
324 | lpFileName: LPCSTR, | |
325 | fInfoLevelId: GET_FILEEX_INFO_LEVELS, | |
326 | lpFileInformation: LPVOID, | |
327 | ) -> BOOL; | |
328 | pub fn GetFileAttributesExW( | |
329 | lpFileName: LPCWSTR, | |
330 | fInfoLevelId: GET_FILEEX_INFO_LEVELS, | |
331 | lpFileInformation: LPVOID, | |
332 | ) -> BOOL; | |
333 | pub fn GetFileInformationByHandle( | |
334 | hFile: HANDLE, | |
335 | lpFileInformation: LPBY_HANDLE_FILE_INFORMATION, | |
336 | ) -> BOOL; | |
337 | pub fn GetFileSize( | |
338 | hFile: HANDLE, | |
60c5eb7d | 339 | lpFileSizeHigh: LPDWORD, |
ff7c6d11 XL |
340 | ) -> DWORD; |
341 | pub fn GetFileSizeEx( | |
342 | hFile: HANDLE, | |
60c5eb7d | 343 | lpFileSize: PLARGE_INTEGER, |
ff7c6d11 XL |
344 | ) -> BOOL; |
345 | pub fn GetFileType( | |
60c5eb7d | 346 | hFile: HANDLE, |
ff7c6d11 XL |
347 | ) -> DWORD; |
348 | pub fn GetFinalPathNameByHandleA( | |
349 | hFile: HANDLE, | |
350 | lpszFilePath: LPSTR, | |
351 | cchFilePath: DWORD, | |
352 | dwFlags: DWORD, | |
353 | ) -> DWORD; | |
354 | pub fn GetFinalPathNameByHandleW( | |
355 | hFile: HANDLE, | |
356 | lpszFilePath: LPWSTR, | |
357 | cchFilePath: DWORD, | |
358 | dwFlags: DWORD, | |
359 | ) -> DWORD; | |
360 | pub fn GetFileTime( | |
361 | hFile: HANDLE, | |
362 | lpCreationTime: LPFILETIME, | |
363 | lpLastAccessTime: LPFILETIME, | |
364 | lpLastWriteTime: LPFILETIME, | |
365 | ) -> BOOL; | |
366 | pub fn GetFullPathNameW( | |
367 | lpFileName: LPCWSTR, | |
368 | nBufferLength: DWORD, | |
369 | lpBuffer: LPWSTR, | |
370 | lpFilePart: *mut LPWSTR, | |
371 | ) -> DWORD; | |
372 | pub fn GetFullPathNameA( | |
373 | lpFileName: LPCSTR, | |
374 | nBufferLength: DWORD, | |
375 | lpBuffer: LPSTR, | |
376 | lpFilePart: *mut LPSTR, | |
377 | ) -> DWORD; | |
378 | pub fn GetLogicalDrives() -> DWORD; | |
379 | pub fn GetLogicalDriveStringsW( | |
380 | nBufferLength: DWORD, | |
60c5eb7d | 381 | lpBuffer: LPWSTR, |
ff7c6d11 XL |
382 | ) -> DWORD; |
383 | pub fn GetLongPathNameA( | |
384 | lpszShortPath: LPCSTR, | |
385 | lpszLongPath: LPSTR, | |
60c5eb7d | 386 | cchBuffer: DWORD, |
ff7c6d11 XL |
387 | ) -> DWORD; |
388 | pub fn GetLongPathNameW( | |
389 | lpszShortPath: LPCWSTR, | |
390 | lpszLongPath: LPWSTR, | |
391 | cchBuffer: DWORD, | |
392 | ) -> DWORD; | |
393 | pub fn GetShortPathNameW( | |
394 | lpszLongPath: LPCWSTR, | |
395 | lpszShortPath: LPWSTR, | |
396 | cchBuffer: DWORD, | |
397 | ) -> DWORD; | |
398 | pub fn GetTempFileNameW( | |
399 | lpPathName: LPCWSTR, | |
400 | lpPrefixString: LPCWSTR, | |
401 | uUnique: UINT, | |
402 | lpTempFileName: LPWSTR, | |
403 | ) -> UINT; | |
404 | pub fn GetVolumeInformationByHandleW( | |
405 | hFile: HANDLE, | |
406 | lpVolumeNameBuffer: LPWSTR, | |
407 | nVolumeNameSize: DWORD, | |
408 | lpVolumeSerialNumber: LPDWORD, | |
409 | lpMaximumComponentLength: LPDWORD, | |
410 | lpFileSystemFlags: LPDWORD, | |
411 | lpFileSystemNameBuffer: LPWSTR, | |
412 | nFileSystemNameSize: DWORD, | |
413 | ) -> BOOL; | |
414 | pub fn GetVolumeInformationW( | |
415 | lpRootPathName: LPCWSTR, | |
416 | lpVolumeNameBuffer: LPWSTR, | |
417 | nVolumeNameSize: DWORD, | |
418 | lpVolumeSerialNumber: LPDWORD, | |
419 | lpMaximumComponentLength: LPDWORD, | |
420 | lpFileSystemFlags: LPDWORD, | |
421 | lpFileSystemNameBuffer: LPWSTR, | |
422 | nFileSystemNameSize: DWORD, | |
423 | ) -> BOOL; | |
424 | pub fn GetVolumePathNameW( | |
425 | lpszFileName: LPCWSTR, | |
426 | lpszVolumePathName: LPWSTR, | |
427 | cchBufferLength: DWORD, | |
428 | ) -> BOOL; | |
429 | pub fn LocalFileTimeToFileTime( | |
430 | lpLocalFileTime: *const FILETIME, | |
431 | lpFileTime: LPFILETIME, | |
432 | ) -> BOOL; | |
433 | pub fn LockFile( | |
434 | hFile: HANDLE, | |
435 | dwFileOffsetLow: DWORD, | |
436 | dwFileOffsetHigh: DWORD, | |
437 | nNumberOfBytesToLockLow: DWORD, | |
438 | nNumberOfBytesToLockHigh: DWORD, | |
439 | ) -> BOOL; | |
440 | pub fn LockFileEx( | |
441 | hFile: HANDLE, | |
442 | dwFlags: DWORD, | |
443 | dwReserved: DWORD, | |
444 | nNumberOfBytesToLockLow: DWORD, | |
445 | nNumberOfBytesToLockHigh: DWORD, | |
446 | lpOverlapped: LPOVERLAPPED, | |
447 | ) -> BOOL; | |
448 | pub fn QueryDosDeviceW( | |
449 | lpDeviceName: LPCWSTR, | |
450 | lpTargetPath: LPWSTR, | |
60c5eb7d | 451 | ucchMax: DWORD, |
ff7c6d11 XL |
452 | ) -> DWORD; |
453 | pub fn ReadFile( | |
454 | hFile: HANDLE, | |
455 | lpBuffer: LPVOID, | |
456 | nNumberOfBytesToRead: DWORD, | |
457 | lpNumberOfBytesRead: LPDWORD, | |
458 | lpOverlapped: LPOVERLAPPED, | |
459 | ) -> BOOL; | |
460 | pub fn ReadFileEx( | |
461 | hFile: HANDLE, | |
462 | lpBuffer: LPVOID, | |
463 | nNumberOfBytesToRead: DWORD, | |
464 | lpOverlapped: LPOVERLAPPED, | |
465 | lpCompletionRoutine: LPOVERLAPPED_COMPLETION_ROUTINE, | |
466 | ) -> BOOL; | |
467 | pub fn ReadFileScatter( | |
468 | hFile: HANDLE, | |
469 | aSegmentArray: *mut FILE_SEGMENT_ELEMENT, | |
470 | nNumberOfBytesToRead: DWORD, | |
471 | lpReserved: LPDWORD, | |
472 | lpOverlapped: LPOVERLAPPED, | |
473 | ) -> BOOL; | |
474 | pub fn RemoveDirectoryA( | |
60c5eb7d | 475 | lpPathName: LPCSTR, |
ff7c6d11 XL |
476 | ) -> BOOL; |
477 | pub fn RemoveDirectoryW( | |
60c5eb7d | 478 | lpPathName: LPCWSTR, |
ff7c6d11 XL |
479 | ) -> BOOL; |
480 | pub fn SetEndOfFile( | |
60c5eb7d | 481 | hFile: HANDLE, |
ff7c6d11 XL |
482 | ) -> BOOL; |
483 | pub fn SetFileAttributesA( | |
484 | lpFileName: LPCSTR, | |
60c5eb7d | 485 | dwFileAttributes: DWORD, |
ff7c6d11 XL |
486 | ) -> BOOL; |
487 | pub fn SetFileAttributesW( | |
488 | lpFileName: LPCWSTR, | |
60c5eb7d | 489 | dwFileAttributes: DWORD, |
ff7c6d11 XL |
490 | ) -> BOOL; |
491 | pub fn SetFileInformationByHandle( | |
492 | hFile: HANDLE, | |
493 | FileInformationClass: FILE_INFO_BY_HANDLE_CLASS, | |
494 | lpFileInformation: LPVOID, | |
495 | dwBufferSize: DWORD, | |
496 | ) -> BOOL; | |
497 | pub fn SetFilePointer( | |
498 | hFile: HANDLE, | |
499 | lDistanceToMove: LONG, | |
500 | lpDistanceToMoveHigh: PLONG, | |
501 | dwMoveMethod: DWORD, | |
502 | ) -> DWORD; | |
503 | pub fn SetFilePointerEx( | |
504 | hFile: HANDLE, | |
505 | liDistanceToMove: LARGE_INTEGER, | |
506 | lpNewFilePointer: PLARGE_INTEGER, | |
507 | dwMoveMethod: DWORD, | |
508 | ) -> BOOL; | |
509 | pub fn SetFileTime( | |
510 | hFile: HANDLE, | |
511 | lpCreationTime: *const FILETIME, | |
512 | lpLastAccessTime: *const FILETIME, | |
513 | lpLastWriteTime: *const FILETIME, | |
514 | ) -> BOOL; | |
515 | pub fn SetFileValidData( | |
516 | hFile: HANDLE, | |
60c5eb7d | 517 | ValidDataLength: LONGLONG, |
ff7c6d11 XL |
518 | ) -> BOOL; |
519 | pub fn UnlockFile( | |
520 | hFile: HANDLE, | |
521 | dwFileOffsetLow: DWORD, | |
522 | dwFileOffsetHigh: DWORD, | |
523 | nNumberOfBytesToUnlockLow: DWORD, | |
524 | nNumberOfBytesToUnlockHigh: DWORD, | |
525 | ) -> BOOL; | |
526 | pub fn UnlockFileEx( | |
527 | hFile: HANDLE, | |
528 | dwReserved: DWORD, | |
529 | nNumberOfBytesToUnlockLow: DWORD, | |
530 | nNumberOfBytesToUnlockHigh: DWORD, | |
531 | lpOverlapped: LPOVERLAPPED, | |
532 | ) -> BOOL; | |
533 | pub fn WriteFile( | |
534 | hFile: HANDLE, | |
535 | lpBuffer: LPCVOID, | |
536 | nNumberOfBytesToWrite: DWORD, | |
537 | lpNumberOfBytesWritten: LPDWORD, | |
538 | lpOverlapped: LPOVERLAPPED, | |
539 | ) -> BOOL; | |
540 | pub fn WriteFileEx( | |
541 | hFile: HANDLE, | |
542 | lpBuffer: LPCVOID, | |
543 | nNumberOfBytesToWrite: DWORD, | |
544 | lpOverlapped: LPOVERLAPPED, | |
545 | lpCompletionRoutine: LPOVERLAPPED_COMPLETION_ROUTINE, | |
546 | ) -> BOOL; | |
547 | pub fn WriteFileGather( | |
548 | hFile: HANDLE, | |
549 | aSegmentArray: *mut FILE_SEGMENT_ELEMENT, | |
550 | nNumberOfBytesToWrite: DWORD, | |
551 | lpReserved: LPDWORD, | |
552 | lpOverlapped: LPOVERLAPPED, | |
553 | ) -> BOOL; | |
554 | pub fn GetTempPathW( | |
555 | nBufferLength: DWORD, | |
60c5eb7d | 556 | lpBuffer: LPWSTR, |
ff7c6d11 XL |
557 | ) -> DWORD; |
558 | pub fn GetVolumeNameForVolumeMountPointW( | |
559 | lpszVolumeMountPoint: LPCWSTR, | |
560 | lpszVolumeName: LPWSTR, | |
561 | cchBufferLength: DWORD, | |
562 | ) -> BOOL; | |
563 | pub fn GetVolumePathNamesForVolumeNameW( | |
564 | lpszVolumeName: LPCWSTR, | |
565 | lpszVolumePathNames: LPWCH, | |
566 | cchBufferLength: DWORD, | |
567 | lpcchReturnLength: PDWORD, | |
568 | ) -> BOOL; | |
569 | pub fn CreateFile2( | |
570 | lpFileName: LPCWSTR, | |
571 | dwDesiredAccess: DWORD, | |
572 | dwShareMode: DWORD, | |
573 | dwCreationDisposition: DWORD, | |
574 | pCreateExParams: LPCREATEFILE2_EXTENDED_PARAMETERS, | |
575 | ) -> HANDLE; | |
576 | pub fn SetFileIoOverlappedRange( | |
577 | FileHandle: HANDLE, | |
578 | OverlappedRangeStart: PUCHAR, | |
579 | Length: ULONG, | |
580 | ) -> BOOL; | |
581 | pub fn GetCompressedFileSizeA( | |
582 | lpFileName: LPCSTR, | |
60c5eb7d | 583 | lpFileSizeHigh: LPDWORD, |
ff7c6d11 XL |
584 | ) -> DWORD; |
585 | pub fn GetCompressedFileSizeW( | |
586 | lpFileName: LPCWSTR, | |
60c5eb7d | 587 | lpFileSizeHigh: LPDWORD, |
ff7c6d11 XL |
588 | ) -> DWORD; |
589 | } | |
590 | ENUM!{enum STREAM_INFO_LEVELS { | |
591 | FindStreamInfoStandard, | |
592 | FindStreamInfoMaxInfoLevel, | |
593 | }} | |
594 | extern "system" { | |
595 | pub fn FindFirstStreamW( | |
596 | lpFileName: LPCWSTR, | |
597 | InfoLevel: STREAM_INFO_LEVELS, | |
598 | lpFindStreamData: LPVOID, | |
599 | dwFlags: DWORD, | |
600 | ) -> HANDLE; | |
601 | pub fn FindNextStreamW( | |
602 | hFindStream: HANDLE, | |
60c5eb7d | 603 | lpFindStreamData: LPVOID, |
ff7c6d11 XL |
604 | ) -> BOOL; |
605 | pub fn AreFileApisANSI() -> BOOL; | |
606 | pub fn GetTempPathA( | |
607 | nBufferLength: DWORD, | |
60c5eb7d | 608 | lpBuffer: LPSTR, |
ff7c6d11 XL |
609 | ) -> DWORD; |
610 | pub fn FindFirstFileNameW( | |
611 | lpFileName: LPCWSTR, | |
612 | dwFlags: DWORD, | |
613 | StringLength: LPDWORD, | |
614 | LinkName: PWSTR, | |
615 | ) -> HANDLE; | |
616 | pub fn FindNextFileNameW( | |
617 | hFindStream: HANDLE, | |
618 | StringLength: LPDWORD, | |
60c5eb7d | 619 | LinkName: PWSTR, |
ff7c6d11 XL |
620 | ) -> BOOL; |
621 | pub fn GetVolumeInformationA( | |
622 | lpRootPathName: LPCSTR, | |
623 | lpVolumeNameBuffer: LPSTR, | |
624 | nVolumeNameSize: DWORD, | |
625 | lpVolumeSerialNumber: LPDWORD, | |
626 | lpMaximumComponentLength: LPDWORD, | |
627 | lpFileSystemFlags: LPDWORD, | |
628 | lpFileSystemNameBuffer: LPSTR, | |
629 | nFileSystemNameSize: DWORD, | |
630 | ) -> BOOL; | |
631 | pub fn GetTempFileNameA( | |
632 | lpPathName: LPCSTR, | |
633 | lpPrefixString: LPCSTR, | |
634 | uUnique: UINT, | |
635 | lpTempFileName: LPSTR, | |
636 | ) -> UINT; | |
637 | pub fn SetFileApisToOEM(); | |
638 | pub fn SetFileApisToANSI(); | |
639 | } |