copy.c File Reference

#include <k32.h>
#include <debug.h>

Include dependency graph for copy.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
static NTSTATUS	CopyLoop (HANDLE FileHandleSource, HANDLE FileHandleDest, LARGE_INTEGER SourceFileSize, LPPROGRESS_ROUTINE lpProgressRoutine, LPVOID lpData, BOOL *pbCancel, BOOL *KeepDest)
static NTSTATUS	SetLastWriteTime (HANDLE FileHandle, LARGE_INTEGER LastWriteTime)
BOOL	BasepCopyFileExW (IN LPCWSTR lpExistingFileName, IN LPCWSTR lpNewFileName, IN LPPROGRESS_ROUTINE lpProgressRoutine OPTIONAL, IN LPVOID lpData OPTIONAL, IN LPBOOL pbCancel OPTIONAL, IN DWORD dwCopyFlags, IN DWORD dwBasepFlags, OUT LPHANDLE lpExistingHandle, OUT LPHANDLE lpNewHandle)
BOOL WINAPI	CopyFileExW (IN LPCWSTR lpExistingFileName, IN LPCWSTR lpNewFileName, IN LPPROGRESS_ROUTINE lpProgressRoutine OPTIONAL, IN LPVOID lpData OPTIONAL, IN LPBOOL pbCancel OPTIONAL, IN DWORD dwCopyFlags)
BOOL WINAPI	CopyFileExA (IN LPCSTR lpExistingFileName, IN LPCSTR lpNewFileName, IN LPPROGRESS_ROUTINE lpProgressRoutine OPTIONAL, IN LPVOID lpData OPTIONAL, IN LPBOOL pbCancel OPTIONAL, IN DWORD dwCopyFlags)
BOOL WINAPI	CopyFileA (IN LPCSTR lpExistingFileName, IN LPCSTR lpNewFileName, IN BOOL bFailIfExists)
BOOL WINAPI	CopyFileW (IN LPCWSTR lpExistingFileName, IN LPCWSTR lpNewFileName, IN BOOL bFailIfExists)
BOOL WINAPI	PrivCopyFileExW (IN LPCWSTR lpExistingFileName, IN LPCWSTR lpNewFileName, IN LPPROGRESS_ROUTINE lpProgressRoutine, IN LPVOID lpData, IN LPBOOL pbCancel, IN DWORD dwCopyFlags)

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 15 of file copy.c.

Function Documentation

BasepCopyFileExW()

BOOL BasepCopyFileExW	(	IN LPCWSTR	lpExistingFileName,
		IN LPCWSTR	lpNewFileName,
		IN LPPROGRESS_ROUTINE lpProgressRoutine	OPTIONAL,
		IN LPVOID lpData	OPTIONAL,
		IN LPBOOL pbCancel	OPTIONAL,
		IN DWORD	dwCopyFlags,
		IN DWORD	dwBasepFlags,
		OUT LPHANDLE	lpExistingHandle,
		OUT LPHANDLE	lpNewHandle
	)

Definition at line 202 of file copy.c.

