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

  1. //------------------------------------------------------------------------------
  2. // <copyright file="ConfigPathUtility.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. //------------------------------------------------------------------------------
  15. namespace System.Configuration
  16. {
  17.    
  18.    
  19.     static internal class ConfigPathUtility
  20.     {
  21.         private const char SeparatorChar = '/';
  22.        
  23.         //
  24.         // A configPath is valid if
  25.         // * It does not start or end with a '/'
  26.         // * It is not null or empty, except in the case of the root configuration record
  27.         // * It does not contain '\'
  28.         // * It does not contain a path component equal to "." or ".."
  29.         //
  30.         // The checks for '\', ".", and ".." are not strictly necessary, but their presence
  31.         // could lead to problems for configuration hosts.
  32.         //
  33.         static internal bool IsValid(string configPath)
  34.         {
  35.             if (String.IsNullOrEmpty(configPath)) {
  36.                 return false;
  37.             }
  38.            
  39.             int start = -1;
  40.             for (int examine = 0; examine <= configPath.Length; examine++) {
  41.                 char ch;
  42.                
  43.                 if (examine < configPath.Length) {
  44.                     ch = configPath[examine];
  45.                 }
  46.                 else {
  47.                     ch = SeparatorChar;
  48.                 }
  49.                
  50.                 // backslash disallowed
  51.                 if (ch == '\\') {
  52.                     return false;
  53.                 }
  54.                
  55.                 if (ch == SeparatorChar) {
  56.                     // double slash disallowed
  57.                     // note this check also purposefully catches starting and ending slash
  58.                     if (examine == start + 1) {
  59.                         return false;
  60.                     }
  61.                    
  62.                     // "." disallowed
  63.                     if (examine == start + 2 && configPath[start + 1] == '.') {
  64.                         return false;
  65.                     }
  66.                    
  67.                     // ".." disallowed
  68.                     if (examine == start + 3 && configPath[start + 1] == '.' && configPath[start + 2] == '.') {
  69.                         return false;
  70.                     }
  71.                    
  72.                     start = examine;
  73.                 }
  74.             }
  75.            
  76.             return true;
  77.         }
  78.        
  79.         static internal string Combine(string parentConfigPath, string childConfigPath)
  80.         {
  81.             Debug.Assert(String.IsNullOrEmpty(parentConfigPath) || IsValid(parentConfigPath), "String.IsNullOrEmpty(parentConfigPath) || IsValid(parentConfigPath)");
  82.             Debug.Assert(String.IsNullOrEmpty(childConfigPath) || IsValid(childConfigPath), "String.IsNullOrEmpty(childConfigPath) || IsValid(childConfigPath)");
  83.            
  84.             if (String.IsNullOrEmpty(parentConfigPath)) {
  85.                 return childConfigPath;
  86.             }
  87.            
  88.             if (String.IsNullOrEmpty(childConfigPath)) {
  89.                 return parentConfigPath;
  90.             }
  91.            
  92.             return parentConfigPath + "/" + childConfigPath;
  93.         }
  94.        
  95.         static internal string[] GetParts(string configPath)
  96.         {
  97.             Debug.Assert(IsValid(configPath), "IsValid(configPath)");
  98.            
  99.             string[] parts = configPath.Split(SeparatorChar);
  100.             return parts;
  101.         }
  102.        
  103.         //
  104.         // Return the last part of a config path, e.g.
  105.         // GetName("MACHINE/WEBROOT/Default Web Site/app") == "app"
  106.         //
  107.         static internal string GetName(string configPath)
  108.         {
  109.             Debug.Assert(String.IsNullOrEmpty(configPath) || IsValid(configPath), "String.IsNullOrEmpty(configPath) || IsValid(configPath)");
  110.            
  111.             if (String.IsNullOrEmpty(configPath)) {
  112.                 return configPath;
  113.             }
  114.            
  115.             int index = configPath.LastIndexOf('/');
  116.             if (index == -1) {
  117.                 return configPath;
  118.             }
  119.            
  120.             Debug.Assert(index != configPath.Length - 1);
  121.             return configPath.Substring(index + 1);
  122.         }
  123.        
  124.         // Avoid unused code warning in System.Configuration by including functions in assembly-specific #defines
  125.     }
  126. }

Developer Fusion