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

   1 //
   2 // System.IO.Directory.cs
   3 //
   4 // Authors:
   5 //   Jim Richardson  (develop@wtfo-guru.com)
   6 //   Miguel de Icaza (miguel@ximian.com)
   7 //   Dan Lewis       (dihlewis@yahoo.co.uk)
   8 //   Eduardo Garcia  (kiwnix@yahoo.es)
   9 //   Ville Palo      (vi64pa@kolumbus.fi)
  10 //
  11 // Copyright (C) 2001 Moonlight Enterprises, All Rights Reserved
  12 // Copyright (C) 2002 Ximian, Inc.
  13 //
  14 // Created:        Monday, August 13, 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.Collections;
  42 using System.Collections.Generic;
  43 using System.Security;
  44 using System.Security.Permissions;
  45 using System.Text;
  46 using System.Runtime.InteropServices;
  47
  48 #if !MOONLIGHT
  49 using System.Security.AccessControl;
  50 #endif
  51
  52 namespace System.IO
  53 {
  54         [ComVisible (true)]
  55         public static class Directory
  56         {
  57
  58                 public static DirectoryInfo CreateDirectory (string path)
  59                 {
  60                         if (path == null)
  61                                 throw new ArgumentNullException ("path");
  62
  63                         if (path.Length == 0)
  64                                 throw new ArgumentException ("Path is empty");
  65
  66                         if (path.IndexOfAny (Path.InvalidPathChars) != -1)
  67                                 throw new ArgumentException ("Path contains invalid chars");
  68
  69                         if (path.Trim ().Length == 0)
  70                                 throw new ArgumentException ("Only blank characters in path");
  71
  72                         // after validations but before File.Exists to avoid an oracle
  73                         SecurityManager.EnsureElevatedPermissions (); // this is a no-op outside moonlight
  74
  75                         if (File.Exists(path))
  76                                 throw new IOException ("Cannot create " + path + " because a file with the same name already exists.");
  77
  78                         // LAMESPEC: with .net 1.0 version this throw NotSupportedException and msdn says so too
  79                         // but v1.1 throws ArgumentException.
  80                         if (Environment.IsRunningOnWindows && path == ":")
  81                                 throw new ArgumentException ("Only ':' In path");
  82
  83                         return CreateDirectoriesInternal (path);
  84                 }
  85
  86 #if !MOONLIGHT
  87                 [MonoLimitation ("DirectorySecurity not implemented")]
  88                 public static DirectoryInfo CreateDirectory (string path, DirectorySecurity directorySecurity)
  89                 {
  90                         return(CreateDirectory (path));
  91                 }
  92 #endif
  93
  94                 static DirectoryInfo CreateDirectoriesInternal (string path)
  95                 {
  96 #if !NET_2_1
  97                         if (SecurityManager.SecurityEnabled) {
  98                                 new FileIOPermission (FileIOPermissionAccess.Read | FileIOPermissionAccess.Write, path).Demand ();
  99                         }
 100 #endif
 101                         DirectoryInfo info = new DirectoryInfo (path, true);
 102                         if (info.Parent != null && !info.Parent.Exists)
 103                                  info.Parent.Create ();
 104
 105                         MonoIOError error;
 106                         if (!MonoIO.CreateDirectory (path, out error)) {
 107                                 // LAMESPEC: 1.1 and 1.2alpha allow CreateDirectory on a file path.
 108                                 // So CreateDirectory ("/tmp/somefile") will succeed if 'somefile' is
 109                                 // not a directory. However, 1.0 will throw an exception.
 110                                 // We behave like 1.0 here (emulating 1.1-like behavior is just a matter
 111                                 // of comparing error to ERROR_FILE_EXISTS, but it's lame to do:
 112                                 //    DirectoryInfo di = Directory.CreateDirectory (something);
 113                                 // and having di.Exists return false afterwards.
 114                                 // I hope we don't break anyone's code, as they should be catching
 115                                 // the exception anyway.
 116                                 if (error != MonoIOError.ERROR_ALREADY_EXISTS &&
 117                                     error != MonoIOError.ERROR_FILE_EXISTS)
 118                                         throw MonoIO.GetException (path, error);
 119                         }
 120
 121                         return info;
 122                 }
 123
 124                 public static void Delete (string path)
 125                 {
 126                         Path.Validate (path);
 127
 128                         if (Environment.IsRunningOnWindows && path == ":")
 129                                 throw new NotSupportedException ("Only ':' In path");
 130
 131                         SecurityManager.EnsureElevatedPermissions (); // this is a no-op outside moonlight
 132
 133                         MonoIOError error;
 134                         bool success;
 135
 136                         if (MonoIO.ExistsSymlink (path, out error)) {
 137                                 /* RemoveDirectory maps to rmdir()
 138                                  * which fails on symlinks (ENOTDIR)
 139                                  */
 140                                 success = MonoIO.DeleteFile (path, out error);
 141                         } else {
 142                                 success = MonoIO.RemoveDirectory (path, out error);
 143                         }
 144
 145                         if (!success) {
 146                                 /*
 147                                  * FIXME:
 148                                  * In io-layer/io.c rmdir returns error_file_not_found if directory does not exists.
 149                                  * So maybe this could be handled somewhere else?
 150                                  */
 151                                 if (error == MonoIOError.ERROR_FILE_NOT_FOUND) {
 152                                         if (File.Exists (path))
 153                                                 throw new IOException ("Directory does not exist, but a file of the same name exists.");
 154                                         else
 155                                                 throw new DirectoryNotFoundException ("Directory does not exist.");
 156                                 } else
 157                                         throw MonoIO.GetException (path, error);
 158                         }
 159                 }
 160
 161                 static void RecursiveDelete (string path)
 162                 {
 163                         MonoIOError error;
 164
 165                         foreach (string dir in GetDirectories (path)) {
 166                                 if (MonoIO.ExistsSymlink (dir, out error)) {
 167                                         MonoIO.DeleteFile (dir, out error);
 168                                 } else {
 169                                         RecursiveDelete (dir);
 170                                 }
 171                         }
 172
 173                         foreach (string file in GetFiles (path))
 174                                 File.Delete (file);
 175
 176                         Directory.Delete (path);
 177                 }
 178
 179                 public static void Delete (string path, bool recursive)
 180                 {
 181                         Path.Validate (path);
 182                         SecurityManager.EnsureElevatedPermissions (); // this is a no-op outside moonlight
 183
 184                         if (recursive)
 185                                 RecursiveDelete (path);
 186                         else
 187                                 Delete (path);
 188                 }
 189
 190                 public static bool Exists (string path)
 191                 {
 192                         if (path == null)
 193                                 return false;
 194
 195                         // on Moonlight this does not throw but returns false
 196                         if (!SecurityManager.CheckElevatedPermissions ())
 197                                 return false;
 198
 199                         MonoIOError error;
 200                         bool exists;
 201
 202                         exists = MonoIO.ExistsDirectory (path, out error);
 203                         /* This should not throw exceptions */
 204                         return exists;
 205                 }
 206
 207                 public static DateTime GetLastAccessTime (string path)
 208                 {
 209                         return File.GetLastAccessTime (path);
 210                 }
 211
 212                 public static DateTime GetLastAccessTimeUtc (string path)
 213                 {
 214                         return GetLastAccessTime (path).ToUniversalTime ();
 215                 }
 216
 217                 public static DateTime GetLastWriteTime (string path)
 218                 {
 219                         return File.GetLastWriteTime (path);
 220                 }
 221
 222                 public static DateTime GetLastWriteTimeUtc (string path)
 223                 {
 224                         return GetLastWriteTime (path).ToUniversalTime ();
 225                 }
 226
 227                 public static DateTime GetCreationTime (string path)
 228                 {
 229                         return File.GetCreationTime (path);
 230                 }
 231
 232                 public static DateTime GetCreationTimeUtc (string path)
 233                 {
 234                         return GetCreationTime (path).ToUniversalTime ();
 235                 }
 236
 237                 public static string GetCurrentDirectory ()
 238                 {
 239                         MonoIOError error;
 240
 241                         SecurityManager.EnsureElevatedPermissions (); // this is a no-op outside moonlight
 242
 243                         string result = MonoIO.GetCurrentDirectory (out error);
 244                         if (error != MonoIOError.ERROR_SUCCESS)
 245                                 throw MonoIO.GetException (error);
 246 #if !NET_2_1
 247                         if ((result != null) && (result.Length > 0) && SecurityManager.SecurityEnabled) {
 248                                 new FileIOPermission (FileIOPermissionAccess.PathDiscovery, result).Demand ();
 249                         }
 250 #endif
 251                         return result;
 252                 }
 253
 254                 public static string [] GetDirectories (string path)
 255                 {
 256                         return GetDirectories (path, "*");
 257                 }
 258
 259                 public static string [] GetDirectories (string path, string searchPattern)
 260                 {
 261                         return GetFileSystemEntries (path, searchPattern, FileAttributes.Directory, FileAttributes.Directory);
 262                 }
 263
 264 #if !MOONLIGHT
 265                 public static string [] GetDirectories (string path, string searchPattern, SearchOption searchOption)
 266                 {
 267                         if (searchOption == SearchOption.TopDirectoryOnly)
 268                                 return GetDirectories (path, searchPattern);
 269                         var all = new List<string> ();
 270                         GetDirectoriesRecurse (path, searchPattern, all);
 271                         return all.ToArray ();
 272                 }
 273
 274                 static void GetDirectoriesRecurse (string path, string searchPattern, List<string> all)
 275                 {
 276                         all.AddRange (GetDirectories (path, searchPattern));
 277                         foreach (string dir in GetDirectories (path))
 278                                 GetDirectoriesRecurse (dir, searchPattern, all);
 279                 }
 280 #endif
 281
 282                 public static string GetDirectoryRoot (string path)
 283                 {
 284                         Path.Validate (path);
 285                         SecurityManager.EnsureElevatedPermissions (); // this is a no-op outside moonlight
 286
 287                         // FIXME nice hack but that does not work under windows
 288                         return new String(Path.DirectorySeparatorChar,1);
 289                 }
 290
 291                 public static string [] GetFiles (string path)
 292                 {
 293                         return GetFiles (path, "*");
 294                 }
 295
 296                 public static string [] GetFiles (string path, string searchPattern)
 297                 {
 298                         return GetFileSystemEntries (path, searchPattern, FileAttributes.Directory, 0);
 299                 }
 300
 301 #if !MOONLIGHT
 302                 public static string[] GetFiles (string path, string searchPattern, SearchOption searchOption)
 303                 {
 304                         if (searchOption == SearchOption.TopDirectoryOnly)
 305                                 return GetFiles (path, searchPattern);
 306                         var all = new List<string> ();
 307                         GetFilesRecurse (path, searchPattern, all);
 308                         return all.ToArray ();
 309                 }
 310
 311                 static void GetFilesRecurse (string path, string searchPattern, List<string> all)
 312                 {
 313                         all.AddRange (GetFiles (path, searchPattern));
 314                         foreach (string dir in GetDirectories (path))
 315                                 GetFilesRecurse (dir, searchPattern, all);
 316                 }
 317 #endif
 318
 319                 public static string [] GetFileSystemEntries (string path)
 320                 {
 321                         return GetFileSystemEntries (path, "*");
 322                 }
 323
 324                 public static string [] GetFileSystemEntries (string path, string searchPattern)
 325                 {
 326                         return GetFileSystemEntries (path, searchPattern, 0, 0);
 327                 }
 328
 329                 public static string[] GetLogicalDrives ()
 330                 {
 331                         return Environment.GetLogicalDrives ();
 332                 }
 333
 334                 static bool IsRootDirectory (string path)
 335                 {
 336                         // Unix
 337                         if (Path.DirectorySeparatorChar == '/' && path == "/")
 338                                 return true;
 339
 340                         // Windows
 341                         if (Path.DirectorySeparatorChar == '\\')
 342                                 if (path.Length == 3 && path.EndsWith (":\\"))
 343                                         return true;
 344
 345                         return false;
 346                 }
 347
 348                 public static DirectoryInfo GetParent (string path)
 349                 {
 350                         Path.Validate (path);
 351
 352                         // return null if the path is the root directory
 353                         if (IsRootDirectory (path))
 354                                 return null;
 355
 356                         string parent_name = Path.GetDirectoryName (path);
 357                         if (parent_name.Length == 0)
 358                                 parent_name = GetCurrentDirectory();
 359
 360                         return new DirectoryInfo (parent_name);
 361                 }
 362
 363                 public static void Move (string sourceDirName, string destDirName)
 364                 {
 365                         if (sourceDirName == null)
 366                                 throw new ArgumentNullException ("sourceDirName");
 367
 368                         if (destDirName == null)
 369                                 throw new ArgumentNullException ("destDirName");
 370
 371                         if (sourceDirName.Trim ().Length == 0 || sourceDirName.IndexOfAny (Path.InvalidPathChars) != -1)
 372                                 throw new ArgumentException ("Invalid source directory name: " + sourceDirName, "sourceDirName");
 373
 374                         if (destDirName.Trim ().Length == 0 || destDirName.IndexOfAny (Path.InvalidPathChars) != -1)
 375                                 throw new ArgumentException ("Invalid target directory name: " + destDirName, "destDirName");
 376
 377                         if (sourceDirName == destDirName)
 378                                 throw new IOException ("Source and destination path must be different.");
 379
 380                         SecurityManager.EnsureElevatedPermissions (); // this is a no-op outside moonlight
 381
 382                         if (Exists (destDirName))
 383                                 throw new IOException (destDirName + " already exists.");
 384
 385                         if (!Exists (sourceDirName) && !File.Exists (sourceDirName))
 386                                 throw new DirectoryNotFoundException (sourceDirName + " does not exist");
 387
 388                         MonoIOError error;
 389                         if (!MonoIO.MoveFile (sourceDirName, destDirName, out error))
 390                                 throw MonoIO.GetException (error);
 391                 }
 392
 393 #if !MOONLIGHT
 394                 public static void SetAccessControl (string path, DirectorySecurity directorySecurity)
 395                 {
 396                         if (null == directorySecurity)
 397                                 throw new ArgumentNullException ("directorySecurity");
 398
 399                         directorySecurity.PersistModifications (path);
 400                 }
 401 #endif
 402
 403                 public static void SetCreationTime (string path, DateTime creationTime)
 404                 {
 405                         File.SetCreationTime (path, creationTime);
 406                 }
 407
 408                 public static void SetCreationTimeUtc (string path, DateTime creationTimeUtc)
 409                 {
 410                         SetCreationTime (path, creationTimeUtc.ToLocalTime ());
 411                 }
 412
 413                 [SecurityPermission (SecurityAction.Demand, UnmanagedCode = true)]
 414                 public static void SetCurrentDirectory (string path)
 415                 {
 416                         if (path == null)
 417                                 throw new ArgumentNullException ("path");
 418                         if (path.Trim ().Length == 0)
 419                                 throw new ArgumentException ("path string must not be an empty string or whitespace string");
 420
 421                         MonoIOError error;
 422
 423                         if (!Exists (path))
 424                                 throw new DirectoryNotFoundException ("Directory \"" +
 425                                                                         path + "\" not found.");
 426
 427                         MonoIO.SetCurrentDirectory (path, out error);
 428                         if (error != MonoIOError.ERROR_SUCCESS)
 429                                 throw MonoIO.GetException (path, error);
 430                 }
 431
 432                 public static void SetLastAccessTime (string path, DateTime lastAccessTime)
 433                 {
 434                         File.SetLastAccessTime (path, lastAccessTime);
 435                 }
 436
 437                 public static void SetLastAccessTimeUtc (string path, DateTime lastAccessTimeUtc)
 438                 {
 439                         SetLastAccessTime (path, lastAccessTimeUtc.ToLocalTime ());
 440                 }
 441
 442                 public static void SetLastWriteTime (string path, DateTime lastWriteTime)
 443                 {
 444                         File.SetLastWriteTime (path, lastWriteTime);
 445                 }
 446
 447                 public static void SetLastWriteTimeUtc (string path, DateTime lastWriteTimeUtc)
 448                 {
 449                         SetLastWriteTime (path, lastWriteTimeUtc.ToLocalTime ());
 450                 }
 451
 452                 // private
 453
 454                 // Does the common validation, searchPattern has already been checked for not-null
 455                 static string ValidateDirectoryListing (string path, string searchPattern, out bool stop)
 456                 {
 457                         Path.Validate (path);
 458
 459                         string wild = Path.Combine (path, searchPattern);
 460                         string wildpath = Path.GetDirectoryName (wild);
 461                         if (wildpath.IndexOfAny (Path.InvalidPathChars) != -1)
 462                                 throw new ArgumentException ("Pattern contains invalid characters", "pattern");
 463
 464                         MonoIOError error;
 465                         if (!MonoIO.ExistsDirectory (wildpath, out error)) {
 466                                 if (error == MonoIOError.ERROR_SUCCESS) {
 467                                         MonoIOError file_error;
 468                                         if (MonoIO.ExistsFile (wildpath, out file_error))
 469                                                 throw new IOException ("The directory name is invalid.");
 470                                 }
 471
 472                                 if (error != MonoIOError.ERROR_PATH_NOT_FOUND)
 473                                         throw MonoIO.GetException (wildpath, error);
 474
 475                                 if (wildpath.IndexOfAny (SearchPattern.WildcardChars) == -1)
 476                                         throw new DirectoryNotFoundException ("Directory '" + wildpath + "' not found.");
 477
 478                                 if (path.IndexOfAny (SearchPattern.WildcardChars) == -1)
 479                                         throw new ArgumentException ("Pattern is invalid", "searchPattern");
 480
 481                                 throw new ArgumentException ("Path is invalid", "path");
 482                         }
 483
 484                         stop = false;
 485                         return wild;
 486                 }
 487
 488                 private static string [] GetFileSystemEntries (string path, string searchPattern, FileAttributes mask, FileAttributes attrs)
 489                 {
 490                         if (searchPattern == null)
 491                                 throw new ArgumentNullException ("searchPattern");
 492                         if (searchPattern.Length == 0)
 493                                 return new string [] {};
 494                         bool stop;
 495                         string path_with_pattern = ValidateDirectoryListing (path, searchPattern, out stop);
 496                         if (stop)
 497                                 return new string [] { path_with_pattern };
 498
 499                         MonoIOError error;
 500                         string [] result = MonoIO.GetFileSystemEntries (path, path_with_pattern, (int) attrs, (int) mask, out error);
 501                         if (error != 0)
 502                                 throw MonoIO.GetException (Path.GetDirectoryName (Path.Combine (path, searchPattern)), error);
 503
 504                         return result;
 505                 }
 506
 507 #if NET_4_0 || MOONLIGHT || MOBILE
 508                 public static string[] GetFileSystemEntries (string path, string searchPattern, SearchOption searchOption)
 509                 {
 510                         // Take the simple way home:
 511                         return new List<string> (EnumerateFileSystemEntries (path, searchPattern, searchOption)).ToArray ();
 512                 }
 513
 514                 static void EnumerateCheck (string path, string searchPattern, SearchOption searchOption)
 515                 {
 516                         if (searchPattern == null)
 517                                 throw new ArgumentNullException ("searchPattern");
 518
 519                         if (searchPattern.Length == 0)
 520                                 return;
 521
 522                         if (searchOption != SearchOption.TopDirectoryOnly && searchOption != SearchOption.AllDirectories)
 523                                 throw new ArgumentOutOfRangeException ("searchoption");
 524
 525                         Path.Validate (path);
 526                         SecurityManager.EnsureElevatedPermissions (); // this is a no-op outside moonlight
 527                 }
 528
 529                 internal static IEnumerable<string> EnumerateKind (string path, string searchPattern, SearchOption searchOption, FileAttributes kind)
 530                 {
 531                         if (searchPattern.Length == 0)
 532                                 yield break;
 533
 534                         bool stop;
 535                         string path_with_pattern = ValidateDirectoryListing (path, searchPattern, out stop);
 536                         if (stop){
 537                                 yield return path_with_pattern;
 538                                 yield break;
 539                         }
 540
 541                         IntPtr handle;
 542                         MonoIOError error;
 543                         FileAttributes rattr;
 544                         bool subdirs = searchOption == SearchOption.AllDirectories;
 545
 546                         string s = MonoIO.FindFirst (path, path_with_pattern, out rattr, out error, out handle);
 547                         if (s == null)
 548                                 yield break;
 549                         if (error != 0)
 550                                 throw MonoIO.GetException (Path.GetDirectoryName (Path.Combine (path, searchPattern)), (MonoIOError) error);
 551
 552                         try {
 553                                 //
 554                                 // Convert any file specific flag to FileAttributes.Normal which is used as include files flag
 555                                 //
 556                                 if (((rattr & FileAttributes.Directory) == 0) && rattr != 0)
 557                                         rattr |= FileAttributes.Normal;
 558
 559                                 bool first = true;
 560                                 if (((rattr & FileAttributes.ReparsePoint) == 0) && ((rattr & kind) != 0))
 561                                         yield return s;
 562
 563                                 do {
 564                                         if (((rattr & FileAttributes.Directory) != 0) && subdirs) {
 565                                                 foreach (string child in EnumerateKind (s, searchPattern, searchOption, kind))
 566                                                         yield return child;
 567                                         }
 568
 569                                         if (first) {
 570                                                 first = false;
 571                                                 continue;
 572                                         }
 573
 574                                         if ((rattr & FileAttributes.ReparsePoint) != 0)
 575                                                 continue;
 576
 577                                         if ((rattr & kind) != 0)
 578                                                 yield return s;
 579                                 } while ((s = MonoIO.FindNext (handle, out rattr, out error)) != null);
 580                         } finally {
 581                                 MonoIO.FindClose (handle);
 582                         }
 583                 }
 584
 585                 public static IEnumerable<string> EnumerateDirectories (string path, string searchPattern, SearchOption searchOption)
 586                 {
 587                         EnumerateCheck (path, searchPattern, searchOption);
 588                         return EnumerateKind (path, searchPattern, searchOption, FileAttributes.Directory);
 589                 }
 590
 591                 public static IEnumerable<string> EnumerateDirectories (string path, string searchPattern)
 592                 {
 593                         EnumerateCheck (path, searchPattern, SearchOption.TopDirectoryOnly);
 594                         return EnumerateKind (path, searchPattern, SearchOption.TopDirectoryOnly, FileAttributes.Directory);
 595                 }
 596
 597                 public static IEnumerable<string> EnumerateDirectories (string path)
 598                 {
 599                         Path.Validate (path); // no need for EnumerateCheck since we supply valid arguments
 600                         SecurityManager.EnsureElevatedPermissions (); // this is a no-op outside moonlight
 601                         return EnumerateKind (path, "*", SearchOption.TopDirectoryOnly, FileAttributes.Directory);
 602                 }
 603
 604                 public static IEnumerable<string> EnumerateFiles (string path, string searchPattern, SearchOption searchOption)
 605                 {
 606                         EnumerateCheck (path, searchPattern, searchOption);
 607                         return EnumerateKind (path, searchPattern, searchOption, FileAttributes.Normal);
 608                 }
 609
 610                 public static IEnumerable<string> EnumerateFiles (string path, string searchPattern)
 611                 {
 612                         EnumerateCheck (path, searchPattern, SearchOption.TopDirectoryOnly);
 613                         return EnumerateKind (path, searchPattern, SearchOption.TopDirectoryOnly, FileAttributes.Normal);
 614                 }
 615
 616                 public static IEnumerable<string> EnumerateFiles (string path)
 617                 {
 618                         Path.Validate (path); // no need for EnumerateCheck since we supply valid arguments
 619                         SecurityManager.EnsureElevatedPermissions (); // this is a no-op outside moonlight
 620                         return EnumerateKind (path, "*", SearchOption.TopDirectoryOnly, FileAttributes.Normal);
 621                 }
 622
 623                 public static IEnumerable<string> EnumerateFileSystemEntries (string path, string searchPattern, SearchOption searchOption)
 624                 {
 625                         EnumerateCheck (path, searchPattern, searchOption);
 626                         return EnumerateKind (path, searchPattern, searchOption, FileAttributes.Normal | FileAttributes.Directory);
 627                 }
 628
 629                 public static IEnumerable<string> EnumerateFileSystemEntries (string path, string searchPattern)
 630                 {
 631                         EnumerateCheck (path, searchPattern, SearchOption.TopDirectoryOnly);
 632                         return EnumerateKind (path, searchPattern, SearchOption.TopDirectoryOnly, FileAttributes.Normal | FileAttributes.Directory);
 633                 }
 634
 635                 public static IEnumerable<string> EnumerateFileSystemEntries (string path)
 636                 {
 637                         Path.Validate (path); // no need for EnumerateCheck since we supply valid arguments
 638                         SecurityManager.EnsureElevatedPermissions (); // this is a no-op outside moonlight
 639                         return EnumerateKind (path, "*", SearchOption.TopDirectoryOnly, FileAttributes.Normal | FileAttributes.Directory);
 640                 }
 641
 642 #endif
 643
 644 #if !MOONLIGHT
 645                 public static DirectorySecurity GetAccessControl (string path, AccessControlSections includeSections)
 646                 {
 647                         return new DirectorySecurity (path, includeSections);
 648                 }
 649
 650                 public static DirectorySecurity GetAccessControl (string path)
 651                 {
 652                         // AccessControlSections.Audit requires special permissions.
 653                         return GetAccessControl (path,
 654                                                  AccessControlSections.Owner |
 655                                                  AccessControlSections.Group |
 656                                                  AccessControlSections.Access);
 657                 }
 658 #endif
 659         }
 660 }