//=======================================================================
//
//  Copyright (c) 1998-2000 Microsoft Corporation.  All Rights Reserved.
//
//  File:   History.CPP
//	Author:	Charles Ma, 10/13/2000
//
//	Revision History:
//
//
//
//  Description:
//
//      Class to handle history log
//
//=======================================================================


#include "iuengine.h"
#include <iucommon.h>
#include <fileutil.h>
#include <StringUtil.h>
#include <shlwapi.h>	// for PathAppend() API
#include "history.h"

const TCHAR C_V3_LOG_FILE[]			= _T("wuhistv3.log");
const TCHAR C_LOG_FILE[]			= _T("iuhist.xml");
const TCHAR C_LOG_FILE_CORP[]		= _T("iuhist_catalog.xml");
const TCHAR C_LOG_FILE_CORP_ADMIN[]	= _T("iuhist_catalogAdmin.xml");
const OLECHAR	C_IU_CORP_SITE[]	= L"IU_CORP_SITE";
const OLECHAR	C_HISTORICALSPEED[]	= L"GetHistoricalSpeed";

//
// we use a global mutex name to let all clients, including services
// on terminal servers gain exclusive access for updating history on disk
//
#if defined(UNICODE) || defined(_UNICODE)
const TCHAR C_MUTEX_NAME[] = _T("Global\\6D7495AB-399E-4768-89CC-9444202E8412");
#else
const TCHAR C_MUTEX_NAME[] = _T("6D7495AB-399E-4768-89CC-9444202E8412");
#endif

#define CanSaveHistory					(NULL != m_hMutex)
#define ReturnFailedAllocSetHrMsg(x)	{if (NULL == (x)) {hr = E_OUTOFMEMORY; LOG_ErrorMsg(hr); return hr;}}



CIUHistory::CIUHistory()
 : m_pszDownloadBasePath(NULL),
   m_bstrCurrentClientName(NULL)
{
	LOG_Block("CIUHisotry::CIUHistory()");

	m_pxmlExisting = new CXmlItems(TRUE);
	m_pxmlDownload = new CXmlItems(FALSE);
	m_pxmlInstall = new CXmlItems(FALSE);

	m_hMutex = CreateMutex(
						   NULL,	// no security descriptor
						   FALSE,	// mutex object not owned, yet
						   C_MUTEX_NAME
						   );
	if (NULL == m_hMutex)
	{
		DWORD dwErr = GetLastError();
		LOG_ErrorMsg(dwErr);
		m_ErrorCode = HRESULT_FROM_WIN32(GetLastError());
	}
	else
	{
		LOG_Out(_T("Mutex created okay"));
		m_ErrorCode = S_OK;
	}

	m_fSavePending = FALSE;
}



CIUHistory::~CIUHistory()
{
	if (m_fSavePending)
	{
		SaveHistoryToDisk();
	}

	if (CanSaveHistory)
	{
		CloseHandle(m_hMutex);
	}

	if (NULL != m_pxmlExisting)
	{
		delete m_pxmlExisting;
	}

	if (NULL != m_pxmlDownload)
	{
		delete m_pxmlDownload;
	}

	if (NULL != m_pxmlInstall)
	{
		delete m_pxmlInstall;
	}

	SafeHeapFree(m_pszDownloadBasePath);
	SysFreeString(m_bstrCurrentClientName);
}



