reactos/dll/win32/kernel32/client/file/move.c

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS system libraries
   4  * FILE:            lib/kernel32/file/file.c
   5  * PURPOSE:         Directory functions
   6  * PROGRAMMER:      Ariadne ( ariadne@xs4all.nl)
   7  *                  Gerhard W. Gruber (sparhawk_at_gmx.at)
   8  *                  Dmitry Philippov (shedon@mail.ru)
   9  *                  Pierre Schweitzer (pierre@reactos.org)
  10  * UPDATE HISTORY:
  11  *                  Created 01/11/98
  12  *                  DP (29/07/2006)
  13  *                      Fix some bugs in the add_boot_rename_entry function
  14  */
  15
  16 /* INCLUDES *****************************************************************/
  17
  18 #include <k32.h>
  19 #include <malloc.h>
  20 #include <strsafe.h>
  21 #define NDEBUG
  22 #include <debug.h>
  23 DEBUG_CHANNEL(kernel32file);
  24
  25 /* GLOBALS *****************************************************************/
  26
  27 /* DEFINES *****************************************************************/
  28 typedef struct _COPY_PROGRESS_CONTEXT
  29 {
  30     ULONG Flags;
  31     LPPROGRESS_ROUTINE UserRoutine;
  32     LPVOID UserData;
  33 } COPY_PROGRESS_CONTEXT, *PCOPY_PROGRESS_CONTEXT;
  34
  35 /* FUNCTIONS ****************************************************************/
  36 /*
  37  * @implemented
  38  */
  39 NTSTATUS
  40 WINAPI
  41 BasepMoveFileDelayed(IN PUNICODE_STRING ExistingPath,
  42                      IN PUNICODE_STRING NewPath,
  43                      IN INT KeyId,
  44                      IN BOOL CreateIfNotFound)
  45 {
  46 #define STRING_LENGTH 0x400
  47     NTSTATUS Status;
  48     HANDLE KeyHandle;
  49     PVOID Buffer, BufferBegin;
  50     OBJECT_ATTRIBUTES ObjectAttributes;
  51     PWSTR PendingOperations, BufferWrite;
  52     ULONG DataSize, BufferLength, StringLength = STRING_LENGTH;
  53     UNICODE_STRING SessionManagerString, PendingOperationsString;
  54     /* +6 because a INT shouldn't take more than 6 chars. Especially given the call path */
  55     WCHAR PendingOperationsBuffer[sizeof(L"PendingFileRenameOperations") / sizeof(WCHAR) + 6];
  56
  57     RtlInitUnicodeString(&SessionManagerString, L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\Session Manager");
  58
  59     /* Select appropriate key for adding our file */
  60     if (KeyId == 1)
  61     {
  62         PendingOperations = L"PendingFileRenameOperations";
  63     }
  64     else
  65     {
  66         StringCbPrintfW(PendingOperationsBuffer, sizeof(PendingOperationsBuffer), L"PendingFileRenameOperations%d", KeyId);
  67         PendingOperations = PendingOperationsBuffer;
  68     }
  69     RtlInitUnicodeString(&PendingOperationsString, PendingOperations);
  70
  71     InitializeObjectAttributes(&ObjectAttributes,
  72                                &SessionManagerString,
  73                                OBJ_OPENIF | OBJ_CASE_INSENSITIVE,
  74                                NULL, NULL);
  75
  76     /* Open parent key */
  77     Status = NtCreateKey(&KeyHandle,
  78                          GENERIC_READ | GENERIC_WRITE,
  79                          &ObjectAttributes, 0, NULL,
  80                          REG_OPTION_NON_VOLATILE, NULL);
  81     if (Status == STATUS_ACCESS_DENIED)
  82     {
  83         Status = NtCreateKey(&KeyHandle,
  84                              GENERIC_READ | GENERIC_WRITE,
  85                              &ObjectAttributes, 0, NULL,
  86                              REG_OPTION_BACKUP_RESTORE, NULL);
  87     }
  88
  89     if (!NT_SUCCESS(Status))
  90     {
  91         return Status;
  92     }
  93
  94     /* Reserve enough to read previous string + to append our with required null chars */
  95     BufferLength = NewPath->Length + ExistingPath->Length + STRING_LENGTH + 3 * sizeof(UNICODE_NULL);
  96
  97     while (TRUE)
  98     {
  99         /* Allocate output buffer */
 100         Buffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, BufferLength);
 101         if (Buffer == NULL)
 102         {
 103             NtClose(KeyHandle);
 104             return STATUS_NO_MEMORY;
 105         }
 106
 107         Status = NtQueryValueKey(KeyHandle,
 108                                  &PendingOperationsString,
 109                                  KeyValuePartialInformation,
 110                                  Buffer, StringLength, &DataSize);
 111         if (Status != STATUS_BUFFER_OVERFLOW)
 112         {
 113             break;
 114         }
 115
 116         /* If buffer was too small, then, reallocate one which is big enough */
 117         StringLength = DataSize;
 118         RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
 119         BufferLength = ExistingPath->Length + StringLength + NewPath->Length + 3 * sizeof(UNICODE_NULL);
 120         /* Check we didn't overflow */
 121         if (BufferLength < StringLength)
 122         {
 123             NtClose(KeyHandle);
 124             return STATUS_BUFFER_TOO_SMALL;
 125         }
 126     }
 127
 128     /* Check if it existed - if not, create only IF asked to */
 129     if (!NT_SUCCESS(Status) && (Status != STATUS_OBJECT_NAME_NOT_FOUND || !CreateIfNotFound))
 130     {
 131         NtClose(KeyHandle);
 132         RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
 133         return Status;
 134     }
 135
 136     if (!NT_SUCCESS(Status))
 137     {
 138         /* We didn't find any - ie, we create, so use complete buffer */
 139         BufferBegin = Buffer;
 140         BufferWrite = Buffer;
 141     }
 142     else
 143     {
 144         PKEY_VALUE_PARTIAL_INFORMATION PartialInfo = (PKEY_VALUE_PARTIAL_INFORMATION)Buffer;
 145
 146         /* Get data, our buffer begin and then where we should append data
 147          * (- null char, this is REG_MULTI_SZ, it already includes double termination, we keep only one)
 148          */
 149         BufferBegin = PartialInfo->Data;
 150         BufferWrite = (PWSTR)((ULONG_PTR)PartialInfo->Data + PartialInfo->DataLength - sizeof(UNICODE_NULL));
 151     }
 152
 153     /* First copy existing */
 154     RtlCopyMemory(BufferWrite, ExistingPath->Buffer, ExistingPath->Length);
 155     BufferWrite += ExistingPath->Length / sizeof(WCHAR);
 156     /* And append null char */
 157     *BufferWrite = UNICODE_NULL;
 158     ++BufferWrite;
 159     /* Append destination */
 160     RtlCopyMemory(BufferWrite, NewPath->Buffer, NewPath->Length);
 161     BufferWrite += NewPath->Length / sizeof(WCHAR);
 162     /* And append two null char (end of string) */
 163     *BufferWrite = UNICODE_NULL;
 164     ++BufferWrite;
 165     *BufferWrite = UNICODE_NULL;
 166
 167     /* Set new value */
 168     Status = NtSetValueKey(KeyHandle,
 169                            &PendingOperationsString,
 170                            0, REG_MULTI_SZ, BufferBegin,
 171                            (ULONG_PTR)BufferWrite - (ULONG_PTR)BufferBegin + sizeof(WCHAR));
 172
 173     NtClose(KeyHandle);
 174     RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
 175
 176     return Status;
 177 }
 178
 179
 180 /*
 181  * @unimplemented
 182  */
 183 NTSTATUS
 184 WINAPI
 185 BasepNotifyTrackingService(IN PHANDLE ExistingHandle,
 186                            IN POBJECT_ATTRIBUTES ObjectAttributes,
 187                            IN HANDLE NewHandle,
 188                            IN PUNICODE_STRING NewPath)
 189 {
 190     return STATUS_NOT_IMPLEMENTED;
 191 }
 192
 193
 194 /*
 195  * @implemented
 196  */
 197 NTSTATUS
 198 WINAPI
 199 BasepOpenFileForMove(IN LPCWSTR File,
 200                      OUT PUNICODE_STRING RelativeNtName,
 201                      OUT LPWSTR * NtName,
 202                      OUT PHANDLE FileHandle,
 203                      OUT POBJECT_ATTRIBUTES ObjectAttributes,
 204                      IN ACCESS_MASK DesiredAccess,
 205                      IN ULONG ShareAccess,
 206                      IN ULONG OpenOptions)
 207 {
 208     RTL_RELATIVE_NAME_U RelativeName;
 209     NTSTATUS Status;
 210     IO_STATUS_BLOCK IoStatusBlock;
 211     FILE_ATTRIBUTE_TAG_INFORMATION TagInfo;
 212     ULONG IntShareAccess;
 213     BOOLEAN HasRelative = FALSE;
 214
 215     _SEH2_TRY
 216     {
 217         /* Zero output */
 218         RelativeNtName->Length =
 219         RelativeNtName->MaximumLength = 0;
 220         RelativeNtName->Buffer = NULL;
 221         *NtName = NULL;
 222
 223         if (!RtlDosPathNameToRelativeNtPathName_U(File, RelativeNtName, NULL, &RelativeName))
 224         {
 225             Status = STATUS_OBJECT_PATH_NOT_FOUND;
 226             _SEH2_LEAVE;
 227         }
 228
 229         HasRelative = TRUE;
 230         *NtName = RelativeNtName->Buffer;
 231
 232         if (RelativeName.RelativeName.Length)
 233         {
 234             RelativeNtName->Length = RelativeName.RelativeName.Length;
 235             RelativeNtName->MaximumLength = RelativeName.RelativeName.MaximumLength;
 236             RelativeNtName->Buffer = RelativeName.RelativeName.Buffer;
 237         }
 238         else
 239         {
 240             RelativeName.ContainingDirectory = 0;
 241         }
 242
 243         InitializeObjectAttributes(ObjectAttributes,
 244                                    RelativeNtName,
 245                                    OBJ_CASE_INSENSITIVE,
 246                                    RelativeName.ContainingDirectory,
 247                                    NULL);
 248         /* Force certain flags here, given ops we'll do */
 249         IntShareAccess = ShareAccess | FILE_SHARE_READ | FILE_SHARE_WRITE;
 250         OpenOptions |= FILE_OPEN_FOR_BACKUP_INTENT | FILE_SYNCHRONOUS_IO_NONALERT;
 251
 252         /* We'll try to read reparse tag */
 253         Status = NtOpenFile(FileHandle,
 254                             DesiredAccess | FILE_READ_ATTRIBUTES | SYNCHRONIZE,
 255                             ObjectAttributes,
 256                             &IoStatusBlock,
 257                             IntShareAccess,
 258                             OpenOptions | FILE_OPEN_REPARSE_POINT);
 259         if (NT_SUCCESS(Status))
 260         {
 261             /* Attempt the read */
 262             Status = NtQueryInformationFile(*FileHandle,
 263                                             &IoStatusBlock,
 264                                             &TagInfo,
 265                                             sizeof(FILE_ATTRIBUTE_TAG_INFORMATION),
 266                                             FileAttributeTagInformation);
 267
 268             /* Return if failure with a status that wouldn't mean the FSD cannot support reparse points */
 269             if (!NT_SUCCESS(Status) &&
 270                 (Status != STATUS_NOT_IMPLEMENTED && Status != STATUS_INVALID_PARAMETER))
 271             {
 272                 _SEH2_LEAVE;
 273             }
 274
 275             if (NT_SUCCESS(Status))
 276             {
 277                 /* This cannot happen on mount points */
 278                 if (TagInfo.FileAttributes & FILE_ATTRIBUTE_DEVICE ||
 279                     TagInfo.ReparseTag == IO_REPARSE_TAG_MOUNT_POINT)
 280                 {
 281                     _SEH2_LEAVE;
 282                 }
 283             }
 284
 285             NtClose(*FileHandle);
 286             *FileHandle = INVALID_HANDLE_VALUE;
 287
 288             IntShareAccess = ShareAccess | FILE_SHARE_READ | FILE_SHARE_DELETE;
 289         }
 290         else if (Status == STATUS_INVALID_PARAMETER)
 291         {
 292             IntShareAccess = ShareAccess | FILE_SHARE_READ | FILE_SHARE_WRITE;
 293         }
 294         else
 295         {
 296             _SEH2_LEAVE;
 297         }
 298
 299         /* Reattempt to open normally, following reparse point if needed */
 300         Status = NtOpenFile(FileHandle,
 301                             DesiredAccess | SYNCHRONIZE,
 302                             ObjectAttributes,
 303                             &IoStatusBlock,
 304                             IntShareAccess,
 305                             OpenOptions);
 306     }
 307     _SEH2_FINALLY
 308     {
 309         if (HasRelative)
 310         {
 311             RtlReleaseRelativeName(&RelativeName);
 312         }
 313     }
 314     _SEH2_END;
 315
 316     return Status;
 317 }
 318
 319
 320 /*
 321  * @implemented
 322  */
 323 DWORD
 324 WINAPI
 325 BasepMoveFileCopyProgress(IN LARGE_INTEGER TotalFileSize,
 326                           IN LARGE_INTEGER TotalBytesTransferred,
 327                           IN LARGE_INTEGER StreamSize,
 328                           IN LARGE_INTEGER StreamBytesTransferred,
 329                           IN DWORD dwStreamNumber,
 330                           IN DWORD dwCallbackReason,
 331                           IN HANDLE hSourceFile,
 332                           IN HANDLE hDestinationFile,
 333                           IN LPVOID lpData OPTIONAL)
 334 {
 335     DWORD Ret = 0;
 336     PCOPY_PROGRESS_CONTEXT Context = (PCOPY_PROGRESS_CONTEXT)lpData;
 337
 338     if (Context->Flags & MOVEFILE_WRITE_THROUGH)
 339     {
 340         if (!dwCallbackReason)
 341         {
 342             if (StreamBytesTransferred.QuadPart == StreamSize.QuadPart)
 343             {
 344                 FlushFileBuffers(hDestinationFile);
 345             }
 346         }
 347     }
 348
 349     if (Context->UserRoutine)
 350     {
 351         Ret = Context->UserRoutine(TotalFileSize,
 352                                    TotalBytesTransferred,
 353                                    StreamSize,
 354                                    StreamBytesTransferred,
 355                                    dwStreamNumber,
 356                                    dwCallbackReason,
 357                                    hSourceFile,
 358                                    hDestinationFile,
 359                                    Context->UserData);
 360     }
 361
 362     return Ret;
 363 }
 364
 365
 366 /*
 367  * @implemented
 368  */
 369 BOOL
 370 WINAPI
 371 MoveFileWithProgressW(IN LPCWSTR lpExistingFileName,
 372                       IN LPCWSTR lpNewFileName,
 373                       IN LPPROGRESS_ROUTINE lpProgressRoutine,
 374                       IN LPVOID lpData,
 375                       IN DWORD dwFlags)
 376 {
 377     NTSTATUS Status;
 378     PWSTR NewBuffer;
 379     IO_STATUS_BLOCK IoStatusBlock;
 380     COPY_PROGRESS_CONTEXT CopyContext;
 381     OBJECT_ATTRIBUTES ObjectAttributes;
 382     PFILE_RENAME_INFORMATION RenameInfo;
 383     UNICODE_STRING NewPathU, ExistingPathU;
 384     FILE_ATTRIBUTE_TAG_INFORMATION FileAttrTagInfo;
 385     HANDLE SourceHandle = INVALID_HANDLE_VALUE, NewHandle, ExistingHandle;
 386     BOOL Ret = FALSE, ReplaceIfExists, DelayUntilReboot, AttemptReopenWithoutReparse;
 387
 388     DPRINT("MoveFileWithProgressW(%S, %S, %p, %p, %x)\n", lpExistingFileName, lpNewFileName, lpProgressRoutine, lpData, dwFlags);
 389
 390     NewPathU.Buffer = NULL;
 391     ExistingPathU.Buffer = NULL;
 392
 393     _SEH2_TRY
 394     {
 395         /* Don't allow renaming to a disk */
 396         if (lpNewFileName && RtlIsDosDeviceName_U(lpNewFileName))
 397         {
 398             BaseSetLastNTError(STATUS_OBJECT_NAME_COLLISION);
 399             _SEH2_LEAVE;
 400         }
 401
 402         ReplaceIfExists = !!(dwFlags & MOVEFILE_REPLACE_EXISTING);
 403
 404         /* Get file path */
 405         if (!RtlDosPathNameToNtPathName_U(lpExistingFileName, &ExistingPathU, NULL, NULL))
 406         {
 407             BaseSetLastNTError(STATUS_OBJECT_PATH_NOT_FOUND);
 408             _SEH2_LEAVE;
 409         }
 410
 411         /* Sanitize input */
 412         DelayUntilReboot = !!(dwFlags & MOVEFILE_DELAY_UNTIL_REBOOT);
 413         if (DelayUntilReboot && (dwFlags & MOVEFILE_CREATE_HARDLINK))
 414         {
 415             BaseSetLastNTError(STATUS_INVALID_PARAMETER);
 416             _SEH2_LEAVE;
 417         }
 418
 419         /* Unless we manage a proper opening, we'll attempt to reopen without reparse support */
 420         AttemptReopenWithoutReparse = TRUE;
 421         InitializeObjectAttributes(&ObjectAttributes,
 422                                    &ExistingPathU,
 423                                    OBJ_CASE_INSENSITIVE,
 424                                    NULL,
 425                                    NULL);
 426         /* Attempt to open source file */
 427         Status = NtOpenFile(&SourceHandle,
 428                             FILE_READ_ATTRIBUTES | DELETE | SYNCHRONIZE,
 429                             &ObjectAttributes,
 430                             &IoStatusBlock,
 431                             FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
 432                             FILE_OPEN_FOR_BACKUP_INTENT | ((dwFlags & MOVEFILE_WRITE_THROUGH) ? FILE_WRITE_THROUGH : 0));
 433         if (!NT_SUCCESS(Status))
 434         {
 435             /* If we failed and the file doesn't exist, don't attempt to reopen without reparse */
 436             if (DelayUntilReboot &&
 437                 (Status == STATUS_SHARING_VIOLATION || Status == STATUS_OBJECT_NAME_NOT_FOUND || Status == STATUS_OBJECT_PATH_NOT_FOUND))
 438             {
 439                 /* Here we don't fail completely, as we postpone the operation to reboot
 440                  * File might exist afterwards, and we don't need a handle here
 441                  */
 442                 SourceHandle = INVALID_HANDLE_VALUE;
 443                 AttemptReopenWithoutReparse = FALSE;
 444             }
 445             /* If we failed for any reason than unsupported reparse, fail completely */
 446             else if (Status != STATUS_INVALID_PARAMETER)
 447             {
 448                 BaseSetLastNTError(Status);
 449                 _SEH2_LEAVE;
 450             }
 451         }
 452         else
 453         {
 454             /* We managed to open, so query information */
 455             Status = NtQueryInformationFile(SourceHandle,
 456                                             &IoStatusBlock,
 457                                             &FileAttrTagInfo,
 458                                             sizeof(FILE_ATTRIBUTE_TAG_INFORMATION),
 459                                             FileAttributeTagInformation);
 460             if (!NT_SUCCESS(Status))
 461             {
 462                 /* Do not tolerate any other error than something related to not supported operation */
 463                 if (Status != STATUS_NOT_IMPLEMENTED && Status != STATUS_INVALID_PARAMETER)
 464                 {
 465                     BaseSetLastNTError(Status);
 466                     _SEH2_LEAVE;
 467                 }
 468
 469                 /* Not a reparse point, no need to reopen, it's fine */
 470                 AttemptReopenWithoutReparse = FALSE;
 471             }
 472             /* Validate the reparse point (do we support it?) */
 473             else if (FileAttrTagInfo.FileAttributes & FILE_ATTRIBUTE_REPARSE_POINT &&
 474                      FileAttrTagInfo.ReparseTag != IO_REPARSE_TAG_MOUNT_POINT)
 475             {
 476                 NtClose(SourceHandle);
 477                 SourceHandle = INVALID_HANDLE_VALUE;
 478             }
 479         }
 480
 481         /* Simply reopen if required */
 482         if (AttemptReopenWithoutReparse)
 483         {
 484             Status = NtOpenFile(&SourceHandle,
 485                                 DELETE | SYNCHRONIZE,
 486                                 &ObjectAttributes,
 487                                 &IoStatusBlock,
 488                                 FILE_SHARE_READ | FILE_SHARE_WRITE,
 489                                 ((dwFlags & MOVEFILE_WRITE_THROUGH) ? FILE_WRITE_THROUGH : 0));
 490             if (!NT_SUCCESS(Status))
 491             {
 492                 BaseSetLastNTError(Status);
 493                 _SEH2_LEAVE;
 494             }
 495         }
 496
 497         /* Nullify string if we're to use it */
 498         if (DelayUntilReboot && !lpNewFileName)
 499         {
 500             RtlInitUnicodeString(&NewPathU, 0);
 501         }
 502         /* Check whether path exists */
 503         else if (!RtlDosPathNameToNtPathName_U(lpNewFileName, &NewPathU, 0, 0))
 504         {
 505             BaseSetLastNTError(STATUS_OBJECT_PATH_NOT_FOUND);
 506             _SEH2_LEAVE;
 507         }
 508
 509         /* Handle postponed renaming */
 510         if (DelayUntilReboot)
 511         {
 512             /* If new file exists and we're allowed to replace, then mark the path with ! */
 513             if (ReplaceIfExists && NewPathU.Length)
 514             {
 515                 NewBuffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, NewPathU.Length + sizeof(WCHAR));
 516                 if (NewBuffer == NULL)
 517                 {
 518                     BaseSetLastNTError(STATUS_NO_MEMORY);
 519                     _SEH2_LEAVE;
 520                 }
 521
 522                 NewBuffer[0] = L'!';
 523                 RtlCopyMemory(&NewBuffer[1], NewPathU.Buffer, NewPathU.Length);
 524                 NewPathU.Length += sizeof(WCHAR);
 525                 NewPathU.MaximumLength += sizeof(WCHAR);
 526                 RtlFreeHeap(RtlGetProcessHeap(), 0, NewPathU.Buffer);
 527                 NewPathU.Buffer = NewBuffer;
 528             }
 529
 530             /* Check whether 'copy' renaming is allowed if required */
 531             if (RtlDetermineDosPathNameType_U(lpExistingFileName) == RtlPathTypeUncAbsolute || dwFlags & MOVEFILE_COPY_ALLOWED)
 532             {
 533                 Status = STATUS_INVALID_PARAMETER;
 534             }
 535             else
 536             {
 537                 /* First, probe 2nd key to see whether it exists - if so, it will be appended there */
 538                 Status = BasepMoveFileDelayed(&ExistingPathU, &NewPathU, 2, FALSE);
 539                 if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
 540                 {
 541                     /* If doesn't exist, append to first key first, creating it if it doesn't exist */
 542                     Status = BasepMoveFileDelayed(&ExistingPathU, &NewPathU, 1, TRUE);
 543
 544                     if (Status == STATUS_INSUFFICIENT_RESOURCES)
 545                     {
 546                         /* If it failed because it's too big, then create 2nd key and put it there */
 547                         Status = BasepMoveFileDelayed(&ExistingPathU, &NewPathU, 2, TRUE);
 548                     }
 549                 }
 550             }
 551
 552             /* If we failed at some point, return the error */
 553             if (!NT_SUCCESS(Status))
 554             {
 555                 BaseSetLastNTError(Status);
 556                 _SEH2_LEAVE;
 557             }
 558
 559             Ret = TRUE;
 560             _SEH2_LEAVE;
 561         }
 562
 563         /* At that point, we MUST have a source handle */
 564         ASSERT(SourceHandle != INVALID_HANDLE_VALUE);
 565
 566         /* Allocate renaming buffer and fill it */
 567         RenameInfo = RtlAllocateHeap(RtlGetProcessHeap(), 0, NewPathU.Length + sizeof(FILE_RENAME_INFORMATION));
 568         if (RenameInfo == NULL)
 569         {
 570             BaseSetLastNTError(STATUS_NO_MEMORY);
 571             _SEH2_LEAVE;
 572         }
 573
 574         RtlCopyMemory(&RenameInfo->FileName, NewPathU.Buffer, NewPathU.Length);
 575         RenameInfo->ReplaceIfExists = ReplaceIfExists;
 576         RenameInfo->RootDirectory = 0;
 577         RenameInfo->FileNameLength = NewPathU.Length;
 578
 579         /* Attempt to rename the file */
 580         Status = NtSetInformationFile(SourceHandle,
 581                                       &IoStatusBlock,
 582                                       RenameInfo,
 583                                       NewPathU.Length + sizeof(FILE_RENAME_INFORMATION),
 584                                       ((dwFlags & MOVEFILE_CREATE_HARDLINK) ? FileLinkInformation : FileRenameInformation));
 585         RtlFreeHeap(RtlGetProcessHeap(), 0, RenameInfo);
 586         if (NT_SUCCESS(Status))
 587         {
 588             /* If it succeed, all fine, quit */
 589             Ret = TRUE;
 590             _SEH2_LEAVE;
 591         }
 592         /* If we failed for any other reason than not the same device, fail
 593          * If we failed because of different devices, only allow renaming if user allowed copy
 594          */
 595         if (Status != STATUS_NOT_SAME_DEVICE || !(dwFlags & MOVEFILE_COPY_ALLOWED))
 596         {
 597             /* ReactOS hack! To be removed once all FSD have proper renaming support
 598              * Just leave status to error and leave
 599              */
 600             if (Status == STATUS_NOT_IMPLEMENTED)
 601             {
 602                 DPRINT1("Forcing copy, renaming not supported by FSD\n");
 603             }
 604             else
 605             {
 606                 BaseSetLastNTError(Status);
 607                 _SEH2_LEAVE;
 608             }
 609         }
 610
 611         /* Close source file */
 612         NtClose(SourceHandle);
 613         SourceHandle = INVALID_HANDLE_VALUE;
 614
 615         /* Issue the copy of the file */
 616         CopyContext.Flags = dwFlags;
 617         CopyContext.UserRoutine = lpProgressRoutine;
 618         CopyContext.UserData = lpData;
 619         NewHandle = INVALID_HANDLE_VALUE;
 620         ExistingHandle = INVALID_HANDLE_VALUE;
 621
 622         Ret = BasepCopyFileExW(lpExistingFileName,
 623                                lpNewFileName,
 624                                BasepMoveFileCopyProgress,
 625                                &CopyContext,
 626                                NULL,
 627                                (ReplaceIfExists == 0) | COPY_FILE_OPEN_SOURCE_FOR_WRITE,
 628                                0,
 629                                &ExistingHandle,
 630                                &NewHandle);
 631         if (!Ret)
 632         {
 633             /* If it failed, don't leak any handle */
 634             if (ExistingHandle != INVALID_HANDLE_VALUE)
 635             {
 636                 CloseHandle(ExistingHandle);
 637                 ExistingHandle = INVALID_HANDLE_VALUE;
 638             }
 639         }
 640         else if (ExistingHandle != INVALID_HANDLE_VALUE)
 641         {
 642             if (NewHandle != INVALID_HANDLE_VALUE)
 643             {
 644                 /* If copying succeed, notify */
 645                 Status = BasepNotifyTrackingService(&ExistingHandle, &ObjectAttributes, NewHandle, &NewPathU);
 646                 if (!NT_SUCCESS(Status))
 647                 {
 648                     /* Fail in case it had to succeed */
 649                     if (dwFlags & MOVEFILE_FAIL_IF_NOT_TRACKABLE)
 650                     {
 651                         if (NewHandle != INVALID_HANDLE_VALUE)
 652                             CloseHandle(NewHandle);
 653                         NewHandle = INVALID_HANDLE_VALUE;
 654                         DeleteFileW(lpNewFileName);
 655                         Ret = FALSE;
 656                         BaseSetLastNTError(Status);
 657                     }
 658                 }
 659             }
 660
 661             CloseHandle(ExistingHandle);
 662             ExistingHandle = INVALID_HANDLE_VALUE;
 663         }
 664
 665         /* In case copy worked, close file */
 666         if (NewHandle != INVALID_HANDLE_VALUE)
 667         {
 668             CloseHandle(NewHandle);
 669             NewHandle = INVALID_HANDLE_VALUE;
 670         }
 671
 672         /* If it succeed, delete source file */
 673         if (Ret)
 674         {
 675             if (!DeleteFileW(lpExistingFileName))
 676             {
 677                 /* Reset file attributes if required */
 678                 SetFileAttributesW(lpExistingFileName, FILE_ATTRIBUTE_NORMAL);
 679                 DeleteFileW(lpExistingFileName);
 680             }
 681         }
 682     }
 683     _SEH2_FINALLY
 684     {
 685         if (SourceHandle != INVALID_HANDLE_VALUE)
 686             NtClose(SourceHandle);
 687
 688         RtlFreeHeap(RtlGetProcessHeap(), 0, ExistingPathU.Buffer);
 689         RtlFreeHeap(RtlGetProcessHeap(), 0, NewPathU.Buffer);
 690     }
 691     _SEH2_END;
 692
 693     return Ret;
 694 }
 695
 696
 697 /*
 698  * @implemented
 699  */
 700 BOOL
 701 WINAPI
 702 MoveFileWithProgressA(IN LPCSTR lpExistingFileName,
 703                       IN LPCSTR lpNewFileName OPTIONAL,
 704                       IN LPPROGRESS_ROUTINE lpProgressRoutine OPTIONAL,
 705                       IN LPVOID lpData OPTIONAL,
 706                       IN DWORD dwFlags)
 707 {
 708     BOOL Ret;
 709     UNICODE_STRING ExistingFileNameW, NewFileNameW;
 710
 711     if (!Basep8BitStringToDynamicUnicodeString(&ExistingFileNameW, lpExistingFileName))
 712     {
 713         return FALSE;
 714     }
 715
 716     if (lpNewFileName)
 717     {
 718         if (!Basep8BitStringToDynamicUnicodeString(&NewFileNameW, lpNewFileName))
 719         {
 720             RtlFreeUnicodeString(&ExistingFileNameW);
 721             return FALSE;
 722         }
 723     }
 724     else
 725     {
 726         NewFileNameW.Buffer = NULL;
 727     }
 728
 729     Ret = MoveFileWithProgressW(ExistingFileNameW.Buffer, NewFileNameW.Buffer, lpProgressRoutine, lpData, dwFlags);
 730
 731     RtlFreeUnicodeString(&ExistingFileNameW);
 732     RtlFreeUnicodeString(&NewFileNameW);
 733
 734     return Ret;
 735 }
 736
 737
 738 /*
 739  * @implemented
 740  */
 741 BOOL
 742 WINAPI
 743 MoveFileW(IN LPCWSTR lpExistingFileName,
 744           IN LPCWSTR lpNewFileName)
 745 {
 746     return MoveFileWithProgressW(lpExistingFileName,
 747                                  lpNewFileName,
 748                                  NULL,
 749                                  NULL,
 750                                  MOVEFILE_COPY_ALLOWED);
 751 }
 752
 753
 754 /*
 755  * @implemented
 756  */
 757 BOOL
 758 WINAPI
 759 MoveFileExW(IN LPCWSTR lpExistingFileName,
 760             IN LPCWSTR lpNewFileName OPTIONAL,
 761             IN DWORD dwFlags)
 762 {
 763     return MoveFileWithProgressW(lpExistingFileName,
 764                                  lpNewFileName,
 765                                  NULL,
 766                                  NULL,
 767                                  dwFlags);
 768 }
 769
 770
 771 /*
 772  * @implemented
 773  */
 774 BOOL
 775 WINAPI
 776 MoveFileA(IN LPCSTR lpExistingFileName,
 777           IN LPCSTR lpNewFileName)
 778 {
 779     return MoveFileWithProgressA(lpExistingFileName,
 780                                  lpNewFileName,
 781                                  NULL,
 782                                  NULL,
 783                                  MOVEFILE_COPY_ALLOWED);
 784 }
 785
 786
 787 /*
 788  * @implemented
 789  */
 790 BOOL
 791 WINAPI
 792 MoveFileExA(IN LPCSTR lpExistingFileName,
 793             IN LPCSTR lpNewFileName OPTIONAL,
 794             IN DWORD dwFlags)
 795 {
 796     return MoveFileWithProgressA(lpExistingFileName,
 797                                  lpNewFileName,
 798                                  NULL,
 799                                  NULL,
 800                                  dwFlags);
 801 }
 802
 803 /*
 804  * @implemented
 805  */
 806 BOOL
 807 WINAPI
 808 ReplaceFileA(IN LPCSTR lpReplacedFileName,
 809              IN LPCSTR lpReplacementFileName,
 810              IN LPCSTR lpBackupFileName OPTIONAL,
 811              IN DWORD dwReplaceFlags,
 812              IN LPVOID lpExclude,
 813              IN LPVOID lpReserved)
 814 {
 815     BOOL Ret;
 816     UNICODE_STRING ReplacedFileNameW, ReplacementFileNameW, BackupFileNameW;
 817
 818     if (!lpReplacedFileName || !lpReplacementFileName || lpExclude || lpReserved || dwReplaceFlags & ~(REPLACEFILE_WRITE_THROUGH | REPLACEFILE_IGNORE_MERGE_ERRORS))
 819     {
 820         SetLastError(ERROR_INVALID_PARAMETER);
 821         return FALSE;
 822     }
 823
 824     if (!Basep8BitStringToDynamicUnicodeString(&ReplacedFileNameW, lpReplacedFileName))
 825     {
 826         return FALSE;
 827     }
 828
 829     if (!Basep8BitStringToDynamicUnicodeString(&ReplacementFileNameW, lpReplacementFileName))
 830     {
 831         RtlFreeUnicodeString(&ReplacedFileNameW);
 832         return FALSE;
 833     }
 834
 835     if (lpBackupFileName)
 836     {
 837         if (!Basep8BitStringToDynamicUnicodeString(&BackupFileNameW, lpBackupFileName))
 838         {
 839             RtlFreeUnicodeString(&ReplacementFileNameW);
 840             RtlFreeUnicodeString(&ReplacedFileNameW);
 841             return FALSE;
 842         }
 843     }
 844     else
 845     {
 846         BackupFileNameW.Buffer = NULL;
 847     }
 848
 849     Ret = ReplaceFileW(ReplacedFileNameW.Buffer, ReplacementFileNameW.Buffer, BackupFileNameW.Buffer, dwReplaceFlags, 0, 0);
 850
 851     if (lpBackupFileName)
 852     {
 853         RtlFreeUnicodeString(&BackupFileNameW);
 854     }
 855     RtlFreeUnicodeString(&ReplacementFileNameW);
 856     RtlFreeUnicodeString(&ReplacedFileNameW);
 857
 858     return Ret;
 859 }
 860
 861 /*
 862  * @unimplemented
 863  */
 864 BOOL
 865 WINAPI
 866 ReplaceFileW(
 867     LPCWSTR lpReplacedFileName,
 868     LPCWSTR lpReplacementFileName,
 869     LPCWSTR lpBackupFileName,
 870     DWORD   dwReplaceFlags,
 871     LPVOID  lpExclude,
 872     LPVOID  lpReserved
 873     )
 874 {
 875     HANDLE hReplaced = NULL, hReplacement = NULL;
 876     UNICODE_STRING NtReplacedName = { 0, 0, NULL };
 877     UNICODE_STRING NtReplacementName = { 0, 0, NULL };
 878     DWORD Error = ERROR_SUCCESS;
 879     NTSTATUS Status;
 880     BOOL Ret = FALSE;
 881     IO_STATUS_BLOCK IoStatusBlock;
 882     OBJECT_ATTRIBUTES ObjectAttributes;
 883     PVOID Buffer = NULL ;
 884
 885     if (dwReplaceFlags)
 886         FIXME("Ignoring flags %x\n", dwReplaceFlags);
 887
 888     /* First two arguments are mandatory */
 889     if (!lpReplacedFileName || !lpReplacementFileName)
 890     {
 891         SetLastError(ERROR_INVALID_PARAMETER);
 892         return FALSE;
 893     }
 894
 895     /* Back it up */
 896     if(lpBackupFileName)
 897     {
 898         if(!CopyFileW(lpReplacedFileName, lpBackupFileName, FALSE))
 899         {
 900             Error = GetLastError();
 901             goto Cleanup ;
 902         }
 903     }
 904
 905     /* Open the "replaced" file for reading and writing */
 906     if (!(RtlDosPathNameToNtPathName_U(lpReplacedFileName, &NtReplacedName, NULL, NULL)))
 907     {
 908         Error = ERROR_PATH_NOT_FOUND;
 909         goto Cleanup;
 910     }
 911
 912     InitializeObjectAttributes(&ObjectAttributes,
 913                                &NtReplacedName,
 914                                OBJ_CASE_INSENSITIVE,
 915                                NULL,
 916                                NULL);
 917
 918     Status = NtOpenFile(&hReplaced,
 919                         GENERIC_READ | GENERIC_WRITE | DELETE | SYNCHRONIZE | WRITE_DAC,
 920                         &ObjectAttributes,
 921                         &IoStatusBlock,
 922                         FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
 923                         FILE_SYNCHRONOUS_IO_NONALERT | FILE_NON_DIRECTORY_FILE);
 924
 925     if (!NT_SUCCESS(Status))
 926     {
 927         if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
 928             Error = ERROR_FILE_NOT_FOUND;
 929         else
 930             Error = ERROR_UNABLE_TO_REMOVE_REPLACED;
 931         goto Cleanup;
 932     }
 933
 934     /* Blank it */
 935     SetEndOfFile(hReplaced) ;
 936
 937     /*
 938      * Open the replacement file for reading, writing, and deleting
 939      * (deleting is needed when finished)
 940      */
 941     if (!(RtlDosPathNameToNtPathName_U(lpReplacementFileName, &NtReplacementName, NULL, NULL)))
 942     {
 943         Error = ERROR_PATH_NOT_FOUND;
 944         goto Cleanup;
 945     }
 946
 947     InitializeObjectAttributes(&ObjectAttributes,
 948                                &NtReplacementName,
 949                                OBJ_CASE_INSENSITIVE,
 950                                NULL,
 951                                NULL);
 952
 953     Status = NtOpenFile(&hReplacement,
 954                         GENERIC_READ | DELETE | SYNCHRONIZE,
 955                         &ObjectAttributes,
 956                         &IoStatusBlock,
 957                         0,
 958                         FILE_SYNCHRONOUS_IO_NONALERT | FILE_NON_DIRECTORY_FILE | FILE_DELETE_ON_CLOSE);
 959
 960     if (!NT_SUCCESS(Status))
 961     {
 962         Error = RtlNtStatusToDosError(Status);
 963         goto Cleanup;
 964     }
 965
 966     Buffer = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, 0x10000) ;
 967     if (!Buffer)
 968     {
 969         Error = ERROR_NOT_ENOUGH_MEMORY;
 970         goto Cleanup ;
 971     }
 972     while (Status != STATUS_END_OF_FILE)
 973     {
 974         Status = NtReadFile(hReplacement, NULL, NULL, NULL, &IoStatusBlock, Buffer, 0x10000, NULL, NULL) ;
 975         if (NT_SUCCESS(Status))
 976         {
 977             Status = NtWriteFile(hReplaced, NULL, NULL, NULL, &IoStatusBlock, Buffer,
 978                     IoStatusBlock.Information, NULL, NULL) ;
 979             if (!NT_SUCCESS(Status))
 980             {
 981                 Error = RtlNtStatusToDosError(Status);
 982                 goto Cleanup;
 983             }
 984         }
 985         else if (Status != STATUS_END_OF_FILE)
 986         {
 987             Error = RtlNtStatusToDosError(Status);
 988             goto Cleanup;
 989         }
 990     }
 991
 992     Ret = TRUE;
 993
 994     /* Perform resource cleanup */
 995 Cleanup:
 996     if (hReplaced) NtClose(hReplaced);
 997     if (hReplacement) NtClose(hReplacement);
 998     if (Buffer) RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
 999
