92c45558e6fcd520c7309e2dadaa952c2d3999aa
[reactos.git] / reactos / dll / win32 / kernel32 / client / file / copy.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS system libraries
4 * FILE: dll/win32/kernel32/client/file/copy.c
5 * PURPOSE: Copying files
6 * PROGRAMMER: Ariadne (ariadne@xs4all.nl)
7 * UPDATE HISTORY:
8 * 01/11/98 Created
9 * 07/02/99 Moved to separate file
10 */
11
12 /* INCLUDES ****************************************************************/
13
14 #include <k32.h>
15 #define NDEBUG
16 #include <debug.h>
17
18 #if DBG
19 DEBUG_CHANNEL(kernel32file);
20 #endif
21
22 /* FUNCTIONS ****************************************************************/
23
24
25 static NTSTATUS
26 CopyLoop (
27 HANDLE FileHandleSource,
28 HANDLE FileHandleDest,
29 LARGE_INTEGER SourceFileSize,
30 LPPROGRESS_ROUTINE lpProgressRoutine,
31 LPVOID lpData,
32 BOOL *pbCancel,
33 BOOL *KeepDest
34 )
35 {
36 NTSTATUS errCode;
37 IO_STATUS_BLOCK IoStatusBlock;
38 UCHAR *lpBuffer = NULL;
39 SIZE_T RegionSize = 0x10000;
40 LARGE_INTEGER BytesCopied;
41 DWORD CallbackReason;
42 DWORD ProgressResult;
43 BOOL EndOfFileFound;
44
45 *KeepDest = FALSE;
46 errCode = NtAllocateVirtualMemory(NtCurrentProcess(),
47 (PVOID *)&lpBuffer,
48 0,
49 &RegionSize,
50 MEM_RESERVE | MEM_COMMIT,
51 PAGE_READWRITE);
52
53 if (NT_SUCCESS(errCode))
54 {
55 BytesCopied.QuadPart = 0;
56 EndOfFileFound = FALSE;
57 CallbackReason = CALLBACK_STREAM_SWITCH;
58 while (! EndOfFileFound &&
59 NT_SUCCESS(errCode) &&
60 (NULL == pbCancel || ! *pbCancel))
61 {
62 if (NULL != lpProgressRoutine)
63 {
64 ProgressResult = (*lpProgressRoutine)(SourceFileSize,
65 BytesCopied,
66 SourceFileSize,
67 BytesCopied,
68 0,
69 CallbackReason,
70 FileHandleSource,
71 FileHandleDest,
72 lpData);
73 switch (ProgressResult)
74 {
75 case PROGRESS_CANCEL:
76 TRACE("Progress callback requested cancel\n");
77 errCode = STATUS_REQUEST_ABORTED;
78 break;
79 case PROGRESS_STOP:
80 TRACE("Progress callback requested stop\n");
81 errCode = STATUS_REQUEST_ABORTED;
82 *KeepDest = TRUE;
83 break;
84 case PROGRESS_QUIET:
85 lpProgressRoutine = NULL;
86 break;
87 case PROGRESS_CONTINUE:
88 default:
89 break;
90 }
91 CallbackReason = CALLBACK_CHUNK_FINISHED;
92 }
93 if (NT_SUCCESS(errCode))
94 {
95 errCode = NtReadFile(FileHandleSource,
96 NULL,
97 NULL,
98 NULL,
99 (PIO_STATUS_BLOCK)&IoStatusBlock,
100 lpBuffer,
101 RegionSize,
102 NULL,
103 NULL);
104 /* With sync read, 0 length + status success mean EOF:
105 * https://msdn.microsoft.com/en-us/library/windows/desktop/aa365467(v=vs.85).aspx
106 */
107 if (NT_SUCCESS(errCode) && IoStatusBlock.Information == 0)
108 {
109 errCode = STATUS_END_OF_FILE;
110 }
111 if (NT_SUCCESS(errCode) && (NULL == pbCancel || ! *pbCancel))
112 {
113 errCode = NtWriteFile(FileHandleDest,
114 NULL,
115 NULL,
116 NULL,
117 (PIO_STATUS_BLOCK)&IoStatusBlock,
118 lpBuffer,
119 IoStatusBlock.Information,
120 NULL,
121 NULL);
122 if (NT_SUCCESS(errCode))
123 {
124 BytesCopied.QuadPart += IoStatusBlock.Information;
125 }
126 else
127 {
128 WARN("Error 0x%08x reading writing to dest\n", errCode);
129 }
130 }
131 else if (!NT_SUCCESS(errCode))
132 {
133 if (STATUS_END_OF_FILE == errCode)
134 {
135 EndOfFileFound = TRUE;
136 errCode = STATUS_SUCCESS;
137 }
138 else
139 {
140 WARN("Error 0x%08x reading from source\n", errCode);
141 }
142 }
143 }
144 }
145
146 if (! EndOfFileFound && (NULL != pbCancel && *pbCancel))
147 {
148 TRACE("User requested cancel\n");
149 errCode = STATUS_REQUEST_ABORTED;
150 }
151
152 NtFreeVirtualMemory(NtCurrentProcess(),
153 (PVOID *)&lpBuffer,
154 &RegionSize,
155 MEM_RELEASE);
156 }
157 else
158 {
159 TRACE("Error 0x%08x allocating buffer of %lu bytes\n", errCode, RegionSize);
160 }
161
162 return errCode;
163 }
164
165 static NTSTATUS
166 SetLastWriteTime(
167 HANDLE FileHandle,
168 LARGE_INTEGER LastWriteTime
169 )
170 {
171 NTSTATUS errCode = STATUS_SUCCESS;
172 IO_STATUS_BLOCK IoStatusBlock;
173 FILE_BASIC_INFORMATION FileBasic;
174
175 errCode = NtQueryInformationFile (FileHandle,
176 &IoStatusBlock,
177 &FileBasic,
178 sizeof(FILE_BASIC_INFORMATION),
179 FileBasicInformation);
180 if (!NT_SUCCESS(errCode))
181 {
182 WARN("Error 0x%08x obtaining FileBasicInformation\n", errCode);
183 }
184 else
185 {
186 FileBasic.LastWriteTime.QuadPart = LastWriteTime.QuadPart;
187 errCode = NtSetInformationFile (FileHandle,
188 &IoStatusBlock,
189 &FileBasic,
190 sizeof(FILE_BASIC_INFORMATION),
191 FileBasicInformation);
192 if (!NT_SUCCESS(errCode))
193 {
194 WARN("Error 0x%0x setting LastWriteTime\n", errCode);
195 }
196 }
197
198 return errCode;
199 }
200
201 BOOL
202 BasepCopyFileExW(IN LPCWSTR lpExistingFileName,
203 IN LPCWSTR lpNewFileName,
204 IN LPPROGRESS_ROUTINE lpProgressRoutine OPTIONAL,
205 IN LPVOID lpData OPTIONAL,
206 IN LPBOOL pbCancel OPTIONAL,
207 IN DWORD dwCopyFlags,
208 IN DWORD dwBasepFlags,
209 OUT LPHANDLE lpExistingHandle,
210 OUT LPHANDLE lpNewHandle)
211 {
212 NTSTATUS errCode;
213 HANDLE FileHandleSource, FileHandleDest;
214 IO_STATUS_BLOCK IoStatusBlock;
215 FILE_STANDARD_INFORMATION FileStandard;
216 FILE_BASIC_INFORMATION FileBasic;
217 BOOL RC = FALSE;
218 BOOL KeepDestOnError = FALSE;
219 DWORD SystemError;
220
221 FileHandleSource = CreateFileW(lpExistingFileName,
222 GENERIC_READ,
223 FILE_SHARE_READ | FILE_SHARE_WRITE,
224 NULL,
225 OPEN_EXISTING,
226 FILE_ATTRIBUTE_NORMAL|FILE_FLAG_NO_BUFFERING,
227 NULL);
228 if (INVALID_HANDLE_VALUE != FileHandleSource)
229 {
230 errCode = NtQueryInformationFile(FileHandleSource,
231 &IoStatusBlock,
232 &FileStandard,
233 sizeof(FILE_STANDARD_INFORMATION),
234 FileStandardInformation);
235 if (!NT_SUCCESS(errCode))
236 {
237 TRACE("Status 0x%08x obtaining FileStandardInformation for source\n", errCode);
238 BaseSetLastNTError(errCode);
239 }
240 else
241 {
242 errCode = NtQueryInformationFile(FileHandleSource,
243 &IoStatusBlock,&FileBasic,
244 sizeof(FILE_BASIC_INFORMATION),
245 FileBasicInformation);
246 if (!NT_SUCCESS(errCode))
247 {
248 TRACE("Status 0x%08x obtaining FileBasicInformation for source\n", errCode);
249 BaseSetLastNTError(errCode);
250 }
251 else
252 {
253 FileHandleDest = CreateFileW(lpNewFileName,
254 GENERIC_WRITE,
255 FILE_SHARE_WRITE,
256 NULL,
257 dwCopyFlags ? CREATE_NEW : CREATE_ALWAYS,
258 FileBasic.FileAttributes,
259 NULL);
260 if (INVALID_HANDLE_VALUE != FileHandleDest)
261 {
262 errCode = CopyLoop(FileHandleSource,
263 FileHandleDest,
264 FileStandard.EndOfFile,
265 lpProgressRoutine,
266 lpData,
267 pbCancel,
268 &KeepDestOnError);
269 if (!NT_SUCCESS(errCode))
270 {
271 BaseSetLastNTError(errCode);
272 }
273 else
274 {
275 LARGE_INTEGER t;
276
277 t.QuadPart = FileBasic.LastWriteTime.QuadPart;
278 errCode = SetLastWriteTime(FileHandleDest, t);
279 if (!NT_SUCCESS(errCode))
280 {
281 BaseSetLastNTError(errCode);
282 }
283 else
284 {
285 RC = TRUE;
286 }
287 }
288 NtClose(FileHandleDest);
289 if (! RC && ! KeepDestOnError)
290 {
291 SystemError = GetLastError();
292 SetFileAttributesW(lpNewFileName, FILE_ATTRIBUTE_NORMAL);
293 DeleteFileW(lpNewFileName);
294 SetLastError(SystemError);
295 }
296 }
297 else
298 {
299 WARN("Error %lu during opening of dest file\n", GetLastError());
300 }
301 }
302 }
303 NtClose(FileHandleSource);
304 }
305 else
306 {
307 WARN("Error %lu during opening of source file\n", GetLastError());
308 }
309
310 return RC;
311 }
312
313 /*
314 * @implemented
315 */
316 BOOL
317 WINAPI
318 CopyFileExW(IN LPCWSTR lpExistingFileName,
319 IN LPCWSTR lpNewFileName,
320 IN LPPROGRESS_ROUTINE lpProgressRoutine OPTIONAL,
321 IN LPVOID lpData OPTIONAL,
322 IN LPBOOL pbCancel OPTIONAL,
323 IN DWORD dwCopyFlags)
324 {
325 BOOL Ret;
326 HANDLE ExistingHandle, NewHandle;
327
328 ExistingHandle = INVALID_HANDLE_VALUE;
329 NewHandle = INVALID_HANDLE_VALUE;
330
331 _SEH2_TRY
332 {
333 Ret = BasepCopyFileExW(lpExistingFileName,
334 lpNewFileName,
335 lpProgressRoutine,
336 lpData,
337 pbCancel,
338 dwCopyFlags,
339 0,
340 &ExistingHandle,
341 &NewHandle);
342 }
343 _SEH2_FINALLY
344 {
345 if (ExistingHandle != INVALID_HANDLE_VALUE)
346 {
347 CloseHandle(ExistingHandle);
348 }
349
350 if (NewHandle != INVALID_HANDLE_VALUE)
351 {
352 CloseHandle(NewHandle);
353 }
354 }
355 _SEH2_END;
356
357 return Ret;
358 }
359
360
361 /*
362 * @implemented
363 */
364 BOOL
365 WINAPI
366 CopyFileExA(IN LPCSTR lpExistingFileName,
367 IN LPCSTR lpNewFileName,
368 IN LPPROGRESS_ROUTINE lpProgressRoutine OPTIONAL,
369 IN LPVOID lpData OPTIONAL,
370 IN LPBOOL pbCancel OPTIONAL,
371 IN DWORD dwCopyFlags)
372 {
373 BOOL Result = FALSE;
374 UNICODE_STRING lpNewFileNameW;
375 PUNICODE_STRING lpExistingFileNameW;
376
377 lpExistingFileNameW = Basep8BitStringToStaticUnicodeString(lpExistingFileName);
378 if (!lpExistingFileNameW)
379 {
380 return FALSE;
381 }
382
383 if (Basep8BitStringToDynamicUnicodeString(&lpNewFileNameW, lpNewFileName))
384 {
385 Result = CopyFileExW(lpExistingFileNameW->Buffer,
386 lpNewFileNameW.Buffer,
387 lpProgressRoutine,
388 lpData,
389 pbCancel,
390 dwCopyFlags);
391
392 RtlFreeUnicodeString(&lpNewFileNameW);
393 }
394
395 return Result;
396 }
397
398
399 /*
400 * @implemented
401 */
402 BOOL
403 WINAPI
404 CopyFileA(IN LPCSTR lpExistingFileName,
405 IN LPCSTR lpNewFileName,
406 IN BOOL bFailIfExists)
407 {
408 BOOL Result = FALSE;
409 UNICODE_STRING lpNewFileNameW;
410 PUNICODE_STRING lpExistingFileNameW;
411
412 lpExistingFileNameW = Basep8BitStringToStaticUnicodeString(lpExistingFileName);
413 if (!lpExistingFileNameW)
414 {
415 return FALSE;
416 }
417
418 if (Basep8BitStringToDynamicUnicodeString(&lpNewFileNameW, lpNewFileName))
419 {
420 Result = CopyFileExW(lpExistingFileNameW->Buffer,
421 lpNewFileNameW.Buffer,
422 NULL,
423 NULL,
424 NULL,
425 (bFailIfExists ? COPY_FILE_FAIL_IF_EXISTS : 0));
426
427 RtlFreeUnicodeString(&lpNewFileNameW);
428 }
429
430 return Result;
431 }
432
433
434 /*
435 * @implemented
436 */
437 BOOL
438 WINAPI
439 CopyFileW(IN LPCWSTR lpExistingFileName,
440 IN LPCWSTR lpNewFileName,
441 IN BOOL bFailIfExists)
442 {
443 return CopyFileExW(lpExistingFileName,
444 lpNewFileName,
445 NULL,
446 NULL,
447 NULL,
448 (bFailIfExists ? COPY_FILE_FAIL_IF_EXISTS : 0));
449 }
450
451
452 /*
453 * @implemented
454 */
455 BOOL
456 WINAPI
457 PrivCopyFileExW(IN LPCWSTR lpExistingFileName,
458 IN LPCWSTR lpNewFileName,
459 IN LPPROGRESS_ROUTINE lpProgressRoutine,
460 IN LPVOID lpData,
461 IN LPBOOL pbCancel,
462 IN DWORD dwCopyFlags)
463 {
464 BOOL Ret;
465 HANDLE ExistingHandle, NewHandle;
466
467 ExistingHandle = INVALID_HANDLE_VALUE;
468 NewHandle = INVALID_HANDLE_VALUE;
469
470 /* Check for incompatible flags */
471 if (dwCopyFlags & COPY_FILE_FAIL_IF_EXISTS && dwCopyFlags & BASEP_COPY_REPLACE)
472 {
473 SetLastError(ERROR_INVALID_PARAMETER);
474 return FALSE;
475 }
476
477 _SEH2_TRY
478 {
479 Ret = BasepCopyFileExW(lpExistingFileName,
480 lpNewFileName,
481 lpProgressRoutine,
482 lpData,
483 pbCancel,
484 dwCopyFlags & BASEP_COPY_PUBLIC_MASK,
485 dwCopyFlags & BASEP_COPY_BASEP_MASK,
486 &ExistingHandle,
487 &NewHandle);
488 }
489 _SEH2_FINALLY
490 {
491 if (ExistingHandle != INVALID_HANDLE_VALUE)
492 {
493 CloseHandle(ExistingHandle);
494 }
495
496 if (NewHandle != INVALID_HANDLE_VALUE)
497 {
498 CloseHandle(NewHandle);
499 }
500 }
501 _SEH2_END;
502
503 return Ret;
504 }
505
506 /* EOF */