// ------------------------------------------------------------------
//
// public function SetDownloadBasePath()
//	this function should be called before AddHistoryItemDownloadStatus()
//	for corporate case to set the download path that the user has input,
//	so that we know where to save the history log.
//	
// ------------------------------------------------------------------
HRESULT CIUHistory::SetDownloadBasePath(LPCTSTR pszDownloadedBasePath)
{
	LOG_Block("SetDownloadBasePath()");

	if (NULL != pszDownloadedBasePath)
	{
        HRESULT hr = S_OK;
	    
		if (NULL != m_pszDownloadBasePath)
		{
			//
			// most likely user called SetDownloadBasePath() at least twice
			// within the same instance of this class
			//
			SafeHeapFree(m_pszDownloadBasePath);
		}

		
		m_pszDownloadBasePath = (LPTSTR)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, MAX_PATH * sizeof (TCHAR));
		if (NULL == m_pszDownloadBasePath)
		{
			LOG_ErrorMsg(E_OUTOFMEMORY);
			return E_OUTOFMEMORY;
		}

		hr = StringCchCopyEx(m_pszDownloadBasePath, MAX_PATH,  pszDownloadedBasePath,
		                     NULL, NULL, MISTSAFE_STRING_FLAGS);
		if (FAILED(hr))
		{
		    SafeHeapFree(m_pszDownloadBasePath);
		    LOG_ErrorMsg(hr);
		    return hr;
		}
		
		BSTR bstrCorpSite = SysAllocString(C_IU_CORP_SITE);
		SetClientName(bstrCorpSite);
		SafeSysFreeString(bstrCorpSite);
	}
	return S_OK;
}
	

	
// ------------------------------------------------------------------
//
// public function AddHistoryItemDownloadStatus()
//	this function should be called when you want to record the
//	download status of this item. A new history item will be
//	added to the history file
//	
// ------------------------------------------------------------------
HRESULT CIUHistory::AddHistoryItemDownloadStatus(
			CXmlCatalog* pCatalog, 
			HANDLE_NODE hCatalogItem,	// a handle points to node in catalog
			_HISTORY_STATUS enDownloadStatus,
			LPCTSTR lpcszDownloadedTo,
			LPCTSTR lpcszClient,
			DWORD dwErrorCode /*= 0*/
)
{
    LOG_Block("AddHistoryItemDownloadStatus()");

	HRESULT	hr	= S_OK;

    HANDLE_NODE hDownloadItem = HANDLE_NODE_INVALID;

	ReturnFailedAllocSetHrMsg(m_pxmlDownload);

	if (NULL == lpcszClient || _T('\0') == lpcszClient[0])
	{
		hr = E_INVALIDARG;
		LOG_ErrorMsg(hr);
		return hr;
	}

	if (!CanSaveHistory)
	{
		return m_ErrorCode;
	}

	BSTR bstrDownloadedTo = NULL;
	BSTR bstrClient = T2BSTR(lpcszClient);
	BSTR bstrDownloadStatus = GetBSTRStatus(enDownloadStatus);

	//
	// append a new node
	//
	hr = m_pxmlDownload->AddItem(pCatalog, hCatalogItem, &hDownloadItem);
	if (SUCCEEDED(hr))
	{
		m_pxmlDownload->AddTimeStamp(hDownloadItem);
		if (0 != dwErrorCode)
		{
			m_pxmlDownload->AddDownloadStatus(hDownloadItem, bstrDownloadStatus, dwErrorCode);
		}
		else
		{
			m_pxmlDownload->AddDownloadStatus(hDownloadItem, bstrDownloadStatus);
		}

		bstrDownloadedTo = T2BSTR(lpcszDownloadedTo);
		m_pxmlDownload->AddDownloadPath(hDownloadItem, bstrDownloadedTo);
		m_pxmlDownload->AddClientInfo(hDownloadItem, bstrClient);
		m_pxmlDownload->CloseItem(hDownloadItem);

		m_fSavePending = TRUE;
	}

	SetClientName(bstrClient);
	SysFreeString(bstrDownloadedTo);
	SysFreeString(bstrClient);
	SysFreeString(bstrDownloadStatus);
	return hr;
}
			


