Windows2000/private/inet/urlmon/zones/regzone.h

316 lines
8.7 KiB
C
Raw Normal View History

2001-01-01 00:00:00 +01:00
// 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_