static internal IInternalConfigRecord Create(
InternalConfigRoot configRoot,
IInternalConfigRecord parent,
string configPath) {
RuntimeConfigurationRecord configRecord = new RuntimeConfigurationRecord();
configRecord.Init(configRoot, (BaseConfigurationRecord) parent, configPath, null);
return configRecord;
}
private HybridDictionary _streamInfoUpdates; // List of StreamInfo, including the main config file, the configSource this record uses, and
// new configSource stream added thru API
static internal MgmtConfigurationRecord Create(
IInternalConfigRoot configRoot,
IInternalConfigRecord parent,
string configPath,
string locationSubPath) {
MgmtConfigurationRecord configRecord = new MgmtConfigurationRecord();
configRecord.Init(configRoot, parent, configPath, locationSubPath);
return configRecord;
}
protected RuntimeConfig(IInternalConfigRecord configRecord, bool permitNull)
{
this._configRecord = configRecord;
this._permitNull = permitNull;
this._results = new object[0x18];
for (int i = 0; i < this._results.Length; i++)
{
this._results[i] = s_unevaluatedResult;
}
}
private void Init(
IInternalConfigRoot configRoot,
IInternalConfigRecord parent,
string configPath,
string locationSubPath) {
base.Init(configRoot, (BaseConfigurationRecord) parent, configPath, locationSubPath);
if ( IsLocationConfig &&
(MgmtParent._locationTags == null || !MgmtParent._locationTags.Contains(_locationSubPath))) {
// By instantiating a "new" LocationSubPath class, we have implicitly
// asked for one to be created
_flags[ForceLocationWritten] = true;
}
// Copy all stream information so that we can model changes to ConfigSource
InitStreamInfoUpdates();
}
public override void GetRestrictedPermissions(IInternalConfigRecord configRecord, out PermissionSet permissionSet, out bool isHostReady)
{
string streamName;
bool flag = this.IsFile(configRecord.StreamName);
if (flag)
{
streamName = UrlPath.ConvertFileNameToUrl(configRecord.StreamName);
}
else
{
streamName = configRecord.StreamName;
}
Evidence evidence = new Evidence();
evidence.AddHostEvidence<Url>(new Url(streamName));
evidence.AddHostEvidence<Zone>(Zone.CreateFromUrl(streamName));
if (!flag)
{
evidence.AddHostEvidence<Site>(Site.CreateFromUrl(streamName));
}
permissionSet = SecurityManager.GetStandardSandbox(evidence);
isHostReady = true;
}
public virtual bool IsInitDelayed(IInternalConfigRecord configRecord)
{
return(Host.IsInitDelayed(configRecord));
}
public virtual void RequireCompleteInit(IInternalConfigRecord configRecord) {}
// Ensure that initialization has completed, while handling re-entrancy issues
// for certain sections that may be used during initialization itself.
private void EnsureInit(string configKey)
{
bool doInit = false;
lock (this)
{
// If the user config is not initialized, then we must either:
// a. Perform the initialization ourselves if no other thread is doing it, or
// b. Wait for the initialization to complete if we know the section is not used during initialization itself, or
// c. Ignore initialization if the section can be used during initialization. Note that GetSection()
// returns null is initialization has not completed.
if (!_isUserConfigInited)
{
if (!_isInitInProgress)
{
_isInitInProgress = true;
doInit = true;
}
else
{
if (!IsSectionUsedInInit(configKey))
{
// Wait for initialization to complete.
Monitor.Wait(this);
}
}
}
}
if (!doInit)
{
return;
}
try
{
try
{
// Initialize machine configuration.
_machineConfigRecord = _configRoot.GetConfigRecord(
ClientConfigurationHost.MachineConfigPath);
_machineConfigRecord.ThrowIfInitErrors();
// Make machine configuration available to system.net sections
// when application configuration is downloaded via http.
_isMachineConfigInited = true;
// If we add System.Net.Configuration we'll need to kick the initialization here
// to prevent deadlocks in the networking classes by loading networking config
// before making any networking requests.
//
// Any requests for sections used in initialization during the call to
// EnsureConfigLoaded() will be served by _machine.config or will return null.
//if (_isAppConfigHttp)
//{
//}
// Now load the rest of configuration
var configHostPaths = (IInternalConfigHostPaths)_configHost;
configHostPaths.RefreshConfigPaths();
string configPath;
if (configHostPaths.HasLocalConfig)
{
configPath = ClientConfigurationHost.LocalUserConfigPath;
}
else
{
configPath = configHostPaths.HasRoamingConfig
? ClientConfigurationHost.RoamingUserConfigPath
: ClientConfigurationHost.ExeConfigPath;
}
_completeConfigRecord = _configRoot.GetConfigRecord(configPath);
_completeConfigRecord.ThrowIfInitErrors();
_isUserConfigInited = true;
}
catch (Exception e)
{
_initError =
new ConfigurationErrorsException(SR.Config_client_config_init_error, e);
throw _initError;
}
}
catch
{
ConfigurationManager.SetInitError(_initError);
_isMachineConfigInited = true;
_isUserConfigInited = true;
throw;
}
finally
{
lock (this)
{
try
{
// Notify ConfigurationSettings that initialization has fully completed,
// even if unsuccessful.
ConfigurationManager.CompleteConfigInit();
_isInitInProgress = false;
}
finally
{
// Wake up all threads waiting for initialization to complete.
Monitor.PulseAll(this);
}
}
}
}
public virtual bool IsInitDelayed (IInternalConfigRecord configRecord)
{
throw new NotImplementedException ();
}
public virtual bool IsInitDelayed(IInternalConfigRecord configRecord)
{
throw new NotImplementedException();
}
public object GetSection(string section, string configPath)
{
IInternalConfigRecord rec = GetConfigRecord(configPath);
return(rec.GetSection(section));
}
public void GetRestrictedPermissions(IInternalConfigRecord configRecord, out PermissionSet permissionSet, out bool isHostReady)
{
permissionSet = new PermissionSet(null);
isHostReady = true;
}
// Delay init if we have not been asked to complete init, and it is a user.config file.
public override bool IsInitDelayed(IInternalConfigRecord configRecord)
{
return !_initComplete && IsUserConfig(configRecord.ConfigPath);
}
// Default implementation: ensure that the caller has full trust.
bool IInternalConfigHost.IsFullTrustSectionWithoutAptcaAllowed(IInternalConfigRecord configRecord)
{
return(TypeUtil.IsCallerFullTrust);
}
public override void GetRestrictedPermissions(IInternalConfigRecord configRecord, out PermissionSet permissionSet, out bool isHostReady)
{
StaticGetRestrictedPermissions(configRecord, out permissionSet, out isHostReady);
}
// Get the nearest ancestor path (including self) which contains unique configuration information.
public string GetUniqueConfigPath(string configPath)
{
IInternalConfigRecord configRecord = GetUniqueConfigRecord(configPath);
return(configRecord?.ConfigPath);
}
public INConfiguration CreateConfigRecordConfiguration(IInternalConfigRecord configRecord, IList <string> fileNames)
{
return(new NConfigRecordConfiguration(configRecord, ConfigurationRepository, MergerRegistry, fileNames));
}
// security support
void IInternalConfigHost.GetRestrictedPermissions(IInternalConfigRecord configRecord, out PermissionSet permissionSet, out bool isHostReady)
{
permissionSet = null;
isHostReady = true;
}
private void OnConfigRemoved(object sender, InternalConfigEventArgs e)
{
try
{
IInternalConfigRecord configRecord = this._configRoot.GetConfigRecord(this._completeConfigRecord.ConfigPath);
this._completeConfigRecord = configRecord;
this._completeConfigRecord.ThrowIfInitErrors();
}
catch (Exception exception)
{
this._initError = new ConfigurationErrorsException(System.Configuration.SR.GetString("Config_client_config_init_error"), exception);
ConfigurationManager.SetInitError(this._initError);
throw this._initError;
}
}
public virtual bool IsFullTrustSectionWithoutAptcaAllowed(IInternalConfigRecord configRecord)
{
}
// Delay init if we have not been asked to complete init, and it is a user.config file.
public override bool IsInitDelayed(IInternalConfigRecord configRecord)
{
return(!_initComplete && IsUserConfig(configRecord.ConfigPath));
}
public virtual void GetRestrictedPermissions(IInternalConfigRecord configRecordout, System.Security.PermissionSet& permissionSetout, System.Boolean& isHostReady)
{
}
public virtual void GetRestrictedPermissions(IInternalConfigRecord configRecord, out PermissionSet permissionSet, out bool isHostReady)
{
throw new NotImplementedException();
}
// Methods
public virtual bool IsInitDelayed(IInternalConfigRecord configRecord)
{
}
//
// If config has been removed because initialization was not complete,
// fetch a new configuration record. The record will be created and
// completely initialized as RequireCompleteInit() will have been called
// on the ClientConfigurationHost before we receive this event.
//
private void OnConfigRemoved(object sender, InternalConfigEventArgs e) {
try {
IInternalConfigRecord newConfigRecord = _configRoot.GetConfigRecord(_completeConfigRecord.ConfigPath);
_completeConfigRecord = newConfigRecord;
_completeConfigRecord.ThrowIfInitErrors();
}
catch (Exception ex) {
_initError = new ConfigurationErrorsException(SR.GetString(SR.Config_client_config_init_error), ex);
ConfigurationManager.SetInitError(_initError);
throw _initError;
}
}
bool IInternalConfigHost.IsInitDelayed(IInternalConfigRecord configRecord)
{
throw new NotImplementedException();
}
public bool IsFullTrustSectionWithoutAptcaAllowed(IInternalConfigRecord configRecord) => true;
void IInternalConfigHost.RequireCompleteInit(IInternalConfigRecord configRecord)
{
throw new NotImplementedException();
}
public virtual void GetRestrictedPermissions (IInternalConfigRecord configRecord, out PermissionSet permissionSet, out bool isHostReady)
{
throw new NotImplementedException ();
}
// Default implementation: ensure that the caller has full trust.
bool IInternalConfigHost.IsFullTrustSectionWithoutAptcaAllowed(IInternalConfigRecord configRecord) {
return TypeUtil.IsCallerFullTrust;
}
// Methods
public virtual bool IsInitDelayed(IInternalConfigRecord configRecord) {}
// security support
void IInternalConfigHost.GetRestrictedPermissions(IInternalConfigRecord configRecord, out PermissionSet permissionSet, out bool isHostReady) {
permissionSet = null;
isHostReady = true;
}
public override bool IsFullTrustSectionWithoutAptcaAllowed(IInternalConfigRecord configRecord)
{
return(true);
}
bool IInternalConfigHost.IsInitDelayed(IInternalConfigRecord configRecord) {
return false;
}
public virtual void RequireCompleteInit(IInternalConfigRecord configRecord)
{
Host.RequireCompleteInit(configRecord);
}
void IInternalConfigHost.RequireCompleteInit(IInternalConfigRecord configRecord) {
}
internal RuntimeConfig(IInternalConfigRecord configRecord)
: this(configRecord, false)
{
}
public virtual bool IsFullTrustSectionWithoutAptcaAllowed(IInternalConfigRecord configRecord)
{
return(host.IsFullTrustSectionWithoutAptcaAllowed(configRecord));
}
private void EnsureInit(string configKey)
{
bool flag = false;
lock (this)
{
if (!this._isUserConfigInited)
{
if (!this._isInitInProgress)
{
this._isInitInProgress = true;
flag = true;
}
else if (!this.IsSectionUsedInInit(configKey))
{
Monitor.Wait(this);
}
}
}
if (flag)
{
try
{
try
{
string str;
this._machineConfigRecord = this._configRoot.GetConfigRecord("MACHINE");
this._machineConfigRecord.ThrowIfInitErrors();
this._isMachineConfigInited = true;
if (this._isAppConfigHttp)
{
ConfigurationManagerHelperFactory.Instance.EnsureNetConfigLoaded();
}
this._configHost.RefreshConfigPaths();
if (this._configHost.HasLocalConfig)
{
str = "MACHINE/EXE/ROAMING_USER/LOCAL_USER";
}
else if (this._configHost.HasRoamingConfig)
{
str = "MACHINE/EXE/ROAMING_USER";
}
else
{
str = "MACHINE/EXE";
}
this._completeConfigRecord = this._configRoot.GetConfigRecord(str);
this._completeConfigRecord.ThrowIfInitErrors();
this._isUserConfigInited = true;
}
catch (Exception exception)
{
this._initError = new ConfigurationErrorsException(System.Configuration.SR.GetString("Config_client_config_init_error"), exception);
throw this._initError;
}
}
catch
{
ConfigurationManager.SetInitError(this._initError);
this._isMachineConfigInited = true;
this._isUserConfigInited = true;
throw;
}
finally
{
lock (this)
{
try
{
ConfigurationManager.CompleteConfigInit();
this._isInitInProgress = false;
}
finally
{
Monitor.PulseAll(this);
}
}
}
}
}
public virtual void GetRestrictedPermissions(IInternalConfigRecord configRecord, out PermissionSet permissionSet, out bool isHostReady)
{
host.GetRestrictedPermissions(configRecord, out permissionSet, out isHostReady);
}
public override void RequireCompleteInit(IInternalConfigRecord record)
{
// Loading information about user.config files is expensive,
// so do it just once by locking.
lock (this)
{
if (!_initComplete)
{
// Note that all future requests for config must be complete.
_initComplete = true;
// Throw out the ConfigPath for this exe.
ClientConfigPaths.RefreshCurrent();
// Throw out our cached copy.
_configPaths = null;
// Force loading of user.config file information under lock.
ClientConfigPaths configPaths = ConfigPaths;
}
}
}
public NConfigRecordConfiguration(IInternalConfigRecord configRecord, IConfigurationRepository repository, INSectionMergerRegistry mergerRegistry, IList <string> fileNames) :
base(repository, mergerRegistry, fileNames)
{
this.configRecord = configRecord;
}
public virtual bool IsFullTrustSectionWithoutAptcaAllowed(IInternalConfigRecord configRecord)
{
throw new NotImplementedException();
}
internal static void StaticGetRestrictedPermissions(IInternalConfigRecord configRecord, out PermissionSet permissionSet, out bool isHostReady) {
isHostReady = HttpRuntime.IsTrustLevelInitialized;
permissionSet = null;
if (isHostReady && IsVirtualPathConfigPath(configRecord.ConfigPath)) {
permissionSet = HttpRuntime.NamedPermissionSet;
}
}
public virtual void RequireCompleteInit(IInternalConfigRecord configRecord)
{
throw new NotImplementedException();
}
public override bool IsFullTrustSectionWithoutAptcaAllowed(IInternalConfigRecord configRecord) {
if (HostingEnvironment.IsHosted) {
return HttpRuntime.HasAspNetHostingPermission(AspNetHostingPermissionLevel.Unrestricted);
}
else {
return Host.IsFullTrustSectionWithoutAptcaAllowed(configRecord);
}
}
public override void SubstituteSystemConfiguration(IConfigurationFactory factory, IList <string> fileNames)
{
if (OriginalConfiguration != null)
{
throw new InvalidOperationException("Web system default configuration already substituted.");
}
IInternalConfigSystem originalConfigSystem = SubstituteConfigurationSystem(factory, fileNames);
// Web Part (10 level black magic starts here)
var httpConfigurationSystem = new ReflectionAccessor(originalConfigSystem.GetType());
// Get original values.
var configSystem = httpConfigurationSystem.GetField <IConfigSystem>("s_configSystem");
var replacingSystem = new NConfigSystemReplacement(configSystem, factory, fileNames);
// Substitute to decorated instances.
httpConfigurationSystem.SetField("s_configSystem", replacingSystem);
httpConfigurationSystem.SetField("s_configRoot", replacingSystem.Root);
// Refill system cache with new decorated records.
var systemWebAss = httpConfigurationSystem.AccessedType.Assembly;
var hostingEnviroment = new ReflectionAccessor(systemWebAss.GetType("System.Web.Hosting.HostingEnvironment"));
string siteId = hostingEnviroment.GetProperty <string>("SiteID");
string configPath = "dmachine/webroot/" + siteId;
var httpRuntime = new ReflectionAccessor(systemWebAss.GetType("System.Web.HttpRuntime"));
var internalCache = new ReflectionAccessor(httpRuntime.GetProperty("CacheInternal"));
var caches = internalCache.GetField("_caches") as IEnumerable ?? Enumerable.Empty <object>();
// Get all site specific configuration records keys for internal cache.
var rootReplacement = replacingSystem.Root as NConfigRootReplacement;
foreach (var cache in caches)
{
// Caches stored in array ala hash, so there is could be gaps.
if (cache == null)
{
continue;
}
var cacheAcessor = new ReflectionAccessor(cache);
lock (cacheAcessor.GetField("_lock"))
{
var entries = cacheAcessor.GetField("_entries") as IEnumerable ?? Enumerable.Empty <object>();
// entries is HashTable, so just iterate through
foreach (DictionaryEntry entry in entries)
{
var keyAccessor = new ReflectionAccessor(entry.Key);
// Only configuration cache entries replaced.
if (!keyAccessor.GetProperty("Key").ToString().StartsWith(configPath))
{
continue;
}
// Key and Value is the same object in the configuration cache entry.
var entryValueAccesor = new ReflectionAccessor(keyAccessor.GetField("_value"));
var runtimeConfigAccessor = new ReflectionAccessor(entryValueAccesor.GetField("_runtimeConfig"));
IInternalConfigRecord replacingRecord = rootReplacement.CreateConfigRecord(runtimeConfigAccessor.GetField <IInternalConfigRecord>("_configRecord"));
runtimeConfigAccessor.SetField("_configRecord", replacingRecord);
runtimeConfigAccessor.SetField("_runtimeConfigLKG", null);
}
}
}
OriginalConfiguration = originalConfigSystem;
}
public override void GetRestrictedPermissions(IInternalConfigRecord configRecord, out PermissionSet permissionSet, out bool isHostReady) {
StaticGetRestrictedPermissions(configRecord, out permissionSet, out isHostReady);
}
internal RuntimeConfigLKG(IInternalConfigRecord configRecord) : base(configRecord, true)
{
}
void IInternalConfigHost.RequireCompleteInit(IInternalConfigRecord configRecord)
{
}
// Ensure that initialization has completed, while handling re-entrancy issues
// for certain sections that may be used during initialization itself.
void EnsureInit(string configKey) {
bool doInit = false;
lock (this) {
// If the user config is not initialized, then we must either:
// a. Perform the initialization ourselves if no other thread is doing it, or
// b. Wait for the initialization to complete if we know the section is not used during initialization itself, or
// c. Ignore initialization if the section can be used during initialization. Note that GetSection()
// returns null is initialization has not completed.
if (!_isUserConfigInited) {
if (!_isInitInProgress) {
_isInitInProgress = true;
doInit = true;
}
else if (!IsSectionUsedInInit(configKey)) {
// Wait for initialization to complete.
Monitor.Wait(this);
}
}
}
if (doInit) {
try {
try {
try {
// Initialize machine configuration.
_machineConfigRecord = _configRoot.GetConfigRecord(
ClientConfigurationHost.MachineConfigPath);
_machineConfigRecord.ThrowIfInitErrors();
// Make machine configuration available to system.net sections
// when application configuration is downloaded via http.
_isMachineConfigInited = true;
//
// Prevent deadlocks in the networking classes by loading
// networking config before making a networking request.
// Any requests for sections used in initialization during
// the call to EnsureConfigLoaded() will be served by
// _machine.config or will return null.
//
if (_isAppConfigHttp) {
ConfigurationManagerHelperFactory.Instance.EnsureNetConfigLoaded();
}
//
// Now load the rest of configuration
//
_configHost.RefreshConfigPaths();
string configPath;
if (_configHost.HasLocalConfig) {
configPath = ClientConfigurationHost.LocalUserConfigPath;
}
else if (_configHost.HasRoamingConfig) {
configPath = ClientConfigurationHost.RoamingUserConfigPath;
}
else {
configPath = ClientConfigurationHost.ExeConfigPath;
}
_completeConfigRecord = _configRoot.GetConfigRecord(configPath);
_completeConfigRecord.ThrowIfInitErrors();
_isUserConfigInited = true;
}
catch (Exception e) {
_initError = new ConfigurationErrorsException(SR.GetString(SR.Config_client_config_init_error), e);
throw _initError;
}
}
catch {
ConfigurationManager.SetInitError(_initError);
_isMachineConfigInited = true;
_isUserConfigInited = true;
throw;
}
}
finally {
lock (this) {
try {
// Notify ConfigurationSettings that initialization has fully completed,
// even if unsuccessful.
ConfigurationManager.CompleteConfigInit();
_isInitInProgress = false;
}
finally {
// Wake up all threads waiting for initialization to complete.
Monitor.PulseAll(this);
}
}
}
}
}
public virtual void GetRestrictedPermissions(IInternalConfigRecord configRecord, out PermissionSet permissionSet, out bool isHostReady) {
Host.GetRestrictedPermissions(configRecord, out permissionSet, out isHostReady);
}
bool IInternalConfigHost.IsInitDelayed(IInternalConfigRecord configRecord)
{
return(false);
}
public virtual bool IsInitDelayed(IInternalConfigRecord configRecord) {
return Host.IsInitDelayed(configRecord);
}
public virtual bool IsFullTrustSectionWithoutAptcaAllowed (IInternalConfigRecord configRecord)
{
throw new NotImplementedException ();
}
//
// Note that if configRecord is null, we are the LKG for the ClientRuntimeConfig.
//
internal RuntimeConfigLKG(IInternalConfigRecord configRecord) : base(configRecord, true) {}
public virtual void RequireCompleteInit (IInternalConfigRecord configRecord)
{
throw new NotImplementedException ();
}
public virtual bool IsFullTrustSectionWithoutAptcaAllowed(IInternalConfigRecord configRecord) {}
public NConfigRecordReplacement(IInternalConfigRecord originalRecord, INConfiguration configuration)
{
this.originalRecord = originalRecord;
this.configuration = configuration;
}
public virtual void GetRestrictedPermissions(IInternalConfigRecord configRecordout , System.Security.PermissionSet& permissionSetout , System.Boolean& isHostReady) {}