// ------------------------------------------------------------------
//
// public function AddHistoryItemInstallStatus()
//	this function should be called when you want to record the
//	install status of this item. This function will go to the
//	existing history tree and find the first item that matches
//	the identity of hCatalogItem, and assume that one as 
//	the one you want to modify the install status
//	
//
// return:
//		HRESULT - S_OK if succeeded
//				- E_HANDLE if can't find hCatalogItem from 
//				  the current history log tree
//				- or other HRESULT error
//
// ------------------------------------------------------------------
HRESULT CIUHistory::AddHistoryItemInstallStatus(
			CXmlCatalog* pCatalog, 
			HANDLE_NODE hCatalogItem,	// a handle points to node in catalog
			_HISTORY_STATUS enInstallStatus,
			LPCTSTR lpcszClient,
			BOOL fNeedsReboot,
			DWORD dwErrorCode /*= 0*/
)
{
    LOG_Block("AddHistoryItemInstallStatus()");

	HRESULT	hr	= S_OK;

    HANDLE_NODE hInstallItem = HANDLE_NODE_INVALID;

	ReturnFailedAllocSetHrMsg(m_pxmlInstall);

	if (!CanSaveHistory)
	{
		return m_ErrorCode;
	}

	BSTR bstrClient = NULL;
	BSTR bstrInstallStatus = GetBSTRStatus(enInstallStatus);
	//
	// append a new node
	//
	hr = m_pxmlInstall->AddItem(pCatalog, hCatalogItem, &hInstallItem);
	if (SUCCEEDED(hr))
	{
		m_pxmlInstall->AddTimeStamp(hInstallItem);
		if (0 != dwErrorCode)
		{
			m_pxmlInstall->AddInstallStatus(hInstallItem, bstrInstallStatus, fNeedsReboot, dwErrorCode);
		}
		else
		{
			m_pxmlInstall->AddInstallStatus(hInstallItem, bstrInstallStatus, fNeedsReboot);
		}
		bstrClient = T2BSTR(lpcszClient);
		m_pxmlInstall->AddClientInfo(hInstallItem, bstrClient);
		m_pxmlInstall->CloseItem(hInstallItem);
	
		m_fSavePending = TRUE;
	}

	SysFreeString(bstrClient);
	SysFreeString(bstrInstallStatus);
	return hr;
}



// ------------------------------------------------------------------
//
// public function UpdateHistoryItemInstallStatus()
//	this function should be called when you want to record the
//	install status of this item. This function will go to the
//	existing history tree and find the first item that matches
//	the identity of hCatalogItem, and assume that one as 
//	the one you want to modify the install status
//	
//
// return:
//		HRESULT - S_OK if succeeded
//				- E_HANDLE if can't find hCatalogItem from 
//				  the current history log tree
//				- or other HRESULT error
//
// ------------------------------------------------------------------
HRESULT CIUHistory::UpdateHistoryItemInstallStatus(
			CXmlCatalog* pCatalog, 
			HANDLE_NODE hCatalogItem,	// a handle points to node in catalog
			_HISTORY_STATUS enInstallStatus,
			BOOL fNeedsReboot,
			DWORD dwErrorCode /*= 0*/
)
{
    LOG_Block("UpdateHistoryItemInstallStatus()");

	HRESULT	hr	= S_OK;

    HANDLE_NODE hInstallItem = HANDLE_NODE_INVALID;

	ReturnFailedAllocSetHrMsg(m_pxmlInstall);

	if (!CanSaveHistory)
	{
		return m_ErrorCode;
	}

	BSTR bstrInstallStatus = GetBSTRStatus(enInstallStatus);
	//
	// append a new node
	//
	hr = m_pxmlInstall->FindItem(pCatalog, hCatalogItem, &hInstallItem);
	if (SUCCEEDED(hr))
	{
		m_pxmlInstall->AddTimeStamp(hInstallItem);
		if (0 != dwErrorCode)
		{
			m_pxmlInstall->UpdateItemInstallStatus(hInstallItem, bstrInstallStatus, fNeedsReboot, dwErrorCode);
		}
		else
		{
			m_pxmlInstall->UpdateItemInstallStatus(hInstallItem, bstrInstallStatus, fNeedsReboot);
		}
		m_pxmlInstall->CloseItem(hInstallItem);
	
		m_fSavePending = TRUE;
	}

	SysFreeString(bstrInstallStatus);
	return hr;
}



