internal StreamInfo Clone() {
StreamInfo clone = new StreamInfo();
clone._sectionName = this._sectionName;
clone._configSource = this._configSource;
clone._streamName = this._streamName;
clone._isMonitored = this._isMonitored;
clone._version = this._version;
return clone;
}
//
// Set the configSource attribute on a ConfigurationSection
//
internal void ChangeConfigSource(
SectionInformation sectionInformation,
string oldConfigSource,
string oldConfigSourceStreamName,
string newConfigSource) {
if (String.IsNullOrEmpty(oldConfigSource)) {
oldConfigSource = null;
}
if (String.IsNullOrEmpty(newConfigSource)) {
newConfigSource = null;
}
// Check if there is a change to config source
if (StringUtil.EqualsIgnoreCase(oldConfigSource, newConfigSource))
return;
if (String.IsNullOrEmpty(ConfigStreamInfo.StreamName)) {
throw new ConfigurationErrorsException(SR.GetString(SR.Config_source_requires_file));
}
string newConfigSourceStreamName = null;
if (newConfigSource != null) {
newConfigSourceStreamName = Host.GetStreamNameForConfigSource(ConfigStreamInfo.StreamName, newConfigSource);
}
// Add the stream to the updates
if (newConfigSourceStreamName != null) {
//
// Ensure that no parent is using the same config source stream
//
ValidateUniqueChildConfigSource(sectionInformation.ConfigKey, newConfigSourceStreamName, newConfigSource, null);
StreamInfo streamInfo = (StreamInfo) _streamInfoUpdates[newConfigSourceStreamName];
if (streamInfo != null) {
//
// Detect if another section in this file is using the same configSource
// with has a different section name.
//
if (streamInfo.SectionName != sectionInformation.ConfigKey) {
throw new ConfigurationErrorsException(
SR.GetString(SR.Config_source_cannot_be_shared, newConfigSource));
}
}
else {
//
// Add stream to updates
//
streamInfo = new StreamInfo(sectionInformation.ConfigKey, newConfigSource, newConfigSourceStreamName);
_streamInfoUpdates.Add(newConfigSourceStreamName, streamInfo);
}
}
// remove old streamname if no longer referenced
if (oldConfigSourceStreamName != null && !IsStreamUsed(oldConfigSourceStreamName)) {
_streamInfoUpdates.Remove(oldConfigSourceStreamName);
}
// update the configSourceStreamName
sectionInformation.ConfigSourceStreamName = newConfigSourceStreamName;
}
//
// Update the config file with the changes in each ConfigurationSection
//
internal void SaveAs(string filename, ConfigurationSaveMode saveMode, bool forceUpdateAll) {
// Get the updates.
SectionUpdates declarationUpdates = GetConfigDeclarationUpdates(saveMode, forceUpdateAll);
ConfigDefinitionUpdates definitionUpdates;
ArrayList configSourceUpdates;
bool checkedConfigForUpdates = false;
bool requireUpdates = (filename != null);
GetConfigDefinitionUpdates(requireUpdates, saveMode, forceUpdateAll, out definitionUpdates, out configSourceUpdates);
if (filename != null) {
Debug.Assert(filename.Length > 0, "The caller should make sure that filename is not empty");
//
// Verify that the filename is not being used.
//
// Note that if we are using a remote host, all the streamName's in _streamInfoUpdates
// are actually fullpaths on the remote machine. In this case there is no way to
// detect if we have a conflict or not.
if (!Host.IsRemote && _streamInfoUpdates.Contains(filename)) {
throw new ArgumentException(SR.GetString(SR.Filename_in_SaveAs_is_used_already, filename));
}
//
// If there was no config file for this config record,
// record the new stream name and version.
//
if (String.IsNullOrEmpty(ConfigStreamInfo.StreamName)) {
StreamInfo streamInfo = new StreamInfo(null, null, filename);
_streamInfoUpdates.Add(filename, streamInfo);
ConfigStreamInfo.StreamName = filename;
ConfigStreamInfo.StreamVersion = MonitorStream(null, null, ConfigStreamInfo.StreamName);
}
//
// Update the host to redirect filenames
//
UpdateConfigHost.AddStreamname(ConfigStreamInfo.StreamName, filename, Host.IsRemote);
// Redirect also all configSource filenames
foreach (StreamInfo streamInfo in _streamInfoUpdates.Values) {
if (!String.IsNullOrEmpty(streamInfo.SectionName)) {
// Get the new configSource streamName based on the new filename path
string newStreamName = InternalConfigHost.StaticGetStreamNameForConfigSource(
filename, streamInfo.ConfigSource);
// Ask UpdateConfigHost to intercept them.
UpdateConfigHost.AddStreamname(streamInfo.StreamName, newStreamName, Host.IsRemote);
}
}
}
if (!requireUpdates) {
// Check if there are any updates needed for the
// configuration record itself.
requireUpdates = RecordItselfRequiresUpdates;
}
if (declarationUpdates != null || definitionUpdates != null || requireUpdates) {
// Copy the input stream before opening the output stream.
byte[] readBuffer = null;
Encoding encoding = null;
if (ConfigStreamInfo.HasStream) {
using (Stream streamRead = Host.OpenStreamForRead(ConfigStreamInfo.StreamName)) {
if (streamRead == null) {
throw new ConfigurationErrorsException(SR.GetString(SR.Config_file_has_changed), ConfigStreamInfo.StreamName, 0);
}
readBuffer = new byte[streamRead.Length];
int count = streamRead.Read(readBuffer, 0, (int) streamRead.Length);
if (count != streamRead.Length) {
throw new ConfigurationErrorsException(SR.GetString(SR.Config_data_read_count_mismatch));
}
}
// Read the first byte so that we can determine the encoding.
try {
using (StreamReader reader = new StreamReader(ConfigStreamInfo.StreamName)) {
if (reader.Peek() >= 0) {
reader.Read();
}
// Dev10 bug 687017 - Handle only UTF-16 explicitly, so that handling of other
// encodings are not affected.
if (reader.CurrentEncoding is UnicodeEncoding) {
encoding = reader.CurrentEncoding;
}
}
}
catch {
// Ignore any errors, encoding will remain null.
}
}
string changedStreamName = FindChangedConfigurationStream();
if (changedStreamName != null) {
throw new ConfigurationErrorsException(SR.GetString(SR.Config_file_has_changed), changedStreamName, 0);
}
checkedConfigForUpdates = true;
// Write the changes to the output stream.
object writeContext = null;
bool streamOpened = false;
try {
try {
using (Stream streamWrite = Host.OpenStreamForWrite(ConfigStreamInfo.StreamName, null, ref writeContext)) {
streamOpened = true;
// Use the default StreamWriter constructor if encoding is null,
// otherwise specify the encoding.
using (StreamWriter streamWriter = encoding == null ? new StreamWriter(streamWrite) : new StreamWriter(streamWrite, encoding)) {
XmlUtilWriter utilWriter = new XmlUtilWriter(streamWriter, true);
if (ConfigStreamInfo.HasStream) {
CopyConfig(declarationUpdates, definitionUpdates, readBuffer,
ConfigStreamInfo.StreamName, NamespaceChangeNeeded, utilWriter);
}
else {
CreateNewConfig(declarationUpdates, definitionUpdates, NamespaceChangeNeeded, utilWriter);
}
}
}
}
catch {
if (streamOpened) {
Host.WriteCompleted(ConfigStreamInfo.StreamName, false, writeContext);
}
throw;
}
}
//
// Guarantee that exceptions contain at least the name of the stream by wrapping them
// in a ConfigurationException.
//
catch (Exception e) {
throw ExceptionUtil.WrapAsConfigException(SR.GetString(SR.Config_error_loading_XML_file), e, ConfigStreamInfo.StreamName, 0);
}
Host.WriteCompleted(ConfigStreamInfo.StreamName, true, writeContext);
// Update stream information for the config file
ConfigStreamInfo.HasStream = true;
ConfigStreamInfo.ClearStreamInfos();
ConfigStreamInfo.StreamVersion = MonitorStream(null, null, ConfigStreamInfo.StreamName);
}
if (configSourceUpdates != null) {
// If we haven't checked before, check now
if (!checkedConfigForUpdates) {
string changedStreamName = FindChangedConfigurationStream();
if (changedStreamName != null) {
throw new ConfigurationErrorsException(SR.GetString(SR.Config_file_has_changed), changedStreamName, 0);
}
}
// write updates
foreach (DefinitionUpdate update in configSourceUpdates) {
SaveConfigSource(update);
}
}
// Update state to reflect the changes to the config file
UpdateRecords();
}
protected object MonitorStream(string configKey, string configSource, string streamname) {
lock (this) {
if (_flags[Closed]) {
return null;
}
StreamInfo streamInfo = (StreamInfo) ConfigStreamInfo.StreamInfos[streamname];
if (streamInfo != null) {
if (streamInfo.SectionName != configKey) {
throw new ConfigurationErrorsException(SR.GetString(SR.Config_source_cannot_be_shared, streamname));
}
if (streamInfo.IsMonitored) {
return streamInfo.Version;
}
}
else {
streamInfo = new StreamInfo(configKey, configSource, streamname);
ConfigStreamInfo.StreamInfos.Add(streamname, streamInfo);
}
}
//
// Call the host outside the lock to avoid deadlock.
//
object version = Host.GetStreamVersion(streamname);
StreamChangeCallback callbackDelegate = null;
lock (this) {
if (_flags[Closed]) {
return null;
}
StreamInfo streamInfo = (StreamInfo) ConfigStreamInfo.StreamInfos[streamname];
if (streamInfo.IsMonitored) {
return streamInfo.Version;
}
streamInfo.IsMonitored = true;
streamInfo.Version = version;
if (_flags[SupportsChangeNotifications]) {
if (ConfigStreamInfo.CallbackDelegate == null) {
ConfigStreamInfo.CallbackDelegate = new StreamChangeCallback(this.OnStreamChanged);
}
callbackDelegate = ConfigStreamInfo.CallbackDelegate;
}
}
if (_flags[SupportsChangeNotifications]) {
Host.StartMonitoringStreamForChanges(streamname, callbackDelegate);
}
return version;
}
internal void ChangeConfigSource(SectionInformation sectionInformation, string oldConfigSource, string oldConfigSourceStreamName, string newConfigSource)
{
if (string.IsNullOrEmpty(oldConfigSource))
{
oldConfigSource = null;
}
if (string.IsNullOrEmpty(newConfigSource))
{
newConfigSource = null;
}
if (!StringUtil.EqualsIgnoreCase(oldConfigSource, newConfigSource))
{
if (string.IsNullOrEmpty(base.ConfigStreamInfo.StreamName))
{
throw new ConfigurationErrorsException(System.Configuration.SR.GetString("Config_source_requires_file"));
}
string configSourceStreamName = null;
if (newConfigSource != null)
{
configSourceStreamName = base.Host.GetStreamNameForConfigSource(base.ConfigStreamInfo.StreamName, newConfigSource);
}
if (configSourceStreamName != null)
{
base.ValidateUniqueChildConfigSource(sectionInformation.ConfigKey, configSourceStreamName, newConfigSource, null);
StreamInfo info = (StreamInfo) this._streamInfoUpdates[configSourceStreamName];
if (info != null)
{
if (info.SectionName != sectionInformation.ConfigKey)
{
throw new ConfigurationErrorsException(System.Configuration.SR.GetString("Config_source_cannot_be_shared", new object[] { newConfigSource }));
}
}
else
{
info = new StreamInfo(sectionInformation.ConfigKey, newConfigSource, configSourceStreamName);
this._streamInfoUpdates.Add(configSourceStreamName, info);
}
}
if ((oldConfigSourceStreamName != null) && !this.IsStreamUsed(oldConfigSourceStreamName))
{
this._streamInfoUpdates.Remove(oldConfigSourceStreamName);
}
sectionInformation.ConfigSourceStreamName = configSourceStreamName;
}
}
internal void SaveAs(string filename, ConfigurationSaveMode saveMode, bool forceUpdateAll)
{
ConfigDefinitionUpdates updates2;
ArrayList list;
SectionUpdates configDeclarationUpdates = this.GetConfigDeclarationUpdates(saveMode, forceUpdateAll);
bool flag = false;
bool requireUpdates = filename != null;
this.GetConfigDefinitionUpdates(requireUpdates, saveMode, forceUpdateAll, out updates2, out list);
if (filename != null)
{
if (!base.Host.IsRemote && this._streamInfoUpdates.Contains(filename))
{
throw new ArgumentException(System.Configuration.SR.GetString("Filename_in_SaveAs_is_used_already", new object[] { filename }));
}
if (string.IsNullOrEmpty(base.ConfigStreamInfo.StreamName))
{
StreamInfo info = new StreamInfo(null, null, filename);
this._streamInfoUpdates.Add(filename, info);
base.ConfigStreamInfo.StreamName = filename;
base.ConfigStreamInfo.StreamVersion = base.MonitorStream(null, null, base.ConfigStreamInfo.StreamName);
}
this.UpdateConfigHost.AddStreamname(base.ConfigStreamInfo.StreamName, filename, base.Host.IsRemote);
foreach (StreamInfo info2 in this._streamInfoUpdates.Values)
{
if (!string.IsNullOrEmpty(info2.SectionName))
{
string newStreamname = InternalConfigHost.StaticGetStreamNameForConfigSource(filename, info2.ConfigSource);
this.UpdateConfigHost.AddStreamname(info2.StreamName, newStreamname, base.Host.IsRemote);
}
}
}
if (!requireUpdates)
{
requireUpdates = this.RecordItselfRequiresUpdates;
}
if (((configDeclarationUpdates != null) || (updates2 != null)) || requireUpdates)
{
byte[] buffer = null;
Encoding currentEncoding = null;
if (base.ConfigStreamInfo.HasStream)
{
using (Stream stream = base.Host.OpenStreamForRead(base.ConfigStreamInfo.StreamName))
{
if (stream == null)
{
throw new ConfigurationErrorsException(System.Configuration.SR.GetString("Config_file_has_changed"), base.ConfigStreamInfo.StreamName, 0);
}
buffer = new byte[stream.Length];
if (stream.Read(buffer, 0, (int) stream.Length) != stream.Length)
{
throw new ConfigurationErrorsException(System.Configuration.SR.GetString("Config_data_read_count_mismatch"));
}
}
try
{
using (StreamReader reader = new StreamReader(base.ConfigStreamInfo.StreamName))
{
if (reader.Peek() >= 0)
{
reader.Read();
}
if (reader.CurrentEncoding is UnicodeEncoding)
{
currentEncoding = reader.CurrentEncoding;
}
}
}
catch
{
}
}
string str2 = base.FindChangedConfigurationStream();
if (str2 != null)
{
throw new ConfigurationErrorsException(System.Configuration.SR.GetString("Config_file_has_changed"), str2, 0);
}
flag = true;
object writeContext = null;
bool flag3 = false;
try
{
try
{
using (Stream stream2 = base.Host.OpenStreamForWrite(base.ConfigStreamInfo.StreamName, null, ref writeContext))
{
flag3 = true;
using (StreamWriter writer = (currentEncoding == null) ? new StreamWriter(stream2) : new StreamWriter(stream2, currentEncoding))
{
XmlUtilWriter utilWriter = new XmlUtilWriter(writer, true);
if (base.ConfigStreamInfo.HasStream)
{
this.CopyConfig(configDeclarationUpdates, updates2, buffer, base.ConfigStreamInfo.StreamName, this.NamespaceChangeNeeded, utilWriter);
}
else
{
this.CreateNewConfig(configDeclarationUpdates, updates2, this.NamespaceChangeNeeded, utilWriter);
}
}
}
}
catch
{
if (flag3)
{
base.Host.WriteCompleted(base.ConfigStreamInfo.StreamName, false, writeContext);
}
throw;
}
}
catch (Exception exception)
{
throw ExceptionUtil.WrapAsConfigException(System.Configuration.SR.GetString("Config_error_loading_XML_file"), exception, base.ConfigStreamInfo.StreamName, 0);
}
base.Host.WriteCompleted(base.ConfigStreamInfo.StreamName, true, writeContext);
base.ConfigStreamInfo.HasStream = true;
base.ConfigStreamInfo.ClearStreamInfos();
base.ConfigStreamInfo.StreamVersion = base.MonitorStream(null, null, base.ConfigStreamInfo.StreamName);
}
if (list != null)
{
if (!flag)
{
string str3 = base.FindChangedConfigurationStream();
if (str3 != null)
{
throw new ConfigurationErrorsException(System.Configuration.SR.GetString("Config_file_has_changed"), str3, 0);
}
}
foreach (DefinitionUpdate update in list)
{
this.SaveConfigSource(update);
}
}
this.UpdateRecords();
}