//------------------------------------------------------------------------------
//
-// Copyright (C) 2004 Novell, Inc (http://www.novell.com)
+// Copyright (C) 2004, 2006 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
-using System;
+using System.Runtime.InteropServices;
+using System.Runtime.Serialization;
+using System.Security;
+
+#if !NET_2_1
+using System.Security.AccessControl;
+#endif
namespace System.IO {
[Serializable]
- public sealed class FileInfo : FileSystemInfo {
-
-
+ [ComVisible (true)]
+ public sealed class FileInfo : FileSystemInfo
+ {
private bool exists;
- public FileInfo (string path) {
- CheckPath (path);
-
- OriginalPath = path;
- FullPath = Path.GetFullPath (path);
+#if MOONLIGHT
+ internal FileInfo ()
+ {
}
-
+#endif
+ public FileInfo (string fileName)
+ {
+ if (fileName == null)
+ throw new ArgumentNullException ("fileName");
+
+ CheckPath (fileName);
+ SecurityManager.EnsureElevatedPermissions (); // this is a no-op outside moonlight
+
+ OriginalPath = fileName;
+ FullPath = Path.GetFullPath (fileName);
+ }
+
+ private FileInfo (SerializationInfo info, StreamingContext context)
+ : base (info, context)
+ {
+ }
+
internal override void InternalRefresh ()
{
exists = File.Exists (FullPath);
}
-
// public properties
public override bool Exists {
}
}
-#if NET_2_0
+#if !NET_2_1
public bool IsReadOnly {
get {
if (!Exists)
if (value)
attrs |= FileAttributes.ReadOnly;
else
- attrs &= ~FileAttributes.ReadOnly;
+ attrs &= ~FileAttributes.ReadOnly;
File.SetAttributes(FullPath, attrs);
}
}
+
+ [MonoLimitation ("File encryption isn't supported (even on NTFS).")]
+ [ComVisible (false)]
+ public void Encrypt ()
+ {
+ // MS.NET support this only on NTFS file systems, i.e. it's a file-system (not a framework) feature.
+ // otherwise it throws a NotSupportedException (or a PlatformNotSupportedException on older OS).
+ // we throw the same (instead of a NotImplementedException) because most code should already be
+ // handling this exception to work properly.
+ throw new NotSupportedException (Locale.GetText ("File encryption isn't supported on any file system."));
+ }
+
+ [MonoLimitation ("File encryption isn't supported (even on NTFS).")]
+ [ComVisible (false)]
+ public void Decrypt ()
+ {
+ // MS.NET support this only on NTFS file systems, i.e. it's a file-system (not a framework) feature.
+ // otherwise it throws a NotSupportedException (or a PlatformNotSupportedException on older OS).
+ // we throw the same (instead of a NotImplementedException) because most code should already be
+ // handling this exception to work properly.
+ throw new NotSupportedException (Locale.GetText ("File encryption isn't supported on any file system."));
+ }
#endif
public long Length {
// streamreader methods
- public StreamReader OpenText () {
+ public StreamReader OpenText ()
+ {
return new StreamReader (Open (FileMode.Open, FileAccess.Read));
}
- public StreamWriter CreateText () {
+ public StreamWriter CreateText ()
+ {
return new StreamWriter (Open (FileMode.Create, FileAccess.Write));
}
- public StreamWriter AppendText () {
+ public StreamWriter AppendText ()
+ {
return new StreamWriter (Open (FileMode.Append, FileAccess.Write));
}
{
return File.Create (FullPath);
}
-
-
- public FileStream OpenRead () {
+
+ public FileStream OpenRead ()
+ {
return Open (FileMode.Open, FileAccess.Read, FileShare.Read);
}
- public FileStream OpenWrite () {
+ public FileStream OpenWrite ()
+ {
return Open (FileMode.OpenOrCreate, FileAccess.Write);
}
- public FileStream Open (FileMode mode) {
+ public FileStream Open (FileMode mode)
+ {
return Open (mode, FileAccess.ReadWrite);
}
- public FileStream Open (FileMode mode, FileAccess access) {
+ public FileStream Open (FileMode mode, FileAccess access)
+ {
return Open (mode, access, FileShare.None);
}
- public FileStream Open (FileMode mode, FileAccess access, FileShare share) {
+ public FileStream Open (FileMode mode, FileAccess access, FileShare share)
+ {
return new FileStream (FullPath, mode, access, share);
}
// file methods
- public override void Delete () {
+ public override void Delete ()
+ {
MonoIOError error;
-
- if (!MonoIO.Exists (FullPath, out error)) {
+
+ SecurityManager.EnsureElevatedPermissions (); // this is a no-op outside moonlight
+
+ if (!MonoIO.Exists (FullPath, out error))
// a weird MS.NET behaviour
return;
- }
- if (MonoIO.ExistsDirectory (FullPath, out error)) {
+ if (MonoIO.ExistsDirectory (FullPath, out error))
throw new UnauthorizedAccessException ("Access to the path \"" + FullPath + "\" is denied.");
- }
-
- if (!MonoIO.DeleteFile (FullPath, out error)) {
- throw MonoIO.GetException (OriginalPath,
- error);
- }
+ if (!MonoIO.DeleteFile (FullPath, out error))
+ throw MonoIO.GetException (OriginalPath, error);
}
-
- public void MoveTo (string dest) {
-
- if (dest == null)
- throw new ArgumentNullException ();
- if (dest == Name || dest == FullName)
- return;
+ public void MoveTo (string destFileName)
+ {
+ if (destFileName == null)
+ throw new ArgumentNullException ("destFileName");
+ if (destFileName == Name || destFileName == FullName)
+ return;
+ if (!File.Exists (FullPath))
+ throw new FileNotFoundException ();
- MonoIOError error;
- if (MonoIO.Exists (dest, out error) ||
- MonoIO.ExistsDirectory (dest, out error))
- throw new IOException ();
- File.Move (FullPath, dest);
- this.FullPath = Path.GetFullPath (dest);
+ File.Move (FullPath, destFileName);
+ this.FullPath = Path.GetFullPath (destFileName);
}
- public FileInfo CopyTo (string path) {
- return CopyTo (path, false);
+ public FileInfo CopyTo (string destFileName)
+ {
+ return CopyTo (destFileName, false);
}
- public FileInfo CopyTo (string path, bool overwrite) {
- string dest = Path.GetFullPath (path);
+ public FileInfo CopyTo (string destFileName, bool overwrite)
+ {
+ if (destFileName == null)
+ throw new ArgumentNullException ("destFileName");
+ if (destFileName.Length == 0)
+ throw new ArgumentException ("An empty file name is not valid.", "destFileName");
+
+ string dest = Path.GetFullPath (destFileName);
- if (overwrite && File.Exists (path))
- File.Delete (path);
+ if (overwrite && File.Exists (dest))
+ File.Delete (dest);
File.Copy (FullPath, dest);
return new FileInfo (dest);
}
- public override string ToString () {
+ public override string ToString ()
+ {
+#if NET_2_1
+ // for Moonlight we *never* return paths, since ToString is not [SecurityCritical] we simply return the Name
+ return Name;
+#else
return OriginalPath;
+#endif
}
+
+#if !NET_2_1
+ public FileSecurity GetAccessControl ()
+ {
+ throw new NotImplementedException ();
+ }
+
+ public FileSecurity GetAccessControl (AccessControlSections includeSections)
+ {
+ throw new NotImplementedException ();
+ }
+
+ [ComVisible (false)]
+ public FileInfo Replace (string destinationFileName,
+ string destinationBackupFileName)
+ {
+ string destinationFullPath = null;
+ if (!Exists)
+ throw new FileNotFoundException ();
+ if (destinationFileName == null)
+ throw new ArgumentNullException ("destinationFileName");
+ if (destinationFileName.Length == 0)
+ throw new ArgumentException ("An empty file name is not valid.", "destinationFileName");
+
+ destinationFullPath = Path.GetFullPath (destinationFileName);
+
+ if (!File.Exists (destinationFullPath))
+ throw new FileNotFoundException ();
+
+ FileAttributes attrs = File.GetAttributes (destinationFullPath);
+
+ if ( (attrs & FileAttributes.ReadOnly) == FileAttributes.ReadOnly)
+ throw new UnauthorizedAccessException ();
+
+ if (destinationBackupFileName != null) {
+ if (destinationBackupFileName.Length == 0)
+ throw new ArgumentException ("An empty file name is not valid.", "destinationBackupFileName");
+ File.Copy (destinationFullPath, Path.GetFullPath (destinationBackupFileName), true);
+ }
+ File.Copy (FullPath, destinationFullPath,true);
+ File.Delete (FullPath);
+ return new FileInfo (destinationFullPath);
+ }
+
+ [ComVisible (false)]
+ [MonoLimitation ("We ignore the ignoreMetadataErrors parameter")]
+ public FileInfo Replace (string destinationFileName,
+ string destinationBackupFileName,
+ bool ignoreMetadataErrors)
+ {
+ return Replace (destinationFileName, destinationBackupFileName);
+ }
+
+ public void SetAccessControl (FileSecurity fileSecurity)
+ {
+ throw new NotImplementedException ();
+ }
+#endif
}
}
projects / mono.git / blobdiff