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.
547 lines
20 KiB
547 lines
20 KiB
//+-------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
//
|
|
// Copyright (C) Microsoft Corporation, 1997 - 1999
|
|
//
|
|
// File: config.cpp
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
#include "pch.h"
|
|
#pragma hdrstop
|
|
|
|
#include <shlwapi.h>
|
|
#include "config.h"
|
|
#include "util.h"
|
|
#include "strings.h"
|
|
|
|
|
|
LPCTSTR CConfig::s_rgpszSubkeys[] = { REGSTR_KEY_OFFLINEFILES,
|
|
REGSTR_KEY_OFFLINEFILESPOLICY };
|
|
|
|
LPCTSTR CConfig::s_rgpszValues[] = { REGSTR_VAL_DEFCACHESIZE,
|
|
REGSTR_VAL_CSCENABLED,
|
|
REGSTR_VAL_GOOFFLINEACTION,
|
|
REGSTR_VAL_NOCONFIGCACHE,
|
|
REGSTR_VAL_NOCACHEVIEWER,
|
|
REGSTR_VAL_NOMAKEAVAILABLEOFFLINE,
|
|
REGSTR_VAL_SYNCATLOGOFF,
|
|
REGSTR_VAL_SYNCATLOGON,
|
|
REGSTR_VAL_SYNCATSUSPEND,
|
|
REGSTR_VAL_NOREMINDERS,
|
|
REGSTR_VAL_REMINDERFREQMINUTES,
|
|
REGSTR_VAL_INITIALBALLOONTIMEOUTSECONDS,
|
|
REGSTR_VAL_REMINDERBALLOONTIMEOUTSECONDS,
|
|
REGSTR_VAL_EVENTLOGGINGLEVEL,
|
|
REGSTR_VAL_PURGEATLOGOFF,
|
|
REGSTR_VAL_PURGEONLYAUTOCACHEATLOGOFF,
|
|
REGSTR_VAL_FIRSTPINWIZARDSHOWN,
|
|
REGSTR_VAL_SLOWLINKSPEED,
|
|
REGSTR_VAL_ALWAYSPINSUBFOLDERS,
|
|
REGSTR_VAL_ENCRYPTCACHE,
|
|
REGSTR_VAL_NOFRADMINPIN
|
|
};
|
|
|
|
//
|
|
// Returns the single instance of the CConfig class.
|
|
// Note that by making the singleton instance a function static
|
|
// object it is not created until the first call to GetSingleton.
|
|
//
|
|
CConfig& CConfig::GetSingleton(
|
|
void
|
|
)
|
|
{
|
|
static CConfig TheConfig;
|
|
return TheConfig;
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// This is the workhorse of the CSCUI policy code for scalar values.
|
|
// The caller passes in a value (iVAL_XXXXXX) identifier from the eValues
|
|
// enumeration to identify the policy/preference value of interest.
|
|
// Known keys in the registry are scanned until a value is found.
|
|
// The scanning order enforces the precedence of policy vs. default vs.
|
|
// preference and machine vs. user.
|
|
//
|
|
DWORD CConfig::GetValue(
|
|
eValues iValue,
|
|
bool *pbSetByPolicy
|
|
) const
|
|
{
|
|
//
|
|
// This table identifies each DWORD policy/preference item used by CSCUI.
|
|
// The entries MUST be ordered the same as the eValues enumeration.
|
|
// Each entry describes the possible sources for data and a default value
|
|
// to be used if no registry entries are present or if there's a problem reading
|
|
// the registry.
|
|
//
|
|
static const struct Item
|
|
{
|
|
DWORD fSrc; // Mask indicating the reg locations to read.
|
|
DWORD dwDefault; // Hard-coded default.
|
|
|
|
} rgItems[] = {
|
|
|
|
// Value ID eSRC_PREF_CU | eSRC_PREF_LM | eSRC_POL_CU | eSRC_POL_LM Default value
|
|
// -------------------------------------- ------------ ------------ ----------- ----------- -------------------
|
|
/* iVAL_DEFCACHESIZE */ { eSRC_POL_LM, 1000 },
|
|
/* iVAL_CSCENABLED */ { eSRC_POL_LM, 1 },
|
|
/* iVAL_GOOFFLINEACTION */ { eSRC_PREF_CU | eSRC_POL_CU | eSRC_POL_LM, eGoOfflineSilent },
|
|
/* iVAL_NOCONFIGCACHE */ { eSRC_POL_CU | eSRC_POL_LM, 0 },
|
|
/* iVAL_NOCACHEVIEWER */ { eSRC_POL_CU | eSRC_POL_LM, 0 },
|
|
/* iVAL_NOMAKEAVAILABLEOFFLINE */ { eSRC_POL_CU | eSRC_POL_LM, 0 },
|
|
/* iVAL_SYNCATLOGOFF */ { eSRC_PREF_CU | eSRC_POL_CU | eSRC_POL_LM, eSyncFull },
|
|
/* iVAL_SYNCATLOGON */ { eSRC_PREF_CU | eSRC_POL_CU | eSRC_POL_LM, eSyncNone },
|
|
/* iVAL_SYNCATSUSPEND */ { eSRC_POL_CU | eSRC_POL_LM, eSyncNone },
|
|
/* iVAL_NOREMINDERS */ { eSRC_PREF_CU | eSRC_POL_CU | eSRC_POL_LM, 0 },
|
|
/* iVAL_REMINDERFREQMINUTES */ { eSRC_PREF_CU | eSRC_POL_CU | eSRC_POL_LM, 60 },
|
|
/* iVAL_INITIALBALLOONTIMEOUTSECONDS */ { eSRC_POL_CU | eSRC_POL_LM, 30 },
|
|
/* iVAL_REMINDERBALLOONTIMEOUTSECONDS */ { eSRC_POL_CU | eSRC_POL_LM, 15 },
|
|
/* iVAL_EVENTLOGGINGLEVEL */ { eSRC_PREF_CU | eSRC_PREF_LM | eSRC_POL_CU | eSRC_POL_LM, 0 },
|
|
/* iVAL_PURGEATLOGOFF */ { eSRC_POL_LM, 0 },
|
|
/* iVAL_PURGEONLYAUTOCACHEATLOGOFF */ { eSRC_POL_LM, 0 },
|
|
/* iVAL_FIRSTPINWIZARDSHOWN */ { eSRC_PREF_CU , 0 },
|
|
/* iVAL_SLOWLINKSPEED */ { eSRC_PREF_CU | eSRC_PREF_LM | eSRC_POL_CU | eSRC_POL_LM, 640 },
|
|
/* iVAL_ALWAYSPINSUBFOLDERS */ { eSRC_POL_LM, 0 },
|
|
/* iVAL_ENCRYPTCACHE */ { eSRC_PREF_LM | eSRC_POL_LM, 0 },
|
|
/* iVAL_NOFRADMINPIN */ { eSRC_POL_CU | eSRC_POL_LM, 0 }
|
|
};
|
|
|
|
//
|
|
// This table maps registry keys and subkey names to our
|
|
// source mask values. The array is ordered with the highest
|
|
// precedence sources first. A policy level mask is also
|
|
// associated with each entry so that we honor the "big switch"
|
|
// for enabling/disabling CSCUI policies.
|
|
//
|
|
static const struct Source
|
|
{
|
|
eSources fSrc; // Source for reg data.
|
|
HKEY hkeyRoot; // Root key in registry (hkcu, hklm).
|
|
eSubkeys iSubkey; // Index into s_rgpszSubkeys[]
|
|
|
|
} rgSrcs[] = { { eSRC_POL_LM, HKEY_LOCAL_MACHINE, iSUBKEY_POL },
|
|
{ eSRC_POL_CU, HKEY_CURRENT_USER, iSUBKEY_POL },
|
|
{ eSRC_PREF_CU, HKEY_CURRENT_USER, iSUBKEY_PREF },
|
|
{ eSRC_PREF_LM, HKEY_LOCAL_MACHINE, iSUBKEY_PREF }
|
|
};
|
|
|
|
|
|
const Item& item = rgItems[iValue];
|
|
DWORD dwResult = item.dwDefault; // Set default return value.
|
|
bool bSetByPolicy = false;
|
|
|
|
//
|
|
// Iterate over all of the sources until we find one that is specified
|
|
// for this item. For each iteration, if we're able to read the value,
|
|
// that's the one we return. If not we drop down to the next source
|
|
// in the precedence order (rgSrcs[]) and try to read it's value. If
|
|
// we've tried all of the sources without a successful read we return the
|
|
// hard-coded default.
|
|
//
|
|
for (int i = 0; i < ARRAYSIZE(rgSrcs); i++)
|
|
{
|
|
const Source& src = rgSrcs[i];
|
|
|
|
//
|
|
// Is this source valid for this item?
|
|
//
|
|
if (0 != (src.fSrc & item.fSrc))
|
|
{
|
|
//
|
|
// This source is valid for this item. Read it.
|
|
//
|
|
DWORD cbResult = sizeof(dwResult);
|
|
DWORD dwType;
|
|
|
|
if (ERROR_SUCCESS == SHGetValue(src.hkeyRoot,
|
|
s_rgpszSubkeys[src.iSubkey],
|
|
s_rgpszValues[iValue],
|
|
&dwType,
|
|
&dwResult,
|
|
&cbResult))
|
|
{
|
|
//
|
|
// We read a value from the registry so we're done.
|
|
//
|
|
bSetByPolicy = (0 != (eSRC_POL & src.fSrc));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (NULL != pbSetByPolicy)
|
|
*pbSetByPolicy = bSetByPolicy;
|
|
|
|
return dwResult;
|
|
}
|
|
|
|
|
|
//
|
|
// Save a custom GoOfflineAction list to the registry.
|
|
// See comments for LoadCustomGoOfflineActions for formatting details.
|
|
//
|
|
HRESULT
|
|
CConfig::SaveCustomGoOfflineActions(
|
|
HKEY hkey,
|
|
HDPA hdpaGOA
|
|
)
|
|
{
|
|
if (NULL == hdpaGOA)
|
|
{
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
HRESULT hr = NOERROR;
|
|
TCHAR szServer[MAX_PATH];
|
|
TCHAR szAction[20];
|
|
const int cGOA = DPA_GetPtrCount(hdpaGOA);
|
|
for (int i = 0; i < cGOA; i++)
|
|
{
|
|
//
|
|
// Write each sharename-action pair to the registry.
|
|
// The action value must be converted to ASCII to be
|
|
// compatible with the values generated by poledit.
|
|
//
|
|
CustomGOA *pGOA = (CustomGOA *)DPA_GetPtr(hdpaGOA, i);
|
|
if (NULL != pGOA)
|
|
{
|
|
wnsprintf(szAction, ARRAYSIZE(szAction), TEXT("%d"), DWORD(pGOA->GetAction()));
|
|
pGOA->GetServerName(szServer, ARRAYSIZE(szServer));
|
|
DWORD dwResult = RegSetValueEx(hkey,
|
|
szServer,
|
|
0,
|
|
REG_SZ,
|
|
(CONST BYTE *)szAction,
|
|
(lstrlen(szAction)+1) * sizeof(szAction[0]));
|
|
|
|
hr = HRESULT_FROM_WIN32(dwResult);
|
|
if (FAILED(hr))
|
|
{
|
|
Trace((TEXT("Error 0x%08X saving GoOfflineAction for \"%s\" to registry."),
|
|
hr, szServer));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
CConfig::CustomGOAExists(
|
|
HDPA hdpaGOA,
|
|
const CustomGOA& goa
|
|
)
|
|
{
|
|
if (NULL != hdpaGOA)
|
|
{
|
|
const int cEntries = DPA_GetPtrCount(hdpaGOA);
|
|
for (int i = 0; i < cEntries; i++)
|
|
{
|
|
CustomGOA *pGOA = (CustomGOA *)DPA_GetPtr(hdpaGOA, i);
|
|
if (NULL != pGOA)
|
|
{
|
|
if (0 == goa.CompareByServer(*pGOA))
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
//
|
|
// Builds an array of Go-offline actions.
|
|
// Each entry is a server-action pair.
|
|
//
|
|
void
|
|
CConfig::GetCustomGoOfflineActions(
|
|
HDPA hdpa,
|
|
bool *pbSetByPolicy // optional. Can be NULL.
|
|
)
|
|
{
|
|
TraceAssert(NULL != hdpa);
|
|
|
|
static const struct Source
|
|
{
|
|
eSources fSrc; // Source for reg data.
|
|
HKEY hkeyRoot; // Root key in registry (hkcu, hklm).
|
|
eSubkeys iSubkey; // Index into s_rgpszSubkeys[]
|
|
|
|
} rgSrcs[] = { { eSRC_POL_LM, HKEY_LOCAL_MACHINE, iSUBKEY_POL },
|
|
{ eSRC_POL_CU, HKEY_CURRENT_USER, iSUBKEY_POL },
|
|
{ eSRC_PREF_CU, HKEY_CURRENT_USER, iSUBKEY_PREF }
|
|
};
|
|
|
|
ClearCustomGoOfflineActions(hdpa);
|
|
|
|
bool bSetByPolicyAny = false;
|
|
bool bSetByPolicy = false;
|
|
|
|
//
|
|
// Iterate over all of the possible sources.
|
|
//
|
|
for (int i = 0; i < ARRAYSIZE(rgSrcs); i++)
|
|
{
|
|
const Source& src = rgSrcs[i];
|
|
HKEY hkey;
|
|
DWORD dwResult = RegOpenKeyEx(src.hkeyRoot,
|
|
s_rgpszSubkeys[src.iSubkey],
|
|
0,
|
|
KEY_READ,
|
|
&hkey);
|
|
if (ERROR_SUCCESS == dwResult)
|
|
{
|
|
HKEY hkeyGOA;
|
|
dwResult = RegOpenKeyEx(hkey,
|
|
REGSTR_SUBKEY_CUSTOMGOOFFLINEACTIONS,
|
|
0,
|
|
KEY_READ,
|
|
&hkeyGOA);
|
|
|
|
if (ERROR_SUCCESS == dwResult)
|
|
{
|
|
TCHAR szName[MAX_PATH];
|
|
TCHAR szValue[20];
|
|
DWORD dwIndex = 0;
|
|
do
|
|
{
|
|
DWORD dwType;
|
|
DWORD cbValue = sizeof(szValue);
|
|
DWORD cchName = ARRAYSIZE(szName);
|
|
|
|
dwResult = RegEnumValue(hkeyGOA,
|
|
dwIndex,
|
|
szName,
|
|
&cchName,
|
|
NULL,
|
|
&dwType,
|
|
(LPBYTE)szValue,
|
|
&cbValue);
|
|
|
|
if (ERROR_SUCCESS == dwResult)
|
|
{
|
|
dwIndex++;
|
|
if (REG_SZ == dwType)
|
|
{
|
|
//
|
|
// Convert from "0","1","2" to 0,1,2
|
|
//
|
|
DWORD dwValue = szValue[0] - TEXT('0');
|
|
if (IsValidGoOfflineAction(dwValue))
|
|
{
|
|
//
|
|
// Only add if value is of proper type and value.
|
|
// Protects against someone manually adding garbage
|
|
// to the registry.
|
|
//
|
|
// Server names can also be entered into the registry
|
|
// using poledit (and winnt.adm). This entry mechanism
|
|
// can't validate format so we need to ensure the entry
|
|
// doesn't have leading '\' or space characters.
|
|
//
|
|
LPCTSTR pszServer = szName;
|
|
while(*pszServer && (TEXT('\\') == *pszServer || TEXT(' ') == *pszServer))
|
|
pszServer++;
|
|
|
|
bSetByPolicy = (0 != (src.fSrc & eSRC_POL));
|
|
bSetByPolicyAny = bSetByPolicyAny || bSetByPolicy;
|
|
CustomGOA *pGOA = new CustomGOA(pszServer,
|
|
(CConfig::OfflineAction)dwValue,
|
|
bSetByPolicy);
|
|
if (NULL != pGOA)
|
|
{
|
|
if (CustomGOAExists(hdpa, *pGOA) || -1 == DPA_AppendPtr(hdpa, pGOA))
|
|
{
|
|
delete pGOA;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Trace((TEXT("GoOfflineAction value %d invalid for \"%s\""),
|
|
dwValue, szName));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Trace((TEXT("GoOfflineAction for \"%s\" has invalid reg type %d"),
|
|
szName, dwType));
|
|
}
|
|
}
|
|
}
|
|
while(ERROR_SUCCESS == dwResult);
|
|
RegCloseKey(hkeyGOA);
|
|
}
|
|
RegCloseKey(hkey);
|
|
}
|
|
}
|
|
if (NULL != pbSetByPolicy)
|
|
*pbSetByPolicy = bSetByPolicyAny;
|
|
}
|
|
|
|
|
|
//
|
|
// Delete all CustomGOA blocks attached to a DPA.
|
|
// When complete, the DPA is empty.
|
|
//
|
|
void
|
|
CConfig::ClearCustomGoOfflineActions( // [static]
|
|
HDPA hdpaGOA
|
|
)
|
|
{
|
|
if (NULL != hdpaGOA)
|
|
{
|
|
const int cEntries = DPA_GetPtrCount(hdpaGOA);
|
|
for (int i = cEntries - 1; 0 <= i; i--)
|
|
{
|
|
CustomGOA *pGOA = (CustomGOA *)DPA_GetPtr(hdpaGOA, i);
|
|
delete pGOA;
|
|
DPA_DeletePtr(hdpaGOA, i);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// Retrieve the go-offline action for a specific server. If the server
|
|
// has a "customized" action defined by either system policy or user
|
|
// setting, that action is used. Otherwise, the "default" action is
|
|
// used.
|
|
//
|
|
int
|
|
CConfig::GoOfflineAction(
|
|
LPCTSTR pszServer
|
|
) const
|
|
{
|
|
int iAction = GoOfflineAction(); // Get default action.
|
|
|
|
if (NULL == pszServer)
|
|
return iAction;
|
|
|
|
TraceAssert(NULL != pszServer);
|
|
|
|
//
|
|
// Skip passed any leading backslashes for comparison.
|
|
// The values we store in the registry don't have a leading "\\".
|
|
//
|
|
while(*pszServer && TEXT('\\') == *pszServer)
|
|
pszServer++;
|
|
|
|
HRESULT hr;
|
|
CConfig::OfflineActionInfo info;
|
|
CConfig::OfflineActionIter iter = CreateOfflineActionIter();
|
|
while(S_OK == (hr = iter.Next(&info)))
|
|
{
|
|
if (0 == lstrcmpi(pszServer, info.szServer))
|
|
{
|
|
iAction = info.iAction; // Return custom action.
|
|
break;
|
|
}
|
|
}
|
|
//
|
|
// Guard against bogus reg data.
|
|
//
|
|
if (eNumOfflineActions <= iAction || 0 > iAction)
|
|
iAction = eGoOfflineSilent;
|
|
|
|
return iAction;
|
|
}
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// CConfig::CustomGOA
|
|
// "GOA" is "Go Offline Action"
|
|
//-----------------------------------------------------------------------------
|
|
bool
|
|
CConfig::CustomGOA::operator < (
|
|
const CustomGOA& rhs
|
|
) const
|
|
{
|
|
int diff = CompareByServer(rhs);
|
|
if (0 == diff)
|
|
diff = m_action - rhs.m_action;
|
|
|
|
return diff < 0;
|
|
}
|
|
|
|
|
|
//
|
|
// Compare two CustomGoOfflineAction objects by their
|
|
// server names. Comparison is case-insensitive.
|
|
// Returns: <0 = *this < rhs
|
|
// 0 = *this == rhs
|
|
// >0 = *this > rhs
|
|
//
|
|
int
|
|
CConfig::CustomGOA::CompareByServer(
|
|
const CustomGOA& rhs
|
|
) const
|
|
{
|
|
return lstrcmpi(GetServerName(), rhs.GetServerName());
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// CConfig::OfflineActionIter
|
|
//-----------------------------------------------------------------------------
|
|
CConfig::OfflineActionIter::OfflineActionIter(
|
|
const CConfig *pConfig
|
|
) : m_pConfig(const_cast<CConfig *>(pConfig)),
|
|
m_iAction(-1),
|
|
m_hdpaGOA(DPA_Create(4))
|
|
{
|
|
}
|
|
|
|
|
|
CConfig::OfflineActionIter::~OfflineActionIter(
|
|
void
|
|
)
|
|
{
|
|
if (NULL != m_hdpaGOA)
|
|
{
|
|
CConfig::ClearCustomGoOfflineActions(m_hdpaGOA);
|
|
DPA_Destroy(m_hdpaGOA);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
HRESULT
|
|
CConfig::OfflineActionIter::Next(
|
|
OfflineActionInfo *pInfo
|
|
)
|
|
{
|
|
if (NULL == m_hdpaGOA)
|
|
{
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
HRESULT hr = S_FALSE;
|
|
|
|
if (-1 == m_iAction)
|
|
{
|
|
m_pConfig->GetCustomGoOfflineActions(m_hdpaGOA);
|
|
m_iAction = 0;
|
|
}
|
|
if (m_iAction < DPA_GetPtrCount(m_hdpaGOA))
|
|
{
|
|
CustomGOA *pGOA = (CustomGOA *)DPA_GetPtr(m_hdpaGOA, m_iAction);
|
|
if (NULL != pGOA)
|
|
{
|
|
hr = StringCchCopy(pInfo->szServer, ARRAYSIZE(pInfo->szServer), pGOA->GetServerName());
|
|
pInfo->iAction = (DWORD)pGOA->GetAction();
|
|
m_iAction++;
|
|
}
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
|
|
|