ReactOS 0.4.16-dev-527-gdad3a09
Classes | Macros | Typedefs | Functions
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  bCommonItem,
LPCSTR  lpItemName,
LPCSTR  lpArguments,
LPCSTR  lpIconLocation,
INT  iIcon,
LPCSTR  lpWorkingDirectory,
WORD  wHotKey,
INT  iShowCmd 
)

Definition at line 157 of file desktop.c.

165{
166 UNICODE_STRING ItemName;
167 UNICODE_STRING Arguments;
168 UNICODE_STRING IconLocation;
169 UNICODE_STRING WorkingDirectory;
170 BOOL bResult;
171
172 if (!RtlCreateUnicodeStringFromAsciiz(&ItemName,
173 (LPSTR)lpItemName))
174 {
175 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
176 return FALSE;
177 }
178
179 if (!RtlCreateUnicodeStringFromAsciiz(&Arguments,
180 (LPSTR)lpArguments))
181 {
182 RtlFreeUnicodeString(&ItemName);
183 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
184 return FALSE;
185 }
186
187 if (!RtlCreateUnicodeStringFromAsciiz(&IconLocation,
188 (LPSTR)lpIconLocation))
189 {
190 RtlFreeUnicodeString(&Arguments);
191 RtlFreeUnicodeString(&ItemName);
192 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
193 return FALSE;
194 }
195
196 if (lpWorkingDirectory != NULL)
197 {
198 if (!RtlCreateUnicodeStringFromAsciiz(&WorkingDirectory,
199 (LPSTR)lpWorkingDirectory))
200 {
201 RtlFreeUnicodeString(&IconLocation);
202 RtlFreeUnicodeString(&Arguments);
203 RtlFreeUnicodeString(&ItemName);
204 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
205 return FALSE;
206 }
207 }
208
209 bResult = AddDesktopItemW(bCommonItem,
210 ItemName.Buffer,
211 Arguments.Buffer,
212 IconLocation.Buffer,
213 iIcon,
214 (lpWorkingDirectory != NULL) ? WorkingDirectory.Buffer : NULL,
215 wHotKey,
216 iShowCmd);
217
218 if (lpWorkingDirectory != NULL)
219 {
220 RtlFreeUnicodeString(&WorkingDirectory);
221 }
222
223 RtlFreeUnicodeString(&IconLocation);
224 RtlFreeUnicodeString(&Arguments);
225 RtlFreeUnicodeString(&ItemName);
226
227 return bResult;
228}
ERROR_NOT_ENOUGH_MEMORY
#define ERROR_NOT_ENOUGH_MEMORY
Definition: dderror.h:7
NULL
#define NULL
Definition: types.h:112
FALSE
#define FALSE
Definition: types.h:117
SetLastError
#define SetLastError(x)
Definition: compat.h:752
AddDesktopItemW
BOOL WINAPI AddDesktopItemW(BOOL bCommonDesktop, LPCWSTR lpItemName, LPCWSTR lpArguments, LPCWSTR lpIconLocation, INT iIcon, LPCWSTR lpWorkingDirectory, WORD wHotKey, INT iShowCmd)
Definition: desktop.c:233
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94
RtlCreateUnicodeStringFromAsciiz
NTSYSAPI BOOLEAN NTAPI RtlCreateUnicodeStringFromAsciiz(_Out_ PUNICODE_STRING Destination, _In_ PCSZ Source)
RtlFreeUnicodeString
NTSYSAPI VOID NTAPI RtlFreeUnicodeString(PUNICODE_STRING UnicodeString)
_UNICODE_STRING
Definition: env_spec_w32.h:368
_UNICODE_STRING::Buffer
PWSTR Buffer
Definition: env_spec_w32.h:371
LPSTR
char * LPSTR
Definition: xmlstorage.h:182

◆ AddDesktopItemW()

BOOL WINAPI AddDesktopItemW ( BOOL  bCommonDesktop,
LPCWSTR  lpItemName,
LPCWSTR  lpArguments,
LPCWSTR  lpIconLocation,
INT  iIcon,
LPCWSTR  lpWorkingDirectory,
WORD  wHotKey,
INT  iShowCmd 
)

Definition at line 233 of file desktop.c.

