global.cpp

一个管理ie的软件

	WritePrivateProfileString(APP_NAME, _T("ClearAtExit"), sTemp, pszFilePath);

	sTemp.Format(_T("%ld"), m_lWindowSizeThreshold);
	WritePrivateProfileString(APP_NAME, _T("WindowSizeThreshold"), sTemp, pszFilePath);

	sTemp.Format(_T("%ld"), m_nKeyDisable);
	WritePrivateProfileString(APP_NAME, _T("KeyDisable"), sTemp, pszFilePath);

	sTemp.Format(_T("%ld"), m_nKeyHideIE);
	WritePrivateProfileString(APP_NAME, _T("KeyHideIE"), sTemp, pszFilePath);

	sTemp.Format(_T("%ld"), m_nKeyShowIE);
	WritePrivateProfileString(APP_NAME, _T("KeyShowIE"), sTemp, pszFilePath);
}

BOOL CGlobal::ReadFilter(LPCTSTR pszFilePath, CString* psErrorMsg)
{
	BOOL bRet = FALSE;
	HANDLE hFile;
	DWORD dwSize;
	DWORD dwRead;
	CString sFileContent;
	CString sErrorMsg;
	LPBYTE pFileBuffer = NULL;

	if (!pszFilePath)
	{
		return bRet;
	}

	//open file
	if ((hFile = CreateFile(pszFilePath, GENERIC_READ, FILE_SHARE_READ, NULL, 
		OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL )) == INVALID_HANDLE_VALUE)
	{
		GetErrorMessage(GetLastError(), &sErrorMsg);
		goto error;
	}

	//read file
	dwSize = GetFileSize(hFile, NULL);
	try
	{
		pFileBuffer = (LPBYTE)sFileContent.GetBuffer(dwSize + sizeof(TCHAR));
	}
	catch (...)
	{
		sErrorMsg.LoadString(IDS_NOT_ENOUGH_MEMORY);
		goto error;
	}

	if (! ReadFile(hFile, pFileBuffer, dwSize, &dwRead, NULL ) || 
		dwRead != dwSize )
	{
		sFileContent.ReleaseBuffer(0);
		CloseHandle(hFile);

		GetErrorMessage(GetLastError(), &sErrorMsg);
		goto error;
	}
	CloseHandle(hFile);
	pFileBuffer[dwSize] = _T('\0');

	m_lockUrlBlacklist.WriteLock();
	LoadFilter((LPTSTR)pFileBuffer, &m_mapUrlBlacklist, PT_URL_BLACKLIST);
	m_lockUrlBlacklist.WriteUnlock();

	m_lockUrlExclusion.WriteLock();
	LoadFilter((LPTSTR)pFileBuffer, &m_mapUrlExclusion, PT_URL_EXCLUSION);
	m_lockUrlExclusion.WriteUnlock();

	m_lockTitleBlacklist.WriteLock();
	LoadFilter((LPTSTR)pFileBuffer, &m_mapTitleBlacklist, PT_TITLE_BLACKLIST);
	m_lockTitleBlacklist.WriteUnlock();

	m_lockTitleExclusion.WriteLock();
	LoadFilter((LPTSTR)pFileBuffer, &m_mapTitleExclusion, PT_TITLE_EXCLUSION);
	m_lockTitleExclusion.WriteUnlock();

	sFileContent.ReleaseBuffer();

	bRet = TRUE;

error:
	if (!bRet)
	{
		if (psErrorMsg)
		{
			*psErrorMsg = sErrorMsg;
		}
	}
	return bRet;
}

BOOL CGlobal::WriteFilter(LPCTSTR pszFilePath, CString* psErrorMsg)
{
	BOOL bRet = FALSE;
	HANDLE hFile;
	CString sErrorMsg;

	if (!pszFilePath)
	{
		return bRet;
	}

	//open file
	if ((hFile = CreateFile(pszFilePath, GENERIC_WRITE, FILE_SHARE_READ, NULL, 
		CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL )) == INVALID_HANDLE_VALUE)
	{
		GetErrorMessage(GetLastError(), &sErrorMsg);
		goto error;
	}

	m_lockUrlBlacklist.ReadLock();
	SaveFilter(hFile, &m_mapUrlBlacklist, PT_URL_BLACKLIST);
	m_lockUrlBlacklist.ReadUnlock();

	m_lockUrlExclusion.ReadLock();
	SaveFilter(hFile, &m_mapUrlExclusion, PT_URL_EXCLUSION);
	m_lockUrlExclusion.ReadUnlock();

	m_lockTitleBlacklist.ReadLock();
	SaveFilter(hFile, &m_mapTitleBlacklist, PT_TITLE_BLACKLIST);
	m_lockTitleBlacklist.ReadUnlock();

	m_lockTitleExclusion.ReadLock();
	SaveFilter(hFile, &m_mapTitleExclusion, PT_TITLE_EXCLUSION);
	m_lockTitleExclusion.ReadUnlock();

	CloseHandle(hFile);

	bRet = TRUE;

error:
	if (!bRet)
	{
		if (psErrorMsg)
		{
			*psErrorMsg = sErrorMsg;
		}
	}
	return bRet;
}

