internal XmlUtil(Stream stream, string name, bool readToFirstElement, ConfigurationSchemaErrors schemaErrors) { try { Filename = name; _stream = stream; Reader = new XmlTextReader(_stream) { XmlResolver = null }; // config reads never require a resolver SchemaErrors = schemaErrors; _lastLineNumber = 1; _lastLinePosition = 1; // When parsing config that we don't intend to copy, skip all content // before the first element. if (!readToFirstElement) { return; } Reader.WhitespaceHandling = WhitespaceHandling.None; bool done = false; while (!done && Reader.Read()) { switch (Reader.NodeType) { case XmlNodeType.XmlDeclaration: case XmlNodeType.Comment: case XmlNodeType.DocumentType: break; case XmlNodeType.Element: done = true; break; default: throw new ConfigurationErrorsException(SR.Config_base_unrecognized_element, this); } } } catch { ReleaseResources(); throw; } }
internal XmlUtil(Stream stream, string name, bool readToFirstElement, ConfigurationSchemaErrors schemaErrors) { try { _streamName = name; _stream = stream; _reader = XmlReader.Create(_stream); // config reads never require a resolver // _reader.XmlResolver = null; _schemaErrors = schemaErrors; _lastLineNumber = 1; _lastLinePosition = 1; // // When parsing config that we don't intend to copy, skip all content // before the first element. // if (readToFirstElement) { // _reader.WhitespaceHandling = WhitespaceHandling.None; bool done = false; while (!done && _reader.Read()) { switch (_reader.NodeType) { case XmlNodeType.XmlDeclaration: case XmlNodeType.Comment: case XmlNodeType.DocumentType: break; case XmlNodeType.Element: done = true; break; default: throw new ConfigurationErrorsException(SR.GetString(SR.Config_base_unrecognized_element), this); } } } } catch { ReleaseResources(); throw; } }
internal XmlUtil(Stream stream, string name, bool readToFirstElement, ConfigurationSchemaErrors schemaErrors) { try { this._streamName = name; this._stream = stream; this._reader = new XmlTextReader(this._stream); this._reader.XmlResolver = null; this._schemaErrors = schemaErrors; this._lastLineNumber = 1; this._lastLinePosition = 1; if (readToFirstElement) { this._reader.WhitespaceHandling = WhitespaceHandling.None; bool flag = false; while (!flag && this._reader.Read()) { switch (this._reader.NodeType) { case XmlNodeType.Comment: case XmlNodeType.DocumentType: case XmlNodeType.XmlDeclaration: { continue; } case XmlNodeType.Element: { flag = true; continue; } } throw new ConfigurationErrorsException(System.Configuration.SR.GetString("Config_base_unrecognized_element"), this); } } } catch { this.ReleaseResources(); throw; } }
// RefreshFactoryRecord // // Refresh the Factory Record for a particular section. // private void RefreshFactoryRecord(string configKey) { Hashtable factoryList = null; FactoryRecord factoryRecord = null; ConfigurationSchemaErrors errors; errors = new ConfigurationSchemaErrors(); // Get Updated Factory List from File int lineNumber = 0; try { using (Impersonate()) { using (Stream stream = Host.OpenStreamForRead(ConfigStreamInfo.StreamName)) { if (stream != null) { ConfigStreamInfo.HasStream = true; using (XmlUtil xmlUtil = new XmlUtil(stream, ConfigStreamInfo.StreamName, true, errors)) { try { factoryList = ScanFactories(xmlUtil); ThrowIfParseErrors(xmlUtil.SchemaErrors); } catch { lineNumber = xmlUtil.LineNumber; throw; } } } } } // Add implicit sections to the factory list if (factoryList == null) { // But if factoryList isn't found in this config, we still try to // add implicit sections to an empty factoryList. factoryList = new Hashtable(); } AddImplicitSections(factoryList); if (factoryList != null) { factoryRecord = (FactoryRecord) factoryList[configKey]; } } // // Guarantee that exceptions contain the name of the stream and an approximate line number if available. // // And don't allow frames up the stack to run exception filters while impersonated. catch (Exception e) { errors.AddError( ExceptionUtil.WrapAsConfigException(SR.GetString(SR.Config_error_loading_XML_file), e, ConfigStreamInfo.StreamName, lineNumber), ExceptionAction.Global); } catch { errors.AddError( ExceptionUtil.WrapAsConfigException(SR.GetString(SR.Config_error_loading_XML_file), null, ConfigStreamInfo.StreamName, lineNumber), ExceptionAction.Global); } // Set/Add/Remove Record // Note that the _factoryRecords hashtable is protected by the hierarchy lock. if (factoryRecord != null || HasFactoryRecords) { EnsureFactories()[configKey] = factoryRecord; } // Throw accumulated errors ThrowIfParseErrors(errors); }
// ThrowIfParseErrors // // Throw if there were parse errors detected // private void ThrowIfParseErrors(ConfigurationSchemaErrors schemaErrors) { schemaErrors.ThrowIfErrors(ClassFlags[ClassIgnoreLocalErrors]); }
internal void Init( IInternalConfigRoot configRoot, BaseConfigurationRecord parent, string configPath, string locationSubPath) { _initErrors = new ConfigurationSchemaErrors(); // // try/catch here is only for unexpected exceptions due to errors in // our own code, as we always want the configuration record to be // usable // try { _configRoot = (InternalConfigRoot) configRoot; _parent = parent; _configPath = configPath; _locationSubPath = locationSubPath; _configName = ConfigPathUtility.GetName(configPath); if (IsLocationConfig) { _configStreamInfo = _parent.ConfigStreamInfo; } else { _configStreamInfo = new ConfigRecordStreamInfo(); } // no more initialization in case of root config if (IsRootConfig) return; // determine what features we support _flags[SupportsChangeNotifications] = ClassFlags[ClassSupportsChangeNotifications] && Host.SupportsChangeNotifications; _flags[SupportsRefresh] = ClassFlags[ClassSupportsRefresh] && Host.SupportsRefresh; _flags[SupportsKeepInputs] = ClassFlags[ClassSupportsKeepInputs] || _flags[SupportsRefresh]; _flags[SupportsPath] = Host.SupportsPath; _flags[SupportsLocation] = Host.SupportsLocation; // get static state based on the configPath if (_flags[SupportsLocation]) { _flags[IsAboveApplication] = Host.IsAboveApplication(_configPath); } _flags[IsTrusted] = Host.IsTrustedConfigPath(_configPath); ArrayList locationSubPathInputs = null; if (_flags[SupportsLocation]) { // // Treat location inputs from parent record // as though they were bonafide sections in this record. // if (IsLocationConfig && _parent._locationSections != null) { // Resolve paths and check for errors in location sections. _parent.ResolveLocationSections(); int i = 0; while (i < _parent._locationSections.Count) { LocationSectionRecord locationSectionRecord = (LocationSectionRecord) _parent._locationSections[i]; if (!StringUtil.EqualsIgnoreCase(locationSectionRecord.SectionXmlInfo.SubPath, _locationSubPath)) { i++; } else { // remove the locationSectionRecord from the list _parent._locationSections.RemoveAt(i); if (locationSubPathInputs == null) { locationSubPathInputs = new ArrayList(); } locationSubPathInputs.Add(locationSectionRecord); } } } // // Add location inputs that apply to this path, all the way up the parent hierarchy. // if (Host.IsLocationApplicable(_configPath)) { BaseConfigurationRecord current = _parent; while (!current.IsRootConfig) { if (current._locationSections != null) { current.ResolveLocationSections(); foreach (LocationSectionRecord locationSectionRecord in current._locationSections) { // We use the location tag input if: // - The path matches, and // - It's not skipped due to inheritInChildApplications setting. if (StringUtil.EqualsIgnoreCase(locationSectionRecord.SectionXmlInfo.TargetConfigPath, this._configPath) && !ShouldSkipDueToInheritInChildApplications(locationSectionRecord.SectionXmlInfo.SkipInChildApps)) { // add the location input for this section SectionRecord sectionRecord = EnsureSectionRecord(locationSectionRecord.ConfigKey, true); SectionInput sectionInput = new SectionInput( locationSectionRecord.SectionXmlInfo, locationSectionRecord.ErrorsList); sectionRecord.AddLocationInput(sectionInput); // copy the initialization errors to the record if (locationSectionRecord.HasErrors) { this._initErrors.AddSavedLocalErrors(locationSectionRecord.Errors); } } } } current = current._parent; } } } if (!IsLocationConfig) { // // If config file exists, open it and parse it once so we can // find what to evaluate later. // InitConfigFromFile(); } else { // Add location sections for this record as bonafide sections. if (locationSubPathInputs != null) { foreach (LocationSectionRecord locationSectionRecord in locationSubPathInputs) { // add the file input SectionRecord sectionRecord = EnsureSectionRecord(locationSectionRecord.ConfigKey, true); SectionInput sectionInput = new SectionInput(locationSectionRecord.SectionXmlInfo, locationSectionRecord.ErrorsList); sectionRecord.AddFileInput(sectionInput); // copy the initialization errors to the record if (locationSectionRecord.HasErrors) { this._initErrors.AddSavedLocalErrors(locationSectionRecord.Errors); } } } } } // // Capture all exceptions and include them in initialization errors. // catch (Exception e) { string streamname = (ConfigStreamInfo != null) ? ConfigStreamInfo.StreamName : null; _initErrors.AddError( ExceptionUtil.WrapAsConfigException(SR.GetString(SR.Config_error_loading_XML_file), e, streamname, 0), ExceptionAction.Global); } catch { string streamname = (ConfigStreamInfo != null) ? ConfigStreamInfo.StreamName : null; _initErrors.AddError( ExceptionUtil.WrapAsConfigException(SR.GetString(SR.Config_error_loading_XML_file), null, streamname, 0), ExceptionAction.Global); } }