241{
242 DYN_FUNCS Ole32;
243 WCHAR szLinkPath[MAX_PATH];
244 WCHAR szArguments[MAX_PATH];
245 WCHAR szCommand[MAX_PATH];
246 WIN32_FIND_DATAW FindData;
247 HANDLE hFind;
248 LPWSTR Ptr;
249 DWORD dwLength;
250 IShellLinkW* psl;
251 IPersistFile* ppf;
252 HRESULT hr;
253 BOOL bResult;
254
255 DPRINT("AddDesktopItemW() called\n");
256
257 bResult = FALSE;
258
259 if (!GetDesktopPath(bCommonDesktop, szLinkPath))
260 {
261 DPRINT1("GetDesktopPath() failed\n");
262 return FALSE;
263 }
264 DPRINT("Desktop path: '%S'\n", szLinkPath);
265
266 /* Make sure the path exists */
267 hFind = FindFirstFileW(szLinkPath,
268 &FindData);
269 if (hFind == INVALID_HANDLE_VALUE)
270 {
271 DPRINT("'%S' does not exist\n", szLinkPath);
272
273 /* Create directory path */
274 if (!CreateDirectoryPath(szLinkPath, NULL))
275 return FALSE;
276 }
277 else
278 {
279 DPRINT("'%S' exists\n", szLinkPath);
280 FindClose(hFind);
281 }
282
283 /* Append backslash, item name and ".lnk" extension */
284 wcscat(szLinkPath, L"\\");
285 wcscat(szLinkPath, lpItemName);
286 wcscat(szLinkPath, L".lnk");
287 DPRINT("Link path: '%S'\n", szLinkPath);
288
289 /* Split 'lpArguments' string into command and arguments */
290 Ptr = wcschr(lpArguments, L' ');
291 DPRINT("Ptr %p lpArguments %p\n", Ptr, lpArguments);
292 if (Ptr != NULL)
293 {
294 dwLength = (DWORD)(Ptr - lpArguments);
295 DPRINT("dwLength %lu\n", dwLength);
296 memcpy(szCommand, lpArguments, dwLength * sizeof(WCHAR));
297 szCommand[dwLength] = 0;
298 Ptr++;
299 wcscpy(szArguments, Ptr);
300 }
301 else
302 {
303 wcscpy(szCommand, lpArguments);
304 szArguments[0] = 0;
305 }
306 DPRINT("szCommand: '%S'\n", szCommand);
307 DPRINT("szArguments: '%S'\n", szArguments);
308
309 /* Dynamically load ole32.dll */
310 if (!LoadDynamicImports(&DynOle32, &Ole32))
311 {
312 DPRINT1("USERENV: Unable to load OLE32.DLL\n");
313 return FALSE;
314 }
315
316 Ole32.fn.CoInitialize(NULL);
317
318 hr = Ole32.fn.CoCreateInstance(&CLSID_ShellLink,
319 NULL,
320 CLSCTX_INPROC_SERVER,
321 &IID_IShellLinkW,
322 (LPVOID*)&psl);
323 if (!SUCCEEDED(hr))
324 {
325 Ole32.fn.CoUninitialize();
326 UnloadDynamicImports(&Ole32);
327 return FALSE;
328 }
329
330 hr = psl->lpVtbl->QueryInterface(psl,
331 &IID_IPersistFile,
332 (LPVOID*)&ppf);
333 if (SUCCEEDED(hr))
334 {
335 psl->lpVtbl->SetDescription(psl,
336 lpItemName);
337
338 psl->lpVtbl->SetPath(psl,
339 szCommand);
340
341 psl->lpVtbl->SetArguments(psl,
342 szArguments);
343
344 psl->lpVtbl->SetIconLocation(psl,
345 lpIconLocation,
346 iIcon);
347
348 if (lpWorkingDirectory != NULL)
349 {
350 psl->lpVtbl->SetWorkingDirectory(psl,
351 lpWorkingDirectory);
352 }
353 else
354 {
355 psl->lpVtbl->SetWorkingDirectory(psl,
356 L"%HOMEDRIVE%%HOMEPATH%");
357 }
358
359 psl->lpVtbl->SetHotkey(psl,
360 wHotKey);
361
362 psl->lpVtbl->SetShowCmd(psl,
363 iShowCmd);
364
365 hr = ppf->lpVtbl->Save(ppf,
366 szLinkPath,
367 TRUE);
368 if (SUCCEEDED(hr))
369 bResult = TRUE;
370
371 ppf->lpVtbl->Release(ppf);
372 }
373
374 psl->lpVtbl->Release(psl);
375
376 Ole32.fn.CoUninitialize();
377
378 UnloadDynamicImports(&Ole32);
379
380 DPRINT("AddDesktopItemW() done\n");
381
382 return bResult;
383}
DPRINT1
#define DPRINT1
Definition: precomp.h:8
wcscat
wcscat
Definition: corecrt_wstring.h:101
wcscpy
wcscpy
Definition: corecrt_wstring.h:120
TRUE
#define TRUE
Definition: types.h:120
wcschr
#define wcschr
Definition: compat.h:17
INVALID_HANDLE_VALUE
#define INVALID_HANDLE_VALUE
Definition: compat.h:731
MAX_PATH
#define MAX_PATH
Definition: compat.h:34
dwLength
static DWORD DWORD * dwLength
Definition: fusion.c:86
FindFirstFileW
HANDLE WINAPI FindFirstFileW(IN LPCWSTR lpFileName, OUT LPWIN32_FIND_DATAW lpFindFileData)
Definition: find.c:320
FindClose
BOOL WINAPI FindClose(HANDLE hFindFile)
Definition: find.c:502
GetDesktopPath
static BOOL GetDesktopPath(BOOL bCommonPath, LPWSTR lpDesktopPath)
Definition: desktop.c:38
CreateDirectoryPath
BOOL CreateDirectoryPath(LPCWSTR lpPathName, LPSECURITY_ATTRIBUTES lpSecurityAttributes)
Definition: directory.c:176
DynOle32
DYN_MODULE DynOle32
Definition: misc.c:204
LoadDynamicImports
BOOL LoadDynamicImports(PDYN_MODULE Module, PDYN_FUNCS DynFuncs)
Definition: misc.c:223
UnloadDynamicImports
VOID UnloadDynamicImports(PDYN_FUNCS DynFuncs)
Definition: misc.c:259
DWORD
unsigned long DWORD
Definition: ntddk_ex.h:95
Ptr
_Must_inspect_result_ _In_ PFSRTL_PER_STREAM_CONTEXT Ptr
Definition: fsrtlfuncs.h:898
nsISupports::QueryInterface
nsresult QueryInterface(nsIIDRef riid, void **result)
nsISupports::Release
nsrefcnt Release()
SUCCEEDED
#define SUCCEEDED(hr)
Definition: intsafe.h:50
memcpy
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
DWORD
#define DWORD
Definition: nt_native.h:44
L
#define L(x)
Definition: ntvdm.h:50
IID_IPersistFile
const GUID IID_IPersistFile
hr
HRESULT hr
Definition: shlfolder.c:183
DPRINT
#define DPRINT
Definition: sndvol32.h:73
WIN32_FIND_DATAA
Definition: shtypes.idl:80
_DYN_FUNCS
Definition: internal.h:48
_DYN_FUNCS::fn
union _DYN_FUNCS::@573 fn
WCHAR
__wchar_t WCHAR
Definition: xmlstorage.h:180
LPWSTR
WCHAR * LPWSTR
Definition: xmlstorage.h:184

