mcs/class/corlib/System.IO/Path.cs

   1 //------------------------------------------------------------------------------
   2 //
   3 // System.IO.Path.cs
   4 //
   5 // Copyright (C) 2001 Moonlight Enterprises, All Rights Reserved
   6 // Copyright (C) 2002 Ximian, Inc. (http://www.ximian.com)
   7 // Copyright (C) 2003 Ben Maurer
   8 //
   9 // Author:         Jim Richardson, develop@wtfo-guru.com
  10 //                 Dan Lewis (dihlewis@yahoo.co.uk)
  11 //                 Gonzalo Paniagua Javier (gonzalo@ximian.com)
  12 //                 Ben Maurer (bmaurer@users.sourceforge.net)
  13 //                 Sebastien Pouliot  <sebastien@ximian.com>
  14 // Created:        Saturday, August 11, 2001
  15 //
  16 //------------------------------------------------------------------------------
  17
  18 //
  19 // Copyright (C) 2004-2005 Novell, Inc (http://www.novell.com)
  20 //
  21 // Permission is hereby granted, free of charge, to any person obtaining
  22 // a copy of this software and associated documentation files (the
  23 // "Software"), to deal in the Software without restriction, including
  24 // without limitation the rights to use, copy, modify, merge, publish,
  25 // distribute, sublicense, and/or sell copies of the Software, and to
  26 // permit persons to whom the Software is furnished to do so, subject to
  27 // the following conditions:
  28 //
  29 // The above copyright notice and this permission notice shall be
  30 // included in all copies or substantial portions of the Software.
  31 //
  32 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  33 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  34 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  35 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  36 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  37 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  38 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  39 //
  40
  41 using System.Globalization;
  42 using System.Runtime.CompilerServices;
  43 using System.Runtime.InteropServices;
  44 using System.Security;
  45 using System.Security.Cryptography;
  46 using System.Security.Permissions;
  47 using System.Text;
  48
  49 namespace System.IO {
  50
  51         [ComVisible (true)]
  52         public static class Path {
  53
  54                 [Obsolete ("see GetInvalidPathChars and GetInvalidFileNameChars methods.")]
  55                 public static readonly char[] InvalidPathChars;
  56                 public static readonly char AltDirectorySeparatorChar;
  57                 public static readonly char DirectorySeparatorChar;
  58                 public static readonly char PathSeparator;
  59                 internal static readonly string DirectorySeparatorStr;
  60                 public static readonly char VolumeSeparatorChar;
  61
  62                 internal static readonly char[] PathSeparatorChars;
  63                 private static readonly bool dirEqualsVolume;
  64
  65                 // class methods
  66                 public static string ChangeExtension (string path, string extension)
  67                 {
  68                         if (path == null)
  69                                 return null;
  70
  71                         if (path.IndexOfAny (InvalidPathChars) != -1)
  72                                 throw new ArgumentException ("Illegal characters in path.");
  73
  74                         int iExt = findExtension (path);
  75
  76                         if (extension == null)
  77                                 return iExt < 0 ? path : path.Substring (0, iExt);
  78                         else if (extension.Length == 0)
  79                                 return iExt < 0 ? path + '.' : path.Substring (0, iExt + 1);
  80
  81                         else if (path.Length != 0) {
  82                                 if (extension.Length > 0 && extension [0] != '.')
  83                                         extension = "." + extension;
  84                         } else
  85                                 extension = String.Empty;
  86
  87                         if (iExt < 0) {
  88                                 return path + extension;
  89                         } else if (iExt > 0) {
  90                                 string temp = path.Substring (0, iExt);
  91                                 return temp + extension;
  92                         }
  93
  94                         return extension;
  95                 }
  96
  97                 public static string Combine (string path1, string path2)
  98                 {
  99                         if (path1 == null)
 100                                 throw new ArgumentNullException ("path1");
 101
 102                         if (path2 == null)
 103                                 throw new ArgumentNullException ("path2");
 104
 105                         if (path1.Length == 0)
 106                                 return path2;
 107
 108                         if (path2.Length == 0)
 109                                 return path1;
 110
 111                         if (path1.IndexOfAny (InvalidPathChars) != -1)
 112                                 throw new ArgumentException ("Illegal characters in path.");
 113
 114                         if (path2.IndexOfAny (InvalidPathChars) != -1)
 115                                 throw new ArgumentException ("Illegal characters in path.");
 116
 117                         //TODO???: UNC names
 118                         if (IsPathRooted (path2))
 119                                 return path2;
 120
 121                         char p1end = path1 [path1.Length - 1];
 122                         if (p1end != DirectorySeparatorChar && p1end != AltDirectorySeparatorChar && p1end != VolumeSeparatorChar)
 123                                 return path1 + DirectorySeparatorStr + path2;
 124
 125                         return path1 + path2;
 126                 }
 127
 128                 //
 129                 // This routine:
 130                 //   * Removes duplicat path separators from a string
 131                 //   * If the string starts with \\, preserves the first two (hostname on Windows)
 132                 //   * Removes the trailing path separator.
 133                 //   * Returns the DirectorySeparatorChar for the single input DirectorySeparatorChar or AltDirectorySeparatorChar
 134                 //
 135                 // Unlike CanonicalizePath, this does not do any path resolution
 136                 // (which GetDirectoryName is not supposed to do).
 137                 //
 138                 internal static string CleanPath (string s)
 139                 {
 140                         int l = s.Length;
 141                         int sub = 0;
 142                         int start = 0;
 143
 144                         // Host prefix?
 145                         char s0 = s [0];
 146                         if (l > 2 && s0 == '\\' && s [1] == '\\'){
 147                                 start = 2;
 148                         }
 149
 150                         // We are only left with root
 151                         if (l == 1 && (s0 == DirectorySeparatorChar || s0 == AltDirectorySeparatorChar))
 152                                 return s;
 153
 154                         // Cleanup
 155                         for (int i = start; i < l; i++){
 156                                 char c = s [i];
 157
 158                                 if (c != DirectorySeparatorChar && c != AltDirectorySeparatorChar)
 159                                         continue;
 160                                 if (i+1 == l)
 161                                         sub++;
 162                                 else {
 163                                         c = s [i + 1];
 164                                         if (c == DirectorySeparatorChar || c == AltDirectorySeparatorChar)
 165                                                 sub++;
 166                                 }
 167                         }
 168
 169                         if (sub == 0)
 170                                 return s;
 171
 172                         char [] copy = new char [l-sub];
 173                         if (start != 0){
 174                                 copy [0] = '\\';
 175                                 copy [1] = '\\';
 176                         }
 177                         for (int i = start, j = start; i < l && j < copy.Length; i++){
 178                                 char c = s [i];
 179
 180                                 if (c != DirectorySeparatorChar && c != AltDirectorySeparatorChar){
 181                                         copy [j++] = c;
 182                                         continue;
 183                                 }
 184
 185                                 // For non-trailing cases.
 186                                 if (j+1 != copy.Length){
 187                                         copy [j++] = DirectorySeparatorChar;
 188                                         for (;i < l-1; i++){
 189                                                 c = s [i+1];
 190                                                 if (c != DirectorySeparatorChar && c != AltDirectorySeparatorChar)
 191                                                         break;
 192                                         }
 193                                 }
 194                         }
 195                         return new String (copy);
 196                 }
 197
 198                 public static string GetDirectoryName (string path)
 199                 {
 200                         // LAMESPEC: For empty string MS docs say both
 201                         // return null AND throw exception.  Seems .NET throws.
 202                         if (path == String.Empty)
 203                                 throw new ArgumentException("Invalid path");
 204
 205                         if (path == null || GetPathRoot (path) == path)
 206                                 return null;
 207
 208                         if (path.Trim ().Length == 0)
 209                                 throw new ArgumentException ("Argument string consists of whitespace characters only.");
 210
 211                         if (path.IndexOfAny (System.IO.Path.InvalidPathChars) > -1)
 212                                 throw new ArgumentException ("Path contains invalid characters");
 213
 214                         int nLast = path.LastIndexOfAny (PathSeparatorChars);
 215                         if (nLast == 0)
 216                                 nLast++;
 217
 218                         if (nLast > 0) {
 219                                 string ret = path.Substring (0, nLast);
 220                                 int l = ret.Length;
 221
 222                                 if (l >= 2 && DirectorySeparatorChar == '\\' && ret [l - 1] == VolumeSeparatorChar)
 223                                         return ret + DirectorySeparatorChar;
 224                                 else {
 225                                         //
 226                                         // Important: do not use CanonicalizePath here, use
 227                                         // the custom CleanPath here, as this should not
 228                                         // return absolute paths
 229                                         //
 230                                         return CleanPath (ret);
 231                                 }
 232                         }
 233
 234                         return String.Empty;
 235                 }
 236
 237                 public static string GetExtension (string path)
 238                 {
 239                         if (path == null)
 240                                 return null;
 241
 242                         if (path.IndexOfAny (InvalidPathChars) != -1)
 243                                 throw new ArgumentException ("Illegal characters in path.");
 244
 245                         int iExt = findExtension (path);
 246
 247                         if (iExt > -1)
 248                         {
 249                                 if (iExt < path.Length - 1)
 250                                         return path.Substring (iExt);
 251                         }
 252                         return string.Empty;
 253                 }
 254
 255                 public static string GetFileName (string path)
 256                 {
 257                         if (path == null || path.Length == 0)
 258                                 return path;
 259
 260                         if (path.IndexOfAny (InvalidPathChars) != -1)
 261                                 throw new ArgumentException ("Illegal characters in path.");
 262
 263                         int nLast = path.LastIndexOfAny (PathSeparatorChars);
 264                         if (nLast >= 0)
 265                                 return path.Substring (nLast + 1);
 266
 267                         return path;
 268                 }
 269
 270                 public static string GetFileNameWithoutExtension (string path)
 271                 {
 272                         return ChangeExtension (GetFileName (path), null);
 273                 }
 274
 275                 public static string GetFullPath (string path)
 276                 {
 277                         string fullpath = InsecureGetFullPath (path);
 278
 279                         SecurityManager.EnsureElevatedPermissions (); // this is a no-op outside moonlight
 280
 281 #if !NET_2_1
 282                         if (SecurityManager.SecurityEnabled) {
 283                                 new FileIOPermission (FileIOPermissionAccess.PathDiscovery, fullpath).Demand ();
 284                         }
 285 #endif
 286                         return fullpath;
 287                 }
 288
 289                 internal static string WindowsDriveAdjustment (string path)
 290                 {
 291                         // two special cases to consider when a drive is specified
 292                         if (path.Length < 2)
 293                                 return path;
 294                         if ((path [1] != ':') || !Char.IsLetter (path [0]))
 295                                 return path;
 296
 297                         string current = Directory.GetCurrentDirectory ();
 298                         // first, only the drive is specified
 299                         if (path.Length == 2) {
 300                                 // then if the current directory is on the same drive
 301                                 if (current [0] == path [0])
 302                                         path = current; // we return it
 303                                 else
 304                                         path += '\\';
 305                         } else if ((path [2] != Path.DirectorySeparatorChar) && (path [2] != Path.AltDirectorySeparatorChar)) {
 306                                 // second, the drive + a directory is specified *without* a separator between them (e.g. C:dir).
 307                                 // If the current directory is on the specified drive...
 308                                 if (current [0] == path [0]) {
 309                                         // then specified directory is appended to the current drive directory
 310                                         path = Path.Combine (current, path.Substring (2, path.Length - 2));
 311                                 } else {
 312                                         // if not, then just pretend there was a separator (Path.Combine won't work in this case)
 313                                         path = String.Concat (path.Substring (0, 2), DirectorySeparatorStr, path.Substring (2, path.Length - 2));
 314                                 }
 315                         }
 316                         return path;
 317                 }
 318
 319                 // insecure - do not call directly
 320                 internal static string InsecureGetFullPath (string path)
 321                 {
 322                         if (path == null)
 323                                 throw new ArgumentNullException ("path");
 324
 325                         if (path.Trim ().Length == 0) {
 326                                 string msg = Locale.GetText ("The specified path is not of a legal form (empty).");
 327                                 throw new ArgumentException (msg);
 328                         }
 329
 330                         // adjust for drives, i.e. a special case for windows
 331                         if (Environment.IsRunningOnWindows)
 332                                 path = WindowsDriveAdjustment (path);
 333
 334                         // if the supplied path ends with a separator...
 335                         char end = path [path.Length - 1];
 336
 337                         var canonicalize = true;
 338                         if (path.Length >= 2 &&
 339                                 IsDsc (path [0]) &&
 340                                 IsDsc (path [1])) {
 341                                 if (path.Length == 2 || path.IndexOf (path [0], 2) < 0)
 342                                         throw new ArgumentException ("UNC pass should be of the form \\\\server\\share.");
 343
 344                                 if (path [0] != DirectorySeparatorChar)
 345                                         path = path.Replace (AltDirectorySeparatorChar, DirectorySeparatorChar);
 346
 347                         } else {
 348                                 if (!IsPathRooted (path)) {
 349
 350                                         // avoid calling expensive CanonicalizePath when possible
 351                                         var start = 0;
 352                                         while ((start = path.IndexOf ('.', start)) != -1) {
 353                                                 if (++start == path.Length || path [start] == DirectorySeparatorChar || path [start] == AltDirectorySeparatorChar)
 354                                                         break;
 355                                         }
 356                                         canonicalize = start > 0;
 357
 358                                         path = Directory.GetCurrentDirectory () + DirectorySeparatorStr + path;
 359                                 } else if (DirectorySeparatorChar == '\\' &&
 360                                         path.Length >= 2 &&
 361                                         IsDsc (path [0]) &&
 362                                         !IsDsc (path [1])) { // like `\abc\def'
 363                                         string current = Directory.GetCurrentDirectory ();
 364                                         if (current [1] == VolumeSeparatorChar)
 365                                                 path = current.Substring (0, 2) + path;
 366                                         else
 367                                                 path = current.Substring (0, current.IndexOf ('\\', current.IndexOf ("\\\\") + 1));
 368                                 }
 369                         }
 370
 371                         if (canonicalize)
 372                             path = CanonicalizePath (path);
 373
 374                         // if the original ended with a [Alt]DirectorySeparatorChar then ensure the full path also ends with one
 375                         if (IsDsc (end) && (path [path.Length - 1] != DirectorySeparatorChar))
 376                                 path += DirectorySeparatorChar;
 377
 378                         return path;
 379                 }
 380
 381                 static bool IsDsc (char c) {
 382                         return c == DirectorySeparatorChar || c == AltDirectorySeparatorChar;
 383                 }
 384
 385                 public static string GetPathRoot (string path)
 386                 {
 387                         if (path == null)
 388                                 return null;
 389
 390                         if (path.Trim ().Length == 0)
 391                                 throw new ArgumentException ("The specified path is not of a legal form.");
 392
 393                         if (!IsPathRooted (path))
 394                                 return String.Empty;
 395
 396                         if (DirectorySeparatorChar == '/') {
 397                                 // UNIX
 398                                 return IsDsc (path [0]) ? DirectorySeparatorStr : String.Empty;
 399                         } else {
 400                                 // Windows
 401                                 int len = 2;
 402
 403                                 if (path.Length == 1 && IsDsc (path [0]))
 404                                         return DirectorySeparatorStr;
 405                                 else if (path.Length < 2)
 406                                         return String.Empty;
 407
 408                                 if (IsDsc (path [0]) && IsDsc (path[1])) {
 409                                         // UNC: \\server or \\server\share
 410                                         // Get server
 411                                         while (len < path.Length && !IsDsc (path [len])) len++;
 412
 413                                         // Get share
 414                                         if (len < path.Length) {
 415                                                 len++;
 416                                                 while (len < path.Length && !IsDsc (path [len])) len++;
 417                                         }
 418
 419                                         return DirectorySeparatorStr +
 420                                                 DirectorySeparatorStr +
 421                                                 path.Substring (2, len - 2).Replace (AltDirectorySeparatorChar, DirectorySeparatorChar);
 422                                 } else if (IsDsc (path [0])) {
 423                                         // path starts with '\' or '/'
 424                                         return DirectorySeparatorStr;
 425                                 } else if (path[1] == VolumeSeparatorChar) {
 426                                         // C:\folder
 427                                         if (path.Length >= 3 && (IsDsc (path [2]))) len++;
 428                                 } else
 429                                         return Directory.GetCurrentDirectory ().Substring (0, 2);// + path.Substring (0, len);
 430                                 return path.Substring (0, len);
 431                         }
 432                 }
 433
 434                 // FIXME: Further limit the assertion when imperative Assert is implemented
 435                 [FileIOPermission (SecurityAction.Assert, Unrestricted = true)]
 436                 public static string GetTempFileName ()
 437                 {
 438                         FileStream f = null;
 439                         string path;
 440                         Random rnd;
 441                         int num = 0;
 442
 443                         SecurityManager.EnsureElevatedPermissions (); // this is a no-op outside moonlight
 444
 445                         rnd = new Random ();
 446                         do {
 447                                 num = rnd.Next ();
 448                                 num++;
 449                                 path = Path.Combine (GetTempPath(), "tmp" + num.ToString("x") + ".tmp");
 450
 451                                 try {
 452                                         f = new FileStream (path, FileMode.CreateNew, FileAccess.ReadWrite, FileShare.Read,
 453                                                             8192, false, (FileOptions) 1);
 454                                 }
 455                                 catch (SecurityException) {
 456                                         // avoid an endless loop
 457                                         throw;
 458                                 }
 459                                 catch (UnauthorizedAccessException) {
 460                                         // This can happen if we don't have write permission to /tmp
 461                                         throw;
 462                                 }
 463                                 catch {
 464                                 }
 465                         } while (f == null);
 466
 467                         f.Close();
 468                         return path;
 469                 }
 470
 471                 [EnvironmentPermission (SecurityAction.Demand, Unrestricted = true)]
 472                 public static string GetTempPath ()
 473                 {
 474                         SecurityManager.EnsureElevatedPermissions (); // this is a no-op outside moonlight
 475
 476                         string p = get_temp_path ();
 477                         if (p.Length > 0 && p [p.Length - 1] != DirectorySeparatorChar)
 478                                 return p + DirectorySeparatorChar;
 479
 480                         return p;
 481                 }
 482
 483                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
 484                 private static extern string get_temp_path ();
 485
 486                 public static bool HasExtension (string path)
 487                 {
 488                         if (path == null || path.Trim ().Length == 0)
 489                                 return false;
 490
 491                         if (path.IndexOfAny (InvalidPathChars) != -1)
 492                                 throw new ArgumentException ("Illegal characters in path.");
 493
 494                         int pos = findExtension (path);
 495                         return 0 <= pos && pos < path.Length - 1;
 496                 }
 497
 498                 public static bool IsPathRooted (string path)
 499                 {
 500                         if (path == null || path.Length == 0)
 501                                 return false;
 502
 503                         if (path.IndexOfAny (InvalidPathChars) != -1)
 504                                 throw new ArgumentException ("Illegal characters in path.");
 505
 506                         char c = path [0];
 507                         return (c == DirectorySeparatorChar     ||
 508                                 c == AltDirectorySeparatorChar  ||
 509                                 (!dirEqualsVolume && path.Length > 1 && path [1] == VolumeSeparatorChar));
 510                 }
 511
 512                 public static char[] GetInvalidFileNameChars ()
 513                 {
 514                         // return a new array as we do not want anyone to be able to change the values
 515                         if (Environment.IsRunningOnWindows) {
 516                                 return new char [41] { '\x00', '\x01', '\x02', '\x03', '\x04', '\x05', '\x06', '\x07',
 517                                         '\x08', '\x09', '\x0A', '\x0B', '\x0C', '\x0D', '\x0E', '\x0F', '\x10', '\x11', '\x12',
 518                                         '\x13', '\x14', '\x15', '\x16', '\x17', '\x18', '\x19', '\x1A', '\x1B', '\x1C', '\x1D',
 519                                         '\x1E', '\x1F', '\x22', '\x3C', '\x3E', '\x7C', ':', '*', '?', '\\', '/' };
 520                         } else {
 521                                 return new char [2] { '\x00', '/' };
 522                         }
 523                 }
 524
 525                 public static char[] GetInvalidPathChars ()
 526                 {
 527                         // return a new array as we do not want anyone to be able to change the values
 528                         if (Environment.IsRunningOnWindows) {
 529                                 return new char [36] { '\x22', '\x3C', '\x3E', '\x7C', '\x00', '\x01', '\x02', '\x03', '\x04', '\x05', '\x06', '\x07',
 530                                         '\x08', '\x09', '\x0A', '\x0B', '\x0C', '\x0D', '\x0E', '\x0F', '\x10', '\x11', '\x12',
 531                                         '\x13', '\x14', '\x15', '\x16', '\x17', '\x18', '\x19', '\x1A', '\x1B', '\x1C', '\x1D',
 532                                         '\x1E', '\x1F' };
 533                         } else {
 534                                 return new char [1] { '\x00' };
 535                         }
 536                 }
 537
 538                 public static string GetRandomFileName ()
 539                 {
 540                         // returns a 8.3 filename (total size 12)
 541                         StringBuilder sb = new StringBuilder (12);
 542                         // using strong crypto but without creating the file
 543                         RandomNumberGenerator rng = RandomNumberGenerator.Create ();
 544                         byte [] buffer = new byte [11];
 545                         rng.GetBytes (buffer);
 546
 547                         for (int i = 0; i < buffer.Length; i++) {
 548                                 if (sb.Length == 8)
 549                                         sb.Append ('.');
 550
 551                                 // restrict to length of range [a..z0..9]
 552                                 int b = (buffer [i] % 36);
 553                                 char c = (char) (b < 26 ? (b + 'a') : (b - 26 + '0'));
 554                                 sb.Append (c);
 555                         }
 556
 557                         return sb.ToString ();
 558                 }
 559
 560                 // private class methods
 561
 562                 private static int findExtension (string path)
 563                 {
 564                         // method should return the index of the path extension
 565                         // start or -1 if no valid extension
 566                         if (path != null){
 567                                 int iLastDot = path.LastIndexOf ('.');
 568                                 int iLastSep = path.LastIndexOfAny ( PathSeparatorChars );
 569
 570                                 if (iLastDot > iLastSep)
 571                                         return iLastDot;
 572                         }
 573                         return -1;
 574                 }
 575
 576                 static Path ()
 577                 {
 578                         VolumeSeparatorChar = MonoIO.VolumeSeparatorChar;
 579                         DirectorySeparatorChar = MonoIO.DirectorySeparatorChar;
 580                         AltDirectorySeparatorChar = MonoIO.AltDirectorySeparatorChar;
 581
 582                         PathSeparator = MonoIO.PathSeparator;
 583                         // this copy will be modifiable ("by design")
 584                         InvalidPathChars = GetInvalidPathChars ();
 585                         // internal fields
 586
 587                         DirectorySeparatorStr = DirectorySeparatorChar.ToString ();
 588                         PathSeparatorChars = new char [] {
 589                                 DirectorySeparatorChar,
 590                                 AltDirectorySeparatorChar,
 591                                 VolumeSeparatorChar
 592                         };
 593
 594                         dirEqualsVolume = (DirectorySeparatorChar == VolumeSeparatorChar);
 595                 }
 596
 597                 // returns the server and share part of a UNC. Assumes "path" is a UNC.
 598                 static string GetServerAndShare (string path)
 599                 {
 600                         int len = 2;
 601                         while (len < path.Length && !IsDsc (path [len])) len++;
 602
 603                         if (len < path.Length) {
 604                                 len++;
 605                                 while (len < path.Length && !IsDsc (path [len])) len++;
 606                         }
 607
 608                         return path.Substring (2, len - 2).Replace (AltDirectorySeparatorChar, DirectorySeparatorChar);
 609                 }
 610
 611                 // assumes Environment.IsRunningOnWindows == true
 612                 static bool SameRoot (string root, string path)
 613                 {
 614                         // compare root - if enough details are available
 615                         if ((root.Length < 2) || (path.Length < 2))
 616                                 return false;
 617
 618                         // UNC handling
 619                         if (IsDsc (root[0]) && IsDsc (root[1])) {
 620                                 if (!(IsDsc (path[0]) && IsDsc (path[1])))
 621                                         return false;
 622
 623                                 string rootShare = GetServerAndShare (root);
 624                                 string pathShare = GetServerAndShare (path);
 625
 626                                 return String.Compare (rootShare, pathShare, true, CultureInfo.InvariantCulture) == 0;
 627                         }
 628
 629                         // same volume/drive
 630                         if (!root [0].Equals (path [0]))
 631                                 return false;
 632                         // presence of the separator
 633                         if (path[1] != Path.VolumeSeparatorChar)
 634                                 return false;
 635                         if ((root.Length > 2) && (path.Length > 2)) {
 636                                 // but don't directory compare the directory separator
 637                                 return (IsDsc (root[2]) && IsDsc (path[2]));
 638                         }
 639                         return true;
 640                 }
 641
 642                 static string CanonicalizePath (string path)
 643                 {
 644                         // STEP 1: Check for empty string
 645                         if (path == null)
 646                                 return path;
 647                         if (Environment.IsRunningOnWindows)
 648                                 path = path.Trim ();
 649
 650                         if (path.Length == 0)
 651                                 return path;
 652
 653                         // STEP 2: Check to see if this is only a root
 654                         string root = Path.GetPathRoot (path);
 655                         // it will return '\' for path '\', while it should return 'c:\' or so.
 656                         // Note: commenting this out makes the need for the (target == 1...) check in step 5
 657                         //if (root == path) return path;
 658
 659                         // STEP 3: split the directories, this gets rid of consecutative "/"'s
 660                         string[] dirs = path.Split (Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
 661                         // STEP 4: Get rid of directories containing . and ..
 662                         int target = 0;
 663
 664                         bool isUnc = Environment.IsRunningOnWindows &&
 665                                 root.Length > 2 && IsDsc (root[0]) && IsDsc (root[1]);
 666
 667                         // Set an overwrite limit for UNC paths since '\' + server + share
 668                         // must not be eliminated by the '..' elimination algorithm.
 669                         int limit = isUnc ? 3 : 0;
 670
 671                         for (int i = 0; i < dirs.Length; i++) {
 672                                 // WIN32 path components must be trimmed
 673                                 if (Environment.IsRunningOnWindows)
 674                                         dirs[i] = dirs[i].TrimEnd ();
 675
 676                                 if (dirs[i] == "." || (i != 0 && dirs[i].Length == 0))
 677                                         continue;
 678                                 else if (dirs[i] == "..") {
 679                                         // don't overwrite path segments below the limit
 680                                         if (target > limit)
 681                                                 target--;
 682                                 } else
 683                                         dirs[target++] = dirs[i];
 684                         }
 685
 686                         // STEP 5: Combine everything.
 687                         if (target == 0 || (target == 1 && dirs[0] == ""))
 688                                 return root;
 689                         else {
 690                                 string ret = String.Join (DirectorySeparatorStr, dirs, 0, target);
 691                                 if (Environment.IsRunningOnWindows) {
 692                                         // append leading '\' of the UNC path that was lost in STEP 3.
 693                                         if (isUnc)
 694                                                 ret = Path.DirectorySeparatorStr + ret;
 695
 696                                         if (!SameRoot (root, ret))
 697                                                 ret = root + ret;
 698
 699                                         if (isUnc) {
 700                                                 return ret;
 701                                         } else if (!IsDsc (path[0]) && SameRoot (root, path)) {
 702                                                 if (ret.Length <= 2 && !ret.EndsWith (DirectorySeparatorStr)) // '\' after "c:"
 703                                                         ret += Path.DirectorySeparatorChar;
 704                                                 return ret;
 705                                         } else {
 706                                                 string current = Directory.GetCurrentDirectory ();
 707                                                 if (current.Length > 1 && current[1] == Path.VolumeSeparatorChar) {
 708                                                         // DOS local file path
 709                                                         if (ret.Length == 0 || IsDsc (ret[0]))
 710                                                                 ret += '\\';
 711                                                         return current.Substring (0, 2) + ret;
 712                                                 } else if (IsDsc (current[current.Length - 1]) && IsDsc (ret[0]))
 713                                                         return current + ret.Substring (1);
 714                                                 else
 715                                                         return current + ret;
 716                                         }
 717                                 }
 718                                 return ret;
 719                         }
 720                 }
 721
 722                 // required for FileIOPermission (and most proibably reusable elsewhere too)
 723                 // both path MUST be "full paths"
 724                 static internal bool IsPathSubsetOf (string subset, string path)
 725                 {
 726                         if (subset.Length > path.Length)
 727                                 return false;
 728
 729                         // check that everything up to the last separator match
 730                         int slast = subset.LastIndexOfAny (PathSeparatorChars);
 731                         if (String.Compare (subset, 0, path, 0, slast) != 0)
 732                                 return false;
 733
 734                         slast++;
 735                         // then check if the last segment is identical
 736                         int plast = path.IndexOfAny (PathSeparatorChars, slast);
 737                         if (plast >= slast) {
 738                                 return String.Compare (subset, slast, path, slast, path.Length - plast) == 0;
 739                         }
 740                         if (subset.Length != path.Length)
 741                                 return false;
 742
 743                         return String.Compare (subset, slast, path, slast, subset.Length - slast) == 0;
 744                 }
 745
 746 #if NET_4_0 || MOONLIGHT
 747                 public static string Combine (params string [] paths)
 748                 {
 749                         if (paths == null)
 750                                 throw new ArgumentNullException ("paths");
 751
 752                         int l = 0;
 753                         bool need_sep = false;
 754                         foreach (var s in paths){
 755                                 if (s == null)
 756                                         throw new ArgumentNullException ("One of the paths contains a null value", "paths");
 757                                 if (s.IndexOfAny (InvalidPathChars) != -1)
 758                                         throw new ArgumentException ("Illegal characters in path.");
 759                                 if (l == 0 && s.Length > 0){
 760                                         char p1end = s [s.Length - 1];
 761                                         if (p1end != DirectorySeparatorChar && p1end != AltDirectorySeparatorChar && p1end != VolumeSeparatorChar){
 762                                                 need_sep = true;
 763                                                 l += DirectorySeparatorStr.Length;
 764                                         }
 765                                 }
 766                         }
 767                         var ret = new StringBuilder (l);
 768                         l = 0;
 769                         foreach (var s in paths){
 770                                 if (IsPathRooted (s))
 771                                         ret.Length = l = 0;
 772                                 ret.Append (s);
 773                                 if (l == 0 && need_sep)
 774                                         ret.Append (DirectorySeparatorStr);
 775                                 l = 1;
 776                         }
 777
 778                         return ret.ToString ();
 779                 }
 780
 781                 public static string Combine (string path1, string path2, string path3)
 782                 {
 783                         return Combine (new string [] { path1, path2, path3 });
 784                 }
 785
 786                 public static string Combine (string path1, string path2, string path3, string path4)
 787                 {
 788                         return Combine (new string [] { path1, path2, path3, path4 });
 789                 }
 790 #endif
 791
 792                 internal static void Validate (string path)
 793                 {
 794                         Validate (path, "path");
 795                 }
 796
 797                 internal static void Validate (string path, string parameterName)
 798                 {
 799                         if (path == null)
 800                                 throw new ArgumentNullException (parameterName);
 801                         if (String.IsNullOrWhiteSpace (path))
 802                                 throw new ArgumentException (Locale.GetText ("Path is empty"));
 803                         if (path.IndexOfAny (Path.InvalidPathChars) != -1)
 804                                 throw new ArgumentException (Locale.GetText ("Path contains invalid chars"));
 805 #if MOONLIGHT
 806                         // On Moonlight (SL4+) there are some limitations in "Elevated Trust"
 807                         if (SecurityManager.HasElevatedPermissions) {
 808                         }
 809 #endif
 810                 }
 811         }
 812 }