{
    NTSTATUS errCode;
    HANDLE FileHandleSource, FileHandleDest;
    IO_STATUS_BLOCK IoStatusBlock;
    FILE_STANDARD_INFORMATION FileStandard;
    FILE_BASIC_INFORMATION FileBasic;
    BOOL RC = FALSE;
    BOOL KeepDestOnError = FALSE;
    DWORD SystemError;
 
    FileHandleSource = CreateFileW(lpExistingFileName,
                                   GENERIC_READ,
                                   FILE_SHARE_READ | FILE_SHARE_WRITE,
                                   NULL,
                                   OPEN_EXISTING,
                                   FILE_ATTRIBUTE_NORMAL|FILE_FLAG_NO_BUFFERING,
                                   NULL);
    if (INVALID_HANDLE_VALUE != FileHandleSource)
    {
        errCode = NtQueryInformationFile(FileHandleSource,
                                         &IoStatusBlock,
                                         &FileStandard,
                                         sizeof(FILE_STANDARD_INFORMATION),
                                         FileStandardInformation);
        if (!NT_SUCCESS(errCode))
        {
            TRACE("Status 0x%08x obtaining FileStandardInformation for source\n", errCode);
            BaseSetLastNTError(errCode);
        }
        else
        {
            errCode = NtQueryInformationFile(FileHandleSource,
                                             &IoStatusBlock,&FileBasic,
                                             sizeof(FILE_BASIC_INFORMATION),
                                             FileBasicInformation);
            if (!NT_SUCCESS(errCode))
            {
                TRACE("Status 0x%08x obtaining FileBasicInformation for source\n", errCode);
                BaseSetLastNTError(errCode);
            }
            else
            {
                FileHandleDest = CreateFileW(lpNewFileName,
                                             GENERIC_WRITE,
                                             FILE_SHARE_WRITE,
                                             NULL,
                                             dwCopyFlags ? CREATE_NEW : CREATE_ALWAYS,
                                             FileBasic.FileAttributes,
                                             NULL);
                if (INVALID_HANDLE_VALUE != FileHandleDest)
                {
                    errCode = CopyLoop(FileHandleSource,
                                       FileHandleDest,
                                       FileStandard.EndOfFile,
                                       lpProgressRoutine,
                                       lpData,
                                       pbCancel,
                                       &KeepDestOnError);
                    if (!NT_SUCCESS(errCode))
                    {
                        BaseSetLastNTError(errCode);
                    }
                    else
                    {
                        LARGE_INTEGER t;
 
                        t.QuadPart = FileBasic.LastWriteTime.QuadPart;
                        errCode = SetLastWriteTime(FileHandleDest, t);
                        if (!NT_SUCCESS(errCode))
                        {
                            BaseSetLastNTError(errCode);
                        }
                        else
                        {
                            RC = TRUE;
                        }
                    }
                    NtClose(FileHandleDest);
                    if (! RC && ! KeepDestOnError)
                    {
                        SystemError = GetLastError();
                        SetFileAttributesW(lpNewFileName, FILE_ATTRIBUTE_NORMAL);
                        DeleteFileW(lpNewFileName);
                        SetLastError(SystemError);
                    }
                }
                else
                {
                    WARN("Error %lu during opening of dest file\n", GetLastError());
                }
            }
        }
        NtClose(FileHandleSource);
    }
    else
    {
        WARN("Error %lu during opening of source file\n", GetLastError());
    }
 
    return RC;
}

Referenced by CopyFileExW(), MoveFileWithProgressW(), and PrivCopyFileExW().

CopyFileA()

BOOL WINAPI CopyFileA	(	IN LPCSTR	lpExistingFileName,
		IN LPCSTR	lpNewFileName,
		IN BOOL	bFailIfExists
	)

Definition at line 404 of file copy.c.

{
    BOOL Result = FALSE;
    UNICODE_STRING lpNewFileNameW;
    PUNICODE_STRING lpExistingFileNameW;
 
    lpExistingFileNameW = Basep8BitStringToStaticUnicodeString(lpExistingFileName);
    if (!lpExistingFileNameW)
    {
        return FALSE;
    }
 
    if (Basep8BitStringToDynamicUnicodeString(&lpNewFileNameW, lpNewFileName))
    {
        Result = CopyFileExW(lpExistingFileNameW->Buffer,
                             lpNewFileNameW.Buffer,
                             NULL,
                             NULL,
                             NULL,
                             (bFailIfExists ? COPY_FILE_FAIL_IF_EXISTS : 0));
 
        RtlFreeUnicodeString(&lpNewFileNameW);
    }
 
    return Result;
}

Referenced by copy_dll_file(), create_file_with_version(), generate_transform(), main(), START_TEST(), test_copy(), test_CopyFileA(), test_directory(), test_exes(), test_SearchPathA(), and test_states().

