bool RegistryAccess::GetRegValue( const RString &sKey, const RString &sName, RString &sVal ) { HKEY hKey = OpenRegKey( sKey, READ ); if( hKey == NULL ) return false; char sBuffer[MAX_PATH]; DWORD iSize = sizeof(sBuffer); DWORD iType; LONG iRet = RegQueryValueEx( hKey, sName, NULL, &iType, (LPBYTE)sBuffer, &iSize ); RegCloseKey( hKey ); if( iRet != ERROR_SUCCESS ) return false; /* Actually, CStrings are 8-bit clean, so we can accept any type of data. Remove * this if that becomes useful. */ if( iType != REG_SZ && iType != REG_MULTI_SZ && iType != REG_EXPAND_SZ && iType != REG_BINARY ) return false; /* type mismatch */ if( iSize && (iType == REG_SZ || iType == REG_MULTI_SZ || iType == REG_EXPAND_SZ) ) --iSize; /* remove nul terminator */ sVal = RString( sBuffer, iSize ); return true; }
Shortcuts::Shortcuts() { HKEY hNewKey = OpenRegKey(FolderShortcutsKeyTest); if (hNewKey == NULL) { for(size_t i = 0; i < KeyCount; i++) { FormatString ValueName; ValueName << RecTypeName[PSCR_RT_SHORTCUT] << i; string strValue; if(!GetRegKey(OldFolderShortcutsKey, ValueName, strValue, L"")) continue; ValueName.Clear(); ShortcutItem* Item = Items[i].Push(); Item->strFolder = strValue; ValueName << RecTypeName[PSCR_RT_PLUGINMODULE] << i; GetRegKey(OldFolderShortcutsKey, ValueName, Item->strPluginModule, L""); ValueName.Clear(); ValueName << RecTypeName[PSCR_RT_PLUGINFILE] << i; GetRegKey(OldFolderShortcutsKey, ValueName, Item->strPluginFile, L""); ValueName.Clear(); ValueName << RecTypeName[PSCR_RT_PLUGINDATA] << i; GetRegKey(OldFolderShortcutsKey, ValueName, Item->strPluginData, L""); ValueName.Clear(); } return; } for(size_t i = 0; i < KeyCount; i++) { FormatString strFolderShortcuts; strFolderShortcuts << FolderShortcutsKey << i; if (!CheckRegKey(strFolderShortcuts)) continue; for(size_t j=0; ; j++) { FormatString ValueName; ValueName << RecTypeName[PSCR_RT_SHORTCUT] << j; string strValue; if(!GetRegKey(strFolderShortcuts, ValueName, strValue, L"")) break; ValueName.Clear(); ShortcutItem* Item = Items[i].Push(); Item->strFolder = strValue; ValueName << RecTypeName[PSCR_RT_PLUGINMODULE] << j; GetRegKey(strFolderShortcuts, ValueName, Item->strPluginModule, L""); ValueName.Clear(); ValueName << RecTypeName[PSCR_RT_PLUGINFILE] << j; GetRegKey(strFolderShortcuts, ValueName, Item->strPluginFile, L""); ValueName.Clear(); ValueName << RecTypeName[PSCR_RT_PLUGINDATA] << j; GetRegKey(strFolderShortcuts, ValueName, Item->strPluginData, L""); ValueName.Clear(); } } }
// проверить существование ключа BOOL CheckRegKey(HKEY hRoot,TCHAR *Key) { HKEY hKey=OpenRegKey(hRoot,Key); if(hKey!=NULL) RegCloseKey(hKey); return(hKey!=NULL); }
bool RegistryRW::KeyExist(const std::string& path ,long &ret) const { HKEY key; ret = OpenRegKey(path,key); if (ret == ERROR_SUCCESS) { RegCloseKey(key); return true; } return false; }
BOOL DeleteRegValue(HKEY hkBase, char *szKeyName, char *szValueName) { HKEY hkey; BOOL success; if (!(hkey = OpenRegKey(hkBase, szKeyName))) return FALSE; success = (RegDeleteValue(hkey, szValueName) == ERROR_SUCCESS); RegCloseKey(hkey); return success; }
bool CStartupInfo::QueryRegKeyValue(HKEY parentKey, const CSysString &keyName, LPCTSTR valueName, bool valueDefault) const { NRegistry::CKey regKey; if (OpenRegKey(parentKey, keyName, regKey) != ERROR_SUCCESS) return valueDefault; bool value; if(regKey.QueryValue(valueName, value) != ERROR_SUCCESS) return valueDefault; return value; }
int GetRegKey(HKEY hRoot,const char *Key,const char *ValueName,int &ValueData,DWORD Default) { HKEY hKey=OpenRegKey(hRoot,Key); DWORD Type,Size=sizeof(ValueData); int ExitCode=RegQueryValueEx(hKey,ValueName,0,&Type,(BYTE *)&ValueData,&Size); RegCloseKey(hKey); if (hKey==NULL || ExitCode!=ERROR_SUCCESS) { ValueData=Default; return FALSE; } return TRUE; }
BOOL GetRegKey(const char *ValueName,int *ValueData,DWORD Default) { hKey=OpenRegKey(); DWORD Type,Size=sizeof(*ValueData); int ExitCode=RegQueryValueEx(hKey,ValueName,0,&Type,(BYTE *)ValueData,&Size); RegCloseKey(hKey); if (hKey==NULL || ExitCode!=ERROR_SUCCESS) { *ValueData=Default; return(FALSE); } return(TRUE); }
int GetRegKeyStr(HKEY hRoot, wchar_t *Key, wchar_t *ValueName, wchar_t *ValueData, wchar_t *Default, DWORD DataSize) { HKEY hKey=OpenRegKey(hRoot, Key); DWORD Type; int ExitCode=RegQueryValueExW(hKey, ValueName, 0, &Type, (BYTE*)ValueData, &DataSize); RegCloseKey(hKey); if (hKey==NULL || ExitCode!=ERROR_SUCCESS) { wcscpy(ValueData, Default); return(FALSE); } return(TRUE); }
int GetRegKeyInt(HKEY hRoot, wchar_t *Key, wchar_t *ValueName, int *ValueData, DWORD Default) { HKEY hKey=OpenRegKey(hRoot, Key); DWORD Type, Size=sizeof(ValueData); int ExitCode=RegQueryValueExW(hKey, ValueName, 0, &Type, (BYTE *)ValueData, &Size); RegCloseKey(hKey); if (hKey==NULL || ExitCode!=ERROR_SUCCESS) { *ValueData=Default; return(FALSE); } return(TRUE); }
int GetRegKey(HKEY hRoot,const char *Key,const char *ValueName,char *ValueData,const char *Default,DWORD DataSize) { HKEY hKey=OpenRegKey(hRoot,Key); DWORD Type; int ExitCode=RegQueryValueEx(hKey,ValueName,0,&Type,(BYTE*)ValueData,&DataSize); RegCloseKey(hKey); if (hKey==NULL || ExitCode!=ERROR_SUCCESS) { lstrcpy(ValueData,Default); return FALSE; } return TRUE; }
BOOL QueryRegString(HKEY hkBase, char *szKeyName, char *szValueName, char *lpBuffer, int cbBuffer) { HKEY hkey; BOOL success; DWORD type; if (!(hkey = OpenRegKey(hkBase, szKeyName))) return FALSE; success = (ERROR_SUCCESS == RegQueryValueEx(hkey, szValueName, 0, &type, (LPBYTE)lpBuffer, (LPDWORD)&cbBuffer)); RegCloseKey(hkey); return success; }
long RegistryRW::DeleteKey(const std::string& path,const std::string& subKey) const { HKEY key; long ret = OpenRegKey(path,key); if (ret!=ERROR_SUCCESS) return ret; #ifdef _WIN32 ret =RegDeleteKeyEx(key, subKey.c_str(), KEY_WOW64_32KEY, 0); #else ret= RegDeleteKeyEx(key, subKey.c_str(), KEY_WOW64_64KEY, 0); #endif return ret; }
int RegistryRW::Get_numKeyItems(const std::string& path) const { HKEY hkey; DWORD numItems = 0; DWORD biggest; long ret ; ret = OpenRegKey(path,hkey); if (ret != ERROR_SUCCESS) { CreateErrorMsg(ret,true); return -1; //error } GetInfoKey(hkey,numItems,biggest); return numItems; }
int GetRegKey(HKEY hRoot, BOOL bEx, const TCHAR *Key,const TCHAR *ValueName,CString &ValueData,TCHAR *Default) { HKEY hKey=OpenRegKey(hRoot, bEx, Key); DWORD Type; DWORD DataSize = 1000; int ExitCode=RegQueryValueEx(hKey,ValueName,0,&Type,(LPBYTE)ValueData.GetBuffer(1000),&DataSize); ValueData.ReleaseBuffer(); RegCloseKey(hKey); if (hKey==NULL || ExitCode!=ERROR_SUCCESS) { ValueData = Default; return(FALSE); } return(TRUE); }
bool RegistryAccess::SetRegValue( const RString &sKey, const RString &sName, bool bVal ) { HKEY hKey = OpenRegKey( sKey, WRITE ); if( hKey == NULL ) return false; bool bSuccess = true; if (::RegSetValueEx(hKey, LPCTSTR(sName), 0, REG_BINARY, (LPBYTE)&bVal, sizeof(bVal)) != ERROR_SUCCESS) bSuccess = false; ::RegCloseKey(hKey); return bSuccess; }
int GetRegKeyArr(HKEY hRoot, wchar_t *Key, wchar_t *ValueName, BYTE *ValueData, BYTE *Default, DWORD DataSize) { HKEY hKey=OpenRegKey(hRoot, Key); DWORD Type; int ExitCode=RegQueryValueExW(hKey, ValueName, 0, &Type, ValueData, &DataSize); RegCloseKey(hKey); if (hKey==NULL || ExitCode!=ERROR_SUCCESS) { if (Default!=NULL) memcpy(ValueData, Default, DataSize); else memset(ValueData, 0, DataSize); return(FALSE); } return(TRUE); }
int GetRegKey(HKEY hRoot, BOOL bEx, const TCHAR *Key,const TCHAR *ValueName,BYTE *ValueData,BYTE *Default,DWORD DataSize) { HKEY hKey=OpenRegKey(hRoot, bEx, Key); DWORD Type,Required=DataSize; int ExitCode=RegQueryValueEx(hKey,ValueName,0,&Type,ValueData,&Required); RegCloseKey(hKey); if (hKey==NULL || ExitCode!=ERROR_SUCCESS) { if (Default!=NULL) my_memcpy(ValueData,Default,DataSize); else my_memset(ValueData,0,DataSize); return(FALSE); } return(DataSize); }
// получить данные типа char* int GetRegKey(HKEY hRoot,TCHAR *Key,TCHAR *ValueName,TCHAR *ValueData,TCHAR *Default,DWORD DataSize) { HKEY hKey=OpenRegKey(hRoot,Key); DWORD Type; DWORD Size = DataSize * sizeof(TCHAR); int ExitCode=RegQueryValueEx(hKey,ValueName,0,&Type,(LPBYTE)ValueData,&Size); ValueData[DataSize - 1] = 0; RegCloseKey(hKey); if(hKey==NULL || ExitCode!=ERROR_SUCCESS) { StringCchCopy(ValueData,DataSize,Default); return(FALSE); } return(TRUE); }
BOOL CRegistryCfg::DeleteValue(LPCTSTR szContainer, LPCTSTR szValueName) { BOOL bCreate(FALSE); HKEY hKey = OpenRegKey(m_hCfgRootKey, szContainer, KEY_SET_VALUE); if (INVALID_HANDLE_VALUE == hKey) { return FALSE; } LONG lResult = ::RegDeleteValue(hKey, szValueName); if (ERROR_SUCCESS != lResult) { ::SetLastError(lResult); ::RegCloseKey(hKey); return FALSE; } ::RegCloseKey(hKey); return TRUE; }
int GetRegKey(const wchar_t *Key,const wchar_t *ValueName,BYTE *ValueData,const BYTE *Default,DWORD DataSize,DWORD *pType) { int ExitCode=!ERROR_SUCCESS; HKEY hKey=OpenRegKey(Key); DWORD Required=DataSize; if (hKey) { DWORD Type; ExitCode=RegQueryValueEx(hKey,ValueName,0,&Type,ValueData,&Required); if (ExitCode == ERROR_MORE_DATA) // если размер не подходящие... { char *TempBuffer=new char[Required+1]; // ...то выделим сколько надо if (TempBuffer) // Если с памятью все нормально... { if ((ExitCode=RegQueryValueEx(hKey,ValueName,0,&Type,(unsigned char *)TempBuffer,&Required)) == ERROR_SUCCESS) memcpy(ValueData,TempBuffer,DataSize); // скопируем сколько надо. delete[] TempBuffer; } } if (pType) *pType=Type; CloseRegKey(hKey); } if (ExitCode!=ERROR_SUCCESS) { if (Default) memcpy(ValueData,Default,DataSize); else memset(ValueData,0,DataSize); return 0; } return(Required); }
bool RegistryAccess::GetRegValue( const RString &sKey, const RString &sName, int &iVal, bool bWarnOnError ) { HKEY hKey = OpenRegKey( sKey, READ, bWarnOnError ); if( hKey == NULL ) return false; DWORD iValue; DWORD iSize = sizeof(iValue); DWORD iType; LONG iRet = RegQueryValueEx( hKey, sName, NULL, &iType, (LPBYTE) &iValue, &iSize ); RegCloseKey( hKey ); if( iRet != ERROR_SUCCESS ) return false; if( iType != REG_DWORD ) return false; /* type mismatch */ iVal = iValue; return true; }
int GetRegKey(const wchar_t *Key,const wchar_t *ValueName,int &ValueData,DWORD Default) { int ExitCode=!ERROR_SUCCESS; HKEY hKey=OpenRegKey(Key); if (hKey) { DWORD Type,Size=sizeof(ValueData); ExitCode=RegQueryValueEx(hKey,ValueName,0,&Type,(BYTE *)&ValueData,&Size); CloseRegKey(hKey); } if (ExitCode!=ERROR_SUCCESS) { ValueData=Default; return FALSE; } return TRUE; }
bool RegistryAccess::SetRegValue( const RString &sKey, const RString &sName, const RString &sVal ) { HKEY hKey = OpenRegKey( sKey, WRITE ); if( hKey == NULL ) return false; bool bSuccess = true; TCHAR sz[255]; if( sVal.size() > 254 ) return false; strcpy( sz, sVal.c_str() ); LONG lResult = ::RegSetValueEx(hKey, LPCTSTR(sName), 0, REG_SZ, (LPBYTE)sz, strlen(sz) + 1); if( lResult != ERROR_SUCCESS ) bSuccess = false; ::RegCloseKey(hKey); return bSuccess; }
int GetRegKey(const wchar_t *Key,const wchar_t *ValueName,string &strValueData,const wchar_t *Default,DWORD *pType) { int ExitCode=!ERROR_SUCCESS; HKEY hKey=OpenRegKey(Key); if (hKey) // надобно проверить! { DWORD Type,QueryDataSize=0; if ((ExitCode = RegQueryValueEx( hKey, ValueName, 0, &Type, nullptr, &QueryDataSize )) == ERROR_SUCCESS) { wchar_t *TempBuffer = strValueData.GetBuffer(QueryDataSize/sizeof(wchar_t)+1); // ...то выделим сколько надо ExitCode = RegQueryValueEx(hKey,ValueName,0,&Type,(unsigned char *)TempBuffer,&QueryDataSize); strValueData.ReleaseBuffer(QueryDataSize/sizeof(wchar_t)); if (strValueData.GetLength() > 0 && !strValueData.At(strValueData.GetLength()-1)) strValueData.SetLength(strValueData.GetLength()-1); } if (pType) *pType=Type; CloseRegKey(hKey); } if (ExitCode!=ERROR_SUCCESS) { strValueData = Default; return FALSE; } return TRUE; }
bool RegistryAccess::GetRegSubKeys( const RString &sKey, vector<RString> &lst, const RString ®ex, bool bReturnPathToo ) { HKEY hKey = OpenRegKey( sKey, READ ); if( hKey == NULL ) return false; Regex re(regex); bool bError = false; for( int index = 0; ; ++index ) { FILETIME ft; char szBuffer[MAX_PATH]; DWORD iSize = sizeof(szBuffer); LONG iRet = RegEnumKeyEx( hKey, index, szBuffer, &iSize, NULL, NULL, NULL, &ft); if( iRet == ERROR_NO_MORE_ITEMS ) break; if( iRet != ERROR_SUCCESS ) { LOG->Warn( werr_ssprintf(iRet, "GetRegSubKeys(%p,%i) error", hKey, index) ); bError = true; break; } RString sStr( szBuffer, iSize ); if( re.Compare(sStr) ) { if( bReturnPathToo ) sStr = sKey + "\\" + sStr; lst.push_back( sStr ); } } RegCloseKey( hKey ); return !bError; }
void KillRegVal( const char *Key, const char *ValueName ) { HKEY hKey = OpenRegKey( Key ); RegDeleteValue( hKey, ValueName ); RegCloseKey( hKey ); }
// ValueData, DataType = GetRegKey (Root, Key, ValueName [, samDesired]) // Root: [string], one of "HKLM", "HKCC", "HKCR", "HKCU", "HKU" // Key: registry key, [string] // ValueName: registry value name, [string] // samDesired: access mask, [flag] ("KEY_WOW64_32KEY" or "KEY_WOW64_64KEY"; the default is 0) // Returns: // ValueData: registry value data, [string | number | lstring] // DataType: "string", "expandstring", "multistring", "dword" or "binary", [string] static int win_GetRegKey(lua_State *L) { HKEY hKey; DWORD datatype, datasize; char *data; LONG ret; HKEY hRoot = CheckHKey(L, 1); wchar_t* Key = (wchar_t*)check_utf8_string(L, 2, NULL); const wchar_t* ValueName = check_utf8_string(L, 3, NULL); REGSAM samDesired = (REGSAM) OptFlags(L, 4, 0); hKey = OpenRegKey(hRoot, Key, samDesired); if(hKey == NULL) { lua_pushnil(L); lua_pushstring(L, "OpenRegKey failed."); return 2; } RegQueryValueExW(hKey, ValueName, NULL, &datatype, NULL, &datasize); data = (char*) malloc(datasize); ret = RegQueryValueExW(hKey, ValueName, NULL, &datatype, (BYTE*)data, &datasize); RegCloseKey(hKey); if(ret != ERROR_SUCCESS) { lua_pushnil(L); lua_pushstring(L, "RegQueryValueEx failed."); } else { switch(datatype) { case REG_BINARY: lua_pushlstring(L, data, datasize); lua_pushstring(L, "binary"); break; case REG_DWORD: lua_pushinteger(L, *(int*)data); lua_pushstring(L, "dword"); break; case REG_SZ: push_utf8_string(L, (wchar_t*)data, -1); lua_pushstring(L, "string"); break; case REG_EXPAND_SZ: push_utf8_string(L, (wchar_t*)data, -1); lua_pushstring(L, "expandstring"); break; case REG_MULTI_SZ: push_utf8_string(L, (wchar_t*)data, datasize/sizeof(wchar_t)); lua_pushstring(L, "multistring"); break; default: lua_pushnil(L); lua_pushstring(L, "unsupported value type"); break; } } free(data); return 2; }
bool History::ReadHistory(bool bOnlyLines) { HKEY hKey=OpenRegKey(strRegKey); if (!hKey) return false; bool ret = false; wchar_t *TypesBuffer=nullptr; wchar_t *LocksBuffer=nullptr; FILETIME *TimesBuffer=nullptr; wchar_t *Buffer=nullptr; int Position=-1; DWORD Size=sizeof(Position); DWORD Type; if (!bOnlyLines) RegQueryValueEx(hKey,L"Position",0,&Type,(BYTE *)&Position,&Size); bool NeedReadType=false; bool NeedReadLock=false; bool NeedReadTime=false; Size=0; if (!bOnlyLines && SaveType && RegQueryValueEx(hKey,L"Types",0,&Type,nullptr,&Size)==ERROR_SUCCESS && Size>0) { NeedReadType=true; Size=Max(Size,(DWORD)((HistoryCount+2)*sizeof(wchar_t))); TypesBuffer=(wchar_t *)xf_malloc(Size); if (TypesBuffer) { memset(TypesBuffer,0,Size); if (RegQueryValueEx(hKey,L"Types",0,&Type,(BYTE *)TypesBuffer,&Size)!=ERROR_SUCCESS) goto end; } else goto end; } Size=0; if (!bOnlyLines && RegQueryValueEx(hKey,L"Locks",0,&Type,nullptr,&Size)==ERROR_SUCCESS && Size>0) { NeedReadLock=true; Size=Max(Size,(DWORD)((HistoryCount+2)*sizeof(wchar_t))); LocksBuffer=(wchar_t *)xf_malloc(Size); if (LocksBuffer) { memset(LocksBuffer,0,Size); if (RegQueryValueEx(hKey,L"Locks",0,&Type,(BYTE *)LocksBuffer,&Size)!=ERROR_SUCCESS) goto end; } else goto end; } Size=0; if (!bOnlyLines && RegQueryValueEx(hKey,L"Times",0,&Type,nullptr,&Size)==ERROR_SUCCESS && Size>0) { NeedReadTime=true; Size=Max(Size,(DWORD)((HistoryCount+2)*sizeof(FILETIME))); TimesBuffer=(FILETIME *)xf_malloc(Size); if (TimesBuffer) { memset(TimesBuffer,0,Size); if (RegQueryValueEx(hKey,L"Times",0,&Type,(BYTE *)TimesBuffer,&Size)!=ERROR_SUCCESS) goto end; } else goto end; } Size=0; if (RegQueryValueEx(hKey,L"Lines",0,&Type,nullptr,&Size)!=ERROR_SUCCESS || !Size) // Нету ничерта { ret = true; goto end; } if (!(Buffer=(wchar_t*)xf_malloc(Size))) goto end; if (RegQueryValueEx(hKey,L"Lines",0,&Type,(unsigned char *)Buffer,&Size)==ERROR_SUCCESS) { CurrentItem=nullptr; wchar_t *TypesBuf=TypesBuffer; wchar_t *LockBuf=LocksBuffer; FILETIME *TimeBuf=TimesBuffer; size_t StrPos=0; wchar_t *Buf=Buffer; Size/=sizeof(wchar_t); Buf[Size-1]=0; //safety while (Size > 1 && StrPos < HistoryCount) { int Length=StrLength(Buf)+1; HistoryRecord AddRecord; AddRecord.strName = Buf; Buf+=Length; Size-=Length; if (NeedReadType) { if (iswdigit(*TypesBuf)) { AddRecord.Type = *TypesBuf-L'0'; TypesBuf++; } } if (NeedReadLock) { if (iswdigit(*LockBuf)) { AddRecord.Lock = (*LockBuf-L'0')? true:false; LockBuf++; } } if (NeedReadTime) { AddRecord.Timestamp.dwLowDateTime=TimeBuf->dwLowDateTime; AddRecord.Timestamp.dwHighDateTime=TimeBuf->dwHighDateTime; TimeBuf++; } if (AddRecord.strName.GetLength()) { HistoryList.Unshift(&AddRecord); if (StrPos == static_cast<size_t>(Position)) CurrentItem=HistoryList.First(); } StrPos++; } } else goto end; ret=true; end: RegCloseKey(hKey); if (TypesBuffer) xf_free(TypesBuffer); if (Buffer) xf_free(Buffer); if (LocksBuffer) xf_free(LocksBuffer); if (TimesBuffer) xf_free(TimesBuffer); //if (!ret) //clear(); return ret; }