void CGlobal::LoadFilter(LPTSTR pszData, MAP_FILTER* pmapFilter, 
						   LPCTSTR pszType)
{
	USES_CONVERSION;
	LPTSTR pLineBegin;
	LPTSTR pLineEnd;
	BOOL bEnable;

	pLineBegin = _tcsstr(pszData, pszType);
	if (! pLineBegin)
	{
		return;
	}

	//goto next line 
	pLineEnd = _tcsstr(pLineBegin, NEW_LINE);
	if (!pLineEnd)
	{
		return;
	}
	pLineBegin = pLineEnd + 2;

	while (TRUE)
	{
		pLineEnd = _tcsstr(pLineBegin, NEW_LINE);
		if (!pLineEnd || pLineEnd - pLineBegin < 3)
		{
			break;
		}

		if (*pLineBegin == _T('1'))
		{
			bEnable = TRUE;
		}
		else if (*pLineBegin == _T('0'))
		{
			bEnable = FALSE;
		}
		else
		{
			break;
		}

		pLineBegin += 2;
		*pLineEnd = _T('\0');
		pmapFilter->insert(MAP_FILTER::value_type(pLineBegin, bEnable));

		*pLineEnd = _T('\r');
		pLineBegin = pLineEnd + 2;
	}

}

void CGlobal::SaveFilter(HANDLE hFile, MAP_FILTER* pmapFilter, 
						   LPCTSTR pszType)
{
	MAP_FILTER::iterator theFilter;
	DWORD dwSize;
	CString sLine;

	sLine = pszType;
	sLine += NEW_LINE;
	WriteFile(hFile, sLine, sLine.GetLength(), &dwSize, NULL);

	for (theFilter=pmapFilter->begin(); 
		theFilter!=pmapFilter->end(); theFilter++)
	{
		sLine.Format(_T("%d %s")NEW_LINE, theFilter->second ? 1 : 0,
			theFilter->first);
		WriteFile(hFile, sLine, sLine.GetLength(), &dwSize, NULL);
	}
}

BOOL CGlobal::AddFilter(MAP_FILTER* pmapFilter, CRWLock* pLock, 
						 LPCTSTR pszFilter, BOOL bEnable)
{
	std::pair<MAP_FILTER::iterator, bool> pairRet;

	pLock->WriteLock();
	pairRet = pmapFilter->insert(MAP_FILTER::value_type(pszFilter, bEnable));
	pLock->WriteUnlock();
	if (! pairRet.second)
	{
		return FALSE;
	}
	return TRUE;
}

BOOL CGlobal::RemoveFilter(MAP_FILTER* pmapFilter, CRWLock* pLock, 
							LPCTSTR pszFilter)
{
	BOOL bRet = FALSE;
	MAP_FILTER::iterator theFilter;
	pLock->WriteLock();
	theFilter = pmapFilter->find(pszFilter);
	if (theFilter != pmapFilter->end())
	{
		bRet = TRUE;
		pmapFilter->erase(theFilter);
	}
	pLock->WriteUnlock();
	return bRet;
}

BOOL CGlobal::ChangeFilter(MAP_FILTER* pmapFilter, CRWLock* pLock, 
						 LPCTSTR pszFilter, BOOL bEnable)
{
	BOOL bRet = FALSE;
	MAP_FILTER::iterator theFilter;
	pLock->WriteLock();
	theFilter = pmapFilter->find(pszFilter);
	if (theFilter != pmapFilter->end())
	{
		bRet = TRUE;
		theFilter->second = bEnable;
	}
	pLock->WriteUnlock();
	return bRet;
}

BOOL CGlobal::SaveLog(LPCTSTR pszFilePath, CString* psErrorMsg)
{
	BOOL bRet = FALSE;
	VEC_POPUP_LOG::iterator theLog;
	HANDLE hFile;
	CPopupLog* pLog;
	CString sErrorMsg;
	CString sLog;
	CString sType[3];
	DWORD dwSize;

	if (!pszFilePath)
	{
		return bRet;
	}

	//open file
	if ((hFile = CreateFile(pszFilePath, GENERIC_WRITE, FILE_SHARE_READ, NULL, 
		CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL )) == INVALID_HANDLE_VALUE)
	{
		GetErrorMessage(GetLastError(), &sErrorMsg);
		goto error;
	}

	sType[0].LoadString(IDS_KILLED_BY_SIZE);
	sType[1].LoadString(IDS_KILLED_BY_TITLE);
	sType[2].LoadString(IDS_KILLED_BY_URL);

	m_lockPopupLog.ReadLock();
	for (theLog=m_vecPopupLog.begin(); theLog!=m_vecPopupLog.end(); theLog++)
	{
		pLog = *theLog;
		sLog.Format(_T("%d-%02d-%02d %02d:%02d:%02d %s %s %s %s\r\n"),
			pLog->m_timeOccur.wYear, pLog->m_timeOccur.wMonth,
			pLog->m_timeOccur.wDay, pLog->m_timeOccur.wHour,
			pLog->m_timeOccur.wMinute, pLog->m_timeOccur.wSecond,
			pLog->m_sTitle, pLog->m_sUrl, sType[pLog->m_lKillType],
			pLog->m_sFilter);

		WriteFile(hFile, sLog, sLog.GetLength(), &dwSize, NULL);
	}
	m_lockPopupLog.ReadUnlock();

	CloseHandle(hFile);

	bRet = TRUE;

error:
	if (!bRet)
	{
		if (psErrorMsg)
		{
			*psErrorMsg = sErrorMsg;
		}
	}
	return bRet;
}