CopyFileExA()

BOOL WINAPI CopyFileExA	(	IN LPCSTR	lpExistingFileName,
		IN LPCSTR	lpNewFileName,
		IN LPPROGRESS_ROUTINE lpProgressRoutine	OPTIONAL,
		IN LPVOID lpData	OPTIONAL,
		IN LPBOOL pbCancel	OPTIONAL,
		IN DWORD	dwCopyFlags
	)

Definition at line 366 of file copy.c.

{
    BOOL Result = FALSE;
    UNICODE_STRING lpNewFileNameW;
    PUNICODE_STRING lpExistingFileNameW;
 
    lpExistingFileNameW = Basep8BitStringToStaticUnicodeString(lpExistingFileName);
    if (!lpExistingFileNameW)
    {
        return FALSE;
    }
 
    if (Basep8BitStringToDynamicUnicodeString(&lpNewFileNameW, lpNewFileName))
    {
        Result = CopyFileExW(lpExistingFileNameW->Buffer,
                             lpNewFileNameW.Buffer,
                             lpProgressRoutine,
                             lpData,
                             pbCancel,
                             dwCopyFlags);
 
        RtlFreeUnicodeString(&lpNewFileNameW);
    }
 
    return Result;
}

Referenced by test_CopyFileEx().

CopyFileExW()

BOOL WINAPI CopyFileExW	(	IN LPCWSTR	lpExistingFileName,
		IN LPCWSTR	lpNewFileName,
		IN LPPROGRESS_ROUTINE lpProgressRoutine	OPTIONAL,
		IN LPVOID lpData	OPTIONAL,
		IN LPBOOL pbCancel	OPTIONAL,
		IN DWORD	dwCopyFlags
	)

Definition at line 318 of file copy.c.

{
    BOOL Ret;
    HANDLE ExistingHandle, NewHandle;
 
    ExistingHandle = INVALID_HANDLE_VALUE;
    NewHandle = INVALID_HANDLE_VALUE;
 
    _SEH2_TRY
    {
        Ret = BasepCopyFileExW(lpExistingFileName,
                               lpNewFileName,
                               lpProgressRoutine,
                               lpData,
                               pbCancel,
                               dwCopyFlags,
                               0,
                               &ExistingHandle,
                               &NewHandle);
    }
    _SEH2_FINALLY
    {
        if (ExistingHandle != INVALID_HANDLE_VALUE)
        {
            CloseHandle(ExistingHandle);
        }
 
        if (NewHandle != INVALID_HANDLE_VALUE)
        {
            CloseHandle(NewHandle);
        }
    }
    _SEH2_END;
 
    return Ret;
}

Referenced by CopyFileA(), CopyFileExA(), CopyFileW(), SHNotifyCopyFileW(), and transfer_file_local().

CopyFileW()

BOOL WINAPI CopyFileW	(	IN LPCWSTR	lpExistingFileName,
		IN LPCWSTR	lpNewFileName,
		IN BOOL	bFailIfExists
	)

Definition at line 439 of file copy.c.

{
    return CopyFileExW(lpExistingFileName,
                       lpNewFileName,
                       NULL,
                       NULL,
                       NULL,
                       (bFailIfExists ? COPY_FILE_FAIL_IF_EXISTS : 0));
}

Referenced by apd_copyfile(), BackupIniFile(), copy_file(), CopyDirectory(), CryptCATAdminAddCatalog(), CFontExt::DoInstallFontFile(), DownloadBSC_OnStopBinding(), downloadcb_OnStopBinding(), CDeskLinkDropHandler::Drop(), GetVersionFromFileExW(), install_assembly(), install_policy(), InstallColorProfileW(), MainWnd_OnInstall(), MSI_OpenDatabaseW(), MSI_OpenPackageW(), CNewMenu::NewItemByNonCommand(), OpenMailer(), publish_patches(), ReplaceFileW(), SetupCopyOEMInfW(), SetupDecompressOrCopyFileW(), START_TEST(), test_CopyFileW(), TEST_Start(), test_wshshell(), CDownloadManager::ThreadFunc(), write_raw_resources(), and XCOPY_DoCopy().

