/*************************************************************************
* AddERExcludedApplicationW [FAULTREP.@]
*
* Adds an application to a list of applications for which fault reports
* shouldn't be generated
*
* PARAMS
* lpAppFileName [I] The filename of the application executable
*
* RETURNS
* TRUE on success, FALSE of failure
*
* NOTES
* Wine doesn't use this data but stores it in the registry (in the same place
* as Windows would) in case it will be useful in a future version
*
* According to MSDN this function should succeed even if the user has no write
* access to HKLM. This probably means that there is no error checking.
*/
BOOL WINAPI AddERExcludedApplicationW(LPCWSTR lpAppFileName)
{
WCHAR *bslash;
DWORD value = 1;
HKEY hkey;
TRACE("(%s)\n", wine_dbgstr_w(lpAppFileName));
bslash = strrchrW(lpAppFileName, '\\');
if (bslash != NULL)
lpAppFileName = bslash + 1;
if (*lpAppFileName == '\0')
{
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
if (!RegCreateKeyW(HKEY_LOCAL_MACHINE, SZ_EXCLUSIONLIST_KEY, &hkey))
{
RegSetValueExW(hkey, lpAppFileName, 0, REG_DWORD, (LPBYTE)&value, sizeof(value));
RegCloseKey(hkey);
}
return TRUE;
}
HRESULT e3d_set_process_key(const BYTE *key)
{
if (key_in_process)
delete key_in_process;
key_in_process = new unsigned char[32];
memcpy(key_in_process, key, 32);
int len = 4;
wchar_t pid[100];
wsprintfW(pid, L"%d", GetCurrentProcessId());
HKEY hkey = NULL;
int ret = RegCreateKeyExW(HKEY_CURRENT_USER, e3d_soft_key, 0,0,REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS | KEY_WRITE |KEY_SET_VALUE, NULL , &hkey, NULL );
if (ret != ERROR_SUCCESS)
return E_FAIL;
ret = RegSetValueExW(hkey, pid, 0, REG_BINARY, (const byte*)&key_in_process, len );
if (ret != ERROR_SUCCESS)
return E_FAIL;
RegCloseKey(hkey);
return S_OK;
}
void MainWnd_OnOpenRegKey(HWND hwnd)
{
static const WCHAR s_szRegeditKey[] =
L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Applets\\Regedit";
WCHAR sz[MAX_STRING];
// open regedit key
HKEY hKey = NULL;
LSTATUS Result = RegCreateKeyExW(HKEY_CURRENT_USER, s_szRegeditKey, 0,
NULL, 0, KEY_WRITE, NULL, &hKey, NULL);
if (Result != ERROR_SUCCESS)
{
LoadStringW(g_hInstance, IDS_CANTOPENKEY, sz, _countof(sz));
MessageBoxW(hwnd, sz, NULL, MB_ICONERROR);
return;
}
// set LastKey value
wsprintfW(sz, L"HKEY_LOCAL_MACHINE\\%s", g_pszKey);
DWORD dwSize = sizeof(sz);
Result = RegSetValueExW(hKey, L"LastKey", 0, REG_SZ,
(LPBYTE)sz, dwSize);
// close now
RegCloseKey(hKey);
if (Result != ERROR_SUCCESS)
{
LoadStringW(g_hInstance, IDS_CANTOPENKEY, sz, _countof(sz));
MessageBoxW(hwnd, sz, NULL, MB_ICONERROR);
return;
}
// open by regedit
ShellExecuteW(hwnd, NULL, L"regedit.exe", NULL, NULL, SW_SHOWNORMAL);
}
bool SetRegistryString(const char *szSubKey,
const char *szValueName,
const char *szValue)
{
long qerr;
HKEY ckey;
DWORD disposition;
// Open the key
if ((qerr=RegCreateKeyExW(HKEY_CURRENT_USER,
GetWideChar(szSubKey),
0,
L"",
REG_OPTION_NON_VOLATILE,
KEY_ALL_ACCESS,
NULL,
&ckey,
&disposition
))!=ERROR_SUCCESS) return false;
// Set the value
StdBuf v = GetWideCharBuf(szValue);
if ((qerr=RegSetValueExW(ckey,
GetWideChar(szValueName),
0,
REG_SZ,
getBufPtr<BYTE>(v),
v.getSize()
))!=ERROR_SUCCESS) { RegCloseKey(ckey); return false; }
// Close the key
RegCloseKey(ckey);
return true;
}
static LONG installBrandingValue(MSIHANDLE hModule,
const WCHAR *pwszFileName,
const WCHAR *pwszSection,
const WCHAR *pwszValue)
{
LONG rc;
WCHAR wszValue[_MAX_PATH];
if (GetPrivateProfileStringW(pwszSection, pwszValue, NULL,
wszValue, sizeof(wszValue), pwszFileName) > 0)
{
HKEY hkBranding;
WCHAR wszKey[_MAX_PATH];
if (wcsicmp(L"General", pwszSection) != 0)
swprintf_s(wszKey, RT_ELEMENTS(wszKey), L"SOFTWARE\\%s\\VirtualBox\\Branding\\", VBOX_VENDOR_SHORT, pwszSection);
else
swprintf_s(wszKey, RT_ELEMENTS(wszKey), L"SOFTWARE\\%s\\VirtualBox\\Branding", VBOX_VENDOR_SHORT);
rc = RegOpenKeyExW(HKEY_LOCAL_MACHINE, wszKey, 0, KEY_WRITE, &hkBranding);
if (rc == ERROR_SUCCESS)
{
rc = RegSetValueExW(hkBranding,
pwszValue,
NULL,
REG_SZ,
(BYTE *)wszValue,
(DWORD)wcslen(wszValue));
if (rc != ERROR_SUCCESS)
logStringW(hModule, L"InstallBranding: Could not write value %s! Error %ld", pwszValue, rc);
RegCloseKey (hkBranding);
}
}
else
rc = ERROR_NOT_FOUND;
return rc;
}
static HRESULT WINAPI stillimagew_RegisterLaunchApplication(IStillImageW *iface, LPWSTR pwszAppName,
LPWSTR pwszCommandLine)
{
static const WCHAR format[] = {'%','s',' ','%','s',0};
static const WCHAR commandLineSuffix[] = {
'/','S','t','i','D','e','v','i','c','e',':','%','1',' ',
'/','S','t','i','E','v','e','n','t',':','%','2',0};
HKEY registeredAppsKey = NULL;
DWORD ret;
HRESULT hr = S_OK;
stillimage *This = impl_from_IStillImageW(iface);
TRACE("(%p, %s, %s)\n", This, debugstr_w(pwszAppName), debugstr_w(pwszCommandLine));
ret = RegCreateKeyW(HKEY_LOCAL_MACHINE, registeredAppsLaunchPath, ®isteredAppsKey);
if (ret == ERROR_SUCCESS)
{
WCHAR *value = HeapAlloc(GetProcessHeap(), 0,
(lstrlenW(pwszCommandLine) + 1 + lstrlenW(commandLineSuffix) + 1) * sizeof(WCHAR));
if (value)
{
sprintfW(value, format, pwszCommandLine, commandLineSuffix);
ret = RegSetValueExW(registeredAppsKey, pwszAppName, 0,
REG_SZ, (BYTE*)value, (lstrlenW(value)+1)*sizeof(WCHAR));
if (ret != ERROR_SUCCESS)
hr = HRESULT_FROM_WIN32(ret);
HeapFree(GetProcessHeap(), 0, value);
}
else
hr = E_OUTOFMEMORY;
RegCloseKey(registeredAppsKey);
}
else
hr = HRESULT_FROM_WIN32(ret);
return hr;
}
/******************************************************************************
* Sets the value with name val_name to the data in val_data for the currently
* opened key.
*
* Parameters:
* val_name - name of the registry value
* val_data - registry value data
*/
static LONG setValue(WCHAR* val_name, WCHAR* val_data, BOOL is_unicode)
{
LONG res;
DWORD dwDataType, dwParseType;
LPBYTE lpbData;
DWORD dwData, dwLen;
WCHAR del[] = {'-',0};
if ( (val_name == NULL) || (val_data == NULL) )
return ERROR_INVALID_PARAMETER;
if (lstrcmpW(val_data, del) == 0)
{
res=RegDeleteValueW(currentKeyHandle,val_name);
return (res == ERROR_FILE_NOT_FOUND ? ERROR_SUCCESS : res);
}
/* Get the data type stored into the value field */
dwDataType = getDataType(&val_data, &dwParseType);
if (dwParseType == REG_SZ) /* no conversion for string */
{
REGPROC_unescape_string(val_data);
/* Compute dwLen after REGPROC_unescape_string because it may
* have changed the string length and we don't want to store
* the extra garbage in the registry.
*/
dwLen = lstrlenW(val_data);
if(val_data[dwLen-1] != '"')
return ERROR_INVALID_DATA;
if (dwLen>0 && val_data[dwLen-1]=='"')
{
dwLen--;
val_data[dwLen]='\0';
}
lpbData = (BYTE*) val_data;
dwLen++; /* include terminating null */
dwLen = dwLen * sizeof(WCHAR); /* size is in bytes */
}
else if (dwParseType == REG_DWORD) /* Convert the dword types */
{
if (!convertHexToDWord(val_data, &dwData))
return ERROR_INVALID_DATA;
lpbData = (BYTE*)&dwData;
dwLen = sizeof(dwData);
}
else if (dwParseType == REG_BINARY) /* Convert the binary data */
{
lpbData = convertHexCSVToHex(val_data, &dwLen);
if (!lpbData)
return ERROR_INVALID_DATA;
if((dwDataType == REG_MULTI_SZ || dwDataType == REG_EXPAND_SZ) && !is_unicode)
{
LPBYTE tmp = lpbData;
lpbData = (LPBYTE)GetWideStringN((char*)lpbData, dwLen, &dwLen);
dwLen *= sizeof(WCHAR);
HeapFree(GetProcessHeap(), 0, tmp);
}
}
else /* unknown format */
{
fprintf(stderr,"%s: ERROR, unknown data format\n", getAppName());
return ERROR_INVALID_DATA;
}
res = RegSetValueExW(
currentKeyHandle,
val_name,
0, /* Reserved */
dwDataType,
lpbData,
dwLen);
if (dwParseType == REG_BINARY)
HeapFree(GetProcessHeap(), 0, lpbData);
return res;
}
/***********************************************************************
* MSACM_WriteCurrentPriorities()
* Writes out current order of driver priorities to registry key:
* HKCU\\Software\\Microsoft\\Multimedia\\Audio Compression Manager\\Priority v4.00
*/
void MSACM_WriteCurrentPriorities(void)
{
LONG lError;
HKEY hPriorityKey;
static const WCHAR basePriorityKey[] = {
'S','o','f','t','w','a','r','e','\\',
'M','i','c','r','o','s','o','f','t','\\',
'M','u','l','t','i','m','e','d','i','a','\\',
'A','u','d','i','o',' ','C','o','m','p','r','e','s','s','i','o','n',' ','M','a','n','a','g','e','r','\\',
'P','r','i','o','r','i','t','y',' ','v','4','.','0','0','\0'
};
PWINE_ACMDRIVERID padid;
DWORD dwPriorityCounter;
static const WCHAR priorityTmpl[] = {'P','r','i','o','r','i','t','y','%','l','d','\0'};
static const WCHAR valueTmpl[] = {'%','c',',',' ','%','s','\0'};
static const WCHAR converterAlias[] = {'I','n','t','e','r','n','a','l',' ','P','C','M',' ','C','o','n','v','e','r','t','e','r','\0'};
WCHAR szSubKey[17];
WCHAR szBuffer[256];
/* Delete ACM priority key and create it anew */
lError = RegDeleteKeyW(HKEY_CURRENT_USER, basePriorityKey);
if (lError != ERROR_SUCCESS && lError != ERROR_FILE_NOT_FOUND) {
ERR("unable to remove current key %s (0x%08x) - priority changes won't persist past application end.\n",
debugstr_w(basePriorityKey), lError);
return;
}
lError = RegCreateKeyW(HKEY_CURRENT_USER, basePriorityKey, &hPriorityKey);
if (lError != ERROR_SUCCESS) {
ERR("unable to create key %s (0x%08x) - priority changes won't persist past application end.\n",
debugstr_w(basePriorityKey), lError);
return;
}
/* Write current list of priorities */
for (dwPriorityCounter = 0, padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
if (padid->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_LOCAL) continue;
if (padid->pszDriverAlias == NULL) continue; /* internal PCM converter is last */
/* Build required value name */
dwPriorityCounter++;
snprintfW(szSubKey, 17, priorityTmpl, dwPriorityCounter);
/* Value has a 1 in front for enabled drivers and 0 for disabled drivers */
snprintfW(szBuffer, 256, valueTmpl, (padid->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED) ? '0' : '1', padid->pszDriverAlias);
strlwrW(szBuffer);
lError = RegSetValueExW(hPriorityKey, szSubKey, 0, REG_SZ, (BYTE *)szBuffer, (strlenW(szBuffer) + 1) * sizeof(WCHAR));
if (lError != ERROR_SUCCESS) {
ERR("unable to write value for %s under key %s (0x%08x)\n",
debugstr_w(padid->pszDriverAlias), debugstr_w(basePriorityKey), lError);
}
}
/* Build required value name */
dwPriorityCounter++;
snprintfW(szSubKey, 17, priorityTmpl, dwPriorityCounter);
/* Value has a 1 in front for enabled drivers and 0 for disabled drivers */
snprintfW(szBuffer, 256, valueTmpl, '1', converterAlias);
lError = RegSetValueExW(hPriorityKey, szSubKey, 0, REG_SZ, (BYTE *)szBuffer, (strlenW(szBuffer) + 1) * sizeof(WCHAR));
if (lError != ERROR_SUCCESS) {
ERR("unable to write value for %s under key %s (0x%08x)\n",
debugstr_w(converterAlias), debugstr_w(basePriorityKey), lError);
}
RegCloseKey(hPriorityKey);
}
static int reg_delete(WCHAR *key_name, WCHAR *value_name, BOOL value_empty,
BOOL value_all, BOOL force)
{
LPWSTR p;
HKEY root,subkey;
static const WCHAR stubW[] = {'D','E','L','E','T','E',
' ','-',' ','%','s',' ','%','s',' ','%','d',' ','%','d',' ','%','d','\n'
,0
};
reg_printfW(stubW, key_name, value_name, value_empty, value_all, force);
if (key_name[0]=='\\' && key_name[1]=='\\')
{
reg_message(STRING_NO_REMOTE);
return 1;
}
p = strchrW(key_name,'\\');
if (!p)
{
reg_message(STRING_INVALID_KEY);
return 1;
}
p++;
root = get_rootkey(key_name);
if (!root)
{
reg_message(STRING_INVALID_KEY);
return 1;
}
if (value_name && value_empty)
{
reg_message(STRING_INVALID_CMDLINE);
return 1;
}
if (value_empty && value_all)
{
reg_message(STRING_INVALID_CMDLINE);
return 1;
}
if (!force)
{
/* FIXME: Prompt for delete */
}
/* Delete subtree only if no /v* option is given */
if (!value_name && !value_empty && !value_all)
{
if (RegDeleteTreeW(root,p)!=ERROR_SUCCESS)
{
reg_message(STRING_CANNOT_FIND);
return 1;
}
reg_message(STRING_SUCCESS);
return 0;
}
if(RegOpenKeyW(root,p,&subkey)!=ERROR_SUCCESS)
{
reg_message(STRING_CANNOT_FIND);
return 1;
}
if (value_all)
{
LPWSTR szValue;
DWORD maxValue;
DWORD count;
LONG rc;
rc = RegQueryInfoKeyW(subkey, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
&maxValue, NULL, NULL, NULL);
if (rc != ERROR_SUCCESS)
{
/* FIXME: failure */
RegCloseKey(subkey);
return 1;
}
maxValue++;
szValue = HeapAlloc(GetProcessHeap(),0,maxValue*sizeof(WCHAR));
while (1)
{
count = maxValue;
rc = RegEnumValueW(subkey, 0, szValue, &count, NULL, NULL, NULL, NULL);
if (rc == ERROR_SUCCESS)
{
rc = RegDeleteValueW(subkey, szValue);
if (rc != ERROR_SUCCESS)
break;
}
else break;
}
if (rc != ERROR_SUCCESS)
{
/* FIXME delete failed */
}
}
else if (value_name)
{
if (RegDeleteValueW(subkey,value_name) != ERROR_SUCCESS)
{
RegCloseKey(subkey);
reg_message(STRING_CANNOT_FIND);
return 1;
}
}
else if (value_empty)
{
RegSetValueExW(subkey,NULL,0,REG_SZ,NULL,0);
}
RegCloseKey(subkey);
reg_message(STRING_SUCCESS);
return 0;
}
/**
* Removes a string entry from a MULTI_SZ registry list.
*
* @return Exit code (EXIT_OK, EXIT_FAIL)
* @param pszSubKey Sub key containing the list.
* @param pszKeyValue The actual key name of the list.
* @param pszValueToRemove The value to remove from the list.
*/
int RegistryRemoveStringFromMultiSZ(const TCHAR *pszSubKey, const TCHAR *pszKeyValue, const TCHAR *pszValueToRemove)
{
// @todo Make string sizes dynamically allocated!
const TCHAR *pszKey = pszSubKey;
#ifdef DEBUG
_tprintf(_T("RemoveStringFromMultiSZ: Removing MULTI_SZ string: %ws from %ws\\%ws ...\n"), pszValueToRemove, pszSubKey, pszKeyValue);
#endif
HKEY hkey;
DWORD disp, dwType;
LONG lRet = RegCreateKeyEx(HKEY_LOCAL_MACHINE, pszKey, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_READ | KEY_WRITE, NULL, &hkey, &disp);
if (lRet != ERROR_SUCCESS)
_tprintf(_T("RemoveStringFromMultiSZ: RegCreateKeyEx %ts failed with error %ld!\n"), pszKey, lRet);
if (lRet == ERROR_SUCCESS)
{
TCHAR szKeyValue[1024];
DWORD cbKeyValue = sizeof(szKeyValue);
lRet = RegQueryValueEx(hkey, pszKeyValue, NULL, &dwType, (LPBYTE)szKeyValue, &cbKeyValue);
if ( lRet != ERROR_SUCCESS
|| dwType != REG_MULTI_SZ)
{
_tprintf(_T("RemoveStringFromMultiSZ: RegQueryValueEx failed with %d, key type = 0x%x!\n"), lRet, dwType);
}
else
{
#ifdef DEBUG
_tprintf(_T("RemoveStringFromMultiSZ: Current key len: %ld\n"), cbKeyValue);
#endif
TCHAR szCurString[1024] = { 0 };
TCHAR szFinalString[1024] = { 0 };
int iIndex = 0;
int iNewIndex = 0;
for (unsigned i = 0; i < cbKeyValue / sizeof(TCHAR); i++)
{
if (szKeyValue[i] != _T('\0'))
szCurString[iIndex++] = szKeyValue[i];
if ( (!szKeyValue[i] == _T('\0'))
&& (szKeyValue[i + 1] == _T('\0')))
{
if (NULL == wcsstr(szCurString, pszValueToRemove))
{
wcscat(&szFinalString[iNewIndex], szCurString);
if (iNewIndex == 0)
iNewIndex = iIndex;
else iNewIndex += iIndex;
szFinalString[++iNewIndex] = _T('\0');
}
iIndex = 0;
ZeroMemory(szCurString, sizeof(szCurString));
}
}
szFinalString[++iNewIndex] = _T('\0');
#ifdef DEBUG
_tprintf(_T("RemoveStringFromMultiSZ: New key value: %ws (%u bytes)\n"),
szFinalString, iNewIndex * sizeof(TCHAR));
#endif
lRet = RegSetValueExW(hkey, pszKeyValue, 0, REG_MULTI_SZ, (LPBYTE)szFinalString, iNewIndex * sizeof(TCHAR));
if (lRet != ERROR_SUCCESS)
_tprintf(_T("RemoveStringFromMultiSZ: RegSetValueEx failed with %d!\n"), lRet);
}
RegCloseKey(hkey);
#ifdef DEBUG
if (lRet == ERROR_SUCCESS)
_tprintf(_T("RemoveStringFromMultiSZ: Value %ws successfully removed!\n"), pszValueToRemove);
#endif
}
return (lRet == ERROR_SUCCESS) ? EXIT_OK : EXIT_FAIL;
}
static BOOL
CopyKey (HKEY hDstKey,
HKEY hSrcKey)
{
LONG Error;
#if (_WIN32_WINNT >= 0x0600)
Error = RegCopyTreeW(hSrcKey,
NULL,
hDstKey);
if (Error != ERROR_SUCCESS)
{
SetLastError((DWORD)Error);
return FALSE;
}
return TRUE;
#else
FILETIME LastWrite;
DWORD dwSubKeys;
DWORD dwValues;
DWORD dwType;
DWORD dwMaxSubKeyNameLength;
DWORD dwSubKeyNameLength;
DWORD dwMaxValueNameLength;
DWORD dwValueNameLength;
DWORD dwMaxValueLength;
DWORD dwValueLength;
DWORD dwDisposition;
DWORD i;
LPWSTR lpNameBuffer;
LPBYTE lpDataBuffer;
HKEY hDstSubKey;
HKEY hSrcSubKey;
DPRINT ("CopyKey() called \n");
Error = RegQueryInfoKey (hSrcKey,
NULL,
NULL,
NULL,
&dwSubKeys,
&dwMaxSubKeyNameLength,
NULL,
&dwValues,
&dwMaxValueNameLength,
&dwMaxValueLength,
NULL,
NULL);
if (Error != ERROR_SUCCESS)
{
DPRINT1 ("RegQueryInfoKey() failed (Error %lu)\n", Error);
SetLastError((DWORD)Error);
return FALSE;
}
DPRINT ("dwSubKeys %lu\n", dwSubKeys);
DPRINT ("dwMaxSubKeyNameLength %lu\n", dwMaxSubKeyNameLength);
DPRINT ("dwValues %lu\n", dwValues);
DPRINT ("dwMaxValueNameLength %lu\n", dwMaxValueNameLength);
DPRINT ("dwMaxValueLength %lu\n", dwMaxValueLength);
/* Copy subkeys */
if (dwSubKeys != 0)
{
lpNameBuffer = HeapAlloc (GetProcessHeap (),
0,
dwMaxSubKeyNameLength * sizeof(WCHAR));
if (lpNameBuffer == NULL)
{
DPRINT1("Buffer allocation failed\n");
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return FALSE;
}
for (i = 0; i < dwSubKeys; i++)
{
dwSubKeyNameLength = dwMaxSubKeyNameLength;
Error = RegEnumKeyExW (hSrcKey,
i,
lpNameBuffer,
&dwSubKeyNameLength,
NULL,
NULL,
NULL,
&LastWrite);
if (Error != ERROR_SUCCESS)
{
DPRINT1 ("Subkey enumeration failed (Error %lu)\n", Error);
HeapFree (GetProcessHeap (),
0,
lpNameBuffer);
SetLastError((DWORD)Error);
return FALSE;
}
Error = RegCreateKeyExW (hDstKey,
lpNameBuffer,
0,
NULL,
REG_OPTION_NON_VOLATILE,
KEY_WRITE,
NULL,
&hDstSubKey,
&dwDisposition);
if (Error != ERROR_SUCCESS)
{
DPRINT1 ("Subkey creation failed (Error %lu)\n", Error);
HeapFree (GetProcessHeap (),
0,
lpNameBuffer);
SetLastError((DWORD)Error);
return FALSE;
}
Error = RegOpenKeyExW (hSrcKey,
lpNameBuffer,
0,
KEY_READ,
&hSrcSubKey);
if (Error != ERROR_SUCCESS)
{
DPRINT1 ("Error: %lu\n", Error);
RegCloseKey (hDstSubKey);
HeapFree (GetProcessHeap (),
0,
lpNameBuffer);
SetLastError((DWORD)Error);
return FALSE;
}
if (!CopyKey (hDstSubKey,
hSrcSubKey))
{
DPRINT1 ("Error: %lu\n", GetLastError());
RegCloseKey (hSrcSubKey);
RegCloseKey (hDstSubKey);
HeapFree (GetProcessHeap (),
0,
lpNameBuffer);
return FALSE;
}
RegCloseKey (hSrcSubKey);
RegCloseKey (hDstSubKey);
}
HeapFree (GetProcessHeap (),
0,
lpNameBuffer);
}
/* Copy values */
if (dwValues != 0)
{
lpNameBuffer = HeapAlloc (GetProcessHeap (),
0,
dwMaxValueNameLength * sizeof(WCHAR));
if (lpNameBuffer == NULL)
{
DPRINT1 ("Buffer allocation failed\n");
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return FALSE;
}
lpDataBuffer = HeapAlloc (GetProcessHeap (),
0,
dwMaxValueLength);
if (lpDataBuffer == NULL)
{
DPRINT1 ("Buffer allocation failed\n");
HeapFree (GetProcessHeap (),
0,
lpNameBuffer);
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return FALSE;
}
for (i = 0; i < dwValues; i++)
{
dwValueNameLength = dwMaxValueNameLength;
dwValueLength = dwMaxValueLength;
Error = RegEnumValueW (hSrcKey,
i,
lpNameBuffer,
&dwValueNameLength,
NULL,
&dwType,
lpDataBuffer,
&dwValueLength);
if (Error != ERROR_SUCCESS)
{
DPRINT1("Error: %lu\n", Error);
HeapFree (GetProcessHeap (),
0,
lpDataBuffer);
HeapFree (GetProcessHeap (),
0,
lpNameBuffer);
SetLastError((DWORD)Error);
return FALSE;
}
Error = RegSetValueExW (hDstKey,
lpNameBuffer,
0,
dwType,
lpDataBuffer,
dwValueLength);
if (Error != ERROR_SUCCESS)
{
DPRINT1("Error: %lu\n", Error);
HeapFree (GetProcessHeap (),
0,
lpDataBuffer);
HeapFree (GetProcessHeap (),
0,
lpNameBuffer);
SetLastError((DWORD)Error);
return FALSE;
}
}
HeapFree (GetProcessHeap (),
0,
lpDataBuffer);
HeapFree (GetProcessHeap (),
0,
lpNameBuffer);
}
DPRINT ("CopyKey() done \n");
return TRUE;
#endif
}
LONG
WINAPI
ComDBReleasePort(IN HCOMDB hComDB,
IN DWORD ComNumber)
{
PCOMDB pComDB;
DWORD dwByteIndex;
DWORD dwBitIndex;
DWORD dwType;
DWORD dwSize;
PBYTE pBitmap = NULL;
BYTE cMask;
LONG lError;
TRACE("ComDBReleasePort(%p %lu)\n", hComDB, ComNumber);
if (hComDB == INVALID_HANDLE_VALUE ||
ComNumber == 0 ||
ComNumber > COMDB_MAX_PORTS_ARBITRATED)
return ERROR_INVALID_PARAMETER;
pComDB = (PCOMDB)hComDB;
/* Wait for the mutex */
WaitForSingleObject(pComDB->hMutex, INFINITE);
/* Get the required bitmap size */
lError = RegQueryValueExW(pComDB->hKey,
L"ComDB",
NULL,
&dwType,
NULL,
&dwSize);
if (lError != ERROR_SUCCESS)
{
ERR("Failed to query the bitmap size!\n");
goto done;
}
/* Allocate the bitmap */
pBitmap = HeapAlloc(GetProcessHeap(),
HEAP_ZERO_MEMORY,
dwSize);
if (pBitmap == NULL)
{
ERR("Failed to allocate the bitmap!\n");
lError = ERROR_NOT_ENOUGH_MEMORY;
goto done;
}
/* Read the bitmap */
lError = RegQueryValueExW(pComDB->hKey,
L"ComDB",
NULL,
&dwType,
pBitmap,
&dwSize);
if (lError != ERROR_SUCCESS)
goto done;
/* Get the bit index */
dwBitIndex = ComNumber - 1;
/* Check if the bit to set fits into the bitmap */
if (dwBitIndex >= (dwSize * BITS_PER_BYTE))
{
lError = ERROR_INVALID_PARAMETER;
goto done;
}
/* Calculate the byte index and a mask for the affected bit */
dwByteIndex = dwBitIndex / BITS_PER_BYTE;
cMask = 1 << (dwBitIndex % BITS_PER_BYTE);
/* Release the port */
pBitmap[dwByteIndex] &= ~cMask;
lError = RegSetValueExW(pComDB->hKey,
L"ComDB",
0,
REG_BINARY,
pBitmap,
dwSize);
done:;
/* Release the mutex */
ReleaseMutex(pComDB->hMutex);
/* Release the bitmap */
if (pBitmap != NULL)
HeapFree(GetProcessHeap(), 0, pBitmap);
return lError;
}
LONG
WINAPI
ComDBClaimNextFreePort(IN HCOMDB hComDB,
OUT LPDWORD ComNumber)
{
PCOMDB pComDB;
DWORD dwBitIndex;
DWORD dwByteIndex;
DWORD dwSize;
DWORD dwType;
PBYTE pBitmap = NULL;
BYTE cMask;
LONG lError;
TRACE("ComDBClaimNextFreePort(%p %p)\n", hComDB, ComNumber);
if (hComDB == INVALID_HANDLE_VALUE ||
hComDB == NULL ||
ComNumber == NULL)
return ERROR_INVALID_PARAMETER;
pComDB = (PCOMDB)hComDB;
/* Wait for the mutex */
WaitForSingleObject(pComDB->hMutex, INFINITE);
/* Get the required bitmap size */
lError = RegQueryValueExW(pComDB->hKey,
L"ComDB",
NULL,
&dwType,
NULL,
&dwSize);
if (lError != ERROR_SUCCESS)
{
ERR("Failed to query the bitmap size!\n");
goto done;
}
/* Allocate the bitmap */
pBitmap = HeapAlloc(GetProcessHeap(),
HEAP_ZERO_MEMORY,
dwSize);
if (pBitmap == NULL)
{
ERR("Failed to allocate the bitmap!\n");
lError = ERROR_NOT_ENOUGH_MEMORY;
goto done;
}
/* Read the bitmap */
lError = RegQueryValueExW(pComDB->hKey,
L"ComDB",
NULL,
&dwType,
pBitmap,
&dwSize);
if (lError != ERROR_SUCCESS)
goto done;
lError = ERROR_INVALID_PARAMETER;
for (dwBitIndex = 0; dwBitIndex < (dwSize * BITS_PER_BYTE); dwBitIndex++)
{
/* Calculate the byte index and a mask for the affected bit */
dwByteIndex = dwBitIndex / BITS_PER_BYTE;
cMask = 1 << (dwBitIndex % BITS_PER_BYTE);
if ((pBitmap[dwByteIndex] & cMask) == 0)
{
pBitmap[dwByteIndex] |= cMask;
*ComNumber = dwBitIndex + 1;
lError = ERROR_SUCCESS;
break;
}
}
/* Save the bitmap if it was modified */
if (lError == ERROR_SUCCESS)
{
lError = RegSetValueExW(pComDB->hKey,
L"ComDB",
0,
REG_BINARY,
pBitmap,
dwSize);
}
done:;
/* Release the mutex */
ReleaseMutex(pComDB->hMutex);
/* Release the bitmap */
if (pBitmap != NULL)
HeapFree(GetProcessHeap(), 0, pBitmap);
return lError;
}
/* wrapper for RegSetValueExW */
static DWORD set_reg_value( HKEY hkey, const WCHAR *name, const WCHAR *value )
{
return RegSetValueExW( hkey, name, 0, REG_SZ, (const BYTE *)value, (strlenW(value) + 1) * sizeof(WCHAR) );
}
VOID
DisableNetworkAdapter(INetConnection * pNet, LANSTATUSUI_CONTEXT * pContext, HWND hwndDlg)
{
HKEY hKey;
NETCON_PROPERTIES * pProperties;
LPOLESTR pDisplayName;
WCHAR szPath[200];
DWORD dwSize, dwType;
LPWSTR pPnp;
HDEVINFO hInfo;
SP_DEVINFO_DATA DevInfo;
SP_PROPCHANGE_PARAMS PropChangeParams;
BOOL bClose = FALSE;
NOTIFYICONDATAW nid;
if (FAILED(pNet->GetProperties(&pProperties)))
return;
hInfo = SetupDiGetClassDevsW(&GUID_DEVCLASS_NET, NULL, NULL, DIGCF_PRESENT );
if (!hInfo)
{
NcFreeNetconProperties(pProperties);
return;
}
if (FAILED(StringFromCLSID((CLSID)pProperties->guidId, &pDisplayName)))
{
NcFreeNetconProperties(pProperties);
SetupDiDestroyDeviceInfoList(hInfo);
return;
}
NcFreeNetconProperties(pProperties);
if (FindNetworkAdapter(hInfo, &DevInfo, pDisplayName))
{
PropChangeParams.ClassInstallHeader.cbSize = sizeof(SP_CLASSINSTALL_HEADER);
PropChangeParams.ClassInstallHeader.InstallFunction = DIF_PROPERTYCHANGE; //;
PropChangeParams.StateChange = DICS_DISABLE;
PropChangeParams.Scope = DICS_FLAG_CONFIGSPECIFIC;
PropChangeParams.HwProfile = 0;
if (SetupDiSetClassInstallParams(hInfo, &DevInfo, &PropChangeParams.ClassInstallHeader, sizeof(SP_PROPCHANGE_PARAMS)))
{
if (SetupDiCallClassInstaller(DIF_PROPERTYCHANGE, hInfo, &DevInfo))
bClose = TRUE;
}
}
SetupDiDestroyDeviceInfoList(hInfo);
swprintf(szPath, L"SYSTEM\\CurrentControlSet\\Control\\Network\\{4D36E972-E325-11CE-BFC1-08002BE10318}\\%s\\Connection", pDisplayName);
CoTaskMemFree(pDisplayName);
if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, szPath, 0, KEY_READ, &hKey) != ERROR_SUCCESS)
return;
dwSize = 0;
if (RegQueryValueExW(hKey, L"PnpInstanceID", NULL, &dwType, NULL, &dwSize) != ERROR_SUCCESS || dwType != REG_SZ)
{
RegCloseKey(hKey);
return;
}
pPnp = static_cast<PWSTR>(CoTaskMemAlloc(dwSize));
if (!pPnp)
{
RegCloseKey(hKey);
return;
}
if (RegQueryValueExW(hKey, L"PnpInstanceID", NULL, &dwType, (LPBYTE)pPnp, &dwSize) != ERROR_SUCCESS)
{
CoTaskMemFree(pPnp);
RegCloseKey(hKey);
return;
}
RegCloseKey(hKey);
swprintf(szPath, L"System\\CurrentControlSet\\Hardware Profiles\\Current\\System\\CurrentControlSet\\Enum\\%s", pPnp);
CoTaskMemFree(pPnp);
if (RegCreateKeyExW(HKEY_LOCAL_MACHINE, szPath, 0, NULL, 0, KEY_WRITE, NULL, &hKey, NULL) != ERROR_SUCCESS)
return;
dwSize = 1; /* enable = 0, disable = 1 */
RegSetValueExW(hKey, L"CSConfigFlags", 0, REG_DWORD, (LPBYTE)&dwSize, sizeof(DWORD));
RegCloseKey(hKey);
if (!bClose)
return;
PropSheet_PressButton(GetParent(hwndDlg), PSBTN_CANCEL);
ZeroMemory(&nid, sizeof(nid));
nid.cbSize = sizeof(nid);
nid.uID = pContext->uID;
nid.hWnd = pContext->hwndDlg;
nid.uFlags = NIF_STATE;
nid.dwState = NIS_HIDDEN;
nid.dwStateMask = NIS_HIDDEN;
Shell_NotifyIconW(NIM_MODIFY, &nid);
}
LONG
DeleteFromMultiSzValue (
HKEY hkeyAdapterGuid,
_In_ LPWSTR szMiniportGuid)
{
LPWSTR lpCurrentValue=NULL;
LPWSTR lpNewValue=NULL;
LPWSTR lpCurrentValueTemp;
LPWSTR lpNewValueTemp;
DWORD dwLen;
DWORD dwNewLen;
LONG lResult;
dwLen = 0;
lResult = RegQueryValueExW(
hkeyAdapterGuid,
c_szUpperBindings,
NULL,
NULL,
NULL,
&dwLen );
if ( lResult == ERROR_SUCCESS ) {
lpCurrentValue = (LPWSTR)calloc( dwLen, 1 );
lpNewValue = (LPWSTR)calloc( dwLen, 1 );
if ( (lpCurrentValue != NULL) && (lpNewValue != NULL) ) {
lResult = RegQueryValueExW(
hkeyAdapterGuid,
c_szUpperBindings,
NULL,
NULL,
(LPBYTE)lpCurrentValue,
&dwLen );
if ( lResult == ERROR_SUCCESS ) {
lpCurrentValueTemp = lpCurrentValue;
lpNewValueTemp = lpNewValue;
dwNewLen = 0;
lpCurrentValueTemp[dwLen-1]='\0';
while( wcslen(lpCurrentValueTemp) > 0) {
//if a register in the existing register sequence do not match szMiniportGuid, copy to new register sequence
if ( _wcsicmp(lpCurrentValueTemp, szMiniportGuid) != 0 ) {
StringCchCopyW ( lpNewValueTemp,
wcslen(lpCurrentValueTemp), //size of the register
lpCurrentValueTemp );
*(lpNewValueTemp+=wcslen(lpCurrentValueTemp)+1)='\0';
lpNewValueTemp += wcslen(lpNewValueTemp) + 1;
dwNewLen += (DWORD)wcslen(lpNewValueTemp) + 1;
}
lpCurrentValueTemp += wcslen(lpCurrentValueTemp) + 1;
} //end of while
//the minimum length of a register sequence is 3 (start with '\\' and end with '\0') eg: '\\','a','\0'
if ( dwNewLen > 2 ) {
lResult = RegSetValueExW( hkeyAdapterGuid,
c_szUpperBindings,
0,
REG_MULTI_SZ,
(LPBYTE)lpNewValue,
dwNewLen );
}
else {
lResult = RegDeleteValueW( hkeyAdapterGuid,
c_szUpperBindings );
}
}
}
else {
lResult = ERROR_NOT_ENOUGH_MEMORY;
}
}
if ( lpCurrentValue ) {
free( lpCurrentValue );
}
if ( lpNewValue ) {
free( lpNewValue );
}
return lResult;
}
LONG
AddToMultiSzValue (
HKEY hkeyAdapterGuid,
_In_ LPWSTR szMiniportGuid)
{
LPWSTR lpCurrentValue=NULL;
LPWSTR lpNewValue=NULL;
DWORD dwLen;
DWORD dwNewLen;
LONG lResult;
dwLen = 0;
lResult = RegQueryValueExW(
hkeyAdapterGuid,
c_szUpperBindings,
NULL,
NULL,
NULL,
&dwLen );
if( lResult != ERROR_SUCCESS ){
//you may do something
}
if ( dwLen != 0 ) {
lpCurrentValue = (LPWSTR)calloc( dwLen, 1 );
if ( lpCurrentValue ) {
lResult = RegQueryValueExW( hkeyAdapterGuid,
c_szUpperBindings,
NULL,
NULL,
(LPBYTE)lpCurrentValue,
&dwLen );
}
else {
lResult = ERROR_NOT_ENOUGH_MEMORY;
}
}
else {
dwLen = sizeof(WCHAR);
lpCurrentValue = (LPWSTR)calloc( dwLen, 1 );
if ( !lpCurrentValue ) {
lResult = ERROR_NOT_ENOUGH_MEMORY;
}
else {
lResult = ERROR_SUCCESS;
}
}
if ( lResult == ERROR_SUCCESS ) {
dwNewLen =(DWORD) (dwLen + ((wcslen(szMiniportGuid) + 1) * sizeof(WCHAR)));
lpNewValue = (LPWSTR)malloc( dwNewLen );
if ( lpNewValue ) {
StringCbCopyW ( lpNewValue,
dwNewLen,
szMiniportGuid );
CopyMemory( lpNewValue+wcslen(szMiniportGuid)+1,
lpCurrentValue,
dwLen );
lResult = RegSetValueExW( hkeyAdapterGuid,
c_szUpperBindings,
0,
REG_MULTI_SZ,
(LPBYTE)lpNewValue,
dwNewLen );
}
else {
lResult = ERROR_NOT_ENOUGH_MEMORY;
}
}
if ( lpCurrentValue ) {
#ifndef DISABLE_PREFAST_PRAGMA
#pragma prefast(suppress:__WARNING_MISSING_ZERO_TERMINATION, "lpCurrentValue is used as a counted string.")
#endif
free( lpCurrentValue );
}
if ( lpNewValue ) {
free( lpNewValue );
}
return lResult;
}
/**
* Removes a string from a registry string list (STRING_SZ).
* Only operates in HKLM for now, needs to be extended later for
* using other hives. Only processes lists with a "," separator
* at the moment.
*
* @return Exit code (EXIT_OK, EXIT_FAIL)
* @param pszSubKey Sub key containing the list.
* @param pszKeyValue The actual key name of the list.
* @param pszValueToRemove The value to remove from the list.
*/
int RegistryRemoveStringFromList(const TCHAR *pszSubKey, const TCHAR *pszKeyValue, const TCHAR *pszValueToRemove)
{
HKEY hKey = NULL;
DWORD disp, dwType;
LONG lRet = RegCreateKeyEx(HKEY_LOCAL_MACHINE, pszSubKey, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_READ | KEY_WRITE, NULL, &hKey, &disp);
if (lRet != ERROR_SUCCESS)
_tprintf(_T("RegistryRemoveStringFromList: RegCreateKeyEx %ts failed with error %ld!\n"), pszSubKey, lRet);
TCHAR szKeyValue[512] = { 0 };
TCHAR szNewKeyValue[512] = { 0 };
DWORD cbKeyValue = sizeof(szKeyValue);
lRet = RegQueryValueEx(hKey, pszKeyValue, NULL, &dwType, (LPBYTE)szKeyValue, &cbKeyValue);
if ( lRet != ERROR_SUCCESS
|| dwType != REG_SZ)
{
_tprintf(_T("RegistryRemoveStringFromList: RegQueryValueEx failed with %d, key type = 0x%x!\n"), lRet, dwType);
}
if (lRet == ERROR_SUCCESS)
{
#ifdef DEBUG
_tprintf(_T("RegistryRemoveStringFromList: Key value: %ws\n"), szKeyValue);
#endif
/* Create entire new list. */
int iPos = 0;
TCHAR *pszToken = wcstok(szKeyValue, _T(","));
TCHAR *pszNewToken = NULL;
while (pszToken != NULL)
{
pszNewToken = wcstok(NULL, _T(","));
/* Append all list values as long as it's not the
* value we want to remove. */
if (wcsicmp(pszToken, pszValueToRemove))
{
wcscat(szNewKeyValue, pszToken);
wcscat(szNewKeyValue, _T(","));
iPos++;
}
#ifdef DEBUG
_tprintf (_T("RegistryRemoveStringFromList: Temp new key value: %ws\n"), szNewKeyValue);
#endif
pszToken = pszNewToken;
}
/* Last char a delimiter? Cut off ... */
if (szNewKeyValue[wcslen(szNewKeyValue) - 1] == ',')
szNewKeyValue[wcslen(szNewKeyValue) - 1] = '\0';
size_t iNewLen = (wcslen(szNewKeyValue) * sizeof(WCHAR)) + sizeof(WCHAR);
#ifdef DEBUG
_tprintf(_T("RegistryRemoveStringFromList: New provider list: %ws (%u bytes)\n"), szNewKeyValue, iNewLen);
#endif
lRet = RegSetValueExW(hKey, pszKeyValue, 0, REG_SZ, (LPBYTE)szNewKeyValue, (DWORD)iNewLen);
if (lRet != ERROR_SUCCESS)
_tprintf(_T("RegistryRemoveStringFromList: RegSetValueEx failed with %ld!\n"), lRet);
}
RegCloseKey(hKey);
return (lRet == ERROR_SUCCESS) ? EXIT_OK : EXIT_FAIL;
}
/**
* Adds a string to a registry string list (STRING_SZ).
* Only operates in HKLM for now, needs to be extended later for
* using other hives. Only processes lists with a "," separator
* at the moment.
*
* @return Exit code (EXIT_OK, EXIT_FAIL)
* @param pszSubKey Sub key containing the list.
* @param pszKeyValue The actual key name of the list.
* @param pszValueToAdd The value to add to the list.
* @param uiOrder Position (zero-based) of where to add the value to the list.
* @param dwFlags Flags.
*/
int RegistryAddStringToList(const TCHAR *pszSubKey, const TCHAR *pszKeyValue, const TCHAR *pszValueToAdd,
unsigned int uiOrder, DWORD dwFlags)
{
HKEY hKey = NULL;
DWORD disp, dwType;
LONG lRet = RegCreateKeyEx(HKEY_LOCAL_MACHINE, pszSubKey, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_READ | KEY_WRITE, NULL, &hKey, &disp);
if (lRet != ERROR_SUCCESS)
_tprintf(_T("RegistryAddStringToList: RegCreateKeyEx %ts failed with error %ld!\n"), pszSubKey, lRet);
TCHAR szKeyValue[512] = { 0 };
TCHAR szNewKeyValue[512] = { 0 };
DWORD cbKeyValue = sizeof(szKeyValue);
lRet = RegQueryValueEx(hKey, pszKeyValue, NULL, &dwType, (LPBYTE)szKeyValue, &cbKeyValue);
if ( lRet != ERROR_SUCCESS
|| dwType != REG_SZ)
{
_tprintf(_T("RegistryAddStringToList: RegQueryValueEx failed with %d, key type = 0x%x!\n"), lRet, dwType);
}
if (lRet == ERROR_SUCCESS)
{
#ifdef DEBUG
_tprintf(_T("RegistryAddStringToList: Key value: %ws\n"), szKeyValue);
#endif
/* Create entire new list. */
unsigned int iPos = 0;
TCHAR *pszToken = wcstok(szKeyValue, _T(","));
TCHAR *pszNewToken = NULL;
while (pszToken != NULL)
{
pszNewToken = wcstok(NULL, _T(","));
/* Append new provider name (at beginning if iOrder=0). */
if (iPos == uiOrder)
{
wcscat(szNewKeyValue, pszValueToAdd);
wcscat(szNewKeyValue, _T(","));
iPos++;
}
BOOL fAddToList = FALSE;
if ( !wcsicmp(pszToken, pszValueToAdd)
&& (dwFlags & VBOX_REG_STRINGLIST_ALLOW_DUPLICATES))
fAddToList = TRUE;
else if (wcsicmp(pszToken, pszValueToAdd))
fAddToList = TRUE;
if (fAddToList)
{
wcscat(szNewKeyValue, pszToken);
wcscat(szNewKeyValue, _T(","));
iPos++;
}
#ifdef DEBUG
_tprintf (_T("RegistryAddStringToList: Temp new key value: %ws\n"), szNewKeyValue);
#endif
pszToken = pszNewToken;
}
/* Append as last item if needed. */
if (uiOrder >= iPos)
wcscat(szNewKeyValue, pszValueToAdd);
/* Last char a delimiter? Cut off ... */
if (szNewKeyValue[wcslen(szNewKeyValue) - 1] == ',')
szNewKeyValue[wcslen(szNewKeyValue) - 1] = '\0';
size_t iNewLen = (wcslen(szNewKeyValue) * sizeof(WCHAR)) + sizeof(WCHAR);
#ifdef DEBUG
_tprintf(_T("RegistryAddStringToList: New provider list: %ws (%u bytes)\n"), szNewKeyValue, iNewLen);
#endif
lRet = RegSetValueExW(hKey, pszKeyValue, 0, REG_SZ, (LPBYTE)szNewKeyValue, (DWORD)iNewLen);
if (lRet != ERROR_SUCCESS)
_tprintf(_T("RegistryAddStringToList: RegSetValueEx failed with %ld!\n"), lRet);
}
RegCloseKey(hKey);
return (lRet == ERROR_SUCCESS) ? EXIT_OK : EXIT_FAIL;
}
static HRESULT do_process_key(LPCOLESTR *pstr, HKEY parent_key, strbuf *buf, BOOL do_register)
{
LPCOLESTR iter = *pstr;
HRESULT hres;
LONG lres;
HKEY hkey = 0;
strbuf name;
enum {
NORMAL,
NO_REMOVE,
IS_VAL,
FORCE_REMOVE,
DO_DELETE
} key_type = NORMAL;
static const WCHAR wstrNoRemove[] = {'N','o','R','e','m','o','v','e',0};
static const WCHAR wstrForceRemove[] = {'F','o','r','c','e','R','e','m','o','v','e',0};
static const WCHAR wstrDelete[] = {'D','e','l','e','t','e',0};
static const WCHAR wstrval[] = {'v','a','l',0};
iter = *pstr;
hres = get_word(&iter, buf);
if(FAILED(hres))
return hres;
strbuf_init(&name);
while(buf->str[1] || buf->str[0] != '}') {
key_type = NORMAL;
if(!lstrcmpiW(buf->str, wstrNoRemove))
key_type = NO_REMOVE;
else if(!lstrcmpiW(buf->str, wstrForceRemove))
key_type = FORCE_REMOVE;
else if(!lstrcmpiW(buf->str, wstrval))
key_type = IS_VAL;
else if(!lstrcmpiW(buf->str, wstrDelete))
key_type = DO_DELETE;
if(key_type != NORMAL) {
hres = get_word(&iter, buf);
if(FAILED(hres))
break;
}
TRACE("name = %s\n", debugstr_w(buf->str));
if(do_register) {
if(key_type == IS_VAL) {
hkey = parent_key;
strbuf_write(buf->str, &name, -1);
}else if(key_type == DO_DELETE) {
TRACE("Deleting %s\n", debugstr_w(buf->str));
lres = RegDeleteTreeW(parent_key, buf->str);
}else {
if(key_type == FORCE_REMOVE)
RegDeleteTreeW(parent_key, buf->str);
lres = RegCreateKeyW(parent_key, buf->str, &hkey);
if(lres != ERROR_SUCCESS) {
WARN("Could not create(open) key: %08x\n", lres);
hres = HRESULT_FROM_WIN32(lres);
break;
}
}
}else if(key_type != IS_VAL && key_type != DO_DELETE) {
strbuf_write(buf->str, &name, -1);
lres = RegOpenKeyW(parent_key, buf->str, &hkey);
if(lres != ERROR_SUCCESS)
WARN("Could not open key %s: %08x\n", debugstr_w(name.str), lres);
}
if(key_type != DO_DELETE && *iter == '=') {
iter++;
hres = get_word(&iter, buf);
if(FAILED(hres))
break;
if(buf->len != 1) {
WARN("Wrong registry type: %s\n", debugstr_w(buf->str));
hres = DISP_E_EXCEPTION;
break;
}
if(do_register) {
switch(buf->str[0]) {
case 's':
hres = get_word(&iter, buf);
if(FAILED(hres))
break;
lres = RegSetValueExW(hkey, name.len ? name.str : NULL, 0, REG_SZ, (PBYTE)buf->str,
(lstrlenW(buf->str)+1)*sizeof(WCHAR));
if(lres != ERROR_SUCCESS) {
WARN("Could set value of key: %08x\n", lres);
hres = HRESULT_FROM_WIN32(lres);
break;
}
break;
case 'd': {
WCHAR *end;
DWORD dw;
if(*iter == '0' && iter[1] == 'x') {
iter += 2;
dw = strtolW(iter, &end, 16);
}else {
dw = strtolW(iter, &end, 10);
}
iter = end;
lres = RegSetValueExW(hkey, name.len ? name.str : NULL, 0, REG_DWORD,
(PBYTE)&dw, sizeof(dw));
if(lres != ERROR_SUCCESS) {
WARN("Could set value of key: %08x\n", lres);
hres = HRESULT_FROM_WIN32(lres);
break;
}
break;
}
default:
WARN("Wrong resource type: %s\n", debugstr_w(buf->str));
hres = DISP_E_EXCEPTION;
};
if(FAILED(hres))
break;
}else {
if(*iter == '-')
iter++;
hres = get_word(&iter, buf);
if(FAILED(hres))
break;
}
}else if(key_type == IS_VAL) {
WARN("value not set!\n");
hres = DISP_E_EXCEPTION;
break;
}
if(key_type != IS_VAL && key_type != DO_DELETE && *iter == '{' && isspaceW(iter[1])) {
hres = get_word(&iter, buf);
if(FAILED(hres))
break;
hres = do_process_key(&iter, hkey, buf, do_register);
if(FAILED(hres))
break;
}
TRACE("%x %x\n", do_register, key_type);
if(!do_register && (key_type == NORMAL || key_type == FORCE_REMOVE)) {
TRACE("Deleting %s\n", debugstr_w(name.str));
RegDeleteKeyW(parent_key, name.str);
}
if(hkey && key_type != IS_VAL)
RegCloseKey(hkey);
hkey = 0;
name.len = 0;
hres = get_word(&iter, buf);
if(FAILED(hres))
break;
}
HeapFree(GetProcessHeap(), 0, name.str);
if(hkey && key_type != IS_VAL)
RegCloseKey(hkey);
*pstr = iter;
return hres;
}
DWORD
ScmWriteDependencies(HKEY hServiceKey,
LPCWSTR lpDependencies,
DWORD dwDependenciesLength)
{
DWORD dwError = ERROR_SUCCESS;
SIZE_T cchGroupLength = 0;
SIZE_T cchServiceLength = 0;
SIZE_T cchLength;
LPWSTR lpGroupDeps;
LPWSTR lpServiceDeps;
LPCWSTR lpSrc;
LPWSTR lpDst;
if (*lpDependencies == 0)
{
RegDeleteValueW(hServiceKey,
L"DependOnService");
RegDeleteValueW(hServiceKey,
L"DependOnGroup");
}
else
{
lpGroupDeps = HeapAlloc(GetProcessHeap(),
HEAP_ZERO_MEMORY,
(dwDependenciesLength + 2) * sizeof(WCHAR));
if (lpGroupDeps == NULL)
return ERROR_NOT_ENOUGH_MEMORY;
lpSrc = lpDependencies;
lpDst = lpGroupDeps;
while (*lpSrc != 0)
{
cchLength = wcslen(lpSrc) + 1;
if (*lpSrc == SC_GROUP_IDENTIFIERW)
{
lpSrc++;
cchLength--;
cchGroupLength += cchLength;
wcscpy(lpDst, lpSrc);
lpDst = lpDst + cchLength;
}
lpSrc = lpSrc + cchLength;
}
*lpDst = 0;
lpDst++;
cchGroupLength++;
lpSrc = lpDependencies;
lpServiceDeps = lpDst;
while (*lpSrc != 0)
{
cchLength = wcslen(lpSrc) + 1;
if (*lpSrc != SC_GROUP_IDENTIFIERW)
{
cchServiceLength += cchLength;
wcscpy(lpDst, lpSrc);
lpDst = lpDst + cchLength;
}
lpSrc = lpSrc + cchLength;
}
*lpDst = 0;
cchServiceLength++;
if (cchGroupLength > 1)
{
dwError = RegSetValueExW(hServiceKey,
L"DependOnGroup",
0,
REG_MULTI_SZ,
(LPBYTE)lpGroupDeps,
(DWORD)(cchGroupLength * sizeof(WCHAR)));
}
else
{
RegDeleteValueW(hServiceKey,
L"DependOnGroup");
}
if (dwError == ERROR_SUCCESS)
{
if (cchServiceLength > 1)
{
dwError = RegSetValueExW(hServiceKey,
L"DependOnService",
0,
REG_MULTI_SZ,
(LPBYTE)lpServiceDeps,
(DWORD)(cchServiceLength * sizeof(WCHAR)));
}
else
{
RegDeleteValueW(hServiceKey,
L"DependOnService");
}
}
HeapFree(GetProcessHeap(), 0, lpGroupDeps);
}
return dwError;
}
/* create the volatile hardware registry keys */
static void create_hardware_registry_keys(void)
{
static const WCHAR SystemW[] = {'H','a','r','d','w','a','r','e','\\',
'D','e','s','c','r','i','p','t','i','o','n','\\',
'S','y','s','t','e','m',0};
static const WCHAR fpuW[] = {'F','l','o','a','t','i','n','g','P','o','i','n','t','P','r','o','c','e','s','s','o','r',0};
static const WCHAR cpuW[] = {'C','e','n','t','r','a','l','P','r','o','c','e','s','s','o','r',0};
static const WCHAR FeatureSetW[] = {'F','e','a','t','u','r','e','S','e','t',0};
static const WCHAR IdentifierW[] = {'I','d','e','n','t','i','f','i','e','r',0};
static const WCHAR ProcessorNameStringW[] = {'P','r','o','c','e','s','s','o','r','N','a','m','e','S','t','r','i','n','g',0};
static const WCHAR SysidW[] = {'A','T',' ','c','o','m','p','a','t','i','b','l','e',0};
static const WCHAR mhzKeyW[] = {'~','M','H','z',0};
static const WCHAR VendorIdentifierW[] = {'V','e','n','d','o','r','I','d','e','n','t','i','f','i','e','r',0};
static const WCHAR VenidIntelW[] = {'G','e','n','u','i','n','e','I','n','t','e','l',0};
/* static const WCHAR VenidAMDW[] = {'A','u','t','h','e','n','t','i','c','A','M','D',0}; */
static const WCHAR PercentDW[] = {'%','d',0};
static const WCHAR IntelCpuDescrW[] = {'x','8','6',' ','F','a','m','i','l','y',' ','%','d',' ','M','o','d','e','l',' ','%','d',
' ','S','t','e','p','p','i','n','g',' ','%','d',0};
static const WCHAR IntelCpuStringW[] = {'I','n','t','e','l','(','R',')',' ','P','e','n','t','i','u','m','(','R',')',' ','4',' ',
'C','P','U',' ','2','.','4','0','G','H','z',0};
unsigned int i;
HKEY hkey, system_key, cpu_key, fpu_key;
SYSTEM_CPU_INFORMATION sci;
PROCESSOR_POWER_INFORMATION power_info;
WCHAR idW[60];
NtQuerySystemInformation( SystemCpuInformation, &sci, sizeof(sci), NULL );
if (NtPowerInformation(ProcessorInformation, NULL, 0, &power_info, sizeof(power_info)))
power_info.MaxMhz = 0;
/*TODO: report 64bit processors properly*/
sprintfW( idW, IntelCpuDescrW, sci.Level, HIBYTE(sci.Revision), LOBYTE(sci.Revision) );
if (RegCreateKeyExW( HKEY_LOCAL_MACHINE, SystemW, 0, NULL, REG_OPTION_VOLATILE,
KEY_ALL_ACCESS, NULL, &system_key, NULL ))
return;
set_reg_value( system_key, IdentifierW, SysidW );
if (RegCreateKeyExW( system_key, fpuW, 0, NULL, REG_OPTION_VOLATILE,
KEY_ALL_ACCESS, NULL, &fpu_key, NULL ))
fpu_key = 0;
if (RegCreateKeyExW( system_key, cpuW, 0, NULL, REG_OPTION_VOLATILE,
KEY_ALL_ACCESS, NULL, &cpu_key, NULL ))
cpu_key = 0;
for (i = 0; i < NtCurrentTeb()->Peb->NumberOfProcessors; i++)
{
WCHAR numW[10];
sprintfW( numW, PercentDW, i );
if (!RegCreateKeyExW( cpu_key, numW, 0, NULL, REG_OPTION_VOLATILE,
KEY_ALL_ACCESS, NULL, &hkey, NULL ))
{
RegSetValueExW( hkey, FeatureSetW, 0, REG_DWORD, (BYTE *)&sci.FeatureSet, sizeof(DWORD) );
set_reg_value( hkey, IdentifierW, idW );
/*TODO; report amd's properly*/
set_reg_value( hkey, ProcessorNameStringW, IntelCpuStringW );
set_reg_value( hkey, VendorIdentifierW, VenidIntelW );
RegSetValueExW( hkey, mhzKeyW, 0, REG_DWORD, (BYTE *)&power_info.MaxMhz, sizeof(DWORD) );
RegCloseKey( hkey );
}
if (!RegCreateKeyExW( fpu_key, numW, 0, NULL, REG_OPTION_VOLATILE,
KEY_ALL_ACCESS, NULL, &hkey, NULL ))
{
set_reg_value( hkey, IdentifierW, idW );
RegCloseKey( hkey );
}
}
RegCloseKey( fpu_key );
RegCloseKey( cpu_key );
RegCloseKey( system_key );
}
LONG
WINAPI
ComDBOpen(OUT HCOMDB *phComDB)
{
PCOMDB pComDB;
DWORD dwDisposition;
DWORD dwType;
DWORD dwSize;
PBYTE pBitmap;
LONG lError;
TRACE("ComDBOpen(%p)\n", phComDB);
/* Allocate a new database */
pComDB = HeapAlloc(GetProcessHeap(),
HEAP_ZERO_MEMORY,
sizeof(COMDB));
if (pComDB == NULL)
{
ERR("Failed to allocate the database!\n");
*phComDB = HCOMDB_INVALID_HANDLE_VALUE;
return ERROR_ACCESS_DENIED;
}
/* Create a mutex to protect the database */
pComDB->hMutex = CreateMutexW(NULL,
FALSE,
L"ComDBMutex");
if (pComDB->hMutex == NULL)
{
ERR("Failed to create the mutex!\n");
HeapFree(GetProcessHeap(), 0, pComDB);
*phComDB = HCOMDB_INVALID_HANDLE_VALUE;
return ERROR_ACCESS_DENIED;
}
/* Wait for the mutex */
WaitForSingleObject(pComDB->hMutex, INFINITE);
/* Create or open the database key */
lError = RegCreateKeyExW(HKEY_LOCAL_MACHINE,
L"System\\CurrentControlSet\\Control\\COM Name Arbiter",
0,
NULL,
0,
KEY_ALL_ACCESS,
NULL,
&pComDB->hKey,
&dwDisposition);
if (lError != ERROR_SUCCESS)
goto done;
/* Get the required bitmap size */
lError = RegQueryValueExW(pComDB->hKey,
L"ComDB",
NULL,
&dwType,
NULL,
&dwSize);
if (lError == ERROR_FILE_NOT_FOUND)
{
/* Allocate a new bitmap */
dwSize = COMDB_MIN_PORTS_ARBITRATED / BITS_PER_BYTE;
pBitmap = HeapAlloc(GetProcessHeap(),
HEAP_ZERO_MEMORY,
dwSize);
if (pBitmap == NULL)
{
ERR("Failed to allocate the bitmap!\n");
lError = ERROR_ACCESS_DENIED;
goto done;
}
/* Write the bitmap to the registry */
lError = RegSetValueExW(pComDB->hKey,
L"ComDB",
0,
REG_BINARY,
pBitmap,
dwSize);
HeapFree(GetProcessHeap(), 0, pBitmap);
}
done:;
/* Release the mutex */
ReleaseMutex(pComDB->hMutex);
if (lError != ERROR_SUCCESS)
{
/* Clean up in case of failure */
if (pComDB->hKey != NULL)
RegCloseKey(pComDB->hKey);
if (pComDB->hMutex != NULL)
CloseHandle(pComDB->hMutex);
HeapFree(GetProcessHeap(), 0, pComDB);
*phComDB = HCOMDB_INVALID_HANDLE_VALUE;
}
else
{
/* Return the database handle */
*phComDB = (HCOMDB)pComDB;
}
TRACE("done (Error %lu)\n", lError);
return lError;
}
/***********************************************************************
* register_interfaces
*/
static HRESULT register_interfaces(struct regsvr_interface const *list) {
LONG res = ERROR_SUCCESS;
HKEY interface_key;
res = RegCreateKeyExW(HKEY_CLASSES_ROOT, interface_keyname, 0, NULL, 0,
KEY_READ | KEY_WRITE, NULL, &interface_key, NULL);
if (res != ERROR_SUCCESS) goto error_return;
for (; res == ERROR_SUCCESS && list->iid; ++list) {
WCHAR buf[39];
HKEY iid_key;
StringFromGUID2(list->iid, buf, 39);
res = RegCreateKeyExW(interface_key, buf, 0, NULL, 0,
KEY_READ | KEY_WRITE, NULL, &iid_key, NULL);
if (res != ERROR_SUCCESS) goto error_close_interface_key;
if (list->name) {
res = RegSetValueExA(iid_key, NULL, 0, REG_SZ,
(CONST BYTE*)(list->name),
strlen(list->name) + 1);
if (res != ERROR_SUCCESS) goto error_close_iid_key;
}
if (list->base_iid) {
res = register_key_guid(iid_key, base_ifa_keyname, list->base_iid);
if (res != ERROR_SUCCESS) goto error_close_iid_key;
}
if (0 <= list->num_methods) {
static WCHAR const fmt[3] = { '%', 'd', 0 };
HKEY key;
res = RegCreateKeyExW(iid_key, num_methods_keyname, 0, NULL, 0,
KEY_READ | KEY_WRITE, NULL, &key, NULL);
if (res != ERROR_SUCCESS) goto error_close_iid_key;
wsprintfW(buf, fmt, list->num_methods);
res = RegSetValueExW(key, NULL, 0, REG_SZ,
(CONST BYTE*)buf,
(lstrlenW(buf) + 1) * sizeof(WCHAR));
RegCloseKey(key);
if (res != ERROR_SUCCESS) goto error_close_iid_key;
}
if (list->ps_clsid) {
res = register_key_guid(iid_key, ps_clsid_keyname, list->ps_clsid);
if (res != ERROR_SUCCESS) goto error_close_iid_key;
}
if (list->ps_clsid32) {
res = register_key_guid(iid_key, ps_clsid32_keyname, list->ps_clsid32);
if (res != ERROR_SUCCESS) goto error_close_iid_key;
}
error_close_iid_key:
RegCloseKey(iid_key);
}
error_close_interface_key:
RegCloseKey(interface_key);
error_return:
return res != ERROR_SUCCESS ? HRESULT_FROM_WIN32(res) : S_OK;
}
LONG
WINAPI
ComDBResizeDatabase(IN HCOMDB hComDB,
IN DWORD NewSize)
{
PCOMDB pComDB;
PBYTE pBitmap = NULL;
DWORD dwSize;
DWORD dwNewSize;
DWORD dwType;
LONG lError;
TRACE("ComDBResizeDatabase(%p %lu)\n", hComDB, NewSize);
if (hComDB == INVALID_HANDLE_VALUE ||
hComDB == NULL ||
(NewSize & BITMAP_SIZE_INVALID_BITS))
return ERROR_INVALID_PARAMETER;
pComDB = (PCOMDB)hComDB;
/* Wait for the mutex */
WaitForSingleObject(pComDB->hMutex, INFINITE);
/* Get the required bitmap size */
lError = RegQueryValueExW(pComDB->hKey,
L"ComDB",
NULL,
&dwType,
NULL,
&dwSize);
if (lError != ERROR_SUCCESS)
goto done;
/* Check the size limits */
if (NewSize > COMDB_MAX_PORTS_ARBITRATED ||
NewSize <= dwSize * BITS_PER_BYTE)
{
lError = ERROR_BAD_LENGTH;
goto done;
}
/* Calculate the new bitmap size */
dwNewSize = NewSize / BITS_PER_BYTE;
/* Allocate the new bitmap */
pBitmap = HeapAlloc(GetProcessHeap(),
HEAP_ZERO_MEMORY,
dwSize);
if (pBitmap == NULL)
{
ERR("Failed to allocate the bitmap!\n");
lError = ERROR_ACCESS_DENIED;
goto done;
}
/* Read the current bitmap */
lError = RegQueryValueExW(pComDB->hKey,
L"ComDB",
NULL,
&dwType,
pBitmap,
&dwSize);
if (lError != ERROR_SUCCESS)
goto done;
/* Write the new bitmap */
lError = RegSetValueExW(pComDB->hKey,
L"ComDB",
0,
REG_BINARY,
pBitmap,
dwNewSize);
done:;
/* Release the mutex */
ReleaseMutex(pComDB->hMutex);
if (pBitmap != NULL)
HeapFree(GetProcessHeap(), 0, pBitmap);
return lError;
}
static int reg_add(WCHAR *key_name, WCHAR *value_name, BOOL value_empty,
WCHAR *type, WCHAR separator, WCHAR *data, BOOL force)
{
static const WCHAR stubW[] = {'A','D','D',' ','-',' ','%','s',
' ','%','s',' ','%','d',' ','%','s',' ','%','s',' ','%','d','\n',0
};
LPWSTR p;
HKEY root,subkey;
reg_printfW(stubW, key_name, value_name, value_empty, type, data, force);
if (key_name[0]=='\\' && key_name[1]=='\\')
{
reg_message(STRING_NO_REMOTE);
return 1;
}
p = strchrW(key_name,'\\');
if (!p)
{
reg_message(STRING_INVALID_KEY);
return 1;
}
p++;
root = get_rootkey(key_name);
if (!root)
{
reg_message(STRING_INVALID_KEY);
return 1;
}
if(RegCreateKeyW(root,p,&subkey)!=ERROR_SUCCESS)
{
reg_message(STRING_INVALID_KEY);
return 1;
}
if (value_name || data)
{
DWORD reg_type;
DWORD reg_count = 0;
BYTE* reg_data = NULL;
if (!force)
{
if (RegQueryValueW(subkey,value_name,NULL,NULL)==ERROR_SUCCESS)
{
/* FIXME: Prompt for overwrite */
}
}
reg_type = get_regtype(type);
if (reg_type == -1)
{
RegCloseKey(subkey);
reg_message(STRING_INVALID_CMDLINE);
return 1;
}
if (data)
reg_data = get_regdata(data,reg_type,separator,®_count);
RegSetValueExW(subkey,value_name,0,reg_type,reg_data,reg_count);
HeapFree(GetProcessHeap(),0,reg_data);
}
RegCloseKey(subkey);
reg_message(STRING_SUCCESS);
return 0;
}
BOOLEAN
ConCfgWriteUserSettings(IN PCONSOLE_STATE_INFO ConsoleInfo,
IN BOOLEAN DefaultSettings)
{
HKEY hKey;
DWORD Storage = 0;
#define SetConsoleSetting(SettingName, SettingType, SettingSize, Setting, DefaultValue) \
do { \
if (DefaultSettings || (!DefaultSettings && (*(Setting) != (DefaultValue)))) \
{ \
RegSetValueExW(hKey, (SettingName), 0, (SettingType), (PBYTE)(Setting), (SettingSize)); \
} \
else \
{ \
RegDeleteValueW(hKey, (SettingName)); \
} \
} while (0)
WCHAR szValueName[15];
UINT i;
if (!ConCfgOpenUserSettings(DefaultSettings ? L"" : ConsoleInfo->ConsoleTitle,
&hKey, KEY_WRITE, TRUE))
{
return FALSE;
}
for (i = 0; i < ARRAYSIZE(ConsoleInfo->ColorTable); ++i)
{
/*
* Write only the new value if we are saving the global settings
* or we are saving settings for a particular console, which differs
* from the default ones.
*/
swprintf(szValueName, L"ColorTable%02u", i);
SetConsoleSetting(szValueName, REG_DWORD, sizeof(DWORD), &ConsoleInfo->ColorTable[i], s_Colors[i]);
}
SetConsoleSetting(L"FaceName", REG_SZ, (wcslen(ConsoleInfo->FaceName) + 1) * sizeof(WCHAR), ConsoleInfo->FaceName, UNICODE_NULL); // wcsnlen
SetConsoleSetting(L"FontFamily", REG_DWORD, sizeof(DWORD), &ConsoleInfo->FontFamily, FF_DONTCARE);
Storage = MAKELONG(ConsoleInfo->FontSize.X, ConsoleInfo->FontSize.Y); // Width, Height
SetConsoleSetting(L"FontSize", REG_DWORD, sizeof(DWORD), &Storage, 0);
SetConsoleSetting(L"FontWeight", REG_DWORD, sizeof(DWORD), &ConsoleInfo->FontWeight, FW_DONTCARE);
SetConsoleSetting(L"HistoryBufferSize", REG_DWORD, sizeof(DWORD), &ConsoleInfo->HistoryBufferSize, 50);
SetConsoleSetting(L"NumberOfHistoryBuffers", REG_DWORD, sizeof(DWORD), &ConsoleInfo->NumberOfHistoryBuffers, 4);
Storage = ConsoleInfo->HistoryNoDup;
SetConsoleSetting(L"HistoryNoDup", REG_DWORD, sizeof(DWORD), &Storage, FALSE);
Storage = ConsoleInfo->QuickEdit;
SetConsoleSetting(L"QuickEdit", REG_DWORD, sizeof(DWORD), &Storage, FALSE);
Storage = ConsoleInfo->InsertMode;
SetConsoleSetting(L"InsertMode", REG_DWORD, sizeof(DWORD), &Storage, TRUE);
Storage = MAKELONG(ConsoleInfo->ScreenBufferSize.X, ConsoleInfo->ScreenBufferSize.Y);
SetConsoleSetting(L"ScreenBufferSize", REG_DWORD, sizeof(DWORD), &Storage, MAKELONG(80, 300));
Storage = ConsoleInfo->FullScreen;
SetConsoleSetting(L"FullScreen", REG_DWORD, sizeof(DWORD), &Storage, FALSE);
if (ConsoleInfo->AutoPosition == FALSE)
{
Storage = MAKELONG(ConsoleInfo->WindowPosition.x, ConsoleInfo->WindowPosition.y);
RegSetValueExW(hKey, L"WindowPosition", 0, REG_DWORD, (PBYTE)&Storage, sizeof(DWORD));
}
else
{
RegDeleteValueW(hKey, L"WindowPosition");
}
Storage = MAKELONG(ConsoleInfo->WindowSize.X, ConsoleInfo->WindowSize.Y);
SetConsoleSetting(L"WindowSize", REG_DWORD, sizeof(DWORD), &Storage, MAKELONG(80, 25));
SetConsoleSetting(L"CursorSize", REG_DWORD, sizeof(DWORD), &ConsoleInfo->CursorSize, CSR_DEFAULT_CURSOR_SIZE);
Storage = ConsoleInfo->ScreenAttributes;
SetConsoleSetting(L"ScreenColors", REG_DWORD, sizeof(DWORD), &Storage, DEFAULT_SCREEN_ATTRIB);
Storage = ConsoleInfo->PopupAttributes;
SetConsoleSetting(L"PopupColors", REG_DWORD, sizeof(DWORD), &Storage, DEFAULT_POPUP_ATTRIB);
RegCloseKey(hKey);
return TRUE;
}
/**
* Adds a string entry to a MULTI_SZ registry list.
*
* @return Exit code (EXIT_OK, EXIT_FAIL)
* @param pszSubKey Sub key containing the list.
* @param pszKeyValue The actual key name of the list.
* @param pszValueToRemove The value to add to the list.
* @param uiOrder Position (zero-based) of where to add the value to the list.
*/
int RegistryAddStringToMultiSZ(const TCHAR *pszSubKey, const TCHAR *pszKeyValue, const TCHAR *pszValueToAdd, unsigned int uiOrder)
{
#ifdef DEBUG
_tprintf(_T("AddStringToMultiSZ: Adding MULTI_SZ string %ws to %ws\\%ws (Order = %d)\n"), pszValueToAdd, pszSubKey, pszKeyValue, uiOrder);
#endif
HKEY hKey = NULL;
DWORD disp, dwType;
LONG lRet = RegCreateKeyEx(HKEY_LOCAL_MACHINE, pszSubKey, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_READ | KEY_WRITE, NULL, &hKey, &disp);
if (lRet != ERROR_SUCCESS)
_tprintf(_T("AddStringToMultiSZ: RegCreateKeyEx %ts failed with error %ld!\n"), pszSubKey, lRet);
if (lRet == ERROR_SUCCESS)
{
TCHAR szKeyValue[512] = { 0 };
TCHAR szNewKeyValue[512] = { 0 };
DWORD cbKeyValue = sizeof(szKeyValue);
lRet = RegQueryValueEx(hKey, pszKeyValue, NULL, &dwType, (LPBYTE)szKeyValue, &cbKeyValue);
if ( lRet != ERROR_SUCCESS
|| dwType != REG_MULTI_SZ)
{
_tprintf(_T("AddStringToMultiSZ: RegQueryValueEx failed with error %ld, key type = 0x%x!\n"), lRet, dwType);
}
else
{
/* Look if the network provider is already in the list. */
unsigned int iPos = 0;
size_t cb = 0;
/* Replace delimiting "\0"'s with "," to make tokenizing work. */
for (unsigned i = 0; i < cbKeyValue / sizeof(TCHAR); i++)
if (szKeyValue[i] == '\0') szKeyValue[i] = ',';
TCHAR *pszToken = wcstok(szKeyValue, _T(","));
TCHAR *pszNewToken = NULL;
TCHAR *pNewKeyValuePos = szNewKeyValue;
while (pszToken != NULL)
{
pszNewToken = wcstok(NULL, _T(","));
/* Append new value (at beginning if iOrder=0). */
if (iPos == uiOrder)
{
memcpy(pNewKeyValuePos, pszValueToAdd, wcslen(pszValueToAdd)*sizeof(TCHAR));
cb += (wcslen(pszValueToAdd) + 1) * sizeof(TCHAR); /* Add trailing zero as well. */
pNewKeyValuePos += wcslen(pszValueToAdd) + 1;
iPos++;
}
if (0 != wcsicmp(pszToken, pszValueToAdd))
{
memcpy(pNewKeyValuePos, pszToken, wcslen(pszToken)*sizeof(TCHAR));
cb += (wcslen(pszToken) + 1) * sizeof(TCHAR); /* Add trailing zero as well. */
pNewKeyValuePos += wcslen(pszToken) + 1;
iPos++;
}
pszToken = pszNewToken;
}
/* Append as last item if needed. */
if (uiOrder >= iPos)
{
memcpy(pNewKeyValuePos, pszValueToAdd, wcslen(pszValueToAdd)*sizeof(TCHAR));
cb += wcslen(pszValueToAdd) * sizeof(TCHAR); /* Add trailing zero as well. */
}
lRet = RegSetValueExW(hKey, pszKeyValue, 0, REG_MULTI_SZ, (LPBYTE)szNewKeyValue, (DWORD)cb);
if (lRet != ERROR_SUCCESS)
_tprintf(_T("AddStringToMultiSZ: RegSetValueEx failed with error %ld!\n"), lRet);
}
RegCloseKey(hKey);
#ifdef DEBUG
if (lRet == ERROR_SUCCESS)
_tprintf(_T("AddStringToMultiSZ: Value %ws successfully written!\n"), pszValueToAdd);
#endif
}
return (lRet == ERROR_SUCCESS) ? EXIT_OK : EXIT_FAIL;
}
INT WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, char *lpCmdLine, int cmdShow)
{
HKEY hKey;
long ret;
LPTSTR pszMessage;
DWORD dwLastError;
DWORD val=0,valSize,valType;
DWORD dwStart=3;
ret=RegOpenKeyExW(HKEY_LOCAL_MACHINE,USB_KEY,0,KEY_ALL_ACCESS,&hKey);
if(ret == ERROR_SUCCESS)
{
valSize=sizeof(val);
ret = RegQueryValueExW(hKey,START_KEY,0,&valType,(LPBYTE)&val,&valSize);
if(ret == ERROR_SUCCESS)
{
if(val == 3)
{
dwStart=4;
}
else
{
dwStart=3;
}
ret = RegSetValueExW(hKey,START_KEY,0,REG_DWORD,(LPBYTE)&dwStart,valSize);
if(ret == ERROR_SUCCESS)
{
if(dwStart == 4)
MessageBoxW(0,L"USB lock Success!",L"Message",MB_OK);
else
MessageBoxW(0,L"USB Unlock Success!",L"Message",MB_OK);
}
}
RegCloseKey(hKey);
}
else
{
dwLastError = GetLastError();
FormatMessage(
FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_IGNORE_INSERTS,
NULL,
dwLastError,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPTSTR)&pszMessage,
0, NULL );
MessageBoxW(0,pszMessage,L"Error",MB_OK);
}
return 1;
}
/***************************************************************
* DMORegister (MSDMO.@)
*
* Register a DirectX Media Object.
*/
HRESULT WINAPI DMORegister(
LPCWSTR szName,
REFCLSID clsidDMO,
REFGUID guidCategory,
DWORD dwFlags,
DWORD cInTypes,
const DMO_PARTIAL_MEDIATYPE *pInTypes,
DWORD cOutTypes,
const DMO_PARTIAL_MEDIATYPE *pOutTypes
)
{
WCHAR szguid[64];
HRESULT hres;
HKEY hrkey = 0;
HKEY hkey = 0;
HKEY hckey = 0;
HKEY hclskey = 0;
LONG ret;
TRACE("%s %s %s\n", debugstr_w(szName), debugstr_guid(clsidDMO), debugstr_guid(guidCategory));
if (IsEqualGUID(guidCategory, &GUID_NULL))
return E_INVALIDARG;
ret = RegCreateKeyExW(HKEY_CLASSES_ROOT, szDMORootKey, 0, NULL,
REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hrkey, NULL);
if (ret)
return HRESULT_FROM_WIN32(ret);
/* Create clsidDMO key under MediaObjects */
ret = RegCreateKeyExW(hrkey, GUIDToString(szguid, clsidDMO), 0, NULL,
REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hkey, NULL);
if (ret)
goto lend;
/* Set default Name value */
ret = RegSetValueExW(hkey, NULL, 0, REG_SZ, (const BYTE*) szName,
(strlenW(szName) + 1) * sizeof(WCHAR));
/* Set InputTypes */
hres = write_types(hkey, szDMOInputType, pInTypes, cInTypes);
/* Set OutputTypes */
hres = write_types(hkey, szDMOOutputType, pOutTypes, cOutTypes);
if (dwFlags & DMO_REGISTERF_IS_KEYED)
{
/* Create Keyed key */
ret = RegCreateKeyExW(hkey, szDMOKeyed, 0, NULL,
REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hckey, NULL);
if (ret)
goto lend;
RegCloseKey(hckey);
}
/* Register the category */
ret = RegCreateKeyExW(hrkey, szDMOCategories, 0, NULL,
REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hckey, NULL);
if (ret)
goto lend;
RegCloseKey(hkey);
ret = RegCreateKeyExW(hckey, GUIDToString(szguid, guidCategory), 0, NULL,
REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hkey, NULL);
if (ret)
goto lend;
ret = RegCreateKeyExW(hkey, GUIDToString(szguid, clsidDMO), 0, NULL,
REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hclskey, NULL);
if (ret)
goto lend;
lend:
if (hkey)
RegCloseKey(hkey);
if (hckey)
RegCloseKey(hckey);
if (hclskey)
RegCloseKey(hclskey);
if (hrkey)
RegCloseKey(hrkey);
hres = HRESULT_FROM_WIN32(ret);
TRACE(" hresult=0x%08x\n", hres);
return hres;
}