You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
315 lines
9.2 KiB
315 lines
9.2 KiB
// File: regzone.h
|
|
//
|
|
// Contents: Registry management for a single zone.
|
|
//
|
|
// Classes: CRegZone
|
|
//
|
|
// Functions:
|
|
//
|
|
// History:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
#ifndef _REGZONE_H_
|
|
#define _REGZONE_H_
|
|
|
|
// Constants corresponding to the registry.
|
|
#define MAX_REG_ZONE_CACHE 20
|
|
#define URLZONE_INVALID URLZONE_USER_MAX+1
|
|
|
|
#define MAX_ZONE_NAME 240
|
|
#define MAX_ZONE_PATH 256 // This is "Standard\\ZoneName"
|
|
#define MAX_VALUE_NAME 256
|
|
|
|
#define ZONEID_INVALID 0xFFFFFFFF
|
|
#define URLZONE_FINDCACHEENTRY 0xFFFFFFFF
|
|
|
|
// There are two registry keys under which the information is copied.
|
|
// One of them is "Zones" which holds the actual information and the other
|
|
// one is "TemplatePolicies" which holds the high medium and low policies.
|
|
// This enumeration indicates which part of the registry to read.
|
|
|
|
enum REGZONEUSE { REGZONEUSEZONES, REGZONEUSETEMPLATE };
|
|
|
|
class CRegZone
|
|
{
|
|
public:
|
|
CRegZone();
|
|
// Seperate init function to allow for failure on return.
|
|
BOOL Init(LPCTSTR lpStr, BOOL bCreate = TRUE, REGZONEUSE regZoneUse = REGZONEUSEZONES, BOOL bSystem = TRUE);
|
|
|
|
~CRegZone();
|
|
|
|
// Attributes
|
|
DWORD GetZoneId() const { return m_dwZoneId; }
|
|
LPTSTR GetZoneName() const { return m_lpZoneName; }
|
|
|
|
// Returns NULL terminated string, free using CoTaskFree
|
|
STDMETHODIMP GetZoneAttributes (ZONEATTRIBUTES& zoneAttrib);
|
|
STDMETHODIMP SetZoneAttributes (const ZONEATTRIBUTES& zoneAttrib);
|
|
|
|
STDMETHODIMP GetActionPolicy (DWORD dwAction, URLZONEREG urlZone, DWORD& dwPolicy) const;
|
|
STDMETHODIMP SetActionPolicy (DWORD dwAction, URLZONEREG urlZone, DWORD dwPolicy);
|
|
|
|
STDMETHODIMP GetCustomPolicy (REFGUID guid, URLZONEREG urlZone, BYTE** ppByte, DWORD *pcb) const;
|
|
STDMETHODIMP SetCustomPolicy (REFGUID guid, URLZONEREG urlZone, BYTE* pByte, DWORD cb);
|
|
|
|
STDMETHODIMP CopyTemplatePolicies(DWORD dwTemplateIndex);
|
|
|
|
BOOL UpdateZoneMapFlags( );
|
|
|
|
// Should we display this zone in the UI.
|
|
// Note that Zones not displayed in UI are not included in the zone enumeration.
|
|
inline BOOL IsUIZone() const;
|
|
|
|
protected:
|
|
inline IsValid() const { return (m_dwZoneId != ZONEID_INVALID); }
|
|
inline BOOL UseHKLM(URLZONEREG urlZoneReg) const;
|
|
|
|
// Helper functions
|
|
inline BOOL IsHardCodedZone() const { return FALSE; }
|
|
inline BOOL GetHardCodedZonePolicy(DWORD dwAction, DWORD& dwPolicy) const;
|
|
|
|
|
|
inline BOOL QueryTemplatePolicyIndex(CRegKey& regKey, LPCTSTR psz, LPDWORD pdw) const;
|
|
inline BOOL SetTemplatePolicyIndex(CRegKey& regKey, LPCTSTR psz, DWORD dw);
|
|
|
|
static BOOL IsAttributeName(LPCTSTR psz);
|
|
static LPCTSTR GetTemplateNameFromIndex ( URLTEMPLATE urlTemplateIndex);
|
|
inline static BOOL IsValidTemplateIndex( DWORD dwTemplateIndex );
|
|
static BOOL GetAggregateAction(DWORD dwAction, LPDWORD dwAggregateAction);
|
|
static void KludgeMapAggregatePolicy(DWORD dwAction, LPDWORD pdwAction);
|
|
static VOID IncrementGlobalCounter( );
|
|
|
|
// Methods/members to support caching
|
|
protected:
|
|
|
|
class CRegZoneCache {
|
|
public:
|
|
CRegZoneCache(void);
|
|
~CRegZoneCache(void);
|
|
|
|
BOOL Lookup(DWORD dwZone, LPTSTR lpZonePath, DWORD dwAction, BOOL fUseHKLM, DWORD *pdwPolicy);
|
|
void Add(DWORD dwZone, DWORD dwAction, BOOL fUseHKLM, DWORD dwPolicy, int iEntry = URLZONE_FINDCACHEENTRY);
|
|
void Flush(void);
|
|
|
|
static VOID IncrementGlobalCounter( );
|
|
|
|
protected:
|
|
|
|
// Counters to flag cross-process cache invalidation.
|
|
DWORD m_dwPrevCounter ; // Global counter so we can correctly invalidate the cache if
|
|
// user changes options.
|
|
static HANDLE s_hMutexCounter; // mutex controlling access to shared memory counter.
|
|
|
|
BOOL IsCounterEqual() const;
|
|
VOID SetToCurrentCounter();
|
|
|
|
// The body of the cache is this array of cache entries.
|
|
// Cross-thread access control for the array is by critical section.
|
|
|
|
CRITICAL_SECTION m_csectZoneCache; // assumes only one, static instance of the cache
|
|
|
|
|
|
struct CRegZoneCacheEntry {
|
|
CRegZoneCacheEntry(void) :
|
|
m_dwZone(ZONEID_INVALID),
|
|
m_dwAction(0),
|
|
m_fUseHKLM(FALSE),
|
|
m_dwPolicy(0) {};
|
|
~CRegZoneCacheEntry(void) { Flush(); };
|
|
|
|
void Set(DWORD dwZone, DWORD dwAction, BOOL fUseHKLM, DWORD dwPolicy);
|
|
void Flush(void);
|
|
|
|
DWORD m_dwZone;
|
|
DWORD m_dwAction;
|
|
BOOL m_fUseHKLM;
|
|
DWORD m_dwPolicy;
|
|
}; // CRegZoneCacheEntry
|
|
|
|
CRegZoneCacheEntry m_arzce[MAX_REG_ZONE_CACHE];
|
|
int m_iAdd;
|
|
|
|
BOOL FindCacheEntry(DWORD dwZone, DWORD dwAction, BOOL fUseHKLM, int& riEntry ); // must be called under critical section.
|
|
|
|
}; // CRegZoneCache
|
|
|
|
static CRegZoneCache s_rzcache;
|
|
|
|
private:
|
|
|
|
DWORD m_dwZoneId;
|
|
DWORD m_dwZoneFlags;
|
|
LPTSTR m_lpZoneName;
|
|
LPTSTR m_lpZonePath;
|
|
|
|
BOOL m_bHKLMOnly;
|
|
BOOL m_bStandard;
|
|
BOOL m_bZoneLockOut; // Is the whole zone locked out.
|
|
REGZONEUSE m_regZoneUse;
|
|
};
|
|
|
|
typedef CRegZone *LPREGZONE;
|
|
|
|
BOOL CRegZone::UseHKLM(URLZONEREG urlZoneReg) const
|
|
{
|
|
BOOL bReturn;
|
|
|
|
switch(urlZoneReg)
|
|
{
|
|
case URLZONEREG_HKLM:
|
|
bReturn = TRUE;
|
|
break;
|
|
case URLZONEREG_HKCU:
|
|
bReturn = FALSE;
|
|
break;
|
|
case URLZONEREG_DEFAULT:
|
|
bReturn = m_bHKLMOnly;
|
|
break;
|
|
default:
|
|
TransAssert(FALSE);
|
|
}
|
|
|
|
return bReturn;
|
|
}
|
|
|
|
BOOL CRegZone::IsValidTemplateIndex(DWORD dwTemplateIndex)
|
|
{
|
|
BOOL bReturn = FALSE;
|
|
|
|
switch (dwTemplateIndex)
|
|
{
|
|
case URLTEMPLATE_CUSTOM:
|
|
case URLTEMPLATE_LOW:
|
|
case URLTEMPLATE_MEDLOW:
|
|
case URLTEMPLATE_MEDIUM:
|
|
case URLTEMPLATE_HIGH:
|
|
bReturn = TRUE;
|
|
break;
|
|
}
|
|
return bReturn;
|
|
}
|
|
|
|
BOOL CRegZone::QueryTemplatePolicyIndex(CRegKey& regKey, LPCTSTR psz, LPDWORD pdw) const
|
|
{
|
|
LONG lRet;
|
|
|
|
lRet = regKey.QueryValue(pdw, psz);
|
|
|
|
if (NO_ERROR != lRet)
|
|
{
|
|
*pdw = URLTEMPLATE_CUSTOM;
|
|
}
|
|
else if (*pdw < URLTEMPLATE_PREDEFINED_MIN || *pdw > URLTEMPLATE_PREDEFINED_MAX)
|
|
{
|
|
// Invalid value, just return back default.
|
|
*pdw = URLTEMPLATE_CUSTOM;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL CRegZone::SetTemplatePolicyIndex(CRegKey& regKey, LPCTSTR psz, DWORD dwIndex)
|
|
{
|
|
// Write this only if it is a valid template index.
|
|
if (IsValidTemplateIndex(dwIndex))
|
|
{
|
|
if (regKey.SetValue(dwIndex, psz) == NO_ERROR)
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
TransAssert(FALSE);
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
BOOL CRegZone::GetHardCodedZonePolicy(DWORD dwAction, DWORD& dwPolicy) const
|
|
{
|
|
TransAssert(IsHardCodedZone());
|
|
|
|
if (!IsHardCodedZone())
|
|
return FALSE;
|
|
|
|
switch(dwAction)
|
|
{
|
|
case URLACTION_JAVA_PERMISSIONS:
|
|
dwPolicy = URLPOLICY_JAVA_HIGH;
|
|
break;
|
|
case URLACTION_CREDENTIALS_USE:
|
|
dwPolicy = URLPOLICY_CREDENTIALS_SILENT_LOGON_OK;
|
|
break;
|
|
case URLACTION_AUTHENTICATE_CLIENT:
|
|
dwPolicy = URLPOLICY_AUTHENTICATE_CLEARTEXT_OK;
|
|
break;
|
|
case URLACTION_ACTIVEX_OVERRIDE_OBJECT_SAFETY:
|
|
dwPolicy = URLPOLICY_QUERY;
|
|
break;
|
|
default:
|
|
dwPolicy = 0;
|
|
break;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL CRegZone::IsUIZone() const
|
|
{
|
|
return (m_dwZoneFlags & ZAFLAGS_NO_UI) ? FALSE : TRUE;
|
|
}
|
|
|
|
// This is the class that maintains the list of the RegZones currently in action
|
|
|
|
class CRegZoneContainer
|
|
{
|
|
public:
|
|
|
|
CRegZoneContainer();
|
|
~CRegZoneContainer();
|
|
|
|
public:
|
|
BOOL Attach(BOOL bUseHKLM, REGZONEUSE regZoneUse = REGZONEUSEZONES);
|
|
BOOL Detach();
|
|
BOOL SelfHeal(BOOL bUseHKLM);
|
|
|
|
CRegZone * GetRegZoneByName(LPCTSTR lpszZoneName) const;
|
|
CRegZone * GetRegZoneById(DWORD dwZoneId) const;
|
|
DWORD GetZoneCount() const { return m_cZones; };
|
|
|
|
STDMETHODIMP CreateZoneEnumerator(DWORD *pdwEnum, DWORD *pdwCount);
|
|
STDMETHODIMP GetZoneAt(DWORD dwEnum, DWORD dwIndex, DWORD *pdwZone);
|
|
STDMETHODIMP DestroyZoneEnumerator(DWORD dwEnum);
|
|
|
|
protected:
|
|
// Used internally only.
|
|
struct CRegListElem {
|
|
CRegListElem * next;
|
|
CRegZone * pRegZone;
|
|
DWORD dwZoneIndex;
|
|
};
|
|
|
|
struct CZoneEnumList {
|
|
DWORD dwEnum; // Cookie indicating which enum this corresponds to.
|
|
CZoneEnumList * next;
|
|
};
|
|
|
|
CZoneEnumList * m_pZoneEnumList;
|
|
DWORD m_dwNextEnum;
|
|
|
|
// Is this enumerator a valid enumerator.
|
|
BOOL VerifyZoneEnum(DWORD dwEnum) const;
|
|
|
|
private:
|
|
|
|
CRegZone** m_ppRegZones; // Array of RegZones.
|
|
DWORD m_cZones; // # of Zones.
|
|
BOOL m_bHKLMOnly;
|
|
CRITICAL_SECTION m_csect;
|
|
};
|
|
|
|
#endif // _REGZONE_H_
|
|
|
|
|