Beispiel #1
0
      public override void EraseFileSystemObject(StreamInfo info, ErasureMethod method,
 ErasureMethodProgressFunction callback)
      {
          VolumeInfo volume = VolumeInfo.FromMountpoint(info.DirectoryName);
             if (info.Length < Math.Max(volume.ClusterSize, 1024))
             {
          using (FileStream strm = info.Open(FileMode.Open, FileAccess.Write,
           FileShare.None))
          {
           method.Erase(strm, long.MaxValue,
            PrngManager.GetInstance(ManagerLibrary.Settings.ActivePrng), null);
          }
             }
             long fileArea = GetFileArea(info.FullName);
             if (fileArea == 0)
          return;
             using (FileStream strm = info.Open(FileMode.Open, FileAccess.Write,
          FileShare.None, FileOptions.WriteThrough))
             {
          strm.SetLength(fileArea);
          method.Erase(strm, long.MaxValue,
           PrngManager.GetInstance(ManagerLibrary.Settings.ActivePrng),
           callback
          );
          strm.Seek(0, SeekOrigin.Begin);
          strm.SetLength(0);
             }
      }
Beispiel #2
0
 public override long GetFileArea(string filePath)
 {
     StreamInfo info = new StreamInfo(filePath);
        VolumeInfo volume = VolumeInfo.FromMountPoint(info.Directory.FullName);
        long clusterSize = volume.ClusterSize;
        return (info.Length + (clusterSize - 1)) & ~(clusterSize - 1);
 }
Beispiel #3
0
      public override void EraseClusterTips(VolumeInfo info, ErasureMethod method,
 ClusterTipsSearchProgress searchCallback, ClusterTipsEraseProgress eraseCallback)
      {
          List<string> files = new List<string>();
             if (!info.IsMounted)
          throw new InvalidOperationException(S._("Could not erase cluster tips in {0} " +
           "as the volume is not mounted.", info.VolumeId));
             ListFiles(new DirectoryInfo(info.MountPoints[0]), files, searchCallback);
             for (int i = 0, j = files.Count; i != j; ++i)
             {
          StreamInfo streamInfo = new StreamInfo(files[i]);
          FileAttributes fileAttr = streamInfo.Attributes;
          try
          {
           streamInfo.Attributes = FileAttributes.Normal;
           EraseFileClusterTips(files[i], method);
          }
          catch (UnauthorizedAccessException)
          {
           Logger.Log(S._("{0} did not have its cluster tips erased because you do not " +
            "have the required permissions to erase the file cluster tips.", files[i]),
            LogLevel.Information);
          }
          catch (IOException e)
          {
           Logger.Log(S._("{0} did not have its cluster tips erased. The error returned " +
            "was: {1}", files[i], e.Message), LogLevel.Error);
          }
          finally
          {
           streamInfo.Attributes = fileAttr;
          }
          eraseCallback(i, files.Count, files[i]);
             }
      }
Beispiel #4
0
 public static IList<string> GetADSes(FileInfo info)
 {
     List<string> result = new List<string>();
        using (FileStream stream = new StreamInfo(info.FullName).Open(FileMode.Open,
     FileAccess.Read, FileShare.ReadWrite))
        using (SafeFileHandle streamHandle = stream.SafeFileHandle)
        {
     NativeMethods.FILE_STREAM_INFORMATION[] streams = GetADSes(streamHandle);
     foreach (NativeMethods.FILE_STREAM_INFORMATION streamInfo in streams)
     {
      string streamName = streamInfo.StreamName.Substring(1,
       streamInfo.StreamName.LastIndexOf(':') - 1);
      if (streamName.Length != 0)
       result.Add(streamName);
     }
        }
        return result.AsReadOnly();
 }
