1594 lines
36 KiB
C++
1594 lines
36 KiB
C++
/*++
|
||
|
||
(c) 1998 Seagate Software, Inc. All rights reserved.
|
||
|
||
Module Name:
|
||
|
||
fsaftclt.cpp
|
||
|
||
Abstract:
|
||
|
||
This class represents a user who the filter has detected accessing a file with placeholder information.
|
||
|
||
Author:
|
||
|
||
Chuck Bardeen [cbardeen] 12-Feb-1997
|
||
|
||
Revision History:
|
||
|
||
--*/
|
||
|
||
#include "stdafx.h"
|
||
extern "C" {
|
||
#include <ntseapi.h>
|
||
#include <wchar.h>
|
||
#include <lmaccess.h>
|
||
#include <lmserver.h>
|
||
#include <lmshare.h>
|
||
#include <lmapibuf.h>
|
||
#include <lmerr.h>
|
||
|
||
// #define MAC_SUPPORT // NOTE: You must define MAC_SUPPORT in fsafltr.cpp to enable all the code
|
||
|
||
#ifdef MAC_SUPPORT
|
||
#include <macfile.h>
|
||
#endif
|
||
}
|
||
|
||
|
||
#define WSB_TRACE_IS WSB_TRACE_BIT_FSA
|
||
|
||
#include "wsb.h"
|
||
#include "fsa.h"
|
||
#include "fsaftclt.h"
|
||
|
||
static USHORT iCountFtclt = 0; // Count of existing objects
|
||
|
||
//
|
||
// We need to dynamically load the DLL for MAC support because it is not there if
|
||
// the MAC service is not installed.
|
||
//
|
||
#ifdef MAC_SUPPORT
|
||
HANDLE FsaDllSfm = 0;
|
||
BOOL FsaMacSupportInstalled = FALSE;
|
||
|
||
extern "C" {
|
||
DWORD (*pAfpAdminConnect) (LPWSTR lpwsServerName, PAFP_SERVER_HANDLE phAfpServer);
|
||
VOID (*pAfpAdminDisconnect) (AFP_SERVER_HANDLE hAfpServer);
|
||
VOID (*pAfpAdminBufferFree) (PVOID pBuffer);
|
||
DWORD (*pAfpAdminSessionEnum) (AFP_SERVER_HANDLE hAfpServer, LPBYTE *lpbBuffer,
|
||
DWORD dwPrefMaxLen, LPDWORD lpdwEntriesRead, LPDWORD lpdwTotalEntries,
|
||
LPDWORD lpdwResumeHandle);
|
||
}
|
||
#endif
|
||
|
||
DWORD FsaIdentifyThread(void *pNotifyInterface);
|
||
|
||
|
||
|
||
DWORD FsaIdentifyThread(
|
||
void* pVoid
|
||
)
|
||
|
||
/*++
|
||
Entry point of the thread that performs identify operation with remote clients.
|
||
|
||
--*/
|
||
{
|
||
HRESULT hr;
|
||
|
||
hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
|
||
hr = ((CFsaFilterClient*) pVoid)->IdentifyThread();
|
||
CoUninitialize();
|
||
return(hr);
|
||
}
|
||
|
||
|
||
|
||
static
|
||
HRESULT
|
||
GetNotifyClientInterface(
|
||
IN OLECHAR * machineName,
|
||
OUT IFsaRecallNotifyClient ** ppClient
|
||
)
|
||
{
|
||
HRESULT hr = S_OK;
|
||
|
||
try {
|
||
|
||
//
|
||
// Make sure parameters OK and OUTs initially cleared
|
||
//
|
||
|
||
WsbAffirmPointer ( ppClient );
|
||
*ppClient = 0;
|
||
|
||
//
|
||
// If connecting local, things work better to use NULL
|
||
// for the computer name
|
||
//
|
||
|
||
if ( machineName ) {
|
||
|
||
CWsbStringPtr localMachine;
|
||
WsbAffirmHr( WsbGetComputerName( localMachine ) );
|
||
|
||
if( _wcsicmp( localMachine, machineName ) == 0 ) {
|
||
|
||
machineName = 0;
|
||
|
||
}
|
||
|
||
}
|
||
|
||
//
|
||
// Set server info
|
||
//
|
||
COSERVERINFO csi;
|
||
COAUTHINFO cai;
|
||
memset ( &csi, 0, sizeof ( csi ) );
|
||
memset ( &cai, 0, sizeof ( cai ) );
|
||
|
||
// Set machine name
|
||
csi.pwszName = machineName;
|
||
|
||
// Create a proxy with security settings of no authentication (note that RsNotify is running with this security)
|
||
cai.dwAuthnSvc = RPC_C_AUTHN_WINNT;
|
||
cai.dwAuthzSvc = RPC_C_AUTHZ_DEFAULT;
|
||
cai.pwszServerPrincName = NULL;
|
||
cai.dwImpersonationLevel = RPC_C_IMP_LEVEL_IMPERSONATE;
|
||
cai.pAuthIdentityData = NULL;
|
||
cai.dwCapabilities = EOAC_NONE;
|
||
|
||
cai.dwAuthnLevel = RPC_C_AUTHN_LEVEL_NONE;
|
||
|
||
csi.pAuthInfo = &cai;
|
||
|
||
//
|
||
// We want IFsaRecallNotifyClient back
|
||
//
|
||
|
||
MULTI_QI mqi;
|
||
memset ( &mqi, 0, sizeof ( mqi ) );
|
||
mqi.pIID = &IID_IFsaRecallNotifyClient;
|
||
|
||
//
|
||
// Make the connection...
|
||
//
|
||
|
||
WsbAffirmHr ( CoCreateInstanceEx (
|
||
CLSID_CFsaRecallNotifyClient, 0,
|
||
CLSCTX_NO_FAILURE_LOG | ( machineName ? CLSCTX_REMOTE_SERVER : CLSCTX_LOCAL_SERVER ),
|
||
&csi, 1, &mqi ) );
|
||
WsbAffirmHr ( mqi.hr );
|
||
|
||
//
|
||
// We need to make sure we clean up correctly if any interface
|
||
// post-processing fails, so assign over to a smart pointer for
|
||
// the time being
|
||
//
|
||
|
||
CComPtr<IFsaRecallNotifyClient> pClientTemp = (IFsaRecallNotifyClient*)mqi.pItf;
|
||
mqi.pItf->Release ( );
|
||
|
||
//
|
||
// Finally, we need to set the security on the procy to allow the
|
||
// anonymous connection. Values should be the same as above (COAUTHINFO)
|
||
// We need to make sure this is a remote machine first. Otherwise, we
|
||
// get an error of E_INVALIDARG.
|
||
//
|
||
if( machineName ) {
|
||
|
||
CComPtr<IClientSecurity> pSecurity;
|
||
WsbAffirmHr( pClientTemp->QueryInterface( IID_IClientSecurity, (void**)&pSecurity ) );
|
||
|
||
WsbAffirmHr( pSecurity->SetBlanket ( pClientTemp, RPC_C_AUTHN_NONE, RPC_C_AUTHZ_NONE, 0, RPC_C_AUTHN_LEVEL_NONE, RPC_C_IMP_LEVEL_IDENTIFY, 0, 0 ) );
|
||
|
||
}
|
||
|
||
//
|
||
// Finally, assign over and AddRef the return.
|
||
//
|
||
|
||
*ppClient = pClientTemp;
|
||
(*ppClient)->AddRef ( );
|
||
|
||
} WsbCatch ( hr );
|
||
|
||
return ( hr );
|
||
}
|
||
|
||
|
||
|
||
HRESULT
|
||
CFsaFilterClient::CheckRecallLimit(
|
||
IN DWORD minRecallInterval,
|
||
IN DWORD maxRecalls,
|
||
IN BOOLEAN exemptAdmin
|
||
)
|
||
|
||
/*++
|
||
|
||
Implements:
|
||
|
||
IWsbCollectable::CheckRecallLimit().
|
||
|
||
--*/
|
||
{
|
||
HRESULT hr = S_OK;
|
||
FILETIME now, last;
|
||
LARGE_INTEGER tNow, tLast;
|
||
ULONG rCount;
|
||
|
||
|
||
WsbTraceIn(OLESTR("CFsaFilterClient::CheckRecallLimit"), OLESTR(""));
|
||
|
||
try {
|
||
//
|
||
// Now check for runaway recall limits if the user is not
|
||
// an administrator
|
||
//
|
||
|
||
if ((!m_isAdmin) || (!exemptAdmin)) {
|
||
//
|
||
// See if the time since the end of the last recall is
|
||
// less than m_minRecallInterval (in seconds) and if so,
|
||
// increment the count.
|
||
// If not, then reset the count (if we were not
|
||
// already triggered).
|
||
// If the count is equal to the max then set the trigger.
|
||
//
|
||
WsbTrace(OLESTR("CHsmFilter::IoctlThread: Not an administrator or admin is not exempt.\n"));
|
||
GetSystemTimeAsFileTime(&now);
|
||
tNow.LowPart = now.dwLowDateTime;
|
||
tNow.HighPart = now.dwHighDateTime;
|
||
|
||
GetLastRecallTime(&last);
|
||
|
||
tLast.LowPart = last.dwLowDateTime;
|
||
tLast.HighPart = last.dwHighDateTime;
|
||
//
|
||
// Get the time (in 100 nano-second units)
|
||
// from the end of the last recall until now.
|
||
//
|
||
tNow.QuadPart -= tLast.QuadPart;
|
||
//
|
||
// Convert to seconds and check against the interval time
|
||
//
|
||
tNow.QuadPart /= (LONGLONG) 10000000;
|
||
if (tNow.QuadPart < (LONGLONG) minRecallInterval) {
|
||
//
|
||
// This one counts - increment the count
|
||
// and check for a trigger.
|
||
//
|
||
GetRecallCount(&rCount);
|
||
rCount++;
|
||
SetRecallCount(rCount);
|
||
|
||
WsbTrace(OLESTR("CHsmFilterClient::CheckRecallLimit: Recall count bumped to %ls.\n"),
|
||
WsbLongAsString(rCount));
|
||
|
||
if (rCount >= maxRecalls) {
|
||
//
|
||
// Hit the runaway recall limit. Set the
|
||
// limit flag.
|
||
//
|
||
WsbTrace(OLESTR("CHsmFilter::IoctlThread: Hit the runaway recall limit!!!.\n"));
|
||
SetHitRecallLimit(TRUE);
|
||
}
|
||
} else {
|
||
//
|
||
// Reset the count if they are not already triggered.
|
||
// If they are triggered then reset the trigger and
|
||
// limit if it has been a respectable time.
|
||
// TBD - What is a respectable time??
|
||
//
|
||
if (HitRecallLimit() != S_FALSE) {
|
||
if (tNow.QuadPart > (LONGLONG) minRecallInterval * 100) {
|
||
//
|
||
// A respectable time has passed - reset the trigger and count.
|
||
//
|
||
WsbTrace(OLESTR("CHsmFilterClient::CheckRecallLimit: Resetting recall limit trigger and count.\n"));
|
||
SetHitRecallLimit(FALSE);
|
||
SetRecallCount(0);
|
||
m_loggedLimitError = FALSE;
|
||
}
|
||
} else {
|
||
//
|
||
// This one did not count and they were not already triggered.
|
||
// Reset the count to zero.
|
||
//
|
||
WsbTrace(OLESTR("CHsmFilterClient::CheckRecallLimit: Resetting recall count.\n"));
|
||
SetRecallCount(0);
|
||
}
|
||
}
|
||
//
|
||
// Fail if the limit is hit.
|
||
//
|
||
WsbAffirm(HitRecallLimit() == S_FALSE, FSA_E_HIT_RECALL_LIMIT);
|
||
}
|
||
|
||
} WsbCatch(hr);
|
||
|
||
// NOTE - IF RUNAWAY RECALL BEHAVIOR CHANGES TO TRUNCATE ON CLOSE, CHANGE
|
||
// FSA_MESSAGE_HIT_RECALL_LIMIT_ACCESSDENIED TO FSA_MESSAGE_HIT_RECALL_LIMIT_TRUNCATEONCLOSE.
|
||
|
||
if ( (hr == FSA_E_HIT_RECALL_LIMIT) && (!m_loggedLimitError)) {
|
||
WsbLogEvent(FSA_MESSAGE_HIT_RECALL_LIMIT_ACCESSDENIED, 0, NULL, (WCHAR *) m_userName, NULL);
|
||
m_loggedLimitError = TRUE;
|
||
}
|
||
|
||
WsbTraceOut(OLESTR("CHsmFilterClient::CheckRecallLimit"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
||
|
||
return(hr);
|
||
}
|
||
|
||
|
||
HRESULT
|
||
CFsaFilterClient::CompareBy(
|
||
FSA_FILTERCLIENT_COMPARE by
|
||
)
|
||
|
||
/*++
|
||
|
||
Implements:
|
||
|
||
IFsaFilterClient::CompareBy().
|
||
|
||
--*/
|
||
{
|
||
HRESULT hr = S_OK;
|
||
|
||
m_compareBy = by;
|
||
m_isDirty = TRUE;
|
||
|
||
return(hr);
|
||
}
|
||
|
||
|
||
HRESULT
|
||
CFsaFilterClient::CompareTo(
|
||
IN IUnknown* pUnknown,
|
||
OUT SHORT* pResult
|
||
)
|
||
|
||
/*++
|
||
|
||
Implements:
|
||
|
||
IWsbCollectable::CompareTo().
|
||
|
||
--*/
|
||
{
|
||
HRESULT hr = S_OK;
|
||
CComPtr<IFsaFilterClient> pClient;
|
||
|
||
WsbTraceIn(OLESTR("CFsaFilterClient::CompareTo"), OLESTR(""));
|
||
|
||
try {
|
||
|
||
// Did they give us a valid item to compare to?
|
||
WsbAssert(0 != pUnknown, E_POINTER);
|
||
|
||
// We need the IWsbBool interface to get the value of the object.
|
||
WsbAffirmHr(pUnknown->QueryInterface(IID_IFsaFilterClient, (void**) &pClient));
|
||
|
||
// Compare the rules.
|
||
hr = CompareToIClient(pClient, pResult);
|
||
|
||
} WsbCatch(hr);
|
||
|
||
WsbTraceOut(OLESTR("CHsmFilterClient::CompareTo"), OLESTR("hr = <%ls>, result = <%ls>"), WsbHrAsString(hr), WsbPtrToShortAsString(pResult));
|
||
|
||
return(hr);
|
||
}
|
||
|
||
|
||
HRESULT
|
||
CFsaFilterClient::CompareToAuthenticationId(
|
||
IN LONG luidHigh,
|
||
IN ULONG luidLow,
|
||
OUT SHORT* pResult
|
||
)
|
||
|
||
/*++
|
||
|
||
Implements:
|
||
|
||
IFsaFilterClient::CompareToAuthenticationId().
|
||
|
||
--*/
|
||
{
|
||
HRESULT hr = S_OK;
|
||
SHORT aResult;
|
||
|
||
WsbTraceIn(OLESTR("CFsaFilterClient::CompareToAuthenticationId"), OLESTR(""));
|
||
|
||
try {
|
||
|
||
if (m_luidHigh > luidHigh) {
|
||
aResult = 1;
|
||
} else if (m_luidHigh < luidHigh) {
|
||
aResult = -1;
|
||
} else if (m_luidLow > luidLow) {
|
||
aResult = 1;
|
||
} else if (m_luidLow < luidLow) {
|
||
aResult = -1;
|
||
} else {
|
||
aResult = 0;
|
||
}
|
||
|
||
if (0 != aResult) {
|
||
hr = S_FALSE;
|
||
}
|
||
|
||
if (0 != pResult) {
|
||
*pResult = aResult;
|
||
}
|
||
|
||
|
||
} WsbCatch(hr);
|
||
|
||
WsbTraceOut(OLESTR("CFsaFilterClient::CompareToAuthenticationId"), OLESTR("hr = <%ls>, result = <%d>"), WsbHrAsString(hr), aResult);
|
||
|
||
return(hr);
|
||
}
|
||
|
||
|
||
HRESULT
|
||
CFsaFilterClient::CompareToIClient(
|
||
IN IFsaFilterClient* pClient,
|
||
OUT SHORT* pResult
|
||
)
|
||
|
||
/*++
|
||
|
||
Implements:
|
||
|
||
IFsaFilterClient::CompareToIClient().
|
||
|
||
--*/
|
||
{
|
||
HRESULT hr = S_OK;
|
||
CWsbStringPtr name;
|
||
LONG luidHigh;
|
||
ULONG luidLow;
|
||
|
||
WsbTraceIn(OLESTR("CFsaFilterClient::CompareToIClient"), OLESTR(""));
|
||
|
||
try {
|
||
|
||
// Did they give us a valid item to compare to?
|
||
WsbAssert(0 != pClient, E_POINTER);
|
||
|
||
switch (m_compareBy) {
|
||
case FSA_FILTERCLIENT_COMPARE_ID:
|
||
WsbAffirmHr(pClient->GetAuthenticationId(&luidHigh, &luidLow));
|
||
hr = CompareToAuthenticationId(luidHigh, luidLow, pResult);
|
||
break;
|
||
case FSA_FILTERCLIENT_COMPARE_MACHINE:
|
||
WsbAffirmHr(pClient->GetMachineName(&name, 0));
|
||
hr = CompareToMachineName(name, pResult);
|
||
break;
|
||
default:
|
||
WsbAssert(FALSE, E_UNEXPECTED);
|
||
}
|
||
|
||
} WsbCatch(hr);
|
||
|
||
WsbTraceOut(OLESTR("CFsaFilterClient::CompareToIClient"), OLESTR("hr = <%ls>, result = <%ls>"), WsbHrAsString(hr), WsbPtrToShortAsString(pResult));
|
||
|
||
return(hr);
|
||
}
|
||
|
||
|
||
HRESULT
|
||
CFsaFilterClient::CompareToMachineName(
|
||
IN OLECHAR* name,
|
||
OUT SHORT* pResult
|
||
)
|
||
|
||
/*++
|
||
|
||
Implements:
|
||
|
||
IFsaFilterClient::CompareToMachineName().
|
||
|
||
--*/
|
||
{
|
||
HRESULT hr = S_OK;
|
||
SHORT aResult;
|
||
|
||
WsbTraceIn(OLESTR("CFsaFilterClient::CompareToMachineName"), OLESTR(""));
|
||
|
||
try {
|
||
|
||
aResult = (SHORT)wcscmp(name, m_machineName); // TBD - Case sensitive or not?
|
||
|
||
if (0 != aResult) {
|
||
hr = S_FALSE;
|
||
}
|
||
|
||
if (0 != pResult) {
|
||
*pResult = aResult;
|
||
}
|
||
|
||
} WsbCatch(hr);
|
||
|
||
WsbTraceOut(OLESTR("CFsaFilterClient::CompareToMachineName"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
||
|
||
return(hr);
|
||
}
|
||
|
||
|
||
HRESULT
|
||
CFsaFilterClient::FinalConstruct(
|
||
void
|
||
)
|
||
|
||
/*++
|
||
|
||
Implements:
|
||
|
||
CComObjectRoot::FinalConstruct().
|
||
|
||
--*/
|
||
{
|
||
HRESULT hr = S_OK;
|
||
|
||
WsbTraceIn(OLESTR("CFsaFilterClient::FinalConstruct"),OLESTR(""));
|
||
try {
|
||
|
||
WsbAffirmHr(CWsbCollectable::FinalConstruct());
|
||
|
||
m_compareBy = FSA_FILTERCLIENT_COMPARE_ID;
|
||
m_luidHigh = 0;
|
||
m_luidLow = 0;
|
||
m_hasRecallDisabled = FALSE;
|
||
m_hitRecallLimit = FALSE;
|
||
m_lastRecallTime.dwLowDateTime = 0;
|
||
m_lastRecallTime.dwHighDateTime = 0;
|
||
m_identified = FALSE;
|
||
m_tokenSource = L"";
|
||
m_msgCounter = 1;
|
||
m_identifyThread = NULL;
|
||
m_isAdmin = FALSE;
|
||
m_loggedLimitError = FALSE;
|
||
|
||
} WsbCatch(hr);
|
||
|
||
iCountFtclt++;
|
||
WsbTraceOut(OLESTR("CFsaFilterClient::FinalConstruct"),OLESTR("Count is <%d>"), iCountFtclt);
|
||
|
||
return(hr);
|
||
}
|
||
void
|
||
CFsaFilterClient::FinalRelease(
|
||
void
|
||
)
|
||
|
||
/*++
|
||
|
||
Implements:
|
||
|
||
CComObjectRoot::FinalRelease().
|
||
|
||
--*/
|
||
{
|
||
WsbTraceIn(OLESTR("CFsaFilterClient::FinalRelease"),OLESTR(""));
|
||
|
||
CWsbCollectable::FinalRelease();
|
||
|
||
iCountFtclt--;
|
||
WsbTraceOut(OLESTR("CFsaFilterClient::FinalRelease"),OLESTR("Count is <%d>"), iCountFtclt);
|
||
}
|
||
|
||
|
||
HRESULT
|
||
CFsaFilterClient::GetClassID(
|
||
OUT CLSID* pClsid
|
||
)
|
||
|
||
/*++
|
||
|
||
Implements:
|
||
|
||
IPersist::GetClassID().
|
||
|
||
--*/
|
||
{
|
||
HRESULT hr = S_OK;
|
||
|
||
WsbTraceIn(OLESTR("CFsaFilterClient::GetClassID"), OLESTR(""));
|
||
|
||
try {
|
||
|
||
WsbAssert(0 != pClsid, E_POINTER);
|
||
*pClsid = CLSID_CFsaFilterClientNTFS;
|
||
|
||
} WsbCatch(hr);
|
||
|
||
WsbTraceOut(OLESTR("CFsaFilterClient::GetClassID"), OLESTR("hr = <%ls>, CLSID = <%ls>"), WsbHrAsString(hr), WsbGuidAsString(*pClsid));
|
||
|
||
return(hr);
|
||
}
|
||
|
||
|
||
HRESULT
|
||
CFsaFilterClient::GetAuthenticationId(
|
||
OUT LONG* pLuidHigh,
|
||
OUT ULONG* pLuidLow
|
||
)
|
||
|
||
/*++
|
||
|
||
Implements:
|
||
|
||
IFsaFilterClient::GetAuthenticationId().
|
||
|
||
--*/
|
||
{
|
||
HRESULT hr = S_OK;
|
||
|
||
try {
|
||
|
||
WsbAssert(0 != pLuidHigh, E_POINTER);
|
||
WsbAssert(0 != pLuidLow, E_POINTER);
|
||
|
||
*pLuidHigh = m_luidHigh;
|
||
*pLuidLow = m_luidLow;
|
||
|
||
} WsbCatch(hr);
|
||
|
||
return(hr);
|
||
}
|
||
|
||
|
||
HRESULT
|
||
CFsaFilterClient::GetDomainName(
|
||
OUT OLECHAR** pName,
|
||
IN ULONG bufferSize
|
||
)
|
||
|
||
/*++
|
||
|
||
Implements:
|
||
|
||
IFsaFilterClient::GetDomainName().
|
||
|
||
--*/
|
||
{
|
||
HRESULT hr = S_OK;
|
||
|
||
try {
|
||
|
||
WsbAssert(0 != pName, E_POINTER);
|
||
WsbAffirmHr(m_domainName.CopyTo(pName, bufferSize));
|
||
|
||
} WsbCatch(hr);
|
||
|
||
return(hr);
|
||
}
|
||
|
||
|
||
HRESULT
|
||
CFsaFilterClient::GetIsAdmin(
|
||
OUT BOOLEAN *pIsAdmin
|
||
)
|
||
|
||
/*++
|
||
|
||
Implements:
|
||
|
||
IPersist::GetIsAdmin().
|
||
|
||
--*/
|
||
{
|
||
HRESULT hr = S_OK;
|
||
|
||
WsbTraceIn(OLESTR("CFsaFilterClient::GetIsAdmin"), OLESTR(""));
|
||
|
||
try {
|
||
|
||
WsbAssert(0 != pIsAdmin, E_POINTER);
|
||
*pIsAdmin = m_isAdmin;
|
||
|
||
} WsbCatch(hr);
|
||
|
||
WsbTraceOut(OLESTR("CFsaFilterClient::GetIsAdmin"), OLESTR("hr = <%ls>, isAdmin = <%u>"), WsbHrAsString(hr), *pIsAdmin);
|
||
|
||
return(hr);
|
||
}
|
||
|
||
|
||
HRESULT
|
||
CFsaFilterClient::GetLastRecallTime(
|
||
OUT FILETIME* pTime
|
||
)
|
||
|
||
/*++
|
||
|
||
Implements:
|
||
|
||
IFsaFilterClient::GetLastRecallTime().
|
||
|
||
--*/
|
||
{
|
||
HRESULT hr = S_OK;
|
||
|
||
try {
|
||
|
||
WsbAssert(0 != pTime, E_POINTER);
|
||
*pTime = m_lastRecallTime;
|
||
|
||
} WsbCatch(hr);
|
||
|
||
return(hr);
|
||
}
|
||
|
||
|
||
HRESULT
|
||
CFsaFilterClient::GetMachineName(
|
||
OUT OLECHAR** pName,
|
||
IN ULONG bufferSize
|
||
)
|
||
|
||
/*++
|
||
|
||
Implements:
|
||
|
||
IFsaFilterClient::GetMachineName().
|
||
|
||
--*/
|
||
{
|
||
HRESULT hr = S_OK;
|
||
|
||
try {
|
||
|
||
WsbAssert(0 != pName, E_POINTER);
|
||
WsbAffirmHr(m_machineName.CopyTo(pName, bufferSize));
|
||
|
||
} WsbCatch(hr);
|
||
|
||
return(hr);
|
||
}
|
||
|
||
|
||
HRESULT
|
||
CFsaFilterClient::GetRecallCount(
|
||
OUT ULONG* pCount
|
||
)
|
||
|
||
/*++
|
||
|
||
Implements:
|
||
|
||
IFsaFilterClient::GetRecallCount().
|
||
|
||
--*/
|
||
{
|
||
HRESULT hr = S_OK;
|
||
|
||
try {
|
||
|
||
WsbAssert(0 != pCount, E_POINTER);
|
||
*pCount = m_recallCount;
|
||
|
||
} WsbCatch(hr);
|
||
|
||
return(hr);
|
||
}
|
||
|
||
|
||
HRESULT
|
||
CFsaFilterClient::GetUserName(
|
||
OUT OLECHAR** pName,
|
||
IN ULONG bufferSize
|
||
)
|
||
|
||
/*++
|
||
|
||
Implements:
|
||
|
||
IFsaFilterClient::GetUserName().
|
||
|
||
--*/
|
||
{
|
||
HRESULT hr = S_OK;
|
||
|
||
try {
|
||
|
||
WsbAssert(0 != pName, E_POINTER);
|
||
WsbAffirmHr(m_userName.CopyTo(pName, bufferSize));
|
||
|
||
} WsbCatch(hr);
|
||
|
||
return(hr);
|
||
}
|
||
|
||
|
||
HRESULT
|
||
CFsaFilterClient::GetSizeMax(
|
||
OUT ULARGE_INTEGER* pSize
|
||
)
|
||
|
||
/*++
|
||
|
||
Implements:
|
||
|
||
IPersistStream::GetSizeMax().
|
||
|
||
--*/
|
||
{
|
||
HRESULT hr = S_OK;
|
||
|
||
|
||
WsbTraceIn(OLESTR("CFsaFilterClient::GetSizeMax"), OLESTR(""));
|
||
|
||
try {
|
||
|
||
WsbAssert(0 != pSize, E_POINTER);
|
||
pSize->QuadPart = 0;
|
||
|
||
// WE don't need to persist these.
|
||
hr = E_NOTIMPL;
|
||
|
||
} WsbCatch(hr);
|
||
|
||
WsbTraceOut(OLESTR("CFsaFilterClient::GetSizeMax"), OLESTR("hr = <%ls>, Size = <%ls>"), WsbHrAsString(hr), WsbPtrToUliAsString(pSize));
|
||
|
||
return(hr);
|
||
}
|
||
|
||
|
||
HRESULT
|
||
CFsaFilterClient::HasRecallDisabled(
|
||
void
|
||
)
|
||
|
||
/*++
|
||
|
||
Implements:
|
||
|
||
IFsaFilterClient::HasRecallDisabled().
|
||
|
||
--*/
|
||
{
|
||
HRESULT hr = S_OK;
|
||
|
||
WsbTraceIn(OLESTR("CFsaFilterClient::HasRecallDisabled"), OLESTR(""));
|
||
|
||
if (!m_hasRecallDisabled) {
|
||
hr = S_FALSE;
|
||
}
|
||
|
||
WsbTraceOut(OLESTR("CHsmFilterClient::HasRecallDisabled"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
||
|
||
return(hr);
|
||
}
|
||
|
||
|
||
HRESULT
|
||
CFsaFilterClient::HitRecallLimit(
|
||
void
|
||
)
|
||
|
||
/*++
|
||
|
||
Implements:
|
||
|
||
IFsaFilterClient::HitRecallLimit().
|
||
|
||
--*/
|
||
{
|
||
HRESULT hr = S_OK;
|
||
|
||
WsbTraceIn(OLESTR("CFsaFilterClient::HitRecallLimit"), OLESTR(""));
|
||
|
||
if (!m_hitRecallLimit) {
|
||
hr = S_FALSE;
|
||
}
|
||
|
||
WsbTraceOut(OLESTR("CHsmFilterClient::HitRecallLimit"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
||
|
||
return(hr);
|
||
}
|
||
|
||
|
||
|
||
HRESULT
|
||
CFsaFilterClient::IdentifyThread(
|
||
void
|
||
)
|
||
|
||
/*++
|
||
|
||
Implements:
|
||
|
||
CFsaFilterClient::IdentifyThread().
|
||
|
||
--*/
|
||
{
|
||
#define WSB_BUFF_SIZE 1024
|
||
|
||
HRESULT hr = S_OK;
|
||
BOOL done, guestUser, noUser;
|
||
DWORD res, totalEnt, numEnt;
|
||
UCHAR *buff = NULL;
|
||
NET_API_STATUS status;
|
||
SESSION_INFO_1 *sess;
|
||
CWsbStringPtr pipePath;
|
||
ULONG holdOff = 0;
|
||
#ifdef MAC_SUPPORT
|
||
LPBYTE macBuff = NULL;
|
||
PAFP_SESSION_INFO macInfo;
|
||
AFP_SERVER_HANDLE macHandle = 0;
|
||
DWORD macResume = 0;
|
||
DWORD macTotalEntries, macTotalRead;
|
||
DWORD result;
|
||
#endif
|
||
|
||
|
||
WsbTraceIn(OLESTR("CFsaFilterClient::IdentifyThread"), OLESTR(""));
|
||
|
||
try {
|
||
WsbTrace(OLESTR("CFsaFilterClient::IdentifyThread Flag: %x Client ID: %x:%x Source: %ls\n"),
|
||
m_identified, m_luidHigh, m_luidLow, (WCHAR *) m_tokenSource);
|
||
|
||
//
|
||
// If already identified then we bail out here.
|
||
//
|
||
WsbAffirm(m_identified == FALSE, S_OK);
|
||
|
||
|
||
done = FALSE;
|
||
res = 0;
|
||
|
||
noUser = FALSE;
|
||
if (_wcsicmp(m_userName, L"GUEST") == 0) {
|
||
/* It is the guest user - find all sessions and
|
||
send to ones marked guest */
|
||
guestUser = TRUE;
|
||
} else {
|
||
guestUser = FALSE;
|
||
if (wcslen(m_userName) == 0) {
|
||
noUser = TRUE;
|
||
}
|
||
}
|
||
|
||
CComPtr<IFsaRecallNotifyClient> pRecallClient;
|
||
|
||
WsbGetComputerName( pipePath );
|
||
|
||
WsbAffirmHr(pipePath.Prepend("\\\\"));
|
||
WsbAffirmHr(pipePath.Append("\\pipe\\"));
|
||
WsbAffirmHr(pipePath.Append(WSB_PIPE_NAME));
|
||
|
||
while ( done == FALSE ) {
|
||
|
||
if ( (guestUser == FALSE) && (noUser == FALSE) ) {
|
||
|
||
// If NetSessionEnum fails, try calling again for all users
|
||
status = NetSessionEnum(NULL, NULL, m_userName, 1, &buff,
|
||
WSB_BUFF_SIZE, &numEnt, &totalEnt, &res);
|
||
|
||
if (status != 0) {
|
||
status = NetSessionEnum(NULL, NULL, NULL, 1, &buff,
|
||
WSB_BUFF_SIZE, &numEnt, &totalEnt, &res);
|
||
}
|
||
} else {
|
||
status = NetSessionEnum( NULL, NULL, NULL, 1, &buff,
|
||
WSB_BUFF_SIZE, &numEnt, &totalEnt, &res );
|
||
}
|
||
|
||
if ((status == NERR_Success) || (status == ERROR_MORE_DATA)) {
|
||
|
||
WsbTrace(OLESTR("CHsmFilterClient::IdentifyThread: NetSessionEnum output: Total entries=%ls , Read entries=%ls \n"),
|
||
WsbLongAsString(totalEnt), WsbLongAsString(numEnt));
|
||
|
||
if (status != ERROR_MORE_DATA) {
|
||
done = TRUE;
|
||
}
|
||
|
||
sess = (SESSION_INFO_1 *) buff;
|
||
|
||
while ( numEnt != 0 ) {
|
||
//
|
||
// If the request was made from the user GUEST then
|
||
// we enumerate all sessions and send the
|
||
// identification request to all the machines with
|
||
// sessions marked as GUEST. This is because the
|
||
// session may have some other user name but the
|
||
// request could still have GUEST access.
|
||
//
|
||
if (((guestUser) && (sess->sesi1_user_flags & SESS_GUEST)) ||
|
||
(!guestUser)) {
|
||
|
||
//
|
||
// Send the identify request message
|
||
//
|
||
|
||
WsbTrace(OLESTR("CFsaFilterClient::IdentifyThread - Sending identify request to %ls (local machine = %ls)\n"),
|
||
sess->sesi1_cname, (WCHAR *) pipePath);
|
||
|
||
hr = GetNotifyClientInterface ( sess->sesi1_cname, &pRecallClient );
|
||
if ( SUCCEEDED ( hr ) ) {
|
||
|
||
hr = pRecallClient->IdentifyWithServer( pipePath );
|
||
if (hr != S_OK) {
|
||
WsbTrace(OLESTR("CFsaFilterClient::IdentifyThread - error Identifing (%ls)\n"),
|
||
WsbHrAsString(hr));
|
||
}
|
||
} else {
|
||
WsbTrace(OLESTR("CFsaFilterClient::IdentifyThread - error getting notify client interface hr = %ls (%x)\n"),
|
||
WsbHrAsString( hr ), hr);
|
||
}
|
||
hr = S_OK;
|
||
pRecallClient.Release ( );
|
||
}
|
||
|
||
sess++;
|
||
numEnt--;
|
||
}
|
||
|
||
NetApiBufferFree(buff);
|
||
buff = NULL;
|
||
} else {
|
||
done = TRUE;
|
||
}
|
||
}
|
||
|
||
#ifdef MAC_SUPPORT
|
||
//
|
||
// Done with LAN manager scan, now do a MAC scan.
|
||
//
|
||
if ( (FsaMacSupportInstalled) && ((pAfpAdminConnect)(NULL, &macHandle) == NO_ERROR) ) {
|
||
//
|
||
// We have connected to the MAC service - do a session enumeration
|
||
//
|
||
macResume = 0;
|
||
done = FALSE;
|
||
while (done == FALSE) {
|
||
result = (pAfpAdminSessionEnum)(macHandle, &macBuff, -1,
|
||
&macTotalRead, &macTotalEntries, &macResume);
|
||
|
||
if ((result == NO_ERROR) || (result == ERROR_MORE_DATA)) {
|
||
//
|
||
// Read some entries - send the message to each one
|
||
//
|
||
if (macTotalRead == macTotalEntries) {
|
||
done = TRUE;
|
||
}
|
||
|
||
macInfo = (PAFP_SESSION_INFO) macBuff;
|
||
while ( macTotalRead != 0 ) {
|
||
//
|
||
// Send to each matching user
|
||
//
|
||
if ( ( NULL != macInfo->afpsess_ws_name ) &&
|
||
( _wcsicmp(m_userName, macInfo->afpsess_username ) == 0 ) ) {
|
||
|
||
WsbTrace(OLESTR("CHsmFilterClient::IdentifyThread: Send Identify to MAC %ls.\n"),
|
||
macInfo->afpsess_ws_name);
|
||
|
||
//
|
||
// Send the identify request message
|
||
//
|
||
|
||
hr = GetNotifyClientInterface ( sess->sesi1_cname, &pRecallClient );
|
||
if ( SUCCEEDED ( hr ) ) {
|
||
pRecallClient->IdentifyWithServer ( pipePath );
|
||
}
|
||
|
||
hr = S_OK;
|
||
pRecallClient.Release ( );
|
||
}
|
||
macInfo++;
|
||
macTotalRead--;
|
||
}
|
||
|
||
(pAfpAdminBufferFree)(macBuff);
|
||
macBuff = NULL;
|
||
} else {
|
||
done = TRUE;
|
||
}
|
||
(pAfpAdminDisconnect)(macHandle);
|
||
macHandle = 0;
|
||
}
|
||
}
|
||
#endif
|
||
|
||
} WsbCatch(hr);
|
||
|
||
if (buff != NULL) {
|
||
NetApiBufferFree(buff);
|
||
}
|
||
|
||
#ifdef MAC_SUPPORT
|
||
|
||
if (FsaMacSupportInstalled) {
|
||
if (macBuff != NULL) {
|
||
(pAfpAdminBufferFree)(macBuff);
|
||
}
|
||
if (macHandle != 0) {
|
||
(pAfpAdminDisconnect)(macHandle);
|
||
}
|
||
}
|
||
#endif
|
||
|
||
CloseHandle(m_identifyThread);
|
||
m_identifyThread = NULL;
|
||
|
||
WsbTraceOut(OLESTR("CFsaFilterClient::IdentifyThread"), OLESTR("hr = %ls"), WsbHrAsString(hr));
|
||
return(hr);
|
||
}
|
||
|
||
|
||
|
||
HRESULT
|
||
CFsaFilterClient::Load(
|
||
IN IStream* pStream
|
||
)
|
||
|
||
/*++
|
||
|
||
Implements:
|
||
|
||
IPersistStream::Load().
|
||
|
||
--*/
|
||
{
|
||
HRESULT hr = S_OK;
|
||
|
||
WsbTraceIn(OLESTR("CFsaFilterClient::Load"), OLESTR(""));
|
||
|
||
try {
|
||
WsbAssert(0 != pStream, E_POINTER);
|
||
|
||
// No persistence.
|
||
hr = E_NOTIMPL;
|
||
|
||
} WsbCatch(hr);
|
||
|
||
WsbTraceOut(OLESTR("CFsaFilterClient::Load"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
||
|
||
return(hr);
|
||
}
|
||
|
||
|
||
HRESULT
|
||
CFsaFilterClient::Save(
|
||
IN IStream* pStream,
|
||
IN BOOL clearDirty
|
||
)
|
||
|
||
/*++
|
||
|
||
Implements:
|
||
|
||
IPersistStream::Save().
|
||
|
||
--*/
|
||
{
|
||
HRESULT hr = S_OK;
|
||
CComPtr<IPersistStream> pPersistStream;
|
||
|
||
WsbTraceIn(OLESTR("CFsaFilterClient::Save"), OLESTR("clearDirty = <%ls>"), WsbBoolAsString(clearDirty));
|
||
|
||
try {
|
||
WsbAssert(0 != pStream, E_POINTER);
|
||
|
||
// No persistence.
|
||
hr = E_NOTIMPL;
|
||
|
||
// If we got it saved and we were asked to clear the dirty bit, then
|
||
// do so now.
|
||
if (clearDirty) {
|
||
m_isDirty = FALSE;
|
||
}
|
||
|
||
} WsbCatch(hr);
|
||
|
||
WsbTraceOut(OLESTR("CFsaFilterClient::Save"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
||
|
||
return(hr);
|
||
}
|
||
|
||
|
||
HRESULT
|
||
CFsaFilterClient::SendRecallInfo(
|
||
IFsaFilterRecall *pRecall,
|
||
BOOL starting,
|
||
HRESULT rHr
|
||
)
|
||
|
||
/*++
|
||
|
||
Implements:
|
||
|
||
CFsaFilterClient::SendRecallInfo
|
||
|
||
--*/
|
||
{
|
||
HRESULT hr = E_FAIL;
|
||
|
||
if( ! m_identified && ( m_identifyThread != NULL ) ) {
|
||
|
||
//
|
||
// Wait for up to 10 seconds for identify thread to complete if
|
||
// Client not yet identified
|
||
//
|
||
WaitForMultipleObjects( 1, &m_identifyThread, FALSE, 10000 );
|
||
}
|
||
|
||
//
|
||
// Let the client know that the recall is starting or is finished
|
||
//
|
||
|
||
if ( m_identified ) {
|
||
|
||
try {
|
||
WsbTrace(OLESTR("CFsaFilterClient::SendRecallInfo - Client (%ls) is being notified of recall status (starting = %u hr = %x).\n"),
|
||
(WCHAR *) m_machineName, starting, rHr);
|
||
|
||
//
|
||
// Create intermediate server object which will be the client's
|
||
// connection back to the service. This object acts as a middle
|
||
// man to overcome the admin-only access into the FSA service.
|
||
//
|
||
CComPtr<IFsaRecallNotifyServer> pRecallServer;
|
||
WsbAffirmHr(CoCreateInstance(CLSID_CFsaRecallNotifyServer, 0, CLSCTX_NO_FAILURE_LOG | CLSCTX_ALL, IID_IFsaRecallNotifyServer, (void**)&pRecallServer));
|
||
WsbAffirmHr(pRecallServer->Init(pRecall));
|
||
|
||
CComPtr<IFsaRecallNotifyClient> pRecallClient;
|
||
hr = GetNotifyClientInterface ( m_machineName, &pRecallClient );
|
||
if ( SUCCEEDED( hr ) ) {
|
||
if (starting) {
|
||
hr = pRecallClient->OnRecallStarted ( pRecallServer );
|
||
} else {
|
||
hr = pRecallClient->OnRecallFinished ( pRecallServer, rHr );
|
||
}
|
||
if (hr != S_OK) {
|
||
WsbTrace(OLESTR("CFsaFilterClient::SendRecallInfo - Got the interface but failed in OnRecall... (%ls)\n"),
|
||
WsbHrAsString(hr));
|
||
}
|
||
} else {
|
||
WsbTrace(OLESTR("CFsaFilterClient::SendRecallInfo - error getting notify client interface hr = %ls (%x)\n"),
|
||
WsbHrAsString( hr ), hr);
|
||
}
|
||
} WsbCatchAndDo(hr,
|
||
WsbTrace(OLESTR("CFsaFilterClient::SendRecallInfo - hr = %ls\n"),
|
||
WsbHrAsString(hr));
|
||
);
|
||
}
|
||
|
||
return(hr);
|
||
|
||
}
|
||
|
||
|
||
|
||
HRESULT
|
||
CFsaFilterClient::SetAuthenticationId(
|
||
IN LONG luidHigh,
|
||
IN ULONG luidLow
|
||
)
|
||
|
||
/*++
|
||
|
||
Implements:
|
||
|
||
IFsaFilterClient::SetAuthenticationId().
|
||
|
||
--*/
|
||
{
|
||
m_luidHigh = luidHigh;
|
||
m_luidLow = luidLow;
|
||
|
||
return(S_OK);
|
||
}
|
||
|
||
|
||
HRESULT
|
||
CFsaFilterClient::SetDomainName(
|
||
IN OLECHAR* name
|
||
)
|
||
|
||
/*++
|
||
|
||
Implements:
|
||
|
||
IFsaFilterClient::SetDomainName().
|
||
|
||
--*/
|
||
{
|
||
HRESULT hr = S_OK;
|
||
|
||
try {
|
||
|
||
m_domainName = name;
|
||
WsbAssert(m_domainName != 0, E_UNEXPECTED);
|
||
|
||
} WsbCatch(hr);
|
||
|
||
return(hr);
|
||
}
|
||
|
||
|
||
HRESULT
|
||
CFsaFilterClient::SetIsAdmin(
|
||
IN BOOLEAN isAdmin
|
||
)
|
||
|
||
/*++
|
||
|
||
Implements:
|
||
|
||
IFsaFilterClient::SetIsAdmin().
|
||
|
||
--*/
|
||
{
|
||
m_isAdmin = isAdmin;
|
||
|
||
return(S_OK);
|
||
}
|
||
|
||
|
||
HRESULT
|
||
CFsaFilterClient::SetLastRecallTime(
|
||
IN FILETIME time
|
||
)
|
||
|
||
/*++
|
||
|
||
Implements:
|
||
|
||
IFsaFilterClient::SetLastRecallTime().
|
||
|
||
--*/
|
||
{
|
||
m_lastRecallTime = time;
|
||
|
||
return(S_OK);
|
||
}
|
||
|
||
|
||
HRESULT
|
||
CFsaFilterClient::SetMachineName(
|
||
IN OLECHAR* name
|
||
)
|
||
|
||
/*++
|
||
|
||
Implements:
|
||
|
||
IFsaFilterClient::SetMachineName().
|
||
|
||
--*/
|
||
{
|
||
HRESULT hr = S_OK;
|
||
|
||
try {
|
||
WsbAssert(name != 0, E_UNEXPECTED);
|
||
|
||
m_machineName = name;
|
||
m_identified = TRUE;
|
||
|
||
WsbTrace(OLESTR("CFsaFilterClient::SetMachineName Flag: %x Client ID: %x:%x Source: %ls == %ls\n"),
|
||
m_identified, m_luidLow, m_luidHigh, (WCHAR *) m_tokenSource, (WCHAR *) m_machineName);
|
||
|
||
|
||
} WsbCatch(hr);
|
||
|
||
return(hr);
|
||
}
|
||
|
||
|
||
HRESULT
|
||
CFsaFilterClient::SetRecallCount(
|
||
IN ULONG count
|
||
)
|
||
|
||
/*++
|
||
|
||
Implements:
|
||
|
||
IFsaFilterClient::SetRecallCount().
|
||
|
||
--*/
|
||
{
|
||
m_recallCount = count;
|
||
|
||
return(S_OK);
|
||
}
|
||
|
||
|
||
HRESULT
|
||
CFsaFilterClient::SetUserName(
|
||
IN OLECHAR* name
|
||
)
|
||
|
||
/*++
|
||
|
||
Implements:
|
||
|
||
IFsaFilterClient::SetUserName().
|
||
|
||
--*/
|
||
{
|
||
HRESULT hr = S_OK;
|
||
|
||
try {
|
||
|
||
m_userName = _wcsupr(name);
|
||
WsbAssert(m_userName != 0, E_UNEXPECTED);
|
||
|
||
} WsbCatch(hr);
|
||
|
||
return(hr);
|
||
}
|
||
|
||
|
||
HRESULT
|
||
CFsaFilterClient::SetHasRecallDisabled(
|
||
IN BOOL hasBeen
|
||
)
|
||
|
||
/*++
|
||
|
||
Implements:
|
||
|
||
IFsaFilterClient::SetHasRecallDisabled().
|
||
|
||
--*/
|
||
{
|
||
m_hasRecallDisabled = hasBeen;
|
||
|
||
return(S_OK);
|
||
}
|
||
|
||
|
||
HRESULT
|
||
CFsaFilterClient::SetHitRecallLimit(
|
||
IN BOOL hasBeen
|
||
)
|
||
|
||
/*++
|
||
|
||
Implements:
|
||
|
||
IFsaFilterClient::SetHitRecallLimit().
|
||
|
||
--*/
|
||
{
|
||
m_hitRecallLimit = hasBeen;
|
||
|
||
return(S_OK);
|
||
}
|
||
|
||
|
||
|
||
|
||
HRESULT
|
||
CFsaFilterClient::SetTokenSource(
|
||
IN CHAR *source
|
||
)
|
||
|
||
/*++
|
||
|
||
Implements:
|
||
|
||
IFsaFilterClient::SetTokenSource()
|
||
|
||
--*/
|
||
{
|
||
OLECHAR tSource[TOKEN_SOURCE_LENGTH + 1];
|
||
|
||
|
||
mbstowcs((WCHAR *) tSource, source, TOKEN_SOURCE_LENGTH);
|
||
m_tokenSource = tSource;
|
||
return(S_OK);
|
||
}
|
||
|
||
|
||
HRESULT
|
||
CFsaFilterClient::StartIdentify(
|
||
void
|
||
)
|
||
|
||
/*++
|
||
|
||
Implements:
|
||
|
||
CFsaFilterClient::StartIdentify().
|
||
|
||
--*/
|
||
{
|
||
#define WSB_BUFF_SIZE 1024
|
||
|
||
HRESULT hr = S_OK;
|
||
DWORD tid;
|
||
|
||
|
||
WsbTraceIn(OLESTR("CFsaFilterClient::StartIdentify"), OLESTR(""));
|
||
|
||
try {
|
||
WsbTrace(OLESTR("CFsaFilterClient::StartIdentify Flag: %x Client ID: %x:%x Source: %ls\n"),
|
||
m_identified, m_luidHigh, m_luidLow, (WCHAR *) m_tokenSource);
|
||
|
||
//
|
||
// If already identified then we bail out here.
|
||
//
|
||
WsbAffirm(m_identified == FALSE, S_OK);
|
||
//
|
||
// If the request is from User32 then it is local
|
||
//
|
||
|
||
if (_wcsicmp(m_tokenSource, L"User32") == 0) {
|
||
|
||
//
|
||
// Identified as the local machine.
|
||
// Set the name and bail out with S_OK
|
||
//
|
||
WsbGetComputerName( m_machineName );
|
||
m_identified = TRUE;
|
||
|
||
WsbTrace(OLESTR("CHsmFilterClient::StartIdentify: Identified as %ls.\n"),
|
||
(WCHAR *) m_machineName);
|
||
|
||
WsbThrow( S_OK );
|
||
} else {
|
||
//
|
||
// Start the identification thread
|
||
//
|
||
if (NULL == m_identifyThread) {
|
||
WsbTrace(OLESTR("CHsmFilterClient::StartIdentify: Starting ID thread.\n"));
|
||
|
||
WsbAffirm((m_identifyThread = CreateThread(0, 0, FsaIdentifyThread, (void*) this, 0, &tid)) != 0, HRESULT_FROM_WIN32(GetLastError()));
|
||
|
||
if (m_identifyThread == NULL) {
|
||
WsbAssertHr(E_FAIL); // TBD What error to return here??
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
} WsbCatch(hr);
|
||
|
||
|
||
WsbTraceOut(OLESTR("CFsaFilterClient::StartIdentify"), OLESTR("hr = %ls"), WsbHrAsString(hr));
|
||
|
||
return(hr);
|
||
}
|
||
|
||
|
||
|
||
HRESULT
|
||
CFsaFilterClient::Test(
|
||
USHORT* passed,
|
||
USHORT* failed
|
||
)
|
||
|
||
/*++
|
||
|
||
Implements:
|
||
|
||
IWsbTestable::Test().
|
||
|
||
--*/
|
||
{
|
||
HRESULT hr = S_OK;
|
||
|
||
try {
|
||
|
||
WsbAssert(0 != passed, E_POINTER);
|
||
WsbAssert(0 != failed, E_POINTER);
|
||
|
||
*passed = 0;
|
||
*failed = 0;
|
||
|
||
} WsbCatch(hr);
|
||
|
||
return(hr);
|
||
}
|