1000     if (NtReplacementName.Buffer)
1001         RtlFreeHeap(GetProcessHeap(), 0, NtReplacementName.Buffer);
1002     if (NtReplacedName.Buffer)
1003         RtlFreeHeap(GetProcessHeap(), 0, NtReplacedName.Buffer);
1004
1005     /* If there was an error, set the error code */
1006     if(!Ret)
1007     {
1008         TRACE("ReplaceFileW failed (error=%lu)\n", Error);
1009         SetLastError(Error);
1010     }
1011     return Ret;
1012 }
1013
1014
1015 /*
1016  * @implemented
1017  */
1018 BOOL
1019 WINAPI
1020 PrivMoveFileIdentityW(IN LPCWSTR lpSource, IN LPCWSTR lpDestination, IN DWORD dwFlags)
1021 {
1022     ACCESS_MASK SourceAccess;
1023     UNICODE_STRING NtSource, NtDestination;
1024     LPWSTR RelativeSource, RelativeDestination;
1025     HANDLE SourceHandle, DestinationHandle;
1026     OBJECT_ATTRIBUTES ObjectAttributesSource, ObjectAttributesDestination;
1027     NTSTATUS Status, OldStatus = STATUS_SUCCESS;
1028     ACCESS_MASK DestAccess;
1029     IO_STATUS_BLOCK IoStatusBlock;
1030     FILE_BASIC_INFORMATION SourceInformation, DestinationInformation;
1031     FILE_DISPOSITION_INFORMATION FileDispositionInfo;
1032
1033     DPRINT("PrivMoveFileIdentityW(%S, %S, %x)\n", lpSource, lpDestination, dwFlags);
1034
1035     SourceHandle = INVALID_HANDLE_VALUE;
1036     NtSource.Length =
1037     NtSource.MaximumLength = 0;
1038     NtSource.Buffer = NULL;
1039     RelativeSource = NULL;
1040     DestinationHandle = INVALID_HANDLE_VALUE;
1041     NtDestination.Length =
1042     NtDestination.MaximumLength = 0;
1043     NtDestination.Buffer = NULL;
1044     RelativeDestination = NULL;
1045
1046     /* FILE_WRITE_DATA is required for later on notification */
1047     SourceAccess = FILE_READ_ATTRIBUTES | FILE_WRITE_DATA;
1048     if (dwFlags & PRIV_DELETE_ON_SUCCESS)
1049     {
1050         SourceAccess |= DELETE;
1051     }
1052
1053     _SEH2_TRY
1054     {
1055         /* We will loop twice:
1056          * First we attempt to open with FILE_WRITE_DATA for notification
1057          * If it fails and we have flag for non-trackable files, we retry
1058          * without FILE_WRITE_DATA.
1059          * If that one fails, then, we quit for real
1060          */
1061         while (TRUE)
1062         {
1063             Status = BasepOpenFileForMove(lpSource,
1064                                           &NtSource,
1065                                           &RelativeSource,
1066                                           &SourceHandle,
1067                                           &ObjectAttributesSource,
1068                                           SourceAccess,
1069                                           FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
1070                                           FILE_OPEN_NO_RECALL);
1071             if (NT_SUCCESS(Status))
1072             {
1073                 break;
1074             }
1075
1076             /* If we already attempted the opening without FILE_WRITE_DATA
1077              * or if we cannot move on non-trackable files, fail.
1078              */
1079             if (!(SourceAccess & FILE_WRITE_DATA) || !(dwFlags & PRIV_ALLOW_NON_TRACKABLE))
1080             {
1081                 _SEH2_LEAVE;
1082             }
1083
1084             if (RelativeSource)
1085             {
1086                 RtlFreeHeap(RtlGetProcessHeap(), 0, RelativeSource);
1087                 RelativeSource = NULL;
1088             }
1089
1090             if (SourceHandle != INVALID_HANDLE_VALUE)
1091             {
1092                 NtClose(SourceHandle);
1093                 SourceHandle = INVALID_HANDLE_VALUE;
1094             }
1095
1096             SourceAccess &= ~FILE_WRITE_DATA;
1097
1098             /* Remember fist failure in the path */
1099             if (NT_SUCCESS(OldStatus))
1100             {
1101                 OldStatus = Status;
1102             }
1103         }
1104
1105         DestAccess = FILE_WRITE_ATTRIBUTES;
1106         /* If we could preserve FILE_WRITE_DATA for source, attempt to get it for destination
1107          * Still for notification purposes
1108          */
1109         if (SourceAccess & FILE_WRITE_DATA)
1110         {
1111             DestAccess |= FILE_WRITE_DATA;
1112         }
1113
1114         /* cf comment for first loop */
1115         while (TRUE)
1116         {
1117             Status = BasepOpenFileForMove(lpDestination,
1118                                           &NtDestination,
1119                                           &RelativeDestination,
1120                                           &DestinationHandle,
1121                                           &ObjectAttributesDestination,
1122                                           DestAccess,
1123                                           FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
1124                                           FILE_OPEN_NO_RECALL);
1125             if (NT_SUCCESS(Status))
1126             {
1127                 break;
1128             }
1129
1130             /* If we already attempted the opening without FILE_WRITE_DATA
1131              * or if we cannot move on non-trackable files, fail.
1132              */
1133             if (!(DestAccess & FILE_WRITE_DATA) || !(dwFlags & PRIV_ALLOW_NON_TRACKABLE))
1134             {
1135                 _SEH2_LEAVE;
1136             }
1137
1138             if (RelativeDestination)
1139             {
1140                 RtlFreeHeap(RtlGetProcessHeap(), 0, RelativeDestination);
1141                 RelativeDestination = NULL;
1142             }
1143
1144             if (DestinationHandle != INVALID_HANDLE_VALUE)
1145             {
1146                 NtClose(DestinationHandle);
1147                 DestinationHandle = INVALID_HANDLE_VALUE;
1148             }
1149
1150             DestAccess &= ~FILE_WRITE_DATA;
1151
1152             /* Remember fist failure in the path */
1153             if (NT_SUCCESS(OldStatus))
1154             {
1155                 OldStatus = Status;
1156             }
1157         }
1158
1159         /* Get the creation time from source */
1160         Status = NtQueryInformationFile(SourceHandle,
1161                                         &IoStatusBlock,
1162                                         &SourceInformation,
1163                                         sizeof(SourceInformation),
1164                                         FileBasicInformation);
1165         if (NT_SUCCESS(Status))
1166         {
1167             /* Then, prepare to set it for destination */
1168             RtlZeroMemory(&DestinationInformation, sizeof(DestinationInformation));
1169             DestinationInformation.CreationTime.QuadPart = SourceInformation.CreationTime.QuadPart;
1170
1171             /* And set it, that's all folks! */
1172             Status = NtSetInformationFile(DestinationHandle,
1173                                           &IoStatusBlock,
1174                                           &DestinationInformation,
1175                                           sizeof(DestinationInformation),
1176                                           FileBasicInformation);
1177         }
1178
1179         if (!NT_SUCCESS(Status))
1180         {
1181             if (!(dwFlags & PRIV_ALLOW_NON_TRACKABLE))
1182             {
1183                 _SEH2_LEAVE;
1184             }
1185
1186             /* Remember the failure for later notification */
1187             if (NT_SUCCESS(OldStatus))
1188             {
1189                 OldStatus = Status;
1190             }
1191         }
1192
1193         /* If we could open with FILE_WRITE_DATA both source and destination,
1194          * then, notify
1195          */
1196         if (DestAccess & FILE_WRITE_DATA && SourceAccess & FILE_WRITE_DATA)
1197         {
1198             Status = BasepNotifyTrackingService(&SourceHandle,
1199                                                 &ObjectAttributesSource,
1200                                                 DestinationHandle,
1201                                                 &NtDestination);
1202 #if 1 // ReactOS HACK
1203             /* FIXME: To be removed once BasepNotifyTrackingService is implemented */
1204             if (Status == STATUS_NOT_IMPLEMENTED)
1205                 Status = STATUS_SUCCESS;
1206 #endif
1207             if (!NT_SUCCESS(Status))
1208             {
1209                 if (dwFlags & PRIV_ALLOW_NON_TRACKABLE)
1210                 {
1211                     if (NT_SUCCESS(OldStatus))
1212                         OldStatus = Status;
1213                 }
1214             }
1215         }
1216     }
1217     _SEH2_FINALLY
1218     {
1219         if (RelativeSource)
1220             RtlFreeHeap(RtlGetProcessHeap(), 0, RelativeSource);
1221
1222         if (RelativeDestination)
1223             RtlFreeHeap(RtlGetProcessHeap(), 0, RelativeDestination);
1224     }
1225     _SEH2_END;
1226
1227     /* If caller asked for source deletion, if everything succeed, proceed */
1228     if (NT_SUCCESS(Status) && dwFlags & PRIV_DELETE_ON_SUCCESS)
1229     {
1230         FileDispositionInfo.DeleteFile = TRUE;
1231
1232         Status = NtSetInformationFile(SourceHandle,
1233                                       &IoStatusBlock,
1234                                       &FileDispositionInfo,
1235                                       sizeof(FileDispositionInfo),
1236                                       FileDispositionInformation);
1237     }
1238
1239     /* Cleanup/close portion */
1240     if (DestinationHandle != INVALID_HANDLE_VALUE)
1241     {
1242         NtClose(DestinationHandle);
1243     }
1244
1245     if (SourceHandle != INVALID_HANDLE_VALUE)
1246     {
1247         NtClose(SourceHandle);
1248     }
1249
1250     /* Set last error if any, and quit */
1251     if (NT_SUCCESS(Status))
1252     {
1253         if (!NT_SUCCESS(OldStatus))
1254         {
1255             BaseSetLastNTError(OldStatus);
1256         }
1257     }
1258     else
1259     {
1260         BaseSetLastNTError(Status);
1261     }
1262
1263     return NT_SUCCESS(Status);
1264 }
1265
1266 /* EOF */