/*
// ------------------------------------------------------------------
//
// public function RetrieveItemDownloadPath()
//	this function will go to the existing history tree and find
//  the first item that matches the identity of hCatalogItem, and
//  assume that's the one you want to retrieve the download path from
//
// return:
//		HRESULT - S_OK if succeeded
//				- E_HANDLE if can't find hCatalogItem from 
//				  the current history log tree
//				- or other HRESULT error
//
// ------------------------------------------------------------------
HRESULT CIUHistory::RetrieveItemDownloadPath(
			CXmlCatalog* pCatalog, 
			HANDLE_NODE hCatalogItem,	// a handle points to node in catalog
			BSTR* pbstrDownloadPath
)
{
	HRESULT	hr = S_OK;

	if (NULL == m_Existing.'DocumentPtr())
	{
		//
		// need to read the existing history
		//
		WaitForSingleObject(m_hMutex, INFINITE);

		hr = ReadHistoryFromDisk(NULL);
		if (FAILED(hr))
		{
			//
			// if we can't load the existing history
			// we can't do anything here
			//
			ReleaseMutex(m_hMutex);
			return hr;
		}

		ReleaseMutex(m_hMutex);
	}

	hr = m_Existing.GetItemDownloadPath(pCatalog, hCatalogItem, pbstrDownloadPath);
	return hr;
}		
*/	
			
			
// ------------------------------------------------------------------
//
// public function ReadHistoryFromDisk()
//	this function will read the history from the given file
//
// if the file path is NULL, assumes default IU log file locally
//
// ------------------------------------------------------------------
HRESULT CIUHistory::ReadHistoryFromDisk(LPCTSTR lpszLogFile, BOOL fCorpAdmin /*= FALSE*/)
{
	LOG_Block("ReadHistoryFromDisk()");

	HRESULT hr = S_OK;
	TCHAR szLogPath[MAX_PATH];

	ReturnFailedAllocSetHrMsg(m_pxmlExisting);

	//
	// check to see if we use designated path (comsumer)
	// or user-specified path (corporate)
	//
	if ((NULL == lpszLogFile || _T('\0') == lpszLogFile[0]) && !fCorpAdmin)
	{
		GetIndustryUpdateDirectory(szLogPath);
		hr = PathCchAppend(szLogPath, ARRAYSIZE(szLogPath), C_LOG_FILE);
		if (FAILED(hr))
		{
		    LOG_ErrorMsg(hr);
		    return hr;
		}
	}
	else
	{
		//
		// this is corporate case to read log file from
		// a server location
		//
		if (fCorpAdmin)
		{
			GetIndustryUpdateDirectory(szLogPath);
			hr = PathCchAppend(szLogPath, ARRAYSIZE(szLogPath), C_LOG_FILE_CORP_ADMIN);
    		if (FAILED(hr))
    		{
    		    LOG_ErrorMsg(hr);
    		    return hr;
    		}
		}
		else
		{
			hr = StringCchCopyEx(szLogPath, ARRAYSIZE(szLogPath), lpszLogFile, 
			                     NULL, NULL, MISTSAFE_STRING_FLAGS);
    		if (FAILED(hr))
    		{
    		    LOG_ErrorMsg(hr);
    		    return hr;
    		}
			
			hr = PathCchAppend(szLogPath, ARRAYSIZE(szLogPath), C_LOG_FILE_CORP);
    		if (FAILED(hr))
    		{
    		    LOG_ErrorMsg(hr);
    		    return hr;
    		}
		}
	}

	//
	// if we are not passing in the class file path buffer,
	// then update the class path buffer with this new path
	//
	if (szLogPath != m_szLogFilePath)
	{
	    hr = StringCchCopyEx(m_szLogFilePath, ARRAYSIZE(m_szLogFilePath), szLogPath,
	                         NULL, NULL, MISTSAFE_STRING_FLAGS);
	    if (FAILED(hr))
	    {
		    LOG_ErrorMsg(hr);
		    return hr;
	    }
	}

	//
	// load the xml file
	//
	m_pxmlExisting->Clear();
	
	BSTR bstrLogPath = T2BSTR(szLogPath);
	hr = m_pxmlExisting->LoadXMLDocumentFile(bstrLogPath);
	SysFreeString(bstrLogPath);
		
	return hr;
}



