userenv.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_PROFILEINFOA
struct	_PROFILEINFOW

Macros
#define	PI_NOUI   (1)
#define	PI_APPLYPOLICY   (2)
#define	CreateUserProfile   CreateUserProfileA
#define	CreateUserProfileEx   CreateUserProfileExA
#define	AddDesktopItem   AddDesktopItemA
#define	DeleteDesktopItem   DeleteDesktopItemA
#define	CreateGroup   CreateGroupA
#define	DeleteGroup   DeleteGroupA
#define	AddItem   AddItemA
#define	DeleteItem   DeleteItemA
#define	CopyProfileDirectory   CopyProfileDirectoryA
#define	LoadUserProfile   LoadUserProfileA
#define	GetAllUsersProfileDirectory   GetAllUsersProfileDirectoryA
#define	GetDefaultUserProfileDirectory   GetDefaultUserProfileDirectoryA
#define	GetProfilesDirectory   GetProfilesDirectoryA
#define	GetUserProfileDirectory   GetUserProfileDirectoryA

Typedefs
typedef struct _PROFILEINFOA	PROFILEINFOA
typedef struct _PROFILEINFOA *	LPPROFILEINFOA
typedef struct _PROFILEINFOW	PROFILEINFOW
typedef struct _PROFILEINFOW *	LPPROFILEINFOW
typedef PROFILEINFOA	PROFILEINFO
typedef LPPROFILEINFOA	LPPROFILEINFO

Functions
BOOL WINAPI	InitializeProfiles (VOID)
BOOL WINAPI	CreateUserProfileA (PSID, LPCSTR)
BOOL WINAPI	CreateUserProfileW (PSID, LPCWSTR)
BOOL WINAPI	CreateUserProfileExA (PSID, LPCSTR, LPCSTR, LPSTR, DWORD, BOOL)
BOOL WINAPI	CreateUserProfileExW (PSID, LPCWSTR, LPCWSTR, LPWSTR, DWORD, BOOL)
BOOL WINAPI	AddDesktopItemA (BOOL, LPCSTR, LPCSTR, LPCSTR, INT, LPCSTR, WORD, INT)
BOOL WINAPI	AddDesktopItemW (BOOL, LPCWSTR, LPCWSTR, LPCWSTR, INT, LPCWSTR, WORD, INT)
BOOL WINAPI	DeleteDesktopItemA (BOOL, LPCSTR)
BOOL WINAPI	DeleteDesktopItemW (BOOL, LPCWSTR)
BOOL WINAPI	CreateGroupA (LPCSTR, BOOL)
BOOL WINAPI	CreateGroupW (LPCWSTR, BOOL)
BOOL WINAPI	DeleteGroupA (LPCSTR, BOOL)
BOOL WINAPI	DeleteGroupW (LPCWSTR, BOOL)
BOOL WINAPI	AddItemA (LPCSTR, BOOL, LPCSTR, LPCSTR, LPCSTR, INT, LPCSTR, WORD, INT)
BOOL WINAPI	AddItemW (LPCWSTR, BOOL, LPCWSTR, LPCWSTR, LPCWSTR, INT, LPCWSTR, WORD, INT)
BOOL WINAPI	DeleteItemA (LPCSTR, BOOL, LPCSTR, BOOL)
BOOL WINAPI	DeleteItemW (LPCWSTR, BOOL, LPCWSTR, BOOL)
BOOL WINAPI	CopyProfileDirectoryA (LPCSTR, LPCSTR, DWORD)
BOOL WINAPI	CopyProfileDirectoryW (LPCWSTR, LPCWSTR, DWORD)
PSID WINAPI	GetUserSid (HANDLE)
BOOL WINAPI	CopySystemProfile (ULONG)
BOOL WINAPI	LoadUserProfileA (HANDLE, LPPROFILEINFOA)
BOOL WINAPI	LoadUserProfileW (HANDLE, LPPROFILEINFOW)
BOOL WINAPI	UnloadUserProfile (HANDLE, HANDLE)
BOOL WINAPI	GetAllUsersProfileDirectoryA (LPSTR, LPDWORD)
BOOL WINAPI	GetAllUsersProfileDirectoryW (LPWSTR, LPDWORD)
BOOL WINAPI	GetDefaultUserProfileDirectoryA (LPSTR, LPDWORD)
BOOL WINAPI	GetDefaultUserProfileDirectoryW (LPWSTR, LPDWORD)
BOOL WINAPI	GetProfilesDirectoryA (LPSTR, LPDWORD)
BOOL WINAPI	GetProfilesDirectoryW (LPWSTR, LPDWORD)
BOOL WINAPI	GetUserProfileDirectoryA (HANDLE, LPSTR, LPDWORD)
BOOL WINAPI	GetUserProfileDirectoryW (HANDLE, LPWSTR, LPDWORD)
BOOL WINAPI	CreateEnvironmentBlock (LPVOID *, HANDLE, BOOL)
BOOL WINAPI	DestroyEnvironmentBlock (LPVOID)
HANDLE WINAPI	EnterCriticalPolicySection (BOOL)
BOOL WINAPI	LeaveCriticalPolicySection (HANDLE)
BOOL WINAPI	RefreshPolicy (BOOL)
BOOL WINAPI	RegisterGPNotification (HANDLE, BOOL)
BOOL WINAPI	UnregisterGPNotification (HANDLE)

