directory.c File Reference

#include "precomp.h"
#include <debug.h>

Include dependency graph for directory.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
BOOL WINAPI	CopyProfileDirectoryA (LPCSTR lpSourcePath, LPCSTR lpDestinationPath, DWORD dwFlags)
BOOL WINAPI	CopyProfileDirectoryW (LPCWSTR lpSourcePath, LPCWSTR lpDestinationPath, DWORD dwFlags)
BOOL	CopyDirectory (LPCWSTR lpDestinationPath, LPCWSTR lpSourcePath)
BOOL	CreateDirectoryPath (LPCWSTR lpPathName, LPSECURITY_ATTRIBUTES lpSecurityAttributes)
static BOOL	RecursiveRemoveDir (LPCWSTR lpPath)
BOOL	RemoveDirectoryPath (LPCWSTR lpPathName)

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 29 of file directory.c.

Function Documentation

CopyDirectory()

BOOL CopyDirectory	(	LPCWSTR	lpDestinationPath,
		LPCWSTR	lpSourcePath
	)

Definition at line 82 of file directory.c.

{
    WCHAR szFileName[MAX_PATH];
    WCHAR szFullSrcName[MAX_PATH];
    WCHAR szFullDstName[MAX_PATH];
    WIN32_FIND_DATAW FindFileData;
    LPWSTR lpSrcPtr;
    LPWSTR lpDstPtr;
    HANDLE hFind;
 
    DPRINT("CopyDirectory (%S, %S) called\n",
            lpDestinationPath, lpSourcePath);
 
    wcscpy(szFileName, lpSourcePath);
    wcscat(szFileName, L"\\*.*");
 
    hFind = FindFirstFileW(szFileName,
                           &FindFileData);
    if (hFind == INVALID_HANDLE_VALUE)
    {
        DPRINT1("Error: %lu\n", GetLastError());
        return FALSE;
    }
 
    wcscpy(szFullSrcName, lpSourcePath);
    lpSrcPtr = AppendBackslash(szFullSrcName);
 
    wcscpy(szFullDstName, lpDestinationPath);
    lpDstPtr = AppendBackslash(szFullDstName);
 
    for (;;)
    {
        if (wcscmp(FindFileData.cFileName, L".") &&
            wcscmp(FindFileData.cFileName, L".."))
        {
            wcscpy(lpSrcPtr, FindFileData.cFileName);
            wcscpy(lpDstPtr, FindFileData.cFileName);
 
            if (FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
            {
                DPRINT("Create directory: %S\n", szFullDstName);
                if (!CreateDirectoryExW(szFullSrcName, szFullDstName, NULL))
                {
                    if (GetLastError() != ERROR_ALREADY_EXISTS)
                    {
                        DPRINT1("Error: %lu\n", GetLastError());
 
                        FindClose(hFind);
                        return FALSE;
                    }
                }
 
                if (!CopyDirectory(szFullDstName, szFullSrcName))
                {
                    DPRINT1("Error: %lu\n", GetLastError());
 
                    FindClose(hFind);
                    return FALSE;
                }
            }
            else
            {
                DPRINT("Copy file: %S -> %S\n", szFullSrcName, szFullDstName);
                if (!CopyFileW(szFullSrcName, szFullDstName, FALSE))
                {
                    DPRINT1("Error: %lu\n", GetLastError());
 
                    FindClose(hFind);
                    return FALSE;
                }
            }
        }
 
        if (!FindNextFileW(hFind, &FindFileData))
        {
            if (GetLastError() != ERROR_NO_MORE_FILES)
            {
                DPRINT1("Error: %lu\n", GetLastError());
            }
 
            break;
        }
    }
 
    FindClose(hFind);
 
    DPRINT("CopyDirectory() done\n");
 
    return TRUE;
}

Referenced by CopyDirectory(), CopyProfileDirectoryW(), CopySystemProfile(), and CreateUserProfileExW().

CopyProfileDirectoryA()

BOOL WINAPI CopyProfileDirectoryA	(	LPCSTR	lpSourcePath,
		LPCSTR	lpDestinationPath,
		DWORD	dwFlags
	)

Definition at line 36 of file directory.c.

{
    UNICODE_STRING SrcPath;
    UNICODE_STRING DstPath;
    BOOL bResult;
 
    if (!RtlCreateUnicodeStringFromAsciiz(&SrcPath,
                                          (LPSTR)lpSourcePath))
    {
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return FALSE;
    }
 
    if (!RtlCreateUnicodeStringFromAsciiz(&DstPath,
                                          (LPSTR)lpDestinationPath))
    {
        RtlFreeUnicodeString(&SrcPath);
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return FALSE;
    }
 
    bResult = CopyProfileDirectoryW(SrcPath.Buffer,
                                    DstPath.Buffer,
                                    dwFlags);
 
    RtlFreeUnicodeString(&DstPath);
    RtlFreeUnicodeString(&SrcPath);
 
    return bResult;
}

CopyProfileDirectoryW()

BOOL WINAPI CopyProfileDirectoryW	(	LPCWSTR	lpSourcePath,
		LPCWSTR	lpDestinationPath,
		DWORD	dwFlags
	)

Definition at line 72 of file directory.c.

{
    /* FIXME: dwFlags are ignored! */
    return CopyDirectory(lpDestinationPath, lpSourcePath);
}

Referenced by CopyProfileDirectoryA().

CreateDirectoryPath()

BOOL CreateDirectoryPath	(	LPCWSTR	lpPathName,
		LPSECURITY_ATTRIBUTES	lpSecurityAttributes
	)

Definition at line 176 of file directory.c.

{
    WCHAR szPath[MAX_PATH];
    LPWSTR Ptr;
    DWORD dwError;
 
    DPRINT("CreateDirectoryPath() called\n");
 
    if (lpPathName == NULL || *lpPathName == 0)
        return TRUE;
 
    if (CreateDirectoryW(lpPathName,
                         lpSecurityAttributes))
        return TRUE;
 
    dwError = GetLastError();
    if (dwError == ERROR_ALREADY_EXISTS)
        return TRUE;
 
    wcscpy(szPath, lpPathName);
 
    if (wcslen(szPath) > 3 && szPath[1] == ':' && szPath[2] == '\\')
    {
        Ptr = &szPath[3];
    }
    else
    {
        Ptr = szPath;
    }
 
    while (Ptr != NULL)
    {
        Ptr = wcschr(Ptr, L'\\');
        if (Ptr != NULL)
            *Ptr = 0;
 
        DPRINT("CreateDirectory(%S)\n", szPath);
        if (!CreateDirectoryW(szPath,
                              lpSecurityAttributes))
        {
            dwError = GetLastError();
            if (dwError != ERROR_ALREADY_EXISTS)
                return FALSE;
        }
 
        if (Ptr != NULL)
        {
            *Ptr = L'\\';
            Ptr++;
        }
    }
 
    DPRINT("CreateDirectoryPath() done\n");
 
    return TRUE;
}

Referenced by AddDesktopItemW(), and CreateGroupW().

RecursiveRemoveDir()

static BOOL RecursiveRemoveDir ( LPCWSTR  lpPath )

static

Definition at line 237 of file directory.c.

{
    WCHAR szPath[MAX_PATH];
    WIN32_FIND_DATAW FindData;
    HANDLE hFind;
    BOOL bResult;
 
    wcscpy(szPath, lpPath);
    wcscat(szPath, L"\\*.*");
    DPRINT("Search path: '%S'\n", szPath);
 
    hFind = FindFirstFileW(szPath,
                           &FindData);
    if (hFind == INVALID_HANDLE_VALUE)
        return FALSE;
 
    bResult = TRUE;
    while (TRUE)
    {
        if (wcscmp(FindData.cFileName, L".") &&
            wcscmp(FindData.cFileName, L".."))
        {
            wcscpy(szPath, lpPath);
            wcscat(szPath, L"\\");
            wcscat(szPath, FindData.cFileName);
            DPRINT("File name: '%S'\n", szPath);
 
            if (FindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
            {
                DPRINT("Delete directory: '%S'\n", szPath);
 
                if (!RecursiveRemoveDir(szPath))
                {
                    bResult = FALSE;
                    break;
                }
 
                if (FindData.dwFileAttributes & FILE_ATTRIBUTE_READONLY)
                {
                    SetFileAttributesW(szPath,
                                       FindData.dwFileAttributes & ~FILE_ATTRIBUTE_READONLY);
                }
 
                if (!RemoveDirectoryW(szPath))
                {
                    bResult = FALSE;
                    break;
                }
            }
            else
            {
                DPRINT("Delete file: '%S'\n", szPath);
 
                if (FindData.dwFileAttributes & (FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_SYSTEM))
                {
                    SetFileAttributesW(szPath,
                                       FILE_ATTRIBUTE_NORMAL);
                }
 
                if (!DeleteFileW(szPath))
                {
                    bResult = FALSE;
                    break;
                }
            }
        }
 
        if (!FindNextFileW(hFind, &FindData))
        {
            if (GetLastError() != ERROR_NO_MORE_FILES)
            {
                DPRINT1("Error: %lu\n", GetLastError());
                bResult = FALSE;
                break;
            }
 
            break;
        }
    }
 
    FindClose(hFind);
 
    return bResult;
}

Referenced by RecursiveRemoveDir(), and RemoveDirectoryPath().

RemoveDirectoryPath()

BOOL RemoveDirectoryPath

(

LPCWSTR

lpPathName

)

Definition at line 324 of file directory.c.

{
    if (!RecursiveRemoveDir(lpPathName))
        return FALSE;
 
    DPRINT("Delete directory: '%S'\n", lpPathName);
    return RemoveDirectoryW(lpPathName);
}

Referenced by DeleteGroupW(), and DeleteProfileW().