// ------------------------------------------------------------------
//
// public function SaveHistoryToDisk()
//	this function will re-read the history in exclusive mode, and
//	merge the newly added data to the tree (so we don't overwrite
//	new changes made by other instances of this control) and
//	write it back 
//
// ------------------------------------------------------------------
HRESULT CIUHistory::SaveHistoryToDisk(void)
{
	LOG_Block("SaveHistoryToDisk()");

	HRESULT	hr = S_OK, hr2 = S_OK;
	BSTR bstrLogFilePath = NULL;

	ReturnFailedAllocSetHrMsg(m_pxmlExisting);
	ReturnFailedAllocSetHrMsg(m_pxmlDownload);
	ReturnFailedAllocSetHrMsg(m_pxmlInstall);

	if (!CanSaveHistory)
	{
		return m_ErrorCode;
	}

	if (!m_fSavePending)
	{
		//
		// nothing to save
		//
		return S_OK;
	}

	//
	// first, we need to gain exclusive access
	// to the log file before reading it
	//
	// since this is not a long process, so I 
	// don't think we need to take care of WM_QUIT
	// message
	//
	WaitForSingleObject(m_hMutex, INFINITE);

	BSTR bstrCorpSite = SysAllocString(C_IU_CORP_SITE);
	ReturnFailedAllocSetHrMsg(bstrCorpSite);

	if (!CompareBSTRsEqual(bstrCorpSite, m_bstrCurrentClientName))
	{
		SysFreeString(bstrCorpSite);
		//
		// re-read history file
		//
		hr = ReadHistoryFromDisk(NULL);

		//
		// comment out...if we get failure on reading, 
		// we recreate a new history file later when saving.
		//
		//if (FAILED(hr))
		//{
		//	//
		//	// if we can't load the existing history
		//	// we can't do anything here
		//	//
		//	ReleaseMutex(m_hMutex);
		//	return hr;
		//}

		//
		// merge changes:
		// 
		// loop through m_Download, insert each node to top of m_Existing
		//
		hr = m_pxmlExisting->MergeItemDownloaded(m_pxmlDownload);
		if (FAILED(hr))
		{
			ReleaseMutex(m_hMutex);
			return hr;
		}

		//
		// loop through m_Install, for each node in m_Install
		// find the one in m_Existing, update install status
		//
		hr = m_pxmlExisting->UpdateItemInstalled(m_pxmlInstall);
		if (FAILED(hr))
		{
			ReleaseMutex(m_hMutex);
			return hr;
		}

		//
		// save the xml file
		//
		bstrLogFilePath = T2BSTR(m_szLogFilePath);
		hr = m_pxmlExisting->SaveXMLDocument(bstrLogFilePath);
		SafeSysFreeString(bstrLogFilePath);
		if (SUCCEEDED(hr))
		{
			m_fSavePending = FALSE;
		}
	}
	else
	{
		//
		// this is the corporate case...
		//
		SysFreeString(bstrCorpSite);
		if (NULL != m_pszDownloadBasePath && _T('\0') != m_pszDownloadBasePath[0])
		{
			//
			// re-read corp history from download base folder
			//
			ReadHistoryFromDisk(m_pszDownloadBasePath);

			//
			// merge new items downloaded
			// 
			hr = m_pxmlExisting->MergeItemDownloaded(m_pxmlDownload);
			if (FAILED(hr))
			{
				ReleaseMutex(m_hMutex);
				return hr;
			}

			//
			// save the xml file
			//
			bstrLogFilePath = T2BSTR(m_szLogFilePath);
			hr = m_pxmlExisting->SaveXMLDocument(bstrLogFilePath);
			SafeSysFreeString(bstrLogFilePath);
		}
		//
		// re-read corp admin history from windowsupdate folder
		//
		ReadHistoryFromDisk(m_pszDownloadBasePath, TRUE);

		//
		// merge new items downloaded
		// 
		hr2 = m_pxmlExisting->MergeItemDownloaded(m_pxmlDownload);
		if (FAILED(hr2))
		{
			ReleaseMutex(m_hMutex);
			return hr2;
		}

		//
		// save the xml file
		//
		bstrLogFilePath = T2BSTR(m_szLogFilePath);
		hr2 = m_pxmlExisting->SaveXMLDocument(bstrLogFilePath);
		SafeSysFreeString(bstrLogFilePath);
		if (SUCCEEDED(hr) && SUCCEEDED(hr2))
		{
			m_fSavePending = FALSE;
		}
	}

	ReleaseMutex(m_hMutex);
	SysFreeString(bstrLogFilePath);
	hr = SUCCEEDED(hr) ? hr2 : hr;
	return hr;
}



// ------------------------------------------------------------------
//
// public function to set the client name 
//
//	a client name is used to put in history to denode who
//	caused download/install happened.
//
// ------------------------------------------------------------------
void CIUHistory::SetClientName(BSTR bstrClientName)
{
	if (NULL != m_bstrCurrentClientName)
	{
		SysFreeString(m_bstrCurrentClientName);
		m_bstrCurrentClientName = NULL;
	}
	if (NULL != bstrClientName)
	{
		m_bstrCurrentClientName = SysAllocString(bstrClientName);
	}
}



