1663 lines
46 KiB
C++
1663 lines
46 KiB
C++
#include "stdinc.h"
|
|
#include "util.h"
|
|
#include "xmlparser.hxx"
|
|
#include "FusionEventLog.h"
|
|
#include "parsing.h"
|
|
#include "hashfile.h"
|
|
#include "recover.h"
|
|
#include "filestream.h"
|
|
#include "CAssemblyRecoveryInfo.h"
|
|
#include "sxsprotect.h"
|
|
#include "strongname.h"
|
|
#include "SxsExceptionHandling.h"
|
|
#include "sxssfcscan.h"
|
|
|
|
#define MANIFEST_FILE_EXTENSION (L".manifest")
|
|
#define FILE_ELEMENT_NAME (L"file")
|
|
|
|
#define HASH_ATTRIB_NAME (L"hash")
|
|
#define FILE_ATTRIB_NAME (L"name")
|
|
#define HASHALG_ATTRIB_NAME (L"hashalg")
|
|
|
|
class CProtectionRequestList;
|
|
static CProtectionRequestList* g_ProtectionRequestList = NULL;
|
|
HANDLE g_hSxsLoginEvent = NULL;
|
|
static BOOL s_fIsSfcAcceptingNotifications = TRUE;
|
|
|
|
#if DBG
|
|
#define SXS_SFC_EXCEPTION_SETTING (SXSP_EXCEPTION_FILTER())
|
|
#else
|
|
#define SXS_SFC_EXCEPTION_SETTING (EXCEPTION_EXECUTE_HANDLER)
|
|
#endif
|
|
|
|
BOOL
|
|
CRecoveryJobTableEntry::Initialize()
|
|
{
|
|
FN_PROLOG_WIN32
|
|
|
|
//
|
|
// Creates an event that other callers should wait on - manual reset, not
|
|
// currently signalled.
|
|
//
|
|
m_Subscriber = 0;
|
|
m_fSuccessValue = FALSE;
|
|
IFW32NULL_EXIT(m_EventInstallingAssemblyComplete = ::CreateEventW(NULL, TRUE, FALSE, NULL));
|
|
|
|
FN_EPILOG
|
|
}
|
|
|
|
BOOL
|
|
CRecoveryJobTableEntry::StartInstallation()
|
|
{
|
|
FN_PROLOG_WIN32
|
|
|
|
//
|
|
// Clear the event (if it wasn't already cleared.
|
|
//
|
|
IFW32FALSE_ORIGINATE_AND_EXIT(::ResetEvent(m_EventInstallingAssemblyComplete));
|
|
|
|
FN_EPILOG
|
|
}
|
|
|
|
|
|
BOOL
|
|
SxspEnsureCatalogStillPresentForManifest(
|
|
IN const CBaseStringBuffer& buffManifestPath,
|
|
OUT BOOL &rfStillPresent
|
|
)
|
|
{
|
|
FN_PROLOG_WIN32
|
|
|
|
rfStillPresent = FALSE;
|
|
|
|
CStringBuffer buffCatalogPath;
|
|
|
|
IFW32FALSE_EXIT(buffCatalogPath.Win32Assign(buffManifestPath));
|
|
|
|
IFW32FALSE_EXIT(
|
|
buffCatalogPath.Win32ChangePathExtension(
|
|
FILE_EXTENSION_CATALOG,
|
|
FILE_EXTENSION_CATALOG_CCH,
|
|
eAddIfNoExtension));
|
|
|
|
const DWORD dwCatalogAttribs = ::GetFileAttributesW(buffCatalogPath);
|
|
if (dwCatalogAttribs != INVALID_FILE_ATTRIBUTES)
|
|
{
|
|
rfStillPresent = TRUE;
|
|
}
|
|
else
|
|
{
|
|
const DWORD dwLastError = ::FusionpGetLastWin32Error();
|
|
|
|
switch (dwLastError)
|
|
{
|
|
default:
|
|
ORIGINATE_WIN32_FAILURE_AND_EXIT(GetFileAttributesW, dwLastError);
|
|
|
|
case ERROR_PATH_NOT_FOUND:
|
|
case ERROR_FILE_NOT_FOUND:
|
|
case ERROR_BAD_NET_NAME:
|
|
case ERROR_BAD_NETPATH:
|
|
;
|
|
}
|
|
}
|
|
|
|
FN_EPILOG
|
|
}
|
|
|
|
BOOL
|
|
CRecoveryJobTableEntry::InstallationComplete(
|
|
BOOL bDoneOk,
|
|
SxsRecoveryResult Result,
|
|
DWORD dwRecoveryLastError
|
|
)
|
|
{
|
|
FN_PROLOG_WIN32
|
|
|
|
m_Result = Result;
|
|
m_fSuccessValue = bDoneOk;
|
|
m_dwLastError = dwRecoveryLastError;
|
|
|
|
//
|
|
// This will tell all the people waiting that we're done and that they
|
|
// should capture the exit code and exit out.
|
|
//
|
|
IFW32FALSE_ORIGINATE_AND_EXIT(::SetEvent(m_EventInstallingAssemblyComplete));
|
|
|
|
//
|
|
// We wait for all our subscribers to go away (ie: for them to capture an
|
|
// install code and success value.)
|
|
//
|
|
while (m_Subscriber)
|
|
{
|
|
Sleep(50);
|
|
}
|
|
|
|
FN_EPILOG
|
|
}
|
|
|
|
|
|
BOOL
|
|
CRecoveryJobTableEntry::WaitUntilCompleted(
|
|
SxsRecoveryResult &rResult,
|
|
BOOL &rbSucceededValue,
|
|
DWORD &rdwErrorResult
|
|
)
|
|
{
|
|
FN_PROLOG_WIN32
|
|
|
|
DWORD WaitResult;
|
|
|
|
//
|
|
// Here we join up to the existing installation routine. We up the number
|
|
// of people waiting before entering the wait. I wish there was a better
|
|
// way of doing this, something like a built-in kernel object that we can
|
|
// raise a count on (like a semaphore), and have another thread lower a
|
|
// count on, and someone can wait on the internal count being zero. Yes,
|
|
// I could implement this by hand using something with another event or
|
|
// two, but that's not the point.
|
|
//
|
|
::SxspInterlockedIncrement(&m_Subscriber);
|
|
|
|
//
|
|
// Hang about forever until another thread is done installing
|
|
//
|
|
IFW32FALSE_ORIGINATE_AND_EXIT((WaitResult = ::WaitForSingleObject(m_EventInstallingAssemblyComplete, INFINITE)) != WAIT_FAILED);
|
|
|
|
//
|
|
// Capture values once the installation is done, return them to the caller.
|
|
//
|
|
rResult = m_Result;
|
|
rdwErrorResult = m_dwLastError;
|
|
rbSucceededValue = m_fSuccessValue;
|
|
|
|
//
|
|
// And indicate that we're complete.
|
|
//
|
|
::SxspInterlockedDecrement(&m_Subscriber);
|
|
|
|
FN_EPILOG
|
|
}
|
|
|
|
CRecoveryJobTableEntry::~CRecoveryJobTableEntry()
|
|
{
|
|
//
|
|
// We're done with the event, so close it (release refcount, we don't want lots of these
|
|
// just sitting around.)
|
|
//
|
|
if ((m_EventInstallingAssemblyComplete != NULL) &&
|
|
(m_EventInstallingAssemblyComplete != INVALID_HANDLE_VALUE))
|
|
{
|
|
::CloseHandle(m_EventInstallingAssemblyComplete);
|
|
m_EventInstallingAssemblyComplete = INVALID_HANDLE_VALUE;
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// This is our holy grail of sxs protection lists. Don't fidget with
|
|
// this listing. Note that we've also got only one. This is because
|
|
// right now, there's only one entry to be had (a), and (b) because we
|
|
// will fill in the sxs directory on the fly at runtime.
|
|
//
|
|
SXS_PROTECT_DIRECTORY s_SxsProtectionList[] =
|
|
{
|
|
{
|
|
{0},
|
|
0,
|
|
SXS_PROTECT_RECURSIVE,
|
|
SXS_PROTECT_FILTER_DEFAULT
|
|
}
|
|
};
|
|
|
|
const SIZE_T s_SxsProtectionListCount = NUMBER_OF(s_SxsProtectionList);
|
|
|
|
|
|
BOOL SxspConstructProtectionList();
|
|
|
|
|
|
BOOL WINAPI
|
|
SxsProtectionGatherEntriesW(
|
|
PCSXS_PROTECT_DIRECTORY *prgpProtectListing,
|
|
SIZE_T *pcProtectEntries
|
|
)
|
|
/*++
|
|
This is called by Sfc to gather the entries that we want them to watch.
|
|
At the moment, it's a 'proprietary' listing of all the directories and
|
|
flags we want them to set on their call to the directory-change watcher.
|
|
Mayhaps we should work with them to find out exactly what they want us
|
|
to pass (probably the name plus a PVOID, which is fine) and then go from
|
|
there.
|
|
--*/
|
|
{
|
|
BOOL fSuccess = FALSE;
|
|
FN_TRACE_WIN32(fSuccess);
|
|
|
|
CStringBuffer sbTemp;
|
|
|
|
|
|
if (prgpProtectListing) *prgpProtectListing = NULL;
|
|
if (pcProtectEntries) *pcProtectEntries = 0;
|
|
|
|
PARAMETER_CHECK(prgpProtectListing);
|
|
PARAMETER_CHECK(pcProtectEntries);
|
|
|
|
//
|
|
// This is try/caught because we don't want something here to
|
|
// cause WinLogon to bugcheck the system when it AV's.
|
|
//
|
|
IFW32FALSE_EXIT(::SxspConstructProtectionList());
|
|
|
|
//
|
|
// We really have only one entry, so let's go and edit the first entry to
|
|
// be the main sxs store directory.
|
|
//
|
|
IFW32FALSE_EXIT(::SxspGetAssemblyRootDirectory(sbTemp));
|
|
wcsncpy(
|
|
s_SxsProtectionList[0].pwszDirectory,
|
|
sbTemp,
|
|
NUMBER_OF(s_SxsProtectionList[0].pwszDirectory));
|
|
//
|
|
// Zero out the last character, just in case wcsncpy didn't do it for us
|
|
//
|
|
s_SxsProtectionList[0].pwszDirectory[NUMBER_OF(s_SxsProtectionList[0].pwszDirectory) - 1] = L'\0';
|
|
|
|
//
|
|
// Shh, don't tell anyone, but the cookie is actually this structure!
|
|
//
|
|
for (DWORD dw = 0; dw < s_SxsProtectionListCount; dw++)
|
|
{
|
|
s_SxsProtectionList[dw].pvCookie = &(s_SxsProtectionList[dw]);
|
|
}
|
|
|
|
*prgpProtectListing = s_SxsProtectionList;
|
|
*pcProtectEntries = s_SxsProtectionListCount;
|
|
|
|
fSuccess = TRUE;
|
|
Exit:
|
|
return fSuccess;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
inline BOOL
|
|
SxspExpandLongPath(
|
|
IN OUT CBaseStringBuffer &rbuffPathToLong
|
|
)
|
|
/*++
|
|
|
|
Takes in a short path (c:\foo\bar\bloben~1.zot) and sends back out the
|
|
full path (c:\foo\bar\blobenheisen.zotamax) if possible. Returns FALSE if
|
|
the path could not be expanded (most likely because the path on-disk is
|
|
no longer available.)
|
|
|
|
--*/
|
|
{
|
|
FN_PROLOG_WIN32
|
|
|
|
CStringBuffer buffPathName;
|
|
CStringBufferAccessor buffAccess;
|
|
SIZE_T cchNeededChars;
|
|
|
|
IFW32ZERO_EXIT(
|
|
cchNeededChars = ::GetLongPathNameW(
|
|
static_cast<PCWSTR>(rbuffPathToLong),
|
|
NULL,
|
|
0));
|
|
|
|
IFW32FALSE_EXIT(buffPathName.Win32ResizeBuffer(cchNeededChars, eDoNotPreserveBufferContents));
|
|
buffAccess.Attach(&buffPathName);
|
|
|
|
IFW32ZERO_EXIT(
|
|
cchNeededChars = ::GetLongPathNameW(
|
|
rbuffPathToLong,
|
|
buffAccess,
|
|
static_cast<DWORD>(buffAccess.GetBufferCch())));
|
|
|
|
INTERNAL_ERROR_CHECK(cchNeededChars <= buffAccess.GetBufferCch());
|
|
|
|
IFW32FALSE_EXIT(rbuffPathToLong.Win32Assign(buffPathName));
|
|
|
|
FN_EPILOG
|
|
}
|
|
|
|
BOOL
|
|
SxspResolveAssemblyManifestPath(
|
|
const CBaseStringBuffer &rbuffAssemblyDirectoryName,
|
|
CBaseStringBuffer &rbuffManifestPath
|
|
)
|
|
{
|
|
FN_PROLOG_WIN32
|
|
CStringBuffer buffAssemblyRootDir;
|
|
BOOL fLooksLikeAssemblyName = FALSE;
|
|
|
|
rbuffManifestPath.Clear();
|
|
|
|
//
|
|
// If the string doesn't look like an assembly name, then it's an
|
|
// invalid parameter. This is somewhat heavy-handed, as the caller(s)
|
|
// to this function will be entirely hosed if they haven't checked to
|
|
// see if the string is really an assembly name. Make sure that all
|
|
// clients of this,
|
|
//
|
|
IFW32FALSE_EXIT(::SxspLooksLikeAssemblyDirectoryName(rbuffAssemblyDirectoryName, fLooksLikeAssemblyName));
|
|
PARAMETER_CHECK(fLooksLikeAssemblyName);
|
|
|
|
IFW32FALSE_EXIT(::SxspGetAssemblyRootDirectory(buffAssemblyRootDir));
|
|
IFW32FALSE_EXIT(rbuffManifestPath.Win32Format(
|
|
L"%ls\\Manifests\\%ls.%ls",
|
|
static_cast<PCWSTR>(buffAssemblyRootDir),
|
|
static_cast<PCWSTR>(rbuffAssemblyDirectoryName),
|
|
FILE_EXTENSION_MANIFEST));
|
|
|
|
FN_EPILOG
|
|
}
|
|
|
|
|
|
|
|
|
|
CProtectionRequestRecord::CProtectionRequestRecord()
|
|
: m_dwAction(0), m_pvProtection(NULL), m_ulInRecoveryMode(0),
|
|
m_pParent(NULL),
|
|
m_bIsManPathResolved(FALSE),
|
|
m_bInitialized(FALSE)
|
|
{
|
|
}
|
|
|
|
BOOL
|
|
CProtectionRequestRecord::GetManifestPath(
|
|
CBaseStringBuffer &rsbManPath
|
|
)
|
|
{
|
|
BOOL bOk = FALSE;
|
|
FN_TRACE_WIN32(bOk);
|
|
|
|
rsbManPath.Clear();
|
|
|
|
if (!m_bIsManPathResolved)
|
|
{
|
|
m_bIsManPathResolved =
|
|
::SxspResolveAssemblyManifestPath(
|
|
m_sbAssemblyDirectoryName,
|
|
m_sbManifestPath);
|
|
}
|
|
|
|
if (m_bIsManPathResolved)
|
|
{
|
|
IFW32FALSE_EXIT(rsbManPath.Win32Assign(m_sbManifestPath));
|
|
}
|
|
else
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
bOk = TRUE;
|
|
Exit:
|
|
return bOk;
|
|
}
|
|
|
|
inline BOOL
|
|
CProtectionRequestRecord::GetManifestContent(CSecurityMetaData *&pMetaData)
|
|
{
|
|
FN_PROLOG_WIN32
|
|
FN_EPILOG
|
|
}
|
|
|
|
//
|
|
// Close down this request record.
|
|
//
|
|
CProtectionRequestRecord::~CProtectionRequestRecord()
|
|
{
|
|
if (m_bInitialized)
|
|
{
|
|
ClearList();
|
|
m_bInitialized = FALSE;
|
|
}
|
|
}
|
|
|
|
inline VOID
|
|
CProtectionRequestRecord::ClearList()
|
|
{
|
|
CStringListEntry *pTop;
|
|
|
|
while (pTop = (CStringListEntry*)SxspInterlockedPopEntrySList(&m_ListHeader))
|
|
{
|
|
FUSION_DELETE_SINGLETON(pTop);
|
|
}
|
|
}
|
|
|
|
inline BOOL
|
|
CProtectionRequestRecord::AddSubFile(
|
|
const CBaseStringBuffer &rbuffRelChange
|
|
)
|
|
{
|
|
CStringListEntry *pairing = NULL;
|
|
BOOL fSuccess = FALSE;
|
|
|
|
FN_TRACE_WIN32(fSuccess);
|
|
|
|
if (!SxspInterlockedCompareExchange(&m_ulInRecoveryMode, 0, 0))
|
|
{
|
|
IFALLOCFAILED_EXIT(pairing = new CStringListEntry);
|
|
IFW32FALSE_EXIT(pairing->m_sbText.Win32Assign(rbuffRelChange));
|
|
|
|
//
|
|
// Add it to the list (atomically, to boot!)
|
|
//
|
|
::SxspInterlockedPushEntrySList(&m_ListHeader, pairing);
|
|
pairing = NULL;
|
|
}
|
|
|
|
fSuccess = TRUE;
|
|
Exit:
|
|
if (pairing)
|
|
{
|
|
//
|
|
// The setup or something like that failed - release it here.
|
|
//
|
|
FUSION_DELETE_SINGLETON(pairing);
|
|
}
|
|
return fSuccess;
|
|
}
|
|
|
|
|
|
inline BOOL
|
|
CProtectionRequestRecord::Initialize(
|
|
const CBaseStringBuffer &rsbAssemblyDirectoryName,
|
|
const CBaseStringBuffer &rsbKeyString,
|
|
CProtectionRequestList* ParentList,
|
|
PVOID pvRequestRecord,
|
|
DWORD dwAction
|
|
)
|
|
{
|
|
BOOL fSuccess = FALSE;
|
|
|
|
FN_TRACE_WIN32(fSuccess);
|
|
|
|
m_sbAssemblyDirectoryName.Clear();
|
|
m_sbKeyValue.Clear();
|
|
m_sbManifestPath.Clear();
|
|
SxspInitializeSListHead(&m_ListHeader);
|
|
|
|
PARAMETER_CHECK(ParentList != NULL);
|
|
PARAMETER_CHECK(pvRequestRecord != NULL);
|
|
|
|
m_pParent = ParentList;
|
|
m_dwAction = dwAction;
|
|
m_pvProtection = (PSXS_PROTECT_DIRECTORY)pvRequestRecord;
|
|
|
|
IFW32FALSE_EXIT(m_sbAssemblyStore.Win32Assign(m_pvProtection->pwszDirectory, (m_pvProtection->pwszDirectory != NULL) ? ::wcslen(m_pvProtection->pwszDirectory) : 0));
|
|
IFW32FALSE_EXIT(m_sbAssemblyDirectoryName.Win32Assign(rsbAssemblyDirectoryName));
|
|
IFW32FALSE_EXIT(m_sbKeyValue.Win32Assign(rsbKeyString));
|
|
|
|
fSuccess = TRUE;
|
|
Exit:
|
|
return fSuccess;
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// Bad form: This returns a BOOL to indicate whether or not this class
|
|
// was able to pop something off the list. It's no good to ask "is the
|
|
// list empty," since that's not provided with this list class.
|
|
//
|
|
inline BOOL
|
|
CProtectionRequestRecord::PopNextFileChange(CBaseStringBuffer &Dest)
|
|
{
|
|
BOOL fFound = FALSE;
|
|
CStringListEntry *pPairing;
|
|
|
|
Dest.Clear();
|
|
pPairing = (CStringListEntry*)SxspInterlockedPopEntrySList(&m_ListHeader);
|
|
|
|
if (pPairing)
|
|
{
|
|
Dest.Win32Assign(pPairing->m_sbText);
|
|
FUSION_DELETE_SINGLETON(pPairing);
|
|
fFound = TRUE;
|
|
}
|
|
|
|
return fFound;
|
|
}
|
|
|
|
|
|
//
|
|
// "If a thread dies in winlogon, and no kernel debugger is attached, does it
|
|
// bugcheck the system?" - From 'The Zen of Dodgy Code'
|
|
//
|
|
DWORD
|
|
CProtectionRequestList::ProtectionNormalThreadProc(PVOID pvParam)
|
|
{
|
|
BOOL fSuccess = FALSE;
|
|
CProtectionRequestRecord *pRequestRecord = NULL;
|
|
CProtectionRequestList *pThis = NULL;
|
|
|
|
__try
|
|
{
|
|
pRequestRecord = static_cast<CProtectionRequestRecord*>(pvParam);
|
|
if (pRequestRecord)
|
|
{
|
|
pThis = pRequestRecord->GetParent();
|
|
}
|
|
if (pThis)
|
|
{
|
|
fSuccess = pThis->ProtectionNormalThreadProcWrapped(pRequestRecord);
|
|
}
|
|
}
|
|
__except(SXS_SFC_EXCEPTION_SETTING)
|
|
{
|
|
// Don't take down winlogon...
|
|
}
|
|
|
|
return static_cast<DWORD>(fSuccess);
|
|
}
|
|
|
|
BOOL
|
|
CProtectionRequestList::Initialize()
|
|
{
|
|
BOOL fSuccess = FALSE;
|
|
FN_TRACE_WIN32(fSuccess);
|
|
|
|
ASSERT(m_pInternalList == NULL);
|
|
|
|
::InitializeCriticalSectionAndSpinCount(&m_cSection, INITIALIZE_CRITICAL_SECTION_AND_SPIN_COUNT_ALLOCATE_NOW);
|
|
::InitializeCriticalSectionAndSpinCount(&m_cInstallerCriticalSection, INITIALIZE_CRITICAL_SECTION_AND_SPIN_COUNT_ALLOCATE_NOW);
|
|
IFW32FALSE_EXIT(::SxspAtExit(this));
|
|
|
|
IFALLOCFAILED_EXIT(m_pInternalList = new COurInternalTable);
|
|
IFW32FALSE_EXIT(m_pInternalList->Initialize());
|
|
|
|
IFALLOCFAILED_EXIT(m_pInstallsTable = new CInstallsInProgressTable);
|
|
IFW32FALSE_EXIT(m_pInstallsTable->Initialize());
|
|
|
|
//
|
|
// Manifest protection stuff
|
|
//
|
|
::SxspInitializeSListHead(&m_ManifestEditList);
|
|
|
|
m_hManifestEditHappened = ::CreateEventW(NULL, TRUE, FALSE, NULL);
|
|
if (m_hManifestEditHappened == NULL)
|
|
{
|
|
TRACE_WIN32_FAILURE_ORIGINATION(CreateEventW);
|
|
goto Exit;
|
|
}
|
|
|
|
ASSERT(m_pInternalList != NULL);
|
|
ASSERT(m_pInstallsTable != NULL);
|
|
|
|
fSuccess = TRUE;
|
|
Exit:
|
|
return fSuccess;
|
|
}
|
|
|
|
CProtectionRequestList::CProtectionRequestList()
|
|
: m_pInternalList(NULL), m_pInstallsTable(NULL),
|
|
m_hManifestEditHappened(INVALID_HANDLE_VALUE),
|
|
m_ulIsAThreadServicingManifests(0)
|
|
|
|
{
|
|
}
|
|
|
|
|
|
CProtectionRequestList::~CProtectionRequestList()
|
|
{
|
|
::DeleteCriticalSection(&m_cSection);
|
|
::DeleteCriticalSection(&m_cInstallerCriticalSection);
|
|
|
|
COurInternalTable *pTempListing = m_pInternalList;
|
|
CInstallsInProgressTable *pInstalls = m_pInstallsTable;
|
|
|
|
m_pInternalList = NULL;
|
|
m_pInternalList = NULL;
|
|
|
|
if (pTempListing != NULL)
|
|
{
|
|
pTempListing->Clear(this, &CProtectionRequestList::ClearProtectionItems);
|
|
FUSION_DELETE_SINGLETON(pTempListing);
|
|
}
|
|
|
|
if (pInstalls != NULL)
|
|
{
|
|
pInstalls->ClearNoCallback();
|
|
FUSION_DELETE_SINGLETON(pInstalls);
|
|
}
|
|
|
|
}
|
|
|
|
BOOL
|
|
CProtectionRequestList::IsSfcIgnoredStoreSubdir(PCWSTR wsz)
|
|
{
|
|
FN_TRACE();
|
|
|
|
ASSERT(m_arrIgnorableSubdirs);
|
|
|
|
for (SIZE_T i = 0; i < m_cIgnorableSubdirs; i++)
|
|
{
|
|
if (!::FusionpStrCmpI(m_arrIgnorableSubdirs[i], wsz))
|
|
{
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
BOOL
|
|
CProtectionRequestList::AttemptRemoveItem(CProtectionRequestRecord *AttemptRemoval)
|
|
{
|
|
//
|
|
// This quickly indicates that the progress is complete and just returns to
|
|
// the caller.
|
|
//
|
|
const CBaseStringBuffer &sbKey = AttemptRemoval->GetChangeBasePath();
|
|
BOOL fSuccess = FALSE;
|
|
CSxsLockCriticalSection lock(m_cSection);
|
|
|
|
FN_TRACE_WIN32(fSuccess);
|
|
PARAMETER_CHECK(AttemptRemoval != NULL);
|
|
|
|
IFW32FALSE_EXIT(lock.Lock());
|
|
//
|
|
// This item is no longer in service. Please check the item and
|
|
// try your call again. The nice thing is that Remove on CStringPtrTable
|
|
// knows to delete the value lickety-split before returning. This isn't
|
|
// such a bad thing, but it's ... different.
|
|
//
|
|
m_pInternalList->Remove(sbKey, NULL);
|
|
|
|
fSuccess = TRUE;
|
|
Exit:
|
|
return fSuccess;
|
|
}
|
|
|
|
BOOL
|
|
CProtectionRequestList::AddRequest(
|
|
PSXS_PROTECT_DIRECTORY pProtect,
|
|
PCWSTR pcwszDirName,
|
|
SIZE_T cchName,
|
|
DWORD dwAction
|
|
)
|
|
{
|
|
BOOL fSuccess = FALSE;
|
|
bool fIsManifestEdit = false;
|
|
BOOL fIsIgnorable;
|
|
BOOL fNewAddition = FALSE;
|
|
CSmallStringBuffer sbTemp;
|
|
CSmallStringBuffer sbAssemblyDirectoryName;
|
|
CSmallStringBuffer sbRequestText;
|
|
CSmallStringBuffer buffManifestsDirectoryName;
|
|
CSmallStringBuffer buffManifestsShortDirectoryName;
|
|
CProtectionRequestRecord *pRecord = NULL;
|
|
CProtectionRequestRecord *ppFoundInTable = NULL;
|
|
CSxsLockCriticalSection lock(m_cSection);
|
|
|
|
FN_TRACE_WIN32(fSuccess);
|
|
|
|
//
|
|
// The key here is the first characters (up to the first slash) in the
|
|
// notification name. If there's no slash in the notification name, then
|
|
// we can ignore this change request, since nothing important happened.
|
|
//
|
|
IFW32FALSE_EXIT(sbTemp.Win32Assign(pProtect->pwszDirectory, (pProtect->pwszDirectory != NULL) ? ::wcslen(pProtect->pwszDirectory) : 0));
|
|
IFW32FALSE_EXIT(sbRequestText.Win32Assign(pcwszDirName, cchName));
|
|
IFW32FALSE_EXIT(sbRequestText.Win32GetFirstPathElement(sbAssemblyDirectoryName));
|
|
|
|
fIsIgnorable = IsSfcIgnoredStoreSubdir(sbAssemblyDirectoryName);
|
|
|
|
fIsManifestEdit = !::FusionpStrCmpI(sbAssemblyDirectoryName, MANIFEST_ROOT_DIRECTORY_NAME);
|
|
|
|
if (!fIsManifestEdit)
|
|
{
|
|
DWORD dwTemp;
|
|
CStringBufferAccessor acc;
|
|
|
|
IFW32FALSE_EXIT(::SxspGetAssemblyRootDirectory(buffManifestsDirectoryName));
|
|
IFW32FALSE_EXIT(buffManifestsDirectoryName.Win32AppendPathElement(MANIFEST_ROOT_DIRECTORY_NAME, NUMBER_OF(MANIFEST_ROOT_DIRECTORY_NAME) - 1));
|
|
|
|
acc.Attach(&buffManifestsShortDirectoryName);
|
|
IFW32ZERO_ORIGINATE_AND_EXIT(dwTemp = ::GetShortPathNameW(buffManifestsDirectoryName, acc.GetBufferPtr(), acc.GetBufferCchAsDWORD()));
|
|
while (dwTemp >= acc.GetBufferCchAsDWORD())
|
|
{
|
|
acc.Detach();
|
|
IFW32FALSE_EXIT(buffManifestsShortDirectoryName.Win32ResizeBuffer(dwTemp, eDoNotPreserveBufferContents));
|
|
acc.Attach(&buffManifestsShortDirectoryName);
|
|
IFW32ZERO_ORIGINATE_AND_EXIT(dwTemp = ::GetShortPathNameW(buffManifestsDirectoryName, acc.GetBufferPtr(), acc.GetBufferCchAsDWORD()));
|
|
}
|
|
|
|
acc.Detach();
|
|
|
|
// Ok all that work and now we finally have the manifests directory name as a short string. Let's abuse buffManifestsShortDirectoryName
|
|
// to just hold the short name of the manifests directory.
|
|
|
|
IFW32FALSE_EXIT(buffManifestsShortDirectoryName.Win32GetLastPathElement(buffManifestsDirectoryName));
|
|
|
|
if (::FusionpCompareStrings(
|
|
buffManifestsDirectoryName,
|
|
sbAssemblyDirectoryName,
|
|
true) == 0)
|
|
{
|
|
// Convert the directory name to its proper long form
|
|
IFW32FALSE_EXIT(sbAssemblyDirectoryName.Win32Assign(MANIFEST_ROOT_DIRECTORY_NAME, NUMBER_OF(MANIFEST_ROOT_DIRECTORY_NAME) - 1));
|
|
fIsManifestEdit = true;
|
|
}
|
|
}
|
|
|
|
if ((fIsIgnorable) && (!fIsManifestEdit))
|
|
{
|
|
#if DBG
|
|
//
|
|
// We get a lot of these.
|
|
//
|
|
if (::FusionpStrCmpI(sbAssemblyDirectoryName, L"InstallTemp") != 0)
|
|
{
|
|
::FusionpDbgPrintEx(
|
|
FUSION_DBG_LEVEL_WFP,
|
|
"SXS.DLL: %s() - %ls is ignorable (%d)\n",
|
|
__FUNCTION__,
|
|
static_cast<PCWSTR>(sbAssemblyDirectoryName),
|
|
fIsIgnorable
|
|
);
|
|
}
|
|
#endif
|
|
fSuccess = TRUE;
|
|
goto Exit;
|
|
}
|
|
|
|
//
|
|
// The "key" value here is the full path to the assembly that we're protecting.
|
|
// This is what we'll store in the table.
|
|
//
|
|
IFW32FALSE_EXIT(sbTemp.Win32AppendPathElement(sbAssemblyDirectoryName));
|
|
|
|
|
|
if (fIsManifestEdit)
|
|
{
|
|
CStringListEntry *pEntry = NULL;
|
|
ULONG ulWasSomeoneServicing = 0;
|
|
|
|
//
|
|
// Create a new manifest edit slot, add it to the list of items that are being
|
|
// serviced.
|
|
//
|
|
IFALLOCFAILED_EXIT(pEntry = new CStringListEntry);
|
|
if (!pEntry->m_sbText.Win32Assign(sbRequestText))
|
|
{
|
|
TRACE_WIN32_FAILURE(m_sbText.Win32Assign);
|
|
FUSION_DELETE_SINGLETON(pEntry);
|
|
pEntry = NULL;
|
|
goto Exit;
|
|
}
|
|
SxspInterlockedPushEntrySList(&m_ManifestEditList, pEntry);
|
|
pEntry = NULL;
|
|
|
|
//
|
|
// Tell anyone that's listening that we have a new manifest edit here
|
|
//
|
|
SetEvent(m_hManifestEditHappened);
|
|
|
|
//
|
|
// See if someone is servicing the queue at the moment
|
|
//
|
|
ulWasSomeoneServicing = SxspInterlockedCompareExchange(&m_ulIsAThreadServicingManifests, 1, 0);
|
|
|
|
if (!ulWasSomeoneServicing)
|
|
{
|
|
QueueUserWorkItem(ProtectionManifestThreadProc, (PVOID)this, WT_EXECUTEDEFAULT);
|
|
}
|
|
|
|
fSuccess = TRUE;
|
|
goto Exit;
|
|
}
|
|
|
|
//
|
|
// At this point, we need to see if the chunk that we identified is currently
|
|
// in the list of things to be validated. If not, it gets added and a thread
|
|
// is spun off to work on it. Otherwise, an entry may already exist in a
|
|
// thread that's being serviced, and so it needs to be deleted.
|
|
//
|
|
IFW32FALSE_EXIT(lock.Lock());
|
|
m_pInternalList->Find(sbTemp, ppFoundInTable);
|
|
|
|
if (!ppFoundInTable)
|
|
{
|
|
IFALLOCFAILED_EXIT(pRecord = new CProtectionRequestRecord);
|
|
#if DBG
|
|
::FusionpDbgPrintEx(
|
|
FUSION_DBG_LEVEL_WFP,
|
|
"SXS.DLL: %s() - Creating protection record for %ls:\n"
|
|
"\tKey = %ls\n"
|
|
"\tManifest? = %d\n"
|
|
"\tProtectionRecord = %p\n"
|
|
"\tAction = %d\n",
|
|
__FUNCTION__,
|
|
static_cast<PCWSTR>(sbAssemblyDirectoryName),
|
|
static_cast<PCWSTR>(sbTemp),
|
|
fIsManifestEdit,
|
|
pProtect,
|
|
dwAction);
|
|
#endif
|
|
IFW32FALSE_EXIT(pRecord->Initialize(
|
|
sbAssemblyDirectoryName,
|
|
sbTemp,
|
|
this,
|
|
pProtect,
|
|
dwAction));
|
|
|
|
//
|
|
// Add this first request to be serviced, then spin a thread to start it.
|
|
//
|
|
m_pInternalList->Insert(sbTemp, pRecord);
|
|
fNewAddition = TRUE;
|
|
|
|
//
|
|
// A little bookkeeping ... so we don't accidentally use it later.
|
|
//
|
|
ppFoundInTable = pRecord;
|
|
pRecord = NULL;
|
|
}
|
|
|
|
//
|
|
// If we actually got something into the table...
|
|
//
|
|
if (ppFoundInTable)
|
|
{
|
|
ppFoundInTable->AddSubFile(sbRequestText);
|
|
|
|
//
|
|
// If this is a new thing in the table (ie: we inserted it ourselves)
|
|
// then we should go and spin up a thread for it.
|
|
//
|
|
if (fNewAddition)
|
|
{
|
|
QueueUserWorkItem(ProtectionNormalThreadProc, (PVOID)ppFoundInTable, WT_EXECUTEDEFAULT);
|
|
}
|
|
}
|
|
|
|
fSuccess = TRUE;
|
|
|
|
Exit:
|
|
DWORD dwLastError = ::FusionpGetLastWin32Error();
|
|
if (pRecord)
|
|
{
|
|
//
|
|
// If this is still set, something bad happened in the process of trying to
|
|
// create/find this object. Delete it here.
|
|
//
|
|
FUSION_DELETE_SINGLETON(pRecord);
|
|
pRecord = NULL;
|
|
}
|
|
::FusionpSetLastWin32Error(dwLastError);
|
|
return fSuccess;
|
|
}
|
|
|
|
static BYTE p_bProtectionListBuffer[ sizeof(CProtectionRequestList) * 2 ];
|
|
PCWSTR CProtectionRequestList::m_arrIgnorableSubdirs[] =
|
|
{
|
|
ASSEMBLY_INSTALL_TEMP_DIR_NAME,
|
|
POLICY_ROOT_DIRECTORY_NAME,
|
|
REGISTRY_BACKUP_ROOT_DIRECTORY_NAME
|
|
};
|
|
SIZE_T CProtectionRequestList::m_cIgnorableSubdirs =
|
|
NUMBER_OF(CProtectionRequestList::m_arrIgnorableSubdirs);
|
|
|
|
BOOL
|
|
SxspIsSfcIgnoredStoreSubdir(PCWSTR pwsz)
|
|
{
|
|
return CProtectionRequestList::IsSfcIgnoredStoreSubdir(pwsz);
|
|
}
|
|
|
|
BOOL
|
|
SxspConstructProtectionList()
|
|
{
|
|
CProtectionRequestList *pTemp = NULL;
|
|
BOOL fSuccess = FALSE;
|
|
|
|
FN_TRACE_WIN32(fSuccess);
|
|
|
|
//
|
|
// This only gets called once, if they know what's good for them.
|
|
//
|
|
ASSERT(!g_ProtectionRequestList);
|
|
|
|
//
|
|
// Construct - this should never fail, but if it does, there's trouble.
|
|
//
|
|
pTemp = new (&p_bProtectionListBuffer) CProtectionRequestList;
|
|
if (!pTemp)
|
|
{
|
|
::FusionpDbgPrintEx(FUSION_DBG_LEVEL_ERROR, "SXS: %s() - Failed placement new of CProtectionRequestList????\n", __FUNCTION__);
|
|
::FusionpSetLastWin32Error(FUSION_WIN32_ALLOCFAILED_ERROR);
|
|
TRACE_WIN32_FAILURE_ORIGINATION(new(CProtectionRequestList));
|
|
goto Exit;
|
|
}
|
|
IFW32FALSE_EXIT(pTemp->Initialize());
|
|
|
|
g_ProtectionRequestList = pTemp;
|
|
pTemp = NULL;
|
|
|
|
//
|
|
// Create our logon event.
|
|
//
|
|
IFW32NULL_EXIT(g_hSxsLoginEvent = CreateEventW(NULL, TRUE, FALSE, NULL));
|
|
|
|
fSuccess = TRUE;
|
|
Exit:
|
|
|
|
if (pTemp)
|
|
{
|
|
//
|
|
// If this is still set, then something failed somewhere in the construction
|
|
// code for the protection system. We don't want to delete it, per-se, but
|
|
// we need to just null out everything.
|
|
//
|
|
g_ProtectionRequestList = NULL;
|
|
pTemp = NULL;
|
|
g_hSxsLoginEvent = NULL;
|
|
}
|
|
|
|
return fSuccess;
|
|
}
|
|
|
|
|
|
|
|
BOOL WINAPI
|
|
SxsProtectionNotifyW(
|
|
PVOID pvCookie,
|
|
PCWSTR wsChangeText,
|
|
SIZE_T cchChangeText,
|
|
DWORD dwChangeAction
|
|
)
|
|
{
|
|
BOOL fSuccess;
|
|
|
|
#if YOU_ARE_HAVING_ANY_WIERDNESS_WITH_SFC_AND_SXS
|
|
fSuccess = TRUE;
|
|
return TRUE;
|
|
#else
|
|
|
|
if (::FusionpDbgWouldPrintAtFilterLevel(FUSION_DBG_LEVEL_FILECHANGENOT))
|
|
{
|
|
const USHORT Length = (cchChangeText > UNICODE_STRING_MAX_CHARS) ? UNICODE_STRING_MAX_BYTES : ((USHORT) (cchChangeText * sizeof(WCHAR)));
|
|
const UNICODE_STRING u = { Length, Length, const_cast<PWSTR>(wsChangeText) };
|
|
|
|
::FusionpDbgPrintEx(
|
|
FUSION_DBG_LEVEL_FILECHANGENOT,
|
|
"[%lx.%lx: %wZ] SXS FCN (cookie, action, text): %p, %lu, \"%wZ\"\n",
|
|
HandleToULong(NtCurrentTeb()->ClientId.UniqueProcess),
|
|
HandleToULong(NtCurrentTeb()->ClientId.UniqueThread),
|
|
&NtCurrentPeb()->ProcessParameters->ImagePathName,
|
|
pvCookie,
|
|
dwChangeAction,
|
|
&u);
|
|
}
|
|
|
|
//
|
|
// If we're not accepting notifications, then quit out immediately.
|
|
//
|
|
if (!s_fIsSfcAcceptingNotifications)
|
|
{
|
|
fSuccess = TRUE;
|
|
goto Exit;
|
|
}
|
|
|
|
//
|
|
// Having done this in the wrong order is also a Bad Bad Thing
|
|
//
|
|
ASSERT2_NTC(g_ProtectionRequestList != NULL, "SXS.DLL: Protection - Check order of operations, g_ProtectionRequestList is invalid!!\n");
|
|
|
|
//
|
|
// Let's not take down winlogon, shall we?
|
|
//
|
|
__try
|
|
{
|
|
fSuccess = g_ProtectionRequestList->AddRequest(
|
|
(PSXS_PROTECT_DIRECTORY)pvCookie,
|
|
wsChangeText,
|
|
cchChangeText,
|
|
dwChangeAction);
|
|
}
|
|
__except(SXS_SFC_EXCEPTION_SETTING)
|
|
{
|
|
}
|
|
|
|
fSuccess = TRUE;
|
|
Exit:
|
|
return fSuccess;
|
|
#endif
|
|
}
|
|
|
|
BOOL
|
|
CProtectionRequestList::ProtectionManifestThreadProcNoSEH(LPVOID pvParam)
|
|
{
|
|
BOOL fSuccess = FALSE;
|
|
CProtectionRequestList *pThis;
|
|
|
|
FN_TRACE_WIN32(fSuccess);
|
|
|
|
PARAMETER_CHECK(pvParam != NULL);
|
|
|
|
pThis = reinterpret_cast<CProtectionRequestList*>(pvParam);
|
|
IFW32FALSE_EXIT(pThis->ProtectionManifestThreadProcWrapped());
|
|
fSuccess = TRUE;
|
|
Exit:
|
|
return fSuccess;
|
|
}
|
|
|
|
|
|
DWORD
|
|
CProtectionRequestList::ProtectionManifestThreadProc(LPVOID pvParam)
|
|
{
|
|
BOOL fSuccess = FALSE;
|
|
__try
|
|
{
|
|
fSuccess = ProtectionManifestThreadProcNoSEH(pvParam);
|
|
}
|
|
__except(SXS_SFC_EXCEPTION_SETTING)
|
|
{
|
|
//
|
|
// Whoops..
|
|
//
|
|
}
|
|
|
|
return static_cast<DWORD>(fSuccess);
|
|
}
|
|
|
|
|
|
BOOL
|
|
CProtectionRequestList::ProtectionManifestSingleManifestWorker(
|
|
const CStringListEntry *pEntry
|
|
)
|
|
{
|
|
BOOL fSuccess = FALSE;
|
|
FN_TRACE_WIN32(fSuccess);
|
|
|
|
CStringBuffer sbAssemblyDirectoryName;
|
|
CStringBuffer sbManifestPath;
|
|
CAssemblyRecoveryInfo RecoverInfo;
|
|
SxsRecoveryResult RecoverResult;
|
|
HashValidateResult HashValidResult;
|
|
BOOL fCatalogPresent = FALSE;
|
|
bool fNoAssembly;
|
|
|
|
PARAMETER_CHECK(pEntry);
|
|
|
|
//
|
|
// Calculate the name of the assembly based on the middling part of
|
|
// the string
|
|
//
|
|
IFW32FALSE_EXIT(sbAssemblyDirectoryName.Win32Assign(pEntry->m_sbText));
|
|
IFW32FALSE_EXIT(sbAssemblyDirectoryName.Win32RemoveFirstPathElement());
|
|
IFW32FALSE_EXIT(sbAssemblyDirectoryName.Win32ClearPathExtension());
|
|
|
|
if (sbAssemblyDirectoryName.Cch() == 0)
|
|
FN_SUCCESSFUL_EXIT();
|
|
|
|
//
|
|
// Try mashing this into an assembly name/recovery info
|
|
//
|
|
IFW32FALSE_EXIT(RecoverInfo.AssociateWithAssembly(sbAssemblyDirectoryName, fNoAssembly));
|
|
|
|
// If we couldn't figure out what this was for, we have to ignore it.
|
|
if (fNoAssembly)
|
|
{
|
|
#if DBG
|
|
::FusionpDbgPrintEx(FUSION_DBG_LEVEL_WFP,
|
|
"SXS.DLL: %s() - File \"%ls\" in the manifest directory modified, but could not be mapped to an assembly. IGNORING.\n",
|
|
__FUNCTION__,
|
|
static_cast<PCWSTR>(pEntry->m_sbText));
|
|
#endif
|
|
|
|
FN_SUCCESSFUL_EXIT();
|
|
}
|
|
|
|
//
|
|
// Now that we have the recovery info..
|
|
//
|
|
if (!RecoverInfo.GetHasCatalog())
|
|
{
|
|
#if DBG
|
|
::FusionpDbgPrintEx(
|
|
FUSION_DBG_LEVEL_WFP,
|
|
"SXS.DLL: %s() - Assembly %ls was in the registry, but without a catalog so we aren't protecting it\n",
|
|
__FUNCTION__,
|
|
static_cast<PCWSTR>(sbAssemblyDirectoryName));
|
|
#endif
|
|
|
|
FN_SUCCESSFUL_EXIT();
|
|
}
|
|
|
|
//
|
|
// Resolve the manifest path, then validate
|
|
//
|
|
IFW32FALSE_EXIT(::SxspResolveAssemblyManifestPath(sbAssemblyDirectoryName, sbManifestPath));
|
|
|
|
IFW32FALSE_EXIT(
|
|
::SxspVerifyFileHash(
|
|
SVFH_RETRY_LOGIC_SIMPLE,
|
|
sbManifestPath,
|
|
RecoverInfo.GetSecurityInformation().GetManifestHash(),
|
|
CALG_SHA1,
|
|
HashValidResult));
|
|
|
|
IFW32FALSE_EXIT(::SxspEnsureCatalogStillPresentForManifest(sbManifestPath, fCatalogPresent));
|
|
|
|
//
|
|
// Reinstall needed?
|
|
//
|
|
if ((HashValidResult != HashValidate_Matches) || !fCatalogPresent)
|
|
IFW32FALSE_EXIT(this->PerformRecoveryOfAssembly(RecoverInfo, NULL, RecoverResult));
|
|
|
|
fSuccess = TRUE;
|
|
Exit:
|
|
return fSuccess;
|
|
}
|
|
|
|
|
|
BOOL
|
|
CProtectionRequestList::ProtectionManifestThreadProcWrapped()
|
|
{
|
|
|
|
BOOL fSuccess = FALSE;
|
|
BOOL bFoundItemsThisTimeAround;
|
|
CStringListEntry *pNextItem = NULL;
|
|
DWORD dwWaitResult;
|
|
|
|
FN_TRACE_WIN32(fSuccess);
|
|
|
|
bFoundItemsThisTimeAround = FALSE;
|
|
|
|
do
|
|
{
|
|
//
|
|
// Yes, mother, we hear you.
|
|
//
|
|
ResetEvent(m_hManifestEditHappened);
|
|
|
|
//
|
|
// Pull the next thing off the list and service it.
|
|
//
|
|
while (pNextItem = (CStringListEntry*)SxspInterlockedPopEntrySList(&m_ManifestEditList))
|
|
{
|
|
bFoundItemsThisTimeAround = TRUE;
|
|
|
|
if (!this->ProtectionManifestSingleManifestWorker(pNextItem))
|
|
::FusionpDbgPrintEx(
|
|
FUSION_DBG_LEVEL_WFP,
|
|
"SXS: %s - Processing work item %p failed\n", __FUNCTION__, pNextItem);
|
|
|
|
FUSION_DELETE_SINGLETON(pNextItem);
|
|
}
|
|
|
|
//
|
|
// Loaf about for a bit and see if anyone else has stuff for us to do
|
|
//
|
|
dwWaitResult = ::WaitForSingleObject(m_hManifestEditHappened, 3000);
|
|
if (dwWaitResult == WAIT_TIMEOUT)
|
|
{
|
|
::SxspInterlockedExchange(&m_ulIsAThreadServicingManifests, 0);
|
|
break;
|
|
}
|
|
else if (dwWaitResult == WAIT_OBJECT_0)
|
|
{
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
TRACE_WIN32_FAILURE_ORIGINATION(WaitForSingleObject);
|
|
goto Exit;
|
|
}
|
|
|
|
}
|
|
while (true);
|
|
|
|
fSuccess = TRUE;
|
|
Exit:
|
|
return fSuccess;
|
|
}
|
|
|
|
|
|
|
|
|
|
BOOL
|
|
CProtectionRequestList::ProtectionNormalThreadProcWrapped(
|
|
CProtectionRequestRecord *pRequestRecord
|
|
)
|
|
{
|
|
BOOL fSuccess = FALSE;
|
|
FN_TRACE_WIN32(fSuccess);
|
|
|
|
CProtectionRequestRecord &rRequest = *pRequestRecord;
|
|
CProtectionRequestList *pRequestList = rRequest.GetParent();
|
|
|
|
BOOL fNeedsReinstall = FALSE;
|
|
BOOL fAssemblyNotFound = FALSE;
|
|
|
|
DWORD dwAsmPathAttribs;
|
|
|
|
SxsRecoveryResult RecoverResult;
|
|
|
|
CSmallStringBuffer buffFullPathOfChange;
|
|
CSmallStringBuffer buffAssemblyStore;
|
|
CSmallStringBuffer buffAssemblyRelativeChange;
|
|
|
|
bool fNoAssembly;
|
|
|
|
|
|
//
|
|
// The request's key value contains the full path of the assembly that
|
|
// is being modified, in theory. So, we can just use it locally.
|
|
//
|
|
CStringBuffer rbuffAssemblyDirectoryName;
|
|
const CBaseStringBuffer &rbuffAssemblyPath = rRequest.GetChangeBasePath();
|
|
CAssemblyRecoveryInfo &rRecoveryInfo = rRequest.GetRecoveryInfo();
|
|
CSecurityMetaData &rSecurityMetaData = rRecoveryInfo.GetSecurityInformation();
|
|
|
|
//
|
|
// this name could be changes because the assemblyName in the request could be a short name,
|
|
// in this case, we need reset the AssemblyName in rRequest
|
|
//
|
|
IFW32FALSE_EXIT(rbuffAssemblyDirectoryName.Win32Assign(rRequest.GetAssemblyDirectoryName()));
|
|
|
|
//
|
|
// This value should not change at all during this function. Save it here.
|
|
//
|
|
IFW32FALSE_EXIT(rRequest.GetAssemblyStore(buffAssemblyStore));
|
|
|
|
//
|
|
// The big question of the day - find out the recovery information for this
|
|
// assembly. See if there was a catalog at installation time (a) or find out
|
|
// whether or not there is a catalog for it right now.
|
|
//
|
|
IFW32FALSE_EXIT(rRecoveryInfo.AssociateWithAssembly(rbuffAssemblyDirectoryName, fNoAssembly));
|
|
|
|
// If we couldn't figure out what assembly this was for, we ignore it.
|
|
if (fNoAssembly)
|
|
FN_SUCCESSFUL_EXIT();
|
|
|
|
//
|
|
// if rbuffAssemblyName is different from the assemblyname from rRequest,
|
|
// it must be a short name, we must reset the AssemblyName in rRequest
|
|
//
|
|
StringComparisonResult scr;
|
|
IFW32FALSE_EXIT(rbuffAssemblyDirectoryName.Win32Compare(rRequest.GetAssemblyDirectoryName(), rRequest.GetAssemblyDirectoryName().Cch(), scr, NORM_IGNORECASE));
|
|
if (scr != eEquals)
|
|
IFW32FALSE_EXIT(rRequest.SetAssemblyDirectoryName(rbuffAssemblyDirectoryName));
|
|
|
|
if (rRecoveryInfo.GetInfoPrepared() == FALSE)
|
|
ORIGINATE_WIN32_FAILURE_AND_EXIT(RecoveryInfoCouldNotBePrepared, ERROR_PATH_NOT_FOUND);
|
|
|
|
if (!rRecoveryInfo.GetHasCatalog())
|
|
{
|
|
#if DBG
|
|
::FusionpDbgPrintEx(
|
|
FUSION_DBG_LEVEL_WFP | FUSION_DBG_LEVEL_INFO,
|
|
"SXS.DLL: %s - Assembly %ls not registered with catalog, WFP ignoring it.\n",
|
|
__FUNCTION__,
|
|
static_cast<PCWSTR>(rbuffAssemblyDirectoryName));
|
|
#endif
|
|
fSuccess = TRUE;
|
|
goto Exit;
|
|
}
|
|
|
|
//
|
|
// See if it still exists...
|
|
//
|
|
dwAsmPathAttribs = ::GetFileAttributesW(rbuffAssemblyPath);
|
|
if (dwAsmPathAttribs == INVALID_FILE_ATTRIBUTES)
|
|
{
|
|
::FusionpDbgPrintEx(
|
|
FUSION_DBG_LEVEL_WFP,
|
|
"SXS.DLL: WFP reinstalling assembly because GetFileAttributesW(\"%ls\") failed with win32 error %ld\n",
|
|
static_cast<PCWSTR>(rbuffAssemblyPath),
|
|
::FusionpGetLastWin32Error());
|
|
|
|
fNeedsReinstall = TRUE;
|
|
goto DoReinstall;
|
|
}
|
|
//
|
|
// Otherwise, is it maybe not a directory for one reason or another?
|
|
//
|
|
else if (!(dwAsmPathAttribs & FILE_ATTRIBUTE_DIRECTORY))
|
|
{
|
|
#if DBG
|
|
::FusionpDbgPrintEx(
|
|
FUSION_DBG_LEVEL_ERROR,
|
|
"SXS.DLL:%s - %ws isn't a directory, we should attempt to remove it?\n",
|
|
__FUNCTION__,
|
|
static_cast<PCWSTR>(rbuffAssemblyPath));
|
|
#endif
|
|
FN_SUCCESSFUL_EXIT();
|
|
}
|
|
|
|
|
|
//
|
|
// Find out whether or not the file is still OK by checking against the manifest
|
|
//
|
|
{
|
|
HashValidateResult HashValid;
|
|
CStringBuffer buffManifestFullPath;
|
|
BOOL fPresent;
|
|
|
|
IFW32FALSE_EXIT(::SxspGetAssemblyRootDirectory( buffFullPathOfChange ) );
|
|
IFW32FALSE_EXIT(::SxspCreateManifestFileNameFromTextualString(
|
|
0,
|
|
SXSP_GENERATE_SXS_PATH_PATHTYPE_MANIFEST,
|
|
buffFullPathOfChange,
|
|
rSecurityMetaData.GetTextualIdentity(),
|
|
buffManifestFullPath) );
|
|
|
|
#if DBG
|
|
::FusionpDbgPrintEx(FUSION_DBG_LEVEL_WFP,
|
|
"SXS.DLL:%s - Checking to see if manifest %ls is OK\n",
|
|
__FUNCTION__,
|
|
static_cast<PCWSTR>(buffManifestFullPath));
|
|
#endif
|
|
|
|
IFW32FALSE_EXIT(::SxspVerifyFileHash(
|
|
SVFH_RETRY_LOGIC_SIMPLE,
|
|
buffManifestFullPath,
|
|
rSecurityMetaData.GetManifestHash(),
|
|
CALG_SHA1,
|
|
HashValid));
|
|
|
|
#if DBG
|
|
FusionpDbgPrintEx( FUSION_DBG_LEVEL_WFP,
|
|
"SXS.DLL:%s - Manifest %ls checks %ls\n",
|
|
__FUNCTION__,
|
|
static_cast<PCWSTR>(buffManifestFullPath),
|
|
SxspHashValidateResultToString(HashValid) );
|
|
#endif
|
|
|
|
if ( HashValid != HashValidate_Matches )
|
|
{
|
|
fNeedsReinstall = TRUE;
|
|
goto DoReinstall;
|
|
}
|
|
|
|
//
|
|
// Let's just ensure the catalog is there - it's not necessary anymore
|
|
// for the protection pass, but it should be there if someone wants to
|
|
// repackage the assembly for distribution.
|
|
//
|
|
IFW32FALSE_EXIT(::SxspEnsureCatalogStillPresentForManifest(buffManifestFullPath, fPresent));
|
|
if ( !fPresent )
|
|
{
|
|
fNeedsReinstall = TRUE;
|
|
goto DoReinstall;
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// Now we can loop through the items in our list of things to be evaluated and
|
|
// see if any of them are bad (or missing, or whatever.)
|
|
//
|
|
// Start out by touching the thing that indicates the last time we spun through
|
|
// here and looked at the file list.
|
|
//
|
|
while (!fNeedsReinstall)
|
|
{
|
|
const CMetaDataFileElement* pFileDataElement = NULL;
|
|
HashValidateResult Valid = HashValidate_OtherProblems;
|
|
BOOL fFileNotFound;
|
|
|
|
if (!rRequest.PopNextFileChange(buffAssemblyRelativeChange))
|
|
{
|
|
break;
|
|
}
|
|
|
|
IFW32FALSE_EXIT(buffAssemblyRelativeChange.Win32RemoveFirstPathElement());
|
|
|
|
//
|
|
// The change here is really to the top level directory - don't
|
|
// bother doing anything in this case. Maybe we should catch
|
|
// this beforehand so we don't do the work of parsing?
|
|
//
|
|
if (buffAssemblyRelativeChange.Cch() == 0)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
|
|
//
|
|
// Acquire the security data
|
|
//
|
|
IFW32FALSE_EXIT( rSecurityMetaData.GetFileMetaData(
|
|
buffAssemblyRelativeChange,
|
|
pFileDataElement ) );
|
|
|
|
//
|
|
// There wasn't any data for this file? Means we don't know about the file, so we
|
|
// probably should do /something/ about it. For now, however, with the agreeance of
|
|
// the backup team, we let sleeping files lie.
|
|
if ( pFileDataElement == NULL )
|
|
{
|
|
//
|
|
// because short-filename is not stored in registry, so for a filename, which might be long-pathname
|
|
// or a short pathname, if we try out all entries in the Registry and still can not find it,
|
|
// we assume it is a short filename. In this case, we would verify the assembly, if it is not intact,
|
|
// do reinstall for the assembly....
|
|
//
|
|
|
|
DWORD dwResult;
|
|
|
|
IFW32FALSE_EXIT(::SxspValidateEntireAssembly(
|
|
SXS_VALIDATE_ASM_FLAG_CHECK_EVERYTHING,
|
|
rRecoveryInfo,
|
|
dwResult));
|
|
|
|
fNeedsReinstall = ( dwResult != SXS_VALIDATE_ASM_FLAG_VALID_PERFECT );
|
|
goto DoReinstall;
|
|
}
|
|
|
|
//
|
|
// And build the full path of the change via:
|
|
//
|
|
// sbAssemblyPath + \ + buffAssemblyRelativeChange
|
|
//
|
|
IFW32FALSE_EXIT(buffFullPathOfChange.Win32Assign(rbuffAssemblyPath));
|
|
IFW32FALSE_EXIT(buffFullPathOfChange.Win32AppendPathElement(buffAssemblyRelativeChange));
|
|
|
|
//
|
|
// We really should check the return value here, but the
|
|
// function is smart enough to set Valid to something useful
|
|
// before returning. A failure here should NOT be an IFW32FALSE_EXIT
|
|
// call, mostly because we don't want to stop protecting this
|
|
// assembly just because it failed with a FILE_NOT_FOUND or other
|
|
// such.
|
|
//
|
|
IFW32FALSE_EXIT_UNLESS(::SxspValidateAllFileHashes(
|
|
*pFileDataElement,
|
|
buffFullPathOfChange,
|
|
Valid ),
|
|
FILE_OR_PATH_NOT_FOUND(::FusionpGetLastWin32Error()),
|
|
fFileNotFound );
|
|
|
|
if ( ( Valid != HashValidate_Matches ) || fFileNotFound )
|
|
{
|
|
fNeedsReinstall = TRUE;
|
|
goto DoReinstall;
|
|
}
|
|
|
|
} /* while */
|
|
|
|
|
|
|
|
DoReinstall:
|
|
//
|
|
// If somewhere along the line we were supposed to reinstall, then we
|
|
// do so.
|
|
//
|
|
if (fNeedsReinstall)
|
|
{
|
|
//
|
|
// We have to indicate that all changes from point A to point B need
|
|
// to be ignored.
|
|
//
|
|
rRequest.MarkInRecoveryMode(TRUE);
|
|
PerformRecoveryOfAssembly(rRecoveryInfo, NULL, RecoverResult);
|
|
rRequest.ClearList();
|
|
rRequest.MarkInRecoveryMode(FALSE);
|
|
|
|
//
|
|
// HACKHACK jonwis 1/20/2001 - Stop failing assertions because lasterror
|
|
// is set wrong by one of the above.
|
|
//
|
|
::FusionpSetLastWin32Error(0);
|
|
}
|
|
|
|
fSuccess = TRUE;
|
|
Exit:
|
|
const DWORD dwLastErrorSaved = ::FusionpGetLastWin32Error();
|
|
|
|
//
|
|
// We are done - this always succeeds. The explanation is hairy.
|
|
//
|
|
if (pRequestList->AttemptRemoveItem(&rRequest))
|
|
{
|
|
::FusionpSetLastWin32Error(dwLastErrorSaved);
|
|
}
|
|
else
|
|
{
|
|
if (!fSuccess)
|
|
{
|
|
// This seems bad that we're losing the original failure; let's at least spew it.
|
|
::FusionpDbgPrintEx(
|
|
FUSION_DBG_LEVEL_ERROR,
|
|
"SXS.DLL: %s() losing original win32 error code of %d; replaced with %d from CProtectionRequestList::AttemptRemoveItem() call.\n",
|
|
__FUNCTION__,
|
|
dwLastErrorSaved,
|
|
::FusionpGetLastWin32Error());
|
|
}
|
|
|
|
fSuccess = FALSE;
|
|
}
|
|
|
|
return fSuccess;
|
|
}
|
|
|
|
|
|
BOOL WINAPI
|
|
SxsProtectionUserLogonEvent()
|
|
{
|
|
return SetEvent(g_hSxsLoginEvent);
|
|
}
|
|
|
|
BOOL WINAPI
|
|
SxsProtectionUserLogoffEvent()
|
|
{
|
|
return ResetEvent(g_hSxsLoginEvent);
|
|
}
|
|
|
|
|
|
|
|
BOOL
|
|
CProtectionRequestList::PerformRecoveryOfAssembly(
|
|
const CAssemblyRecoveryInfo &RecoverInfo,
|
|
CRecoveryCopyQueue *pvPotentialQueue,
|
|
SxsRecoveryResult &ResultOut
|
|
)
|
|
{
|
|
BOOL fSuccess = FALSE;
|
|
FN_TRACE_WIN32(fSuccess);
|
|
|
|
BOOL fFound = FALSE;
|
|
CRecoveryJobTableEntry *pNewEntry, **pExistingEntry;
|
|
DWORD dwRecoveryLastError = ERROR_SUCCESS;
|
|
|
|
IFALLOCFAILED_EXIT(pNewEntry = new CRecoveryJobTableEntry);
|
|
IFW32FALSE_EXIT(pNewEntry->Initialize());
|
|
|
|
{
|
|
CSxsLockCriticalSection lock(m_cInstallerCriticalSection);
|
|
IFW32FALSE_EXIT(lock.Lock());
|
|
IFW32FALSE_EXIT(
|
|
m_pInstallsTable->FindOrInsertIfNotPresent(
|
|
RecoverInfo.GetAssemblyDirectoryName(),
|
|
pNewEntry,
|
|
&pExistingEntry,
|
|
&fFound));
|
|
}
|
|
|
|
//
|
|
// Great, it was either inserted or it was already there - if not already there,
|
|
// then we'll take care if it.
|
|
//
|
|
if (!fFound)
|
|
{
|
|
BOOL fSuccess = FALSE;
|
|
|
|
IFW32FALSE_EXIT(pNewEntry->StartInstallation());
|
|
|
|
//
|
|
// Perform the recovery.
|
|
//
|
|
fSuccess = ::SxspRecoverAssembly(RecoverInfo, pvPotentialQueue, ResultOut);
|
|
|
|
if (!fSuccess)
|
|
dwRecoveryLastError = ::FusionpGetLastWin32Error();
|
|
|
|
#if DBG
|
|
::FusionpDbgPrintEx(FUSION_DBG_LEVEL_WFP,
|
|
"SXS: %s() - RecoverAssembly returned Result = %ls, fSuccess = %s, LastError = 0x%08x\n",
|
|
__FUNCTION__,
|
|
SxspRecoveryResultToString(ResultOut),
|
|
fSuccess ? "true" : "false",
|
|
dwRecoveryLastError);
|
|
#endif
|
|
|
|
//
|
|
// Tell this entry that it's all done. This releases the other people
|
|
// that were waiting on the event to get done as well.
|
|
//
|
|
IFW32FALSE_EXIT(pNewEntry->InstallationComplete(fSuccess, ResultOut, dwRecoveryLastError));
|
|
|
|
//
|
|
// And now delete the item from the list.
|
|
//
|
|
{
|
|
CSxsLockCriticalSection lock2(m_cInstallerCriticalSection);
|
|
IFW32FALSE_EXIT(lock2.Lock());
|
|
IFW32FALSE_EXIT(m_pInstallsTable->Remove(RecoverInfo.GetAssemblyDirectoryName()));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DWORD dwLastError;
|
|
IFW32FALSE_EXIT((*pExistingEntry)->WaitUntilCompleted(ResultOut, fSuccess, dwLastError));
|
|
|
|
#if DBG
|
|
::FusionpDbgPrintEx(FUSION_DBG_LEVEL_WFP,
|
|
"SXS: %s() - WaitUntilCompleted returned Result = %ls, fInstalledOk = %s, LastError = 0x%08x\n",
|
|
__FUNCTION__,
|
|
::SxspRecoveryResultToString(ResultOut),
|
|
fSuccess ? "true" : "false",
|
|
dwLastError);
|
|
#endif
|
|
|
|
dwRecoveryLastError = dwLastError;
|
|
}
|
|
|
|
if (dwRecoveryLastError != ERROR_SUCCESS)
|
|
ORIGINATE_WIN32_FAILURE_AND_EXIT(RecoveryFailed, dwRecoveryLastError);
|
|
|
|
fSuccess = TRUE;
|
|
Exit:
|
|
return fSuccess;
|
|
}
|
|
|
|
|
|
VOID WINAPI
|
|
SxsProtectionEnableProcessing(BOOL fActivityEnabled)
|
|
{
|
|
s_fIsSfcAcceptingNotifications = fActivityEnabled;
|
|
}
|
|
|