/************************************************************************* * 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; }