mcs/class/corlib/System.IO.IsolatedStorage/MoonIsolatedStorageFile.cs

   1 //
   2 // System.IO.IsolatedStorage.MoonIsolatedStorageFile
   3 //
   4 // Moonlight's implementation for the IsolatedStorageFile
   5 //
   6 // Authors
   7 //      Miguel de Icaza (miguel@novell.com)
   8 //      Sebastien Pouliot  <sebastien@ximian.com>
   9 //
  10 // Copyright (C) 2007, 2008, 2009 Novell, Inc (http://www.novell.com)
  11 //
  12 // Permission is hereby granted, free of charge, to any person obtaining
  13 // a copy of this software and associated documentation files (the
  14 // "Software"), to deal in the Software without restriction, including
  15 // without limitation the rights to use, copy, modify, merge, publish,
  16 // distribute, sublicense, and/or sell copies of the Software, and to
  17 // permit persons to whom the Software is furnished to do so, subject to
  18 // the following conditions:
  19 //
  20 // The above copyright notice and this permission notice shall be
  21 // included in all copies or substantial portions of the Software.
  22 //
  23 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  24 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  25 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  26 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  27 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  28 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  29 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  30 //
  31 #if NET_2_1
  32 using System;
  33 using System.IO;
  34 using System.Runtime.InteropServices;
  35 using System.Security;
  36
  37 namespace System.IO.IsolatedStorage {
  38
  39         // Most of the time there will only be a single instance of both
  40         // * Application Store (GetUserStoreForApplication)
  41         // * Site Store (GetUserStoreForSite)
  42         // However both can have multiple concurrent uses, e.g.
  43         // * another instance of the same application (same URL) running in another Moonlight instance
  44         // * another application on the same site (i.e. host) for a site store
  45         // and share the some quota, i.e. a site and all applications on the sites share the same space
  46
  47         // notes:
  48         // * quota seems computed in (disk) blocks, i.e. a small file will have a (non-small) size
  49         // e.g. every files and directories entries takes 1KB
  50
  51         public sealed class IsolatedStorageFile : IDisposable {
  52
  53                 static object locker = new object ();
  54
  55                 private string basedir;
  56                 private long used;
  57                 private bool removed = false;
  58                 private bool disposed = false;
  59
  60                 internal IsolatedStorageFile (string root)
  61                 {
  62                         basedir = root;
  63                 }
  64
  65                 internal void PreCheck ()
  66                 {
  67                         if (disposed)
  68                                 throw new ObjectDisposedException ("Storage was disposed");
  69                         if (removed)
  70                                 throw new IsolatedStorageException ("Storage was removed");
  71                 }
  72
  73                 public static IsolatedStorageFile GetUserStoreForApplication ()
  74                 {
  75                         return new IsolatedStorageFile (IsolatedStorage.ApplicationPath);
  76                 }
  77
  78                 public static IsolatedStorageFile GetUserStoreForSite ()
  79                 {
  80                         return new IsolatedStorageFile (IsolatedStorage.SitePath);
  81                 }
  82
  83                 internal string Verify (string path)
  84                 {
  85                         // special case: 'path' would be returned (instead of combined)
  86                         if ((path.Length > 0) && (path [0] == '/'))
  87                                 path = path.Substring (1, path.Length - 1);
  88
  89                         // outside of try/catch since we want to get things like
  90                         //      ArgumentException for invalid characters
  91                         string combined = Path.Combine (basedir, path);
  92                         try {
  93                                 string full = Path.GetFullPath (combined);
  94                                 if (full.StartsWith (basedir))
  95                                         return full;
  96                         } catch {
  97                                 // we do not supply an inner exception since it could contains details about the path
  98                                 throw new IsolatedStorageException ();
  99                         }
 100                         throw new IsolatedStorageException ();
 101                 }
 102
 103                 public void CreateDirectory (string dir)
 104                 {
 105                         PreCheck ();
 106                         if (dir == null)
 107                                 throw new ArgumentNullException ("dir");
 108                         // empty dir is ignored
 109                         if (dir.Length > 0)
 110                                 Directory.CreateDirectory (Verify (dir));
 111                 }
 112
 113                 public IsolatedStorageFileStream CreateFile (string path)
 114                 {
 115                         PreCheck ();
 116                         try {
 117                                 return new IsolatedStorageFileStream (path, FileMode.Create, this);
 118                         }
 119                         catch (DirectoryNotFoundException) {
 120                                 // this can happen if the supplied path includes an unexisting directory
 121                                 throw new IsolatedStorageException ();
 122                         }
 123                 }
 124
 125                 public void DeleteDirectory (string dir)
 126                 {
 127                         PreCheck ();
 128                         if (dir == null)
 129                                 throw new ArgumentNullException ("dir");
 130                         Directory.Delete (Verify (dir));
 131                 }
 132
 133                 public void DeleteFile (string file)
 134                 {
 135                         PreCheck ();
 136                         if (file == null)
 137                                 throw new ArgumentNullException ("file");
 138                         string checked_filename = Verify (file);
 139                         if (!File.Exists (checked_filename))
 140                                 throw new IsolatedStorageException ("File does not exists");
 141                         File.Delete (checked_filename);
 142                 }
 143
 144                 public void Dispose ()
 145                 {
 146                         disposed = true;
 147                 }
 148
 149                 public bool DirectoryExists (string path)
 150                 {
 151                         PreCheck ();
 152                         return Directory.Exists (Verify (path));
 153                 }
 154
 155                 public bool FileExists (string path)
 156                 {
 157                         PreCheck ();
 158                         return File.Exists (Verify (path));
 159                 }
 160
 161                 private string HideAppDir (string path)
 162                 {
 163                         // remove the "isolated" part of the path (and the extra '/')
 164                         return path.Substring (basedir.Length + 1);
 165                 }
 166
 167                 private string [] HideAppDirs (string[] paths)
 168                 {
 169                         for (int i=0; i < paths.Length; i++)
 170                                 paths [i] = HideAppDir (paths [i]);
 171                         return paths;
 172                 }
 173
 174                 public string [] GetDirectoryNames ()
 175                 {
 176                         return HideAppDirs (Directory.GetDirectories (basedir));
 177                 }
 178
 179                 public string [] GetDirectoryNames (string searchPattern)
 180                 {
 181                         if (searchPattern.IndexOf ('/') != -1)
 182                                 throw new IsolatedStorageException ();
 183
 184                         return HideAppDirs (Directory.GetDirectories (basedir, searchPattern));
 185                 }
 186
 187                 public string [] GetFileNames ()
 188                 {
 189                         return HideAppDirs (Directory.GetFiles (basedir));
 190                 }
 191
 192                 public string [] GetFileNames (string searchPattern)
 193                 {
 194                         if (searchPattern == null)
 195                                 throw new ArgumentNullException ("searchPattern");
 196
 197                         // note: IsolatedStorageFile accept a "dir/file" pattern which is not allowed by DirectoryInfo
 198                         // so we need to split them to get the right results
 199                         string path = Path.GetDirectoryName (searchPattern);
 200                         string pattern = Path.GetFileName (searchPattern);
 201                         string [] afi = null;
 202
 203                         if (path == null || path.Length == 0) {
 204                                 return HideAppDirs (Directory.GetFiles (basedir, searchPattern));
 205                         } else {
 206                                 // we're looking for a single result, identical to path (no pattern here)
 207                                 // we're also looking for something under the current path (not outside isolated storage)
 208
 209                                 string [] subdirs = Directory.GetDirectories (basedir, path);
 210                                 if (subdirs.Length != 1 || subdirs [0].IndexOf (basedir) < 0)
 211                                         throw new IsolatedStorageException ();
 212
 213                                 DirectoryInfo dir = new DirectoryInfo (subdirs [0]);
 214                                 if (dir.Name != path)
 215                                         throw new IsolatedStorageException ();
 216
 217                                 return GetNames (dir.GetFiles (pattern));
 218                         }
 219                 }
 220
 221                 // Return the file name portion of a full path
 222                 private string[] GetNames (FileSystemInfo[] afsi)
 223                 {
 224                         string[] r = new string[afsi.Length];
 225                         for (int i = 0; i != afsi.Length; ++i)
 226                                 r[i] = afsi[i].Name;
 227                         return r;
 228                 }
 229
 230                 public IsolatedStorageFileStream OpenFile (string path, FileMode mode)
 231                 {
 232                         return OpenFile (path, mode, FileAccess.ReadWrite, FileShare.None);
 233                 }
 234
 235                 public IsolatedStorageFileStream OpenFile (string path, FileMode mode, FileAccess access)
 236                 {
 237                         return OpenFile (path, mode, access, FileShare.None);
 238                 }
 239
 240                 public IsolatedStorageFileStream OpenFile (string path, FileMode mode, FileAccess access, FileShare share)
 241                 {
 242                         PreCheck ();
 243                         return new IsolatedStorageFileStream (path, mode, access, share, this);
 244                 }
 245
 246                 public void Remove ()
 247                 {
 248                         PreCheck ();
 249                         IsolatedStorage.Remove (basedir);
 250                         removed = true;
 251                 }
 252
 253                 // note: available free space could be changed from another application (same URL, another ML instance) or
 254                 // another application on the same site
 255                 public long AvailableFreeSpace {
 256                         get {
 257                                 PreCheck ();
 258                                 return IsolatedStorage.AvailableFreeSpace;
 259                         }
 260                 }
 261
 262                 // note: quota could be changed from another application (same URL, another ML instance) or
 263                 // another application on the same site
 264                 public long Quota {
 265                         get {
 266                                 PreCheck ();
 267                                 return IsolatedStorage.Quota;
 268                         }
 269                 }
 270
 271                 [DllImport ("moon")]
 272                 [return: MarshalAs (UnmanagedType.Bool)]
 273                 extern static bool isolated_storage_increase_quota_to (string primary_text, string secondary_text);
 274
 275                 const long mb = 1024 * 1024;
 276
 277                 public bool IncreaseQuotaTo (long newQuotaSize)
 278                 {
 279                         PreCheck ();
 280
 281                         if (newQuotaSize <= Quota)
 282                                 throw new ArgumentException ("newQuotaSize", "Only increases are possible");
 283
 284                         string message = String.Format ("This web site, <u>{0}</u>, is requesting an increase of its local storage capacity on your computer. It is currently using <b>{1:F1} MB</b> out of a maximum of <b>{2:F1} MB</b>.",
 285                                 IsolatedStorage.Site, IsolatedStorage.Current / mb, IsolatedStorage.Quota / mb);
 286                         string question = String.Format ("Do you want to increase the web site quota to a new maximum of <b>{0:F1} MB</b> ?",
 287                                 newQuotaSize / mb);
 288                         bool result = isolated_storage_increase_quota_to (message, question);
 289                         if (result)
 290                                 IsolatedStorage.Quota = newQuotaSize;
 291                         return result;
 292                 }
 293         }
 294 }
 295 #endif