Referenced by AddDesktopItemA().

◆ AddItemA()

BOOL WINAPI AddItemA ( LPCSTR  lpGroupName,
BOOL  bCommonGroup,
LPCSTR  lpItemName,
LPCSTR  lpArguments,
LPCSTR  lpIconLocation,
INT  iIcon,
LPCSTR  lpWorkingDirectory,
WORD  wHotKey,
INT  iShowCmd 
)

Definition at line 552 of file desktop.c.

561{
562 UNICODE_STRING GroupName;
563 UNICODE_STRING ItemName;
564 UNICODE_STRING Arguments;
565 UNICODE_STRING IconLocation;
566 UNICODE_STRING WorkingDirectory;
567 BOOL bResult;
568
569 if (!RtlCreateUnicodeStringFromAsciiz(&ItemName,
570 (LPSTR)lpItemName))
571 {
572 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
573 return FALSE;
574 }
575
576 if (!RtlCreateUnicodeStringFromAsciiz(&Arguments,
577 (LPSTR)lpArguments))
578 {
579 RtlFreeUnicodeString(&ItemName);
580 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
581 return FALSE;
582 }
583
584 if (!RtlCreateUnicodeStringFromAsciiz(&IconLocation,
585 (LPSTR)lpIconLocation))
586 {
587 RtlFreeUnicodeString(&Arguments);
588 RtlFreeUnicodeString(&ItemName);
589 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
590 return FALSE;
591 }
592
593 if (lpGroupName != NULL)
594 {
595 if (!RtlCreateUnicodeStringFromAsciiz(&GroupName,
596 (LPSTR)lpGroupName))
597 {
598 RtlFreeUnicodeString(&IconLocation);
599 RtlFreeUnicodeString(&Arguments);
600 RtlFreeUnicodeString(&ItemName);
601 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
602 return FALSE;
603 }
604 }
605
606 if (lpWorkingDirectory != NULL)
607 {
608 if (!RtlCreateUnicodeStringFromAsciiz(&WorkingDirectory,
609 (LPSTR)lpWorkingDirectory))
610 {
611 if (lpGroupName != NULL)
612 {
613 RtlFreeUnicodeString(&GroupName);
614 }
615 RtlFreeUnicodeString(&IconLocation);
616 RtlFreeUnicodeString(&Arguments);
617 RtlFreeUnicodeString(&ItemName);
618 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
619 return FALSE;
620 }
621 }
622
623 bResult = AddItemW((lpGroupName != NULL) ? GroupName.Buffer : NULL,
624 bCommonGroup,
625 ItemName.Buffer,
626 Arguments.Buffer,
627 IconLocation.Buffer,
628 iIcon,
629 (lpWorkingDirectory != NULL) ? WorkingDirectory.Buffer : NULL,
630 wHotKey,
631 iShowCmd);
632
633 if (lpGroupName != NULL)
634 {
635 RtlFreeUnicodeString(&GroupName);
636 }
637
638 if (lpWorkingDirectory != NULL)
639 {
640 RtlFreeUnicodeString(&WorkingDirectory);
641 }
642
643 RtlFreeUnicodeString(&IconLocation);
644 RtlFreeUnicodeString(&Arguments);
645 RtlFreeUnicodeString(&ItemName);
646
647 return bResult;
648}
AddItemW
BOOL WINAPI AddItemW(LPCWSTR lpGroupName, BOOL bCommonGroup, LPCWSTR lpItemName, LPCWSTR lpArguments, LPCWSTR lpIconLocation, INT iIcon, LPCWSTR lpWorkingDirectory, WORD wHotKey, INT iShowCmd)
Definition: desktop.c:653

◆ AddItemW()

BOOL WINAPI AddItemW ( LPCWSTR  lpGroupName,
BOOL  bCommonGroup,
LPCWSTR  lpItemName,
LPCWSTR  lpArguments,
LPCWSTR  lpIconLocation,
INT  iIcon,
LPCWSTR  lpWorkingDirectory,
WORD  wHotKey,
INT  iShowCmd 
)

