static int win32_find_system(char *system_config_path)
{
const wchar_t *query = L"%PROGRAMFILES%\\Git\\etc\\gitconfig";
wchar_t *apphome_utf16;
char *apphome_utf8;
DWORD size, ret;
size = ExpandEnvironmentStringsW(query, NULL, 0);
/* The function gave us the full size of the buffer in chars, including NUL */
apphome_utf16 = git__malloc(size * sizeof(wchar_t));
if (apphome_utf16 == NULL)
return GIT_ENOMEM;
ret = ExpandEnvironmentStringsW(query, apphome_utf16, size);
if (ret != size)
return git__throw(GIT_ERROR, "Failed to expand environment strings");
if (_waccess(apphome_utf16, F_OK) < 0) {
free(apphome_utf16);
return GIT_ENOTFOUND;
}
apphome_utf8 = conv_utf16_to_utf8(apphome_utf16);
free(apphome_utf16);
if (strlen(apphome_utf8) >= GIT_PATH_MAX) {
free(apphome_utf8);
return git__throw(GIT_ESHORTBUFFER, "Path is too long");
}
strcpy(system_config_path, apphome_utf8);
free(apphome_utf8);
return GIT_SUCCESS;
}
LPWSTR
apxExpandStrW(APXHANDLE hPool, LPCWSTR szString)
{
LPCWSTR p = szString;
while (*p) {
if (*p == L'%') {
p = szString;
break;
}
++p;
}
if (p != szString)
return apxPoolStrdupW(hPool, szString);
else {
DWORD l = ExpandEnvironmentStringsW(szString, NULL, 0);
if (l) {
LPWSTR rv = apxPoolAlloc(hPool, l * sizeof(WCHAR));
l = ExpandEnvironmentStringsW(szString, rv, l);
if (l)
return rv;
else {
apxFree(rv);
return NULL;
}
}
else
return NULL;
}
}
const gchar *
g_getenv (const gchar *variable)
{
GQuark quark;
gchar *value;
wchar_t dummy[2], *wname, *wvalue;
int len;
g_return_val_if_fail (variable != NULL, NULL);
g_return_val_if_fail (g_utf8_validate (variable, -1, NULL), NULL);
/* On Windows NT, it is relatively typical that environment
* variables contain references to other environment variables. If
* so, use ExpandEnvironmentStrings(). (In an ideal world, such
* environment variables would be stored in the Registry as
* REG_EXPAND_SZ type values, and would then get automatically
* expanded before a program sees them. But there is broken software
* that stores environment variables as REG_SZ values even if they
* contain references to other environment variables.)
*/
wname = g_utf8_to_utf16 (variable, -1, NULL, NULL, NULL);
len = GetEnvironmentVariableW (wname, dummy, 2);
if (len == 0)
{
g_free (wname);
return NULL;
}
else if (len == 1)
len = 2;
wvalue = g_new (wchar_t, len);
if (GetEnvironmentVariableW (wname, wvalue, len) != len - 1)
{
g_free (wname);
g_free (wvalue);
return NULL;
}
if (wcschr (wvalue, L'%') != NULL)
{
wchar_t *tem = wvalue;
len = ExpandEnvironmentStringsW (wvalue, dummy, 2);
if (len > 0)
{
wvalue = g_new (wchar_t, len);
if (ExpandEnvironmentStringsW (tem, wvalue, len) != len)
{
g_free (wvalue);
wvalue = tem;
}
else
g_free (tem);
}
/* Returns a string that corresponds to <data> with all existing
* environment variables replaced by their values and with
* %* and %N replaced by the respective command line arguments, taken from <argv>.
* The resulting string is allocated by expand_vars() and must be freed with free().
*/
wchar_t *expand_vars (wchar_t *data, wchar_t *argv[])
{
DWORD res = 0;
DWORD extra_len = 0;
size_t newlen = 0;
wchar_t *result;
wchar_t *arg_result;
int i = 0, j = 0;
BOOL prevrep = FALSE;
size_t len = 0;
int argc;
res = ExpandEnvironmentStringsW (data, NULL, 0);
if (res == 0)
return NULL;
result = (wchar_t *) malloc (sizeof(wchar_t) * res);
if (result == NULL)
return NULL;
res = ExpandEnvironmentStringsW (data, result, res);
if (res == 0)
{
free (result);
return NULL;
}
argc = 0;
for (arg_result = argv[0]; arg_result != NULL; arg_result = argv[argc])
argc += 1;
scan_vars (result, res, &newlen, NULL, argc, argv);
arg_result = (wchar_t *) malloc (sizeof (wchar_t) * (newlen + 1));
scan_vars (result, res, NULL, arg_result, argc, argv);
free (result);
return arg_result;
}
static size_t
BuildCommandLine(LPWSTR lpszDest, LPCWSTR lpszCmdLine, LPCWSTR lpszParam, size_t bufSize)
{
size_t numOfChars = 0; // The null character is counted in ExpandEnvironmentStrings(...).
// TODO: Take into account the "plus one" for numOfChars for ANSI version (see MSDN for more details).
if (lpszCmdLine && *lpszCmdLine)
{
numOfChars += ExpandEnvironmentStringsW(lpszCmdLine, NULL, 0);
if (lpszDest)
ExpandEnvironmentStringsW(lpszCmdLine, lpszDest, (DWORD)bufSize); // TODO: size_t to DWORD conversion !
if (lpszParam && *lpszParam)
{
++numOfChars;
if (lpszDest)
wcscat(lpszDest, L" ");
}
}
if (lpszParam && *lpszParam)
{
numOfChars += wcslen(lpszParam);
if (lpszDest)
wcscat(lpszDest, lpszParam);
}
return numOfChars;
}
/* Allocate and initialize a WSTR containing the expanded string */
static LPWSTR ExpandEnv(LPWSTR string)
{
DWORD size;
LPWSTR expanded_string;
WINE_TRACE("\n");
size = 0;
size = ExpandEnvironmentStringsW(string, NULL, size);
if (size == 0)
{
WINE_ERR("cannot expand env vars in %s: %u\n",
wine_dbgstr_w(string), GetLastError());
return NULL;
}
expanded_string = HeapAlloc(GetProcessHeap(), 0,
(size + 1) * sizeof(WCHAR));
if (ExpandEnvironmentStringsW(string, expanded_string, size) == 0)
{
WINE_ERR("cannot expand env vars in %s: %u\n",
wine_dbgstr_w(string), GetLastError());
HeapFree(GetProcessHeap(), 0, expanded_string);
return NULL;
}
return expanded_string;
}
/**
* bChoose = true %temp%
* bChoose = false %appdata%
*/
tstring GetTempCachePath(HINSTANCE hInstance, bool bChoose = false)
{
LPTSTR lpszTempPath = new TCHAR[MAX_PATH + 1];
int nLength = 0;
if( bChoose )
nLength = GetTempPath(MAX_PATH, lpszTempPath);
else
nLength = ExpandEnvironmentStringsW(L"%appdata%", lpszTempPath, MAX_PATH);
if (nLength > MAX_PATH)
{
delete[] lpszTempPath;
lpszTempPath = new TCHAR[nLength + 1];
if( bChoose )
GetTempPath(nLength, lpszTempPath);
else
ExpandEnvironmentStringsW(L"%appdata%", lpszTempPath, nLength);
}
lpszTempPath[nLength] = '\0';
tstring path = lpszTempPath;
delete[] lpszTempPath;
if (path[path.size() - 1] != '\\')
path += _T("\\");
path += _T("BankUpdate");
CreateDirectory(path.c_str(), NULL);
return path;
}
HRESULT CQueryAssociations::GetExecutable(LPCWSTR pszExtra, LPWSTR path, DWORD pathlen, DWORD *len)
{
WCHAR *pszCommand;
WCHAR *pszStart;
WCHAR *pszEnd;
HRESULT hr = this->GetCommand(pszExtra, &pszCommand);
if (FAILED(hr))
{
return hr;
}
DWORD expLen = ExpandEnvironmentStringsW(pszCommand, NULL, 0);
if (expLen > 0)
{
expLen++;
WCHAR *buf = static_cast<WCHAR *>(HeapAlloc(GetProcessHeap(), 0, expLen * sizeof(WCHAR)));
ExpandEnvironmentStringsW(pszCommand, buf, expLen);
HeapFree(GetProcessHeap(), 0, pszCommand);
pszCommand = buf;
}
/* cleanup pszCommand */
if (pszCommand[0] == '"')
{
pszStart = pszCommand + 1;
pszEnd = strchrW(pszStart, '"');
if (pszEnd)
{
*pszEnd = 0;
}
*len = SearchPathW(NULL, pszStart, NULL, pathlen, path, NULL);
}
else
{
pszStart = pszCommand;
for (pszEnd = pszStart; (pszEnd = strchrW(pszEnd, ' ')); pszEnd++)
{
WCHAR c = *pszEnd;
*pszEnd = 0;
if ((*len = SearchPathW(NULL, pszStart, NULL, pathlen, path, NULL)))
{
break;
}
*pszEnd = c;
}
if (!pszEnd)
{
*len = SearchPathW(NULL, pszStart, NULL, pathlen, path, NULL);
}
}
HeapFree(GetProcessHeap(), 0, pszCommand);
if (!*len)
{
return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
}
return S_OK;
}
BOOL WINAPI GetProfilesDirectoryW( LPWSTR lpProfilesDir, LPDWORD lpcchSize )
{
static const WCHAR ProfilesDirectory[] = {'P','r','o','f','i','l','e','s','D','i','r','e','c','t','o','r','y',0};
LONG l;
HKEY key;
BOOL ret = FALSE;
DWORD len = 0, expanded_len;
LPWSTR unexpanded_profiles_dir = NULL;
TRACE("%p %p\n", lpProfilesDir, lpcchSize );
if (!lpcchSize)
{
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
l = RegOpenKeyExW(HKEY_LOCAL_MACHINE, ProfileListW, 0, KEY_READ, &key);
if (l)
{
SetLastError(l);
return FALSE;
}
l = RegQueryValueExW(key, ProfilesDirectory, NULL, NULL, NULL, &len);
if (l)
{
SetLastError(l);
goto end;
}
unexpanded_profiles_dir = HeapAlloc(GetProcessHeap(), 0, len);
if (!unexpanded_profiles_dir)
{
SetLastError(ERROR_OUTOFMEMORY);
goto end;
}
l = RegQueryValueExW(key, ProfilesDirectory, NULL, NULL,
(BYTE *)unexpanded_profiles_dir, &len);
if (l)
{
SetLastError(l);
goto end;
}
expanded_len = ExpandEnvironmentStringsW(unexpanded_profiles_dir, NULL, 0);
/* The returned length doesn't include the NULL terminator. */
if (*lpcchSize < expanded_len - 1 || !lpProfilesDir)
{
*lpcchSize = expanded_len - 1;
SetLastError(ERROR_INSUFFICIENT_BUFFER);
goto end;
}
*lpcchSize = expanded_len - 1;
/* The return value is also the expected length. */
ret = ExpandEnvironmentStringsW(unexpanded_profiles_dir, lpProfilesDir,
expanded_len) - 1;
end:
HeapFree(GetProcessHeap(), 0, unexpanded_profiles_dir);
RegCloseKey(key);
return ret;
}
static DWORD service_start_process(struct service_entry *service_entry, HANDLE *process)
{
PROCESS_INFORMATION pi;
STARTUPINFOW si;
LPWSTR path = NULL;
DWORD size;
BOOL r;
service_lock_exclusive(service_entry);
if (service_entry->config.dwServiceType == SERVICE_KERNEL_DRIVER)
{
static const WCHAR winedeviceW[] = {'\\','w','i','n','e','d','e','v','i','c','e','.','e','x','e',' ',0};
DWORD len = GetSystemDirectoryW( NULL, 0 ) + sizeof(winedeviceW)/sizeof(WCHAR) + strlenW(service_entry->name);
if (!(path = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
return ERROR_NOT_ENOUGH_SERVER_MEMORY;
GetSystemDirectoryW( path, len );
lstrcatW( path, winedeviceW );
lstrcatW( path, service_entry->name );
}
else
{
size = ExpandEnvironmentStringsW(service_entry->config.lpBinaryPathName,NULL,0);
path = HeapAlloc(GetProcessHeap(),0,size*sizeof(WCHAR));
if (!path)
return ERROR_NOT_ENOUGH_SERVER_MEMORY;
ExpandEnvironmentStringsW(service_entry->config.lpBinaryPathName,path,size);
}
ZeroMemory(&si, sizeof(STARTUPINFOW));
si.cb = sizeof(STARTUPINFOW);
if (!(service_entry->config.dwServiceType & SERVICE_INTERACTIVE_PROCESS))
{
static WCHAR desktopW[] = {'_','_','w','i','n','e','s','e','r','v','i','c','e','_','w','i','n','s','t','a','t','i','o','n','\\','D','e','f','a','u','l','t',0};
si.lpDesktop = desktopW;
}
service_entry->status.dwCurrentState = SERVICE_START_PENDING;
service_unlock(service_entry);
r = CreateProcessW(NULL, path, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi);
HeapFree(GetProcessHeap(),0,path);
if (!r)
{
service_lock_exclusive(service_entry);
service_entry->status.dwCurrentState = SERVICE_STOPPED;
service_unlock(service_entry);
return GetLastError();
}
service_entry->status.dwProcessId = pi.dwProcessId;
*process = pi.hProcess;
CloseHandle( pi.hThread );
return ERROR_SUCCESS;
}
wstring expand_env_vars(const wstring& str) {
Buffer<wchar_t> buf(MAX_PATH);
unsigned size = ExpandEnvironmentStringsW(str.c_str(), buf.data(), static_cast<DWORD>(buf.size()));
if (size > buf.size()) {
buf.resize(size);
size = ExpandEnvironmentStringsW(str.c_str(), buf.data(), static_cast<DWORD>(buf.size()));
}
CHECK_SYS(size);
return wstring(buf.data(), size - 1);
}
void ConsoleTools::setCatalogPath(const String &str) {
delete catalogPath;
#if defined _WIN32
// replace the environment variables to their values
size_t i=ExpandEnvironmentStringsW(str.getWChars(),NULL,0);
wchar_t *temp = new wchar_t[i];
ExpandEnvironmentStringsW(str.getWChars(),temp,static_cast<DWORD>(i));
catalogPath = new SString(temp);
delete[] temp;
#else
catalogPath = new SString(str);
#endif
}
static void ACTION_ConvertRegValue(DWORD regType, const BYTE *value, DWORD sz,
LPWSTR *appValue)
{
static const WCHAR dwordFmt[] = { '#','%','d','\0' };
static const WCHAR binPre[] = { '#','x','\0' };
static const WCHAR binFmt[] = { '%','0','2','X','\0' };
LPWSTR ptr;
DWORD i;
switch (regType)
{
case REG_SZ:
if (*(LPCWSTR)value == '#')
{
/* escape leading pound with another */
*appValue = msi_alloc(sz + sizeof(WCHAR));
(*appValue)[0] = '#';
strcpyW(*appValue + 1, (LPCWSTR)value);
}
else
{
*appValue = msi_alloc(sz);
strcpyW(*appValue, (LPCWSTR)value);
}
break;
case REG_DWORD:
/* 7 chars for digits, 1 for NULL, 1 for #, and 1 for sign
* char if needed
*/
*appValue = msi_alloc(10 * sizeof(WCHAR));
sprintfW(*appValue, dwordFmt, *(const DWORD *)value);
break;
case REG_EXPAND_SZ:
sz = ExpandEnvironmentStringsW((LPCWSTR)value, NULL, 0);
*appValue = msi_alloc(sz * sizeof(WCHAR));
ExpandEnvironmentStringsW((LPCWSTR)value, *appValue, sz);
break;
case REG_BINARY:
/* #x<nibbles>\0 */
*appValue = msi_alloc((sz * 2 + 3) * sizeof(WCHAR));
lstrcpyW(*appValue, binPre);
ptr = *appValue + lstrlenW(binPre);
for (i = 0; i < sz; i++, ptr += 2)
sprintfW(ptr, binFmt, value[i]);
break;
default:
WARN("unimplemented for values of type %d\n", regType);
*appValue = NULL;
}
}
/* At the end of the day this is a subset of what SHRegGetPath() does - copied
* here to avoid linking against shlwapi. */
static DWORD query_reg_path (HKEY hKey, LPCWSTR lpszValue,
LPVOID pvData)
{
DWORD dwRet, dwType, dwUnExpDataLen = MAX_PATH, dwExpDataLen;
TRACE("(hkey=%p,%s,%p)\n", hKey, debugstr_w(lpszValue),
pvData);
dwRet = RegQueryValueExW(hKey, lpszValue, 0, &dwType, pvData, &dwUnExpDataLen);
if (dwRet!=ERROR_SUCCESS && dwRet!=ERROR_MORE_DATA)
return dwRet;
if (dwType == REG_EXPAND_SZ)
{
DWORD nBytesToAlloc;
/* Expand type REG_EXPAND_SZ into REG_SZ */
LPWSTR szData;
/* If the caller didn't supply a buffer or the buffer is too small we have
* to allocate our own
*/
if (dwRet == ERROR_MORE_DATA)
{
WCHAR cNull = '\0';
nBytesToAlloc = dwUnExpDataLen;
szData = LocalAlloc(LMEM_ZEROINIT, nBytesToAlloc);
RegQueryValueExW (hKey, lpszValue, 0, NULL, (LPBYTE)szData, &nBytesToAlloc);
dwExpDataLen = ExpandEnvironmentStringsW(szData, &cNull, 1);
dwUnExpDataLen = max(nBytesToAlloc, dwExpDataLen);
LocalFree(szData);
}
else
{
nBytesToAlloc = (lstrlenW(pvData) + 1) * sizeof(WCHAR);
szData = LocalAlloc(LMEM_ZEROINIT, nBytesToAlloc );
lstrcpyW(szData, pvData);
dwExpDataLen = ExpandEnvironmentStringsW(szData, pvData, MAX_PATH );
if (dwExpDataLen > MAX_PATH) dwRet = ERROR_MORE_DATA;
dwUnExpDataLen = max(nBytesToAlloc, dwExpDataLen);
LocalFree(szData);
}
}
RegCloseKey(hKey);
return dwRet;
}
LONG WINAPI DetourUnhandledExceptionFilter(struct _EXCEPTION_POINTERS* ExceptionInfo)
{
// 记录用户出错信息
if (NULL != ExceptionInfo)
{
WCHAR szDumpFile[MAX_PATH] = {0};
ExpandEnvironmentStringsW(L"%APPDATA%\\MoneyHub\\MoneyhubDmp.dmp", szDumpFile, MAX_PATH);
HANDLE hDumpFile = CreateFile(szDumpFile, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL ,NULL);
MINIDUMP_EXCEPTION_INFORMATION stMiniDumpExceptionInfo;
stMiniDumpExceptionInfo.ExceptionPointers = ExceptionInfo;
stMiniDumpExceptionInfo.ThreadId = GetCurrentThreadId();
stMiniDumpExceptionInfo.ClientPointers = TRUE;
MiniDumpWriteDump(GetCurrentProcess(), GetCurrentProcessId(), hDumpFile,
MiniDumpNormal, &stMiniDumpExceptionInfo, NULL, NULL);
CloseHandle(hDumpFile);
DWORD dwAddr = (DWORD)ExceptionInfo->ExceptionRecord->ExceptionAddress;
CRecordProgram::GetInstance()->FeedbackError(MY_ERROR_PRO_CORE, ERR_UNHANDLE_EXCEPT,
CRecordProgram::GetInstance()->GetRecordInfo(L"UnhandledException Errorcode = %d, ErrAddress = %08x", ExceptionInfo->ExceptionRecord->ExceptionCode, dwAddr));
exit(0);
return 0;
}
return OldUnhandledExceptionFilter(ExceptionInfo);
}
UnicodeString ExpandEnvVars(const UnicodeString & Str)
{
wchar_t buf[MAX_PATH];
intptr_t size = ExpandEnvironmentStringsW(Str.c_str(), buf, static_cast<DWORD>(MAX_PATH - 1));
UnicodeString Result = UnicodeString(buf, size - 1);
return Result;
}
VOID
GetDisplayNameFile(IN LPCWSTR lpLogName,
OUT PWCHAR lpModuleName)
{
HKEY hKey;
WCHAR *KeyPath;
WCHAR szModuleName[MAX_PATH];
DWORD cbData;
SIZE_T cbKeyPath;
cbKeyPath = (wcslen(EVENTLOG_BASE_KEY) + wcslen(lpLogName) + 1) * sizeof(WCHAR);
KeyPath = HeapAlloc(GetProcessHeap(), 0, cbKeyPath);
if (!KeyPath)
{
return;
}
StringCbCopyW(KeyPath, cbKeyPath, EVENTLOG_BASE_KEY);
StringCbCatW(KeyPath, cbKeyPath, lpLogName);
if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, KeyPath, 0, KEY_READ, &hKey) != ERROR_SUCCESS)
{
HeapFree(GetProcessHeap(), 0, KeyPath);
return;
}
cbData = sizeof(szModuleName);
if (RegQueryValueExW(hKey, L"DisplayNameFile", NULL, NULL, (LPBYTE)szModuleName, &cbData) == ERROR_SUCCESS)
{
ExpandEnvironmentStringsW(szModuleName, lpModuleName, MAX_PATH);
}
RegCloseKey(hKey);
HeapFree(GetProcessHeap(), 0, KeyPath);
}
BOOL CheckValidInstallPath(PCWSTR pszGadgetPath)
{
BOOL fIsValid = FALSE;
PCWSTR const rgszPaths[] =
{
L"%ProgramFiles%\\Windows Sidebar\\Gadgets",
L"%ProgramFiles%\\Windows Sidebar\\Shared Gadgets",
L"%LocalAppData%\\Microsoft\\Windows Sidebar\\Gadgets"
};
for (int iPath = 0; iPath < ARRAYSIZE(rgszPaths); ++iPath)
{
WCHAR szPath[MAX_PATH];
if (ExpandEnvironmentStringsW(rgszPaths[iPath], szPath, ARRAYSIZE(szPath)))
{
if (PathIsPrefixW(szPath, pszGadgetPath))
{
fIsValid = TRUE;
break;
}
}
}
return fIsValid;
}
/**************************************************************************
* load_mapi_provider
*
* Attempts to load a MAPI provider from the specified registry key.
*
* Returns a handle to the loaded module in `mapi_provider' if successful.
*/
static void load_mapi_provider(HKEY hkeyMail, LPCWSTR valueName, HMODULE *mapi_provider)
{
static const WCHAR mapi32_dll[] = {'m','a','p','i','3','2','.','d','l','l',0 };
DWORD dwType, dwLen = 0;
LPWSTR dllPath;
/* Check if we have a value set for DLLPath */
if ((RegQueryValueExW(hkeyMail, valueName, NULL, &dwType, NULL, &dwLen) == ERROR_SUCCESS) &&
((dwType == REG_SZ) || (dwType == REG_EXPAND_SZ)) && (dwLen > 0))
{
dllPath = HeapAlloc(GetProcessHeap(), 0, dwLen);
if (dllPath)
{
RegQueryValueExW(hkeyMail, valueName, NULL, NULL, (LPBYTE)dllPath, &dwLen);
/* Check that this value doesn't refer to mapi32.dll (eg, as Outlook does) */
if (lstrcmpiW(dllPath, mapi32_dll) != 0)
{
if (dwType == REG_EXPAND_SZ)
{
DWORD dwExpandLen;
LPWSTR dllPathExpanded;
/* Expand the path if necessary */
dwExpandLen = ExpandEnvironmentStringsW(dllPath, NULL, 0);
dllPathExpanded = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR) * dwExpandLen + 1);
if (dllPathExpanded)
{
ExpandEnvironmentStringsW(dllPath, dllPathExpanded, dwExpandLen + 1);
HeapFree(GetProcessHeap(), 0, dllPath);
dllPath = dllPathExpanded;
}
}
/* Load the DLL */
TRACE("loading %s\n", debugstr_w(dllPath));
*mapi_provider = LoadLibraryW(dllPath);
}
HeapFree(GetProcessHeap(), 0, dllPath);
}
}
}
std::string WinRegistryKey::getStringExpand(const std::string& name)
{
open();
DWORD type;
DWORD size;
#if defined(POCO_WIN32_UTF8)
std::wstring uname;
Poco::UnicodeConverter::toUTF16(name, uname);
if (RegQueryValueExW(_hKey, uname.c_str(), NULL, &type, NULL, &size) != ERROR_SUCCESS || type != REG_SZ && type != REG_EXPAND_SZ)
throw NotFoundException(key(name));
if (size > 0)
{
DWORD len = size/2;
wchar_t* buffer = new wchar_t[len + 1];
RegQueryValueExW(_hKey, uname.c_str(), NULL, NULL, (BYTE*) buffer, &size);
buffer[len] = 0;
wchar_t temp;
DWORD expSize = ExpandEnvironmentStringsW(buffer, &temp, 1);
wchar_t* expBuffer = new wchar_t[expSize];
ExpandEnvironmentStringsW(buffer, expBuffer, expSize);
std::string result;
UnicodeConverter::toUTF8(expBuffer, result);
delete [] buffer;
delete [] expBuffer;
return result;
}
#else
if (RegQueryValueExA(_hKey, name.c_str(), NULL, &type, NULL, &size) != ERROR_SUCCESS || type != REG_SZ && type != REG_EXPAND_SZ)
throw NotFoundException(key(name));
if (size > 0)
{
char* buffer = new char[size + 1];
RegQueryValueExA(_hKey, name.c_str(), NULL, NULL, (BYTE*) buffer, &size);
buffer[size] = 0;
char temp;
DWORD expSize = ExpandEnvironmentStringsA(buffer, &temp, 1);
char* expBuffer = new char[expSize];
ExpandEnvironmentStringsA(buffer, expBuffer, expSize);
std::string result(expBuffer);
delete [] buffer;
delete [] expBuffer;
return result;
}
#endif
return std::string();
}
DWORD load_reg_string(HKEY hKey, LPCWSTR szValue, BOOL bExpand, LPWSTR *output)
{
DWORD size, type;
LPWSTR buf = NULL;
DWORD err;
*output = NULL;
if ((err = RegQueryValueExW(hKey, szValue, 0, &type, NULL, &size)) != 0)
{
if (err == ERROR_FILE_NOT_FOUND)
return ERROR_SUCCESS;
goto failed;
}
if (!(type == REG_SZ || (type == REG_EXPAND_SZ && bExpand)))
{
err = ERROR_INVALID_DATATYPE;
goto failed;
}
buf = HeapAlloc(GetProcessHeap(), 0, size + sizeof(WCHAR));
if ((err = RegQueryValueExW(hKey, szValue, 0, &type, (LPBYTE)buf, &size)) != 0)
goto failed;
buf[size/sizeof(WCHAR)] = 0;
if (type == REG_EXPAND_SZ)
{
LPWSTR str;
DWORD size = ExpandEnvironmentStringsW(buf, NULL, 0);
if (size == 0)
{
err = GetLastError();
goto failed;
}
str = HeapAlloc(GetProcessHeap(), 0, size * sizeof(WCHAR));
ExpandEnvironmentStringsW(buf, str, size);
HeapFree(GetProcessHeap(), 0, buf);
*output = str;
}
else
*output = buf;
return ERROR_SUCCESS;
failed:
WINE_ERR("Error %d while reading value %s\n", err, wine_dbgstr_w(szValue));
HeapFree(GetProcessHeap(), 0, buf);
return err;
}
/*
* @implemented
*/
BOOL WINAPI
WlxActivateUserShell(
PVOID pWlxContext,
PWSTR pszDesktopName,
PWSTR pszMprLogonScript,
PVOID pEnvironment)
{
HKEY hKey;
DWORD BufSize, ValueType;
WCHAR pszUserInitApp[MAX_PATH + 1];
WCHAR pszExpUserInitApp[MAX_PATH];
DWORD len;
LONG rc;
TRACE("WlxActivateUserShell()\n");
UNREFERENCED_PARAMETER(pszMprLogonScript);
/* Get the path of userinit */
rc = RegOpenKeyExW(
HKEY_LOCAL_MACHINE,
L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Winlogon",
0,
KEY_QUERY_VALUE,
&hKey);
if (rc != ERROR_SUCCESS)
{
WARN("RegOpenKeyExW() failed with error %lu\n", rc);
return FALSE;
}
/* Query userinit application */
BufSize = sizeof(pszUserInitApp) - sizeof(UNICODE_NULL);
rc = RegQueryValueExW(
hKey,
L"Userinit",
NULL,
&ValueType,
(LPBYTE)pszUserInitApp,
&BufSize);
RegCloseKey(hKey);
if (rc != ERROR_SUCCESS || (ValueType != REG_SZ && ValueType != REG_EXPAND_SZ))
{
WARN("RegQueryValueExW() failed with error %lu\n", rc);
return FALSE;
}
pszUserInitApp[MAX_PATH] = UNICODE_NULL;
len = ExpandEnvironmentStringsW(pszUserInitApp, pszExpUserInitApp, MAX_PATH);
if (len > MAX_PATH)
{
WARN("ExpandEnvironmentStringsW() failed. Required size %lu\n", len);
return FALSE;
}
/* Start userinit app */
return WlxStartApplication(pWlxContext, pszDesktopName, pEnvironment, pszExpUserInitApp);
}
static
BOOL
GetProgramsPath(BOOL bCommonPath,
LPWSTR lpProgramsPath)
{
WCHAR szPath[MAX_PATH];
DWORD dwLength;
DWORD dwType;
HKEY hKey;
LONG Error;
DPRINT("GetProgramsPath() called\n");
Error = RegOpenKeyExW(HKEY_CURRENT_USER,
L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\User Shell Folders",
0,
KEY_QUERY_VALUE,
&hKey);
if (Error != ERROR_SUCCESS)
{
DPRINT1("RegOpenKeyExW() failed\n");
SetLastError((DWORD)Error);
return FALSE;
}
dwLength = MAX_PATH * sizeof(WCHAR);
Error = RegQueryValueExW(hKey,
bCommonPath ? L"Common Programs" : L"Programs",
0,
&dwType,
(LPBYTE)szPath,
&dwLength);
if (Error != ERROR_SUCCESS)
{
DPRINT1("RegQueryValueExW() failed\n");
RegCloseKey(hKey);
SetLastError((DWORD)Error);
return FALSE;
}
RegCloseKey(hKey);
if (dwType == REG_EXPAND_SZ)
{
ExpandEnvironmentStringsW(szPath,
lpProgramsPath,
MAX_PATH);
}
else
{
wcscpy(lpProgramsPath,
szPath);
}
DPRINT("GetProgramsPath() done\n");
return TRUE;
}
static int git_win32__expand_path(_findfile_path *dest, const wchar_t *src)
{
dest->len = ExpandEnvironmentStringsW(src, dest->path, ARRAY_SIZE(dest->path));
if (!dest->len || dest->len > ARRAY_SIZE(dest->path))
return -1;
return 0;
}
BOOL
GetEventMessageFileDLL(IN LPCWSTR lpLogName,
IN LPCWSTR SourceName,
IN LPCWSTR EntryName,
OUT PWCHAR ExpandedName)
{
DWORD dwSize;
BYTE szModuleName[MAX_PATH];
WCHAR szKeyName[MAX_PATH];
HKEY hAppKey = NULL;
HKEY hSourceKey = NULL;
BOOL bReturn = FALSE;
StringCbCopyW(szKeyName, sizeof(szKeyName), L"SYSTEM\\CurrentControlSet\\Services\\EventLog\\");
StringCbCatW(szKeyName, sizeof(szKeyName), lpLogName);
if (RegOpenKeyExW(HKEY_LOCAL_MACHINE,
szKeyName,
0,
KEY_READ,
&hAppKey) == ERROR_SUCCESS)
{
if (RegOpenKeyExW(hAppKey,
SourceName,
0,
KEY_READ,
&hSourceKey) == ERROR_SUCCESS)
{
dwSize = MAX_PATH;
if (RegQueryValueExW(hSourceKey,
EntryName,
NULL,
NULL,
(LPBYTE)szModuleName,
&dwSize) == ERROR_SUCCESS)
{
/* Returns a string containing the requested substituted environment variable. */
ExpandEnvironmentStringsW((LPCWSTR)szModuleName, ExpandedName, MAX_PATH);
/* Successful */
bReturn = TRUE;
}
}
}
else
{
ShowLastWin32Error();
}
if (hSourceKey != NULL)
RegCloseKey(hSourceKey);
if (hAppKey != NULL)
RegCloseKey(hAppKey);
return bReturn;
}
std::string ExpandVariablesWin(const std::string &path)
{
std::wstring wide;
Multi2Wide(path, wide);
std::wstring buffer;
buffer.resize(MAX_PATH);
DWORD size = ExpandEnvironmentStringsW(wide.c_str(), &buffer[0], buffer.size());
while(size == buffer.size())
{
buffer.resize(buffer.size() * 2);
size = ExpandEnvironmentStringsW(wide.c_str(), &buffer[0], buffer.size());
}
buffer.resize(size);
wide = buffer;
std::string multi;
Wide2Multi(wide, multi);
return multi;
}
static HICON extract_icon( IShellLinkW *link )
{
WCHAR tmp_path[MAX_PATH], icon_path[MAX_PATH], target_path[MAX_PATH];
HICON icon = NULL;
int index;
tmp_path[0] = 0;
IShellLinkW_GetIconLocation( link, tmp_path, MAX_PATH, &index );
ExpandEnvironmentStringsW( tmp_path, icon_path, MAX_PATH );
if (icon_path[0]) ExtractIconExW( icon_path, index, &icon, NULL, 1 );
if (!icon)
{
tmp_path[0] = 0;
IShellLinkW_GetPath( link, tmp_path, MAX_PATH, NULL, SLGP_RAWPATH );
ExpandEnvironmentStringsW( tmp_path, target_path, MAX_PATH );
ExtractIconExW( target_path, index, &icon, NULL, 1 );
}
return icon;
}
/**
* generate path where to store settings.
*
* @note %APPDATA%/Kouets/
* --> C:\Users\nob-aoki\AppData\Roaming[WinVista/7/8]
* --> C:\Documents and Settings\nob-aoki\Application Data[Win2k/XP]
*
* @note ~/.Kouets/ on Linux & MacOS
*/
void KouetsApp::prepareAppDataPath()
{
#ifdef WINDOWS
wchar_t appdatapath[0x1000];
ExpandEnvironmentStringsW(L"%APPDATA%\\Kouets\\",
appdatapath, _countof(appdatapath));
appDataPath_ = QString::fromWCharArray(appdatapath);
#else
appDataPath_ = "~/.Kouets/";
#endif
}
static VOID
CreateTempDir(
IN LPCWSTR VarName)
{
WCHAR szTempDir[MAX_PATH];
WCHAR szBuffer[MAX_PATH];
DWORD dwLength;
HKEY hKey;
if (RegOpenKeyExW(HKEY_LOCAL_MACHINE,
L"SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Environment",
0,
KEY_QUERY_VALUE,
&hKey) != ERROR_SUCCESS)
{
FatalError("Error: %lu\n", GetLastError());
return;
}
/* Get temp dir */
dwLength = MAX_PATH * sizeof(WCHAR);
if (RegQueryValueExW(hKey,
VarName,
NULL,
NULL,
(LPBYTE)szBuffer,
&dwLength) != ERROR_SUCCESS)
{
FatalError("Error: %lu\n", GetLastError());
goto cleanup;
}
/* Expand it */
if (!ExpandEnvironmentStringsW(szBuffer,
szTempDir,
MAX_PATH))
{
FatalError("Error: %lu\n", GetLastError());
goto cleanup;
}
/* Create profiles directory */
if (!CreateDirectoryW(szTempDir, NULL))
{
if (GetLastError() != ERROR_ALREADY_EXISTS)
{
FatalError("Error: %lu\n", GetLastError());
goto cleanup;
}
}
cleanup:
RegCloseKey(hKey);
}
BOOL WINAPI ExpandEnvironmentStringsForUserW( HANDLE hToken, LPCWSTR lpSrc,
LPWSTR lpDest, DWORD dwSize )
{
BOOL ret;
TRACE("%p %s %p %d\n", hToken, debugstr_w(lpSrc), lpDest, dwSize);
ret = ExpandEnvironmentStringsW( lpSrc, lpDest, dwSize );
TRACE("<- %s\n", debugstr_w(lpDest));
return ret;
}