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

  1. //------------------------------------------------------------------------------
  2. // <copyright file="UrlPath.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.     using System.Collections;
  18.     using System.Collections.Specialized;
  19.     using System.Configuration;
  20.     using System.Globalization;
  21.     using System.IO;
  22.     using System.Runtime.InteropServices;
  23.     using System.Security.Permissions;
  24.     using System.Security;
  25.     using System.Text;
  26.     using System.Xml;
  27.     using Microsoft.Win32;
  28.    
  29.     static internal class UrlPath
  30.     {
  31.        
  32.         static internal string GetDirectoryOrRootName(string path)
  33.         {
  34.             string dir;
  35.            
  36.             dir = Path.GetDirectoryName(path);
  37.             if (dir == null) {
  38.                 // dir == null if path = "c:\"
  39.                 dir = Path.GetPathRoot(path);
  40.             }
  41.            
  42.             return dir;
  43.         }
  44.        
  45.         //
  46.         // Determine if subdir is equal to or a subdirectory of dir.
  47.         // For example, c:\mydir\subdir is a subdirectory of c:\mydir
  48.         // Account for optional trailing backslashes.
  49.         //
  50.         static internal bool IsEqualOrSubdirectory(string dir, string subdir)
  51.         {
  52.             if (String.IsNullOrEmpty(dir))
  53.                 return true;
  54.            
  55.             if (String.IsNullOrEmpty(subdir))
  56.                 return false;
  57.            
  58.             //
  59.             // Compare up to but not including trailing backslash
  60.             //
  61.             int lDir = dir.Length;
  62.             if (dir[lDir - 1] == '\\') {
  63.                 lDir -= 1;
  64.             }
  65.            
  66.             int lSubdir = subdir.Length;
  67.             if (subdir[lSubdir - 1] == '\\') {
  68.                 lSubdir -= 1;
  69.             }
  70.            
  71.             if (lSubdir < lDir)
  72.                 return false;
  73.            
  74.             if (String.Compare(dir, 0, subdir, 0, lDir, StringComparison.OrdinalIgnoreCase) != 0)
  75.                 return false;
  76.            
  77.             // Check subdir that character following length of dir is a backslash
  78.             if (lSubdir > lDir && subdir[lDir] != '\\')
  79.                 return false;
  80.            
  81.             return true;
  82.         }
  83.        
  84.         //
  85.         // NOTE: This function is also present in fx\src\xsp\system\web\util\urlpath.cs
  86.         // Please propagate any changes to that file.
  87.         //
  88.         // Determine if subpath is equal to or a subpath of path.
  89.         // For example, /myapp/foo.aspx is a subpath of /myapp
  90.         // Account for optional trailing slashes.
  91.         //
  92.         static internal bool IsEqualOrSubpath(string path, string subpath)
  93.         {
  94.             if (String.IsNullOrEmpty(path))
  95.                 return true;
  96.            
  97.             if (String.IsNullOrEmpty(subpath))
  98.                 return false;
  99.            
  100.             //
  101.             // Compare up to but not including trailing slash
  102.             //
  103.             int lPath = path.Length;
  104.             if (path[lPath - 1] == '/') {
  105.                 lPath -= 1;
  106.             }
  107.            
  108.             int lSubpath = subpath.Length;
  109.             if (subpath[lSubpath - 1] == '/') {
  110.                 lSubpath -= 1;
  111.             }
  112.            
  113.             if (lSubpath < lPath)
  114.                 return false;
  115.            
  116.             if (String.Compare(path, 0, subpath, 0, lPath, StringComparison.OrdinalIgnoreCase) != 0)
  117.                 return false;
  118.            
  119.             // Check subpath that character following length of path is a slash
  120.             if (lSubpath > lPath && subpath[lPath] != '/')
  121.                 return false;
  122.            
  123.             return true;
  124.         }
  125.        
  126.         private static bool IsDirectorySeparatorChar(char ch)
  127.         {
  128.             return (ch == '\\' || ch == '/');
  129.         }
  130.        
  131.         private static bool IsAbsoluteLocalPhysicalPath(string path)
  132.         {
  133.             if (path == null || path.Length < 3)
  134.                 return false;
  135.            
  136.             // e.g c:\foo
  137.             return (path[1] == ':' && IsDirectorySeparatorChar(path[2]));
  138.         }
  139.        
  140.         private static bool IsAbsoluteUNCPhysicalPath(string path)
  141.         {
  142.             if (path == null || path.Length < 3)
  143.                 return false;
  144.            
  145.             // e.g \\server\share\foo or //server/share/foo
  146.             return (IsDirectorySeparatorChar(path[0]) && IsDirectorySeparatorChar(path[1]));
  147.         }
  148.        
  149.         const string FILE_URL_LOCAL = "file:///";
  150.         const string FILE_URL_UNC = "file:";
  151.        
  152.         static internal string ConvertFileNameToUrl(string fileName)
  153.         {
  154.             string prefix;
  155.            
  156.             if (IsAbsoluteLocalPhysicalPath(fileName)) {
  157.                 prefix = FILE_URL_LOCAL;
  158.             }
  159.             else if (IsAbsoluteUNCPhysicalPath(fileName)) {
  160.                 prefix = FILE_URL_UNC;
  161.             }
  162.             else {
  163.                 // We should never get here, but if we do we are likely to have
  164.                 // serious security problems, so throw an exception rather than simply
  165.                 // asserting.
  166.                 throw ExceptionUtil.ParameterInvalid("filename");
  167.             }
  168.            
  169.             string newFileName = prefix + fileName.Replace('\\', '/');
  170.             return newFileName;
  171.         }
  172.     }
  173. }

Developer Fusion