Definition at line 653 of file desktop.c.

662{
663 DYN_FUNCS Ole32;
664 WCHAR szLinkPath[MAX_PATH];
665 WCHAR szArguments[MAX_PATH];
666 WCHAR szCommand[MAX_PATH];
667 WIN32_FIND_DATAW FindData;
668 HANDLE hFind;
669 LPWSTR Ptr;
670 DWORD dwLength;
671 IShellLinkW* psl;
672 IPersistFile* ppf;
673 HRESULT hr;
674 BOOL bResult;
675
676 DPRINT("AddItemW() called\n");
677
678 bResult = FALSE;
679
680 if (!GetProgramsPath(bCommonGroup, szLinkPath))
681 {
682 DPRINT1("GetProgramsPath() failed\n");
683 return FALSE;
684 }
685
686 DPRINT("Programs path: '%S'\n", szLinkPath);
687
688 if (lpGroupName != NULL && *lpGroupName != 0)
689 {
690 wcscat(szLinkPath, L"\\");
691 wcscat(szLinkPath, lpGroupName);
692
693 /* Make sure the path exists */
694 hFind = FindFirstFileW(szLinkPath,
695 &FindData);
696 if (hFind == INVALID_HANDLE_VALUE)
697 {
698 DPRINT("'%S' does not exist\n", szLinkPath);
699 if (!CreateGroupW(lpGroupName,
700 bCommonGroup))
701 return FALSE;
702 }
703 else
704 {
705 DPRINT("'%S' exists\n", szLinkPath);
706 FindClose(hFind);
707 }
708 }
709
710 wcscat(szLinkPath, L"\\");
711 wcscat(szLinkPath, lpItemName);
712 wcscat(szLinkPath, L".lnk");
713 DPRINT("Link path: '%S'\n", szLinkPath);
714
715 /* Split 'lpArguments' string into command and arguments */
716 Ptr = wcschr(lpArguments, L' ');
717 DPRINT("Ptr %p lpArguments %p\n", Ptr, lpArguments);
718 if (Ptr != NULL)
719 {
720 dwLength = (DWORD)(Ptr - lpArguments);
721 DPRINT("dwLength %lu\n", dwLength);
722 memcpy(szCommand, lpArguments, dwLength * sizeof(WCHAR));
723 szCommand[dwLength] = 0;
724 Ptr++;
725 wcscpy(szArguments, Ptr);
726 }
727 else
728 {
729 wcscpy(szCommand, lpArguments);
730 szArguments[0] = 0;
731 }
732 DPRINT("szCommand: '%S'\n", szCommand);
733 DPRINT("szArguments: '%S'\n", szArguments);
734
735 /* Dynamically load ole32.dll */
736 if (!LoadDynamicImports(&DynOle32, &Ole32))
737 {
738 DPRINT1("USERENV: Unable to load OLE32.DLL\n");
739 return FALSE;
740 }
741
742 Ole32.fn.CoInitialize(NULL);
743
744 hr = Ole32.fn.CoCreateInstance(&CLSID_ShellLink,
745 NULL,
746 CLSCTX_INPROC_SERVER,
747 &IID_IShellLinkW,
748 (LPVOID*)&psl);
749 if (!SUCCEEDED(hr))
750 {
751 Ole32.fn.CoUninitialize();
752 UnloadDynamicImports(&Ole32);
753 return FALSE;
754 }
755
756 hr = psl->lpVtbl->QueryInterface(psl,
757 &IID_IPersistFile,
758 (LPVOID*)&ppf);
759 if (SUCCEEDED(hr))
760 {
761 psl->lpVtbl->SetDescription(psl,
762 lpItemName);
763
764 psl->lpVtbl->SetPath(psl,
765 szCommand);
766
767 psl->lpVtbl->SetArguments(psl,
768 szArguments);
769
770 psl->lpVtbl->SetIconLocation(psl,
771 lpIconLocation,
772 iIcon);
773
774 if (lpWorkingDirectory != NULL)
775 {
776 psl->lpVtbl->SetWorkingDirectory(psl,
777 lpWorkingDirectory);
778 }
779 else
780 {
781 psl->lpVtbl->SetWorkingDirectory(psl,
782 L"%HOMEDRIVE%%HOMEPATH%");
783 }
784
785 psl->lpVtbl->SetHotkey(psl,
786 wHotKey);
787
788 psl->lpVtbl->SetShowCmd(psl,
789 iShowCmd);
790
791 hr = ppf->lpVtbl->Save(ppf,
792 szLinkPath,
793 TRUE);
794 if (SUCCEEDED(hr))
795 bResult = TRUE;
796
797 ppf->lpVtbl->Release(ppf);
798 }
799
800 psl->lpVtbl->Release(psl);
801
802 Ole32.fn.CoUninitialize();
803 UnloadDynamicImports(&Ole32);
804
805 DPRINT("AddItemW() done\n");
806
807 return bResult;
808}
CreateGroupW
BOOL WINAPI CreateGroupW(LPCWSTR lpGroupName, BOOL bCommonGroup)
Definition: desktop.c:459
GetProgramsPath
static BOOL GetProgramsPath(BOOL bCommonPath, LPWSTR lpProgramsPath)
Definition: desktop.c:97

Referenced by AddItemA().

