// 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_