Macro Definition Documentation

AddDesktopItem

#define AddDesktopItem   AddDesktopItemA

Definition at line 205 of file userenv.h.

AddItem

#define AddItem   AddItemA

Definition at line 209 of file userenv.h.

CopyProfileDirectory

#define CopyProfileDirectory   CopyProfileDirectoryA

Definition at line 211 of file userenv.h.

CreateGroup

#define CreateGroup   CreateGroupA

Definition at line 207 of file userenv.h.

CreateUserProfile

#define CreateUserProfile   CreateUserProfileA

Definition at line 203 of file userenv.h.

CreateUserProfileEx

#define CreateUserProfileEx   CreateUserProfileExA

Definition at line 204 of file userenv.h.

DeleteDesktopItem

#define DeleteDesktopItem   DeleteDesktopItemA

Definition at line 206 of file userenv.h.

DeleteGroup

#define DeleteGroup   DeleteGroupA

Definition at line 208 of file userenv.h.

DeleteItem

#define DeleteItem   DeleteItemA

Definition at line 210 of file userenv.h.

GetAllUsersProfileDirectory

#define GetAllUsersProfileDirectory   GetAllUsersProfileDirectoryA

Definition at line 217 of file userenv.h.

GetDefaultUserProfileDirectory

#define GetDefaultUserProfileDirectory   GetDefaultUserProfileDirectoryA

Definition at line 218 of file userenv.h.

GetProfilesDirectory

#define GetProfilesDirectory   GetProfilesDirectoryA

Definition at line 219 of file userenv.h.

GetUserProfileDirectory

#define GetUserProfileDirectory   GetUserProfileDirectoryA

Definition at line 220 of file userenv.h.

LoadUserProfile

#define LoadUserProfile   LoadUserProfileA

Definition at line 216 of file userenv.h.

PI_APPLYPOLICY

#define PI_APPLYPOLICY   (2)

Definition at line 9 of file userenv.h.

PI_NOUI

#define PI_NOUI   (1)

Definition at line 8 of file userenv.h.

Typedef Documentation

LPPROFILEINFO

typedef LPPROFILEINFOA LPPROFILEINFO

Definition at line 201 of file userenv.h.

LPPROFILEINFOA

typedef struct _PROFILEINFOA * LPPROFILEINFOA

LPPROFILEINFOW

typedef struct _PROFILEINFOW * LPPROFILEINFOW

PROFILEINFO

typedef PROFILEINFOA PROFILEINFO

Definition at line 200 of file userenv.h.

PROFILEINFOA

typedef struct _PROFILEINFOA PROFILEINFOA

PROFILEINFOW

typedef struct _PROFILEINFOW PROFILEINFOW

Function Documentation

AddDesktopItemA()

BOOL WINAPI AddDesktopItemA	(	BOOL	,
		LPCSTR	,
		LPCSTR	,
		LPCSTR	,
		INT	,
		LPCSTR	,
		WORD	,
		INT
	)

Definition at line 157 of file desktop.c.

{
    UNICODE_STRING ItemName;
    UNICODE_STRING Arguments;
    UNICODE_STRING IconLocation;
    UNICODE_STRING WorkingDirectory;
    BOOL bResult;

    if (!RtlCreateUnicodeStringFromAsciiz(&ItemName,
                                          (LPSTR)lpItemName))
    {
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return FALSE;
    }

    if (!RtlCreateUnicodeStringFromAsciiz(&Arguments,
                                          (LPSTR)lpArguments))
    {
        RtlFreeUnicodeString(&ItemName);
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return FALSE;
    }

    if (!RtlCreateUnicodeStringFromAsciiz(&IconLocation,
                                          (LPSTR)lpIconLocation))
    {
        RtlFreeUnicodeString(&Arguments);
        RtlFreeUnicodeString(&ItemName);
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return FALSE;
    }

    if (lpWorkingDirectory != NULL)
    {
        if (!RtlCreateUnicodeStringFromAsciiz(&WorkingDirectory,
                                              (LPSTR)lpWorkingDirectory))
        {
            RtlFreeUnicodeString(&IconLocation);
            RtlFreeUnicodeString(&Arguments);
            RtlFreeUnicodeString(&ItemName);
            SetLastError(ERROR_NOT_ENOUGH_MEMORY);
            return FALSE;
        }
    }

    bResult = AddDesktopItemW(bCommonItem,
                              ItemName.Buffer,
                              Arguments.Buffer,
                              IconLocation.Buffer,
                              iIcon,
                              (lpWorkingDirectory != NULL) ? WorkingDirectory.Buffer : NULL,
                              wHotKey,
                              iShowCmd);

    if (lpWorkingDirectory != NULL)
    {
        RtlFreeUnicodeString(&WorkingDirectory);
    }

    RtlFreeUnicodeString(&IconLocation);
    RtlFreeUnicodeString(&Arguments);
    RtlFreeUnicodeString(&ItemName);

    return bResult;
}