Beispiel #5
0
 private void EraseFileClusterTips(string file, ErasureMethod method)
 {
     StreamInfo streamInfo = new StreamInfo(file);
        DateTime lastAccess = streamInfo.LastAccessTime;
        DateTime lastWrite = streamInfo.LastWriteTime;
        DateTime created = streamInfo.CreationTime;
        long fileArea = GetFileArea(file);
        long fileLength = streamInfo.Length;
        if (fileArea == fileLength)
     return;
        using (FileStream stream = streamInfo.Open(FileMode.Open, FileAccess.Write,
     FileShare.None, FileOptions.WriteThrough))
        {
     try
     {
      stream.SetLength(fileArea);
      stream.Seek(fileLength, SeekOrigin.Begin);
      method.Erase(stream, long.MaxValue, PrngManager.GetInstance(
       ManagerLibrary.Settings.ActivePrng), null);
     }
     finally
     {
      stream.SetLength(fileLength);
      streamInfo.LastAccessTime = lastAccess;
      streamInfo.LastWriteTime = lastWrite;
      streamInfo.CreationTime = created;
     }
        }
 }
 private void EraseFilesystemObject(Task task, FileSystemObjectTarget target)
 {
     long dataTotal = 0;
        List<string> paths = target.GetPaths(out dataTotal);
        ErasureMethod method = target.Method;
        TaskEventArgs eventArgs = new TaskEventArgs(task);
        SteppedProgressManager progress = new SteppedProgressManager();
        target.Progress = progress;
        task.Progress.Steps.Add(new SteppedProgressManager.Step(progress, 1.0f / task.Targets.Count));
        for (int i = 0; i < paths.Count; ++i)
        {
     ProgressManager step = new ProgressManager();
     progress.Steps.Add(new SteppedProgressManager.Step(step,
      1.0f / paths.Count, S._("Erasing files...")));
     task.OnProgressChanged(target,
      new ProgressChangedEventArgs(step,
       new TaskProgressChangedEventArgs(paths[i], 0, method.Passes)));
     StreamInfo info = new StreamInfo(paths[i]);
     FileSystem fsManager = FileSystemManager.Get(
      VolumeInfo.FromMountpoint(info.DirectoryName));
     if (!info.Exists)
     {
      task.Log.LastSessionEntries.Add(new LogEntry(S._("The file {0} was not erased " +
       "as the file does not exist.", paths[i]), LogLevel.Notice));
      continue;
     }
     bool isReadOnly = false;
     try
     {
      if (isReadOnly = info.IsReadOnly)
       info.IsReadOnly = false;
      if ((info.Attributes & FileAttributes.Compressed) != 0 ||
       (info.Attributes & FileAttributes.Encrypted) != 0 ||
       (info.Attributes & FileAttributes.SparseFile) != 0)
      {
       task.Log.LastSessionEntries.Add(new LogEntry(S._("The file {0} could " +
        "not be erased because the file was either compressed, encrypted or " +
        "a sparse file.", info.FullName), LogLevel.Error));
      }
      fsManager.EraseFileSystemObject(info, method,
       delegate(long lastWritten, long totalData, int currentPass)
       {
        if (currentTask.Canceled)
     throw new OperationCanceledException(S._("The task was cancelled."));
        step.Completed += lastWritten;
        step.Total = totalData;
        task.OnProgressChanged(target,
     new ProgressChangedEventArgs(step,
      new TaskProgressChangedEventArgs(info.FullName, currentPass, method.Passes)));
       });
      FileInfo fileInfo = info.File;
      if (fileInfo != null)
       fsManager.DeleteFile(fileInfo);
      step.Completed = step.Total = 1;
     }
     catch (UnauthorizedAccessException)
     {
      task.Log.LastSessionEntries.Add(new LogEntry(S._("The file {0} could not " +
       "be erased because the file's permissions prevent access to the file.",
       info.FullName), LogLevel.Error));
     }
     catch (FileLoadException)
     {
      if (!ManagerLibrary.Settings.ForceUnlockLockedFiles)
       throw;
      List<System.Diagnostics.Process> processes = new List<System.Diagnostics.Process>();
      foreach (OpenHandle handle in OpenHandle.Items)
       if (handle.Path == paths[i])
        processes.Add(System.Diagnostics.Process.GetProcessById(handle.ProcessId));
      StringBuilder processStr = new StringBuilder();
      foreach (System.Diagnostics.Process process in processes)
       processStr.AppendFormat(System.Globalization.CultureInfo.InvariantCulture,
        "{0}, ", process.MainModule.FileName);
      task.Log.LastSessionEntries.Add(new LogEntry(S._(
       "Could not force closure of file \"{0}\" (locked by {1})",
       paths[i], processStr.ToString().Remove(processStr.Length - 2)), LogLevel.Error));
     }
     finally
     {
      if (isReadOnly && info.Exists && !info.IsReadOnly)
       info.IsReadOnly = isReadOnly;
     }
        }
        if (target is FolderTarget)
        {
     ProgressManager step = new ProgressManager();
     progress.Steps.Add(new SteppedProgressManager.Step(step,
      0.0f, S._("Removing folders...")));
     FolderTarget fldr = (FolderTarget)target;
     FileSystem fsManager = FileSystemManager.Get(VolumeInfo.FromMountpoint(fldr.Path));
     Action<DirectoryInfo> eraseEmptySubFolders = null;
     eraseEmptySubFolders = delegate(DirectoryInfo info)
     {
       foreach (DirectoryInfo subDir in info.GetDirectories())
        eraseEmptySubFolders(subDir);
       task.OnProgressChanged(target,
        new ProgressChangedEventArgs(step,
     new TaskProgressChangedEventArgs(info.FullName, 0, 0)));
       FileSystemInfo[] files = info.GetFileSystemInfos();
       if (files.Length == 0)
        fsManager.DeleteFolder(info);
     };
     eraseEmptySubFolders(new DirectoryInfo(fldr.Path));
     if (fldr.DeleteIfEmpty)
     {
      DirectoryInfo info = new DirectoryInfo(fldr.Path);
      task.OnProgressChanged(target,
       new ProgressChangedEventArgs(step,
        new TaskProgressChangedEventArgs(info.FullName, 0, 0)));
      bool isVolumeRoot = info.Parent == null;
      foreach (VolumeInfo volume in VolumeInfo.Volumes)
       foreach (string mountPoint in volume.MountPoints)
        if (info.FullName == mountPoint)
     isVolumeRoot = true;
      if (!isVolumeRoot && info.Exists && info.GetFiles("*", SearchOption.AllDirectories).Length == 0)
       fsManager.DeleteFolder(info);
     }
        }
        if (target is RecycleBinTarget)
        {
     ProgressManager step = new ProgressManager();
     progress.Steps.Add(new SteppedProgressManager.Step(step,
      0.0f, S._("Emptying recycle bin...")));
     task.OnProgressChanged(target,
      new ProgressChangedEventArgs(step,
       new TaskProgressChangedEventArgs(string.Empty, 0, 0)));
     ShellApi.EmptyRecycleBin(EmptyRecycleBinOptions.NoConfirmation |
      EmptyRecycleBinOptions.NoProgressUI | EmptyRecycleBinOptions.NoSound);
        }
        target.Progress = null;
 }
Beispiel #7
0
      public abstract void EraseFileSystemObject(StreamInfo info, ErasureMethod method,
 ErasureMethodProgressFunction callback);
Beispiel #8
0
      public override void EraseFileSystemObject(StreamInfo info, ErasureMethod method,
 ErasureMethodProgressFunction callback)
      {
          long fileArea = GetFileArea(info.FullName);
             using (FileStream strm = info.Open(FileMode.Open, FileAccess.Write,
          FileShare.None, FileOptions.WriteThrough))
             {
          strm.SetLength(fileArea);
          if (strm.Length != 0)
          {
           method.Erase(strm, long.MaxValue,
            PrngManager.GetInstance(ManagerLibrary.Settings.ActivePrng),
            callback
           );
          }
          strm.Seek(0, SeekOrigin.Begin);
          strm.SetLength(0);
             }
      }