723b8315e40d3f67979824a8469641883519d627
[reactos.git] / reactos / lib / kernel32 / file / move.c
1 /* $Id$
2 *
3 * COPYRIGHT: See COPYING in the top level directory
4 * PROJECT: ReactOS system libraries
5 * FILE: lib/kernel32/file/file.c
6 * PURPOSE: Directory functions
7 * PROGRAMMER: Ariadne ( ariadne@xs4all.nl)
8 * Gerhard W. Gruber (sparhawk_at_gmx.at)
9 * UPDATE HISTORY:
10 * Created 01/11/98
11 */
12
13 /* INCLUDES *****************************************************************/
14
15 #include <k32.h>
16 #include <malloc.h>
17
18 #define NDEBUG
19 #include "../include/debug.h"
20
21 /* GLOBALS *****************************************************************/
22
23 /* FUNCTIONS ****************************************************************/
24 static BOOL
25 RemoveReadOnlyAttributeW(IN LPCWSTR lpFileName)
26 {
27 DWORD Attributes;
28 Attributes = GetFileAttributesW(lpFileName);
29 if (Attributes != INVALID_FILE_ATTRIBUTES)
30 {
31 return SetFileAttributesW(lpFileName,Attributes -
32 (Attributes & ~FILE_ATTRIBUTE_READONLY));
33 }
34
35 return FALSE;
36 }
37
38
39 /***********************************************************************
40 * add_boot_rename_entry
41 *
42 * Adds an entry to the registry that is loaded when windows boots and
43 * checks if there are some files to be removed or renamed/moved.
44 * <fn1> has to be valid and <fn2> may be NULL. If both pointers are
45 * non-NULL then the file is moved, otherwise it is deleted. The
46 * entry of the registrykey is always appended with two zero
47 * terminated strings. If <fn2> is NULL then the second entry is
48 * simply a single 0-byte. Otherwise the second filename goes
49 * there. The entries are prepended with \??\ before the path and the
50 * second filename gets also a '!' as the first character if
51 * MOVEFILE_REPLACE_EXISTING is set. After the final string another
52 * 0-byte follows to indicate the end of the strings.
53 * i.e.:
54 * \??\D:\test\file1[0]
55 * !\??\D:\test\file1_renamed[0]
56 * \??\D:\Test|delete[0]
57 * [0] <- file is to be deleted, second string empty
58 * \??\D:\test\file2[0]
59 * !\??\D:\test\file2_renamed[0]
60 * [0] <- indicates end of strings
61 *
62 * or:
63 * \??\D:\test\file1[0]
64 * !\??\D:\test\file1_renamed[0]
65 * \??\D:\Test|delete[0]
66 * [0] <- file is to be deleted, second string empty
67 * [0] <- indicates end of strings
68 *
69 */
70 static BOOL add_boot_rename_entry( LPCWSTR source, LPCWSTR dest, DWORD flags )
71 {
72 static const WCHAR ValueName[] = {'P','e','n','d','i','n','g',
73 'F','i','l','e','R','e','n','a','m','e',
74 'O','p','e','r','a','t','i','o','n','s',0};
75
76 UNICODE_STRING KeyName = RTL_CONSTANT_STRING(L"\\Registry\\Machine\\SYSTEM\\CurrentControlSet\\Control\\Session Manager");
77
78 static const int info_size = FIELD_OFFSET( KEY_VALUE_PARTIAL_INFORMATION, Data );
79
80 OBJECT_ATTRIBUTES ObjectAttributes;
81 UNICODE_STRING nameW, source_name, dest_name;
82 KEY_VALUE_PARTIAL_INFORMATION *info;
83 BOOL rc = FALSE;
84 HANDLE Reboot = 0;
85 DWORD len1, len2;
86 DWORD DataSize = 0;
87 BYTE *Buffer = NULL;
88 WCHAR *p;
89 NTSTATUS Status;
90
91 DPRINT("Add support to smss for keys created by MOVEFILE_DELAY_UNTIL_REBOOT\n");
92
93 if (!RtlDosPathNameToNtPathName_U( source, &source_name, NULL, NULL ))
94 {
95 SetLastError( ERROR_PATH_NOT_FOUND );
96 return FALSE;
97 }
98 dest_name.Buffer = NULL;
99 if (dest && !RtlDosPathNameToNtPathName_U( dest, &dest_name, NULL, NULL ))
100 {
101 RtlFreeUnicodeString( &source_name );
102 SetLastError( ERROR_PATH_NOT_FOUND );
103 return FALSE;
104 }
105
106 InitializeObjectAttributes(&ObjectAttributes,
107 &KeyName,
108 OBJ_CASE_INSENSITIVE,
109 NULL,
110 NULL);
111
112 Status = NtOpenKey(&Reboot,
113 KEY_ALL_ACCESS,
114 &ObjectAttributes);
115
116 if (!NT_SUCCESS(Status))
117 {
118 Status = NtCreateKey(&Reboot,
119 KEY_ALL_ACCESS,
120 &ObjectAttributes,
121 0,
122 NULL,
123 REG_OPTION_NON_VOLATILE,
124 NULL);
125 }
126
127 if (!NT_SUCCESS(Status))
128 {
129 DPRINT1("NtCreateKey() failed (Status %lx)\n", Status);
130 RtlFreeUnicodeString( &source_name );
131 RtlFreeUnicodeString( &dest_name );
132 return FALSE;
133 }
134
135 len1 = source_name.Length + sizeof(WCHAR);
136 if (dest)
137 {
138 len2 = dest_name.Length + sizeof(WCHAR);
139 if (flags & MOVEFILE_REPLACE_EXISTING)
140 len2 += sizeof(WCHAR); /* Plus 1 because of the leading '!' */
141 }
142 else len2 = sizeof(WCHAR); /* minimum is the 0 characters for the empty second string */
143
144 RtlInitUnicodeString( &nameW, ValueName );
145
146 /* First we check if the key exists and if so how many bytes it already contains. */
147 if (NtQueryValueKey( Reboot, &nameW, KeyValuePartialInformation,
148 NULL, 0, &DataSize ) == STATUS_BUFFER_OVERFLOW)
149 {
150 if (!(Buffer = HeapAlloc( GetProcessHeap(), 0, DataSize + len1 + len2 + sizeof(WCHAR) )))
151 goto Quit;
152 if (NtQueryValueKey( Reboot, &nameW, KeyValuePartialInformation,
153 Buffer, DataSize, &DataSize )) goto Quit;
154 info = (KEY_VALUE_PARTIAL_INFORMATION *)Buffer;
155 if (info->Type != REG_MULTI_SZ) goto Quit;
156 if (DataSize > sizeof(info)) DataSize -= sizeof(WCHAR); /* remove terminating null (will be added back later) */
157 }
158 else
159 {
160 DataSize = info_size;
161 if (!(Buffer = HeapAlloc( GetProcessHeap(), 0, DataSize + len1 + len2 + sizeof(WCHAR) )))
162 goto Quit;
163 }
164
165 memcpy( Buffer + DataSize, source_name.Buffer, len1 );
166 DataSize += len1;
167 p = (WCHAR *)(Buffer + DataSize);
168 if (dest)
169 {
170 if (flags & MOVEFILE_REPLACE_EXISTING)
171 *p++ = '!';
172 memcpy( p, dest_name.Buffer, len2 );
173 DataSize += len2;
174 }
175 else
176 {
177 *p = 0;
178 DataSize += sizeof(WCHAR);
179 }
180
181 /* add final null */
182 p = (WCHAR *)(Buffer + DataSize);
183 *p = 0;
184 DataSize += sizeof(WCHAR);
185
186 rc = !NtSetValueKey(Reboot, &nameW, 0, REG_MULTI_SZ, Buffer + info_size, DataSize - info_size);
187
188 Quit:
189 RtlFreeUnicodeString( &source_name );
190 RtlFreeUnicodeString( &dest_name );
191 if (Reboot) NtClose(Reboot);
192 HeapFree( GetProcessHeap(), 0, Buffer );
193 return(rc);
194 }
195
196
197 /*
198 * @implemented
199 */
200 BOOL
201 STDCALL
202 MoveFileWithProgressW (
203 LPCWSTR lpExistingFileName,
204 LPCWSTR lpNewFileName,
205 LPPROGRESS_ROUTINE lpProgressRoutine,
206 LPVOID lpData,
207 DWORD dwFlags
208 )
209 {
210 HANDLE hFile = NULL;
211 IO_STATUS_BLOCK IoStatusBlock;
212 PFILE_RENAME_INFORMATION FileRename;
213 NTSTATUS errCode;
214 BOOL Result;
215 UNICODE_STRING DstPathU;
216 BOOL folder = FALSE;
217
218 DPRINT("MoveFileWithProgressW()\n");
219
220 if (dwFlags & MOVEFILE_DELAY_UNTIL_REBOOT)
221 return add_boot_rename_entry( lpExistingFileName, lpNewFileName, dwFlags );
222
223 hFile = CreateFileW (lpExistingFileName,
224 GENERIC_ALL,
225 FILE_SHARE_WRITE|FILE_SHARE_READ,
226 NULL,
227 OPEN_EXISTING,
228 FILE_FLAG_BACKUP_SEMANTICS,
229 NULL);
230
231 if (hFile == INVALID_HANDLE_VALUE)
232 {
233 return FALSE;
234 }
235
236
237 /* validate & translate the filename */
238 if (!RtlDosPathNameToNtPathName_U (lpNewFileName,
239 &DstPathU,
240 NULL,
241 NULL))
242 {
243 DPRINT("Invalid destination path\n");
244 CloseHandle(hFile);
245 SetLastError(ERROR_PATH_NOT_FOUND);
246 return FALSE;
247 }
248
249 FileRename = alloca(sizeof(FILE_RENAME_INFORMATION) + DstPathU.Length);
250 if ((dwFlags & MOVEFILE_REPLACE_EXISTING) == MOVEFILE_REPLACE_EXISTING)
251 FileRename->ReplaceIfExists = TRUE;
252 else
253 FileRename->ReplaceIfExists = FALSE;
254
255 memcpy(FileRename->FileName, DstPathU.Buffer, DstPathU.Length);
256 RtlFreeHeap (RtlGetProcessHeap (),
257 0,
258 DstPathU.Buffer);
259 /*
260 * FIXME:
261 * Is the length the count of characters or the length of the buffer?
262 */
263 FileRename->FileNameLength = DstPathU.Length / sizeof(WCHAR);
264 errCode = NtSetInformationFile (hFile,
265 &IoStatusBlock,
266 FileRename,
267 sizeof(FILE_RENAME_INFORMATION) + DstPathU.Length,
268 FileRenameInformation);
269 CloseHandle(hFile);
270
271 if (GetFileAttributesW(lpExistingFileName) & FILE_ATTRIBUTE_DIRECTORY)
272 {
273 folder = TRUE;
274 }
275
276
277 /*
278 * FIXME:
279 * Fail now move the folder
280 * Before we fail at CreateFileW
281 */
282
283
284 if (NT_SUCCESS(errCode))
285 {
286 Result = TRUE;
287 }
288 else
289 {
290 if (folder==FALSE)
291 {
292 Result = CopyFileExW (lpExistingFileName,
293 lpNewFileName,
294 lpProgressRoutine,
295 lpData,
296 NULL,
297 FileRename->ReplaceIfExists ? 0 : COPY_FILE_FAIL_IF_EXISTS);
298 if (Result)
299 {
300 /* Cleanup the source file */
301 Result = DeleteFileW (lpExistingFileName);
302 }
303 }
304 else
305 {
306 /* move folder code start */
307 WIN32_FIND_DATAW findBuffer;
308 LPWSTR lpExistingFileName2 = NULL;
309 LPWSTR lpNewFileName2 = NULL;
310 LPWSTR lpDeleteFile = NULL;
311 INT size;
312 INT size2;
313 BOOL loop = TRUE;
314 BOOL Result = FALSE;
315 INT max_size = MAX_PATH;
316
317
318 /* Build the string */
319 size = wcslen(lpExistingFileName);
320 if (size+6> max_size)
321 max_size = size + 6;
322
323 lpDeleteFile = (LPWSTR) HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,max_size * sizeof(WCHAR));
324 if (lpDeleteFile == NULL)
325 return FALSE;
326
327 lpNewFileName2 = (LPWSTR) HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,max_size * sizeof(WCHAR));
328 if (lpNewFileName2 == NULL)
329 {
330 HeapFree(GetProcessHeap(),0,(VOID *) lpDeleteFile);
331 return FALSE;
332 }
333
334 lpExistingFileName2 = (LPWSTR) HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,max_size * sizeof(WCHAR));
335 if (lpNewFileName2 == NULL)
336 {
337 HeapFree(GetProcessHeap(),0,(VOID *) lpNewFileName2);
338 HeapFree(GetProcessHeap(),0,(VOID *) lpDeleteFile);
339 return FALSE;
340 }
341
342 wcscpy( (WCHAR *)lpExistingFileName2,lpExistingFileName);
343 wcscpy( (WCHAR *)&lpExistingFileName2[size],L"\\*.*\0");
344
345 /* Get the file name */
346 memset(&findBuffer,0,sizeof(WIN32_FIND_DATAW));
347 hFile = FindFirstFileW(lpExistingFileName2, &findBuffer);
348 if (hFile == NULL)
349 loop=FALSE;
350
351 if (findBuffer.cFileName[0] == L'\0')
352 loop=FALSE;
353
354
355 /* FIXME
356 * remove readonly flag from source folder and do not set the readonly flag to dest folder
357 */
358 RemoveReadOnlyAttributeW(lpExistingFileName);
359 RemoveReadOnlyAttributeW(lpNewFileName);
360 //CreateDirectoryExW(lpExistingFileName,lpNewFileName,NULL);
361 CreateDirectoryW(lpNewFileName, NULL);
362
363 /* search the files/folders and move them */
364 while (loop==TRUE)
365 {
366 Result = TRUE;
367
368 if ((!wcscmp(findBuffer.cFileName,L"..")) || (!wcscmp(findBuffer.cFileName,L".")))
369 {
370 loop = FindNextFileW(hFile, &findBuffer);
371
372 if (!loop)
373 {
374 size = wcslen(lpExistingFileName2)-4;
375 FindClose(hFile);
376 wcscpy( &lpExistingFileName2[size],L"\0");
377
378 if (wcsncmp(lpExistingFileName,lpExistingFileName2,size))
379 {
380 DWORD Attributes;
381
382 FindClose(hFile);
383
384 /* delete folder */
385 DPRINT("MoveFileWithProgressW : Delete folder : %S\n",lpDeleteFile);
386
387 /* remove system folder flag other wise we can not delete the folder */
388 Attributes = GetFileAttributesW(lpExistingFileName2);
389 if (Attributes != INVALID_FILE_ATTRIBUTES)
390 {
391 SetFileAttributesW(lpExistingFileName2,(Attributes & ~FILE_ATTRIBUTE_SYSTEM));
392 }
393
394 RemoveReadOnlyAttributeW(lpExistingFileName2);
395
396 Result = RemoveDirectoryW(lpExistingFileName2);
397 if (Result == FALSE)
398 break;
399
400 loop=TRUE;
401 size = wcslen(lpExistingFileName);
402
403 if (size+6>max_size)
404 {
405 if (lpNewFileName2 != NULL)
406 HeapFree(GetProcessHeap(),0,(VOID *) lpNewFileName2);
407
408 if (lpExistingFileName2 != NULL)
409 HeapFree(GetProcessHeap(),0,(VOID *) lpExistingFileName2);
410
411 if (lpDeleteFile != NULL)
412 HeapFree(GetProcessHeap(),0,(VOID *) lpDeleteFile);
413
414 return FALSE;
415 }
416
417 wcscpy( lpExistingFileName2,lpExistingFileName);
418 wcscpy( &lpExistingFileName2[size],L"\\*.*\0");
419
420 /* Get the file name */
421 memset(&findBuffer,0,sizeof(WIN32_FIND_DATAW));
422 hFile = FindFirstFileW(lpExistingFileName2, &findBuffer);
423 }
424 }
425 continue;
426 }
427
428 if (findBuffer.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
429 {
430
431 /* Build the new src string */
432 size = wcslen(findBuffer.cFileName);
433 size2= wcslen(lpExistingFileName2);
434
435 if (size2+size+6>max_size)
436 {
437 FindClose(hFile);
438
439 if (lpNewFileName2 != NULL)
440 HeapFree(GetProcessHeap(),0,(VOID *) lpNewFileName2);
441
442 if (lpExistingFileName2 != NULL)
443 HeapFree(GetProcessHeap(),0,(VOID *) lpExistingFileName2);
444
445 if (lpDeleteFile != NULL)
446 HeapFree(GetProcessHeap(),0,(VOID *) lpDeleteFile);
447
448 return FALSE;
449 }
450
451 wcscpy( &lpExistingFileName2[size2-3],findBuffer.cFileName);
452 wcscpy( &lpExistingFileName2[size2+size-3],L"\0");
453
454
455 /* Continue */
456 wcscpy( lpDeleteFile,lpExistingFileName2);
457 wcscpy( &lpExistingFileName2[size2+size-3],L"\\*.*\0");
458
459
460 /* Build the new dst string */
461 size = wcslen(lpExistingFileName2) + wcslen(lpNewFileName);
462 size2 = wcslen(lpExistingFileName);
463
464 if (size>max_size)
465 {
466 FindClose(hFile);
467
468 if (lpNewFileName2 != NULL)
469 HeapFree(GetProcessHeap(),0,(VOID *) lpNewFileName2);
470
471 if (lpExistingFileName2 != NULL)
472 HeapFree(GetProcessHeap(),0,(VOID *) lpExistingFileName2);
473
474 if (lpDeleteFile != NULL)
475 HeapFree(GetProcessHeap(),0,(VOID *) lpDeleteFile);
476
477 return FALSE;
478 }
479
480 wcscpy( lpNewFileName2,lpNewFileName);
481 size = wcslen(lpNewFileName);
482 wcscpy( &lpNewFileName2[size], &lpExistingFileName2[size2]);
483 size = wcslen(lpNewFileName2);
484 wcscpy( &lpNewFileName2[size-4],L"\0");
485
486 /* Create Folder */
487
488 /* FIXME
489 * remove readonly flag from source folder and do not set the readonly flag to dest folder
490 */
491 RemoveReadOnlyAttributeW(lpDeleteFile);
492 RemoveReadOnlyAttributeW(lpNewFileName2);
493
494 CreateDirectoryW(lpNewFileName2,NULL);
495 //CreateDirectoryExW(lpDeleteFile, lpNewFileName2,NULL);
496
497
498 /* set new search path from src string */
499 FindClose(hFile);
500 memset(&findBuffer,0,sizeof(WIN32_FIND_DATAW));
501 hFile = FindFirstFileW(lpExistingFileName2, &findBuffer);
502 }
503 else
504 {
505
506 /* Build the new string */
507 size = wcslen(findBuffer.cFileName);
508 size2= wcslen(lpExistingFileName2);
509 wcscpy( lpDeleteFile,lpExistingFileName2);
510 wcscpy( &lpDeleteFile[size2-3],findBuffer.cFileName);
511
512 /* Build dest string */
513 size = wcslen(lpDeleteFile) + wcslen(lpNewFileName);
514 size2 = wcslen(lpExistingFileName);
515
516 if (size>max_size)
517 {
518 FindClose(hFile);
519
520 if (lpNewFileName2 != NULL)
521 HeapFree(GetProcessHeap(),0,(VOID *) lpNewFileName2);
522
523 if (lpExistingFileName2 != NULL)
524 HeapFree(GetProcessHeap(),0,(VOID *) lpExistingFileName2);
525
526 if (lpDeleteFile != NULL)
527 HeapFree(GetProcessHeap(),0,(VOID *) lpDeleteFile);
528
529 return FALSE;
530 }
531
532 wcscpy( lpNewFileName2,lpNewFileName);
533 size = wcslen(lpNewFileName);
534 wcscpy(&lpNewFileName2[size],&lpDeleteFile[size2]);
535
536
537 /* overrite existsen file, if the file got the flag have readonly
538 * we need reomve that flag
539 */
540
541 /* copy file */
542
543 DPRINT("MoveFileWithProgressW : Copy file : %S to %S\n",lpDeleteFile, lpNewFileName2);
544 RemoveReadOnlyAttributeW(lpDeleteFile);
545 RemoveReadOnlyAttributeW(lpNewFileName2);
546
547 Result = CopyFileExW (lpDeleteFile,
548 lpNewFileName2,
549 lpProgressRoutine,
550 lpData,
551 NULL,
552 0);
553
554 if (Result == FALSE)
555 break;
556
557 /* delete file */
558 DPRINT("MoveFileWithProgressW : remove readonly flag from file : %S\n",lpNewFileName2);
559 Result = RemoveReadOnlyAttributeW(lpDeleteFile);
560 if (Result == FALSE)
561 break;
562
563 DPRINT("MoveFileWithProgressW : Delete file : %S\n",lpDeleteFile);
564 Result = DeleteFileW(lpDeleteFile);
565 if (Result == FALSE)
566 break;
567
568 }
569 loop = FindNextFileW(hFile, &findBuffer);
570 }
571
572
573 /* Remove last folder */
574 if ((loop == FALSE) && (Result != FALSE))
575 {
576 DWORD Attributes;
577
578 FindClose(hFile);
579 Attributes = GetFileAttributesW(lpDeleteFile);
580 if (Attributes != INVALID_FILE_ATTRIBUTES)
581 {
582 SetFileAttributesW(lpDeleteFile,(Attributes & ~FILE_ATTRIBUTE_SYSTEM));
583 }
584
585 Result = RemoveDirectoryW(lpExistingFileName);
586 }
587
588 /* Cleanup */
589 FindClose(hFile);
590
591 if (lpNewFileName2 != NULL)
592 {
593 HeapFree(GetProcessHeap(),0,(VOID *) lpNewFileName2);
594 lpNewFileName2 = NULL;
595 }
596
597 if (lpExistingFileName2 != NULL)
598 {
599 HeapFree(GetProcessHeap(),0,(VOID *) lpExistingFileName2);
600 lpExistingFileName2 = NULL;
601 }
602
603 if (lpDeleteFile != NULL)
604 {
605 HeapFree(GetProcessHeap(),0,(VOID *) lpDeleteFile);
606 lpDeleteFile = NULL;
607 }
608
609 return Result;
610
611 // end move folder code
612 }
613 }
614
615
616 return Result;
617 }
618
619
620 /*
621 * @implemented
622 */
623 BOOL
624 STDCALL
625 MoveFileWithProgressA (
626 LPCSTR lpExistingFileName,
627 LPCSTR lpNewFileName,
628 LPPROGRESS_ROUTINE lpProgressRoutine,
629 LPVOID lpData,
630 DWORD dwFlags
631 )
632 {
633 PWCHAR ExistingFileNameW;
634 PWCHAR NewFileNameW;
635 BOOL ret;
636
637 if (!(ExistingFileNameW = FilenameA2W(lpExistingFileName, FALSE)))
638 return FALSE;
639
640 if (!(NewFileNameW= FilenameA2W(lpNewFileName, TRUE)))
641 return FALSE;
642
643 ret = MoveFileWithProgressW (ExistingFileNameW ,
644 NewFileNameW,
645 lpProgressRoutine,
646 lpData,
647 dwFlags);
648
649 RtlFreeHeap (RtlGetProcessHeap (), 0, NewFileNameW);
650
651 return ret;
652 }
653
654
655 /*
656 * @implemented
657 */
658 BOOL
659 STDCALL
660 MoveFileW (
661 LPCWSTR lpExistingFileName,
662 LPCWSTR lpNewFileName
663 )
664 {
665 return MoveFileExW (lpExistingFileName,
666 lpNewFileName,
667 MOVEFILE_COPY_ALLOWED);
668 }
669
670
671 /*
672 * @implemented
673 */
674 BOOL
675 STDCALL
676 MoveFileExW (
677 LPCWSTR lpExistingFileName,
678 LPCWSTR lpNewFileName,
679 DWORD dwFlags
680 )
681 {
682 return MoveFileWithProgressW (lpExistingFileName,
683 lpNewFileName,
684 NULL,
685 NULL,
686 dwFlags);
687 }
688
689
690 /*
691 * @implemented
692 */
693 BOOL
694 STDCALL
695 MoveFileA (
696 LPCSTR lpExistingFileName,
697 LPCSTR lpNewFileName
698 )
699 {
700 return MoveFileExA (lpExistingFileName,
701 lpNewFileName,
702 MOVEFILE_COPY_ALLOWED);
703 }
704
705
706 /*
707 * @implemented
708 */
709 BOOL
710 STDCALL
711 MoveFileExA (
712 LPCSTR lpExistingFileName,
713 LPCSTR lpNewFileName,
714 DWORD dwFlags
715 )
716 {
717 return MoveFileWithProgressA (lpExistingFileName,
718 lpNewFileName,
719 NULL,
720 NULL,
721 dwFlags);
722 }
723
724 /* EOF */