AddDesktopItemW()

BOOL WINAPI AddDesktopItemW	(	BOOL	,
		LPCWSTR	,
		LPCWSTR	,
		LPCWSTR	,
		INT	,
		LPCWSTR	,
		WORD	,
		INT
	)

Definition at line 233 of file desktop.c.

{
    DYN_FUNCS Ole32;
    WCHAR szLinkPath[MAX_PATH];
    WCHAR szArguments[MAX_PATH];
    WCHAR szCommand[MAX_PATH];
    WIN32_FIND_DATAW FindData;
    HANDLE hFind;
    LPWSTR Ptr;
    DWORD dwLength;
    IShellLinkW* psl;
    IPersistFile* ppf;
    HRESULT hr;
    BOOL bResult;

    DPRINT("AddDesktopItemW() called\n");

    bResult = FALSE;

    if (!GetDesktopPath(bCommonDesktop, szLinkPath))
    {
        DPRINT1("GetDesktopPath() failed\n");
        return FALSE;
    }
    DPRINT("Desktop path: '%S'\n", szLinkPath);

    /* Make sure the path exists */
    hFind = FindFirstFileW(szLinkPath,
                           &FindData);
    if (hFind == INVALID_HANDLE_VALUE)
    {
        DPRINT("'%S' does not exist\n", szLinkPath);

        /* Create directory path */
        if (!CreateDirectoryPath(szLinkPath, NULL))
            return FALSE;
    }
    else
    {
        DPRINT("'%S' exists\n", szLinkPath);
        FindClose(hFind);
    }

    /* Append backslash, item name and ".lnk" extension */
    wcscat(szLinkPath, L"\\");
    wcscat(szLinkPath, lpItemName);
    wcscat(szLinkPath, L".lnk");
    DPRINT("Link path: '%S'\n", szLinkPath);

    /* Split 'lpArguments' string into command and arguments */
    Ptr = wcschr(lpArguments, L' ');
    DPRINT("Ptr %p  lpArguments %p\n", Ptr, lpArguments);
    if (Ptr != NULL)
    {
        dwLength = (DWORD)(Ptr - lpArguments);
        DPRINT("dwLength %lu\n", dwLength);
        memcpy(szCommand, lpArguments, dwLength * sizeof(WCHAR));
        szCommand[dwLength] = 0;
        Ptr++;
        wcscpy(szArguments, Ptr);
    }
    else
    {
        wcscpy(szCommand, lpArguments);
        szArguments[0] = 0;
    }
    DPRINT("szCommand: '%S'\n", szCommand);
    DPRINT("szArguments: '%S'\n", szArguments);

    /* Dynamically load ole32.dll */
    if (!LoadDynamicImports(&DynOle32, &Ole32))
    {
        DPRINT1("USERENV: Unable to load OLE32.DLL\n");
        return FALSE;
    }

    Ole32.fn.CoInitialize(NULL);

    hr = Ole32.fn.CoCreateInstance(&CLSID_ShellLink,
                                   NULL,
                                   CLSCTX_INPROC_SERVER,
                                   &IID_IShellLinkW,
                                   (LPVOID*)&psl);
    if (!SUCCEEDED(hr))
    {
        Ole32.fn.CoUninitialize();
        UnloadDynamicImports(&Ole32);
        return FALSE;
    }

    hr = psl->lpVtbl->QueryInterface(psl,
                                     &IID_IPersistFile,
                                     (LPVOID*)&ppf);
    if (SUCCEEDED(hr))
    {
        psl->lpVtbl->SetDescription(psl,
                                    lpItemName);

        psl->lpVtbl->SetPath(psl,
                             szCommand);

        psl->lpVtbl->SetArguments(psl,
                                  szArguments);

        psl->lpVtbl->SetIconLocation(psl,
                                     lpIconLocation,
                                     iIcon);

        if (lpWorkingDirectory != NULL)
        {
            psl->lpVtbl->SetWorkingDirectory(psl,
                                             lpWorkingDirectory);
        }
        else
        {
            psl->lpVtbl->SetWorkingDirectory(psl,
                                             L"%HOMEDRIVE%%HOMEPATH%");
        }

        psl->lpVtbl->SetHotkey(psl,
                               wHotKey);

        psl->lpVtbl->SetShowCmd(psl,
                                iShowCmd);

        hr = ppf->lpVtbl->Save(ppf,
                               szLinkPath,
                               TRUE);
        if (SUCCEEDED(hr))
            bResult = TRUE;

        ppf->lpVtbl->Release(ppf);
    }

    psl->lpVtbl->Release(psl);

    Ole32.fn.CoUninitialize();

    UnloadDynamicImports(&Ole32);

    DPRINT("AddDesktopItemW() done\n");

    return bResult;
}