◆ CopyProfileDirectoryA()

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

Definition at line 36 of file directory.c.

39{
40 UNICODE_STRING SrcPath;
41 UNICODE_STRING DstPath;
42 BOOL bResult;
43
44 if (!RtlCreateUnicodeStringFromAsciiz(&SrcPath,
45 (LPSTR)lpSourcePath))
46 {
47 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
48 return FALSE;
49 }
50
51 if (!RtlCreateUnicodeStringFromAsciiz(&DstPath,
52 (LPSTR)lpDestinationPath))
53 {
54 RtlFreeUnicodeString(&SrcPath);
55 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
56 return FALSE;
57 }
58
59 bResult = CopyProfileDirectoryW(SrcPath.Buffer,
60 DstPath.Buffer,
61 dwFlags);
62
63 RtlFreeUnicodeString(&DstPath);
64 RtlFreeUnicodeString(&SrcPath);
65
66 return bResult;
67}
CopyProfileDirectoryW
BOOL WINAPI CopyProfileDirectoryW(LPCWSTR lpSourcePath, LPCWSTR lpDestinationPath, DWORD dwFlags)
Definition: directory.c:72
DstPath
IN HANDLE DstPath
Definition: fsutil.h:81
dwFlags
_In_ PCCERT_CONTEXT _In_ DWORD dwFlags
Definition: wincrypt.h:1176

◆ CopyProfileDirectoryW()

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

Definition at line 72 of file directory.c.

75{
76 /* FIXME: dwFlags are ignored! */
77 return CopyDirectory(lpDestinationPath, lpSourcePath);
78}
CopyDirectory
BOOL CopyDirectory(LPCWSTR lpDestinationPath, LPCWSTR lpSourcePath)
Definition: directory.c:82

Referenced by CopyProfileDirectoryA().

◆ CopySystemProfile()

BOOL WINAPI CopySystemProfile ( ULONG  )

◆ CreateEnvironmentBlock()

BOOL WINAPI CreateEnvironmentBlock ( LPVOID *  ,
HANDLE  ,
BOOL   
)

◆ CreateGroupA()

BOOL WINAPI CreateGroupA ( LPCSTR  lpGroupName,
BOOL  bCommonGroup 
)

Definition at line 436 of file desktop.c.

438{
439 UNICODE_STRING GroupName;
440 BOOL bResult;
441
442 if (!RtlCreateUnicodeStringFromAsciiz(&GroupName,
443 (LPSTR)lpGroupName))
444 {
445 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
446 return FALSE;
447 }
448
449 bResult = CreateGroupW(GroupName.Buffer, bCommonGroup);
450
451 RtlFreeUnicodeString(&GroupName);
452
453 return bResult;
454}

◆ CreateGroupW()

BOOL WINAPI CreateGroupW ( LPCWSTR  lpGroupName,
BOOL  bCommonGroup 
)

Definition at line 459 of file desktop.c.

461{
462 WCHAR szGroupPath[MAX_PATH];
463
464 DPRINT1("CreateGroupW() called\n");
465
466 if (lpGroupName == NULL || *lpGroupName == 0)
467 return TRUE;
468
469 if (!GetProgramsPath(bCommonGroup, szGroupPath))
470 {
471 DPRINT1("GetProgramsPath() failed\n");
472 return FALSE;
473 }
474 DPRINT1("Programs path: '%S'\n", szGroupPath);
475
476 wcscat(szGroupPath, L"\\");
477 wcscat(szGroupPath, lpGroupName);
478 DPRINT1("Group path: '%S'\n", szGroupPath);
479
480 /* Create directory path */
481 if (!CreateDirectoryPath (szGroupPath, NULL))
482 return FALSE;
483
484 /* FIXME: Notify the shell */
485
486 DPRINT1("CreateGroupW() done\n");
487
488 return TRUE;
489}

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  bCommonItem,
LPCSTR  lpItemName 
)

Definition at line 388 of file desktop.c.

390{
391 UNICODE_STRING ItemName;
392 BOOL bResult;
393
394 if (!RtlCreateUnicodeStringFromAsciiz(&ItemName,
395 (LPSTR)lpItemName))
396 {
397 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
398 return FALSE;
399 }
400
401 bResult = DeleteDesktopItemW(bCommonItem,
402 ItemName.Buffer);
403
404 RtlFreeUnicodeString(&ItemName);
405
406 return bResult;
407}
DeleteDesktopItemW
BOOL WINAPI DeleteDesktopItemW(BOOL bCommonItem, LPCWSTR lpItemName)
Definition: desktop.c:412

◆ DeleteDesktopItemW()

BOOL WINAPI DeleteDesktopItemW ( BOOL  bCommonItem,
LPCWSTR  lpItemName 
)

Definition at line 412 of file desktop.c.

414{
415 WCHAR szLinkPath[MAX_PATH];
416
417 DPRINT("DeleteDesktopItemW() called\n");
418
419 if (!GetDesktopPath(bCommonItem, szLinkPath))
420 {
421 DPRINT1("GetDesktopPath() failed\n");
422 return FALSE;
423 }
424
425 wcscat(szLinkPath, L"\\");
426 wcscat(szLinkPath, lpItemName);
427 wcscat(szLinkPath, L".lnk");
428 DPRINT("Link path: '%S'\n", szLinkPath);
429
430 return DeleteFileW (szLinkPath);
431}
DeleteFileW
BOOL WINAPI DeleteFileW(IN LPCWSTR lpFileName)
Definition: delete.c:39

