683 lines
17 KiB
C++
683 lines
17 KiB
C++
/*++
|
|
|
|
Copyright (C) 2000-2001 Microsoft Corporation
|
|
|
|
--*/
|
|
|
|
#include <windows.h>
|
|
#include <wbemcomn.h>
|
|
#include "filecach.h"
|
|
|
|
using namespace a51converter;
|
|
|
|
long CFileCache::Initialize(LPCWSTR wszBaseName)
|
|
{
|
|
long lRes;
|
|
|
|
wcscpy(m_wszBaseName, wszBaseName);
|
|
wcscat(m_wszBaseName, L"\\");
|
|
m_dwBaseNameLen = wcslen(m_wszBaseName);
|
|
|
|
//
|
|
// Read the maximum stage-file size from the registry
|
|
//
|
|
|
|
HKEY hKey;
|
|
lRes = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
|
|
L"SOFTWARE\\Microsoft\\WBEM\\CIMOM",
|
|
0, KEY_READ | KEY_WRITE, &hKey);
|
|
if(lRes)
|
|
return lRes;
|
|
CRegCloseMe cm(hKey);
|
|
|
|
DWORD dwLen = sizeof(DWORD);
|
|
DWORD dwMaxLen;
|
|
lRes = RegQueryValueExW(hKey, L"Max Stage File Size", NULL, NULL,
|
|
(LPBYTE)&dwMaxLen, &dwLen);
|
|
|
|
//
|
|
// If not there, set to default and write the default into the registry
|
|
//
|
|
|
|
if(lRes != ERROR_SUCCESS)
|
|
{
|
|
dwMaxLen = 5000000;
|
|
lRes = RegSetValueExW(hKey, L"Max Stage File Size", 0, REG_DWORD,
|
|
(LPBYTE)&dwMaxLen, sizeof(DWORD));
|
|
}
|
|
|
|
dwLen = sizeof(DWORD);
|
|
DWORD dwAbortTransactionLen;
|
|
lRes = RegQueryValueExW(hKey, L"Absolute Max Stage File Size", NULL, NULL,
|
|
(LPBYTE)&dwAbortTransactionLen, &dwLen);
|
|
|
|
//
|
|
// If not there, set to default and write the default into the registry
|
|
//
|
|
|
|
if(lRes != ERROR_SUCCESS || dwAbortTransactionLen == dwMaxLen * 10)
|
|
{
|
|
dwAbortTransactionLen = 0x7FFFFFFF;
|
|
lRes = RegSetValueExW(hKey, L"Absolute Max Stage File Size", 0,
|
|
REG_DWORD, (LPBYTE)&dwAbortTransactionLen, sizeof(DWORD));
|
|
}
|
|
|
|
if(dwMaxLen == 0)
|
|
{
|
|
//
|
|
// Staged writes are disabled!
|
|
//
|
|
|
|
m_pMainStage = NULL;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Create the main staging area
|
|
//
|
|
|
|
CFileName wszStagingName;
|
|
if (wszStagingName == NULL)
|
|
return ERROR_OUTOFMEMORY;
|
|
swprintf(wszStagingName, L"%s\\MainStage.dat", wszBaseName);
|
|
|
|
m_pMainStage = new CExecutableStagingFile(this, m_wszBaseName,
|
|
dwMaxLen, dwAbortTransactionLen);
|
|
/*
|
|
m_pMainStage = new CPermanentStagingFile(this, m_wszBaseName);
|
|
*/
|
|
|
|
if(m_pMainStage == NULL)
|
|
return E_OUTOFMEMORY;
|
|
|
|
long lRes = m_pMainStage->Create(wszStagingName);
|
|
if(lRes != ERROR_SUCCESS)
|
|
return lRes;
|
|
|
|
if(m_apStages.Add(m_pMainStage) < 0)
|
|
{
|
|
delete m_pMainStage;
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
long CFileCache::RepositoryExists(LPCWSTR wszBaseName)
|
|
{
|
|
CFileName wszStagingName;
|
|
if (wszStagingName == NULL)
|
|
return ERROR_OUTOFMEMORY;
|
|
swprintf(wszStagingName, L"%s\\MainStage.dat", wszBaseName);
|
|
|
|
DWORD dwAttributes = GetFileAttributesW(wszStagingName);
|
|
if (dwAttributes == -1)
|
|
return ERROR_FILE_NOT_FOUND;
|
|
return ERROR_SUCCESS;
|
|
|
|
}
|
|
|
|
CFileCache::CFileCache()
|
|
{
|
|
}
|
|
|
|
CFileCache::~CFileCache()
|
|
{
|
|
Clear();
|
|
}
|
|
|
|
void CFileCache::Clear()
|
|
{
|
|
}
|
|
|
|
bool CFileCache::IsFullyFlushed()
|
|
{
|
|
CInCritSec ics(&m_cs);
|
|
|
|
for(int i = 0; i < m_apStages.GetSize(); i++)
|
|
{
|
|
if(!m_apStages[i]->IsFullyFlushed())
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
long CFileCache::WriteFile(LPCWSTR wszFileName, DWORD dwLen, BYTE* pBuffer)
|
|
{
|
|
CInCritSec ics(&m_cs);
|
|
|
|
//
|
|
// Write the file into the main staging file
|
|
//
|
|
|
|
if(GetMainStagingFile())
|
|
{
|
|
return GetMainStagingFile()->WriteFile(wszFileName + m_dwBaseNameLen,
|
|
dwLen, pBuffer);
|
|
}
|
|
else
|
|
{
|
|
long lRes = A51WriteFile(wszFileName, dwLen, pBuffer);
|
|
_ASSERT(lRes == ERROR_SUCCESS, L"Failed to create a file");
|
|
return lRes;
|
|
}
|
|
}
|
|
|
|
long CFileCache::DeleteFile(LPCWSTR wszFileName)
|
|
{
|
|
CInCritSec ics(&m_cs);
|
|
|
|
//
|
|
// Write the file into the main staging file
|
|
//
|
|
|
|
if(GetMainStagingFile())
|
|
{
|
|
return GetMainStagingFile()->DeleteFile(wszFileName + m_dwBaseNameLen);
|
|
}
|
|
else
|
|
{
|
|
long lRes = A51DeleteFile(wszFileName);
|
|
_ASSERT(lRes == ERROR_SUCCESS || lRes == ERROR_FILE_NOT_FOUND ||
|
|
lRes == ERROR_PATH_NOT_FOUND, L"Failed to delete file");
|
|
return lRes;
|
|
}
|
|
|
|
}
|
|
|
|
long CFileCache::RemoveDirectory(LPCWSTR wszFileName, bool bMustSucceed)
|
|
{
|
|
CInCritSec ics(&m_cs);
|
|
|
|
//
|
|
// Write the file into the main staging file
|
|
//
|
|
|
|
if(GetMainStagingFile())
|
|
{
|
|
return GetMainStagingFile()->
|
|
RemoveDirectory(wszFileName + m_dwBaseNameLen);
|
|
}
|
|
else
|
|
{
|
|
long lRes = A51RemoveDirectory(wszFileName);
|
|
_ASSERT(lRes == ERROR_SUCCESS ||
|
|
lRes == ERROR_FILE_NOT_FOUND || lRes == ERROR_PATH_NOT_FOUND ||
|
|
lRes == ERROR_DIR_NOT_EMPTY,
|
|
L"Failed to remove directory");
|
|
|
|
/*
|
|
_ASSERT(!bMustSucceed || lRes != ERROR_DIR_NOT_EMPTY,
|
|
L"Stuff in directory that should be empty");
|
|
*/
|
|
|
|
return lRes;
|
|
}
|
|
}
|
|
|
|
HRESULT CFileCache::ReadFile(LPCWSTR wszFileName, DWORD* pdwLen,
|
|
BYTE** ppBuffer, bool bMustBeThere)
|
|
{
|
|
long lRes;
|
|
|
|
CInCritSec ics(&m_cs);
|
|
|
|
//
|
|
// Search all staging files in order
|
|
//
|
|
|
|
for(int i = 0; i < m_apStages.GetSize(); i++)
|
|
{
|
|
lRes = m_apStages[i]->ReadFile(wszFileName + m_dwBaseNameLen, pdwLen,
|
|
ppBuffer, bMustBeThere);
|
|
if(lRes != ERROR_NO_INFORMATION)
|
|
{
|
|
if(lRes != ERROR_SUCCESS && lRes != ERROR_FILE_NOT_FOUND &&
|
|
lRes != ERROR_PATH_NOT_FOUND)
|
|
{
|
|
ERRORTRACE((LOG_WBEMCORE, "Repository driver cannot read file "
|
|
"'%S' from the stage with error code %d\n", wszFileName,
|
|
lRes));
|
|
}
|
|
return lRes;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Not in the staging areas --- get from disk!
|
|
//
|
|
|
|
WIN32_FIND_DATAW fd;
|
|
HANDLE hSearch = ::FindFirstFileW(wszFileName, &fd);
|
|
if(hSearch == INVALID_HANDLE_VALUE)
|
|
{
|
|
lRes = GetLastError();
|
|
//_ASSERT(!bMustBeThere, L"Must-be-there file is not found!");
|
|
_ASSERT(lRes != ERROR_SUCCESS, L"Success reported on failure");
|
|
if(lRes == ERROR_FILE_NOT_FOUND || lRes == ERROR_PATH_NOT_FOUND)
|
|
return ERROR_FILE_NOT_FOUND;
|
|
else
|
|
return lRes;
|
|
}
|
|
else
|
|
::FindClose(hSearch);
|
|
|
|
HANDLE hFile = CreateFileW(wszFileName, GENERIC_READ, FILE_SHARE_READ,
|
|
NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
|
|
lRes = GetLastError();
|
|
A51TRACE(("Reading %S returned %d\n", wszFileName, lRes));
|
|
if(hFile == INVALID_HANDLE_VALUE)
|
|
{
|
|
_ASSERT(lRes != ERROR_SUCCESS, L"Success reported on failure");
|
|
if(lRes != ERROR_FILE_NOT_FOUND && lRes != ERROR_PATH_NOT_FOUND)
|
|
{
|
|
ERRORTRACE((LOG_WBEMCORE, "Repository driver unable to open file "
|
|
"'%S' with error code %d\n", wszFileName, lRes));
|
|
}
|
|
//_ASSERT(!bMustBeThere, L"Must-be-there file is not found!");
|
|
return lRes;
|
|
}
|
|
|
|
|
|
CCloseMe cm(hFile);
|
|
|
|
/*
|
|
BY_HANDLE_FILE_INFORMATION fi;
|
|
if(!GetFileInformationByHandle(hFile, &fi))
|
|
{
|
|
_ASSERT(!bMustBeThere, L"Must-be-there file is not found!");
|
|
return GetLastError();
|
|
}
|
|
*/
|
|
|
|
// BUG: instances must be less than 4G :-)
|
|
|
|
//
|
|
// Try to read one byte more than what FindFirstFile told us. This is
|
|
// important because FindFirstFile has been known to lie about the size of
|
|
// the file. If it told us too low a number, then this longer read will
|
|
// succeed, and we will know we've been had.
|
|
//
|
|
|
|
// *pdwLen = fi.nFileSizeLow;
|
|
*pdwLen = fd.nFileSizeLow + 1;
|
|
*ppBuffer = (BYTE*)TempAlloc(*pdwLen);
|
|
if(*ppBuffer == NULL)
|
|
return E_OUTOFMEMORY;
|
|
|
|
DWORD dwRead;
|
|
if(!::ReadFile(hFile, *ppBuffer, *pdwLen, &dwRead, NULL))
|
|
{
|
|
lRes = GetLastError();
|
|
ERRORTRACE((LOG_WBEMCORE, "Repository driver unable to read %d bytes "
|
|
"from file with error %d\n", *pdwLen, lRes));
|
|
_ASSERT(lRes != ERROR_SUCCESS, L"Success reported on failure");
|
|
TempFree(*ppBuffer);
|
|
//_ASSERT(!bMustBeThere, L"Must-be-there file is not found!");
|
|
return lRes;
|
|
}
|
|
else
|
|
{
|
|
if(dwRead == *pdwLen - 1)
|
|
{
|
|
// Got the right number of bytes --- remember we incrememented it
|
|
// to catch liers
|
|
|
|
(*pdwLen)--;
|
|
return ERROR_SUCCESS;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// We were lied to by FindFirstFile. Get the real file length and
|
|
// try again
|
|
//
|
|
|
|
TempFree(*ppBuffer);
|
|
*ppBuffer = NULL;
|
|
|
|
BY_HANDLE_FILE_INFORMATION fi;
|
|
if(!GetFileInformationByHandle(hFile, &fi))
|
|
{
|
|
return GetLastError();
|
|
}
|
|
|
|
//
|
|
// Allocate the buffer from scratch
|
|
//
|
|
|
|
*pdwLen = fi.nFileSizeLow;
|
|
*ppBuffer = (BYTE*)TempAlloc(*pdwLen);
|
|
if(*ppBuffer == NULL)
|
|
return E_OUTOFMEMORY;
|
|
|
|
DWORD dwRead;
|
|
if(!::ReadFile(hFile, *ppBuffer, *pdwLen, &dwRead, NULL))
|
|
{
|
|
lRes = GetLastError();
|
|
ERRORTRACE((LOG_WBEMCORE, "Repository driver unable to read %d "
|
|
"bytes from file with error %d\n", *pdwLen, lRes));
|
|
_ASSERT(lRes != ERROR_SUCCESS, L"Success reported on failure");
|
|
TempFree(*ppBuffer);
|
|
//_ASSERT(!bMustBeThere, L"Must-be-there file is not found!");
|
|
return lRes;
|
|
}
|
|
else
|
|
{
|
|
if(*pdwLen != dwRead)
|
|
{
|
|
_ASSERT(false, L"Read the wrong number of bytes");
|
|
TempFree(*ppBuffer);
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
else
|
|
return ERROR_SUCCESS;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
long CFileCache::FindFirst(LPCWSTR wszFilePrefix, WIN32_FIND_DATAW* pfd,
|
|
void** ppHandle)
|
|
{
|
|
CInCritSec ics(&m_cs);
|
|
|
|
//
|
|
// Construct an enumerator
|
|
//
|
|
|
|
CFileEnumerator* pEnum = new CFileEnumerator(this, m_dwBaseNameLen);
|
|
if (pEnum == NULL)
|
|
return E_OUTOFMEMORY;
|
|
long lRes = pEnum->GetFirst(wszFilePrefix, pfd);
|
|
if(lRes != ERROR_SUCCESS)
|
|
{
|
|
delete pEnum;
|
|
return lRes;
|
|
}
|
|
|
|
*ppHandle = (void*)pEnum;
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
long CFileCache::FindNext(void* pHandle, WIN32_FIND_DATAW* pfd)
|
|
{
|
|
CInCritSec ics(&m_cs);
|
|
|
|
CFileEnumerator* pEnum = (CFileEnumerator*)pHandle;
|
|
return pEnum->GetNext(pfd);
|
|
}
|
|
|
|
|
|
void CFileCache::FindClose(void* pHandle)
|
|
{
|
|
CInCritSec ics(&m_cs);
|
|
|
|
delete (CFileEnumerator*)pHandle;
|
|
}
|
|
|
|
long CFileCache::BeginTransaction()
|
|
{
|
|
if(GetMainStagingFile())
|
|
return GetMainStagingFile()->BeginTransaction();
|
|
else
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
long CFileCache::CommitTransaction()
|
|
{
|
|
A51TRACE(("Committing Transaction!\n"));
|
|
if(GetMainStagingFile())
|
|
return GetMainStagingFile()->CommitTransaction();
|
|
else
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
long CFileCache::AbortTransaction()
|
|
{
|
|
A51TRACE(("Aborting Transaction!\n"));
|
|
if(GetMainStagingFile())
|
|
return GetMainStagingFile()->AbortTransaction();
|
|
else
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
|
|
CFileCache::CFileEnumerator::~CFileEnumerator()
|
|
{
|
|
if(m_pStageEnumerator)
|
|
m_pCache->GetStageFile(m_nCurrentStage)->FindClose(m_pStageEnumerator);
|
|
|
|
if(m_hFileEnum)
|
|
::FindClose(m_hFileEnum);
|
|
}
|
|
|
|
long CFileCache::CFileEnumerator::GetFirst(LPCWSTR wszPrefix,
|
|
WIN32_FIND_DATAW* pfd)
|
|
{
|
|
long lRes;
|
|
|
|
wcscpy(m_wszPrefix, wszPrefix);
|
|
|
|
WCHAR* pwcLastSlash = wcsrchr(m_wszPrefix, L'\\');
|
|
if(pwcLastSlash == NULL)
|
|
return E_OUTOFMEMORY;
|
|
|
|
m_dwPrefixDirLen = pwcLastSlash - m_wszPrefix;
|
|
|
|
//
|
|
// We are going to start with the first staging area
|
|
//
|
|
|
|
m_nCurrentStage = 0;
|
|
m_bUseFiles = false;
|
|
|
|
//
|
|
// Everything is set up to indicate that we are at the very beginning ---
|
|
// GetNext will retrieve the first
|
|
//
|
|
|
|
lRes = GetNext(pfd);
|
|
|
|
//
|
|
// One last thing --- absense of files is ERROR_NO_MORE_FILES for GetNext,
|
|
// but ERROR_FILE_NOT_FOUND for GetFirst, so translate
|
|
//
|
|
|
|
if(lRes == ERROR_NO_MORE_FILES)
|
|
lRes = ERROR_FILE_NOT_FOUND;
|
|
|
|
return lRes;
|
|
}
|
|
|
|
long CFileCache::CFileEnumerator::GetFirstFile(WIN32_FIND_DATAW* pfd)
|
|
{
|
|
m_bUseFiles = true;
|
|
|
|
CFileName wszMask;
|
|
if (wszMask == NULL)
|
|
return ERROR_OUTOFMEMORY;
|
|
wcscpy(wszMask, m_wszPrefix);
|
|
wcscat(wszMask, L"*");
|
|
|
|
m_hFileEnum = ::FindFirstFileW(wszMask, pfd);
|
|
long lRes = GetLastError();
|
|
A51TRACE(("Actual FindFirstFileW on %S returning %p %d\n",
|
|
wszMask, (void*)m_hFileEnum, lRes));
|
|
if(m_hFileEnum == INVALID_HANDLE_VALUE)
|
|
{
|
|
if(lRes == ERROR_PATH_NOT_FOUND)
|
|
return ERROR_FILE_NOT_FOUND;
|
|
else
|
|
return lRes;
|
|
}
|
|
else
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
void CFileCache::CFileEnumerator::ComputeCanonicalName(WIN32_FIND_DATAW* pfd,
|
|
wchar_t *wszFilePath)
|
|
{
|
|
wcsncpy(wszFilePath, m_wszPrefix, m_dwPrefixDirLen+1);
|
|
wbem_wcsupr(wszFilePath+m_dwPrefixDirLen+1, pfd->cFileName);
|
|
}
|
|
|
|
long CFileCache::CFileEnumerator::GetNext(WIN32_FIND_DATAW* pfd)
|
|
{
|
|
long lRes;
|
|
|
|
//
|
|
// Go through the files in the enumerator until we find a new and valid one
|
|
//
|
|
|
|
while((lRes = GetRawNext(pfd)) == ERROR_SUCCESS)
|
|
{
|
|
//
|
|
// Compute the full name
|
|
//
|
|
|
|
CFileName wszFullName;
|
|
if (wszFullName == NULL)
|
|
return ERROR_OUTOFMEMORY;
|
|
ComputeCanonicalName(pfd, wszFullName);
|
|
|
|
//
|
|
// Check if it is already in our map of returned files
|
|
//
|
|
|
|
if(m_setSent.find((const wchar_t*)wszFullName) != m_setSent.end())
|
|
continue;
|
|
|
|
//
|
|
// Check if this file is deleted
|
|
//
|
|
|
|
bool bDeleted = false;
|
|
for(int i = 0; i < m_nCurrentStage; i++)
|
|
{
|
|
long hres = m_pCache->GetStageFile(i)->IsDeleted(wszFullName + m_dwBaseNameLen);
|
|
if (hres == S_OK)
|
|
{
|
|
bDeleted = true;
|
|
break;
|
|
}
|
|
else if (FAILED(hres))
|
|
{
|
|
return hres;
|
|
}
|
|
}
|
|
|
|
if(bDeleted)
|
|
continue;
|
|
|
|
//
|
|
// All clear!
|
|
//
|
|
|
|
if(!m_bUseFiles)
|
|
m_setSent.insert((const wchar_t*)wszFullName);
|
|
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
return lRes;
|
|
}
|
|
|
|
long CFileCache::CFileEnumerator::GetRawNext(WIN32_FIND_DATAW* pfd)
|
|
{
|
|
long lRes;
|
|
|
|
if(m_bUseFiles)
|
|
{
|
|
//
|
|
// Get the next file
|
|
//
|
|
|
|
if(!FindNextFileW(m_hFileEnum, pfd))
|
|
{
|
|
lRes = GetLastError();
|
|
::FindClose(m_hFileEnum);
|
|
m_hFileEnum = NULL;
|
|
return lRes;
|
|
}
|
|
else
|
|
{
|
|
return ERROR_SUCCESS;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Check if we even have a stage enumerator
|
|
//
|
|
|
|
if(m_pStageEnumerator)
|
|
{
|
|
//
|
|
// Get the next file from the same stage
|
|
//
|
|
|
|
lRes = m_pCache->GetStageFile(m_nCurrentStage)->
|
|
FindNext(m_pStageEnumerator, pfd);
|
|
if(lRes != ERROR_NO_MORE_FILES)
|
|
return lRes;
|
|
|
|
//
|
|
// Advance to the next one
|
|
//
|
|
|
|
m_pCache->GetStageFile(m_nCurrentStage)->
|
|
FindClose(m_pStageEnumerator);
|
|
m_pStageEnumerator = NULL;
|
|
m_nCurrentStage++;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// This is our first time --- we are all set up to pick up the first
|
|
// file from the first stage
|
|
//
|
|
}
|
|
|
|
while(1)
|
|
{
|
|
if(m_nCurrentStage >= m_pCache->GetNumStages())
|
|
{
|
|
//
|
|
// Go to files
|
|
//
|
|
|
|
lRes = GetFirstFile(pfd);
|
|
if(lRes == ERROR_FILE_NOT_FOUND)
|
|
return ERROR_NO_MORE_FILES;
|
|
else
|
|
return lRes;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Initialize the next stage
|
|
//
|
|
|
|
lRes = m_pCache->GetStageFile(m_nCurrentStage)->
|
|
FindFirst(m_wszPrefix + m_dwBaseNameLen, pfd, &m_pStageEnumerator);
|
|
if(lRes == ERROR_FILE_NOT_FOUND)
|
|
{
|
|
//
|
|
// This stage has nothing to contribute --- move along
|
|
//
|
|
|
|
m_nCurrentStage++;
|
|
continue;
|
|
}
|
|
else
|
|
return lRes;
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|