Referenced by AddDesktopItemA().

AddItemA()

BOOL WINAPI AddItemA	(	LPCSTR	,
		BOOL	,
		LPCSTR	,
		LPCSTR	,
		LPCSTR	,
		INT	,
		LPCSTR	,
		WORD	,
		INT
	)

Definition at line 552 of file desktop.c.

{
    UNICODE_STRING GroupName;
    UNICODE_STRING ItemName;
    UNICODE_STRING Arguments;
    UNICODE_STRING IconLocation;
    UNICODE_STRING WorkingDirectory;
    BOOL bResult;

    if (!RtlCreateUnicodeStringFromAsciiz(&ItemName,
                                          (LPSTR)lpItemName))
    {
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return FALSE;
    }

    if (!RtlCreateUnicodeStringFromAsciiz(&Arguments,
                                          (LPSTR)lpArguments))
    {
        RtlFreeUnicodeString(&ItemName);
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return FALSE;
    }

    if (!RtlCreateUnicodeStringFromAsciiz(&IconLocation,
                                          (LPSTR)lpIconLocation))
    {
        RtlFreeUnicodeString(&Arguments);
        RtlFreeUnicodeString(&ItemName);
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return FALSE;
    }

    if (lpGroupName != NULL)
    {
        if (!RtlCreateUnicodeStringFromAsciiz(&GroupName,
                                              (LPSTR)lpGroupName))
        {
            RtlFreeUnicodeString(&IconLocation);
            RtlFreeUnicodeString(&Arguments);
            RtlFreeUnicodeString(&ItemName);
            SetLastError(ERROR_NOT_ENOUGH_MEMORY);
            return FALSE;
        }
    }

    if (lpWorkingDirectory != NULL)
    {
        if (!RtlCreateUnicodeStringFromAsciiz(&WorkingDirectory,
                                              (LPSTR)lpWorkingDirectory))
        {
            if (lpGroupName != NULL)
            {
                RtlFreeUnicodeString(&GroupName);
            }
            RtlFreeUnicodeString(&IconLocation);
            RtlFreeUnicodeString(&Arguments);
            RtlFreeUnicodeString(&ItemName);
            SetLastError(ERROR_NOT_ENOUGH_MEMORY);
            return FALSE;
        }
    }

    bResult = AddItemW((lpGroupName != NULL) ? GroupName.Buffer : NULL,
                       bCommonGroup,
                       ItemName.Buffer,
                       Arguments.Buffer,
                       IconLocation.Buffer,
                       iIcon,
                       (lpWorkingDirectory != NULL) ? WorkingDirectory.Buffer : NULL,
                       wHotKey,
                       iShowCmd);

    if (lpGroupName != NULL)
    {
        RtlFreeUnicodeString(&GroupName);
    }

    if (lpWorkingDirectory != NULL)
    {
        RtlFreeUnicodeString(&WorkingDirectory);
    }

    RtlFreeUnicodeString(&IconLocation);
    RtlFreeUnicodeString(&Arguments);
    RtlFreeUnicodeString(&ItemName);

    return bResult;
}

AddItemW()

BOOL WINAPI AddItemW	(	LPCWSTR	,
		BOOL	,
		LPCWSTR	,
		LPCWSTR	,
		LPCWSTR	,
		INT	,
		LPCWSTR	,
		WORD	,
		INT
	)

Definition at line 653 of file desktop.c.