// ------------------------------------------------------------------
//
// public function GetHistory
//
//	read the current history XML file and convert it
//	into bstr to pass out
//
// ------------------------------------------------------------------
HRESULT CIUHistory::GetHistoryStr(
				LPCTSTR lpszLogFile,
				BSTR BeginDateTime, 
				BSTR EndDateTime, 
				BSTR* pbstrHistory)
{
	LOG_Block("GetHistoryStr()");

	HRESULT	hr	= S_OK;

	ReturnFailedAllocSetHrMsg(m_pxmlExisting);

	//
	// need to read the existing history
	//
	WaitForSingleObject(m_hMutex, INFINITE);

	BSTR bstrCorpSite = SysAllocString(C_IU_CORP_SITE);
	if (bstrCorpSite == NULL)
	{
	    hr = E_OUTOFMEMORY;
	    goto done;
	}

	if (CompareBSTRsEqual(bstrCorpSite, m_bstrCurrentClientName))
	{
		TCHAR szLogPath[MAX_PATH];
	    TCHAR szLogFileParam[MAX_PATH];

        if (lpszLogFile != NULL && lpszLogFile[0] != _T('\0'))
        {
    	    hr = StringCchCopyEx(szLogFileParam, ARRAYSIZE(szLogFileParam), lpszLogFile, 
    	                         NULL, NULL, MISTSAFE_STRING_FLAGS);
    	    if (FAILED(hr))
    	    {
    	        LOG_ErrorMsg(hr);
    	        goto done;
    	    }

    	    hr = PathCchAddBackslash(szLogFileParam, ARRAYSIZE(szLogFileParam));
    	    if (FAILED(hr))
    	    {
    	        LOG_ErrorMsg(hr);
    	        goto done;
    	    }
        }
        else
        {
            szLogFileParam[0] = _T('\0');
        }
	    
		//
		// corporate case
		//
		GetIndustryUpdateDirectory(szLogPath);
		if (_T('\0') == szLogFileParam[0] || !lstrcmpi(szLogPath, szLogFileParam))
		{
			// corp admin history
			hr = ReadHistoryFromDisk(szLogPath, TRUE);
		}
		else
		{
			// corp history
			hr = ReadHistoryFromDisk(lpszLogFile);
		}
	}
	else
	{
	    HRESULT hrAppend;
		//
		// consumer case
		//
		hr = ReadHistoryFromDisk(NULL);

		//
		// migrate V3 history to iuhist.xml
		// - if succeeded, save the updated iuhist.xml file and delete wuhistv3.log
		// - if failed, just log error and keep using the current iuhist.xml
		//
		TCHAR szLogPath[MAX_PATH];
		GetWindowsUpdateV3Directory(szLogPath);
		hrAppend = PathCchAppend(szLogPath, ARRAYSIZE(szLogPath), C_V3_LOG_FILE);
		if (FAILED(hrAppend))
		{
		    LOG_ErrorMsg(hrAppend);
		    if (SUCCEEDED(hr))
		        hr = hrAppend;
		    goto done;
		}

		if (0xffffffff != GetFileAttributes(szLogPath))
		{
			// V3 history file "wuhistv3.log" exists, so start migration
			if (FAILED(m_pxmlExisting->MigrateV3History(szLogPath)))
			{
				LOG_Out(_T("Failed to migrate v3 consumer history"));
			}
			else
			{
				BSTR bstrLogFilePath = T2BSTR(m_szLogFilePath);
				if (FAILED(m_pxmlExisting->SaveXMLDocument(bstrLogFilePath)))
				{
					LOG_Out(_T("Failed to save the updated history file %s"), m_szLogFilePath);
				}
				else
				{
					DeleteFile(szLogPath);
				}
				SafeSysFreeString(bstrLogFilePath);
			}
		}
	}

done:
	ReleaseMutex(m_hMutex);
	SafeSysFreeString(bstrCorpSite);

	if (FAILED(hr))
	{
		//
		// if we can't load the existing history
		// we can't do anything here. Return empty string.
		//
		*pbstrHistory = SysAllocString(L"");
		LOG_Out(_T("Loading the history xml file failed"));
		return S_FALSE;
	}

	// 
	// traverse history tree, inspect each node
	// to see if time/clientName fit. If not, delete it
	// then output the string
	//
	hr = m_pxmlExisting->GetFilteredHistoryBSTR(BeginDateTime, EndDateTime, m_bstrCurrentClientName, pbstrHistory);

	return hr;
}



