We need you! We're working hard on the next version of Developer Fusion - Let us know what you think we should be up to!

The Labs \ Source Viewer \ SSCLI \ System.Configuration \ ClientSettingsConfigurationHost

SSCLI
  1. //------------------------------------------------------------------------------
  2. // <copyright file="ClientSettingsStore.cs" company="Microsoft">
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. // </copyright>
  14. //------------------------------------------------------------------------------
  16. using System.Diagnostics.CodeAnalysis;
  18. [assembly: SuppressMessage("Microsoft.Reliability", "CA2000:DisposeObjectsBeforeLosingScope", Scope = "member", Target = "System.Configuration.ClientSettingsStore+QuotaEnforcedStream.Dispose(System.Boolean):System.Void")]
  20. namespace System.Configuration
  21. {
  22.     using System;
  23.     using System.Collections;
  24.     using System.Collections.Specialized;
  25.     using System.Configuration;
  26.     using System.Configuration.Internal;
  27.     using System.Configuration.Provider;
  28.     using System.Diagnostics;
  29.     using System.IO;
  30.     using System.Security;
  31.     using System.Security.Permissions;
  32.     using System.Xml;
  33.    
  34.    
  35.     /// <devdoc>
  36.     /// This class abstracts the details of config system away from the LocalFileSettingsProvider. It talks to
  37.     /// the configuration API and the relevant Sections to read and write settings.
  38.     /// It understands sections of type ClientSettingsSection.
  39.     ///
  40.     /// NOTE: This API supports reading from app.exe.config and user.config, but writing only to
  41.     /// user.config.
  42.     /// </devdoc>
  43.     internal sealed class ClientSettingsStore
  44.     {
  45.         private const string ApplicationSettingsGroupName = "applicationSettings";
  46.         private const string UserSettingsGroupName = "userSettings";
  47.         private const string ApplicationSettingsGroupPrefix = ApplicationSettingsGroupName + "/";
  48.         private const string UserSettingsGroupPrefix = UserSettingsGroupName + "/";
  49.        
  50.         private Configuration GetUserConfig(bool isRoaming)
  51.         {
  52.             ConfigurationUserLevel userLevel = isRoaming ? ConfigurationUserLevel.PerUserRoaming : ConfigurationUserLevel.PerUserRoamingAndLocal;
  53.            
  54.             return ClientSettingsConfigurationHost.OpenExeConfiguration(userLevel);
  55.         }
  56.        
  57.         private ClientSettingsSection GetConfigSection(Configuration config, string sectionName, bool declare)
  58.         {
  59.             string fullSectionName = UserSettingsGroupPrefix + sectionName;
  60.             ClientSettingsSection section = null;
  61.            
  62.             if (config != null) {
  63.                 section = config.GetSection(fullSectionName) as ClientSettingsSection;
  64.                
  65.                 if (section == null && declare) {
  66.                     // Looks like the section isn't declared - let's declare it and try again.
  67.                     DeclareSection(config, sectionName);
  68.                     section = config.GetSection(fullSectionName) as ClientSettingsSection;
  69.                 }
  70.             }
  71.            
  72.             return section;
  73.         }
  74.        
  75.         // Declares the section handler of a given section in its section group, if a declaration isn't already
  76.         // present.
  77.         private void DeclareSection(Configuration config, string sectionName)
  78.         {
  79.             ConfigurationSectionGroup settingsGroup = config.GetSectionGroup(UserSettingsGroupName);
  80.            
  81.             if (settingsGroup == null) {
  82.                 //Declare settings group
  83.                 ConfigurationSectionGroup group = new UserSettingsGroup();
  84.                 config.SectionGroups.Add(UserSettingsGroupName, group);
  85.             }
  86.            
  87.             settingsGroup = config.GetSectionGroup(UserSettingsGroupName);
  88.            
  89.             Debug.Assert(settingsGroup != null, "Failed to declare settings group");
  90.            
  91.             if (settingsGroup != null) {
  92.                 ConfigurationSection section = settingsGroup.Sections[sectionName];
  93.                 if (section == null) {
  94.                     section = new ClientSettingsSection();
  95.                     section.SectionInformation.AllowExeDefinition = ConfigurationAllowExeDefinition.MachineToLocalUser;
  96.                     section.SectionInformation.RequirePermission = false;
  97.                     settingsGroup.Sections.Add(sectionName, section);
  98.                 }
  99.             }
  100.         }
  101.        
  102.         internal IDictionary ReadSettings(string sectionName, bool isUserScoped)
  103.         {
  104.             IDictionary settings = new Hashtable();
  105.            
  106.             if (isUserScoped && !ConfigurationManagerInternalFactory.Instance.SupportsUserConfig) {
  107.                 return settings;
  108.             }
  109.            
  110.             string prefix = isUserScoped ? UserSettingsGroupPrefix : ApplicationSettingsGroupPrefix;
  111.             ConfigurationManager.RefreshSection(prefix + sectionName);
  112.             ClientSettingsSection section = ConfigurationManager.GetSection(prefix + sectionName) as ClientSettingsSection;
  113.            
  114.             if (section != null) {
  115.                 foreach (SettingElement setting in section.Settings) {
  116.                     settings[setting.Name] = new StoredSetting(setting.SerializeAs, setting.Value.ValueXml);
  117.                 }
  118.             }
  119.            
  120.             return settings;
  121.         }
  122.        
  123.         static internal IDictionary ReadSettingsFromFile(string configFileName, string sectionName, bool isUserScoped)
  124.         {
  125.             IDictionary settings = new Hashtable();
  126.            
  127.             if (isUserScoped && !ConfigurationManagerInternalFactory.Instance.SupportsUserConfig) {
  128.                 return settings;
  129.             }
  130.            
  131.             string prefix = isUserScoped ? UserSettingsGroupPrefix : ApplicationSettingsGroupPrefix;
  132.             ExeConfigurationFileMap fileMap = new ExeConfigurationFileMap();
  133.            
  134.             // NOTE: When isUserScoped is true, we don't care if configFileName represents a roaming file or
  135.             // a local one. All we want is three levels of configuration. So, we use the PerUserRoaming level.
  136.             ConfigurationUserLevel userLevel = isUserScoped ? ConfigurationUserLevel.PerUserRoaming : ConfigurationUserLevel.None;
  137.            
  138.             if (isUserScoped) {
  139.                 fileMap.ExeConfigFilename = ConfigurationManagerInternalFactory.Instance.ApplicationConfigUri;
  140.                 fileMap.RoamingUserConfigFilename = configFileName;
  141.             }
  142.             else {
  143.                 fileMap.ExeConfigFilename = configFileName;
  144.             }
  145.            
  146.             Configuration config = ConfigurationManager.OpenMappedExeConfiguration(fileMap, userLevel);
  147.             ClientSettingsSection section = config.GetSection(prefix + sectionName) as ClientSettingsSection;
  148.            
  149.             if (section != null) {
  150.                 foreach (SettingElement setting in section.Settings) {
  151.                     settings[setting.Name] = new StoredSetting(setting.SerializeAs, setting.Value.ValueXml);
  152.                 }
  153.             }
  154.            
  155.             return settings;
  156.         }
  157.        
  158.         internal ConnectionStringSettingsCollection ReadConnectionStrings()
  159.         {
  160.             return PrivilegedConfigurationManager.ConnectionStrings;
  161.         }
  162.        
  163.         internal void RevertToParent(string sectionName, bool isRoaming)
  164.         {
  165.             if (!ConfigurationManagerInternalFactory.Instance.SupportsUserConfig) {
  166.                 throw new ConfigurationErrorsException(SR.GetString(SR.UserSettingsNotSupported));
  167.             }
  168.            
  169.             Configuration config = GetUserConfig(isRoaming);
  170.             ClientSettingsSection section = GetConfigSection(config, sectionName, false);
  171.            
  172.             // If the section is null, there is nothing to revert.
  173.             if (section != null) {
  174.                 section.SectionInformation.RevertToParent();
  175.                 config.Save();
  176.             }
  177.         }
  178.        
  179.         internal void WriteSettings(string sectionName, bool isRoaming, IDictionary newSettings)
  180.         {
  181.             if (!ConfigurationManagerInternalFactory.Instance.SupportsUserConfig) {
  182.                 throw new ConfigurationErrorsException(SR.GetString(SR.UserSettingsNotSupported));
  183.             }
  184.            
  185.             Configuration config = GetUserConfig(isRoaming);
  186.             ClientSettingsSection section = GetConfigSection(config, sectionName, true);
  187.            
  188.             if (section != null) {
  189.                 SettingElementCollection sec = section.Settings;
  190.                 foreach (DictionaryEntry entry in newSettings) {
  191.                     SettingElement se = sec.Get((string)entry.Key);
  192.                    
  193.                     if (se == null) {
  194.                         se = new SettingElement();
  195.                         se.Name = (string)entry.Key;
  196.                         sec.Add(se);
  197.                     }
  198.                    
  199.                     StoredSetting ss = (StoredSetting)entry.Value;
  200.                     se.SerializeAs = ss.SerializeAs;
  201.                     se.Value.ValueXml = ss.Value;
  202.                 }
  203.                
  204.                 try {
  205.                     config.Save();
  206.                 }
  207.                 catch (ConfigurationErrorsException ex) {
  208.                     // We wrap this in an exception with our error message and throw again.
  209.                     throw new ConfigurationErrorsException(SR.GetString(SR.SettingsSaveFailed, ex.Message), ex);
  210.                 }
  211.             }
  212.             else {
  213.                 throw new ConfigurationErrorsException(SR.GetString(SR.SettingsSaveFailedNoSection));
  214.             }
  215.         }
  216.        
  217.         /// <devdoc>
  218.         /// A private configuration host that we use to write settings to config. We need this so we
  219.         /// can enforce a quota on the size of stuff written out.
  220.         /// </devdoc>
  221.         private sealed class ClientSettingsConfigurationHost : DelegatingConfigHost
  222.         {
  223.             private const string ClientConfigurationHostTypeName = "System.Configuration.ClientConfigurationHost," + AssemblyRef.SystemConfiguration;
  224.             private const string InternalConfigConfigurationFactoryTypeName = "System.Configuration.Internal.InternalConfigConfigurationFactory," + AssemblyRef.SystemConfiguration;
  225.             private static IInternalConfigConfigurationFactory s_configFactory;
  226.            
  227.             /// <devdoc>
  228.             /// ClientConfigurationHost implements this - a way of getting some info from it without
  229.             /// depending too much on its internals.
  230.             /// </devdoc>
  231.             private IInternalConfigClientHost ClientHost {
  232.                 get { return (IInternalConfigClientHost)Host; }
  233.             }
  234.            
  235.             static internal IInternalConfigConfigurationFactory ConfigFactory {
  236.                 get {
  237.                     if (s_configFactory == null) {
  238.                         s_configFactory = (IInternalConfigConfigurationFactory)TypeUtil.CreateInstanceWithReflectionPermission(InternalConfigConfigurationFactoryTypeName);
  239.                     }
  240.                     return s_configFactory;
  241.                 }
  242.             }
  243.            
  244.             private ClientSettingsConfigurationHost()
  245.             {
  246.             }
  247.            
  248.             public override void Init(IInternalConfigRoot configRoot, params object[] hostInitParams)
  249.             {
  250.                 Debug.Fail("Did not expect to get called here");
  251.             }
  252.            
  253.             /// <devdoc>
  254.             /// We delegate this to the ClientConfigurationHost. The only thing we need to do here is to
  255.             /// build a configPath from the ConfigurationUserLevel we get passed in.
  256.             /// </devdoc>
  257.             public override void InitForConfiguration(ref string locationSubPath, out string configPath, out string locationConfigPath, IInternalConfigRoot configRoot, params object[] hostInitConfigurationParams)
  258.             {
  259.                
  260.                 ConfigurationUserLevel userLevel = (ConfigurationUserLevel)hostInitConfigurationParams[0];
  261.                 string desiredConfigPath = null;
  262.                 Host = (IInternalConfigHost)TypeUtil.CreateInstanceWithReflectionPermission(ClientConfigurationHostTypeName);
  263.                
  264.                 switch (userLevel) {
  265.                     case ConfigurationUserLevel.None:
  266.                         desiredConfigPath = ClientHost.GetExeConfigPath();
  267.                         break;
  268.                     case ConfigurationUserLevel.PerUserRoaming:
  269.                        
  270.                         desiredConfigPath = ClientHost.GetRoamingUserConfigPath();
  271.                         break;
  272.                     case ConfigurationUserLevel.PerUserRoamingAndLocal:
  273.                        
  274.                         desiredConfigPath = ClientHost.GetLocalUserConfigPath();
  275.                         break;
  276.                     default:
  277.                        
  278.                         throw new ArgumentException(SR.GetString(SR.UnknownUserLevel));
  279.                         break;
  280.                 }
  281.                
  282.                
  283.                 Host.InitForConfiguration(ref locationSubPath, out configPath, out locationConfigPath, configRoot, null, null, desiredConfigPath);
  284.             }
  285.            
  286.             private bool IsKnownConfigFile(string filename)
  287.             {
  288.                 return String.Equals(filename, ConfigurationManagerInternalFactory.Instance.MachineConfigPath, StringComparison.OrdinalIgnoreCase) || String.Equals(filename, ConfigurationManagerInternalFactory.Instance.ApplicationConfigUri, StringComparison.OrdinalIgnoreCase) || String.Equals(filename, ConfigurationManagerInternalFactory.Instance.ExeLocalConfigPath, StringComparison.OrdinalIgnoreCase) || String.Equals(filename, ConfigurationManagerInternalFactory.Instance.ExeRoamingConfigPath, StringComparison.OrdinalIgnoreCase);
  289.                
  290.             }
  291.            
  292.             static internal Configuration OpenExeConfiguration(ConfigurationUserLevel userLevel)
  293.             {
  294.                 return ConfigFactory.Create(typeof(ClientSettingsConfigurationHost), userLevel);
  295.             }
  296.            
  297.             /// <devdoc>
  298.             /// If the stream we are asked for represents a config file that we know about, we ask
  299.             /// the host to assert appropriate permissions.
  300.             /// </devdoc>
  301.             public override Stream OpenStreamForRead(string streamName)
  302.             {
  303.                 if (IsKnownConfigFile(streamName)) {
  304.                     return Host.OpenStreamForRead(streamName, true);
  305.                 }
  306.                 else {
  307.                     return Host.OpenStreamForRead(streamName);
  308.                 }
  309.             }
  310.            
  311.             /// <devdoc>
  312.             /// If the stream we are asked for represents a user.config file that we know about, we wrap it in a
  313.             /// QuotaEnforcedStream, after asking the host to assert appropriate permissions.///
  314.             /// </devdoc>
  315.             public override Stream OpenStreamForWrite(string streamName, string templateStreamName, ref object writeContext)
  316.             {
  317.                 Stream stream = null;
  318.                
  319.                 if (String.Equals(streamName, ConfigurationManagerInternalFactory.Instance.ExeLocalConfigPath, StringComparison.OrdinalIgnoreCase)) {
  320.                     stream = new QuotaEnforcedStream(Host.OpenStreamForWrite(streamName, templateStreamName, ref writeContext, true), false);
  321.                 }
  322.                 else if (String.Equals(streamName, ConfigurationManagerInternalFactory.Instance.ExeRoamingConfigPath, StringComparison.OrdinalIgnoreCase)) {
  323.                     stream = new QuotaEnforcedStream(Host.OpenStreamForWrite(streamName, templateStreamName, ref writeContext, true), true);
  324.                 }
  325.                 else {
  326.                     stream = Host.OpenStreamForWrite(streamName, templateStreamName, ref writeContext);
  327.                 }
  328.                
  329.                 return stream;
  330.             }
  331.            
  332.             /// <devdoc>
  333.             /// If this is a stream that represents a user.config file that we know about, we ask
  334.             /// the host to assert appropriate permissions.
  335.             /// </devdoc>
  336.             public override void WriteCompleted(string streamName, bool success, object writeContext)
  337.             {
  338.                 if (String.Equals(streamName, ConfigurationManagerInternalFactory.Instance.ExeLocalConfigPath, StringComparison.OrdinalIgnoreCase) || String.Equals(streamName, ConfigurationManagerInternalFactory.Instance.ExeRoamingConfigPath, StringComparison.OrdinalIgnoreCase)) {
  339.                    
  340.                     Host.WriteCompleted(streamName, success, writeContext, true);
  341.                 }
  342.                 else {
  343.                     Host.WriteCompleted(streamName, success, writeContext);
  344.                 }
  345.             }
  346.         }
  347.        
  348.         /// <devdoc>
  349.         /// A private stream class that wraps a stream and enforces a quota. The quota enforcement uses
  350.         /// IsolatedStorageFilePermission. We override nearly all methods on the Stream class so we can
  351.         /// forward to the wrapped stream. In the methods that affect stream length, we verify that the
  352.         /// quota is respected before forwarding.
  353.         /// </devdoc>
  354.         private sealed class QuotaEnforcedStream : Stream
  355.         {
  356.             private Stream _originalStream;
  357.             private bool _isRoaming;
  358.            
  359.             internal QuotaEnforcedStream(Stream originalStream, bool isRoaming)
  360.             {
  361.                 _originalStream = originalStream;
  362.                 _isRoaming = isRoaming;
  363.                
  364.                 Debug.Assert(_originalStream != null, "originalStream was null.");
  365.             }
  366.            
  367.             public override bool CanRead {
  368.                 get { return _originalStream.CanRead; }
  369.             }
  370.            
  371.             public override bool CanWrite {
  372.                 get { return _originalStream.CanWrite; }
  373.             }
  374.            
  375.             public override bool CanSeek {
  376.                 get { return _originalStream.CanSeek; }
  377.             }
  378.            
  379.             public override long Length {
  380.                 get { return _originalStream.Length; }
  381.             }
  382.            
  383.             public override long Position {
  384.                
  385.                 get { return _originalStream.Position; }
  386.                
  387.                 set {
  388.                     if (value < 0) {
  389.                         throw new ArgumentOutOfRangeException("value", SR.GetString(SR.PositionOutOfRange));
  390.                     }
  391.                    
  392.                     Seek(value, SeekOrigin.Begin);
  393.                 }
  394.             }
  395.            
  396.             public override void Close()
  397.             {
  398.                 _originalStream.Close();
  399.             }
  400.            
  401.             protected override void Dispose(bool disposing)
  402.             {
  403.                 if (disposing) {
  404.                     if (_originalStream != null) {
  405.                         ((IDisposable)_originalStream).Dispose();
  406.                         _originalStream = null;
  407.                     }
  408.                    
  409.                 }
  410.                
  411.                 base.Dispose(disposing);
  412.             }
  413.            
  414.             public override void Flush()
  415.             {
  416.                 _originalStream.Flush();
  417.             }
  418.            
  419.             public override void SetLength(long value)
  420.             {
  421.                 long oldLen = _originalStream.Length;
  422.                 long newLen = value;
  423.                
  424.                 EnsureQuota(Math.Max(oldLen, newLen));
  425.                 _originalStream.SetLength(value);
  426.             }
  427.            
  428.             public override int Read(byte[] buffer, int offset, int count)
  429.             {
  430.                 return _originalStream.Read(buffer, offset, count);
  431.             }
  432.            
  433.             public override int ReadByte()
  434.             {
  435.                 return _originalStream.ReadByte();
  436.             }
  437.            
  438.             public override long Seek(long offset, SeekOrigin origin)
  439.             {
  440.                 if (!CanSeek) {
  441.                     throw new NotSupportedException();
  442.                 }
  443.                
  444.                 long oldLen = _originalStream.Length;
  445.                 long newLen;
  446.                
  447.                 switch (origin) {
  448.                     case SeekOrigin.Begin:
  449.                         newLen = offset;
  450.                         break;
  451.                     case SeekOrigin.Current:
  452.                         newLen = _originalStream.Position + offset;
  453.                         break;
  454.                     case SeekOrigin.End:
  455.                         newLen = oldLen + offset;
  456.                         break;
  457.                     default:
  458.                         throw new ArgumentException(SR.GetString(SR.UnknownSeekOrigin), "origin");
  459.                         break;
  460.                 }
  461.                
  462.                 EnsureQuota(Math.Max(oldLen, newLen));
  463.                 return _originalStream.Seek(offset, origin);
  464.             }
  465.            
  466.             public override void Write(byte[] buffer, int offset, int count)
  467.             {
  468.                 if (!CanWrite) {
  469.                     throw new NotSupportedException();
  470.                 }
  471.                
  472.                 long oldLen = _originalStream.Length;
  473.                 long newLen = _originalStream.CanSeek ? _originalStream.Position + (long)count : _originalStream.Length + (long)count;
  474.                 EnsureQuota(Math.Max(oldLen, newLen));
  475.                 _originalStream.Write(buffer, offset, count);
  476.             }
  477.            
  478.             public override void WriteByte(byte value)