{
    DYN_FUNCS Ole32;
    WCHAR szLinkPath[MAX_PATH];
    WCHAR szArguments[MAX_PATH];
    WCHAR szCommand[MAX_PATH];
    WIN32_FIND_DATAW FindData;
    HANDLE hFind;
    LPWSTR Ptr;
    DWORD dwLength;
    IShellLinkW* psl;
    IPersistFile* ppf;
    HRESULT hr;
    BOOL bResult;

    DPRINT("AddItemW() called\n");

    bResult = FALSE;

    if (!GetProgramsPath(bCommonGroup, szLinkPath))
    {
        DPRINT1("GetProgramsPath() failed\n");
        return FALSE;
    }

    DPRINT("Programs path: '%S'\n", szLinkPath);

    if (lpGroupName != NULL && *lpGroupName != 0)
    {
        wcscat(szLinkPath, L"\\");
        wcscat(szLinkPath, lpGroupName);

        /* Make sure the path exists */
        hFind = FindFirstFileW(szLinkPath,
                               &FindData);
        if (hFind == INVALID_HANDLE_VALUE)
        {
            DPRINT("'%S' does not exist\n", szLinkPath);
            if (!CreateGroupW(lpGroupName,
                              bCommonGroup))
                return FALSE;
        }
        else
        {
            DPRINT("'%S' exists\n", szLinkPath);
            FindClose(hFind);
        }
    }

    wcscat(szLinkPath, L"\\");
    wcscat(szLinkPath, lpItemName);
    wcscat(szLinkPath, L".lnk");
    DPRINT("Link path: '%S'\n", szLinkPath);

    /* Split 'lpArguments' string into command and arguments */
    Ptr = wcschr(lpArguments, L' ');
    DPRINT("Ptr %p  lpArguments %p\n", Ptr, lpArguments);
    if (Ptr != NULL)
    {
        dwLength = (DWORD)(Ptr - lpArguments);
        DPRINT("dwLength %lu\n", dwLength);
        memcpy(szCommand, lpArguments, dwLength * sizeof(WCHAR));
        szCommand[dwLength] = 0;
        Ptr++;
        wcscpy(szArguments, Ptr);
    }
    else
    {
        wcscpy(szCommand, lpArguments);
        szArguments[0] = 0;
    }
    DPRINT("szCommand: '%S'\n", szCommand);
    DPRINT("szArguments: '%S'\n", szArguments);

    /* Dynamically load ole32.dll */
    if (!LoadDynamicImports(&DynOle32, &Ole32))
    {
        DPRINT1("USERENV: Unable to load OLE32.DLL\n");
        return FALSE;
    }

    Ole32.fn.CoInitialize(NULL);

    hr = Ole32.fn.CoCreateInstance(&CLSID_ShellLink,
                                   NULL,
                                   CLSCTX_INPROC_SERVER,
                                   &IID_IShellLinkW,
                                   (LPVOID*)&psl);
    if (!SUCCEEDED(hr))
    {
        Ole32.fn.CoUninitialize();
        UnloadDynamicImports(&Ole32);
        return FALSE;
    }

    hr = psl->lpVtbl->QueryInterface(psl,
                                     &IID_IPersistFile,
                                     (LPVOID*)&ppf);
    if (SUCCEEDED(hr))
    {
        psl->lpVtbl->SetDescription(psl,
                                    lpItemName);

        psl->lpVtbl->SetPath(psl,
                             szCommand);

        psl->lpVtbl->SetArguments(psl,
                                  szArguments);

        psl->lpVtbl->SetIconLocation(psl,
                                     lpIconLocation,
                                     iIcon);

        if (lpWorkingDirectory != NULL)
        {
            psl->lpVtbl->SetWorkingDirectory(psl,
                                             lpWorkingDirectory);
        }
        else
        {
            psl->lpVtbl->SetWorkingDirectory(psl,
                                             L"%HOMEDRIVE%%HOMEPATH%");
        }

        psl->lpVtbl->SetHotkey(psl,
                               wHotKey);

        psl->lpVtbl->SetShowCmd(psl,
                                iShowCmd);

        hr = ppf->lpVtbl->Save(ppf,
                               szLinkPath,
                               TRUE);
        if (SUCCEEDED(hr))
            bResult = TRUE;

        ppf->lpVtbl->Release(ppf);
    }

    psl->lpVtbl->Release(psl);

    Ole32.fn.CoUninitialize();
    UnloadDynamicImports(&Ole32);

    DPRINT("AddItemW() done\n");

    return bResult;
}

Referenced by AddItemA().

CopyProfileDirectoryA()

BOOL WINAPI CopyProfileDirectoryA	(	LPCSTR	,
		LPCSTR	,
		DWORD
	)

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	,
		LPCWSTR	,
		DWORD
	)

Definition at line 72 of file directory.c.

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

Referenced by CopyProfileDirectoryA().

CopySystemProfile()

BOOL WINAPI CopySystemProfile

(

ULONG

)

CreateEnvironmentBlock()

BOOL WINAPI CreateEnvironmentBlock	(	LPVOID *	,
		HANDLE	,
		BOOL
	)

CreateGroupA()

BOOL WINAPI CreateGroupA	(	LPCSTR	,
		BOOL
	)

Definition at line 436 of file desktop.c.

{
    UNICODE_STRING GroupName;
    BOOL bResult;

    if (!RtlCreateUnicodeStringFromAsciiz(&GroupName,
                                          (LPSTR)lpGroupName))
    {
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return FALSE;
    }

    bResult = CreateGroupW(GroupName.Buffer, bCommonGroup);

    RtlFreeUnicodeString(&GroupName);

    return bResult;
}

CreateGroupW()

