951 lines
29 KiB
C
951 lines
29 KiB
C
/*++
|
|
|
|
Copyright (c) 2000 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
sgmutil.c
|
|
|
|
Abstract:
|
|
|
|
Implements basic utilities used for source data gathering.
|
|
|
|
Author:
|
|
|
|
Jim Schmidt (jimschm) 14-May-2000
|
|
|
|
Revision History:
|
|
|
|
<alias> <date> <comments>
|
|
|
|
--*/
|
|
|
|
//
|
|
// Includes
|
|
//
|
|
|
|
#include "pch.h"
|
|
#include "v1p.h"
|
|
|
|
#define DBG_FOO "Foo"
|
|
|
|
//
|
|
// Strings
|
|
//
|
|
|
|
// None
|
|
|
|
//
|
|
// Constants
|
|
//
|
|
|
|
// None
|
|
|
|
//
|
|
// Macros
|
|
//
|
|
|
|
// None
|
|
|
|
//
|
|
// Types
|
|
//
|
|
|
|
// None
|
|
|
|
//
|
|
// Globals
|
|
//
|
|
|
|
// None
|
|
|
|
//
|
|
// Macro expansion list
|
|
//
|
|
|
|
#define USER_SHELL_FOLDERS \
|
|
DEFMAC(CSIDL_APPDATA, TEXT("AppData"), TEXT("CSIDL_APPDATA")) \
|
|
DEFMAC(CSIDL_APPDATA, TEXT("AppData"), TEXT("APPDATA")) \
|
|
DEFMAC(CSIDL_ADMINTOOLS, TEXT("Administrative Tools"), TEXT("CSIDL_ADMINTOOLS")) \
|
|
DEFMAC(CSIDL_ALTSTARTUP, TEXT("AltStartup"), TEXT("CSIDL_ALTSTARTUP")) \
|
|
DEFMAC(CSIDL_BITBUCKET, TEXT("RecycleBinFolder"), TEXT("CSIDL_BITBUCKET")) \
|
|
DEFMAC(CSIDL_CONTROLS, TEXT("ControlPanelFolder"), TEXT("CSIDL_CONTROLS")) \
|
|
DEFMAC(CSIDL_COOKIES, TEXT("Cookies"), TEXT("CSIDL_COOKIES")) \
|
|
DEFMAC(CSIDL_DESKTOP, TEXT("Desktop"), TEXT("CSIDL_DESKTOP")) \
|
|
DEFMAC(CSIDL_DESKTOPDIRECTORY, TEXT("Desktop"), TEXT("CSIDL_DESKTOPDIRECTORY")) \
|
|
DEFMAC(CSIDL_DRIVES, TEXT("DriveFolder"), TEXT("CSIDL_DRIVES")) \
|
|
DEFMAC(CSIDL_FAVORITES, TEXT("Favorites"), TEXT("CSIDL_FAVORITES")) \
|
|
DEFMAC(CSIDL_FONTS, TEXT("Fonts"), TEXT("CSIDL_FONTS")) \
|
|
DEFMAC(CSIDL_HISTORY, TEXT("History"), TEXT("CSIDL_HISTORY")) \
|
|
DEFMAC(CSIDL_INTERNET, TEXT("InternetFolder"), TEXT("CSIDL_INTERNET")) \
|
|
DEFMAC(CSIDL_INTERNET_CACHE, TEXT("Cache"), TEXT("CSIDL_INTERNET_CACHE")) \
|
|
DEFMAC(CSIDL_LOCAL_APPDATA, TEXT("Local AppData"), TEXT("CSIDL_LOCAL_APPDATA")) \
|
|
DEFMAC(CSIDL_MYPICTURES, TEXT("My Pictures"), TEXT("CSIDL_MYPICTURES")) \
|
|
DEFMAC(CSIDL_NETHOOD, TEXT("NetHood"), TEXT("CSIDL_NETHOOD")) \
|
|
DEFMAC(CSIDL_NETWORK, TEXT("NetworkFolder"), TEXT("CSIDL_NETWORK")) \
|
|
DEFMAC(CSIDL_PERSONAL, TEXT("Personal"), TEXT("CSIDL_PERSONAL")) \
|
|
DEFMAC(CSIDL_PROFILE, TEXT("Profile"), TEXT("CSIDL_PROFILE")) \
|
|
DEFMAC(CSIDL_PROGRAM_FILES, TEXT("ProgramFiles"), TEXT("CSIDL_PROGRAM_FILES")) \
|
|
DEFMAC(CSIDL_PROGRAM_FILES, TEXT("ProgramFiles"), TEXT("PROGRAMFILES")) \
|
|
DEFMAC(CSIDL_PROGRAM_FILES_COMMON, TEXT("CommonProgramFiles"), TEXT("CSIDL_PROGRAM_FILES_COMMON")) \
|
|
DEFMAC(CSIDL_PROGRAM_FILES_COMMON, TEXT("CommonProgramFiles"), TEXT("COMMONPROGRAMFILES")) \
|
|
DEFMAC(CSIDL_PROGRAMS, TEXT("Programs"), TEXT("CSIDL_PROGRAMS")) \
|
|
DEFMAC(CSIDL_RECENT, TEXT("Recent"), TEXT("CSIDL_RECENT")) \
|
|
DEFMAC(CSIDL_SENDTO, TEXT("SendTo"), TEXT("CSIDL_SENDTO")) \
|
|
DEFMAC(CSIDL_STARTMENU, TEXT("Start Menu"), TEXT("CSIDL_STARTMENU")) \
|
|
DEFMAC(CSIDL_STARTUP, TEXT("Startup"), TEXT("CSIDL_STARTUP")) \
|
|
DEFMAC(CSIDL_SYSTEM, TEXT("System"), TEXT("CSIDL_SYSTEM")) \
|
|
DEFMAC(CSIDL_TEMPLATES, TEXT("Templates"), TEXT("CSIDL_TEMPLATES")) \
|
|
DEFMAC(CSIDL_WINDOWS, TEXT("Windows"), TEXT("CSIDL_WINDOWS")) \
|
|
DEFMAC(CSIDL_MYDOCUMENTS, TEXT("My Documents"), TEXT("CSIDL_MYDOCUMENTS")) \
|
|
DEFMAC(CSIDL_MYMUSIC, TEXT("My Music"), TEXT("CSIDL_MYMUSIC")) \
|
|
DEFMAC(CSIDL_MYVIDEO, TEXT("My Video"), TEXT("CSIDL_MYVIDEO")) \
|
|
DEFMAC(CSIDL_SYSTEMX86, TEXT("SystemX86"), TEXT("CSIDL_SYSTEMX86")) \
|
|
DEFMAC(CSIDL_PROGRAM_FILESX86, TEXT("ProgramFilesX86"), TEXT("CSIDL_PROGRAM_FILESX86")) \
|
|
DEFMAC(CSIDL_PROGRAM_FILES_COMMONX86, TEXT("CommonProgramFilesX86"), TEXT("CSIDL_PROGRAM_FILES_COMMONX86")) \
|
|
DEFMAC(CSIDL_CONNECTIONS, TEXT("ConnectionsFolder"), TEXT("CSIDL_CONNECTIONS")) \
|
|
|
|
#define COMMON_SHELL_FOLDERS \
|
|
DEFMAC(CSIDL_COMMON_ADMINTOOLS, TEXT("Common Administrative Tools"), TEXT("CSIDL_COMMON_ADMINTOOLS")) \
|
|
DEFMAC(CSIDL_COMMON_ALTSTARTUP, TEXT("Common AltStartup"), TEXT("CSIDL_COMMON_ALTSTARTUP")) \
|
|
DEFMAC(CSIDL_COMMON_APPDATA, TEXT("Common AppData"), TEXT("CSIDL_COMMON_APPDATA")) \
|
|
DEFMAC(CSIDL_COMMON_DESKTOPDIRECTORY, TEXT("Common Desktop"), TEXT("CSIDL_COMMON_DESKTOPDIRECTORY")) \
|
|
DEFMAC(CSIDL_COMMON_DOCUMENTS, TEXT("Common Documents"), TEXT("CSIDL_COMMON_DOCUMENTS")) \
|
|
DEFMAC(CSIDL_COMMON_FAVORITES, TEXT("Common Favorites"), TEXT("CSIDL_COMMON_FAVORITES")) \
|
|
DEFMAC(CSIDL_COMMON_PROGRAMS, TEXT("Common Programs"), TEXT("CSIDL_COMMON_PROGRAMS")) \
|
|
DEFMAC(CSIDL_COMMON_STARTMENU, TEXT("Common Start Menu"), TEXT("CSIDL_COMMON_STARTMENU")) \
|
|
DEFMAC(CSIDL_COMMON_STARTUP, TEXT("Common Startup"), TEXT("CSIDL_COMMON_STARTUP")) \
|
|
DEFMAC(CSIDL_COMMON_TEMPLATES, TEXT("Common Templates"), TEXT("CSIDL_COMMON_TEMPLATES")) \
|
|
|
|
#define ENVIRONMENT_VARIABLES \
|
|
DEFMAC(TEXT("WINDIR")) \
|
|
DEFMAC(TEXT("SYSTEMROOT")) \
|
|
DEFMAC(TEXT("SYSTEM16")) \
|
|
DEFMAC(TEXT("SYSTEM32")) \
|
|
DEFMAC(TEXT("SYSTEM")) \
|
|
DEFMAC(TEXT("ALLUSERSPROFILE")) \
|
|
DEFMAC(TEXT("USERPROFILE")) \
|
|
DEFMAC(TEXT("PROFILESFOLDER")) \
|
|
DEFMAC(TEXT("APPDATA")) \
|
|
DEFMAC(TEXT("CSIDL_APPDATA")) \
|
|
DEFMAC(TEXT("CSIDL_ADMINTOOLS")) \
|
|
DEFMAC(TEXT("CSIDL_ALTSTARTUP")) \
|
|
DEFMAC(TEXT("CSIDL_BITBUCKET")) \
|
|
DEFMAC(TEXT("CSIDL_COMMON_ADMINTOOLS")) \
|
|
DEFMAC(TEXT("CSIDL_COMMON_ALTSTARTUP")) \
|
|
DEFMAC(TEXT("CSIDL_COMMON_APPDATA")) \
|
|
DEFMAC(TEXT("CSIDL_COMMON_DESKTOPDIRECTORY")) \
|
|
DEFMAC(TEXT("CSIDL_COMMON_DOCUMENTS")) \
|
|
DEFMAC(TEXT("CSIDL_COMMON_FAVORITES")) \
|
|
DEFMAC(TEXT("CSIDL_COMMON_PROGRAMS")) \
|
|
DEFMAC(TEXT("CSIDL_COMMON_STARTMENU")) \
|
|
DEFMAC(TEXT("CSIDL_COMMON_STARTUP")) \
|
|
DEFMAC(TEXT("CSIDL_COMMON_TEMPLATES")) \
|
|
DEFMAC(TEXT("CSIDL_CONTROLS")) \
|
|
DEFMAC(TEXT("CSIDL_COOKIES")) \
|
|
DEFMAC(TEXT("CSIDL_DESKTOP")) \
|
|
DEFMAC(TEXT("CSIDL_DESKTOPDIRECTORY")) \
|
|
DEFMAC(TEXT("CSIDL_DRIVES")) \
|
|
DEFMAC(TEXT("CSIDL_FAVORITES")) \
|
|
DEFMAC(TEXT("CSIDL_FONTS")) \
|
|
DEFMAC(TEXT("CSIDL_HISTORY")) \
|
|
DEFMAC(TEXT("CSIDL_INTERNET")) \
|
|
DEFMAC(TEXT("CSIDL_INTERNET_CACHE")) \
|
|
DEFMAC(TEXT("CSIDL_LOCAL_APPDATA")) \
|
|
DEFMAC(TEXT("CSIDL_MYPICTURES")) \
|
|
DEFMAC(TEXT("CSIDL_NETHOOD")) \
|
|
DEFMAC(TEXT("CSIDL_NETWORK")) \
|
|
DEFMAC(TEXT("CSIDL_PERSONAL")) \
|
|
DEFMAC(TEXT("CSIDL_PRINTERS")) \
|
|
DEFMAC(TEXT("CSIDL_PRINTHOOD")) \
|
|
DEFMAC(TEXT("CSIDL_PROFILE")) \
|
|
DEFMAC(TEXT("CSIDL_PROGRAM_FILES")) \
|
|
DEFMAC(TEXT("ProgramFiles")) \
|
|
DEFMAC(TEXT("CSIDL_PROGRAM_FILES_COMMON")) \
|
|
DEFMAC(TEXT("CommonProgramFiles")) \
|
|
DEFMAC(TEXT("CSIDL_PROGRAMS")) \
|
|
DEFMAC(TEXT("CSIDL_RECENT")) \
|
|
DEFMAC(TEXT("CSIDL_SENDTO")) \
|
|
DEFMAC(TEXT("CSIDL_STARTMENU")) \
|
|
DEFMAC(TEXT("CSIDL_STARTUP")) \
|
|
DEFMAC(TEXT("CSIDL_SYSTEM")) \
|
|
DEFMAC(TEXT("CSIDL_TEMPLATES")) \
|
|
DEFMAC(TEXT("CSIDL_WINDOWS")) \
|
|
DEFMAC(TEXT("CSIDL_MYDOCUMENTS")) \
|
|
DEFMAC(TEXT("CSIDL_MYMUSIC")) \
|
|
DEFMAC(TEXT("CSIDL_MYVIDEO")) \
|
|
DEFMAC(TEXT("CSIDL_SYSTEMX86")) \
|
|
DEFMAC(TEXT("CSIDL_PROGRAM_FILESX86")) \
|
|
DEFMAC(TEXT("CSIDL_PROGRAM_FILES_COMMONX86")) \
|
|
DEFMAC(TEXT("CSIDL_CONNECTIONS")) \
|
|
DEFMAC(TEXT("TEMP")) \
|
|
DEFMAC(TEXT("TMP")) \
|
|
|
|
//
|
|
// Private function prototypes
|
|
//
|
|
|
|
// None
|
|
|
|
//
|
|
// Macro expansion definition
|
|
//
|
|
|
|
// None
|
|
|
|
//
|
|
// Code
|
|
//
|
|
|
|
/*++
|
|
|
|
The shell folder functions here are duplicates of the RAS code. This is not
|
|
a good solution (we have two copies of the same code), but the designed
|
|
solution requires engine scope support. Scopes are the mechanism in which
|
|
major groups of data are separated from each other, such as the separation
|
|
of multiple users. A scope provides properties that affect objects within
|
|
the scope. For example, a user scope has properties such as domain name,
|
|
profile path, sid, and so on.
|
|
|
|
In order not to duplicate this code but still maintain modularity and system
|
|
independence, a scope module is needed for users. So instead of the code
|
|
below, the code would be something like
|
|
|
|
property = IsmGetScopeProperty ("userprofile");
|
|
|
|
This will be implemented if we want to (A) support multiple scopes, (B)
|
|
eliminate physical system access in non-type modules, or (C) clean up this
|
|
duplicated code.
|
|
|
|
--*/
|
|
|
|
typedef HRESULT (WINAPI SHGETFOLDERPATH)(HWND hwndOwner, int nFolder, HANDLE hToken, DWORD dwFlags, PTSTR pszPath);
|
|
typedef SHGETFOLDERPATH * PSHGETFOLDERPATH;
|
|
|
|
HANDLE
|
|
pGetShFolderLib (
|
|
VOID
|
|
)
|
|
{
|
|
static HANDLE lib;
|
|
|
|
if (lib) {
|
|
return lib;
|
|
}
|
|
|
|
lib = LoadLibrary (TEXT("shfolder.dll"));
|
|
if (!lib) {
|
|
LOG ((LOG_ERROR, (PCSTR) MSG_SHFOLDER_LOAD_ERROR));
|
|
}
|
|
|
|
return lib;
|
|
}
|
|
|
|
PTSTR
|
|
pFindSfPath (
|
|
IN PCTSTR FolderStr,
|
|
IN BOOL UserFolder
|
|
)
|
|
{
|
|
HKEY key;
|
|
REGSAM prevMode;
|
|
PCTSTR data;
|
|
PCTSTR result = NULL;
|
|
|
|
if (!result) {
|
|
if (UserFolder) {
|
|
prevMode = SetRegOpenAccessMode (KEY_QUERY_VALUE | KEY_ENUMERATE_SUB_KEYS);
|
|
key = OpenRegKeyStr (TEXT("HKCU\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\User Shell Folders"));
|
|
SetRegOpenAccessMode (prevMode);
|
|
} else {
|
|
prevMode = SetRegOpenAccessMode (KEY_QUERY_VALUE | KEY_ENUMERATE_SUB_KEYS);
|
|
key = OpenRegKeyStr (TEXT("HKLM\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\User Shell Folders"));
|
|
SetRegOpenAccessMode (prevMode);
|
|
}
|
|
|
|
if (key) {
|
|
data = GetRegValueString (key, FolderStr);
|
|
|
|
if (data) {
|
|
result = DuplicatePathString (data, 0);
|
|
FreeAlloc (data);
|
|
}
|
|
CloseRegKey (key);
|
|
}
|
|
}
|
|
|
|
if (!result) {
|
|
if (UserFolder) {
|
|
prevMode = SetRegOpenAccessMode (KEY_QUERY_VALUE | KEY_ENUMERATE_SUB_KEYS);
|
|
key = OpenRegKeyStr (TEXT("HKCU\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders"));
|
|
SetRegOpenAccessMode (prevMode);
|
|
} else {
|
|
prevMode = SetRegOpenAccessMode (KEY_QUERY_VALUE | KEY_ENUMERATE_SUB_KEYS);
|
|
key = OpenRegKeyStr (TEXT("HKLM\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders"));
|
|
SetRegOpenAccessMode (prevMode);
|
|
}
|
|
|
|
if (key) {
|
|
data = GetRegValueString (key, FolderStr);
|
|
|
|
if (data) {
|
|
result = DuplicatePathString (data, 0);
|
|
FreeAlloc (data);
|
|
}
|
|
CloseRegKey (key);
|
|
}
|
|
}
|
|
|
|
return (PTSTR) result;
|
|
}
|
|
|
|
PCTSTR
|
|
GetShellFolderPath (
|
|
IN INT Folder,
|
|
IN PCTSTR FolderStr,
|
|
IN BOOL UserFolder,
|
|
OUT PTSTR Buffer
|
|
)
|
|
{
|
|
HRESULT result;
|
|
LPITEMIDLIST pidl;
|
|
BOOL b;
|
|
LPMALLOC mallocFn;
|
|
HANDLE lib;
|
|
PSHGETFOLDERPATH shGetFolderPath;
|
|
PCTSTR sfPath = NULL;
|
|
PCTSTR expandedPath = NULL;
|
|
PTSTR endPtr = NULL;
|
|
TCHAR currUserProfile[MAX_TCHAR_PATH];
|
|
MIG_USERDATA userData;
|
|
|
|
result = SHGetMalloc (&mallocFn);
|
|
if (result != S_OK) {
|
|
return NULL;
|
|
}
|
|
|
|
if (FolderStr) {
|
|
|
|
//
|
|
// First try to find this in Software\Microsoft\Windows\CurrentVersion\Explorer\User Shell Folders
|
|
//
|
|
sfPath = pFindSfPath (FolderStr, UserFolder);
|
|
|
|
if (sfPath && *sfPath) {
|
|
//
|
|
// We found it.
|
|
//
|
|
StringCopyTcharCount (Buffer, sfPath, MAX_PATH);
|
|
expandedPath = IsmExpandEnvironmentString (IsmGetRealPlatform (), S_SYSENVVAR_GROUP, sfPath, NULL);
|
|
FreePathString (sfPath);
|
|
sfPath = NULL;
|
|
if (expandedPath && *expandedPath) {
|
|
StringCopyTcharCount (Buffer, expandedPath, MAX_PATH);
|
|
}
|
|
if (expandedPath) {
|
|
IsmReleaseMemory (expandedPath);
|
|
}
|
|
|
|
if (IsmGetMappedUserData (&userData)) {
|
|
// we have a mapped user, try to build it's default shell folder location
|
|
GetUserProfileRootPath (currUserProfile);
|
|
|
|
if (StringIMatch (currUserProfile, Buffer)) {
|
|
StringCopyTcharCount (Buffer, userData.UserProfileRoot, MAX_PATH);
|
|
} else {
|
|
AppendWack (currUserProfile);
|
|
|
|
if (StringIMatchTcharCount (currUserProfile, Buffer, TcharCount (currUserProfile))) {
|
|
|
|
endPtr = Buffer + TcharCount (currUserProfile);
|
|
sfPath = JoinPaths (userData.UserProfileRoot, endPtr);
|
|
StringCopyTcharCount (Buffer, sfPath, MAX_PATH);
|
|
FreePathString (sfPath);
|
|
}
|
|
}
|
|
}
|
|
|
|
return Buffer;
|
|
}
|
|
if (sfPath) {
|
|
FreePathString (sfPath);
|
|
}
|
|
|
|
lib = pGetShFolderLib ();
|
|
|
|
if (lib) {
|
|
#ifdef UNICODE
|
|
(FARPROC) shGetFolderPath = GetProcAddress (lib, "SHGetFolderPathW");
|
|
#else
|
|
(FARPROC) shGetFolderPath = GetProcAddress (lib, "SHGetFolderPathA");
|
|
#endif
|
|
if (shGetFolderPath) {
|
|
result = shGetFolderPath (NULL, Folder, NULL, 1, Buffer);
|
|
if (result != S_OK) {
|
|
return NULL;
|
|
}
|
|
expandedPath = IsmExpandEnvironmentString (IsmGetRealPlatform (), S_SYSENVVAR_GROUP, Buffer, NULL);
|
|
if (expandedPath && *expandedPath) {
|
|
StringCopyTcharCount (Buffer, expandedPath, MAX_PATH);
|
|
}
|
|
if (expandedPath) {
|
|
IsmReleaseMemory (expandedPath);
|
|
expandedPath = NULL;
|
|
}
|
|
|
|
if (IsmGetMappedUserData (&userData)) {
|
|
// we have a mapped user, try to build it's default shell folder location
|
|
GetUserProfileRootPath (currUserProfile);
|
|
|
|
if (StringIMatch (currUserProfile, Buffer)) {
|
|
StringCopyTcharCount (Buffer, userData.UserProfileRoot, MAX_PATH);
|
|
} else {
|
|
AppendWack (currUserProfile);
|
|
|
|
if (StringIMatchTcharCount (currUserProfile, Buffer, TcharCount (currUserProfile))) {
|
|
|
|
endPtr = Buffer + TcharCount (currUserProfile);
|
|
sfPath = JoinPaths (userData.UserProfileRoot, endPtr);
|
|
StringCopyTcharCount (Buffer, sfPath, MAX_PATH);
|
|
FreePathString (sfPath);
|
|
}
|
|
}
|
|
|
|
return Buffer;
|
|
|
|
} else {
|
|
// no mapped user, use the current user's path
|
|
result = shGetFolderPath (NULL, Folder, NULL, 0, Buffer);
|
|
}
|
|
if (result != S_OK) {
|
|
return NULL;
|
|
}
|
|
expandedPath = IsmExpandEnvironmentString (IsmGetRealPlatform (), S_SYSENVVAR_GROUP, Buffer, NULL);
|
|
if (expandedPath && *expandedPath) {
|
|
StringCopyTcharCount (Buffer, expandedPath, MAX_PATH);
|
|
}
|
|
if (expandedPath) {
|
|
IsmReleaseMemory (expandedPath);
|
|
expandedPath = NULL;
|
|
}
|
|
return Buffer;
|
|
} else {
|
|
result = SHGetSpecialFolderLocation (NULL, Folder, &pidl);
|
|
}
|
|
} else {
|
|
result = SHGetSpecialFolderLocation (NULL, Folder, &pidl);
|
|
}
|
|
|
|
if (result != S_OK) {
|
|
return NULL;
|
|
}
|
|
|
|
b = SHGetPathFromIDList (pidl, Buffer);
|
|
} else {
|
|
|
|
result = SHGetSpecialFolderLocation (NULL, Folder, &pidl);
|
|
|
|
if (result != S_OK) {
|
|
return NULL;
|
|
}
|
|
|
|
b = SHGetPathFromIDList (pidl, Buffer);
|
|
}
|
|
|
|
IMalloc_Free (mallocFn, pidl);
|
|
|
|
return b ? Buffer : NULL;
|
|
}
|
|
|
|
|
|
PCTSTR
|
|
GetAllUsersProfilePath (
|
|
OUT PTSTR Buffer
|
|
)
|
|
{
|
|
HKEY key;
|
|
REGSAM prevMode;
|
|
PCTSTR data;
|
|
PCTSTR expData;
|
|
|
|
prevMode = SetRegOpenAccessMode (KEY_QUERY_VALUE | KEY_ENUMERATE_SUB_KEYS);
|
|
key = OpenRegKeyStr (TEXT("HKLM\\SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\ProfileList"));
|
|
SetRegOpenAccessMode (prevMode);
|
|
|
|
if (key) {
|
|
|
|
data = GetRegValueString (key, TEXT("ProfilesDirectory"));
|
|
|
|
if (data) {
|
|
expData = IsmExpandEnvironmentString (IsmGetRealPlatform (), S_SYSENVVAR_GROUP, data, NULL);
|
|
StringCopyByteCount (Buffer, expData, MAX_PATH);
|
|
IsmReleaseMemory (expData);
|
|
FreeAlloc (data);
|
|
} else {
|
|
GetWindowsDirectory (Buffer, MAX_PATH);
|
|
StringCopy (AppendWack (Buffer), TEXT("Profiles"));
|
|
}
|
|
|
|
data = GetRegValueString (key, TEXT("AllUsersProfile"));
|
|
|
|
if (data) {
|
|
StringCopy (AppendWack (Buffer), data);
|
|
FreeAlloc (data);
|
|
} else {
|
|
StringCopy (AppendWack (Buffer), TEXT("All Users"));
|
|
}
|
|
|
|
CloseRegKey (key);
|
|
return Buffer;
|
|
}
|
|
|
|
GetWindowsDirectory (Buffer, MAX_PATH);
|
|
return Buffer;
|
|
}
|
|
|
|
PCTSTR
|
|
GetProfilesFolderPath (
|
|
OUT PTSTR Buffer
|
|
)
|
|
{
|
|
HKEY key;
|
|
REGSAM prevMode;
|
|
PCTSTR data;
|
|
PCTSTR expData;
|
|
|
|
prevMode = SetRegOpenAccessMode (KEY_QUERY_VALUE | KEY_ENUMERATE_SUB_KEYS);
|
|
key = OpenRegKeyStr (TEXT("HKLM\\SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\ProfileList"));
|
|
SetRegOpenAccessMode (prevMode);
|
|
|
|
if (key) {
|
|
|
|
data = GetRegValueString (key, TEXT("ProfilesDirectory"));
|
|
|
|
if (data) {
|
|
expData = IsmExpandEnvironmentString (IsmGetRealPlatform (), S_SYSENVVAR_GROUP, data, NULL);
|
|
StringCopyByteCount (Buffer, expData, MAX_PATH);
|
|
IsmReleaseMemory (expData);
|
|
FreeAlloc (data);
|
|
} else {
|
|
GetWindowsDirectory (Buffer, MAX_PATH);
|
|
StringCopy (AppendWack (Buffer), TEXT("Profiles"));
|
|
}
|
|
|
|
CloseRegKey (key);
|
|
return Buffer;
|
|
}
|
|
|
|
GetWindowsDirectory (Buffer, MAX_PATH);
|
|
return Buffer;
|
|
}
|
|
|
|
PCTSTR
|
|
GetUserProfileRootPath (
|
|
OUT PTSTR Buffer
|
|
)
|
|
{
|
|
HKEY key;
|
|
REGSAM prevMode;
|
|
PDWORD data;
|
|
DWORD size;
|
|
|
|
//
|
|
// For Win2k and higher, use the shell
|
|
//
|
|
|
|
if (GetShellFolderPath (CSIDL_PROFILE, NULL, FALSE, Buffer)) {
|
|
return Buffer;
|
|
}
|
|
|
|
//
|
|
// For NT 4, use the environment
|
|
//
|
|
|
|
if (GetEnvironmentVariable (TEXT("USERPROFILE"), Buffer, MAX_PATH)) {
|
|
return Buffer;
|
|
}
|
|
|
|
//
|
|
// For Win9x, are profiles enabled? If so, return %windir%\profiles\%user%.
|
|
// If not, return %windir%.
|
|
//
|
|
|
|
GetWindowsDirectory (Buffer, MAX_PATH);
|
|
|
|
prevMode = SetRegOpenAccessMode (KEY_QUERY_VALUE | KEY_ENUMERATE_SUB_KEYS);
|
|
key = OpenRegKeyStr (TEXT("HKLM\\Network\\Logon"));
|
|
SetRegOpenAccessMode (prevMode);
|
|
if (key) {
|
|
|
|
data = GetRegValueDword (key, TEXT("UserProfiles"));
|
|
|
|
if (data && *data) {
|
|
StringCat (Buffer, TEXT("\\Profiles\\"));
|
|
|
|
size = MAX_PATH;
|
|
GetUserName (GetEndOfString (Buffer), &size);
|
|
|
|
FreeAlloc (data);
|
|
}
|
|
|
|
CloseRegKey (key);
|
|
}
|
|
|
|
return Buffer;
|
|
}
|
|
|
|
|
|
PCTSTR
|
|
IsValidUncPath (
|
|
IN PCTSTR Path
|
|
)
|
|
{
|
|
BOOL needNonWack = FALSE;
|
|
BOOL wackRequired = TRUE;
|
|
INT wacks = 0;
|
|
|
|
while (*Path) {
|
|
|
|
if (_tcsnextc (Path) == TEXT('\\')) {
|
|
|
|
if (needNonWack) {
|
|
break;
|
|
}
|
|
|
|
wacks++;
|
|
if (wacks != 1) {
|
|
needNonWack = TRUE;
|
|
wackRequired = FALSE;
|
|
}
|
|
|
|
Path++;
|
|
|
|
} else {
|
|
//
|
|
// Note: it would be nice to validate the non-wack characters against the
|
|
// legal unc charset
|
|
//
|
|
|
|
if (needNonWack) {
|
|
if (wacks == 3) {
|
|
//
|
|
// Found \\x\x syntax; it's a UNC path
|
|
//
|
|
|
|
do {
|
|
Path = _tcsinc (Path);
|
|
} while (*Path && _tcsnextc (Path) != TEXT('\\'));
|
|
|
|
MYASSERT (*Path == 0 || *Path == TEXT('\\'));
|
|
return Path;
|
|
}
|
|
|
|
needNonWack = FALSE;
|
|
}
|
|
|
|
if (wackRequired) {
|
|
break;
|
|
}
|
|
|
|
Path = _tcsinc (Path);
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
BOOL
|
|
IsValidFileSpec (
|
|
IN PCTSTR FileSpec
|
|
)
|
|
{
|
|
CHARTYPE ch;
|
|
BOOL result = TRUE;
|
|
|
|
for (;;) {
|
|
ch = (CHARTYPE) _tcsnextc (FileSpec);
|
|
if (ch == TEXT('*')) {
|
|
//
|
|
// Really can't say what the validity is!
|
|
//
|
|
|
|
break;
|
|
}
|
|
|
|
if (!_istalpha (ch) && ch != TEXT('?')) {
|
|
result = FALSE;
|
|
break;
|
|
}
|
|
|
|
ch = (CHARTYPE) _tcsnextc (FileSpec + 1);
|
|
if (ch == TEXT('*')) {
|
|
break;
|
|
}
|
|
|
|
if (ch != TEXT(':') && ch != TEXT('?')) {
|
|
result = FALSE;
|
|
break;
|
|
}
|
|
|
|
ch = (CHARTYPE) _tcsnextc (FileSpec + 2);
|
|
|
|
if (ch == 0) {
|
|
// this is something like "d:", it's valid
|
|
break;
|
|
}
|
|
|
|
if (ch == TEXT('*')) {
|
|
break;
|
|
}
|
|
|
|
if (ch != TEXT('\\') && ch != TEXT('?')) {
|
|
result = FALSE;
|
|
break;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
if (!result) {
|
|
result = (IsValidUncPath (FileSpec) != NULL);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
VOID
|
|
pSetEnvironmentVar (
|
|
IN PMAPSTRUCT Map,
|
|
IN PMAPSTRUCT UndefMap, OPTIONAL
|
|
IN BOOL MapSourceToDest,
|
|
IN PCTSTR VariableName,
|
|
IN PCTSTR VariableData OPTIONAL
|
|
)
|
|
{
|
|
TCHAR encodedVariableName[128];
|
|
TCHAR buffer[MAX_TCHAR_PATH];
|
|
PCTSTR undefText;
|
|
|
|
//
|
|
// VariableData is NULL when VariableName is not present on the machine
|
|
//
|
|
|
|
if (MapSourceToDest) {
|
|
|
|
//
|
|
// MapSourceToDest tells us to map a source path (c:\windows) to
|
|
// a destination path (d:\winnt).
|
|
//
|
|
|
|
if (VariableData) {
|
|
if (IsmGetEnvironmentString (
|
|
PLATFORM_SOURCE,
|
|
S_SYSENVVAR_GROUP,
|
|
VariableName,
|
|
buffer,
|
|
ARRAYSIZE(buffer),
|
|
NULL
|
|
)) {
|
|
AddStringMappingPair (Map, buffer, VariableData);
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
//
|
|
// MapSourceToDest is FALSE when we want to map environment variables
|
|
// to the actual path.
|
|
//
|
|
|
|
//
|
|
// VariableName length is hard-coded, so we know it does not exceed our
|
|
// buffer
|
|
//
|
|
|
|
wsprintf (encodedVariableName, TEXT("%%%s%%"), VariableName);
|
|
|
|
if (VariableData) {
|
|
|
|
IsmSetEnvironmentString (IsmGetRealPlatform (), S_SYSENVVAR_GROUP, VariableName, VariableData);
|
|
AddStringMappingPair (Map, encodedVariableName, VariableData);
|
|
|
|
} else if (UndefMap) {
|
|
|
|
//
|
|
// If no variable data, then put environment variable in the
|
|
// "undefined" variable mapping
|
|
//
|
|
|
|
undefText = JoinTextEx (NULL, TEXT("--> "), TEXT(" <--"), encodedVariableName, 0, NULL);
|
|
AddStringMappingPair (UndefMap, encodedVariableName, undefText);
|
|
FreeText (undefText);
|
|
}
|
|
}
|
|
|
|
|
|
VOID
|
|
AddRemappingEnvVar (
|
|
IN PMAPSTRUCT Map,
|
|
IN PMAPSTRUCT ReMap,
|
|
IN PMAPSTRUCT UndefMap, OPTIONAL
|
|
IN PCTSTR VariableName,
|
|
IN PCTSTR VariableData
|
|
)
|
|
{
|
|
pSetEnvironmentVar (Map, UndefMap, FALSE, VariableName, VariableData);
|
|
pSetEnvironmentVar (ReMap, UndefMap, TRUE, VariableName, VariableData);
|
|
}
|
|
|
|
|
|
VOID
|
|
SetIsmEnvironmentFromPhysicalMachine (
|
|
IN PMAPSTRUCT Map,
|
|
IN BOOL MapSourceToDest,
|
|
IN PMAPSTRUCT UndefMap OPTIONAL
|
|
)
|
|
{
|
|
TCHAR dir[MAX_TCHAR_PATH];
|
|
PCTSTR path;
|
|
PTSTR p;
|
|
MIG_USERDATA userData;
|
|
BOOL mappedUser = FALSE;
|
|
|
|
mappedUser = IsmGetMappedUserData (&userData);
|
|
|
|
//
|
|
// Prepare ISM environment variables. The ones added last have the highest priority when
|
|
// two or more variables map to the same path.
|
|
//
|
|
|
|
//
|
|
// ...user profile
|
|
//
|
|
|
|
pSetEnvironmentVar (Map, UndefMap, MapSourceToDest, TEXT("ALLUSERSPROFILE"), GetAllUsersProfilePath (dir));
|
|
|
|
if (mappedUser) {
|
|
pSetEnvironmentVar (Map, UndefMap, MapSourceToDest, TEXT("USERPROFILE"), userData.UserProfileRoot);
|
|
} else {
|
|
pSetEnvironmentVar (Map, UndefMap, MapSourceToDest, TEXT("USERPROFILE"), GetUserProfileRootPath (dir));
|
|
}
|
|
|
|
pSetEnvironmentVar (Map, UndefMap, MapSourceToDest, TEXT("PROFILESFOLDER"), GetProfilesFolderPath (dir));
|
|
|
|
//
|
|
// ...temp dir
|
|
//
|
|
|
|
if (GetTempPath (MAX_PATH, dir)) {
|
|
p = (PTSTR) FindLastWack (dir);
|
|
if (p) {
|
|
if (p[1] == 0) {
|
|
*p = 0;
|
|
}
|
|
|
|
pSetEnvironmentVar (Map, UndefMap, MapSourceToDest, TEXT("TEMP"), dir);
|
|
pSetEnvironmentVar (Map, UndefMap, MapSourceToDest, TEXT("TMP"), dir);
|
|
}
|
|
}
|
|
|
|
//
|
|
// ...windows directory env variable
|
|
//
|
|
|
|
GetWindowsDirectory (dir, ARRAYSIZE(dir));
|
|
pSetEnvironmentVar (Map, UndefMap, MapSourceToDest, TEXT("WINDIR"), dir);
|
|
pSetEnvironmentVar (Map, UndefMap, MapSourceToDest, TEXT("SYSTEMROOT"), dir);
|
|
|
|
//
|
|
// ...16-bit system directory. We invent SYSTEM16 and SYSTEM32 for use
|
|
// in scripts.
|
|
//
|
|
|
|
path = JoinPaths (dir, TEXT("system"));
|
|
pSetEnvironmentVar (Map, UndefMap, MapSourceToDest, TEXT("SYSTEM16"), path);
|
|
FreePathString (path);
|
|
|
|
path = JoinPaths (dir, TEXT("system32"));
|
|
pSetEnvironmentVar (Map, UndefMap, MapSourceToDest, TEXT("SYSTEM32"), path);
|
|
FreePathString (path);
|
|
|
|
//
|
|
// ...platform-specific system directory
|
|
//
|
|
|
|
GetSystemDirectory (dir, ARRAYSIZE(dir));
|
|
pSetEnvironmentVar (Map, UndefMap, MapSourceToDest, TEXT("SYSTEM"), dir);
|
|
|
|
//
|
|
// ...shell folders -- we invent all variables with the CSIDL_ prefix
|
|
//
|
|
|
|
#define DEFMAC(id,folder_str,var_name) \
|
|
pSetEnvironmentVar (Map, UndefMap, MapSourceToDest, var_name, \
|
|
GetShellFolderPath (id, folder_str, TRUE, dir));
|
|
|
|
USER_SHELL_FOLDERS
|
|
|
|
#undef DEFMAC
|
|
|
|
|
|
#define DEFMAC(id,folder_str,var_name) \
|
|
pSetEnvironmentVar (Map, UndefMap, MapSourceToDest, var_name, \
|
|
GetShellFolderPath (id, folder_str, FALSE, dir));
|
|
|
|
COMMON_SHELL_FOLDERS
|
|
|
|
#undef DEFMAC
|
|
}
|
|
|
|
VOID
|
|
pTransferEnvPath (
|
|
IN PCTSTR IsmVariableName,
|
|
IN PMAPSTRUCT DirectMap,
|
|
IN PMAPSTRUCT ReverseMap,
|
|
IN PMAPSTRUCT UndefMap
|
|
)
|
|
{
|
|
TCHAR dir[MAX_TCHAR_PATH];
|
|
TCHAR encodedVariableName[128];
|
|
PCTSTR undefText;
|
|
|
|
wsprintf (encodedVariableName, TEXT("%%%s%%"), IsmVariableName);
|
|
|
|
if (IsmGetEnvironmentString (PLATFORM_SOURCE, S_SYSENVVAR_GROUP, IsmVariableName, dir, sizeof(dir)/sizeof((dir)[0]), NULL)) {
|
|
if (DirectMap) {
|
|
AddStringMappingPair (DirectMap, encodedVariableName, dir);
|
|
}
|
|
if (ReverseMap) {
|
|
AddStringMappingPair (ReverseMap, dir, encodedVariableName);
|
|
}
|
|
} else {
|
|
undefText = JoinTextEx (NULL, TEXT("--> "), TEXT(" <--"), encodedVariableName, 0, NULL);
|
|
if (UndefMap) {
|
|
AddStringMappingPair (UndefMap, encodedVariableName, undefText);
|
|
}
|
|
FreeText (undefText);
|
|
}
|
|
}
|
|
|
|
VOID
|
|
SetIsmEnvironmentFromVirtualMachine (
|
|
IN PMAPSTRUCT DirectMap,
|
|
IN PMAPSTRUCT ReverseMap,
|
|
IN PMAPSTRUCT UndefMap
|
|
)
|
|
{
|
|
//
|
|
// Need to transfer ISM environment into our string mapping
|
|
//
|
|
|
|
#define DEFMAC(name) pTransferEnvPath(name, DirectMap, ReverseMap, UndefMap);
|
|
|
|
ENVIRONMENT_VARIABLES
|
|
|
|
#undef DEFMAC
|
|
}
|
|
|