// parentConfig contains the config that we'd merge with. override protected object CreateSection(bool inputIsTrusted, FactoryRecord factoryRecord, SectionRecord sectionRecord, object parentConfig, ConfigXmlReader reader) { // Get the factory used to create a section. RuntimeConfigurationFactory factory = (RuntimeConfigurationFactory) factoryRecord.Factory; // Use the factory to create a section. object config = factory.CreateSection(inputIsTrusted, this, factoryRecord, sectionRecord, parentConfig, reader); return config; }
// // Add a section definition update to the correct location update. // internal DefinitionUpdate AddUpdate(OverrideModeSetting overrideMode, bool inheritInChildApps, bool moved, string updatedXml, SectionRecord sectionRecord) { LocationUpdates locationUpdates = FindLocationUpdates(overrideMode, inheritInChildApps); if (locationUpdates == null) { locationUpdates = new LocationUpdates(overrideMode, inheritInChildApps); _locationUpdatesList.Add(locationUpdates); } DefinitionUpdate definitionUpdate = new DefinitionUpdate(sectionRecord.ConfigKey, moved, updatedXml, sectionRecord); locationUpdates.SectionUpdates.AddSection(definitionUpdate); return definitionUpdate; }
// Add a section definition update to the correct location update. internal DefinitionUpdate AddUpdate(OverrideModeSetting overrideMode, bool inheritInChildApps, bool moved, string updatedXml, SectionRecord sectionRecord) { LocationUpdates locationUpdates = FindLocationUpdates(overrideMode, inheritInChildApps); if (locationUpdates == null) { locationUpdates = new LocationUpdates(overrideMode, inheritInChildApps); LocationUpdatesList.Add(locationUpdates); } DefinitionUpdate definitionUpdate = new DefinitionUpdate(sectionRecord.ConfigKey, moved, updatedXml, sectionRecord); locationUpdates.SectionUpdates.AddSection(definitionUpdate); return(definitionUpdate); }
internal void SetRuntimeConfigurationInformation(BaseConfigurationRecord configRecord, FactoryRecord factoryRecord, SectionRecord sectionRecord) { _flags[ Flag_Attached ] = true; // factory info _configKey = factoryRecord.ConfigKey; _group = factoryRecord.Group; _name = factoryRecord.Name; _typeName = factoryRecord.FactoryTypeName; _allowDefinition = factoryRecord.AllowDefinition; _allowExeDefinition = factoryRecord.AllowExeDefinition; _flags[ Flag_AllowLocation ] = factoryRecord.AllowLocation; _flags[ Flag_RestartOnExternalChanges ] = factoryRecord.RestartOnExternalChanges; _flags[ Flag_RequirePermission ] = factoryRecord.RequirePermission; if (factoryRecord.IsUndeclared) { _flags[ Flag_IsUndeclared ] = true; _flags[ Flag_Declared ] = false; _flags[ Flag_DeclarationRequired ] = false; } else { _flags[ Flag_IsUndeclared ] = false; _flags[ Flag_Declared ] = configRecord.GetFactoryRecord(factoryRecord.ConfigKey, false) != null; _flags[ Flag_DeclarationRequired ] = configRecord.IsRootDeclaration(factoryRecord.ConfigKey, false); } // section info _flags[ Flag_LocationLocked ] = sectionRecord.Locked; if (sectionRecord.HasFileInput) { SectionInput fileInput = sectionRecord.FileInput; _flags[ Flag_ProtectionProviderDetermined ] = fileInput.IsProtectionProviderDetermined; _protectionProvider = fileInput.ProtectionProvider; SectionXmlInfo sectionXmlInfo = fileInput.SectionXmlInfo; _configSource = sectionXmlInfo.ConfigSource; _configSourceStreamName = sectionXmlInfo.ConfigSourceStreamName; _flags[ Flag_AllowOverride ] = !sectionXmlInfo.LockChildren; _flags[ Flag_InheritInChildApps ] = !sectionXmlInfo.SkipInChildApps; _protectionProviderName = sectionXmlInfo.ProtectionProviderName; } else { _flags[ Flag_ProtectionProviderDetermined ] = false; _protectionProvider = null; } // element context information _configurationSection.AssociateContext( configRecord ); }
// parentConfig contains the config that we'd merge with. override protected object CreateSection(bool inputIsTrusted, FactoryRecord factoryRecord, SectionRecord sectionRecord, object parentConfig, ConfigXmlReader reader) { // Get the factory used to create a section. RuntimeConfigurationFactory factory = (RuntimeConfigurationFactory)factoryRecord.Factory; // Use the factory to create a section. object config = factory.CreateSection(inputIsTrusted, this, factoryRecord, sectionRecord, parentConfig, reader); return(config); }
// for instantiation of a ConfigurationSection from GetConfig internal void AttachToConfigurationRecord(MgmtConfigurationRecord configRecord, FactoryRecord factoryRecord, SectionRecord sectionRecord) { SetRuntimeConfigurationInformation(configRecord, factoryRecord, sectionRecord); _configRecord = configRecord; }
// // Create a new ConfigurationSection with the same values as the parent. // We must use a different instance than the parent, as the parent is cached // by the config system and the child ConfigurationSection may change due to // user interaction. // override protected object UseParentResult(string configKey, object parentResult, SectionRecord sectionRecord) { FactoryRecord factoryRecord = FindFactoryRecord(configKey, false); if (factoryRecord == null) { throw new ConfigurationErrorsException(SR.GetString(SR.Config_unrecognized_configuration_section, configKey)); } object result = CallCreateSection(false, factoryRecord, sectionRecord, parentResult, null, null, -1); return result; }
private object CreateSectionWithFullTrust( RuntimeConfigurationRecord configRecord, FactoryRecord factoryRecord, SectionRecord sectionRecord, object parentConfig, ConfigXmlReader reader) { return(CreateSectionImpl(configRecord, factoryRecord, sectionRecord, parentConfig, reader)); }
private bool IsConfigSectionMoved(SectionRecord sectionRecord, ConfigurationSection configSection) { return (!sectionRecord.HasFileInput || this.AreLocationAttributesModified(sectionRecord, configSection)); }
private bool AreSectionAttributesModified(SectionRecord sectionRecord, ConfigurationSection configSection) { string configSource; string protectionProviderName; if (sectionRecord.HasFileInput) { SectionXmlInfo sectionXmlInfo = sectionRecord.FileInput.SectionXmlInfo; configSource = sectionXmlInfo.ConfigSource; protectionProviderName = sectionXmlInfo.ProtectionProviderName; } else { configSource = null; protectionProviderName = null; } return !StringUtil.EqualsNE(configSource, configSection.SectionInformation.ConfigSource) || !StringUtil.EqualsNE(protectionProviderName, configSection.SectionInformation.ProtectionProviderName) || AreLocationAttributesModified(sectionRecord, configSection); }
private object CreateSectionImpl( RuntimeConfigurationRecord configRecord, FactoryRecord factoryRecord, SectionRecord sectionRecord, object parentConfig, ConfigXmlReader reader) { object config; if (_sectionCtor != null) { ConfigurationSection configSection = (ConfigurationSection) TypeUtil.InvokeCtorWithReflectionPermission(_sectionCtor); configSection.SectionInformation.SetRuntimeConfigurationInformation(configRecord, factoryRecord, sectionRecord); configSection.CallInit(); ConfigurationSection parentSection = (ConfigurationSection) parentConfig; configSection.Reset(parentSection); if (reader != null) { configSection.DeserializeSection(reader); } // throw if there are any cached errors ConfigurationErrorsException errors = configSection.GetErrors(); if (errors != null) { throw errors; } // don't allow changes to sections at runtime configSection.SetReadOnly(); // reset the modified bit configSection.ResetModified(); config = configSection; } else { if (reader != null) { XmlNode xmlNode = ErrorInfoXmlDocument.CreateSectionXmlNode(reader); CheckForLockAttributes(factoryRecord.ConfigKey, xmlNode); // In v1, our old section handler expects a context that contains the virtualPath from the configPath object configContext = configRecord.Host.CreateDeprecatedConfigContext(configRecord.ConfigPath); config = _sectionHandler.Create(parentConfig, configContext, xmlNode); } else { config = null; } } return config; }
protected override object UseParentResult(string configKey, object parentResult, SectionRecord sectionRecord) { FactoryRecord factoryRecord = base.FindFactoryRecord(configKey, false); if (factoryRecord == null) { throw new ConfigurationErrorsException(System.Configuration.SR.GetString("Config_unrecognized_configuration_section", new object[] { configKey })); } return base.CallCreateSection(false, factoryRecord, sectionRecord, parentResult, null, null, -1); }
protected override object CreateSection(bool inputIsTrusted, FactoryRecord factoryRecord, SectionRecord sectionRecord, object parentConfig, ConfigXmlReader reader) { RuntimeConfigurationFactory factory = (RuntimeConfigurationFactory)factoryRecord.Factory; return(factory.CreateSection(inputIsTrusted, this, factoryRecord, sectionRecord, parentConfig, reader)); }
private object CreateSectionWithRestrictedPermissions(RuntimeConfigurationRecord configRecord, FactoryRecord factoryRecord, SectionRecord sectionRecord, object parentConfig, ConfigXmlReader reader) { object obj2; bool flag = false; try { PermissionSet restrictedPermissions = configRecord.GetRestrictedPermissions(); if (restrictedPermissions != null) { restrictedPermissions.PermitOnly(); flag = true; } obj2 = this.CreateSectionImpl(configRecord, factoryRecord, sectionRecord, parentConfig, reader); } finally { if (flag) { CodeAccessPermission.RevertPermitOnly(); } } return(obj2); }
private object CreateSectionImpl(RuntimeConfigurationRecord configRecord, FactoryRecord factoryRecord, SectionRecord sectionRecord, object parentConfig, ConfigXmlReader reader) { if (this._sectionCtor != null) { ConfigurationSection section = (ConfigurationSection)System.Configuration.TypeUtil.InvokeCtorWithReflectionPermission(this._sectionCtor); section.SectionInformation.SetRuntimeConfigurationInformation(configRecord, factoryRecord, sectionRecord); section.CallInit(); ConfigurationSection parentElement = (ConfigurationSection)parentConfig; section.Reset(parentElement); if (reader != null) { section.DeserializeSection(reader); } ConfigurationErrorsException errors = section.GetErrors(); if (errors != null) { throw errors; } section.SetReadOnly(); section.ResetModified(); return(section); } if (reader != null) { XmlNode xmlNode = ErrorInfoXmlDocument.CreateSectionXmlNode(reader); CheckForLockAttributes(factoryRecord.ConfigKey, xmlNode); object configContext = configRecord.Host.CreateDeprecatedConfigContext(configRecord.ConfigPath); return(this._sectionHandler.Create(parentConfig, configContext, xmlNode)); } return(null); }
internal object CreateSection(bool inputIsTrusted, RuntimeConfigurationRecord configRecord, FactoryRecord factoryRecord, SectionRecord sectionRecord, object parentConfig, ConfigXmlReader reader) { if (inputIsTrusted) { return(this.CreateSectionWithFullTrust(configRecord, factoryRecord, sectionRecord, parentConfig, reader)); } return(this.CreateSectionWithRestrictedPermissions(configRecord, factoryRecord, sectionRecord, parentConfig, reader)); }
protected override object CreateSection(bool inputIsTrusted, FactoryRecord factoryRecord, SectionRecord sectionRecord, object parentConfig, ConfigXmlReader reader) { ConstructorInfo factory = (ConstructorInfo) factoryRecord.Factory; ConfigurationSection section = (ConfigurationSection) System.Configuration.TypeUtil.InvokeCtorWithReflectionPermission(factory); section.SectionInformation.AttachToConfigurationRecord(this, factoryRecord, sectionRecord); section.CallInit(); ConfigurationSection parentElement = (ConfigurationSection) parentConfig; section.Reset(parentElement); if (reader != null) { section.DeserializeSection(reader); } section.ResetModified(); return section; }
private object CreateSectionWithRestrictedPermissions( RuntimeConfigurationRecord configRecord, FactoryRecord factoryRecord, SectionRecord sectionRecord, object parentConfig, ConfigXmlReader reader) { // run configuration section handlers as if user code was on the stack bool revertPermitOnly = false; try { PermissionSet permissionSet = configRecord.GetRestrictedPermissions(); if (permissionSet != null) { permissionSet.PermitOnly(); revertPermitOnly = true; } return CreateSectionImpl(configRecord, factoryRecord, sectionRecord, parentConfig, reader); } finally { if (revertPermitOnly) { CodeAccessPermission.RevertPermitOnly(); } } }
internal void SetRuntimeConfigurationInformation(BaseConfigurationRecord configRecord, FactoryRecord factoryRecord, SectionRecord sectionRecord) { this._flags[1] = true; this._configKey = factoryRecord.ConfigKey; this._group = factoryRecord.Group; this._name = factoryRecord.Name; this._typeName = factoryRecord.FactoryTypeName; this._allowDefinition = factoryRecord.AllowDefinition; this._allowExeDefinition = factoryRecord.AllowExeDefinition; this._flags[8] = factoryRecord.AllowLocation; this._flags[0x10] = factoryRecord.RestartOnExternalChanges; this._flags[0x20] = factoryRecord.RequirePermission; this._overrideModeDefault = factoryRecord.OverrideModeDefault; if (factoryRecord.IsUndeclared) { this._flags[0x2000] = true; this._flags[2] = false; this._flags[4] = false; } else { this._flags[0x2000] = false; this._flags[2] = configRecord.GetFactoryRecord(factoryRecord.ConfigKey, false) != null; this._flags[4] = configRecord.IsRootDeclaration(factoryRecord.ConfigKey, false); } this._flags[0x40] = sectionRecord.Locked; this._flags[0x80] = sectionRecord.LockChildren; this._flags[0x4000] = sectionRecord.LockChildrenWithoutFileInput; if (sectionRecord.HasFileInput) { SectionInput fileInput = sectionRecord.FileInput; this._flags[0x800] = fileInput.IsProtectionProviderDetermined; this._protectionProvider = fileInput.ProtectionProvider; SectionXmlInfo sectionXmlInfo = fileInput.SectionXmlInfo; this._configSource = sectionXmlInfo.ConfigSource; this._configSourceStreamName = sectionXmlInfo.ConfigSourceStreamName; this._overrideMode = sectionXmlInfo.OverrideModeSetting; this._flags[0x100] = !sectionXmlInfo.SkipInChildApps; this._protectionProviderName = sectionXmlInfo.ProtectionProviderName; } else { this._flags[0x800] = false; this._protectionProvider = null; } this._configurationSection.AssociateContext(configRecord); }
private object CreateSectionImpl(RuntimeConfigurationRecord configRecord, FactoryRecord factoryRecord, SectionRecord sectionRecord, object parentConfig, ConfigXmlReader reader) { if (this._sectionCtor != null) { ConfigurationSection section = (ConfigurationSection) System.Configuration.TypeUtil.InvokeCtorWithReflectionPermission(this._sectionCtor); section.SectionInformation.SetRuntimeConfigurationInformation(configRecord, factoryRecord, sectionRecord); section.CallInit(); ConfigurationSection parentElement = (ConfigurationSection) parentConfig; section.Reset(parentElement); if (reader != null) { section.DeserializeSection(reader); } ConfigurationErrorsException errors = section.GetErrors(); if (errors != null) { throw errors; } section.SetReadOnly(); section.ResetModified(); return section; } if (reader != null) { XmlNode xmlNode = ErrorInfoXmlDocument.CreateSectionXmlNode(reader); CheckForLockAttributes(factoryRecord.ConfigKey, xmlNode); object configContext = configRecord.Host.CreateDeprecatedConfigContext(configRecord.ConfigPath); return this._sectionHandler.Create(parentConfig, configContext, xmlNode); } return null; }
private bool AreLocationAttributesModified(SectionRecord sectionRecord, ConfigurationSection configSection) { OverrideModeSetting overrideMode = OverrideModeSetting.LocationDefault; bool inheritInChildApplications = true; if (sectionRecord.HasFileInput) { SectionXmlInfo sectionXmlInfo = sectionRecord.FileInput.SectionXmlInfo; overrideMode = sectionXmlInfo.OverrideModeSetting; inheritInChildApplications = !sectionXmlInfo.SkipInChildApps; } // We will use IsSameForLocation tag so that we flag modes that cant go into the same location tag // as different. If we don't do that it will appear like the mode was not changed which will // case conflict later when determining if the section is moved ( when writing the new config updates ) return (!OverrideModeSetting.CanUseSameLocationTag(overrideMode, configSection.SectionInformation.OverrideModeSetting)) || (inheritInChildApplications != configSection.SectionInformation.InheritInChildApplications); }
private object CreateSectionWithRestrictedPermissions(RuntimeConfigurationRecord configRecord, FactoryRecord factoryRecord, SectionRecord sectionRecord, object parentConfig, ConfigXmlReader reader) { object obj2; bool flag = false; try { PermissionSet restrictedPermissions = configRecord.GetRestrictedPermissions(); if (restrictedPermissions != null) { restrictedPermissions.PermitOnly(); flag = true; } obj2 = this.CreateSectionImpl(configRecord, factoryRecord, sectionRecord, parentConfig, reader); } finally { if (flag) { CodeAccessPermission.RevertPermitOnly(); } } return obj2; }
private bool IsConfigSectionMoved(SectionRecord sectionRecord, ConfigurationSection configSection) { if (!sectionRecord.HasFileInput) return true; return AreLocationAttributesModified(sectionRecord, configSection); }
protected override object CreateSection(bool inputIsTrusted, FactoryRecord factoryRecord, SectionRecord sectionRecord, object parentConfig, ConfigXmlReader reader) { RuntimeConfigurationFactory factory = (RuntimeConfigurationFactory) factoryRecord.Factory; return factory.CreateSection(inputIsTrusted, this, factoryRecord, sectionRecord, parentConfig, reader); }
private object CreateSectionImpl( RuntimeConfigurationRecord configRecord, FactoryRecord factoryRecord, SectionRecord sectionRecord, object parentConfig, ConfigXmlReader reader) { object config; if (_sectionCtor != null) { ConfigurationSection configSection = (ConfigurationSection)TypeUtil.InvokeCtorWithReflectionPermission(_sectionCtor); configSection.SectionInformation.SetRuntimeConfigurationInformation(configRecord, factoryRecord, sectionRecord); configSection.CallInit(); ConfigurationSection parentSection = (ConfigurationSection)parentConfig; configSection.Reset(parentSection); if (reader != null) { configSection.DeserializeSection(reader); } // throw if there are any cached errors ConfigurationErrorsException errors = configSection.GetErrors(); if (errors != null) { throw errors; } // don't allow changes to sections at runtime configSection.SetReadOnly(); // reset the modified bit configSection.ResetModified(); config = configSection; } else { if (reader != null) { XmlNode xmlNode = ErrorInfoXmlDocument.CreateSectionXmlNode(reader); CheckForLockAttributes(factoryRecord.ConfigKey, xmlNode); // In v1, our old section handler expects a context that contains the virtualPath from the configPath object configContext = configRecord.Host.CreateDeprecatedConfigContext(configRecord.ConfigPath); config = _sectionHandler.Create(parentConfig, configContext, xmlNode); } else { config = null; } } return(config); }
protected void CreateSectionDefault( string configKey, bool getRuntimeObject, FactoryRecord factoryRecord, SectionRecord sectionRecord, out object result, out object resultRuntimeObject) { result = null; resultRuntimeObject = null; SectionRecord sectionRecordForDefault; if (sectionRecord != null) { sectionRecordForDefault = sectionRecord; } else { sectionRecordForDefault = new SectionRecord(configKey); } object tmpResult = CallCreateSection(true, factoryRecord, sectionRecordForDefault, null, null, null, -1); object tmpResultRuntimeObject; if (getRuntimeObject) { tmpResultRuntimeObject = GetRuntimeObject(tmpResult); } else { tmpResultRuntimeObject = null; } result = tmpResult; resultRuntimeObject = tmpResultRuntimeObject; }
private object CreateSectionWithRestrictedPermissions( RuntimeConfigurationRecord configRecord, FactoryRecord factoryRecord, SectionRecord sectionRecord, object parentConfig, ConfigXmlReader reader) { // run configuration section handlers as if user code was on the stack bool revertPermitOnly = false; try { PermissionSet permissionSet = configRecord.GetRestrictedPermissions(); if (permissionSet != null) { permissionSet.PermitOnly(); revertPermitOnly = true; } return(CreateSectionImpl(configRecord, factoryRecord, sectionRecord, parentConfig, reader)); } finally { if (revertPermitOnly) { CodeAccessPermission.RevertPermitOnly(); } } }
// // Evaluate the input. // // If Evaluate() encounters an error, it may not throw an exception // when getLkg == true. // // The complete success of the evaluation is determined by the return value. // private bool Evaluate( FactoryRecord factoryRecord, SectionRecord sectionRecord, object parentResult, bool getLkg, bool getRuntimeObject, out object result, out object resultRuntimeObject) { result = null; resultRuntimeObject = null; // // Store results in temporary variables, because we don't want to return // results if an exception is thrown. // object tmpResult = null; object tmpResultRuntimeObject = null; // Factory record should be error-free. Debug.Assert(!factoryRecord.HasErrors, "!factoryRecord.HasErrors"); // We should have some input Debug.Assert(sectionRecord.HasInput, "sectionRecord.HasInput"); // // Grab inputs before checking result, // as inputs may be cleared once the result is set. // List<SectionInput> locationInputs = sectionRecord.LocationInputs; SectionInput fileInput = sectionRecord.FileInput; // // Now that we have our inputs, lets check if there // is a result, because if there is, our inputs might // have been invalidated. // bool success = false; if (sectionRecord.HasResult) { // Results should never be stored if the section has errors. Debug.Assert(!sectionRecord.HasErrors, "!sectionRecord.HasErrors"); // Create the runtime object if requested and it does not yet exist. if (getRuntimeObject && !sectionRecord.HasResultRuntimeObject) { try { sectionRecord.ResultRuntimeObject = GetRuntimeObject(sectionRecord.Result); } catch { // // Ignore the error if we are attempting to retreive // the last known good configuration. // if (!getLkg) { throw; } } } // Get the cached result. if (!getRuntimeObject || sectionRecord.HasResultRuntimeObject) { tmpResult = sectionRecord.Result; if (getRuntimeObject) { tmpResultRuntimeObject = sectionRecord.ResultRuntimeObject; } success = true; } } if (!success) { Exception savedException = null; try { string configKey = factoryRecord.ConfigKey; string [] keys = configKey.Split(ConfigPathSeparatorParams); object currentResult = parentResult; // // Evaluate location inputs // if (locationInputs != null) { foreach (SectionInput locationInput in locationInputs) { if (!locationInput.HasResult) { locationInput.ThrowOnErrors(); bool isTrusted = Host.IsTrustedConfigPath(locationInput.SectionXmlInfo.DefinitionConfigPath); locationInput.Result = EvaluateOne(keys, locationInput, isTrusted, factoryRecord, sectionRecord, currentResult); } currentResult = locationInput.Result; } } // // Evaluate file input // if (fileInput != null) { if (!fileInput.HasResult) { fileInput.ThrowOnErrors(); bool isTrusted = _flags[IsTrusted]; fileInput.Result = EvaluateOne(keys, fileInput, isTrusted, factoryRecord, sectionRecord, currentResult); } currentResult = fileInput.Result; } else { // // The section needs its own copy of the result that is distinct // from its location parent result. // Debug.Assert(locationInputs != null, "locationInputs != null"); currentResult = UseParentResult(configKey, currentResult, sectionRecord); } if (getRuntimeObject) { tmpResultRuntimeObject = GetRuntimeObject(currentResult); } tmpResult = currentResult; success = true; } catch (Exception e) { // // Catch the exception if LKG is requested and we have // location input to fall back on. // if (getLkg && locationInputs != null) { savedException = e; } else { throw; } } // // If getLkg, then return a result from the last valid location input. // if (!success) { Debug.Assert(getLkg == true, "getLkg == true"); int i = locationInputs.Count; while (--i >= 0) { SectionInput locationInput = locationInputs[i]; if (locationInput.HasResult) { if (getRuntimeObject && !locationInput.HasResultRuntimeObject) { try { locationInput.ResultRuntimeObject = GetRuntimeObject(locationInput.Result); } catch { } } if (!getRuntimeObject || locationInput.HasResultRuntimeObject) { tmpResult = locationInput.Result; if (getRuntimeObject) { tmpResultRuntimeObject = locationInput.ResultRuntimeObject; } break; } } } if (i < 0) { throw savedException; } } } // // If evaluation was successful, we can remove any saved rawXml. // if (success && !_flags[SupportsKeepInputs]) { sectionRecord.ClearRawXml(); } result = tmpResult; if (getRuntimeObject) { resultRuntimeObject = tmpResultRuntimeObject; } return success; }
protected override object UseParentResult(string configKey, object parentResult, SectionRecord sectionRecord) { return(parentResult); }
private object EvaluateOne( string[] keys, SectionInput input, bool isTrusted, FactoryRecord factoryRecord, SectionRecord sectionRecord, object parentResult) { object result; try { ConfigXmlReader reader = GetSectionXmlReader(keys, input); if (reader == null) { // // If section is not found in a file, use the parent result // result = UseParentResult(factoryRecord.ConfigKey, parentResult, sectionRecord); } else { result = CallCreateSection( isTrusted, factoryRecord, sectionRecord, parentResult, reader, input.SectionXmlInfo.Filename, input.SectionXmlInfo.LineNumber); } } catch (Exception e) { throw ExceptionUtil.WrapAsConfigException( SR.GetString(SR.Config_exception_creating_section, factoryRecord.ConfigKey), e, input.SectionXmlInfo); } catch { throw ExceptionUtil.WrapAsConfigException( SR.GetString(SR.Config_exception_creating_section, factoryRecord.ConfigKey), null, input.SectionXmlInfo); } return result; }
internal void SetRuntimeConfigurationInformation(BaseConfigurationRecord configRecord, FactoryRecord factoryRecord, SectionRecord sectionRecord) { _flags[FlagAttached] = true; // factory info ConfigKey = factoryRecord.ConfigKey; Name = factoryRecord.Name; _typeName = factoryRecord.FactoryTypeName; _allowDefinition = factoryRecord.AllowDefinition; _allowExeDefinition = factoryRecord.AllowExeDefinition; _flags[FlagAllowLocation] = factoryRecord.AllowLocation; _flags[FlagRestartOnExternalChanges] = factoryRecord.RestartOnExternalChanges; _flags[FlagRequirePermission] = factoryRecord.RequirePermission; _overrideModeDefault = factoryRecord.OverrideModeDefault; if (factoryRecord.IsUndeclared) { _flags[FlagIsUndeclared] = true; _flags[FlagDeclared] = false; _flags[FlagDeclarationRequired] = false; } else { _flags[FlagIsUndeclared] = false; _flags[FlagDeclared] = configRecord.GetFactoryRecord(factoryRecord.ConfigKey, false) != null; _flags[FlagDeclarationRequired] = configRecord.IsRootDeclaration(factoryRecord.ConfigKey, false); } // section info _flags[FlagLocationLocked] = sectionRecord.Locked; _flags[FlagChildrenLocked] = sectionRecord.LockChildren; _flags[FlagChildrenLockWithoutFileInput] = sectionRecord.LockChildrenWithoutFileInput; if (sectionRecord.HasFileInput) { SectionInput fileInput = sectionRecord.FileInput; _flags[FlagProtectionProviderDetermined] = fileInput.IsProtectionProviderDetermined; _protectionProvider = fileInput.ProtectionProvider; SectionXmlInfo sectionXmlInfo = fileInput.SectionXmlInfo; _configSource = sectionXmlInfo.ConfigSource; ConfigSourceStreamName = sectionXmlInfo.ConfigSourceStreamName; _overrideMode = sectionXmlInfo.OverrideModeSetting; _flags[FlagInheritInChildApps] = !sectionXmlInfo.SkipInChildApps; ProtectionProviderName = sectionXmlInfo.ProtectionProviderName; } else { _flags[FlagProtectionProviderDetermined] = false; _protectionProvider = null; } // element context information _configurationSection.AssociateContext(configRecord); }
// Create the configuration object protected abstract object CreateSection(bool inputIsTrusted, FactoryRecord factoryRecord, SectionRecord sectionRecord, object parentConfig, ConfigXmlReader reader);
// Use the parent result in creating the child protected abstract object UseParentResult(string configKey, object parentResult, SectionRecord sectionRecord);
protected object CallCreateSection(bool inputIsTrusted, FactoryRecord factoryRecord, SectionRecord sectionRecord, object parentConfig, ConfigXmlReader reader, string filename, int line) { object config; // Call into config section while impersonating process or UNC identity // so that the section could read files from disk if needed try { using (Impersonate()) { config = CreateSection(inputIsTrusted, factoryRecord, sectionRecord, parentConfig, reader); if (config == null && parentConfig != null) { throw new ConfigurationErrorsException(SR.GetString(SR.Config_object_is_null), filename, line); } } } catch (Exception e) { throw ExceptionUtil.WrapAsConfigException(SR.GetString(SR.Config_exception_creating_section_handler, factoryRecord.ConfigKey), e, filename, line); } catch { throw ExceptionUtil.WrapAsConfigException(SR.GetString(SR.Config_exception_creating_section_handler, factoryRecord.ConfigKey), null, filename, line); } return config; }
private object CreateSectionWithFullTrust( RuntimeConfigurationRecord configRecord, FactoryRecord factoryRecord, SectionRecord sectionRecord, object parentConfig, ConfigXmlReader reader) { return CreateSectionImpl(configRecord, factoryRecord, sectionRecord, parentConfig, reader); }
// Return an existing SectionRecord, or create one if one does not exist. // If desired, set the locked bit if locked by a parent. private SectionRecord EnsureSectionRecordImpl(string configKey, bool permitErrors, bool checkIfLocked) { SectionRecord sectionRecord = GetSectionRecord(configKey, permitErrors); if (sectionRecord == null) { bool sectionAdded = false; lock (this) { if (_sectionRecords == null) { _sectionRecords = new Hashtable(); } else { sectionRecord = GetSectionRecord(configKey, permitErrors); } if (sectionRecord == null) { sectionRecord = new SectionRecord(configKey); _sectionRecords.Add(configKey, sectionRecord); sectionAdded = true; } } if (checkIfLocked && sectionAdded) { sectionRecord.Locked = IsParentCausingLock(configKey); } } return sectionRecord; }
internal object CreateSection(bool inputIsTrusted, RuntimeConfigurationRecord configRecord, FactoryRecord factoryRecord, SectionRecord sectionRecord, object parentConfig, ConfigXmlReader reader) { if (inputIsTrusted) { return CreateSectionWithFullTrust(configRecord, factoryRecord, sectionRecord, parentConfig, reader); } else { return CreateSectionWithRestrictedPermissions(configRecord, factoryRecord, sectionRecord, parentConfig, reader); } }
private object CreateSectionWithRestrictedPermissions( RuntimeConfigurationRecord configRecord, FactoryRecord factoryRecord, SectionRecord sectionRecord, object parentConfig, ConfigXmlReader reader) { return CreateSectionImpl(configRecord, factoryRecord, sectionRecord, parentConfig, reader); }
override protected object UseParentResult(string configKey, object parentResult, SectionRecord sectionRecord) { return parentResult; }
// // Create the ConfigurationSection. // override protected object CreateSection(bool inputIsTrusted, FactoryRecord factoryRecord, SectionRecord sectionRecord, object parentConfig, ConfigXmlReader reader) { // Create an instance of the ConfigurationSection ConstructorInfo ctor = (ConstructorInfo) factoryRecord.Factory; ConfigurationSection configSection = (ConfigurationSection) TypeUtil.InvokeCtorWithReflectionPermission(ctor); // Attach the ConfigurationSection to this record configSection.SectionInformation.AttachToConfigurationRecord(this, factoryRecord, sectionRecord); configSection.CallInit(); // Initialize the ConfigurationSection with XML or just its parent. ConfigurationSection parentConfigSection = (ConfigurationSection) parentConfig; configSection.Reset(parentConfigSection); if (reader != null) { configSection.DeserializeSection(reader); } // Clear the modified bit. configSection.ResetModified(); return configSection; }
internal void AttachToConfigurationRecord(MgmtConfigurationRecord configRecord, FactoryRecord factoryRecord, SectionRecord sectionRecord) { this.SetRuntimeConfigurationInformation(configRecord, factoryRecord, sectionRecord); this._configRecord = configRecord; }
private bool AreLocationAttributesModified(SectionRecord sectionRecord, ConfigurationSection configSection) { OverrideModeSetting locationDefault = OverrideModeSetting.LocationDefault; bool flag = true; if (sectionRecord.HasFileInput) { SectionXmlInfo sectionXmlInfo = sectionRecord.FileInput.SectionXmlInfo; locationDefault = sectionXmlInfo.OverrideModeSetting; flag = !sectionXmlInfo.SkipInChildApps; } if (OverrideModeSetting.CanUseSameLocationTag(locationDefault, configSection.SectionInformation.OverrideModeSetting)) { return (flag != configSection.SectionInformation.InheritInChildApplications); } return true; }