BOOL WINAPI CreateGroupW	(	LPCWSTR	,
		BOOL
	)

Definition at line 459 of file desktop.c.

{
    WCHAR szGroupPath[MAX_PATH];

    DPRINT1("CreateGroupW() called\n");

    if (lpGroupName == NULL || *lpGroupName == 0)
        return TRUE;

    if (!GetProgramsPath(bCommonGroup, szGroupPath))
    {
        DPRINT1("GetProgramsPath() failed\n");
        return FALSE;
    }
    DPRINT1("Programs path: '%S'\n", szGroupPath);

    wcscat(szGroupPath, L"\\");
    wcscat(szGroupPath, lpGroupName);
    DPRINT1("Group path: '%S'\n", szGroupPath);

    /* Create directory path */
    if (!CreateDirectoryPath (szGroupPath, NULL))
        return FALSE;

    /* FIXME: Notify the shell */

    DPRINT1("CreateGroupW() done\n");

    return TRUE;
}

Referenced by AddItemW(), and CreateGroupA().

CreateUserProfileA()

BOOL WINAPI CreateUserProfileA	(	PSID	,
		LPCSTR
	)

CreateUserProfileExA()

BOOL WINAPI CreateUserProfileExA	(	PSID	,
		LPCSTR	,
		LPCSTR	,
		LPSTR	,
		DWORD	,
		BOOL
	)

CreateUserProfileExW()

BOOL WINAPI CreateUserProfileExW	(	PSID	,
		LPCWSTR	,
		LPCWSTR	,
		LPWSTR	,
		DWORD	,
		BOOL
	)

CreateUserProfileW()

BOOL WINAPI CreateUserProfileW	(	PSID	,
		LPCWSTR
	)

DeleteDesktopItemA()

BOOL WINAPI DeleteDesktopItemA	(	BOOL	,
		LPCSTR
	)

Definition at line 388 of file desktop.c.

{
    UNICODE_STRING ItemName;
    BOOL bResult;

    if (!RtlCreateUnicodeStringFromAsciiz(&ItemName,
                                          (LPSTR)lpItemName))
    {
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return FALSE;
    }

    bResult = DeleteDesktopItemW(bCommonItem,
                                 ItemName.Buffer);

    RtlFreeUnicodeString(&ItemName);

    return bResult;
}

DeleteDesktopItemW()

BOOL WINAPI DeleteDesktopItemW	(	BOOL	,
		LPCWSTR
	)

Definition at line 412 of file desktop.c.

{
    WCHAR szLinkPath[MAX_PATH];

    DPRINT("DeleteDesktopItemW() called\n");

    if (!GetDesktopPath(bCommonItem, szLinkPath))
    {
        DPRINT1("GetDesktopPath() failed\n");
        return FALSE;
    }

    wcscat(szLinkPath, L"\\");
    wcscat(szLinkPath, lpItemName);
    wcscat(szLinkPath, L".lnk");
    DPRINT("Link path: '%S'\n", szLinkPath);

    return DeleteFileW (szLinkPath);
}

Referenced by DeleteDesktopItemA().

DeleteGroupA()

BOOL WINAPI DeleteGroupA	(	LPCSTR	,
		BOOL
	)

Definition at line 494 of file desktop.c.

{
    UNICODE_STRING GroupName;
    BOOL bResult;

    if (!RtlCreateUnicodeStringFromAsciiz(&GroupName,
                                          (LPSTR)lpGroupName))
    {
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return FALSE;
    }

    bResult = DeleteGroupW(GroupName.Buffer, bCommonGroup);

    RtlFreeUnicodeString(&GroupName);

    return bResult;
}

DeleteGroupW()

BOOL WINAPI DeleteGroupW	(	LPCWSTR	,
		BOOL
	)

Definition at line 517 of file desktop.c.

{
    WCHAR szGroupPath[MAX_PATH];

    DPRINT("DeleteGroupW() called\n");

    if (lpGroupName == NULL || *lpGroupName == 0)
        return TRUE;

    if (!GetProgramsPath(bCommonGroup, szGroupPath))
    {
        DPRINT1("GetProgramsPath() failed\n");
        return FALSE;
    }
    DPRINT("Programs path: '%S'\n", szGroupPath);

    wcscat(szGroupPath, L"\\");
    wcscat(szGroupPath, lpGroupName);
    DPRINT("Group path: '%S'\n", szGroupPath);

    /* Remove directory path */
    if (!RemoveDirectoryPath (szGroupPath))
        return FALSE;

    /* FIXME: Notify the shell */

    DPRINT("DeleteGroupW() done\n");

    return TRUE;
}

Referenced by DeleteGroupA().

DeleteItemA()

BOOL WINAPI DeleteItemA	(	LPCSTR	,
		BOOL	,
		LPCSTR	,
		BOOL
	)

Definition at line 813 of file desktop.c.