// *****************************************************************
//
// IUENGINE.DLL Public API:
//
// *****************************************************************

HRESULT WINAPI CEngUpdate::GetHistory(
	BSTR		bstrDateTimeFrom,
	BSTR		bstrDateTimeTo,
	BSTR		bstrClient,
	BSTR		bstrPath,
	BSTR*		pbstrLog)
{
	LOG_Block("GetHistory()");

	USES_IU_CONVERSION;

	HRESULT		hr = S_OK;
	BSTR		bsStart = NULL;
	BSTR		bsEnd = NULL;
	CIUHistory	cHistory;

	//
	// first, check to see if this is to ask historical speed
	//
	if (NULL != bstrClient && lstrcmpiW(C_HISTORICALSPEED, (LPWSTR)((LPOLESTR) bstrClient)) == 0)
	{
		HKEY	hKey = NULL;
		TCHAR	szSpeed[32];
		DWORD	dwSpeed = 0x0;
		DWORD	dwSize = sizeof(dwSpeed);
		LONG	lResult = ERROR_SUCCESS;

		//
		// get speed here from reg; if failure, dwSpeed remains to be 0.
		//	
		if (ERROR_SUCCESS == (lResult = RegOpenKeyEx(HKEY_LOCAL_MACHINE, REGKEY_IUCTL, 0, KEY_READ, &hKey)))
		{
			lResult = RegQueryValueEx(hKey, REGVAL_HISTORICALSPEED, NULL, NULL, (LPBYTE)&dwSpeed, &dwSize);
			RegCloseKey(hKey);

			if (ERROR_SUCCESS != lResult)
			{
				*pbstrLog = SysAllocString(L"0");
				LOG_Out(_T("GetHistoricalSpeed registry key not found, it must be no downloads happened yet"));
				return hr;
			}
		}
		else
		{
			*pbstrLog = SysAllocString(L"0");
			LOG_ErrorMsg((DWORD)lResult);
			return hr;
		}

		hr = StringCchPrintfEx(szSpeed, ARRAYSIZE(szSpeed), NULL, NULL, MISTSAFE_STRING_FLAGS,
		                       _T("%d"), dwSpeed);
		if (FAILED(hr))
		{
		    *pbstrLog = SysAllocString(L"0");
		    LOG_ErrorMsg(hr);
		    return hr;
		}
		*pbstrLog = SysAllocString(T2OLE(szSpeed));
	
		LOG_Out(_T("GetHistoricalSpeed get called! Return value %s"), szSpeed);
		return hr;
	}

	//
	// really asking history log
	//

	//
	// set the client name
	//
	if (NULL != bstrClient && SysStringLen(bstrClient) > 0)
	{
		LOG_Out(_T("Set client name as %s"), OLE2T(bstrClient));
		cHistory.SetClientName(bstrClient);
	}
	else
	{
		LOG_Out(_T("Set client name as NULL"));
		cHistory.SetClientName(NULL);
	}

	//
	// for script: they may pass empty string. we treat them
	// as NULL
	//
	if (NULL != bstrDateTimeFrom && SysStringLen(bstrDateTimeFrom) > 0)
	{
		LOG_Out(_T("DateTimeFrom=%s"), OLE2T(bstrDateTimeFrom));
		bsStart = bstrDateTimeFrom;
	}
	if (NULL != bstrDateTimeTo && SysStringLen(bstrDateTimeTo) > 0)
	{
		LOG_Out(_T("DateTimeTo=%s"), OLE2T(bstrDateTimeTo));
		bsEnd = bstrDateTimeTo;
	}

	//
	// we do NOT validate the format of these two date/time strings.
	// They are supposed to be in XML datetime format. If not, then
	// the returned history logs may be filtered incorrectly.
	//
	hr = cHistory.GetHistoryStr(OLE2T(bstrPath), bsStart, bsEnd, pbstrLog);

	SysFreeString(bsStart);
	SysFreeString(bsEnd);
	return hr;
}