Referenced by DeleteDesktopItemA().

◆ DeleteGroupA()

BOOL WINAPI DeleteGroupA ( LPCSTR  lpGroupName,
BOOL  bCommonGroup 
)

Definition at line 494 of file desktop.c.

496{
497 UNICODE_STRING GroupName;
498 BOOL bResult;
499
500 if (!RtlCreateUnicodeStringFromAsciiz(&GroupName,
501 (LPSTR)lpGroupName))
502 {
503 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
504 return FALSE;
505 }
506
507 bResult = DeleteGroupW(GroupName.Buffer, bCommonGroup);
508
509 RtlFreeUnicodeString(&GroupName);
510
511 return bResult;
512}
DeleteGroupW
BOOL WINAPI DeleteGroupW(LPCWSTR lpGroupName, BOOL bCommonGroup)
Definition: desktop.c:517

◆ DeleteGroupW()

BOOL WINAPI DeleteGroupW ( LPCWSTR  lpGroupName,
BOOL  bCommonGroup 
)

Definition at line 517 of file desktop.c.

519{
520 WCHAR szGroupPath[MAX_PATH];
521
522 DPRINT("DeleteGroupW() called\n");
523
524 if (lpGroupName == NULL || *lpGroupName == 0)
525 return TRUE;
526
527 if (!GetProgramsPath(bCommonGroup, szGroupPath))
528 {
529 DPRINT1("GetProgramsPath() failed\n");
530 return FALSE;
531 }
532 DPRINT("Programs path: '%S'\n", szGroupPath);
533
534 wcscat(szGroupPath, L"\\");
535 wcscat(szGroupPath, lpGroupName);
536 DPRINT("Group path: '%S'\n", szGroupPath);
537
538 /* Remove directory path */
539 if (!RemoveDirectoryPath (szGroupPath))
540 return FALSE;
541
542 /* FIXME: Notify the shell */
543
544 DPRINT("DeleteGroupW() done\n");
545
546 return TRUE;
547}
RemoveDirectoryPath
BOOL RemoveDirectoryPath(LPCWSTR lpPathName)
Definition: directory.c:324

Referenced by DeleteGroupA().

◆ DeleteItemA()

BOOL WINAPI DeleteItemA ( LPCSTR  lpGroupName,
BOOL  bCommonGroup,
LPCSTR  lpItemName,
BOOL  bDeleteGroup 
)

Definition at line 813 of file desktop.c.

817{
818 UNICODE_STRING GroupName;
819 UNICODE_STRING ItemName;
820 BOOL bResult;
821
822 if (lpGroupName != NULL)
823 {
824 if (!RtlCreateUnicodeStringFromAsciiz(&GroupName,
825 (LPSTR)lpGroupName))
826 {
827 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
828 return FALSE;
829 }
830 }
831
832 if (!RtlCreateUnicodeStringFromAsciiz(&ItemName,
833 (LPSTR)lpItemName))
834 {
835 if (lpGroupName != NULL)
836 {
837 RtlFreeUnicodeString(&GroupName);
838 }
839
840 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
841 return FALSE;
842 }
843
844 bResult = DeleteItemW((lpGroupName != NULL) ? GroupName.Buffer : NULL,
845 bCommonGroup,
846 ItemName.Buffer,
847 bDeleteGroup);
848
849 RtlFreeUnicodeString(&ItemName);
850 if (lpGroupName != NULL)
851 {
852 RtlFreeUnicodeString(&GroupName);
853 }
854
855 return bResult;
856}
DeleteItemW
BOOL WINAPI DeleteItemW(LPCWSTR lpGroupName, BOOL bCommonGroup, LPCWSTR lpItemName, BOOL bDeleteGroup)
Definition: desktop.c:861

◆ DeleteItemW()

BOOL WINAPI DeleteItemW ( LPCWSTR  lpGroupName,
BOOL  bCommonGroup,
LPCWSTR  lpItemName,
BOOL  bDeleteGroup 
)

Definition at line 861 of file desktop.c.

865{
866 WCHAR szItemPath[MAX_PATH];
867 LPWSTR Ptr;
868
869 DPRINT("DeleteItemW() called\n");
870
871 if (!GetProgramsPath(bCommonGroup, szItemPath))
872 {
873 DPRINT1("GetProgramsPath() failed\n");
874 return FALSE;
875 }
876 DPRINT("Programs path: '%S'\n", szItemPath);
877
878 if (lpGroupName != NULL && *lpGroupName != 0)
879 {
880 wcscat(szItemPath, L"\\");
881 wcscat(szItemPath, lpGroupName);
882 }
883
884 wcscat(szItemPath, L"\\");
885 wcscat(szItemPath, lpItemName);
886 wcscat(szItemPath, L".lnk");
887 DPRINT("Item path: '%S'\n", szItemPath);
888
889 if (!DeleteFileW(szItemPath))
890 return FALSE;
891
892 /* FIXME: Notify the shell */
893
894 if (bDeleteGroup)
895 {
896 Ptr = wcsrchr(szItemPath, L'\\');
897 if (Ptr == NULL)
898 return TRUE;
899
900 *Ptr = 0;
901 DPRINT("Item path: '%S'\n", szItemPath);
902 if (RemoveDirectoryW(szItemPath))
903 {
904 /* FIXME: Notify the shell */
905 }
906 }
907
908 DPRINT("DeleteItemW() done\n");
909
910 return TRUE;
911}
wcsrchr
#define wcsrchr
Definition: compat.h:16
RemoveDirectoryW
BOOL WINAPI RemoveDirectoryW(IN LPCWSTR lpPathName)
Definition: dir.c:732

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  hToken)