{
    UNICODE_STRING GroupName;
    UNICODE_STRING ItemName;
    BOOL bResult;

    if (lpGroupName != NULL)
    {
        if (!RtlCreateUnicodeStringFromAsciiz(&GroupName,
                                              (LPSTR)lpGroupName))
        {
            SetLastError(ERROR_NOT_ENOUGH_MEMORY);
            return FALSE;
        }
    }

    if (!RtlCreateUnicodeStringFromAsciiz(&ItemName,
                                          (LPSTR)lpItemName))
    {
        if (lpGroupName != NULL)
        {
            RtlFreeUnicodeString(&GroupName);
        }

        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return FALSE;
    }

    bResult = DeleteItemW((lpGroupName != NULL) ? GroupName.Buffer : NULL,
                          bCommonGroup,
                          ItemName.Buffer,
                          bDeleteGroup);

    RtlFreeUnicodeString(&ItemName);
    if (lpGroupName != NULL)
    {
        RtlFreeUnicodeString(&GroupName);
    }

    return bResult;
}

DeleteItemW()

BOOL WINAPI DeleteItemW	(	LPCWSTR	,
		BOOL	,
		LPCWSTR	,
		BOOL
	)

Definition at line 861 of file desktop.c.

{
    WCHAR szItemPath[MAX_PATH];
    LPWSTR Ptr;

    DPRINT("DeleteItemW() called\n");

    if (!GetProgramsPath(bCommonGroup, szItemPath))
    {
        DPRINT1("GetProgramsPath() failed\n");
        return FALSE;
    }
    DPRINT("Programs path: '%S'\n", szItemPath);

    if (lpGroupName != NULL && *lpGroupName != 0)
    {
        wcscat(szItemPath, L"\\");
        wcscat(szItemPath, lpGroupName);
    }

    wcscat(szItemPath, L"\\");
    wcscat(szItemPath, lpItemName);
    wcscat(szItemPath, L".lnk");
    DPRINT("Item path: '%S'\n", szItemPath);

    if (!DeleteFileW(szItemPath))
        return FALSE;

    /* FIXME: Notify the shell */

    if (bDeleteGroup)
    {
        Ptr = wcsrchr(szItemPath, L'\\');
        if (Ptr == NULL)
            return TRUE;

        *Ptr = 0;
        DPRINT("Item path: '%S'\n", szItemPath);
        if (RemoveDirectoryW(szItemPath))
        {
            /* FIXME: Notify the shell */
        }
    }

    DPRINT("DeleteItemW() done\n");

    return TRUE;
}

Referenced by DeleteItemA().

DestroyEnvironmentBlock()

BOOL WINAPI DestroyEnvironmentBlock

(

LPVOID

)

EnterCriticalPolicySection()

HANDLE WINAPI EnterCriticalPolicySection

(

BOOL

)

GetAllUsersProfileDirectoryA()

BOOL WINAPI GetAllUsersProfileDirectoryA	(	LPSTR	,
		LPDWORD
	)

GetAllUsersProfileDirectoryW()

BOOL WINAPI GetAllUsersProfileDirectoryW	(	LPWSTR	,
		LPDWORD
	)

GetDefaultUserProfileDirectoryA()

BOOL WINAPI GetDefaultUserProfileDirectoryA	(	LPSTR	,
		LPDWORD
	)

GetDefaultUserProfileDirectoryW()

BOOL WINAPI GetDefaultUserProfileDirectoryW	(	LPWSTR	,
		LPDWORD
	)

GetProfilesDirectoryA()

BOOL WINAPI GetProfilesDirectoryA	(	LPSTR	,
		LPDWORD
	)

GetProfilesDirectoryW()

BOOL WINAPI GetProfilesDirectoryW	(	LPWSTR	,
		LPDWORD
	)

GetUserProfileDirectoryA()

BOOL WINAPI GetUserProfileDirectoryA	(	HANDLE	,
		LPSTR	,
		LPDWORD
	)

GetUserProfileDirectoryW()

BOOL WINAPI GetUserProfileDirectoryW	(	HANDLE	,
		LPWSTR	,
		LPDWORD
	)

GetUserSid()

PSID WINAPI GetUserSid

(

HANDLE

)

Definition at line 36 of file sid.c.