CopyLoop()

static NTSTATUS CopyLoop ( HANDLE  FileHandleSource, HANDLE  FileHandleDest, LARGE_INTEGER  SourceFileSize, LPPROGRESS_ROUTINE  lpProgressRoutine, LPVOID  lpData, BOOL *  pbCancel, BOOL *  KeepDest  )

static

Definition at line 26 of file copy.c.

{
    NTSTATUS errCode;
    IO_STATUS_BLOCK IoStatusBlock;
    UCHAR *lpBuffer = NULL;
    SIZE_T RegionSize = 0x10000;
    LARGE_INTEGER BytesCopied;
    DWORD CallbackReason;
    DWORD ProgressResult;
    BOOL EndOfFileFound;
 
    *KeepDest = FALSE;
    errCode = NtAllocateVirtualMemory(NtCurrentProcess(),
                                      (PVOID *)&lpBuffer,
                                      0,
                                      &RegionSize,
                                      MEM_RESERVE | MEM_COMMIT,
                                      PAGE_READWRITE);
 
    if (NT_SUCCESS(errCode))
    {
        BytesCopied.QuadPart = 0;
        EndOfFileFound = FALSE;
        CallbackReason = CALLBACK_STREAM_SWITCH;
        while (! EndOfFileFound &&
                NT_SUCCESS(errCode) &&
                (NULL == pbCancel || ! *pbCancel))
        {
            if (NULL != lpProgressRoutine)
            {
                ProgressResult = (*lpProgressRoutine)(SourceFileSize,
                                                      BytesCopied,
                                                      SourceFileSize,
                                                      BytesCopied,
                                                      0,
                                                      CallbackReason,
                                                      FileHandleSource,
                                                      FileHandleDest,
                                                      lpData);
                switch (ProgressResult)
                {
                case PROGRESS_CANCEL:
                    TRACE("Progress callback requested cancel\n");
                    errCode = STATUS_REQUEST_ABORTED;
                    break;
                case PROGRESS_STOP:
                    TRACE("Progress callback requested stop\n");
                    errCode = STATUS_REQUEST_ABORTED;
                    *KeepDest = TRUE;
                    break;
                case PROGRESS_QUIET:
                    lpProgressRoutine = NULL;
                    break;
                case PROGRESS_CONTINUE:
                default:
                    break;
                }
                CallbackReason = CALLBACK_CHUNK_FINISHED;
            }
            if (NT_SUCCESS(errCode))
            {
                errCode = NtReadFile(FileHandleSource,
                                     NULL,
                                     NULL,
                                     NULL,
                                     (PIO_STATUS_BLOCK)&IoStatusBlock,
                                     lpBuffer,
                                     RegionSize,
                                     NULL,
                                     NULL);
                /* With sync read, 0 length + status success mean EOF:
                 * https://msdn.microsoft.com/en-us/library/windows/desktop/aa365467(v=vs.85).aspx
                 */
                if (NT_SUCCESS(errCode) && IoStatusBlock.Information == 0)
                {
                    errCode = STATUS_END_OF_FILE;
                }
                if (NT_SUCCESS(errCode) && (NULL == pbCancel || ! *pbCancel))
                {
                    errCode = NtWriteFile(FileHandleDest,
                                          NULL,
                                          NULL,
                                          NULL,
                                          (PIO_STATUS_BLOCK)&IoStatusBlock,
                                          lpBuffer,
                                          IoStatusBlock.Information,
                                          NULL,
                                          NULL);
                    if (NT_SUCCESS(errCode))
                    {
                        BytesCopied.QuadPart += IoStatusBlock.Information;
                    }
                    else
                    {
                        WARN("Error 0x%08x reading writing to dest\n", errCode);
                    }
                }
                else if (!NT_SUCCESS(errCode))
                {
                    if (STATUS_END_OF_FILE == errCode)
                    {
                        EndOfFileFound = TRUE;
                        errCode = STATUS_SUCCESS;
                    }
                    else
                    {
                        WARN("Error 0x%08x reading from source\n", errCode);
                    }
                }
            }
        }
 
        if (! EndOfFileFound && (NULL != pbCancel && *pbCancel))
        {
            TRACE("User requested cancel\n");
            errCode = STATUS_REQUEST_ABORTED;
        }
 
        NtFreeVirtualMemory(NtCurrentProcess(),
                            (PVOID *)&lpBuffer,
                            &RegionSize,
                            MEM_RELEASE);
    }
    else
    {
        TRACE("Error 0x%08x allocating buffer of %lu bytes\n", errCode, RegionSize);
    }
 
    return errCode;
}