Definition at line 36 of file sid.c.

37{
38 PTOKEN_USER UserBuffer;
39 PTOKEN_USER TempBuffer;
40 NTSTATUS Status;
41 ULONG Length;
42 PSID pSid;
43
44 Length = 256;
45 UserBuffer = LocalAlloc(LPTR, Length);
46 if (UserBuffer == NULL)
47 {
48 return NULL;
49 }
50
51 Status = NtQueryInformationToken(hToken,
52 TokenUser,
53 (PVOID)UserBuffer,
54 Length,
55 &Length);
56 if (Status == STATUS_BUFFER_TOO_SMALL)
57 {
58 TempBuffer = LocalReAlloc(UserBuffer, Length, LMEM_MOVEABLE);
59 if (TempBuffer == NULL)
60 {
61 LocalFree(UserBuffer);
62 return NULL;
63 }
64
65 UserBuffer = TempBuffer;
66 Status = NtQueryInformationToken(hToken,
67 TokenUser,
68 (PVOID)UserBuffer,
69 Length,
70 &Length);
71 }
72
73 if (!NT_SUCCESS(Status))
74 {
75 LocalFree(UserBuffer);
76 return NULL;
77 }
78
79 Length = RtlLengthSid(UserBuffer->User.Sid);
80
81 pSid = LocalAlloc(LPTR, Length);
82 if (pSid == NULL)
83 {
84 LocalFree(UserBuffer);
85 return NULL;
86 }
87
88 Status = RtlCopySid(Length, pSid, UserBuffer->User.Sid);
89
90 LocalFree(UserBuffer);
91
92 if (!NT_SUCCESS(Status))
93 {
94 LocalFree(pSid);
95 return NULL;
96 }
97
98 return pSid;
99}
NTSTATUS
LONG NTSTATUS
Definition: precomp.h:26
NT_SUCCESS
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:33
Status
Status
Definition: gdiplustypes.h:25
LocalReAlloc
HLOCAL NTAPI LocalReAlloc(HLOCAL hMem, SIZE_T dwBytes, UINT uFlags)
Definition: heapmem.c:1625
LocalAlloc
HLOCAL NTAPI LocalAlloc(UINT uFlags, SIZE_T dwBytes)
Definition: heapmem.c:1390
LocalFree
HLOCAL NTAPI LocalFree(HLOCAL hMem)
Definition: heapmem.c:1594
RtlCopySid
NTSYSAPI BOOLEAN WINAPI RtlCopySid(DWORD, PSID, PSID)
pSid
static PSID pSid
Definition: security.c:74
RtlLengthSid
NTSYSAPI ULONG NTAPI RtlLengthSid(IN PSID Sid)
Definition: sid.c:150
Length
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:102
STATUS_BUFFER_TOO_SMALL
#define STATUS_BUFFER_TOO_SMALL
Definition: shellext.h:69
_SID_AND_ATTRIBUTES::Sid
PSID Sid
Definition: setypes.h:506
_SID
Definition: ms-dtyp.idl:198
_TOKEN_USER
Definition: setypes.h:1009
_TOKEN_USER::User
SID_AND_ATTRIBUTES User
Definition: setypes.h:1010
NtQueryInformationToken
_Must_inspect_result_ __kernel_entry NTSTATUS NTAPI NtQueryInformationToken(_In_ HANDLE TokenHandle, _In_ TOKEN_INFORMATION_CLASS TokenInformationClass, _Out_writes_bytes_to_opt_(TokenInformationLength, *ReturnLength) PVOID TokenInformation, _In_ ULONG TokenInformationLength, _Out_ PULONG ReturnLength)
Queries a specific type of information in regard of an access token based upon the information class....
Definition: tokencls.c:473
ULONG
uint32_t ULONG
Definition: typedefs.h:59
LMEM_MOVEABLE
#define LMEM_MOVEABLE
Definition: winbase.h:395
LPTR
#define LPTR
Definition: winbase.h:407
TokenUser
@ TokenUser
Definition: setypes.h:966

Referenced by CopySystemProfile(), and GetUserAndDomainName().

◆ InitializeProfiles()

BOOL WINAPI InitializeProfiles ( VOID  )

Definition at line 335 of file setup.c.

