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