void CGlobal::ClearLog()
{
	VEC_POPUP_LOG::iterator theLog;

	m_lockPopupLog.WriteLock();
	for (theLog=m_vecPopupLog.begin(); theLog!=m_vecPopupLog.end(); theLog++)
	{
		delete *theLog;
	}
	m_vecPopupLog.clear();
	m_lockPopupLog.WriteUnlock();
}

void CGlobal::ClearHistory()
{
	TCHAR szPath[MAX_PATH];
	CString sKey;
	DWORD dwRet;
	HRESULT hr;

	if (m_dwClearSettings & CLEAR_CACHE)
	{
		DeleteUrlCache(File);
		if (SHGetSpecialFolderPath(NULL, szPath, CSIDL_INTERNET_CACHE, FALSE))
		{
			EmptyDirectory(szPath);
		}
	}

	if (m_dwClearSettings & CLEAR_COOKIES)
	{
		DeleteUrlCache(Cookie);
		if (SHGetSpecialFolderPath(NULL, szPath, CSIDL_COOKIES, FALSE))
		{
			EmptyDirectory(szPath);
		}
	}

	if (m_dwClearSettings & CLEAR_TYPED_URL)
	{
		SHDeleteKey(HKEY_CURRENT_USER, 
			_T("Software\\Microsoft\\Internet Explorer\\TypedURLs"));
	}

	if (m_dwClearSettings & CLEAR_AUTOCOMPLETE_FORMS)
	{
		if (IsWindows2k() || IsWindowsNT())
		{
			CString sBaseKey;
			SECURITY_DESCRIPTOR NewSD;
			BYTE* pOldSD;
			PACL pDacl = NULL;
			PSID pSid = NULL;
			TCHAR szSid[256];
			if (GetUserSid(&pSid))
			{
				//get the hiden key name
				GetSidString(pSid, szSid);

				sKey = _T("Software\\Microsoft\\Protected Storage System Provider\\");
				sKey += szSid;

				//get old SD
				sBaseKey = sKey;
				GetOldSD(HKEY_CURRENT_USER, sBaseKey, &pOldSD);

				//set new SD and then clear
				if (CreateNewSD(pSid, &NewSD, &pDacl))
				{
					RegSetPrivilege(HKEY_CURRENT_USER, sKey, &NewSD, FALSE);

					sKey += _T("\\Data");
					RegSetPrivilege(HKEY_CURRENT_USER, sKey, &NewSD, FALSE);

					sKey += _T("\\e161255a-37c3-11d2-bcaa-00c04fd929db");
					RegSetPrivilege(HKEY_CURRENT_USER, sKey, &NewSD, TRUE);

					dwRet = SHDeleteKey(HKEY_CURRENT_USER, sKey);
				}

				if (pDacl != NULL)
					HeapFree(GetProcessHeap(), 0, pDacl);

				//restore old SD
				if (pOldSD)
				{
					RegSetPrivilege(HKEY_CURRENT_USER, sBaseKey, 
						(SECURITY_DESCRIPTOR*)pOldSD, FALSE);
					delete pOldSD;
				}
			}
			if (pSid)
				HeapFree(GetProcessHeap(), 0, pSid);
		}

		//win9x
		DWORD dwSize = MAX_PATH;
		TCHAR szUserName[MAX_PATH];
		GetUserName(szUserName, &dwSize);

		sKey = _T("Software\\Microsoft\\Protected Storage System Provider\\");
		sKey += szUserName;
		sKey += _T("\\Data\\e161255a-37c3-11d2-bcaa-00c04fd929db");
		dwRet = SHDeleteKey(HKEY_LOCAL_MACHINE, sKey);
	}

	if (m_dwClearSettings & CLEAR_AUTOCOMPLETE_PWDS)
	{
		SHDeleteKey(HKEY_CURRENT_USER, 
			_T("Software\\Microsoft\\Internet Explorer\\IntelliForms"));
	}

	if (m_dwClearSettings & CLEAR_FAVORITES)
	{
		if (SHGetSpecialFolderPath(NULL, szPath, CSIDL_FAVORITES, FALSE))
		{
			EmptyDirectory(szPath);
		}
	}

	if (m_dwClearSettings & CLEAR_RAS_AUTODIAL)
	{
		SHDeleteKey(HKEY_CURRENT_USER, 
			_T("Software\\Microsoft\\RAS Autodial\\Addresses"));
	}