Referenced by BasepCopyFileExW().

PrivCopyFileExW()

BOOL WINAPI PrivCopyFileExW	(	IN LPCWSTR	lpExistingFileName,
		IN LPCWSTR	lpNewFileName,
		IN LPPROGRESS_ROUTINE	lpProgressRoutine,
		IN LPVOID	lpData,
		IN LPBOOL	pbCancel,
		IN DWORD	dwCopyFlags
	)

Definition at line 457 of file copy.c.

{
    BOOL Ret;
    HANDLE ExistingHandle, NewHandle;
 
    ExistingHandle = INVALID_HANDLE_VALUE;
    NewHandle = INVALID_HANDLE_VALUE;
 
    /* Check for incompatible flags */
    if (dwCopyFlags & COPY_FILE_FAIL_IF_EXISTS && dwCopyFlags & BASEP_COPY_REPLACE)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    _SEH2_TRY
    {
        Ret = BasepCopyFileExW(lpExistingFileName,
                               lpNewFileName,
                               lpProgressRoutine,
                               lpData,
                               pbCancel,
                               dwCopyFlags & BASEP_COPY_PUBLIC_MASK,
                               dwCopyFlags & BASEP_COPY_BASEP_MASK,
                               &ExistingHandle,
                               &NewHandle);
    }
    _SEH2_FINALLY
    {
        if (ExistingHandle != INVALID_HANDLE_VALUE)
        {
            CloseHandle(ExistingHandle);
        }
 
        if (NewHandle != INVALID_HANDLE_VALUE)
        {
            CloseHandle(NewHandle);
        }
    }
    _SEH2_END;
 
    return Ret;
}

SetLastWriteTime()

static NTSTATUS SetLastWriteTime ( HANDLE  FileHandle, LARGE_INTEGER  LastWriteTime  )

static

Definition at line 166 of file copy.c.

{
    NTSTATUS errCode = STATUS_SUCCESS;
    IO_STATUS_BLOCK IoStatusBlock;
    FILE_BASIC_INFORMATION FileBasic;
 
    errCode = NtQueryInformationFile (FileHandle,
                                      &IoStatusBlock,
                                      &FileBasic,
                                      sizeof(FILE_BASIC_INFORMATION),
                                      FileBasicInformation);
    if (!NT_SUCCESS(errCode))
    {
        WARN("Error 0x%08x obtaining FileBasicInformation\n", errCode);
    }
    else
    {
        FileBasic.LastWriteTime.QuadPart = LastWriteTime.QuadPart;
        errCode = NtSetInformationFile (FileHandle,
                                        &IoStatusBlock,
                                        &FileBasic,
                                        sizeof(FILE_BASIC_INFORMATION),
                                        FileBasicInformation);
        if (!NT_SUCCESS(errCode))
        {
            WARN("Error 0x%0x setting LastWriteTime\n", errCode);
        }
    }
 
    return errCode;
}

Referenced by BasepCopyFileExW().