private void Init(RuntimeConfigurationRecord configRecord, FactoryRecord factoryRecord)
{
// Get the type of the factory
Type type = TypeUtil.GetType(configRecord.Host, factoryRecord.FactoryTypeName,
true);
// If the type is a ConfigurationSection, that's the type.
if (typeof(ConfigurationSection).IsAssignableFrom(type))
{
_sectionCtor = TypeUtil.GetConstructor(type, typeof(ConfigurationSection),
true);
}
else
{
// Note: in v1, IConfigurationSectionHandler is in effect a factory that has a Create method
// that creates the real section object.
// throws if type does not implement IConfigurationSectionHandler
TypeUtil.VerifyAssignableType(typeof(IConfigurationSectionHandler), type, true);
// Create an instance of the handler
_sectionHandler =
(IConfigurationSectionHandler)TypeUtil.CreateInstance(type);
}
}
internal object CreateSection(bool inputIsTrusted, RuntimeConfigurationRecord configRecord,
FactoryRecord factoryRecord, SectionRecord sectionRecord, object parentConfig, ConfigXmlReader reader)
{
object config;
if (_sectionCtor != null)
{
ConfigurationSection configSection =
(ConfigurationSection)_sectionCtor.Invoke(null);
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);
}
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);
}
// 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;
}
// 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);
}
private FactoryRecord FindParentFactoryRecord(bool permitErrors)
{
FactoryRecord record = null;
if ((this._configRecord != null) && !this._configRecord.Parent.IsRootConfig)
{
record = this._configRecord.Parent.FindFactoryRecord(this._configKey, permitErrors);
}
return(record);
}
private FactoryRecord FindParentFactoryRecord(bool permitErrors)
{
FactoryRecord factoryRecord = null;
if ((_configRecord != null) && !_configRecord.Parent.IsRootConfig)
{
factoryRecord = _configRecord.Parent.FindFactoryRecord(SectionGroupName, permitErrors);
}
return(factoryRecord);
}
private FactoryRecord FindParentFactoryRecord(bool permitErrors)
{
FactoryRecord factoryRecord = null;
if (_configRecord != null && !_configRecord.Parent.IsRootConfig)
{
factoryRecord = _configRecord.Parent.FindFactoryRecord(_configKey, permitErrors);
}
return(factoryRecord);
}
internal void AddConfigurationSection(string group, string name, ConfigurationSection configSection)
{
if (base.IsLocationConfig)
{
throw new InvalidOperationException(System.Configuration.SR.GetString("Config_add_configurationsection_in_location_config"));
}
BaseConfigurationRecord.VerifySectionName(name, null, false);
if (configSection == null)
{
throw new ArgumentNullException("configSection");
}
if (configSection.SectionInformation.Attached)
{
throw new InvalidOperationException(System.Configuration.SR.GetString("Config_add_configurationsection_already_added"));
}
string configKey = BaseConfigurationRecord.CombineConfigKey(group, name);
if (base.FindFactoryRecord(configKey, true) != null)
{
throw new ArgumentException(System.Configuration.SR.GetString("Config_add_configurationsection_already_exists"));
}
if (!string.IsNullOrEmpty(configSection.SectionInformation.ConfigSource))
{
this.ChangeConfigSource(configSection.SectionInformation, null, null, configSection.SectionInformation.ConfigSource);
}
if (this._sectionFactories != null)
{
this._sectionFactories.Add(configKey, new FactoryId(configKey, group, name));
}
string type = configSection.SectionInformation.Type;
if (type == null)
{
type = base.Host.GetConfigTypeName(configSection.GetType());
}
FactoryRecord factoryRecord = new FactoryRecord(configKey, group, name, type, configSection.SectionInformation.AllowLocation, configSection.SectionInformation.AllowDefinition, configSection.SectionInformation.AllowExeDefinition, configSection.SectionInformation.OverrideModeDefaultSetting, configSection.SectionInformation.RestartOnExternalChanges, configSection.SectionInformation.RequirePermission, this._flags[0x2000], false, base.ConfigStreamInfo.StreamName, -1) {
Factory = System.Configuration.TypeUtil.GetConstructorWithReflectionPermission(configSection.GetType(), typeof(ConfigurationSection), true),
IsFactoryTrustedWithoutAptca = System.Configuration.TypeUtil.IsTypeFromTrustedAssemblyWithoutAptca(configSection.GetType())
};
base.EnsureFactories()[configKey] = factoryRecord;
SectionRecord sectionRecord = base.EnsureSectionRecordUnsafe(configKey, false);
sectionRecord.Result = configSection;
sectionRecord.ResultRuntimeObject = configSection;
if (this._removedSections != null)
{
this._removedSections.Remove(configKey);
}
configSection.SectionInformation.AttachToConfigurationRecord(this, factoryRecord, sectionRecord);
string rawXml = configSection.SectionInformation.RawXml;
if (!string.IsNullOrEmpty(rawXml))
{
configSection.SectionInformation.RawXml = null;
configSection.SectionInformation.SetRawXml(rawXml);
}
}
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 void Init(RuntimeConfigurationRecord configRecord, FactoryRecord factoryRecord)
{
Type c = System.Configuration.TypeUtil.GetTypeWithReflectionPermission(configRecord.Host, factoryRecord.FactoryTypeName, true);
if (typeof(ConfigurationSection).IsAssignableFrom(c))
{
this._sectionCtor = System.Configuration.TypeUtil.GetConstructorWithReflectionPermission(c, typeof(ConfigurationSection), true);
}
else
{
System.Configuration.TypeUtil.VerifyAssignableType(typeof(IConfigurationSectionHandler), c, true);
this._sectionHandler = (IConfigurationSectionHandler)System.Configuration.TypeUtil.CreateInstanceWithReflectionPermission(c);
}
}
internal void AttachToConfigurationRecord(MgmtConfigurationRecord configRecord, FactoryRecord factoryRecord) {
_configRecord = configRecord;
_configKey = factoryRecord.ConfigKey;
_group = factoryRecord.Group;
_name = factoryRecord.Name;
_typeName = factoryRecord.FactoryTypeName;
if (_typeName != null) {
FactoryRecord parentFactoryRecord = null;
if (!configRecord.Parent.IsRootConfig) {
parentFactoryRecord = configRecord.Parent.FindFactoryRecord(factoryRecord.ConfigKey, true);
}
_declarationRequired = (parentFactoryRecord == null || parentFactoryRecord.FactoryTypeName == null);
_declared = configRecord.GetFactoryRecord(factoryRecord.ConfigKey, true) != null;
}
}
internal void AttachToConfigurationRecord(MgmtConfigurationRecord configRecord, FactoryRecord factoryRecord)
{
this._configRecord = configRecord;
this._configKey = factoryRecord.ConfigKey;
this._group = factoryRecord.Group;
this._name = factoryRecord.Name;
this._typeName = factoryRecord.FactoryTypeName;
if (this._typeName != null)
{
FactoryRecord record = null;
if (!configRecord.Parent.IsRootConfig)
{
record = configRecord.Parent.FindFactoryRecord(factoryRecord.ConfigKey, true);
}
this._declarationRequired = (record == null) || (record.FactoryTypeName == null);
this._declared = configRecord.GetFactoryRecord(factoryRecord.ConfigKey, true) != null;
}
}
internal void AttachToConfigurationRecord(MgmtConfigurationRecord configRecord, FactoryRecord factoryRecord)
{
this._configRecord = configRecord;
this._configKey = factoryRecord.ConfigKey;
this._group = factoryRecord.Group;
this._name = factoryRecord.Name;
this._typeName = factoryRecord.FactoryTypeName;
if (this._typeName != null)
{
FactoryRecord record = null;
if (!configRecord.Parent.IsRootConfig)
{
record = configRecord.Parent.FindFactoryRecord(factoryRecord.ConfigKey, true);
}
this._declarationRequired = (record == null) || (record.FactoryTypeName == null);
this._declared = configRecord.GetFactoryRecord(factoryRecord.ConfigKey, true) != null;
}
}
internal void AttachToConfigurationRecord(MgmtConfigurationRecord configRecord, FactoryRecord factoryRecord)
{
_configRecord = configRecord;
SectionGroupName = factoryRecord.ConfigKey;
Name = factoryRecord.Name;
_typeName = factoryRecord.FactoryTypeName;
if (_typeName != null)
{
FactoryRecord parentFactoryRecord = null;
if (!configRecord.Parent.IsRootConfig)
{
parentFactoryRecord = configRecord.Parent.FindFactoryRecord(factoryRecord.ConfigKey, true);
}
IsDeclarationRequired = parentFactoryRecord?.FactoryTypeName == null;
IsDeclared = configRecord.GetFactoryRecord(factoryRecord.ConfigKey, true) != null;
}
}
internal void AttachToConfigurationRecord(MgmtConfigurationRecord configRecord, FactoryRecord factoryRecord)
{
_configRecord = configRecord;
_configKey = factoryRecord.ConfigKey;
_group = factoryRecord.Group;
_name = factoryRecord.Name;
_typeName = factoryRecord.FactoryTypeName;
if (_typeName != null)
{
FactoryRecord parentFactoryRecord = null;
if (!configRecord.Parent.IsRootConfig)
{
parentFactoryRecord = configRecord.Parent.FindFactoryRecord(factoryRecord.ConfigKey, true);
}
_declarationRequired = (parentFactoryRecord == null || parentFactoryRecord.FactoryTypeName == null);
_declared = configRecord.GetFactoryRecord(factoryRecord.ConfigKey, true) != null;
}
}
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();
}
}
}
private void InitWithFullTrust(RuntimeConfigurationRecord configRecord, FactoryRecord factoryRecord) {
Init(configRecord, factoryRecord);
}
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;
}
private object CreateSectionWithRestrictedPermissions(
RuntimeConfigurationRecord configRecord, FactoryRecord factoryRecord, SectionRecord sectionRecord,
object parentConfig, ConfigXmlReader reader)
{
return CreateSectionImpl(configRecord, factoryRecord, sectionRecord, parentConfig, reader);
}
internal RuntimeConfigurationFactory(RuntimeConfigurationRecord configRecord, FactoryRecord factoryRecord) {
// If the factory record was defined in a trusted config record, ignore user code on stack
if (factoryRecord.IsFromTrustedConfigRecord) {
InitWithFullTrust(configRecord, factoryRecord);
}
else {
// Run configuration section handlers as if user code was on the stack
InitWithRestrictedPermissions(configRecord, factoryRecord);
}
}
// for instantiation of a ConfigurationSection from GetConfig
internal void AttachToConfigurationRecord(MgmtConfigurationRecord configRecord, FactoryRecord factoryRecord,
SectionRecord sectionRecord)
{
SetRuntimeConfigurationInformation(configRecord, factoryRecord, sectionRecord);
_configRecord = configRecord;
}
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 );
}
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);
}
internal RuntimeConfigurationFactory(RuntimeConfigurationRecord configRecord, FactoryRecord factoryRecord)
{
Init(configRecord, factoryRecord);
}
//
// Add a new configuration section group to this config file.
//
// Called from ConfigurationSectionGroupCollection.Add().
// Note this method DOES NOT update the associated ConfigurationSectionGroupCollection.
//
internal void AddConfigurationSectionGroup(string group, string name, ConfigurationSectionGroup configSectionGroup) {
// <location> tags can't have a <configSections> declaration.
if (IsLocationConfig) {
throw new InvalidOperationException(SR.GetString(SR.Config_add_configurationsectiongroup_in_location_config));
}
// Validate name argument.
VerifySectionName(name, null, false);
// Validate configSectionGroup argument.
if (configSectionGroup == null) {
throw ExceptionUtil.ParameterInvalid("name");
}
// A section group can only belong to one section group collection.
if (configSectionGroup.Attached) {
throw new InvalidOperationException(SR.GetString(SR.Config_add_configurationsectiongroup_already_added));
}
string configKey = BaseConfigurationRecord.CombineConfigKey(group, name);
// Do not add if the section group already exists, even if it is of a different type.
FactoryRecord factoryRecord = FindFactoryRecord(configKey, true);
if (factoryRecord != null) {
throw new ArgumentException(SR.GetString(SR.Config_add_configurationsectiongroup_already_exists));
}
// Add to list of all section groups.
if (_sectionGroupFactories != null) {
_sectionGroupFactories.Add(configKey, new FactoryId(configKey, group, name));
}
// Get the type name - if it is not specified explicitly, get it from the type of the object.
string typeName = configSectionGroup.Type;
if (typeName == null) {
typeName = Host.GetConfigTypeName(configSectionGroup.GetType());
}
// Create a factory record and add it to the collection of factory records.
factoryRecord = new FactoryRecord(configKey, group, name, typeName, ConfigStreamInfo.StreamName, -1);
EnsureFactories()[configKey] = factoryRecord;
// Add it to list of evaluated configuration section groups.
SectionGroups[configKey] = configSectionGroup;
// Remove it from RemovedSectionGroups if it was previously removed.
if (_removedSectionGroups != null) {
_removedSectionGroups.Remove(configKey);
}
// Attach to the configuration record.
configSectionGroup.AttachToConfigurationRecord(this, factoryRecord);
}
private string GetUpdatedSectionDeclarationXml(FactoryRecord factoryRecord, ConfigurationSection configSection, ConfigurationSaveMode saveMode) {
StringBuilder sb = new StringBuilder();
sb.Append('<');
sb.Append(KEYWORD_SECTION);
sb.Append(' ');
string type = (configSection.SectionInformation.Type != null) ? configSection.SectionInformation.Type : factoryRecord.FactoryTypeName;
if (TypeStringTransformerIsSet)
type = TypeStringTransformer(type);
AppendAttribute(sb, KEYWORD_SECTION_NAME, configSection.SectionInformation.Name);
AppendAttribute(sb, KEYWORD_SECTION_TYPE, type);
if ( !configSection.SectionInformation.AllowLocation ||
(saveMode == ConfigurationSaveMode.Full) ||
((saveMode == ConfigurationSaveMode.Modified) &&
configSection.SectionInformation.AllowLocationModified)) {
AppendAttribute(sb,
KEYWORD_SECTION_ALLOWLOCATION,
configSection.SectionInformation.AllowLocation ?
KEYWORD_TRUE :
KEYWORD_FALSE);
}
if ((configSection.SectionInformation.AllowDefinition != ConfigurationAllowDefinition.Everywhere) ||
(saveMode == ConfigurationSaveMode.Full) ||
(saveMode == ConfigurationSaveMode.Modified && configSection.SectionInformation.AllowDefinitionModified)) {
string v = null;
switch (configSection.SectionInformation.AllowDefinition) {
case ConfigurationAllowDefinition.Everywhere:
v = KEYWORD_SECTION_ALLOWDEFINITION_EVERYWHERE;
break;
case ConfigurationAllowDefinition.MachineOnly:
v = KEYWORD_SECTION_ALLOWDEFINITION_MACHINEONLY;
break;
case ConfigurationAllowDefinition.MachineToWebRoot:
v = KEYWORD_SECTION_ALLOWDEFINITION_MACHINETOWEBROOT;
break;
case ConfigurationAllowDefinition.MachineToApplication:
v = KEYWORD_SECTION_ALLOWDEFINITION_MACHINETOAPPLICATION;
break;
}
AppendAttribute(sb, KEYWORD_SECTION_ALLOWDEFINITION, v);
}
if ((configSection.SectionInformation.AllowExeDefinition !=
ConfigurationAllowExeDefinition.MachineToApplication ) ||
(saveMode == ConfigurationSaveMode.Full) ||
(saveMode == ConfigurationSaveMode.Modified && configSection.SectionInformation.AllowExeDefinitionModified)) {
AppendAttribute( sb,
KEYWORD_SECTION_ALLOWEXEDEFINITION,
ExeDefinitionToString(
configSection.SectionInformation.AllowExeDefinition )
);
}
if ( (configSection.SectionInformation.OverrideModeDefaultSetting.IsDefaultForSection == false) ||
(saveMode == ConfigurationSaveMode.Full) ||
(saveMode == ConfigurationSaveMode.Modified && configSection.SectionInformation.OverrideModeDefaultModified)) {
AppendAttribute( sb,
KEYWORD_SECTION_OVERRIDEMODEDEFAULT,
configSection.SectionInformation.OverrideModeDefaultSetting.OverrideModeXmlValue);
}
if (!configSection.SectionInformation.RestartOnExternalChanges) {
AppendAttribute(sb, KEYWORD_SECTION_RESTARTONEXTERNALCHANGES, KEYWORD_FALSE);
}
else if ((saveMode == ConfigurationSaveMode.Full) ||
(saveMode == ConfigurationSaveMode.Modified && configSection.SectionInformation.RestartOnExternalChangesModified)) {
AppendAttribute(sb, KEYWORD_SECTION_RESTARTONEXTERNALCHANGES, KEYWORD_TRUE);
}
if (!configSection.SectionInformation.RequirePermission) {
AppendAttribute(sb, KEYWORD_SECTION_REQUIREPERMISSION, KEYWORD_FALSE);
}
else if ((saveMode == ConfigurationSaveMode.Full) ||
(saveMode == ConfigurationSaveMode.Modified && configSection.SectionInformation.RequirePermissionModified)) {
AppendAttribute(sb, KEYWORD_SECTION_REQUIREPERMISSION, KEYWORD_TRUE);
}
sb.Append("/>");
return sb.ToString();
}
//
// Add a new configuration section to this config file.
// This adds both the section declaration and definition to the config file.
//
// Called from ConfigurationSectionCollection.Add().
// Note this method DOES NOT update the associated ConfigurationSectionCollection.
//
internal void AddConfigurationSection(string group, string name, ConfigurationSection configSection) {
// <configSections> is not permitted within a <location> tag.
if (IsLocationConfig) {
throw new InvalidOperationException(SR.GetString(SR.Config_add_configurationsection_in_location_config));
}
VerifySectionName(name, null, false);
if (configSection == null) {
throw new ArgumentNullException("configSection");
}
// Ensure the section is not already part of the configuration hierarchy.
if (configSection.SectionInformation.Attached) {
throw new InvalidOperationException(SR.GetString(SR.Config_add_configurationsection_already_added));
}
string configKey = BaseConfigurationRecord.CombineConfigKey(group, name);
// Ensure the section is not already declared.
FactoryRecord factoryRecord = FindFactoryRecord(configKey, true);
if (factoryRecord != null) {
throw new ArgumentException(SR.GetString(SR.Config_add_configurationsection_already_exists));
}
// Add the configSource if needed.
if (!String.IsNullOrEmpty(configSection.SectionInformation.ConfigSource)) {
ChangeConfigSource(configSection.SectionInformation, null, null, configSection.SectionInformation.ConfigSource);
}
// Add to list of all sections.
if (_sectionFactories != null) {
_sectionFactories.Add(configKey, new FactoryId(configKey, group, name));
}
// Get the type name.
string typeName = configSection.SectionInformation.Type;
if (typeName == null) {
typeName = Host.GetConfigTypeName(configSection.GetType());
}
// Add a factory record for the section.
factoryRecord = new FactoryRecord(configKey,
group,
name,
typeName,
configSection.SectionInformation.AllowLocation,
configSection.SectionInformation.AllowDefinition,
configSection.SectionInformation.AllowExeDefinition,
configSection.SectionInformation.OverrideModeDefaultSetting,
configSection.SectionInformation.RestartOnExternalChanges,
configSection.SectionInformation.RequirePermission,
_flags[IsTrusted],
false, // isUndeclared
ConfigStreamInfo.StreamName,
-1);
// Construct a factory for the section
factoryRecord.Factory = TypeUtil.GetConstructorWithReflectionPermission(
configSection.GetType(), typeof(ConfigurationSection), true);
factoryRecord.IsFactoryTrustedWithoutAptca = TypeUtil.IsTypeFromTrustedAssemblyWithoutAptca(configSection.GetType());
EnsureFactories()[configKey] = factoryRecord;
// Add a section record for the section.
// Since we are adding a new definition, it cannot be locked.
SectionRecord sectionRecord = EnsureSectionRecordUnsafe(configKey, false);
sectionRecord.Result = configSection;
sectionRecord.ResultRuntimeObject = configSection;
// Undo any previous removals of the section.
if (_removedSections != null) {
_removedSections.Remove(configKey);
}
// Attach the section to the configuration record.
configSection.SectionInformation.AttachToConfigurationRecord(this, factoryRecord, sectionRecord);
//
// If there is rawXml, set it now. Note this will override any other changes to the section
// definition made after the call to SetXml.
//
string rawXml = configSection.SectionInformation.RawXml;
if (!String.IsNullOrEmpty(rawXml)) {
configSection.SectionInformation.RawXml = null;
configSection.SectionInformation.SetRawXml(rawXml);
}
}
//
// Ensure the existence of a section group factory, and return it.
//
private ConstructorInfo EnsureSectionGroupFactory(FactoryRecord factoryRecord) {
ConstructorInfo factory = (ConstructorInfo) factoryRecord.Factory;
if (factory == null) {
factory = CreateSectionGroupFactory(factoryRecord);
factoryRecord.Factory = factory;
}
return factory;
}
//
// Create the type used to create new instances of a ConfigurationSectionGroup.
// Our factory is a ConstructorInfo that creates the section group.
//
private ConstructorInfo CreateSectionGroupFactory(FactoryRecord factoryRecord) {
Type type;
if (String.IsNullOrEmpty(factoryRecord.FactoryTypeName)) {
type = typeof(ConfigurationSectionGroup);
}
else {
type = TypeUtil.GetTypeWithReflectionPermission(Host, factoryRecord.FactoryTypeName, true);
}
ConstructorInfo ctor = TypeUtil.GetConstructorWithReflectionPermission(type, typeof(ConfigurationSectionGroup), true);
return ctor;
}
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 RuntimeConfigurationFactory(RuntimeConfigurationRecord configRecord, FactoryRecord factoryRecord)
{
// If the factory record was defined in a trusted config record, ignore user code on stack
if (factoryRecord.IsFromTrustedConfigRecord)
{
InitWithFullTrust(configRecord, factoryRecord);
}
else
{
// Run configuration section handlers as if user code was on the stack
InitWithRestrictedPermissions(configRecord, factoryRecord);
}
}
//
// 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;
}
private void InitWithFullTrust(RuntimeConfigurationRecord configRecord, FactoryRecord factoryRecord)
{
Init(configRecord, factoryRecord);
}
private void InitWithRestrictedPermissions(RuntimeConfigurationRecord configRecord, FactoryRecord factoryRecord)
{
Init(configRecord, factoryRecord);
}
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 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 AreDeclarationAttributesModified(FactoryRecord factoryRecord, ConfigurationSection configSection) {
return factoryRecord.FactoryTypeName != configSection.SectionInformation.Type
|| factoryRecord.AllowLocation != configSection.SectionInformation.AllowLocation
|| factoryRecord.RestartOnExternalChanges != configSection.SectionInformation.RestartOnExternalChanges
|| factoryRecord.RequirePermission != configSection.SectionInformation.RequirePermission
|| factoryRecord.AllowDefinition != configSection.SectionInformation.AllowDefinition
|| factoryRecord.AllowExeDefinition != configSection.SectionInformation.AllowExeDefinition
|| factoryRecord.OverrideModeDefault.OverrideMode != configSection.SectionInformation.OverrideModeDefaultSetting.OverrideMode // Compare the value only
|| configSection.SectionInformation.IsModifiedFlags();
}
internal RuntimeConfigurationFactory(RuntimeConfigurationRecord configRecord, FactoryRecord factoryRecord)
{
Init(configRecord, factoryRecord);
}
// Create the factory that will evaluate configuration
override protected object CreateSectionFactory(FactoryRecord factoryRecord) {
return new RuntimeConfigurationFactory(this, factoryRecord);
}
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);
}
//
// Create the factory object that is used to create new instances of a ConfigurationSection.
// Our factory is a ConstructorInfo that creates the section.
//
override protected object CreateSectionFactory(FactoryRecord factoryRecord) {
// Get the type of the factory
Type type = TypeUtil.GetTypeWithReflectionPermission(Host, factoryRecord.FactoryTypeName, true);
//
// If the type is not a ConfigurationSection, use the DefaultSection if the type
// implements IConfigurationSectionHandler.
//
if (!typeof(ConfigurationSection).IsAssignableFrom(type)) {
TypeUtil.VerifyAssignableType(typeof(IConfigurationSectionHandler), type, true);
type = typeof(DefaultSection);
}
ConstructorInfo ctor = TypeUtil.GetConstructorWithReflectionPermission(type, typeof(ConfigurationSection), true);
return ctor;
}
private void Init(RuntimeConfigurationRecord configRecord, FactoryRecord factoryRecord) {
// Get the type of the factory
Type type = TypeUtil.GetTypeWithReflectionPermission(configRecord.Host, factoryRecord.FactoryTypeName, true);
// If the type is a ConfigurationSection, that's the type.
if (typeof(ConfigurationSection).IsAssignableFrom(type)) {
_sectionCtor = TypeUtil.GetConstructorWithReflectionPermission(type, typeof(ConfigurationSection), true);
}
else {
// Note: in v1, IConfigurationSectionHandler is in effect a factory that has a Create method
// that creates the real section object.
// throws if type does not implement IConfigurationSectionHandler
TypeUtil.VerifyAssignableType(typeof(IConfigurationSectionHandler), type, true);
// Create an instance of the handler
_sectionHandler = (IConfigurationSectionHandler) TypeUtil.CreateInstanceWithReflectionPermission(type);
}
}
private ConstructorInfo CreateSectionGroupFactory(FactoryRecord factoryRecord)
{
Type type = string.IsNullOrEmpty(factoryRecord.FactoryTypeName)
? typeof(ConfigurationSectionGroup)
: TypeUtil.GetType(Host, factoryRecord.FactoryTypeName, true);
ConstructorInfo ctor = TypeUtil.GetConstructor(type,
typeof(ConfigurationSectionGroup), true);
return ctor;
}
private void InitWithRestrictedPermissions(RuntimeConfigurationRecord configRecord, FactoryRecord factoryRecord) {
// 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;
}
Init(configRecord, factoryRecord);
}
finally {
if (revertPermitOnly) {
CodeAccessPermission.RevertPermitOnly();
}
}
}
private void InitWithRestrictedPermissions(RuntimeConfigurationRecord configRecord, FactoryRecord factoryRecord)
{
bool flag = false;
try
{
PermissionSet restrictedPermissions = configRecord.GetRestrictedPermissions();
if (restrictedPermissions != null)
{
restrictedPermissions.PermitOnly();
flag = true;
}
this.Init(configRecord, factoryRecord);
}
finally
{
if (flag)
{
CodeAccessPermission.RevertPermitOnly();
}
}
}
private object CreateSectionWithFullTrust(
RuntimeConfigurationRecord configRecord, FactoryRecord factoryRecord, SectionRecord sectionRecord,
object parentConfig, ConfigXmlReader reader) {
return CreateSectionImpl(configRecord, factoryRecord, sectionRecord, parentConfig, reader);
}
// Create the factory that will evaluate configuration
protected override object CreateSectionFactory(FactoryRecord factoryRecord)
{
return(new RuntimeConfigurationFactory(this, factoryRecord));
}
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 string GetUpdatedSectionGroupDeclarationXml(FactoryRecord factoryRecord, ConfigurationSectionGroup configSectionGroup) {
if (TargetFramework != null && !configSectionGroup.ShouldSerializeSectionGroupInTargetVersion(TargetFramework))
return null;
StringBuilder sb = new StringBuilder();
sb.Append('<');
sb.Append(KEYWORD_SECTIONGROUP);
sb.Append(' ');
AppendAttribute(sb, KEYWORD_SECTIONGROUP_NAME, configSectionGroup.Name);
string type = (configSectionGroup.Type != null) ? configSectionGroup.Type : factoryRecord.FactoryTypeName;
if (TypeStringTransformerIsSet)
type = TypeStringTransformer(type);
AppendAttribute(sb, KEYWORD_SECTIONGROUP_TYPE, type);
sb.Append('>');
return sb.ToString();
}
internal RuntimeConfigurationFactory(RuntimeConfigurationRecord configRecord, FactoryRecord factoryRecord)
{
if (factoryRecord.IsFromTrustedConfigRecord)
{
this.InitWithFullTrust(configRecord, factoryRecord);
}
else
{
this.InitWithRestrictedPermissions(configRecord, factoryRecord);
}
}
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 void InitWithRestrictedPermissions(RuntimeConfigurationRecord configRecord, FactoryRecord factoryRecord)
{
// 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;
}
Init(configRecord, factoryRecord);
}
finally {
if (revertPermitOnly)
{
CodeAccessPermission.RevertPermitOnly();
}
}
}
private string GetUpdatedSectionGroupDeclarationXml(FactoryRecord factoryRecord,
ConfigurationSectionGroup configSectionGroup)
{
if ((TargetFramework != null) &&
!configSectionGroup.ShouldSerializeSectionGroupInTargetVersion(TargetFramework))
return null;
StringBuilder sb = new StringBuilder();
sb.Append('<');
sb.Append(KeywordSectiongroup);
sb.Append(' ');
AppendAttribute(sb, KeywordSectiongroupName, configSectionGroup.Name);
string type = configSectionGroup.Type ?? factoryRecord.FactoryTypeName;
if (TypeStringTransformerIsSet)
type = TypeStringTransformer(type);
AppendAttribute(sb, KeywordSectiongroupType, type);
sb.Append('>');
return sb.ToString();
}
internal void AttachToConfigurationRecord(MgmtConfigurationRecord configRecord, FactoryRecord factoryRecord, SectionRecord sectionRecord)
{
this.SetRuntimeConfigurationInformation(configRecord, factoryRecord, sectionRecord);
this._configRecord = configRecord;
}
private object CreateSectionWithFullTrust(
RuntimeConfigurationRecord configRecord, FactoryRecord factoryRecord, SectionRecord sectionRecord,
object parentConfig, ConfigXmlReader reader)
{
return(CreateSectionImpl(configRecord, factoryRecord, sectionRecord, parentConfig, reader));
}