336{
337 LONG Error;
338 HKEY hKey;
339 DWORD dwLength;
340 WCHAR szProfilesPath[MAX_PATH];
341 WCHAR szBuffer[MAX_PATH];
342
343 DPRINT("InitializeProfiles()\n");
344
345 /* Load profiles directory path */
346 if (!LoadStringW(hInstance,
347 IDS_PROFILEPATH,
348 szBuffer,
349 ARRAYSIZE(szBuffer)))
350 {
351 DPRINT1("Error: %lu\n", GetLastError());
352 return FALSE;
353 }
354
355 Error = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
356 L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\ProfileList",
357 0,
358 KEY_SET_VALUE,
359 &hKey);
360 if (Error != ERROR_SUCCESS)
361 {
362 DPRINT1("Error: %lu\n", Error);
363 SetLastError((DWORD)Error);
364 return FALSE;
365 }
366
367 /* Expand it */
368 if (!ExpandEnvironmentStringsW(szBuffer,
369 szProfilesPath,
370 ARRAYSIZE(szProfilesPath)))
371 {
372 DPRINT1("Error: %lu\n", GetLastError());
373 RegCloseKey(hKey);
374 return FALSE;
375 }
376
377 /* Create profiles directory */
378 // FIXME: Security!
379 if (!CreateDirectoryW(szProfilesPath, NULL))
380 {
381 if (GetLastError() != ERROR_ALREADY_EXISTS)
382 {
383 DPRINT1("Error: %lu\n", GetLastError());
384 RegCloseKey(hKey);
385 return FALSE;
386 }
387 }
388
389 /* Store the profiles directory path (unexpanded) in the registry */
390 dwLength = (wcslen(szBuffer) + 1) * sizeof(WCHAR);
391 Error = RegSetValueExW(hKey,
392 L"ProfilesDirectory",
393 0,
394 REG_EXPAND_SZ,
395 (LPBYTE)szBuffer,
396 dwLength);
397 if (Error != ERROR_SUCCESS)
398 {
399 DPRINT1("Error: %lu\n", Error);
400 RegCloseKey(hKey);
401 SetLastError((DWORD)Error);
402 return FALSE;
403 }
404
405 /* Create 'Default User' profile directory path */
406 if (!CreateStandardProfile(szProfilesPath, hKey, &StandardProfiles[0]))
407 {
408 DPRINT1("CreateStandardProfile(L\"%S\") failed.\n", StandardProfiles[0].pszProfileName);
409 RegCloseKey(hKey);
410 return FALSE;
411 }
412
413 /* Create 'All Users' profile directory path */
414 if (!CreateStandardProfile(szProfilesPath, hKey, &StandardProfiles[1]))
415 {
416 DPRINT1("CreateStandardProfile(L\"%S\") failed.\n", StandardProfiles[1].pszProfileName);
417 RegCloseKey(hKey);
418 return FALSE;
419 }
420
421 RegCloseKey(hKey);
422
423 DPRINT("Success\n");
424
425 return TRUE;
426}
Error
BOOL Error
Definition: chkdsk.c:66
RegCloseKey
#define RegCloseKey(hKey)
Definition: registry.h:49
hInstance
HINSTANCE hInstance
Definition: charmap.c:19
ERROR_SUCCESS
#define ERROR_SUCCESS
Definition: deptool.c:10
ARRAYSIZE
#define ARRAYSIZE(array)
Definition: filtermapper.c:47
RegOpenKeyExW
LONG WINAPI RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult)
Definition: reg.c:3333
RegSetValueExW
LONG WINAPI RegSetValueExW(_In_ HKEY hKey, _In_ LPCWSTR lpValueName, _In_ DWORD Reserved, _In_ DWORD dwType, _In_ CONST BYTE *lpData, _In_ DWORD cbData)
Definition: reg.c:4882
ExpandEnvironmentStringsW
DWORD WINAPI ExpandEnvironmentStringsW(IN LPCWSTR lpSrc, IN LPWSTR lpDst, IN DWORD nSize)
Definition: environ.c:519
CreateDirectoryW
BOOL WINAPI CreateDirectoryW(IN LPCWSTR lpPathName, IN LPSECURITY_ATTRIBUTES lpSecurityAttributes)
Definition: dir.c:90
IDS_PROFILEPATH
#define IDS_PROFILEPATH
Definition: resources.h:11
StandardProfiles
static PROFILEPARAMS StandardProfiles[]
Definition: setup.c:82
CreateStandardProfile
static BOOL CreateStandardProfile(IN LPCWSTR pszProfilesPath, IN HKEY hProfileListKey, IN PPROFILEPARAMS pProfileParams)
Definition: setup.c:105
hKey
FxAutoRegKey hKey
Definition: fxdriverapikm.cpp:59
wcslen
_CRTIMP size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
ERROR_ALREADY_EXISTS
#define ERROR_ALREADY_EXISTS
Definition: disk.h:80
REG_EXPAND_SZ
#define REG_EXPAND_SZ
Definition: nt_native.h:1494
KEY_SET_VALUE
#define KEY_SET_VALUE
Definition: nt_native.h:1017
LONG
long LONG
Definition: pedump.c:60
LPBYTE
unsigned char * LPBYTE
Definition: typedefs.h:53
GetLastError
DWORD WINAPI GetLastError(void)
Definition: except.c:1042
HKEY_LOCAL_MACHINE
#define HKEY_LOCAL_MACHINE
Definition: winreg.h:12
LoadStringW
int WINAPI LoadStringW(_In_opt_ HINSTANCE hInstance, _In_ UINT uID, _Out_writes_to_(cchBufferMax, return+1) LPWSTR lpBuffer, _In_ int cchBufferMax)

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  )