{
    PTOKEN_USER UserBuffer;
    PTOKEN_USER TempBuffer;
    NTSTATUS Status;
    ULONG Length;
    PSID pSid;

    Length = 256;
    UserBuffer = LocalAlloc(LPTR, Length);
    if (UserBuffer == NULL)
    {
        return NULL;
    }

    Status = NtQueryInformationToken(hToken,
                                     TokenUser,
                                     (PVOID)UserBuffer,
                                     Length,
                                     &Length);
    if (Status == STATUS_BUFFER_TOO_SMALL)
    {
        TempBuffer = LocalReAlloc(UserBuffer, Length, LMEM_MOVEABLE);
        if (TempBuffer == NULL)
        {
            LocalFree(UserBuffer);
            return NULL;
        }

        UserBuffer = TempBuffer;
        Status = NtQueryInformationToken(hToken,
                                         TokenUser,
                                         (PVOID)UserBuffer,
                                         Length,
                                         &Length);
    }

    if (!NT_SUCCESS(Status))
    {
        LocalFree(UserBuffer);
        return NULL;
    }

        Length = RtlLengthSid(UserBuffer->User.Sid);

    pSid = LocalAlloc(LPTR, Length);
    if (pSid == NULL)
    {
        LocalFree(UserBuffer);
        return NULL;
    }

    Status = RtlCopySid(Length, pSid, UserBuffer->User.Sid);

    LocalFree(UserBuffer);

    if (!NT_SUCCESS(Status))
    {
        LocalFree(pSid);
        return NULL;
    }

    return pSid;
}

Referenced by CopySystemProfile(), and GetUserAndDomainName().

InitializeProfiles()

BOOL WINAPI InitializeProfiles

(

VOID

)

Definition at line 335 of file setup.c.

{
    LONG Error;
    HKEY hKey;
    DWORD dwLength;
    WCHAR szProfilesPath[MAX_PATH];
    WCHAR szBuffer[MAX_PATH];

    DPRINT("InitializeProfiles()\n");

    /* Load profiles directory path */
    if (!LoadStringW(hInstance,
                     IDS_PROFILEPATH,
                     szBuffer,
                     ARRAYSIZE(szBuffer)))
    {
        DPRINT1("Error: %lu\n", GetLastError());
        return FALSE;
    }

    Error = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
                          L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\ProfileList",
                          0,
                          KEY_SET_VALUE,
                          &hKey);
    if (Error != ERROR_SUCCESS)
    {
        DPRINT1("Error: %lu\n", Error);
        SetLastError((DWORD)Error);
        return FALSE;
    }

    /* Expand it */
    if (!ExpandEnvironmentStringsW(szBuffer,
                                   szProfilesPath,
                                   ARRAYSIZE(szProfilesPath)))
    {
        DPRINT1("Error: %lu\n", GetLastError());
        RegCloseKey(hKey);
        return FALSE;
    }

    /* Create profiles directory */
    // FIXME: Security!
    if (!CreateDirectoryW(szProfilesPath, NULL))
    {
        if (GetLastError() != ERROR_ALREADY_EXISTS)
        {
            DPRINT1("Error: %lu\n", GetLastError());
            RegCloseKey(hKey);
            return FALSE;
        }
    }

    /* Store the profiles directory path (unexpanded) in the registry */
    dwLength = (wcslen(szBuffer) + 1) * sizeof(WCHAR);
    Error = RegSetValueExW(hKey,
                           L"ProfilesDirectory",
                           0,
                           REG_EXPAND_SZ,
                           (LPBYTE)szBuffer,
                           dwLength);
    if (Error != ERROR_SUCCESS)
    {
        DPRINT1("Error: %lu\n", Error);
        RegCloseKey(hKey);
        SetLastError((DWORD)Error);
        return FALSE;
    }

    /* Create 'Default User' profile directory path */
    if (!CreateStandardProfile(szProfilesPath, hKey, &StandardProfiles[0]))
    {
        DPRINT1("CreateStandardProfile(L\"%S\") failed.\n", StandardProfiles[0].pszProfileName);
        RegCloseKey(hKey);
        return FALSE;
    }

    /* Create 'All Users' profile directory path */
    if (!CreateStandardProfile(szProfilesPath, hKey, &StandardProfiles[1]))
    {
        DPRINT1("CreateStandardProfile(L\"%S\") failed.\n", StandardProfiles[1].pszProfileName);
        RegCloseKey(hKey);
        return FALSE;
    }

    RegCloseKey(hKey);

    DPRINT("Success\n");

    return TRUE;
}

Referenced by InstallReactOS().

LeaveCriticalPolicySection()

BOOL WINAPI LeaveCriticalPolicySection

(

HANDLE

)

LoadUserProfileA()

BOOL WINAPI LoadUserProfileA	(	HANDLE	,
		LPPROFILEINFOA
	)

LoadUserProfileW()

BOOL WINAPI LoadUserProfileW	(	HANDLE	,
		LPPROFILEINFOW
	)

RefreshPolicy()

BOOL WINAPI RefreshPolicy

(

BOOL

)

RegisterGPNotification()

BOOL WINAPI RegisterGPNotification	(	HANDLE	,
		BOOL
	)

UnloadUserProfile()

BOOL WINAPI UnloadUserProfile	(	HANDLE	,
		HANDLE
	)

UnregisterGPNotification()

BOOL WINAPI UnregisterGPNotification

(

HANDLE

)