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 paths 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                         int count = 0;
 443
 444                         SecurityManager.EnsureElevatedPermissions (); // this is a no-op outside moonlight
 445
 446                         rnd = new Random ();
 447                         do {
 448                                 num = rnd.Next ();
 449                                 num++;
 450                                 path = Path.Combine (GetTempPath(), "tmp" + num.ToString("x") + ".tmp");
 451
 452                                 try {
 453                                         f = new FileStream (path, FileMode.CreateNew, FileAccess.ReadWrite, FileShare.Read,
 454                                                             8192, false, (FileOptions) 1);
 455                                 }
 456                                 catch (IOException ex){
 457                                         if (ex.hresult != MonoIO.FileAlreadyExistsHResult || count ++ > 65536)
 458                                                 throw;
 459                                 }
 460                         } while (f == null);
 461
 462                         f.Close();
 463                         return path;
 464                 }
 465
 466                 [EnvironmentPermission (SecurityAction.Demand, Unrestricted = true)]
 467                 public static string GetTempPath ()
 468                 {
 469                         SecurityManager.EnsureElevatedPermissions (); // this is a no-op outside moonlight
 470
 471                         string p = get_temp_path ();
 472                         if (p.Length > 0 && p [p.Length - 1] != DirectorySeparatorChar)
 473                                 return p + DirectorySeparatorChar;
 474
 475                         return p;
 476                 }
 477
 478                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
 479                 private static extern string get_temp_path ();
 480
 481                 public static bool HasExtension (string path)
 482                 {
 483                         if (path == null || path.Trim ().Length == 0)
 484                                 return false;
 485
 486                         if (path.IndexOfAny (InvalidPathChars) != -1)
 487                                 throw new ArgumentException ("Illegal characters in path.");
 488
 489                         int pos = findExtension (path);
 490                         return 0 <= pos && pos < path.Length - 1;
 491                 }
 492
 493                 public static bool IsPathRooted (string path)
 494                 {
 495                         if (path == null || path.Length == 0)
 496                                 return false;
 497
 498                         if (path.IndexOfAny (InvalidPathChars) != -1)
 499                                 throw new ArgumentException ("Illegal characters in path.");
 500
 501                         char c = path [0];
 502                         return (c == DirectorySeparatorChar     ||
 503                                 c == AltDirectorySeparatorChar  ||
 504                                 (!dirEqualsVolume && path.Length > 1 && path [1] == VolumeSeparatorChar));
 505                 }
 506
 507                 public static char[] GetInvalidFileNameChars ()
 508                 {
 509                         // return a new array as we do not want anyone to be able to change the values
 510                         if (Environment.IsRunningOnWindows) {
 511                                 return new char [41] { '\x00', '\x01', '\x02', '\x03', '\x04', '\x05', '\x06', '\x07',
 512                                         '\x08', '\x09', '\x0A', '\x0B', '\x0C', '\x0D', '\x0E', '\x0F', '\x10', '\x11', '\x12',
 513                                         '\x13', '\x14', '\x15', '\x16', '\x17', '\x18', '\x19', '\x1A', '\x1B', '\x1C', '\x1D',
 514                                         '\x1E', '\x1F', '\x22', '\x3C', '\x3E', '\x7C', ':', '*', '?', '\\', '/' };
 515                         } else {
 516                                 return new char [2] { '\x00', '/' };
 517                         }
 518                 }
 519
 520                 public static char[] GetInvalidPathChars ()
 521                 {
 522                         // return a new array as we do not want anyone to be able to change the values
 523                         if (Environment.IsRunningOnWindows) {
 524                                 return new char [36] { '\x22', '\x3C', '\x3E', '\x7C', '\x00', '\x01', '\x02', '\x03', '\x04', '\x05', '\x06', '\x07',
 525                                         '\x08', '\x09', '\x0A', '\x0B', '\x0C', '\x0D', '\x0E', '\x0F', '\x10', '\x11', '\x12',
 526                                         '\x13', '\x14', '\x15', '\x16', '\x17', '\x18', '\x19', '\x1A', '\x1B', '\x1C', '\x1D',
 527                                         '\x1E', '\x1F' };
 528                         } else {
 529                                 return new char [1] { '\x00' };
 530                         }
 531                 }
 532
 533                 public static string GetRandomFileName ()
 534                 {
 535                         // returns a 8.3 filename (total size 12)
 536                         StringBuilder sb = new StringBuilder (12);
 537                         // using strong crypto but without creating the file
 538                         RandomNumberGenerator rng = RandomNumberGenerator.Create ();
 539                         byte [] buffer = new byte [11];
 540                         rng.GetBytes (buffer);
 541
 542                         for (int i = 0; i < buffer.Length; i++) {
 543                                 if (sb.Length == 8)
 544                                         sb.Append ('.');
 545
 546                                 // restrict to length of range [a..z0..9]
 547                                 int b = (buffer [i] % 36);
 548                                 char c = (char) (b < 26 ? (b + 'a') : (b - 26 + '0'));
 549                                 sb.Append (c);
 550                         }
 551
 552                         return sb.ToString ();
 553                 }
 554
 555                 // private class methods
 556
 557                 private static int findExtension (string path)
 558                 {
 559                         // method should return the index of the path extension
 560                         // start or -1 if no valid extension
 561                         if (path != null){
 562                                 int iLastDot = path.LastIndexOf ('.');
 563                                 int iLastSep = path.LastIndexOfAny ( PathSeparatorChars );
 564
 565                                 if (iLastDot > iLastSep)
 566                                         return iLastDot;
 567                         }
 568                         return -1;
 569                 }
 570
 571                 static Path ()
 572                 {
 573                         VolumeSeparatorChar = MonoIO.VolumeSeparatorChar;
 574                         DirectorySeparatorChar = MonoIO.DirectorySeparatorChar;
 575                         AltDirectorySeparatorChar = MonoIO.AltDirectorySeparatorChar;
 576
 577                         PathSeparator = MonoIO.PathSeparator;
 578                         // this copy will be modifiable ("by design")
 579                         InvalidPathChars = GetInvalidPathChars ();
 580                         // internal fields
 581
 582                         DirectorySeparatorStr = DirectorySeparatorChar.ToString ();
 583                         PathSeparatorChars = new char [] {
 584                                 DirectorySeparatorChar,
 585                                 AltDirectorySeparatorChar,
 586                                 VolumeSeparatorChar
 587                         };
 588
 589                         dirEqualsVolume = (DirectorySeparatorChar == VolumeSeparatorChar);
 590                 }
 591
 592                 // returns the server and share part of a UNC. Assumes "path" is a UNC.
 593                 static string GetServerAndShare (string path)
 594                 {
 595                         int len = 2;
 596                         while (len < path.Length && !IsDsc (path [len])) len++;
 597
 598                         if (len < path.Length) {
 599                                 len++;
 600                                 while (len < path.Length && !IsDsc (path [len])) len++;
 601                         }
 602
 603                         return path.Substring (2, len - 2).Replace (AltDirectorySeparatorChar, DirectorySeparatorChar);
 604                 }
 605
 606                 // assumes Environment.IsRunningOnWindows == true
 607                 static bool SameRoot (string root, string path)
 608                 {
 609                         // compare root - if enough details are available
 610                         if ((root.Length < 2) || (path.Length < 2))
 611                                 return false;
 612
 613                         // UNC handling
 614                         if (IsDsc (root[0]) && IsDsc (root[1])) {
 615                                 if (!(IsDsc (path[0]) && IsDsc (path[1])))
 616                                         return false;
 617
 618                                 string rootShare = GetServerAndShare (root);
 619                                 string pathShare = GetServerAndShare (path);
 620
 621                                 return String.Compare (rootShare, pathShare, true, CultureInfo.InvariantCulture) == 0;
 622                         }
 623
 624                         // same volume/drive
 625                         if (!root [0].Equals (path [0]))
 626                                 return false;
 627                         // presence of the separator
 628                         if (path[1] != Path.VolumeSeparatorChar)
 629                                 return false;
 630                         if ((root.Length > 2) && (path.Length > 2)) {
 631                                 // but don't directory compare the directory separator
 632                                 return (IsDsc (root[2]) && IsDsc (path[2]));
 633                         }
 634                         return true;
 635                 }
 636
 637                 static string CanonicalizePath (string path)
 638                 {
 639                         // STEP 1: Check for empty string
 640                         if (path == null)
 641                                 return path;
 642                         if (Environment.IsRunningOnWindows)
 643                                 path = path.Trim ();
 644
 645                         if (path.Length == 0)
 646                                 return path;
 647
 648                         // STEP 2: Check to see if this is only a root
 649                         string root = Path.GetPathRoot (path);
 650                         // it will return '\' for path '\', while it should return 'c:\' or so.
 651                         // Note: commenting this out makes the need for the (target == 1...) check in step 5
 652                         //if (root == path) return path;
 653
 654                         // STEP 3: split the directories, this gets rid of consecutative "/"'s
 655                         string[] dirs = path.Split (Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
 656                         // STEP 4: Get rid of directories containing . and ..
 657                         int target = 0;
 658
 659                         bool isUnc = Environment.IsRunningOnWindows &&
 660                                 root.Length > 2 && IsDsc (root[0]) && IsDsc (root[1]);
 661
 662                         // Set an overwrite limit for UNC paths since '\' + server + share
 663                         // must not be eliminated by the '..' elimination algorithm.
 664                         int limit = isUnc ? 3 : 0;
 665
 666                         for (int i = 0; i < dirs.Length; i++) {
 667                                 // WIN32 path components must be trimmed
 668                                 if (Environment.IsRunningOnWindows)
 669                                         dirs[i] = dirs[i].TrimEnd ();
 670
 671                                 if (dirs[i] == "." || (i != 0 && dirs[i].Length == 0))
 672                                         continue;
 673                                 else if (dirs[i] == "..") {
 674                                         // don't overwrite path segments below the limit
 675                                         if (target > limit)
 676                                                 target--;
 677                                 } else
 678                                         dirs[target++] = dirs[i];
 679                         }
 680
 681                         // STEP 5: Combine everything.
 682                         if (target == 0 || (target == 1 && dirs[0] == ""))
 683                                 return root;
 684                         else {
 685                                 string ret = String.Join (DirectorySeparatorStr, dirs, 0, target);
 686                                 if (Environment.IsRunningOnWindows) {
 687                                         // append leading '\' of the UNC path that was lost in STEP 3.
 688                                         if (isUnc)
 689                                                 ret = Path.DirectorySeparatorStr + ret;
 690
 691                                         if (!SameRoot (root, ret))
 692                                                 ret = root + ret;
 693
 694                                         if (isUnc) {
 695                                                 return ret;
 696                                         } else if (!IsDsc (path[0]) && SameRoot (root, path)) {
 697                                                 if (ret.Length <= 2 && !ret.EndsWith (DirectorySeparatorStr)) // '\' after "c:"
 698                                                         ret += Path.DirectorySeparatorChar;
 699                                                 return ret;
 700                                         } else {
 701                                                 string current = Directory.GetCurrentDirectory ();
 702                                                 if (current.Length > 1 && current[1] == Path.VolumeSeparatorChar) {
 703                                                         // DOS local file path
 704                                                         if (ret.Length == 0 || IsDsc (ret[0]))
 705                                                                 ret += '\\';
 706                                                         return current.Substring (0, 2) + ret;
 707                                                 } else if (IsDsc (current[current.Length - 1]) && IsDsc (ret[0]))
 708                                                         return current + ret.Substring (1);
 709                                                 else
 710                                                         return current + ret;
 711                                         }
 712                                 }
 713                                 return ret;
 714                         }
 715                 }
 716
 717                 // required for FileIOPermission (and most proibably reusable elsewhere too)
 718                 // both path MUST be "full paths"
 719                 static internal bool IsPathSubsetOf (string subset, string path)
 720                 {
 721                         if (subset.Length > path.Length)
 722                                 return false;
 723
 724                         // check that everything up to the last separator match
 725                         int slast = subset.LastIndexOfAny (PathSeparatorChars);
 726                         if (String.Compare (subset, 0, path, 0, slast) != 0)
 727                                 return false;
 728
 729                         slast++;
 730                         // then check if the last segment is identical
 731                         int plast = path.IndexOfAny (PathSeparatorChars, slast);
 732                         if (plast >= slast) {
 733                                 return String.Compare (subset, slast, path, slast, path.Length - plast) == 0;
 734                         }
 735                         if (subset.Length != path.Length)
 736                                 return false;
 737
 738                         return String.Compare (subset, slast, path, slast, subset.Length - slast) == 0;
 739                 }
 740
 741 #if NET_4_0 || MOONLIGHT || MOBILE
 742                 public
 743 #else
 744                 internal
 745 #endif
 746                 static string Combine (params string [] paths)
 747                 {
 748                         if (paths == null)
 749                                 throw new ArgumentNullException ("paths");
 750
 751                         bool need_sep;
 752                         var ret = new StringBuilder ();
 753                         int pathsLen = paths.Length;
 754                         int slen;
 755                         foreach (var s in paths) {
 756                                 need_sep = false;
 757                                 if (s == null)
 758                                         throw new ArgumentNullException ("One of the paths contains a null value", "paths");
 759                                 if (s.IndexOfAny (InvalidPathChars) != -1)
 760                                         throw new ArgumentException ("Illegal characters in path.");
 761
 762                                 pathsLen--;
 763                                 if (IsPathRooted (s))
 764                                         ret.Length = 0;
 765
 766                                 ret.Append (s);
 767                                 slen = s.Length;
 768                                 if (slen > 0 && pathsLen > 0) {
 769                                         char p1end = s [slen - 1];
 770                                         if (p1end != DirectorySeparatorChar && p1end != AltDirectorySeparatorChar && p1end != VolumeSeparatorChar)
 771                                                 need_sep = true;
 772                                 }
 773
 774                                 if (need_sep)
 775                                         ret.Append (DirectorySeparatorStr);
 776                         }
 777
 778                         return ret.ToString ();
 779                 }
 780
 781 #if NET_4_0 || MOONLIGHT || MOBILE
 782                 public
 783 #else
 784                 internal
 785 #endif
 786                 static string Combine (string path1, string path2, string path3)
 787                 {
 788                         if (path1 == null)
 789                                 throw new ArgumentNullException ("path1");
 790
 791                         if (path2 == null)
 792                                 throw new ArgumentNullException ("path2");
 793
 794                         if (path3 == null)
 795                                 throw new ArgumentNullException ("path3");
 796
 797                         return Combine (new string [] { path1, path2, path3 });
 798                 }
 799
 800 #if NET_4_0 || MOONLIGHT || MOBILE
 801                 public
 802 #else
 803                 internal
 804 #endif
 805                 static string Combine (string path1, string path2, string path3, string path4)
 806                 {
 807                         if (path1 == null)
 808                                 throw new ArgumentNullException ("path1");
 809
 810                         if (path2 == null)
 811                                 throw new ArgumentNullException ("path2");
 812
 813                         if (path3 == null)
 814                                 throw new ArgumentNullException ("path3");
 815
 816                         if (path4 == null)
 817                                 throw new ArgumentNullException ("path4");
 818
 819                         return Combine (new string [] { path1, path2, path3, path4 });
 820                 }
 821
 822                 internal static void Validate (string path)
 823                 {
 824                         Validate (path, "path");
 825                 }
 826
 827                 internal static void Validate (string path, string parameterName)
 828                 {
 829                         if (path == null)
 830                                 throw new ArgumentNullException (parameterName);
 831                         if (String.IsNullOrWhiteSpace (path))
 832                                 throw new ArgumentException (Locale.GetText ("Path is empty"));
 833                         if (path.IndexOfAny (Path.InvalidPathChars) != -1)
 834                                 throw new ArgumentException (Locale.GetText ("Path contains invalid chars"));
 835 #if MOONLIGHT
 836                         // On Moonlight (SL4+) there are some limitations in "Elevated Trust"
 837                         if (SecurityManager.HasElevatedPermissions) {
 838                         }
 839 #endif
 840                 }
 841         }
 842 }