Index: branches/eraser6/pluginsRewrite/Eraser.Manager/ErasureMethod.cs =================================================================== --- branches/eraser6/pluginsRewrite/Eraser.Manager/ErasureMethod.cs (revision 2285) +++ branches/eraser6/pluginsRewrite/Eraser.Manager/ErasureMethod.cs (revision 2352) @@ -23,327 +23,14 @@ using System.Collections.Generic; using System.Text; + +using System.Reflection; using System.IO; -using System.Reflection; + using Eraser.Util; +using Eraser.Plugins; +using Eraser.Plugins.ExtensionPoints; namespace Eraser.Manager { - /// - /// An interface class representing the method for erasure. If classes only - /// inherit this class, then the method can only be used to erase abstract - /// streams, not unused drive space. - /// - public abstract class ErasureMethod : IRegisterable - { - public override string ToString() - { - if (Passes == 0) - return Name; - return Passes == 1 ? S._("{0} (1 pass)", Name) : - S._("{0} ({1} passes)", Name, Passes); - } - - /// - /// The name of this erase pass, used for display in the UI - /// - public abstract string Name - { - get; - } - - /// - /// The number of erase passes for this erasure method. - /// - public abstract int Passes - { - get; - } - - /// - /// The GUID for this erasure method. - /// - public abstract Guid Guid - { - get; - } - - /// - /// Calculates the total size of the erasure data that needs to be written. - /// This is mainly for use by the Manager to determine how much data needs - /// to be written to disk. - /// - /// The list containing the file paths to erase. This - /// may be null if the list of paths are unknown. - /// The precomputed value of the total size of - /// the files to be erased. - /// The total size of the files that need to be erased. - /// This function MAY be slow. Most erasure methods can - /// calculate this amount fairly quickly as the number of files and the - /// total size of the files (the ones that take most computation time) - /// are already provided. However some exceptional cases may take a - /// long time if the data set is large. - public abstract long CalculateEraseDataSize(ICollection paths, long targetSize); - - /// - /// The main bit of the class! This function is called whenever data has - /// to be erased. Erase the stream passed in, using the given PRNG for - /// randomness where necessary. - /// - /// This function should be implemented thread-safe as using the same - /// instance, this function may be called across different threads. - /// - /// The stream which needs to be erased. - /// The length of the stream to erase. If all - /// data in the stream should be overwritten, then pass in the maximum - /// value for long, the function will take the minimum. - /// The PRNG source for random data. - /// The progress callback function. - public abstract void Erase(Stream stream, long erasureLength, Prng prng, - ErasureMethodProgressFunction callback); - - /// - /// Disk operation write unit. Chosen such that this value mod 3, 4, 512, - /// and 1024 is 0 - /// - public const int DiskOperationUnit = 1536 * 4096; - - /// - /// Unused space erasure file size. Each of the files used in erasing - /// unused space will be of this size. - /// - public const int FreeSpaceFileUnit = DiskOperationUnit * 36; - - /// - /// Shuffles the passes in the input array, effectively randomizing the - /// order or rewrites. - /// - /// The input set of passes. - /// The shuffled set of passes. - protected static ErasureMethodPass[] ShufflePasses(ErasureMethodPass[] passes) - { - //Make a copy. - ErasureMethodPass[] result = new ErasureMethodPass[passes.Length]; - passes.CopyTo(result, 0); - - //Randomize. - Prng rand = ManagerLibrary.Instance.PrngRegistrar[ManagerLibrary.Settings.ActivePrng]; - for (int i = 0; i < result.Length; ++i) - { - int val = rand.Next(result.Length - 1); - ErasureMethodPass tmpPass = result[val]; - result[val] = result[i]; - result[i] = tmpPass; - } - - return result; - } - - /// - /// Helper function. This function will write random data to the stream - /// using the provided PRNG. - /// - /// The buffer to populate with data to write to disk. - /// The PRNG used. - public static void WriteRandom(byte[] buffer, object value) - { - ((Prng)value).NextBytes(buffer); - } - - /// - /// Helper function. This function will write the repeating pass constant. - /// to the provided buffer. - /// - /// The buffer to populate with data to write to disk. - /// The byte[] to write. - public static void WriteConstant(byte[] buffer, object value) - { - byte[] constant = (byte[])value; - for (int i = 0; i < buffer.Length; ++i) - buffer[i] = constant[i % constant.Length]; - } - } - - /// - /// A simple callback for clients to retrieve progress information from - /// the erase method. - /// - /// The amount of data written to the stream since - /// the last call to the delegate. - /// The total amount of data that must be written to - /// complete the erasure. - /// The current pass number. The total number - /// of passes can be found from the Passes property. - public delegate void ErasureMethodProgressFunction(long lastWritten, long totalData, - int currentPass); - - /// - /// A pass object. This object holds both the pass function, as well as the - /// data used for the pass (random, byte, or triplet) - /// - public class ErasureMethodPass - { - public override string ToString() - { - return OpaqueValue == null ? S._("Random") : OpaqueValue.ToString(); - } - - /// - /// Constructor. - /// - /// The delegate to the function. - /// The opaque value passed to the function. - public ErasureMethodPass(ErasureMethodPassFunction function, object opaqueValue) - { - Function = function; - OpaqueValue = opaqueValue; - } - - /// - /// Executes the pass. - /// - /// The buffer to populate with the data to write. - /// The PRNG used for random passes. - public void Execute(byte[] buffer, Prng prng) - { - Function(buffer, OpaqueValue == null ? prng : OpaqueValue); - } - - /// - /// The function to execute for this pass. - /// - public ErasureMethodPassFunction Function { get; set; } - - /// - /// The value to be passed to the executing function. - /// - public object OpaqueValue { get; set; } - } - - /// - /// The prototype of a pass. - /// - /// The buffer to populate with data to write to disk. - /// An opaque value, depending on the type of callback. - public delegate void ErasureMethodPassFunction(byte[] buffer, object opaque); - - /// - /// This class adds functionality to the ErasureMethod class to erase - /// unused drive space. - /// - public abstract class UnusedSpaceErasureMethod : ErasureMethod - { - /// - /// This function will allow clients to erase a file in a set of files - /// used to fill the disk, thus achieving disk unused space erasure. - /// - /// By default, this function will simply call the Erase method inherited - /// from the ErasureMethod class. - /// - /// This function should be implemented thread-safe as using the same - /// instance, this function may be called across different threads. - /// - /// The stream which needs to be erased. - /// The PRNG source for random data. - /// The progress callback function. - public virtual void EraseUnusedSpace(Stream stream, Prng prng, ErasureMethodProgressFunction callback) - { - Erase(stream, long.MaxValue, prng, callback); - } - } - - /// - /// Pass-based erasure method. This subclass of erasure methods follow a fixed - /// pattern (constant or random data) for every pass, although the order of - /// passes can be randomized. This is to simplify definitions of classes in - /// plugins. - /// - /// Since instances of this class apply data by passes, they can by default - /// erase unused drive space as well. - /// - public abstract class PassBasedErasureMethod : UnusedSpaceErasureMethod - { - public override int Passes - { - get { return PassesSet.Length; } - } - - /// - /// Whether the passes should be randomized before running them in random - /// order. - /// - protected abstract bool RandomizePasses - { - get; - } - - /// - /// The set of Pass objects describing the passes in this erasure method. - /// - protected abstract ErasureMethodPass[] PassesSet - { - get; - } - - public override long CalculateEraseDataSize(ICollection paths, long targetSize) - { - //Simple. Amount of data multiplied by passes. - return targetSize * Passes; - } - - public override void Erase(Stream stream, long erasureLength, Prng prng, - ErasureMethodProgressFunction callback) - { - //Randomize the order of the passes - ErasureMethodPass[] randomizedPasses = PassesSet; - if (RandomizePasses) - randomizedPasses = ShufflePasses(randomizedPasses); - - //Remember the starting position of the stream. - long strmStart = stream.Position; - long strmLength = Math.Min(stream.Length - strmStart, erasureLength); - long totalData = CalculateEraseDataSize(null, strmLength); - - //Allocate memory for a buffer holding data for the pass. - byte[] buffer = new byte[Math.Min(DiskOperationUnit, strmLength)]; - - //Run every pass! - for (int pass = 0; pass < Passes; ++pass) - { - //Do a progress callback first. - if (callback != null) - callback(0, totalData, pass + 1); - - //Start from the beginning again - stream.Seek(strmStart, SeekOrigin.Begin); - - //Write the buffer to disk. - long toWrite = strmLength; - int dataStopped = buffer.Length; - while (toWrite > 0) - { - //Calculate how much of the buffer to write to disk. - int amount = (int)Math.Min(toWrite, buffer.Length - dataStopped); - - //If we have no data left, get more! - if (amount == 0) - { - randomizedPasses[pass].Execute(buffer, prng); - dataStopped = 0; - continue; - } - - //Write the data. - stream.Write(buffer, dataStopped, amount); - stream.Flush(); - toWrite -= amount; - - //Do a progress callback. - if (callback != null) - callback(amount, totalData, pass + 1); - } - } - } - } - /// /// Class managing all the erasure methods. This class pairs GUIDs with constructor @@ -383,5 +70,5 @@ public override void Erase(Stream strm, long erasureLength, Prng prng, - ErasureMethodProgressFunction callback) + ErasureMethod.ErasureMethodProgressFunction callback) { throw new InvalidOperationException("The DefaultMethod class should never " +