static enum install_res install_from_registered_dir(void) { char *package_dir; HKEY hkey; DWORD res, type, size = MAX_PATH; enum install_res ret; hkey = open_config_key(); if(!hkey) return INSTALL_NEXT; package_dir = heap_alloc(size); res = RegGetValueA(hkey, NULL, addon->dir_config_key, RRF_RT_ANY, &type, (PBYTE)package_dir, &size); if(res == ERROR_MORE_DATA) { package_dir = heap_realloc(package_dir, size); res = RegGetValueA(hkey, NULL, addon->dir_config_key, RRF_RT_ANY, &type, (PBYTE)package_dir, &size); } RegCloseKey(hkey); if(res == ERROR_FILE_NOT_FOUND) { heap_free(package_dir); return INSTALL_NEXT; } else if(res != ERROR_SUCCESS || (type != REG_SZ && type != REG_EXPAND_SZ)) { heap_free(package_dir); return INSTALL_FAILED; } TRACE("Trying %s/%s\n", debugstr_a(package_dir), debugstr_a(addon->file_name)); ret = install_from_unix_file(package_dir, "", addon->file_name); heap_free(package_dir); return ret; }
void DebugCheckState(void) { #ifdef __WINDOWS__ char buf[1024]; DWORD size = sizeof(buf); LSTATUS err = RegGetValueA(HKEY_LOCAL_MACHINE, "SOFTWARE\\Silicondust\\HDHomeRun", "DebugFilename", RRF_RT_REG_SZ, NULL, (PVOID) buf, &size); if (err != 0) { buf[0] = '\0'; } DebugFilename = buf; size = sizeof(DebugExpireTime); err = RegGetValueA(HKEY_LOCAL_MACHINE, "SOFTWARE\\Silicondust\\HDHomeRun", "DebugEnabled", RRF_RT_REG_QWORD, NULL, (PVOID) & DebugExpireTime, &size); if (err != 0) { DebugExpireTime = 0; } #endif if (DebugFilename.empty()) { hdhomerun_debug_set_filename(dbg, NULL); } else { hdhomerun_debug_set_filename(dbg, DebugFilename.c_str()); } if (DebugExpireTime > (unsigned long long)time(NULL)) { hdhomerun_debug_enable(dbg); } else { hdhomerun_debug_disable(dbg); } }
static enum install_res install_from_registered_dir(void) { char *package_dir; DWORD res, type, size = MAX_PATH; enum install_res ret; package_dir = heap_alloc(size + sizeof(addon->file_name)); res = RegGetValueA(HKEY_CURRENT_USER, mshtml_keyA, "GeckoCabDir", RRF_RT_ANY, &type, (PBYTE)package_dir, &size); if(res == ERROR_MORE_DATA) { package_dir = heap_realloc(package_dir, size + sizeof(addon->file_name)); res = RegGetValueA(HKEY_CURRENT_USER, mshtml_keyA, "GeckoCabDir", RRF_RT_ANY, &type, (PBYTE)package_dir, &size); } if(res != ERROR_SUCCESS || (type != REG_SZ && type != REG_EXPAND_SZ)) { heap_free(package_dir); return INSTALL_FAILED; } TRACE("Trying %s/%s\n", debugstr_a(package_dir), debugstr_a(addon->file_name)); ret = install_from_unix_file(package_dir, "", addon->file_name); heap_free(package_dir); return ret; }
static BOOL install_from_registered_dir(void) { char *file_name; HKEY hkey; DWORD res, type, size = MAX_PATH; BOOL ret; /* @@ Wine registry key: HKCU\Software\Wine\MSHTML */ res = RegOpenKeyW(HKEY_CURRENT_USER, mshtml_keyW, &hkey); if(res != ERROR_SUCCESS) return FALSE; file_name = heap_alloc(size+sizeof(GECKO_FILE_NAME)); res = RegGetValueA(hkey, NULL, "GeckoCabDir", RRF_RT_ANY, &type, (PBYTE)file_name, &size); if(res == ERROR_MORE_DATA) { file_name = heap_realloc(file_name, size+sizeof(GECKO_FILE_NAME)); res = RegGetValueA(hkey, NULL, "GeckoCabDir", RRF_RT_ANY, &type, (PBYTE)file_name, &size); } RegCloseKey(hkey); if(res != ERROR_SUCCESS || (type != REG_SZ && type != REG_EXPAND_SZ)) { heap_free(file_name); return FALSE; } strcat(file_name, GECKO_FILE_NAME); TRACE("Trying %s\n", debugstr_a(file_name)); ret = install_from_unix_file(file_name); heap_free(file_name); return ret; }
// Read a Registry Key Value into a specified memory buffer static eEsifError DataVault_ReadRegistry ( DataVaultPtr self, esif_string keyname, void * *buffer, UInt32 *buf_size ) { eEsifError rc = ESIF_E_UNSPECIFIED; HKEY hKey = 0; DWORD dwFlags = RRF_RT_ANY; DWORD dwError = 0; DWORD dwSize = 0; char *regkey = 0; char *valuename = 0; u32 j; UNREFERENCED_PARAMETER(self); // Format: HKLM\Subkey\Path\ValueName for (j = 0; HKeyList[j].name; j++) { size_t namelen = esif_ccb_strlen(HKeyList[j].name, 30); if (esif_ccb_strnicmp(HKeyList[j].name, keyname, namelen) == 0 && keyname[namelen] == '\\') { hKey = HKeyList[j].hkey; keyname += esif_ccb_strlen(HKeyList[j].name, 30) + 1; break; } } if (!hKey) { return rc; } regkey = esif_ccb_strdup(keyname); if ((valuename = strrchr(regkey, '\\')) == 0) { esif_ccb_free(regkey); return rc; } *valuename++ = 0; // Get Data Size from Registry and copy into buffer if found if ((dwError = RegGetValueA(hKey, regkey, valuename, dwFlags, NULL, 0, &dwSize)) == 0) { void *reg_buf = esif_ccb_malloc(dwSize); dwError = RegGetValueA(hKey, regkey, valuename, dwFlags, NULL, reg_buf, &dwSize); if (dwError == 0) { *buffer = reg_buf; *buf_size = dwSize; rc = ESIF_OK; } else { esif_ccb_free(reg_buf); } } else { rc = ESIF_E_NOT_FOUND; } esif_ccb_free(regkey); return rc; }
DWORD VmAfWinCfgReadDWORDValue( PVMAF_CFG_KEY pKey, PCSTR pszSubkey, PCSTR pszName, PDWORD pdwValue ) { DWORD dwError = 0; DWORD dwValue = 0; DWORD dwValueSize = sizeof(dwValue); dwError = RegGetValueA( pKey->hKey, pszSubkey, pszName, RRF_RT_REG_DWORD, NULL, (PVOID)&dwValue, &dwValueSize); BAIL_ON_VMAFD_ERROR_NO_LOG(dwError); *pdwValue = dwValue; cleanup: return dwError; error: *pdwValue = 0; goto cleanup; }
BOOL hijack_key(std::string subKey, std::string proxy_path) { std::string commandKey = subKey + "\\shell\\open\\command"; HKEY hHijackedKey = NULL; size_t changed = 0; if (RegOpenKeyExA(HKEY_USERS, commandKey.c_str(), 0, KEY_READ | KEY_WRITE, &hHijackedKey) != ERROR_SUCCESS) { return FALSE; } char path_buffer[MAX_KEY_LENGTH]; DWORD val_len = MAX_KEY_LENGTH; DWORD type; RegGetValueA(hHijackedKey, NULL, 0, REG_SZ, &type, path_buffer, &val_len); printf("[W]%s\n", path_buffer); if (strstr(path_buffer, proxy_path.c_str()) != NULL) { printf("Already hijacked!\n"); RegCloseKey(hHijackedKey); return TRUE; } std::string hijacked = proxy_path + " " + std::string(path_buffer); printf("[H]%s\n\n", hijacked.c_str()); if (RegSetValueExA(hHijackedKey, NULL, 0, REG_SZ, (const BYTE*) hijacked.c_str(), hijacked.length()) != ERROR_SUCCESS) { RegCloseKey(hHijackedKey); return FALSE; } return TRUE; }
DWORD VmDirRegConfigGetValue( PVMDIR_CONFIG_CONNECTION_HANDLE pCfgHandle, PCSTR pszSubKey, PCSTR pszKeyName, DWORD valueType, PBYTE pRetValue, PDWORD pRetValueLen ) { DWORD dwError = 0; dwError = RegGetValueA( #ifndef _WIN32 pCfgHandle->hConnection, #endif pCfgHandle->hKey, pszSubKey, pszKeyName, valueType, NULL, (PVOID) pRetValue, pRetValueLen); BAIL_ON_VMDIR_ERROR_NO_LINE(dwError); error: if (dwError) { *pRetValueLen = 0; } return dwError; }
const std::string& getZusi3Datenpfad() { if (zusi3Datenpfad.empty()) { HKEY key; char buffer[MAX_PATH]; DWORD len = MAX_PATH; if (SUCCEEDED(RegOpenKeyEx(HKEY_LOCAL_MACHINE, L"Software\\Zusi3", 0, KEY_READ | KEY_WOW64_32KEY, &key)) && SUCCEEDED(RegGetValueA(key, nullptr, "DatenVerzeichnis", RRF_RT_REG_SZ, nullptr, (LPBYTE)buffer, &len))) { zusi3Datenpfad = string(buffer, len - 1); // subtract terminating null character RegCloseKey(key); } } return zusi3Datenpfad; }
std::string getValueString(HKEY baseKey, std::string subKey) { HKEY commandKey = NULL; if (RegOpenKeyExA(baseKey, subKey.c_str(), 0, KEY_READ, &commandKey) != ERROR_SUCCESS) { return ""; } char path_buffer[MAX_KEY_LENGTH]; DWORD val_len = MAX_KEY_LENGTH; DWORD type; RegGetValueA(commandKey, NULL, 0, REG_SZ, &type, path_buffer, &val_len); RegCloseKey(commandKey); if (type != REG_SZ) return ""; if (val_len == 0) return ""; return path_buffer; }
bool read_key(HKEY srcBaseKey, std::string subKey, OUT BYTE *path_buffer, OUT DWORD &val_len, OUT DWORD &type) { HKEY commandKey = NULL; if (RegOpenKeyExA(srcBaseKey, subKey.c_str(), 0, KEY_READ, &commandKey) != ERROR_SUCCESS) { return false; } RegGetValueA(commandKey, NULL, 0, RRF_RT_ANY, &type, path_buffer, &val_len); if (val_len == 0) { RegCloseKey(commandKey); return false; } RegCloseKey(commandKey); return true; }
static DWORD VmDirRegConfigGetMultiString( PVMDIR_CONFIG_CONNECTION_HANDLE pCfgHandle, PCSTR pszSubKey, PCSTR pszKeyName, PSTR *ppszValue ) { DWORD dwError = 0; char szValue[VMDIR_MAX_CONFIG_VALUE_LENGTH] = {0}; DWORD dwszValueSize = sizeof(szValue); PSTR pszValue = NULL; dwError = RegGetValueA( #ifndef _WIN32 pCfgHandle->hConnection, #endif pCfgHandle->hKey, pszSubKey, pszKeyName, RRF_RT_REG_MULTI_SZ, NULL, szValue, &dwszValueSize); BAIL_ON_VMDIR_ERROR(dwError); dwError = VmDirAllocateMemory(dwszValueSize, (PVOID)&pszValue); BAIL_ON_VMDIR_ERROR(dwError); dwError = VmDirCopyMemory(pszValue, dwszValueSize, szValue, dwszValueSize); BAIL_ON_VMDIR_ERROR(dwError); *ppszValue = pszValue; cleanup: return dwError; error: *ppszValue = NULL; VMDIR_SAFE_FREE_MEMORY(pszValue); goto cleanup; }
DWORD VmAfWinCfgReadStringValue( PVMAF_CFG_KEY pKey, PCSTR pszSubkey, PCSTR pszName, PSTR* ppszValue ) { DWORD dwError = 0; CHAR szValue[VMAF_MAX_CONFIG_VALUE_BYTE_LENGTH] = {0}; DWORD dwszValueSize = sizeof(szValue); PSTR pszValue = NULL; dwError = RegGetValueA( pKey->hKey, pszSubkey, pszName, RRF_RT_REG_SZ, NULL, szValue, &dwszValueSize); BAIL_ON_VMAFD_ERROR_NO_LOG(dwError); dwError = VmAfdAllocateStringA(szValue, &pszValue); BAIL_ON_VMAFD_ERROR(dwError); *ppszValue = pszValue; cleanup: return dwError; error: *ppszValue = NULL; if (pszValue) { VmAfdFreeStringA(pszValue); } goto cleanup; }
static DWORD VmAuthsvcRegConfigGetString( PVMAUTHSVC_CONFIG_CONNECTION_HANDLE pCfgHandle, PCSTR pszSubKey, PCSTR pszKeyName, PSTR *ppszValue) { DWORD dwError = 0; char szValue[VMAUTHSVC_MAX_CONFIG_VALUE_LENGTH] = {0}; DWORD dwszValueSize = sizeof(szValue); PSTR pszValue = NULL; dwError = RegGetValueA( pCfgHandle->hConnection, pCfgHandle->hKey, pszSubKey, pszKeyName, RRF_RT_REG_SZ, NULL, szValue, &dwszValueSize); BAIL_ON_VMAUTHSVC_ERROR(dwError); dwError = VmAuthsvcAllocateStringA(szValue, &pszValue); BAIL_ON_VMAUTHSVC_ERROR(dwError); *ppszValue = pszValue; cleanup: return dwError; error: *ppszValue = NULL; VMAUTHSVC_SAFE_FREE_STRINGA(pszValue); goto cleanup; }
// Return empty string if registry value was not found. // WARNING - Do not use this function for values larger that 2048. //////////////////////////////////////////////////////////////////////////////////////////////// std::string RetrieveRegistryStringValue( const HKEY in_hkey, const std::string &in_Key ) { std::string tempString = ""; DWORD pdwType; char pvData[MAX_VALUE_NAME]; DWORD pcbData = MAX_VALUE_NAME; LSTATUS errorStatus = RegGetValueA( in_hkey, // A handle to an open registry key NULL, // subkey of the key specified by the hkey parameter. in_Key.c_str(), // The name of the registry value. RRF_RT_REG_SZ, // Flags that restrict the data type of value to be queried. RRF_RT_REG_SZ only strings. &pdwType, // A pointer to a variable that receives a code indicating the type of data stored pvData, // A pointer to a buffer that receives the value's data. &pcbData ); // A pointer to a variable that specifies the size of the buffer pointed to by the pvData if ( errorStatus == ERROR_SUCCESS ) tempString = (char *) pvData; return tempString; }
static DWORD VmDirRegConfigGetDword( PVMDIR_CONFIG_CONNECTION_HANDLE pCfgHandle, PCSTR pszSubKey, PCSTR pszKeyName, PDWORD pdwValue ) { DWORD dwError =0; DWORD dwValue = 0; DWORD dwValueSize = sizeof(dwValue); dwError = RegGetValueA( #ifndef _WIN32 pCfgHandle->hConnection, #endif pCfgHandle->hKey, pszSubKey, pszKeyName, RRF_RT_REG_DWORD, NULL, (PVOID)&dwValue, &dwValueSize); BAIL_ON_VMDIR_ERROR(dwError); *pdwValue = dwValue; cleanup: return dwError; error: *pdwValue = 0; goto cleanup; }
void load_settings() { HKEY hkey; RegOpenKeyEx(HKEY_CURRENT_USER, L"SOFTWARE\\auto-screengrab", 0, KEY_QUERY_VALUE, &hkey); DWORD sz = 128; RegGetValueA(hkey, NULL, "smtp_url", RRF_RT_REG_SZ, NULL, &g_smtpURL, &sz); sz = 128; RegGetValueA(hkey, NULL, "smtp_user", RRF_RT_REG_SZ, NULL, &g_smtpUser, &sz); sz = 128; RegGetValueA(hkey, NULL, "smtp_pass", RRF_RT_REG_SZ, NULL, &g_smtpPass, &sz); sz = 128; RegGetValueA(hkey, NULL, "smtp_from", RRF_RT_REG_SZ, NULL, &g_smtpFrom, &sz); sz = 128; RegGetValueA(hkey, NULL, "smtp_to", RRF_RT_REG_SZ, NULL, &g_smtpTo, &sz); sz = 128; RegGetValueA(hkey, NULL, "smtp_url", RRF_RT_REG_SZ, NULL, &g_smtpURL, &sz); RegCloseKey(hkey); }
int registry_walker(HKEY hkey, const char * section, struct a6o_conf * conf){ int ret = 0; HKEY hSubKey = NULL; char * subkey_name = NULL; int subkey_maxlen = 0; int subkey_len = 0; char * class = NULL; char * value_name = NULL; int value_len = 0; int value_maxlen = 0; int value_type =0; int data_len = 0; char * data_str = NULL; int data_int = 0; char ** data_list = NULL; char * tmp = NULL; int list_len = 0; int class_len = 0; int class_maxlen = 0; int res = 0; int nb_index = 0, i =0,j=0; int nbvalues = 0; struct conf_reg_data data = {0}; if (hkey == NULL) { printf("[-] Error :: registry_walker :: invalid parameter!\n"); return -1; } __try { res = RegQueryInfoKeyA(hkey, NULL, &class_len, NULL, &nb_index, &subkey_maxlen, &class_maxlen, &nbvalues, &value_maxlen, NULL,NULL,NULL); if (res != ERROR_SUCCESS) { printf("[-] Error :: RegEnumKeyExA failed! :: GLE= %d\n", res); ret = -3; __leave; } //printf("[+] Debug :: nbindex = %d :: nbvalues = %d\n",nb_index,nbvalues); //printf("[+] Debug :: subkey_maxlen = %d :: index = %d :: class_maxlen = %d :: nbvalues = %d\n",subkey_maxlen ,nb_index, class_maxlen, nbvalues); value_maxlen++; value_name = (char *)calloc(value_maxlen + 1, sizeof(char)); // Get values. for (i = 0; i < nbvalues; i++) { value_len = value_maxlen; if ((res = RegEnumValueA(hkey, i, value_name, &value_len, NULL, &value_type, NULL, &data_len)) != ERROR_SUCCESS) { printf("[-] Error :: RegEnumValueA failed! :: GLE= %d\n", res); ret = -3; __leave; } // get data. switch (value_type) { case REG_DWORD: if ((res = RegGetValueA(hkey,NULL,value_name,RRF_RT_ANY, NULL, &data_int,&data_len)) != ERROR_SUCCESS ) { printf("[-] Error :: RegEnumValueA failed! :: GLE= %d\n", res); break; } //printf("[+] Debug :: value_name = %s :: value_type = %d :: data_len = %d :: data_int = %d\n",value_name,value_type,data_len,data_int ); //printf("[+] Debug :: (%s) => %d\n",value_name,data_int ); // add value to conf struct if (section != NULL) a6o_conf_add_uint(conf, section, value_name, data_int); break; case REG_SZ: //printf("[+] Debug :: value_name = %s :: value_type = %d :: data_len = %d\n",value_name,value_type,data_len ); data_str = (char *)calloc(data_len + 1, sizeof(char)); if ((res = RegGetValueA(hkey,NULL,value_name,RRF_RT_ANY, NULL,data_str,&data_len)) != ERROR_SUCCESS ) { printf("[-] Error :: RegEnumValueA failed! :: GLE= %d\n", res); break; } //printf("[+] Debug :: (%s) => %s\n",value_name,data_str); if (section != NULL) a6o_conf_add_string(conf, section, value_name, data_str); break; case REG_MULTI_SZ: //data_string //printf("[+] Debug :: value_name = %s :: value_type = %d :: data_len = %d\n",value_name,value_type,data_len ); data_str = (char *)calloc(data_len + 1, sizeof(char)); if ((res = RegGetValueA(hkey,NULL,value_name,RRF_RT_ANY, NULL,data_str,&data_len)) != ERROR_SUCCESS ) { printf("[-] Error :: RegEnumValueA failed! :: GLE= %d\n", res); break; } //printf("[+] Debug :: [%s] => %s\n",value_name,data_str); //printf("[+] Debug :: (%s) =>\n",value_name); list_len = 0; tmp = data_str; for (; *tmp != '\0'; tmp += strnlen(tmp,MAX_PATH)+1) { //printf("\t\tvalue = %s\n",tmp); list_len++; } ///printf("\n"); data_list = (char**)calloc(list_len, sizeof(char*)); tmp = data_str; j = 0; //printf("list_len = %d\n",list_len); for (; *tmp != '\0'; tmp += strnlen(tmp, MAX_PATH) + 1) { data_list[j] = (char*)calloc(strnlen(tmp, MAX_PATH) + 1,sizeof(char)); memcpy(data_list[j],tmp,strnlen(tmp, MAX_PATH) + 1); //printf("\tvalue = %s\n",data_list[j]); j++; } if (section != NULL) a6o_conf_add_list(conf, section, value_name, data_list, list_len); if (data_list != NULL) { for (j = 0; j < list_len; j++) { free(data_list[j]); data_list[j] = NULL; } free(data_list); data_list = NULL; } if (data_str != NULL) { free(data_str); data_str = NULL; } break; default: //printf("[+] Debug :: value_name = %s :: value_type = %d :: data_len = %d\n",value_name,value_type,data_len ); break; } } // Get subkeys subkey_maxlen++; // add null terminating character. subkey_name = (char *)calloc(subkey_maxlen + 1, sizeof(char)); for (i = 0; i < nb_index; i++) { subkey_len = subkey_maxlen; res = RegEnumKeyExA(hkey, i, subkey_name, &subkey_len, NULL, NULL, NULL, NULL); if (res != ERROR_SUCCESS) { printf("[-] Error :: RegEnumKeyExA failed! :: GLE= %d\n", res); ret = -3; __leave; } printf("[+] Debug :: section = [%s]\n",subkey_name); //printf("[+] Debug :: sub_key_name = [%s] :: sub_key_len = %d :: class_len = %d\n",subkey_name, subkey_len,class_len); if ((res = RegOpenKeyA(hkey,subkey_name, &hSubKey)) != ERROR_SUCCESS) { printf("[-] Error :: RegOpenKeyA failed! :: GLE= %d\n", res); ret = -2; __leave; } registry_walker(hSubKey,subkey_name,conf); //printf("\n\n"); } } __finally { if (subkey_name != NULL) { free(subkey_name); subkey_name = NULL; } if (value_name != NULL) { free(value_name); value_name = NULL; } if (hSubKey != NULL) { RegCloseKey(hSubKey); hSubKey = NULL; } if (data_str != NULL) { free(data_str); data_str = NULL; } if (data_list != NULL) { for (j = 0; j < list_len; j++) { free(data_list[j]); data_list[j] = NULL; } free(data_list); data_list = NULL; } } return ret; }
DWORD EVTReadConfigDword( PEVT_CONFIG_REG pReg, PCSTR pszName, BOOLEAN bUsePolicy, DWORD dwMin, DWORD dwMax, PDWORD pdwValue ) { DWORD dwError = 0; BOOLEAN bGotValue = FALSE; DWORD dwValue; DWORD dwSize; DWORD dwType; if (bUsePolicy) { dwSize = sizeof(dwValue); dwError = RegGetValueA( pReg->hConnection, pReg->hKey, pReg->pszPolicyKey, pszName, RRF_RT_REG_DWORD, &dwType, (PBYTE)&dwValue, &dwSize); if (!dwError) { bGotValue = TRUE; } } if (!bGotValue) { dwSize = sizeof(dwValue); dwError = RegGetValueA( pReg->hConnection, pReg->hKey, pReg->pszConfigKey, pszName, RRF_RT_REG_DWORD, &dwType, (PBYTE)&dwValue, &dwSize); if (!dwError) { bGotValue = TRUE; } } if (bGotValue) { if ( dwMin <= dwValue && dwValue <= dwMax) *pdwValue = dwValue; } dwError = 0; return dwError; }
DWORD EVTReadConfigString( PEVT_CONFIG_REG pReg, PCSTR pszName, BOOLEAN bUsePolicy, PSTR *ppszValue ) { DWORD dwError = 0; BOOLEAN bGotValue = FALSE; PSTR pszValue = NULL; char szValue[MAX_VALUE_LENGTH]; DWORD dwType; DWORD dwSize; if ( bUsePolicy ) { dwSize = sizeof(szValue); memset(szValue, 0, dwSize); dwError = RegGetValueA( pReg->hConnection, pReg->hKey, pReg->pszPolicyKey, pszName, RRF_RT_REG_SZ, &dwType, szValue, &dwSize); if (!dwError) bGotValue = TRUE; } if (!bGotValue ) { dwSize = sizeof(szValue); memset(szValue, 0, dwSize); dwError = RegGetValueA( pReg->hConnection, pReg->hKey, pReg->pszConfigKey, pszName, RRF_RT_REG_SZ, &dwType, szValue, &dwSize); if (!dwError) bGotValue = TRUE; } if (bGotValue) { dwError = LwAllocateString(szValue, &pszValue); BAIL_ON_EVT_ERROR(dwError); LW_SAFE_FREE_STRING(*ppszValue); *ppszValue = pszValue; pszValue = NULL; } dwError = 0; cleanup: LW_SAFE_FREE_STRING(pszValue); return dwError; error: goto cleanup; }
// Write a Registry Key Value from an EsifData value static eEsifError DataVault_WriteRegistry ( DataVaultPtr self, esif_string keyname, EsifDataPtr value ) { eEsifError rc = ESIF_E_UNSPECIFIED; HKEY hKey = 0; DWORD dwFlags = RRF_RT_ANY; DWORD dwError = 0; DWORD dwSize = 0; DWORD dwType = REG_NONE; char *regkey = 0; char *valuename = 0; u32 j; UNREFERENCED_PARAMETER(self); // Keyname Format: "HKLM\Subkey\Path\ValueName" for (j = 0; HKeyList[j].name; j++) { size_t namelen = esif_ccb_strlen(HKeyList[j].name, 30); if (esif_ccb_strnicmp(HKeyList[j].name, keyname, namelen) == 0 && keyname[namelen] == '\\') { hKey = HKeyList[j].hkey; keyname += esif_ccb_strlen(HKeyList[j].name, 30) + 1; break; } } if (!hKey) { return rc; } regkey = esif_ccb_strdup(keyname); if ((valuename = strrchr(regkey, '\\')) == 0) { esif_ccb_free(regkey); return rc; } *valuename++ = 0; // Get Data Type from Registry if value already exists, otherwise deduce it from ESIF Data Type if ((dwError = RegGetValueA(hKey, regkey, valuename, dwFlags, &dwType, 0, 0)) != 0) { switch (value->type) { case ESIF_DATA_INT32: case ESIF_DATA_UINT32: case ESIF_DATA_TEMPERATURE: dwType = REG_DWORD; dwSize = value->data_len; break; case ESIF_DATA_INT64: case ESIF_DATA_UINT64: dwType = REG_QWORD; dwSize = value->data_len; break; case ESIF_DATA_STRING: dwType = REG_SZ; dwSize = value->data_len; break; case ESIF_DATA_BINARY: case ESIF_DATA_BLOB: dwType = REG_BINARY; dwSize = value->data_len; break; default: rc = ESIF_E_NOT_SUPPORTED; break; } } // Write Registry Value if (dwType != REG_NONE) { dwError = RegSetKeyValueA(hKey, regkey, valuename, dwType, value->buf_ptr, value->data_len); if (dwError == 0) { rc = ESIF_OK; } } esif_ccb_free(regkey); return rc; }
static DWORD UmnSrvUpdateAccountInfo( long long Now ) { DWORD dwError = 0; HANDLE hLsass = NULL; HANDLE hReg = NULL; HKEY hParameters = NULL; BOOLEAN bLocalDBOpen = FALSE; // Do not free PSTR pDisableLsassEnum = NULL; DWORD lastUpdated = 0; DWORD lastUpdatedLen = sizeof(lastUpdated); PLW_EVENTLOG_CONNECTION pConn = NULL; dwError = LwEvtOpenEventlog( NULL, &pConn); BAIL_ON_UMN_ERROR(dwError); dwError = LsaOpenServer(&hLsass); BAIL_ON_UMN_ERROR(dwError); dwError = RegOpenServer(&hReg); BAIL_ON_UMN_ERROR(dwError); dwError = RegOpenKeyExA( hReg, NULL, HKEY_THIS_MACHINE "\\Services\\" SERVICE_NAME "\\Parameters", 0, KEY_ALL_ACCESS, &hParameters); BAIL_ON_UMN_ERROR(dwError); dwError = RegGetValueA( hReg, hParameters, NULL, "LastUpdated", 0, NULL, (PBYTE)&lastUpdated, &lastUpdatedLen); if (dwError == LWREG_ERROR_NO_SUCH_KEY_OR_VALUE) { lastUpdated = 0; dwError = 0; } BAIL_ON_UMN_ERROR(dwError); /* processing local users/groups so disable AD user/group enumeration */ pDisableLsassEnum = getenv("_DISABLE_LSASS_NSS_ENUMERATION"); if (!pDisableLsassEnum || strcmp(pDisableLsassEnum, "1")) { /* Note, this code must leak memory. * * Putenv uses the memory passed to it, that it is it does not copy the * string. There is no Unix standard to unset an environment variable, * and the string passed to putenv must be accessible as long as the * program is running. A static string cannot be used because the * container could out live this service. There is no opportunity to * free the string before the program ends, because the variable must * be accessible for the duration of the program. */ dwError = LwAllocateString( "_DISABLE_LSASS_NSS_ENUMERATION=1", &pDisableLsassEnum); BAIL_ON_UMN_ERROR(dwError); putenv(pDisableLsassEnum); } setpwent(); setgrent(); bLocalDBOpen = TRUE; dwError = UmnSrvUpdateUsers( hLsass, pConn, hReg, hParameters, lastUpdated, Now); BAIL_ON_UMN_ERROR(dwError); dwError = UmnSrvUpdateGroups( hLsass, pConn, hReg, hParameters, lastUpdated, Now); BAIL_ON_UMN_ERROR(dwError); endpwent(); endgrent(); bLocalDBOpen = FALSE; dwError = UmnSrvUpdateADAccounts( hLsass, pConn, hReg, hParameters, lastUpdated, Now); BAIL_ON_UMN_ERROR(dwError); lastUpdated = Now; dwError = RegSetValueExA( hReg, hParameters, "LastUpdated", 0, REG_DWORD, (PBYTE)&lastUpdated, sizeof(lastUpdated)); BAIL_ON_UMN_ERROR(dwError); cleanup: if (bLocalDBOpen) { endpwent(); endgrent(); } if (hLsass) { LsaCloseServer(hLsass); } if (hReg) { RegCloseServer(hReg); } if (pConn) { LwEvtCloseEventlog(pConn); } return dwError; error: goto cleanup; }
DWORD UmnSrvFindDeletedUsers( PLW_EVENTLOG_CONNECTION pEventlog, HANDLE hReg, PCSTR pUserKeyName, HKEY hUsers, long long Now ) { DWORD dwError = 0; DWORD subKeyCount = 0; DWORD maxSubKeyLen = 0; DWORD subKeyLen = 0; DWORD i = 0; PSTR pKeyName = NULL; DWORD lastUpdated = 0; DWORD lastUpdatedLen = 0; USER_MONITOR_PASSWD old = { 0 }; dwError = RegQueryInfoKeyA( hReg, hUsers, NULL, NULL, NULL, &subKeyCount, &maxSubKeyLen, NULL, NULL, NULL, NULL, NULL, NULL); BAIL_ON_UMN_ERROR(dwError); dwError = LwAllocateMemory( maxSubKeyLen + 1, (PVOID *)&pKeyName); for (i = 0; i < subKeyCount; i++) { if (gbPollerThreadShouldExit) { dwError = ERROR_CANCELLED; BAIL_ON_UMN_ERROR(dwError); } subKeyLen = maxSubKeyLen; dwError = RegEnumKeyExA( hReg, hUsers, i, pKeyName, &subKeyLen, NULL, NULL, NULL, NULL); BAIL_ON_UMN_ERROR(dwError); pKeyName[subKeyLen] = 0; lastUpdatedLen = sizeof(lastUpdated); dwError = RegGetValueA( hReg, hUsers, pKeyName, "LastUpdated", 0, NULL, (PBYTE)&lastUpdated, &lastUpdatedLen); if (dwError == LWREG_ERROR_NO_SUCH_KEY_OR_VALUE) { UMN_LOG_WARNING("User %s not completely written. The user monitor service may have previously terminated ungracefully.", LW_SAFE_LOG_STRING(pKeyName)); lastUpdated = 0; dwError = 0; } else { BAIL_ON_UMN_ERROR(dwError); } if (lastUpdated < Now) { UmnSrvFreeUserContents(&old); dwError = UmnSrvReadUser( pUserKeyName, pKeyName, &old); BAIL_ON_UMN_ERROR(dwError); UMN_LOG_INFO("User '%s' deleted", old.pw_name); dwError = RegDeleteKeyA( hReg, hUsers, pKeyName); BAIL_ON_UMN_ERROR(dwError); if (!strcmp(pUserKeyName, "Users")) { dwError = UmnSrvWriteUserEvent( pEventlog, old.LastUpdated, &old, Now, NULL); BAIL_ON_UMN_ERROR(dwError); } else { dwError = UmnSrvWriteADUserEvent( pEventlog, old.LastUpdated, &old, Now, NULL); BAIL_ON_UMN_ERROR(dwError); } // Make sure we don't skip the next key since this one was deleted i--; subKeyCount--; } } cleanup: UmnSrvFreeUserContents(&old); LW_SAFE_FREE_STRING(pKeyName); return dwError; error: goto cleanup; }
static void test_registry(void) { static const WCHAR keypathW[] = {'H','K','E','Y','_','C','U','R','R','E','N','T','_','U','S','E','R','\\', 'S','o','f','t','w','a','r','e','\\','W','i','n','e','\\','T','e','s','t','\\',0}; static const WCHAR regsz2W[] = {'r','e','g','s','z','2',0}; static const WCHAR regszW[] = {'r','e','g','s','z',0}; static const WCHAR regdwordW[] = {'r','e','g','d','w','o','r','d',0}; static const WCHAR regbinaryW[] = {'r','e','g','b','i','n','a','r','y',0}; static const WCHAR regmultiszW[] = {'r','e','g','m','u','l','t','i','s','z',0}; static const WCHAR regsz1W[] = {'H','K','E','Y','_','C','U','R','R','E','N','T','_','U','S','E','R','\\', 'S','o','f','t','w','a','r','e','\\','W','i','n','e','\\','T','e','s','t','\\','r','e','g','s','z','1',0}; static const WCHAR foobarW[] = {'f','o','o','b','a','r',0}; static const WCHAR fooW[] = {'f','o','o',0}; static const WCHAR brokenW[] = {'H','K','E','Y','_','b','r','o','k','e','n','_','k','e','y',0}; static const WCHAR broken2W[] = {'H','K','E','Y','_','C','U','R','R','E','N','T','_','U','S','E','R','a',0}; WCHAR pathW[MAX_PATH]; DWORD dwvalue, type; VARIANT value, v; IWshShell3 *sh3; VARTYPE vartype; LONG bound; HRESULT hr; BSTR name; HKEY root; LONG ret; UINT dim; hr = CoCreateInstance(&CLSID_WshShell, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER, &IID_IWshShell3, (void**)&sh3); ok(hr == S_OK, "got 0x%08x\n", hr); /* RegRead() */ V_VT(&value) = VT_I2; hr = IWshShell3_RegRead(sh3, NULL, &value); ok(hr == E_POINTER, "got 0x%08x\n", hr); ok(V_VT(&value) == VT_I2, "got %d\n", V_VT(&value)); name = SysAllocString(brokenW); hr = IWshShell3_RegRead(sh3, name, NULL); ok(hr == E_POINTER, "got 0x%08x\n", hr); V_VT(&value) = VT_I2; hr = IWshShell3_RegRead(sh3, name, &value); ok(hr == HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND), "got 0x%08x\n", hr); ok(V_VT(&value) == VT_I2, "got %d\n", V_VT(&value)); SysFreeString(name); name = SysAllocString(broken2W); V_VT(&value) = VT_I2; hr = IWshShell3_RegRead(sh3, name, &value); ok(hr == HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND), "got 0x%08x\n", hr); ok(V_VT(&value) == VT_I2, "got %d\n", V_VT(&value)); SysFreeString(name); ret = RegCreateKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Test", &root); ok(ret == 0, "got %d\n", ret); ret = RegSetValueExA(root, "regsz", 0, REG_SZ, (const BYTE*)"foobar", 7); ok(ret == 0, "got %d\n", ret); ret = RegSetValueExA(root, "regsz2", 0, REG_SZ, (const BYTE*)"foobar\0f", 9); ok(ret == 0, "got %d\n", ret); ret = RegSetValueExA(root, "regmultisz", 0, REG_MULTI_SZ, (const BYTE*)"foo\0bar\0", 9); ok(ret == 0, "got %d\n", ret); dwvalue = 10; ret = RegSetValueExA(root, "regdword", 0, REG_DWORD, (const BYTE*)&dwvalue, sizeof(dwvalue)); ok(ret == 0, "got %d\n", ret); dwvalue = 11; ret = RegSetValueExA(root, "regbinary", 0, REG_BINARY, (const BYTE*)&dwvalue, sizeof(dwvalue)); ok(ret == 0, "got %d\n", ret); /* REG_SZ */ lstrcpyW(pathW, keypathW); lstrcatW(pathW, regszW); name = SysAllocString(pathW); VariantInit(&value); hr = IWshShell3_RegRead(sh3, name, &value); ok(hr == S_OK, "got 0x%08x\n", hr); ok(V_VT(&value) == VT_BSTR, "got %d\n", V_VT(&value)); ok(!lstrcmpW(V_BSTR(&value), foobarW), "got %s\n", wine_dbgstr_w(V_BSTR(&value))); VariantClear(&value); SysFreeString(name); /* REG_SZ with embedded NULL */ lstrcpyW(pathW, keypathW); lstrcatW(pathW, regsz2W); name = SysAllocString(pathW); VariantInit(&value); hr = IWshShell3_RegRead(sh3, name, &value); ok(hr == S_OK, "got 0x%08x\n", hr); ok(V_VT(&value) == VT_BSTR, "got %d\n", V_VT(&value)); ok(SysStringLen(V_BSTR(&value)) == 6, "len %d\n", SysStringLen(V_BSTR(&value))); VariantClear(&value); SysFreeString(name); /* REG_DWORD */ lstrcpyW(pathW, keypathW); lstrcatW(pathW, regdwordW); name = SysAllocString(pathW); VariantInit(&value); hr = IWshShell3_RegRead(sh3, name, &value); ok(hr == S_OK, "got 0x%08x\n", hr); ok(V_VT(&value) == VT_I4, "got %d\n", V_VT(&value)); ok(V_I4(&value) == 10, "got %d\n", V_I4(&value)); SysFreeString(name); /* REG_BINARY */ lstrcpyW(pathW, keypathW); lstrcatW(pathW, regbinaryW); name = SysAllocString(pathW); VariantInit(&value); hr = IWshShell3_RegRead(sh3, name, &value); ok(hr == S_OK, "got 0x%08x\n", hr); ok(V_VT(&value) == (VT_ARRAY|VT_VARIANT), "got 0x%x\n", V_VT(&value)); dim = SafeArrayGetDim(V_ARRAY(&value)); ok(dim == 1, "got %u\n", dim); hr = SafeArrayGetLBound(V_ARRAY(&value), 1, &bound); ok(hr == S_OK, "got 0x%08x\n", hr); ok(bound == 0, "got %u\n", bound); hr = SafeArrayGetUBound(V_ARRAY(&value), 1, &bound); ok(hr == S_OK, "got 0x%08x\n", hr); ok(bound == 3, "got %u\n", bound); hr = SafeArrayGetVartype(V_ARRAY(&value), &vartype); ok(hr == S_OK, "got 0x%08x\n", hr); ok(vartype == VT_VARIANT, "got %d\n", vartype); bound = 0; hr = SafeArrayGetElement(V_ARRAY(&value), &bound, &v); ok(hr == S_OK, "got 0x%08x\n", hr); ok(V_VT(&v) == VT_UI1, "got %d\n", V_VT(&v)); ok(V_UI1(&v) == 11, "got %u\n", V_UI1(&v)); VariantClear(&v); VariantClear(&value); SysFreeString(name); /* REG_MULTI_SZ */ lstrcpyW(pathW, keypathW); lstrcatW(pathW, regmultiszW); name = SysAllocString(pathW); VariantInit(&value); hr = IWshShell3_RegRead(sh3, name, &value); ok(hr == S_OK, "got 0x%08x\n", hr); ok(V_VT(&value) == (VT_ARRAY|VT_VARIANT), "got 0x%x\n", V_VT(&value)); SysFreeString(name); dim = SafeArrayGetDim(V_ARRAY(&value)); ok(dim == 1, "got %u\n", dim); hr = SafeArrayGetLBound(V_ARRAY(&value), 1, &bound); ok(hr == S_OK, "got 0x%08x\n", hr); ok(bound == 0, "got %u\n", bound); hr = SafeArrayGetUBound(V_ARRAY(&value), 1, &bound); ok(hr == S_OK, "got 0x%08x\n", hr); ok(bound == 1, "got %u\n", bound); hr = SafeArrayGetVartype(V_ARRAY(&value), &vartype); ok(hr == S_OK, "got 0x%08x\n", hr); ok(vartype == VT_VARIANT, "got %d\n", vartype); bound = 0; hr = SafeArrayGetElement(V_ARRAY(&value), &bound, &v); ok(hr == S_OK, "got 0x%08x\n", hr); ok(V_VT(&v) == VT_BSTR, "got %d\n", V_VT(&v)); ok(!lstrcmpW(V_BSTR(&v), fooW), "got %s\n", wine_dbgstr_w(V_BSTR(&v))); VariantClear(&v); VariantClear(&value); name = SysAllocString(regsz1W); V_VT(&value) = VT_I2; hr = IWshShell3_RegRead(sh3, name, &value); ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "got 0x%08x\n", hr); ok(V_VT(&value) == VT_I2, "got %d\n", V_VT(&value)); VariantClear(&value); SysFreeString(name); delete_key(root); /* RegWrite() */ ret = RegCreateKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Test", &root); ok(ret == 0, "got %d\n", ret); hr = IWshShell3_RegWrite(sh3, NULL, NULL, NULL); ok(hr == E_POINTER, "got 0x%08x\n", hr); lstrcpyW(pathW, keypathW); lstrcatW(pathW, regszW); name = SysAllocString(pathW); hr = IWshShell3_RegWrite(sh3, name, NULL, NULL); ok(hr == E_POINTER, "got 0x%08x\n", hr); VariantInit(&value); hr = IWshShell3_RegWrite(sh3, name, &value, NULL); ok(hr == E_POINTER, "got 0x%08x\n", hr); hr = IWshShell3_RegWrite(sh3, name, &value, &value); ok(hr == E_INVALIDARG, "got 0x%08x\n", hr); /* type is optional */ V_VT(&v) = VT_ERROR; V_ERROR(&v) = DISP_E_PARAMNOTFOUND; hr = IWshShell3_RegWrite(sh3, name, &value, &v); ok(hr == S_OK, "got 0x%08x\n", hr); /* default type is REG_SZ */ V_VT(&value) = VT_I4; V_I4(&value) = 12; hr = IWshShell3_RegWrite(sh3, name, &value, &v); ok(hr == S_OK, "got 0x%08x\n", hr); type = REG_NONE; ret = RegGetValueA(root, NULL, "regsz", RRF_RT_ANY, &type, NULL, NULL); ok(ret == ERROR_SUCCESS, "got %d\n", ret); ok(type == REG_SZ, "got %d\n", type); ret = RegDeleteValueA(root, "regsz"); ok(ret == ERROR_SUCCESS, "got %d\n", ret); V_VT(&value) = VT_BSTR; V_BSTR(&value) = SysAllocString(regszW); hr = IWshShell3_RegWrite(sh3, name, &value, &v); ok(hr == S_OK, "got 0x%08x\n", hr); VariantClear(&value); type = REG_NONE; ret = RegGetValueA(root, NULL, "regsz", RRF_RT_ANY, &type, NULL, NULL); ok(ret == ERROR_SUCCESS, "got %d\n", ret); ok(type == REG_SZ, "got %d\n", type); ret = RegDeleteValueA(root, "regsz"); ok(ret == ERROR_SUCCESS, "got %d\n", ret); V_VT(&value) = VT_R4; V_R4(&value) = 1.2; hr = IWshShell3_RegWrite(sh3, name, &value, &v); ok(hr == S_OK, "got 0x%08x\n", hr); VariantClear(&value); type = REG_NONE; ret = RegGetValueA(root, NULL, "regsz", RRF_RT_ANY, &type, NULL, NULL); ok(ret == ERROR_SUCCESS, "got %d\n", ret); ok(type == REG_SZ, "got %d\n", type); ret = RegDeleteValueA(root, "regsz"); ok(ret == ERROR_SUCCESS, "got %d\n", ret); V_VT(&value) = VT_R4; V_R4(&value) = 1.2; V_VT(&v) = VT_I2; V_I2(&v) = 1; hr = IWshShell3_RegWrite(sh3, name, &value, &v); ok(hr == E_INVALIDARG, "got 0x%08x\n", hr); VariantClear(&value); SysFreeString(name); delete_key(root); IWshShell3_Release(sh3); }