internal SectionInput(SectionXmlInfo sectionXmlInfo, List<ConfigurationException> errors) { _sectionXmlInfo = sectionXmlInfo; _errors = errors; _result = s_unevaluated; _resultRuntimeObject = s_unevaluated; }
internal SectionInput(SectionXmlInfo sectionXmlInfo, List <ConfigurationException> errors) { _sectionXmlInfo = sectionXmlInfo; _errors = errors; _result = s_unevaluated; _resultRuntimeObject = s_unevaluated; }
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); }
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 List <ConfigurationException> _errors; // errors internal LocationSectionRecord(SectionXmlInfo sectionXmlInfo, List <ConfigurationException> errors) { SectionXmlInfo = sectionXmlInfo; _errors = errors; }
private List<ConfigurationException> _errors; // errors internal LocationSectionRecord(SectionXmlInfo sectionXmlInfo, List<ConfigurationException> errors) { SectionXmlInfo = sectionXmlInfo; _errors = errors; }
// After the config file has been written out, update the section records // to reflect changes that were made in the config file. private void UpdateRecords() { if (_factoryRecords != null) { foreach (FactoryRecord factoryRecord in _factoryRecords.Values) { // Update stream information if (String.IsNullOrEmpty(factoryRecord.Filename)) { factoryRecord.Filename = ConfigStreamInfo.StreamName; } factoryRecord.LineNumber = 0; ConfigurationSection configSection = GetConfigSection(factoryRecord.ConfigKey); if (configSection != null) { if (configSection.SectionInformation.Type != null) { 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; } } } if (_sectionRecords != null) { string definitionConfigPath = (IsLocationConfig) ? _parent.ConfigPath : ConfigPath; foreach (SectionRecord sectionRecord in _sectionRecords.Values) { string configSource; string configSourceStreamName; object configSourceStreamVersion; ConfigurationSection configSection; if (sectionRecord.HasResult) { configSection = (ConfigurationSection) sectionRecord.Result; configSource = configSection.SectionInformation.ConfigSource; if (String.IsNullOrEmpty(configSource)) { configSource = null; } configSourceStreamName = configSection.SectionInformation.ConfigSourceStreamName; if (String.IsNullOrEmpty(configSourceStreamName)) { configSourceStreamName = null; } } else { configSection = null; configSource = null; configSourceStreamName = null; // If there is no result, then the only way there could be a // section record is: // 1. For there to be input in the file. // 2. A location tag applies to this record Debug.Assert(sectionRecord.HasFileInput || sectionRecord.HasLocationInputs, "sectionRecord.HasFileInput || sectionRecord.HasLocationInputs"); // Note that if it's a location input, we don't need to monitor the configSource because // that stream is monitored by one of our parent's config record if (sectionRecord.HasFileInput) { SectionXmlInfo sectionXmlInfo = sectionRecord.FileInput.SectionXmlInfo; configSource = sectionXmlInfo.ConfigSource; configSourceStreamName = sectionXmlInfo.ConfigSourceStreamName; } } if (!String.IsNullOrEmpty(configSource)) { configSourceStreamVersion = MonitorStream(sectionRecord.ConfigKey, configSource, configSourceStreamName); } else { configSourceStreamVersion = null; } if (!sectionRecord.HasResult) { Debug.Assert(sectionRecord.HasFileInput || sectionRecord.HasLocationInputs, "sectionRecord.HasFileInput || sectionRecord.HasLocationInputs"); // Note that if it's a location input, we don't need to monitor the configSource because // that stream is monitored by one of our parent's config record if (sectionRecord.HasFileInput) { SectionXmlInfo sectionXmlInfo = sectionRecord.FileInput.SectionXmlInfo; sectionXmlInfo.StreamVersion = ConfigStreamInfo.StreamVersion; sectionXmlInfo.ConfigSourceStreamVersion = configSourceStreamVersion; } } else { configSection.SectionInformation.RawXml = null; bool addUpdate = sectionRecord.AddUpdate; sectionRecord.AddUpdate = false; if (addUpdate) { SectionInput fileInput = sectionRecord.FileInput; if (fileInput == null) { SectionXmlInfo sectionXmlInfo = new SectionXmlInfo( sectionRecord.ConfigKey, definitionConfigPath, _configPath, _locationSubPath, ConfigStreamInfo.StreamName, 0, ConfigStreamInfo.StreamVersion, null, configSource, configSourceStreamName, configSourceStreamVersion, configSection.SectionInformation.ProtectionProviderName, configSection.SectionInformation.OverrideModeSetting, !configSection.SectionInformation.InheritInChildApplications); fileInput = new SectionInput(sectionXmlInfo, null); fileInput.Result = configSection; fileInput.ResultRuntimeObject = configSection; sectionRecord.AddFileInput(fileInput); } else { SectionXmlInfo sectionXmlInfo = fileInput.SectionXmlInfo; sectionXmlInfo.LineNumber = 0; sectionXmlInfo.StreamVersion = ConfigStreamInfo.StreamVersion; sectionXmlInfo.RawXml = null; sectionXmlInfo.ConfigSource = configSource; sectionXmlInfo.ConfigSourceStreamName = configSourceStreamName; sectionXmlInfo.ConfigSourceStreamVersion = configSourceStreamVersion; sectionXmlInfo.ProtectionProviderName = configSection.SectionInformation.ProtectionProviderName; sectionXmlInfo.OverrideModeSetting = configSection.SectionInformation.OverrideModeSetting; sectionXmlInfo.SkipInChildApps = !configSection.SectionInformation.InheritInChildApplications; } fileInput.ProtectionProvider = configSection.SectionInformation.ProtectionProvider; } try { configSection.ResetModified(); } catch (Exception e) { throw new ConfigurationErrorsException(SR.GetString(SR.Config_exception_in_config_section_handler, sectionRecord.ConfigKey), e, ConfigStreamInfo.StreamName, 0); } } } } // Copy remaining stream updates, which correspond to streams used by location sections foreach (StreamInfo streamInfo in _streamInfoUpdates.Values) { if (!ConfigStreamInfo.StreamInfos.Contains(streamInfo.StreamName)) { MonitorStream(streamInfo.SectionName, streamInfo.ConfigSource, streamInfo.StreamName); } } // reinitialize _streamInfoUpdates InitStreamInfoUpdates(); // Update namespace value _flags[ NamespacePresentInFile ] = _flags[ NamespacePresentCurrent ]; // You only have one chance to force the location config, now you // will have to recreate the object _flags[ ForceLocationWritten ] = false; _flags[ SuggestLocationRemoval ] = false; // Handle removed location sections if (!IsLocationConfig && _locationSections != null && _removedSections != null && _removedSections.Count > 0) { int i = 0; while (i < _locationSections.Count) { LocationSectionRecord locationSectionRecord = (LocationSectionRecord) _locationSections[i]; if (_removedSections.Contains(locationSectionRecord.ConfigKey)) { _locationSections.RemoveAt(i); } else { i++; } } } _removedSections = null; _removedSectionGroups = null; }
// Recursively clear the result. // If forceEvaluation == true, force a rescan of the config file to find // the section. // Requires the hierarchy lock to be acquired (hl) internal void hlClearResultRecursive(string configKey, bool forceEvaluatation) { SectionRecord sectionRecord; // Refresh it's factory Record RefreshFactoryRecord(configKey); // Clear any stored result in the section sectionRecord = GetSectionRecord(configKey, false); if (sectionRecord != null) { sectionRecord.ClearResult(); sectionRecord.ClearRawXml(); } // // If we need to reevaluate, add a dummy file input so // that we open the file on the next evaluation // if (forceEvaluatation && !IsInitDelayed && !String.IsNullOrEmpty(ConfigStreamInfo.StreamName)) { if (_flags[SupportsPath]) { throw ExceptionUtil.UnexpectedError("BaseConfigurationRecord::hlClearResultRecursive"); } FactoryRecord factoryRecord = FindFactoryRecord(configKey, false); if (factoryRecord != null && !factoryRecord.IsGroup) { configKey = factoryRecord.ConfigKey; sectionRecord = EnsureSectionRecord(configKey, false); if (!sectionRecord.HasFileInput) { SectionXmlInfo sectionXmlInfo = new SectionXmlInfo( configKey, _configPath, _configPath, null, ConfigStreamInfo.StreamName, 0, null, null, null, null, null, null, false, false); SectionInput fileInput = new SectionInput(sectionXmlInfo, null); sectionRecord.AddFileInput(fileInput); } } } // Recurse if (_children != null) { IEnumerable children = _children.Values; foreach (BaseConfigurationRecord child in children) { child.hlClearResultRecursive(configKey, forceEvaluatation); } } }
private void ScanSectionsRecursive( XmlUtil xmlUtil, string parentConfigKey, bool inLocation, string locationSubPath, bool lockChildren, bool skipInChildApps) { // discard any accumulated local errors xmlUtil.SchemaErrors.ResetLocalErrors(); int depth; // only move to child nodes when not on first level (we've already passed the first <configsections>) if (parentConfigKey.Length == 0 && !inLocation) { depth = 0; } else { depth = xmlUtil.Reader.Depth; xmlUtil.StrictReadToNextElement(ExceptionAction.NonSpecific); } while (xmlUtil.Reader.Depth == depth + 1) { string tagName = xmlUtil.Reader.Name; // // Check for reserved elements before looking up the factory, // which may have the same name if it is in error. // if (tagName == KEYWORD_CONFIGSECTIONS) { // Error: duplicate <configSections> tag, or <configSections> not the first tag under <configuration> xmlUtil.SchemaErrors.AddError( new ConfigurationErrorsException(SR.GetString(SR.Config_client_config_too_many_configsections_elements, tagName), xmlUtil), ExceptionAction.NonSpecific); xmlUtil.StrictSkipToNextElement(ExceptionAction.NonSpecific); continue; } if (tagName == KEYWORD_LOCATION) { if (parentConfigKey.Length > 0 || inLocation) { // Error: <location> section not at top level xmlUtil.SchemaErrors.AddError( new ConfigurationErrorsException(SR.GetString(SR.Config_location_location_not_allowed), xmlUtil), ExceptionAction.Global); xmlUtil.StrictSkipToNextElement(ExceptionAction.NonSpecific); } else { // Recurse into the location section ScanLocationSection(xmlUtil); } continue; } string configKey = CombineConfigKey(parentConfigKey, tagName); FactoryRecord factoryRecord = FindFactoryRecord(configKey, true); if (factoryRecord == null) { // // if (!ClassFlags[ClassIgnoreLocalErrors]) { xmlUtil.SchemaErrors.AddError( new ConfigurationErrorsException(SR.GetString(SR.Config_unrecognized_configuration_section, configKey), xmlUtil), ExceptionAction.Local); } VerifySectionName(tagName, xmlUtil, ExceptionAction.Local, false); factoryRecord = new FactoryRecord( configKey, parentConfigKey, tagName, typeof(DefaultSection).AssemblyQualifiedName, true, // allowLocation ConfigurationAllowDefinition.Everywhere, ConfigurationAllowExeDefinition.MachineToRoamingUser, true, // restartOnExternalChanges true, // requirePermission _flags[IsTrusted], true, // isUndeclared null, -1); // Add any errors we may have encountered to the factory record, // so that child config that also refer to this unrecognized section // get the error. factoryRecord.AddErrors(xmlUtil.SchemaErrors.RetrieveAndResetLocalErrors(true)); // Add the factory to the list of factories EnsureFactories()[configKey] = factoryRecord; } if (factoryRecord.IsGroup) { // // Section Group // if (factoryRecord.HasErrors) { xmlUtil.StrictSkipToNextElement(ExceptionAction.NonSpecific); } else { if (xmlUtil.Reader.AttributeCount > 0) { while (xmlUtil.Reader.MoveToNextAttribute()) { if (IsReservedAttributeName(xmlUtil.Reader.Name)) { xmlUtil.AddErrorReservedAttribute(ExceptionAction.NonSpecific); } } xmlUtil.Reader.MoveToElement(); // if on an attribute move back to the element } // Recurse into group definition ScanSectionsRecursive(xmlUtil, configKey, inLocation, locationSubPath, lockChildren, skipInChildApps); } } else { // // Section // configKey = factoryRecord.ConfigKey; string fileName = xmlUtil.Filename; int lineNumber = xmlUtil.LineNumber; string rawXml = null; string configSource = null; string configSourceStreamName = null; object configSourceStreamVersion = null; string protectionProviderName = null; bool isSectionLocked = false; bool positionedAtNextElement = false; bool isFileInput = (locationSubPath == null); if (!factoryRecord.HasErrors) { // We have a valid factoryRecord for a section if (inLocation && factoryRecord.AllowLocation == false) { xmlUtil.SchemaErrors.AddError( new ConfigurationErrorsException(SR.GetString(SR.Config_section_cannot_be_used_in_location), xmlUtil), ExceptionAction.Local); } // Verify correctness for file inputs. if (isFileInput) { // Verify that the section is unique SectionRecord sectionRecord = GetSectionRecord(configKey, true); if (sectionRecord != null && sectionRecord.HasFileInput) { xmlUtil.SchemaErrors.AddError( new ConfigurationErrorsException(SR.GetString(SR.Config_sections_must_be_unique), xmlUtil), ExceptionAction.Local); } // Verify that the definition is allowed. try { VerifyDefinitionAllowed(factoryRecord, _configPath, xmlUtil); } catch (ConfigurationException ce) { xmlUtil.SchemaErrors.AddError(ce, ExceptionAction.Local); } } // Verify that section is unlocked, both for file and location inputs. try { VerifySectionUnlocked(configKey, xmlUtil); } catch (ConfigurationException ce) { isSectionLocked = true; xmlUtil.SchemaErrors.AddError(ce, ExceptionAction.Local); } // check for configSource or protectionProvider if (xmlUtil.Reader.AttributeCount >= 1) { // First do all the attributes reading without advancing the reader. string configSourceAttribute = xmlUtil.Reader.GetAttribute(KEYWORD_CONFIGSOURCE); if (configSourceAttribute != null) { try { configSource = NormalizeConfigSource(configSourceAttribute, xmlUtil); } catch (ConfigurationException ce) { xmlUtil.SchemaErrors.AddError(ce, ExceptionAction.Local); } if (xmlUtil.Reader.AttributeCount != 1) { // Error: elements with configSource should not have other attributes xmlUtil.SchemaErrors.AddError( new ConfigurationErrorsException(SR.GetString(SR.Config_source_syntax_error), xmlUtil), ExceptionAction.Local); } } string protectionProviderAttribute = xmlUtil.Reader.GetAttribute(KEYWORD_PROTECTION_PROVIDER); if (protectionProviderAttribute != null) { try { protectionProviderName = ValidateProtectionProviderAttribute(protectionProviderAttribute, xmlUtil); } catch (ConfigurationException ce) { xmlUtil.SchemaErrors.AddError(ce, ExceptionAction.Local); } if (xmlUtil.Reader.AttributeCount != 1) { // Error: elements with protectionProvider should not have other attributes xmlUtil.SchemaErrors.AddError( new ConfigurationErrorsException(SR.GetString(SR.Protection_provider_syntax_error), xmlUtil), ExceptionAction.Local); } } // The 2nd part of the configSource check requires advancing the reader. // Please note that this part should be done only AFTER all other attributes // checking are done. if (configSourceAttribute != null) { if (!xmlUtil.Reader.IsEmptyElement) { while (xmlUtil.Reader.Read()) { XmlNodeType t = xmlUtil.Reader.NodeType; if (t == XmlNodeType.EndElement) break; if (t != XmlNodeType.Comment) { // Error: elements with configSource should not subelements other than comments xmlUtil.SchemaErrors.AddError( new ConfigurationErrorsException(SR.GetString(SR.Config_source_syntax_error), xmlUtil), ExceptionAction.Local); if (t == XmlNodeType.Element) { xmlUtil.StrictSkipToOurParentsEndElement(ExceptionAction.NonSpecific); } else { xmlUtil.StrictSkipToNextElement(ExceptionAction.NonSpecific); } positionedAtNextElement = true; break; } } } } } if (configSource != null) { try { try { configSourceStreamName = Host.GetStreamNameForConfigSource(ConfigStreamInfo.StreamName, configSource); } catch (Exception e) { throw ExceptionUtil.WrapAsConfigException(SR.GetString(SR.Config_source_invalid), e, xmlUtil); } ValidateUniqueConfigSource(configKey, configSourceStreamName, configSource, xmlUtil); configSourceStreamVersion = MonitorStream(configKey, configSource, configSourceStreamName); } catch (ConfigurationException ex) { xmlUtil.SchemaErrors.AddError(ex, ExceptionAction.Local); } } // // prefetch the raw xml // if (!xmlUtil.SchemaErrors.HasLocalErrors) { if (configSource == null && ShouldPrefetchRawXml(factoryRecord)) { Debug.Assert(!positionedAtNextElement, "!positionedAtNextElement"); rawXml = xmlUtil.CopySection(); if (xmlUtil.Reader.NodeType != XmlNodeType.Element) { xmlUtil.VerifyIgnorableNodeType(ExceptionAction.NonSpecific); xmlUtil.StrictReadToNextElement(ExceptionAction.NonSpecific); } positionedAtNextElement = true; } } } // Get the list of errors before advancing the reader List<ConfigurationException> localErrors = xmlUtil.SchemaErrors.RetrieveAndResetLocalErrors(isFileInput); // advance the reader to the next element if (!positionedAtNextElement) { xmlUtil.StrictSkipToNextElement(ExceptionAction.NonSpecific); } // Add the input either to: // 1. The file input at the current config level, or // 2. LocationSections, where it will be used in sub paths bool addInput = true; if (isFileInput) { // If isFileInput==true, Input added will be used against this config level. // Need to check if we need to skip it due to inheritInChildApplications. if (ShouldSkipDueToInheritInChildApplications(skipInChildApps)) { addInput = false; } } else { if (!_flags[SupportsLocation]) { // Skip if we have a location input but we don't support location tag. addInput = false; } } if (addInput) { string targetConfigPath = (locationSubPath == null) ? _configPath : null; SectionXmlInfo sectionXmlInfo = new SectionXmlInfo( configKey, _configPath, targetConfigPath, locationSubPath, fileName, lineNumber, ConfigStreamInfo.StreamVersion, rawXml, configSource, configSourceStreamName, configSourceStreamVersion, protectionProviderName, lockChildren, skipInChildApps); if (locationSubPath == null) { // // Add this file input to the section record // // We've already checked for locked above, so use skip the second check // and set the locked bit. SectionRecord sectionRecord = EnsureSectionRecordUnsafe(configKey, true); Debug.Assert(!sectionRecord.Locked || isSectionLocked, "!sectionRecord.Locked || isSectionLocked"); if (isSectionLocked) { sectionRecord.Locked = true; } SectionInput fileInput = new SectionInput(sectionXmlInfo, localErrors); sectionRecord.AddFileInput(fileInput); } else { // // Add this location input to this list of location sections // LocationSectionRecord locationSectionRecord = new LocationSectionRecord(sectionXmlInfo, localErrors); EnsureLocationSections().Add(locationSectionRecord); } } } } }
private ConfigXmlReader LoadConfigSource(string name, SectionXmlInfo sectionXmlInfo) { string configSourceStreamName = sectionXmlInfo.ConfigSourceStreamName; try { using (Impersonate()) { using (Stream stream = Host.OpenStreamForRead(configSourceStreamName)) { if (stream == null) { throw new ConfigurationErrorsException( SR.GetString(SR.Config_cannot_open_config_source, sectionXmlInfo.ConfigSource), sectionXmlInfo); } using (XmlUtil xmlUtil = new XmlUtil(stream, configSourceStreamName, true)) { if (xmlUtil.Reader.Name != name) { throw new ConfigurationErrorsException(SR.GetString(SR.Config_source_file_format), xmlUtil); } // Check for protectionProvider string protectionProviderAttribute = xmlUtil.Reader.GetAttribute(KEYWORD_PROTECTION_PROVIDER); if (protectionProviderAttribute != null) { if (xmlUtil.Reader.AttributeCount != 1) { // Error: elements with protectionProvider should not have other attributes throw new ConfigurationErrorsException(SR.GetString(SR.Protection_provider_syntax_error), xmlUtil); } sectionXmlInfo.ProtectionProviderName = ValidateProtectionProviderAttribute(protectionProviderAttribute, xmlUtil); } int lineOffset = xmlUtil.Reader.LineNumber; string rawXml = xmlUtil.CopySection(); // Detect if there is any XML left over after the section while (!xmlUtil.Reader.EOF) { XmlNodeType t = xmlUtil.Reader.NodeType; if (t != XmlNodeType.Comment) { throw new ConfigurationErrorsException(SR.GetString(SR.Config_source_file_format), xmlUtil); } xmlUtil.Reader.Read(); } ConfigXmlReader section = new ConfigXmlReader(rawXml, configSourceStreamName, lineOffset); return section; } } } } catch { // Don't allow frames up the stack to run exception filters while impersonated. throw; } }
private ConfigXmlReader FindSection(string [] keys, SectionXmlInfo sectionXmlInfo, out int lineNumber) { lineNumber = 0; ConfigXmlReader section = null; try { using (Impersonate()) { using (Stream stream = Host.OpenStreamForRead(sectionXmlInfo.Filename)) { if ( !_flags[SupportsRefresh] && (stream == null || HasStreamChanged(sectionXmlInfo.Filename, sectionXmlInfo.StreamVersion))) { throw new ConfigurationErrorsException(SR.GetString(SR.Config_file_has_changed), sectionXmlInfo.Filename, 0); } if (stream != null) { using (XmlUtil xmlUtil = new XmlUtil(stream, sectionXmlInfo.Filename, true)) { if (sectionXmlInfo.SubPath == null) { section = FindSectionRecursive(keys, 0, xmlUtil, ref lineNumber); } else { // search children of <configuration> for <location> xmlUtil.ReadToNextElement(); while (xmlUtil.Reader.Depth > 0) { if (xmlUtil.Reader.Name == KEYWORD_LOCATION) { bool locationValid = false; string locationSubPathAttribute = xmlUtil.Reader.GetAttribute(KEYWORD_LOCATION_PATH); try { locationSubPathAttribute = NormalizeLocationSubPath(locationSubPathAttribute, xmlUtil); locationValid = true; } catch (ConfigurationException ce) { xmlUtil.SchemaErrors.AddError(ce, ExceptionAction.NonSpecific); } if (locationValid && StringUtil.EqualsIgnoreCase(sectionXmlInfo.SubPath, locationSubPathAttribute)) { section = FindSectionRecursive(keys, 0, xmlUtil, ref lineNumber); if (section != null) break; } } xmlUtil.SkipToNextElement(); } } // Throw accumulated errors ThrowIfParseErrors(xmlUtil.SchemaErrors); } } } } } // Don't allow frames up the stack to run exception filters while impersonated. catch { throw; } return section; }
private void UpdateRecords() { if (base._factoryRecords != null) { foreach (FactoryRecord record in base._factoryRecords.Values) { if (string.IsNullOrEmpty(record.Filename)) { record.Filename = base.ConfigStreamInfo.StreamName; } record.LineNumber = 0; ConfigurationSection configSection = this.GetConfigSection(record.ConfigKey); if (configSection != null) { if (configSection.SectionInformation.Type != null) { record.FactoryTypeName = configSection.SectionInformation.Type; } record.AllowLocation = configSection.SectionInformation.AllowLocation; record.RestartOnExternalChanges = configSection.SectionInformation.RestartOnExternalChanges; record.RequirePermission = configSection.SectionInformation.RequirePermission; record.AllowDefinition = configSection.SectionInformation.AllowDefinition; record.AllowExeDefinition = configSection.SectionInformation.AllowExeDefinition; } } } if (base._sectionRecords != null) { string definitionConfigPath = base.IsLocationConfig ? base._parent.ConfigPath : base.ConfigPath; foreach (SectionRecord record2 in base._sectionRecords.Values) { string configSource; string configSourceStreamName; object obj2; ConfigurationSection result; if (record2.HasResult) { result = (ConfigurationSection) record2.Result; configSource = result.SectionInformation.ConfigSource; if (string.IsNullOrEmpty(configSource)) { configSource = null; } configSourceStreamName = result.SectionInformation.ConfigSourceStreamName; if (string.IsNullOrEmpty(configSourceStreamName)) { configSourceStreamName = null; } } else { result = null; configSource = null; configSourceStreamName = null; if (record2.HasFileInput) { SectionXmlInfo sectionXmlInfo = record2.FileInput.SectionXmlInfo; configSource = sectionXmlInfo.ConfigSource; configSourceStreamName = sectionXmlInfo.ConfigSourceStreamName; } } if (!string.IsNullOrEmpty(configSource)) { obj2 = base.MonitorStream(record2.ConfigKey, configSource, configSourceStreamName); } else { obj2 = null; } if (!record2.HasResult) { if (record2.HasFileInput) { SectionXmlInfo info2 = record2.FileInput.SectionXmlInfo; info2.StreamVersion = base.ConfigStreamInfo.StreamVersion; info2.ConfigSourceStreamVersion = obj2; } } else { result.SectionInformation.RawXml = null; bool addUpdate = record2.AddUpdate; record2.AddUpdate = false; if (addUpdate) { SectionInput fileInput = record2.FileInput; if (fileInput == null) { SectionXmlInfo info3 = new SectionXmlInfo(record2.ConfigKey, definitionConfigPath, base._configPath, base._locationSubPath, base.ConfigStreamInfo.StreamName, 0, base.ConfigStreamInfo.StreamVersion, null, configSource, configSourceStreamName, obj2, result.SectionInformation.ProtectionProviderName, result.SectionInformation.OverrideModeSetting, !result.SectionInformation.InheritInChildApplications); fileInput = new SectionInput(info3, null) { Result = result, ResultRuntimeObject = result }; record2.AddFileInput(fileInput); } else { SectionXmlInfo info4 = fileInput.SectionXmlInfo; info4.LineNumber = 0; info4.StreamVersion = base.ConfigStreamInfo.StreamVersion; info4.RawXml = null; info4.ConfigSource = configSource; info4.ConfigSourceStreamName = configSourceStreamName; info4.ConfigSourceStreamVersion = obj2; info4.ProtectionProviderName = result.SectionInformation.ProtectionProviderName; info4.OverrideModeSetting = result.SectionInformation.OverrideModeSetting; info4.SkipInChildApps = !result.SectionInformation.InheritInChildApplications; } fileInput.ProtectionProvider = result.SectionInformation.ProtectionProvider; } try { result.ResetModified(); } catch (Exception exception) { throw new ConfigurationErrorsException(System.Configuration.SR.GetString("Config_exception_in_config_section_handler", new object[] { record2.ConfigKey }), exception, base.ConfigStreamInfo.StreamName, 0); } } } } foreach (StreamInfo info5 in this._streamInfoUpdates.Values) { if (!base.ConfigStreamInfo.StreamInfos.Contains(info5.StreamName)) { base.MonitorStream(info5.SectionName, info5.ConfigSource, info5.StreamName); } } this.InitStreamInfoUpdates(); this._flags[0x200] = this._flags[0x4000000]; this._flags[0x1000000] = false; this._flags[0x2000000] = false; if ((!base.IsLocationConfig && (base._locationSections != null)) && ((this._removedSections != null) && (this._removedSections.Count > 0))) { int index = 0; while (index < base._locationSections.Count) { LocationSectionRecord record3 = (LocationSectionRecord) base._locationSections[index]; if (this._removedSections.Contains(record3.ConfigKey)) { base._locationSections.RemoveAt(index); } else { index++; } } } this._removedSections = null; this._removedSectionGroups = null; }