示例#1
0
bool 
CKNSettings::setPass(string strPass)
{
    bool bReturn = true;

    m_strPass = strPass;
    
    // If we're using the registry, write the passed string to the Pass subkey

    if(m_bUseRegistry) {

        // If the key is open, close it.

        if(m_hKey)
            CloseKey();

        // Opening the key for writing, so we pass false for the ForRead value.

        if(OpenKey(false)) {
            bReturn = SetRegValue("Pass", strPass);
    
            CloseKey();
        }
    }

    return bReturn;
}
示例#2
0
文件: registry.cpp 项目: hjgode/c00p
int RegReadBytes(TCHAR *valuename, byte *value, int iSize)
{
	static byte dwResult;
	LONG rc;
	DWORD dwType=REG_BINARY;
	DWORD dwSize=sizeof(byte);
	if (g_hkey==NULL)
		rc = OpenKey();
	if (g_hkey != NULL)
	{
		//query the size of the data
		rc = RegQueryValueEx(g_hkey, valuename, NULL, &dwType, NULL, &dwSize);
		if (rc == ERROR_SUCCESS)
		{
			iSize = dwSize;
			byte* bResult=new byte[dwSize];
			rc = RegQueryValueEx(g_hkey, valuename, NULL, &dwType, bResult, &dwSize);
			if (rc == ERROR_SUCCESS)
			{
				CloseKey();
				memcpy(value, bResult, 20);
				delete bResult;
				return rc;
			}
		}
	}
	CloseKey();
	return rc;
}
示例#3
0
bool 
CKNSettings::setPort(int iPort)
{
    bool bReturn = true;

    m_iPort = iPort;
    
    // If we're using the registry, write the passed int to the Port subkey

    if(m_bUseRegistry) {

        // If the key is open, close it.

        if(m_hKey)
            CloseKey();

        // Opening the key for writing, so we pass false for the ForRead value.

        if(OpenKey(false)) {
            bReturn = SetRegValueNum("Port", iPort);
    
            CloseKey();
        }
    }

    return bReturn;
}
示例#4
0
/*lint -e774 */
bool RegKey::GetKeyValue(LPCTSTR pszKeyName, LPCTSTR pszValueName, BYTE& pValue, DWORD dwValueLength
	, bool bActive /* = false */, HKEY hBaseKey /* = HKEY_CURRENT_USER */, LPCTSTR pszMachineName /* = NULL */)
{
	if ((pszKeyName == NULL) || (pszValueName == NULL) || (&pValue == NULL))
	{
		iLastErrorCode_ = ERROR_BAD_ARGUMENTS;
		return false;
	}

	CloseKey(); // Close current active key and base key if remote

	// Open the key
	if (!OpenKey(pszKeyName, false, hBaseKey, pszMachineName))
		return false;

	if (!GetValue(pszValueName, pValue, dwValueLength))
	{
		if (!bActive)
			CloseKey();
		return false;
	}

	if (!bActive)
		CloseKey(); // Close current active key and base key if remote

	iLastErrorCode_ = ERROR_SUCCESS;
	return true;
}
示例#5
0
// Opens a key, deletes a value from the key and makes key active if required
bool RegKey::DeleteKeyValue(LPCTSTR pszKeyName, LPCTSTR pszValueName, bool bActive /* = false */, HKEY hBaseKey /* = HKEY_CURRENT_USER */, LPCTSTR pszMachineName /* = NULL */)
{
	if (pszValueName == NULL || pszKeyName == NULL)
	{
		iLastErrorCode_ = ERROR_BAD_ARGUMENTS;
		return false;
	}

	CloseKey(); // Close current active key and base key if remote

	// Open the key
	if (!OpenKey(pszKeyName, false, hBaseKey, pszMachineName))
		return false;

	if (!DeleteValue(pszValueName))
	{
		if (!bActive)
			CloseKey();
		return false;
	}

	if (!bActive)
		CloseKey(); // Close current active key and base key if remote

	iLastErrorCode_ = ERROR_SUCCESS;
	return true;
}
示例#6
0
bool RegKey::SetKeyValue(LPCTSTR pszKeyName, LPCTSTR pszValueName, const BYTE* pValue, DWORD dwValueLength
	, bool bCreateIfNoExist /* = false */, bool bActive /* = false */
	, HKEY hBaseKey /* = HKEY_CURRENT_USER */, LPCTSTR pszMachineName /* = NULL */)
{
	if (pszValueName == NULL || pValue == NULL || pszKeyName == NULL)
	{
		iLastErrorCode_ = ERROR_BAD_ARGUMENTS;
		return false;
	}

	CloseKey(); // Close current active key and base key if remote

	// Open / create the key
	if (!OpenKey(pszKeyName, bCreateIfNoExist, hBaseKey, pszMachineName))
		return false;

	if (!SetValue(pszValueName, (BYTE*)pValue, dwValueLength))
	{
		if (!bActive)
			CloseKey();
		return false;
	}

	if (!bActive)
		CloseKey(); // Close current active key and base key if remote

	iLastErrorCode_ = ERROR_SUCCESS;
	return true;
}
示例#7
0
// Delete a Key
bool RegKey::QuickDeleteKey(LPCTSTR pszKeyName, HKEY hBaseKey /* = HKEY_CURRENT_USER */)
{
	if (pszKeyName == NULL)
	{
		iLastErrorCode_ = ERROR_BAD_ARGUMENTS;
		return false;
	}

	CloseKey(); // Close current active key and base key if remote

	TCHAR* pBackSlash;
	bool bRetValue = true;

	// You cannot delete a key if given a full path e.g. "A\\B"
	// We have to go back up a level to "A" and then delete

	// Take a copy of the keyName
	TCHAR* pszCopy = _tcsdup(pszKeyName);

	pBackSlash = _tcsrchr(pszCopy, _T('\\'));
	if (pBackSlash == NULL) // Not found
	{
		// No path, so specified key is just a subkey of active key
		bRetValue = RecursiveDelete(this, hBaseKey, pszKeyName);
	}
	else // Path specified
	{
		LPTSTR pszChildKeyName = pBackSlash + 1;
		*(pBackSlash) = _T('\0'); // Null terminate the parent string

		LPTSTR pszParentKey = (TCHAR*)pszCopy;
		HKEY hTempKey;

		LONG retValue = RegOpenKeyEx(hBaseKey, pszParentKey, NULL, KEY_ALL_ACCESS, &hTempKey);

		if (retValue == ERROR_SUCCESS)
		{
			bRetValue = RecursiveDelete(this, hTempKey, pszChildKeyName);
			RegCloseKey(hTempKey);
		}
		else
		{
			free(pszCopy);
			pszCopy = NULL;

			iLastErrorCode_ = GetLastError();
			return false;
		}
	}

	free(pszCopy);

	if (!bRetValue)
		return false;

	CloseKey(); // Close current active key and base key if remote

	iLastErrorCode_ = ERROR_SUCCESS;
	return true;
}
示例#8
0
BOOL TRegistry::DeleteChildTreeW(const WCHAR *subKey)
{
	WCHAR	wbuf[256];
	BOOL	ret = TRUE;

	if (subKey && !OpenKeyW(subKey)) {
		return	FALSE;
	}

	while (EnumKeyW(0, wbuf, wsizeof(wbuf)))
	{
		if (!(ret = DeleteChildTreeW(wbuf)))
			break;
	}
	if (subKey)
	{
		CloseKey();
		ret = DeleteKeyW(subKey) ? ret : FALSE;
	}
	else {
		while (EnumValueW(0, wbuf, wsizeof(wbuf)))
		{
			if (!DeleteValueW(wbuf))
			{
				ret = FALSE;
				break;
			}
		}
	}
	return	ret;
}
示例#9
0
bool 
CKNSettings::GetSettingsFromRegistry()
{
    // If opening the key for reading succeeds, get the registry values for
    // Server, Path, User, and Pass, and store them in their appropriate
    // variables.

    if(OpenKey(true)) 
    {
        if(GetRegValue("Server", m_strServer) && 
           GetRegValueNum("Port", (DWORD&) m_iPort) && 
           GetRegValue("Path", m_strPath) && 
           GetRegValue("User", m_strUser) && 
           GetRegValue("Pass", m_strPass))
        {
            // If getting all of the above values succeeds, close the key

            CloseKey();

            return true;
        }
    }

    return false;
}
示例#10
0
bool RegUtils::IsRegKeyPresent(const HKEY& hRootHive, const CStdString& sSourceKeyName)
{	
	HKEY hKey = NULL;
	bool bPresent = RegOpenKeyEx(hRootHive, sSourceKeyName, 0, KEY_READ, &hKey) == ERROR_SUCCESS;
	CloseKey(hKey);
	return bPresent;
}
示例#11
0
/*
	subKey を指定した場合は subkey を含むキー以下を削除
	subkey が NULL の場合、カレント の配下を削除
*/
BOOL TRegistry::DeleteChildTree(LPSTR subKey)
{
	char	buf[100];
	BOOL	ret = TRUE;

	if (subKey != NULL && OpenKey(subKey) != TRUE)
		return	FALSE;

	while (EnumKey(0, buf, sizeof(buf)))
	{
		if ((ret = DeleteChildTree(buf)) != TRUE)
			break;
	}
	if (subKey != NULL)
	{
		CloseKey();
		ret = DeleteKey(subKey) ? ret : FALSE;
	}
	else {
		while (EnumValue(0, buf, sizeof(buf)))
		{
			if (DeleteValue(buf) != TRUE)
			{
				ret = FALSE;
				break;
			}
		}
	}
	return	ret;
}
示例#12
0
// Restores a saved registry tree from the specified file to the specified key position
bool RegKey::RestoreRegistry(LPCTSTR pszFileName, LPCTSTR pszKeyName, HKEY hBaseKey /* = HKEY_CURRENT_USER */, LPCTSTR pszMachineName /* = NULL */)
{
	if (pszFileName == NULL || pszKeyName == NULL)
	{
		iLastErrorCode_ = ERROR_BAD_ARGUMENTS;
		return false;
	}

	CloseKey(); // Close current active key and base key if remote

	// Open the key
	if (!OpenKey(pszKeyName, true, hBaseKey, pszMachineName))
		return false;

	LONG lRetValue = RegRestoreKey(hTheKey_, pszFileName, REG_OPTION_NON_VOLATILE);
	if (lRetValue == ERROR_CALL_NOT_IMPLEMENTED) // NT ONLY
	{
		iLastErrorCode_ = ERROR_CALL_NOT_IMPLEMENTED;
		return false;
	}

	if (lRetValue != ERROR_SUCCESS)
	{
		iLastErrorCode_ = GetLastError();
		return false;
	}

	iLastErrorCode_ = ERROR_SUCCESS;
	return true;
}
示例#13
0
// Saves a registry tree into the specified file/path from the specified key position
bool RegKey::SaveRegistry(LPCTSTR pszFileName, LPCTSTR pszKeyName, HKEY hBaseKey /* = HKEY_CURRENT_USER */, LPCTSTR pszMachineName /* = NULL */)
{
	if (pszFileName == NULL || pszKeyName == NULL)
	{
		iLastErrorCode_ = ERROR_BAD_ARGUMENTS;
		return false;
	}

	CloseKey(); // Close current active key and base key if remote

	// Open the key
	if (!OpenKey(pszKeyName, false, hBaseKey, pszMachineName))
		return false;

	LONG lRetValue = RegSaveKey(hTheKey_, pszFileName, NULL);

	if (lRetValue == ERROR_ALREADY_EXISTS || lRetValue == ERROR_REGISTRY_IO_FAILED) // Win NT / Win 95
	{
		iLastErrorCode_ = ERROR_ALREADY_EXISTS;
		return false;
	}

	if (lRetValue != ERROR_SUCCESS)
	{
		iLastErrorCode_ = GetLastError();
		return false;
	}

	iLastErrorCode_ = ERROR_SUCCESS;
	return true;
}
示例#14
0
void TRegistry::ChangeTopKey(HKEY top_key)
{
	while (openCnt > 0)
		CloseKey();

	topKey = top_key;
}
示例#15
0
////////////////////////////////////////////////////////////////////////////////////////////////
// Create a registry key
////////////////////////////////////////////////////////////////////////////////////////////////
void CRegistry::CreateKey(HKEY MainKey, LPCTSTR SubKey)
{
	HKEY hKey = NULL;
	DWORD Disposition = 0;

	RegCreateKeyEx(MainKey, SubKey, 0L, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hKey, &Disposition);
	CloseKey(hKey);
}
示例#16
0
layer_c::~layer_c()
{
  DeleteValue(value);
  if (strlen(data) > 0) {
    SetValue(value,data);
  }
  CloseKey();
}
示例#17
0
bool RegUtils::HaveWriteAccessToKey(const HKEY& hRootKey, const CStdString& sSubKey)
{
	HKEY hKey;
	if (RegOpenKeyEx(hRootKey, sSubKey, 0, KEY_WRITE, &hKey)!=ERROR_SUCCESS)
		return false;

	CloseKey(hKey);
	return true;
}
示例#18
0
bool RegUtils::CreateKey(const HKEY& hRootKey, const CStdString& sName)
{
	HKEY hKey;
	if (::RegCreateKey(hRootKey, sName.c_str(), &hKey) == ERROR_SUCCESS)
	{
		return CloseKey(hKey);
	}
	return false;
}
示例#19
0
bool RegUtils::SetRegStringValue(HKEY hKeyRoot, CStdString sSubKey, CStdString sValueName, CStdString sValue)
{
	HKEY hKey;
	if (RegOpenKeyEx(hKeyRoot, sSubKey, 0, KEY_WRITE, &hKey) != ERROR_SUCCESS)
	{
		return false;
	}

	if (RegSetValueEx(hKey, sValueName, 0, REG_SZ, (BYTE*)sValue.GetBuffer(), (DWORD)sValue.length()*sizeof(TCHAR)) != ERROR_SUCCESS)
	{
		sValue.ReleaseBuffer();
		CloseKey(hKey);
		return false;
	}
	sValue.ReleaseBuffer();
	CloseKey(hKey);

	return true;
}
示例#20
0
CStdString RegUtils::GetStringValueFromRegistry(const HKEY& hKeyRoot, const CStdString& sSubKey, const CStdString& sValueName)
{
	HKEY hKey;
	if (RegOpenKeyEx(hKeyRoot, sSubKey, 0, KEY_READ, &hKey) != ERROR_SUCCESS)
	{
		return _T("");
	}

	CStdString sValue = GetStringValueFromRegistry(hKey, sValueName);
	CloseKey(hKey);
	return sValue;
}
示例#21
0
文件: registry.cpp 项目: hjgode/c00p
//RegReadDword
int RegReadDword(TCHAR *valuename, DWORD *value)
{
	static DWORD dwResult;
	LONG rc;
	DWORD dwType=REG_DWORD;
	DWORD dwSize=sizeof(DWORD);
	if (g_hkey==NULL)
		rc = OpenKey();
	if (g_hkey != NULL)
	{
		rc = RegQueryValueEx(g_hkey, valuename, NULL, &dwType, (LPBYTE) value, &dwSize);
		if (rc == ERROR_SUCCESS)
		{
			CloseKey();
			//*value = dwResult;
			return rc;
		}
	}
	CloseKey();
	return rc;
}
示例#22
0
文件: registry.cpp 项目: hjgode/c00p
int RegReadByte(TCHAR *valuename, byte *value)
{
	static byte dwResult;
	LONG rc;
	DWORD dwType=REG_BINARY;
	DWORD dwSize=sizeof(byte);
	if (g_hkey==NULL)
		rc = OpenKey();
	if (g_hkey != NULL)
	{
		
		rc = RegQueryValueEx(g_hkey, valuename, NULL, &dwType, &dwResult, &dwSize);
		if (rc == ERROR_SUCCESS)
		{
			CloseKey();
			*value = dwResult;
			return rc;
		}
	}
	CloseKey();
	return rc;
}
示例#23
0
文件: fhoreg.cpp 项目: Slesa/launchy
QString FhoReg::GetKeyDefaultValue(HKEY parentKey, QString &parentSubKeyName) {
	HKEY k = OpenKey(parentKey, parentSubKeyName, KEY_QUERY_VALUE);

	QString value;

	if (k != 0) {
		value = GetKeyDefaultValue(k);

		CloseKey(k);
	}

	return value;
}
示例#24
0
void TRegistry::SetRootKey(HKEY ARootKey)
{
  if (FRootKey != ARootKey)
  {
    if (FCloseRootKey)
    {
      RegCloseKey(GetRootKey());
      FCloseRootKey = false;
    }
    FRootKey = ARootKey;
    CloseKey();
  }
}
示例#25
0
BOOL TRegistry::ChangeApp(LPCSTR company, LPSTR appName)
{
	while (openCnt > 0)
		CloseKey();

	topKey = HKEY_CURRENT_USER;

	char	buf[100];
	wsprintf(buf, "software\\%s", company);
	if (appName != NULL && *appName)
		wsprintf(buf + strlen(buf), "\\%s", appName);

	return	CreateKey(buf);
}
示例#26
0
bool RegUtils::DeleteValue(HKEY hRootKey, CStdString sSubKey, CStdString sValueName)
{
	HKEY hKey;
	if (RegOpenKeyEx(hRootKey, sSubKey, 0, KEY_WRITE, &hKey)!=ERROR_SUCCESS)
		return false;

	LONG lRetCode = RegDeleteValue(hKey, sValueName);
	CloseKey(hKey);

	if (lRetCode == ERROR_SUCCESS)
		return true;

	return !IsRegValuePresent(hRootKey, sSubKey, sValueName);
}
示例#27
0
void SettingsXML::CloseStorage()
{
	HRESULT hr = S_OK;
	HANDLE hFile = NULL;
	bool bCanSave = false;

	CloseKey();

	if (mb_Modified && mp_File)
	{
		// Путь к файлу проинициализирован в OpenKey
		_ASSERTE(m_Storage.pszFile && *m_Storage.pszFile);
		LPCWSTR pszXmlFile = m_Storage.pszFile;

		if (pszXmlFile)
		{
			hFile = CreateFile(pszXmlFile, GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE,
			                   NULL, OPEN_EXISTING, 0, 0);

			// XML-файл отсутсвует, или ошибка доступа
			if (hFile == INVALID_HANDLE_VALUE)
			{
				DWORD dwErrCode = GetLastError();
				wchar_t szErr[MAX_PATH*2];
				_wsprintf(szErr, SKIPLEN(countof(szErr)) L"Can't open file for writing!\n%s\nErrCode=0x%08X",
				          pszXmlFile, dwErrCode);
				MBoxA(szErr);
			}
			else
			{
				CloseHandle(hFile); hFile = NULL;
				bCanSave = true;
			}

			if (bCanSave)
			{
				VARIANT vt; vt.vt = VT_BSTR; vt.bstrVal = ::SysAllocString(pszXmlFile);
				hr = mp_File->save(vt);
				VariantClear(&vt);
			}
		}
	}

	SafeRelease(mp_File);

	mb_Modified = false;
	mb_DataChanged = false;
	mb_Empty = false;
	mn_access = 0;
}
示例#28
0
文件: registry.cpp 项目: hjgode/c00p
//RegReadStr
int RegReadStr(TCHAR *valuename, TCHAR *value)
{
	static TCHAR szStr[MAX_PATH+1];
	LONG rc;
	DWORD dwType=REG_SZ;
	DWORD dwSize=0;
	if (g_hkey == NULL)
	{
		if (OpenKey()==0) //use default g_hkey
		{
			dwSize = sizeof(szStr) * sizeof(TCHAR);
			rc = RegQueryValueEx(g_hkey, valuename, NULL, &dwType, (LPBYTE)szStr, &dwSize);
			if (rc == ERROR_SUCCESS)
			{
				CloseKey();
				wcscpy(value, szStr);
				return 0;
			}
		}
	}
	else
	{
		//use already opened g_hkey
		dwSize = sizeof(szStr) * sizeof(TCHAR);
		rc = RegQueryValueEx(g_hkey, valuename, NULL, &dwType, (LPBYTE)szStr, &dwSize);
		if (rc == ERROR_SUCCESS)
		{
			CloseKey();
			wcscpy(value, szStr);
			return 0;
		}
	}

	wcscpy(value, L"");
	CloseKey();
	return -1;
}
示例#29
0
文件: fhoreg.cpp 项目: Slesa/launchy
QStringList* FhoReg::EnumSubKeys(HKEY parentKey, QString &parentSubKeyName) {
	QStringList *resultList;

	HKEY k = OpenKey(parentKey, parentSubKeyName, KEY_ENUMERATE_SUB_KEYS);
	
	if (k != 0) {
		resultList = EnumSubKeys(k);

		CloseKey(k);
	} else {
		resultList = new QStringList();
	}

	return resultList;
}
示例#30
0
bool RegUtils::RecursiveCopyKey(const HKEY& hRootHive, const CStdString& sSourceKeyName, const CStdString& sTargetKeyName)
{
	HKEY hSourceKey = NULL;
	HKEY hTargetKey = NULL;
	long lRetVal	= 0;
	bool bRet		= true;

	if (sSourceKeyName.IsEmpty() || sTargetKeyName.IsEmpty())
	{
		LOG_WS_ERROR(_T("Empty source or target key specified"));
		return false;
	}

	if (((lRetVal = RegOpenKey(hRootHive, sSourceKeyName, &hSourceKey)) != ERROR_SUCCESS))
	{
		CStdString sErr;
		sErr.Format(_T("Failed to open source key %s, error %d"), sSourceKeyName.c_str(), lRetVal);
		LOG_WS_ERROR(sErr.c_str());
		return false;
	}

	CopyKey(hRootHive, hSourceKey, sTargetKeyName);

	TCHAR szKeyName[MAX_PATH];

	for (DWORD i = 0, retcode = ERROR_SUCCESS; retcode == ERROR_SUCCESS; ++i)
	{
		DWORD dwBuffSize = MAX_PATH;
		ZeroMemory(szKeyName, MAX_PATH);

		retcode = RegEnumKeyEx(hSourceKey, i, szKeyName, &dwBuffSize, NULL, NULL, NULL, NULL);
		if (retcode == ERROR_SUCCESS)
		{
			RecursiveCopyKey(hRootHive, sSourceKeyName + _T("\\") + szKeyName, sTargetKeyName + _T("\\") + szKeyName);
		}
		else if (retcode != ERROR_NO_MORE_ITEMS)
		{
			CStdString sErr;
			sErr.Format(_T("Failed to enumerate source key %s, error %d"), sSourceKeyName.c_str(), retcode);
			LOG_WS_ERROR(sErr.c_str());
			bRet = false;
		}
	}
	
	CloseKey(hSourceKey);

	return bRet;
}