Refactor: Move dumping code, and misc file writing code, to

Core.

DiscImageChef.Core/ChangeLog

@@ -1,3 +1,13 @@
+2017-05-27  Natalia Portillo  <claunia@claunia.com>
+
+	* DataFile.cs:
+	* ATA.cs:
+	* NVMe.cs:
+	* SCSI.cs:
+	* DiscImageChef.Core.csproj:
+	* SecureDigital.cs: Refactor: Move dumping code, and misc file
+	  writing code, to Core.
+
 2017-05-27  Natalia Portillo  <claunia@claunia.com>
 
 	* Statistics.cs:

DiscImageChef.Core/DataFile.cs

@@ -0,0 +1,109 @@
+// /***************************************************************************
+// The Disc Image Chef
+// ----------------------------------------------------------------------------
+//
+// Filename       : DataFile.cs
+// Version        : 1.0
+// Author(s)      : Natalia Portillo
+//
+// Component      : Component
+//
+// Revision       : $Revision$
+// Last change by : $Author$
+// Date           : $Date$
+//
+// --[ Description ] ----------------------------------------------------------
+//
+// Description
+//
+// --[ License ] --------------------------------------------------------------
+//
+//     This program is free software: you can redistribute it and/or modify
+//     it under the terms of the GNU General Public License as
+//     published by the Free Software Foundation, either version 3 of the
+//     License, or (at your option) any later version.
+//
+//     This program is distributed in the hope that it will be useful,
+//     but WITHOUT ANY WARRANTY; without even the implied warranty of
+//     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//     GNU General Public License for more details.
+//
+//     You should have received a copy of the GNU General Public License
+//     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+// ----------------------------------------------------------------------------
+// Copyright (C) 2011-2015 Claunia.com
+// ****************************************************************************/
+// //$Id$
+using System;
+using System.IO;
+using DiscImageChef.Console;
+
+namespace DiscImageChef.Core
+{
+    public class DataFile
+    {
+        static FileStream dataFs;
+
+        public DataFile(string outputFile)
+        {
+            dataFs = new FileStream(outputFile, FileMode.OpenOrCreate, FileAccess.ReadWrite);
+        }
+
+        public void Close()
+        {
+            if(dataFs != null)
+                dataFs.Close();
+        }
+
+        public int Read(byte[] array, int offset, int count)
+        {
+            return dataFs.Read(array, offset, count);
+        }
+
+        public long Seek(long offset, SeekOrigin origin)
+        {
+            return dataFs.Seek(offset, origin);
+        }
+
+        public void Write(byte[] data)
+        {
+            dataFs.Write(data, 0, data.Length);
+        }
+
+        public void WriteAt(byte[] data, ulong block, uint blockSize)
+        {
+            dataFs.Seek((long)(block * blockSize), SeekOrigin.Begin);
+            dataFs.Write(data, 0, data.Length);
+        }
+
+        public static void WriteTo(string who, string outputPrefix, string outputSuffix, string what, byte[] data)
+        {
+            if(!string.IsNullOrEmpty(outputPrefix) && !string.IsNullOrEmpty(outputSuffix))
+                WriteTo(who, outputPrefix + outputSuffix, data, what);
+        }
+
+        public static void WriteTo(string who, string filename, byte[] data, string whatWriting = null)
+        {
+            if(!string.IsNullOrEmpty(filename))
+            {
+                if(!File.Exists(filename))
+                {
+                    try
+                    {
+                        DicConsole.DebugWriteLine(who, "Writing " + whatWriting + " to {0}", filename);
+                        FileStream outputFs = new FileStream(filename, FileMode.CreateNew);
+                        outputFs.Write(data, 0, data.Length);
+                        outputFs.Close();
+                    }
+                    catch
+                    {
+                        DicConsole.ErrorWriteLine("Unable to write file {0}", filename);
+                    }
+                }
+                else
+                    DicConsole.ErrorWriteLine("Not overwriting file {0}", filename);
+            }
+        }
+    }
+}

DiscImageChef.Core/Devices/Dumping/ATA.cs

@@ -0,0 +1,919 @@
+// /***************************************************************************
+// The Disc Image Chef
+// ----------------------------------------------------------------------------
+//
+// Filename       : ATA.cs
+// Version        : 1.0
+// Author(s)      : Natalia Portillo
+//
+// Component      : Component
+//
+// Revision       : $Revision$
+// Last change by : $Author$
+// Date           : $Date$
+//
+// --[ Description ] ----------------------------------------------------------
+//
+// Description
+//
+// --[ License ] --------------------------------------------------------------
+//
+//     This program is free software: you can redistribute it and/or modify
+//     it under the terms of the GNU General Public License as
+//     published by the Free Software Foundation, either version 3 of the
+//     License, or (at your option) any later version.
+//
+//     This program is distributed in the hope that it will be useful,
+//     but WITHOUT ANY WARRANTY; without even the implied warranty of
+//     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//     GNU General Public License for more details.
+//
+//     You should have received a copy of the GNU General Public License
+//     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+// ----------------------------------------------------------------------------
+// Copyright (C) 2011-2015 Claunia.com
+// ****************************************************************************/
+// //$Id$
+using System;
+using System.Collections.Generic;
+using System.IO;
+using DiscImageChef.CommonTypes;
+using DiscImageChef.Console;
+using DiscImageChef.Core.Logging;
+using DiscImageChef.Decoders.PCMCIA;
+using DiscImageChef.Devices;
+using DiscImageChef.Filesystems;
+using DiscImageChef.Filters;
+using DiscImageChef.ImagePlugins;
+using DiscImageChef.PartPlugins;
+using Schemas;
+
+namespace DiscImageChef.Core.Devices.Dumping
+{
+    public class ATA
+    {
+        public static void Dump(Device dev, string devicePath, string outputPrefix, ushort retryPasses, bool force, bool dumpRaw, bool persistent, bool stopOnError)
+        {
+            bool aborted;
+            MHDDLog mhddLog;
+            IBGLog ibgLog;
+
+            if(dumpRaw)
+            {
+                DicConsole.ErrorWriteLine("Raw dumping not yet supported in ATA devices.");
+
+                if(force)
+                    DicConsole.ErrorWriteLine("Continuing...");
+                else
+                {
+                    DicConsole.ErrorWriteLine("Aborting...");
+                    return;
+                }
+            }
+
+            byte[] cmdBuf;
+            bool sense;
+            ulong blocks = 0;
+            uint blockSize = 512;
+            ushort currentProfile = 0x0001;
+            Decoders.ATA.AtaErrorRegistersCHS errorChs;
+            Decoders.ATA.AtaErrorRegistersLBA28 errorLba;
+            Decoders.ATA.AtaErrorRegistersLBA48 errorLba48;
+            bool lbaMode = false;
+            byte heads = 0, sectors = 0;
+            ushort cylinders = 0;
+            uint timeout = 5;
+            double duration;
+
+            sense = dev.AtaIdentify(out cmdBuf, out errorChs);
+            if(!sense && Decoders.ATA.Identify.Decode(cmdBuf).HasValue)
+            {
+                Decoders.ATA.Identify.IdentifyDevice ataId = Decoders.ATA.Identify.Decode(cmdBuf).Value;
+
+                CICMMetadataType sidecar = new CICMMetadataType();
+                sidecar.BlockMedia = new BlockMediaType[1];
+                sidecar.BlockMedia[0] = new BlockMediaType();
+
+                if(dev.IsUSB)
+                {
+                    sidecar.BlockMedia[0].USB = new USBType();
+                    sidecar.BlockMedia[0].USB.ProductID = dev.USBProductID;
+                    sidecar.BlockMedia[0].USB.VendorID = dev.USBVendorID;
+                    sidecar.BlockMedia[0].USB.Descriptors = new DumpType();
+                    sidecar.BlockMedia[0].USB.Descriptors.Image = outputPrefix + ".usbdescriptors.bin";
+                    sidecar.BlockMedia[0].USB.Descriptors.Size = dev.USBDescriptors.Length;
+                    sidecar.BlockMedia[0].USB.Descriptors.Checksums = Checksum.GetChecksums(dev.USBDescriptors).ToArray();
+                    DataFile.WriteTo("ATA Dump", sidecar.BlockMedia[0].USB.Descriptors.Image, dev.USBDescriptors);
+                }
+
+                if(dev.IsPCMCIA)
+                {
+                    sidecar.BlockMedia[0].PCMCIA = new PCMCIAType();
+                    sidecar.BlockMedia[0].PCMCIA.CIS = new DumpType();
+                    sidecar.BlockMedia[0].PCMCIA.CIS.Image = outputPrefix + ".cis.bin";
+                    sidecar.BlockMedia[0].PCMCIA.CIS.Size = dev.CIS.Length;
+                    sidecar.BlockMedia[0].PCMCIA.CIS.Checksums = Checksum.GetChecksums(dev.CIS).ToArray();
+                    DataFile.WriteTo("ATA Dump", sidecar.BlockMedia[0].PCMCIA.CIS.Image, dev.CIS);
+                    Decoders.PCMCIA.Tuple[] tuples = CIS.GetTuples(dev.CIS);
+                    if(tuples != null)
+                    {
+                        foreach(Decoders.PCMCIA.Tuple tuple in tuples)
+                        {
+                            if(tuple.Code == TupleCodes.CISTPL_MANFID)
+                            {
+                                ManufacturerIdentificationTuple manfid = CIS.DecodeManufacturerIdentificationTuple(tuple);
+
+                                if(manfid != null)
+                                {
+                                    sidecar.BlockMedia[0].PCMCIA.ManufacturerCode = manfid.ManufacturerID;
+                                    sidecar.BlockMedia[0].PCMCIA.CardCode = manfid.CardID;
+                                    sidecar.BlockMedia[0].PCMCIA.ManufacturerCodeSpecified = true;
+                                    sidecar.BlockMedia[0].PCMCIA.CardCodeSpecified = true;
+                                }
+                            }
+                            else if(tuple.Code == TupleCodes.CISTPL_VERS_1)
+                            {
+                                Level1VersionTuple vers = CIS.DecodeLevel1VersionTuple(tuple);
+
+                                if(vers != null)
+                                {
+                                    sidecar.BlockMedia[0].PCMCIA.Manufacturer = vers.Manufacturer;
+                                    sidecar.BlockMedia[0].PCMCIA.ProductName = vers.Product;
+                                    sidecar.BlockMedia[0].PCMCIA.Compliance = string.Format("{0}.{1}", vers.MajorVersion, vers.MinorVersion);
+                                    sidecar.BlockMedia[0].PCMCIA.AdditionalInformation = vers.AdditionalInformation;
+                                }
+                            }
+                        }
+                    }
+                }
+
+                sidecar.BlockMedia[0].ATA = new ATAType();
+                sidecar.BlockMedia[0].ATA.Identify = new DumpType();
+                sidecar.BlockMedia[0].ATA.Identify.Image = outputPrefix + ".identify.bin";
+                sidecar.BlockMedia[0].ATA.Identify.Size = cmdBuf.Length;
+                sidecar.BlockMedia[0].ATA.Identify.Checksums = Checksum.GetChecksums(cmdBuf).ToArray();
+                DataFile.WriteTo("ATA Dump", sidecar.BlockMedia[0].ATA.Identify.Image, cmdBuf);
+
+                if(ataId.CurrentCylinders > 0 && ataId.CurrentHeads > 0 && ataId.CurrentSectorsPerTrack > 0)
+                {
+                    cylinders = ataId.CurrentCylinders;
+                    heads = (byte)ataId.CurrentHeads;
+                    sectors = (byte)ataId.CurrentSectorsPerTrack;
+                    blocks = (ulong)(cylinders * heads * sectors);
+                }
+
+                if((ataId.CurrentCylinders == 0 || ataId.CurrentHeads == 0 || ataId.CurrentSectorsPerTrack == 0) &&
+                    (ataId.Cylinders > 0 && ataId.Heads > 0 && ataId.SectorsPerTrack > 0))
+                {
+                    cylinders = ataId.Cylinders;
+                    heads = (byte)ataId.Heads;
+                    sectors = (byte)ataId.SectorsPerTrack;
+                    blocks = (ulong)(cylinders * heads * sectors);
+                }
+
+                if(ataId.Capabilities.HasFlag(Decoders.ATA.Identify.CapabilitiesBit.LBASupport))
+                {
+                    blocks = ataId.LBASectors;
+                    lbaMode = true;
+                }
+
+                if(ataId.CommandSet2.HasFlag(Decoders.ATA.Identify.CommandSetBit2.LBA48))
+                {
+                    blocks = ataId.LBA48Sectors;
+                    lbaMode = true;
+                }
+
+                uint physicalsectorsize = blockSize;
+                if((ataId.PhysLogSectorSize & 0x8000) == 0x0000 &&
+                                    (ataId.PhysLogSectorSize & 0x4000) == 0x4000)
+                {
+                    if((ataId.PhysLogSectorSize & 0x1000) == 0x1000)
+                    {
+                        if(ataId.LogicalSectorWords <= 255 || ataId.LogicalAlignment == 0xFFFF)
+                            blockSize = 512;
+                        else
+                            blockSize = ataId.LogicalSectorWords * 2;
+                    }
+                    else
+                        blockSize = 512;
+
+                    if((ataId.PhysLogSectorSize & 0x2000) == 0x2000)
+                    {
+#pragma warning disable IDE0004 // Cast is necessary, otherwise incorrect value is created
+                        physicalsectorsize = blockSize * (uint)Math.Pow(2, (double)(ataId.PhysLogSectorSize & 0xF));
+#pragma warning restore IDE0004 // Cast is necessary, otherwise incorrect value is created
+                    }
+                    else
+                        physicalsectorsize = blockSize;
+                }
+                else
+                {
+                    blockSize = 512;
+                    physicalsectorsize = 512;
+                }
+
+                bool ReadLba = false;
+                bool ReadRetryLba = false;
+                bool ReadDmaLba = false;
+                bool ReadDmaRetryLba = false;
+
+                bool ReadLba48 = false;
+                bool ReadDmaLba48 = false;
+
+                bool Read = false;
+                bool ReadRetry = false;
+                bool ReadDma = false;
+                bool ReadDmaRetry = false;
+
+                sense = dev.Read(out cmdBuf, out errorChs, false, 0, 0, 1, 1, timeout, out duration);
+                Read = (!sense && (errorChs.status & 0x27) == 0 && errorChs.error == 0 && cmdBuf.Length > 0);
+                sense = dev.Read(out cmdBuf, out errorChs, true, 0, 0, 1, 1, timeout, out duration);
+                ReadRetry = (!sense && (errorChs.status & 0x27) == 0 && errorChs.error == 0 && cmdBuf.Length > 0);
+                sense = dev.ReadDma(out cmdBuf, out errorChs, false, 0, 0, 1, 1, timeout, out duration);
+                ReadDma = (!sense && (errorChs.status & 0x27) == 0 && errorChs.error == 0 && cmdBuf.Length > 0);
+                sense = dev.ReadDma(out cmdBuf, out errorChs, true, 0, 0, 1, 1, timeout, out duration);
+                ReadDmaRetry = (!sense && (errorChs.status & 0x27) == 0 && errorChs.error == 0 && cmdBuf.Length > 0);
+
+                sense = dev.Read(out cmdBuf, out errorLba, false, 0, 1, timeout, out duration);
+                ReadLba = (!sense && (errorLba.status & 0x27) == 0 && errorLba.error == 0 && cmdBuf.Length > 0);
+                sense = dev.Read(out cmdBuf, out errorLba, true, 0, 1, timeout, out duration);
+                ReadRetryLba = (!sense && (errorLba.status & 0x27) == 0 && errorLba.error == 0 && cmdBuf.Length > 0);
+                sense = dev.ReadDma(out cmdBuf, out errorLba, false, 0, 1, timeout, out duration);
+                ReadDmaLba = (!sense && (errorLba.status & 0x27) == 0 && errorLba.error == 0 && cmdBuf.Length > 0);
+                sense = dev.ReadDma(out cmdBuf, out errorLba, true, 0, 1, timeout, out duration);
+                ReadDmaRetryLba = (!sense && (errorLba.status & 0x27) == 0 && errorLba.error == 0 && cmdBuf.Length > 0);
+
+                sense = dev.Read(out cmdBuf, out errorLba48, 0, 1, timeout, out duration);
+                ReadLba48 = (!sense && (errorLba48.status & 0x27) == 0 && errorLba48.error == 0 && cmdBuf.Length > 0);
+                sense = dev.ReadDma(out cmdBuf, out errorLba48, 0, 1, timeout, out duration);
+                ReadDmaLba48 = (!sense && (errorLba48.status & 0x27) == 0 && errorLba48.error == 0 && cmdBuf.Length > 0);
+
+                if(!lbaMode)
+                {
+                    if(blocks > 0xFFFFFFF && !ReadLba48 && !ReadDmaLba48)
+                    {
+                        DicConsole.ErrorWriteLine("Device needs 48-bit LBA commands but I can't issue them... Aborting.");
+                        return;
+                    }
+
+                    if(!ReadLba && !ReadRetryLba && !ReadDmaLba && !ReadDmaRetryLba)
+                    {
+                        DicConsole.ErrorWriteLine("Device needs 28-bit LBA commands but I can't issue them... Aborting.");
+                        return;
+                    }
+                }
+                else
+                {
+                    if(!Read && !ReadRetry && !ReadDma && !ReadDmaRetry)
+                    {
+                        DicConsole.ErrorWriteLine("Device needs CHS commands but I can't issue them... Aborting.");
+                        return;
+                    }
+                }
+
+                if(ReadDmaLba48)
+                    DicConsole.WriteLine("Using ATA READ DMA EXT command.");
+                else if(ReadLba48)
+                    DicConsole.WriteLine("Using ATA READ EXT command.");
+                else if(ReadDmaRetryLba)
+                    DicConsole.WriteLine("Using ATA READ DMA command with retries (LBA).");
+                else if(ReadDmaLba)
+                    DicConsole.WriteLine("Using ATA READ DMA command (LBA).");
+                else if(ReadRetryLba)
+                    DicConsole.WriteLine("Using ATA READ command with retries (LBA).");
+                else if(ReadLba)
+                    DicConsole.WriteLine("Using ATA READ command (LBA).");
+                else if(ReadDmaRetry)
+                    DicConsole.WriteLine("Using ATA READ DMA command with retries (CHS).");
+                else if(ReadDma)
+                    DicConsole.WriteLine("Using ATA READ DMA command (CHS).");
+                else if(ReadRetry)
+                    DicConsole.WriteLine("Using ATA READ command with retries (CHS).");
+                else if(Read)
+                    DicConsole.WriteLine("Using ATA READ command (CHS).");
+
+                uint blocksToRead = 64;
+                bool error = true;
+                while(lbaMode)
+                {
+                    if(ReadDmaLba48)
+                    {
+                        sense = dev.ReadDma(out cmdBuf, out errorLba48, 0, (byte)blocksToRead, timeout, out duration);
+                        error = !(!sense && (errorLba48.status & 0x27) == 0 && errorLba48.error == 0 && cmdBuf.Length > 0);
+                    }
+                    else if(ReadLba48)
+                    {
+                        sense = dev.Read(out cmdBuf, out errorLba48, 0, (byte)blocksToRead, timeout, out duration);
+                        error = !(!sense && (errorLba48.status & 0x27) == 0 && errorLba48.error == 0 && cmdBuf.Length > 0);
+                    }
+                    else if(ReadDmaRetryLba)
+                    {
+                        sense = dev.ReadDma(out cmdBuf, out errorLba, true, 0, (byte)blocksToRead, timeout, out duration);
+                        error = !(!sense && (errorLba.status & 0x27) == 0 && errorLba.error == 0 && cmdBuf.Length > 0);
+                    }
+                    else if(ReadDmaLba)
+                    {
+                        sense = dev.ReadDma(out cmdBuf, out errorLba, false, 0, (byte)blocksToRead, timeout, out duration);
+                        error = !(!sense && (errorLba.status & 0x27) == 0 && errorLba.error == 0 && cmdBuf.Length > 0);
+                    }
+                    else if(ReadRetryLba)
+                    {
+                        sense = dev.Read(out cmdBuf, out errorLba, true, 0, (byte)blocksToRead, timeout, out duration);
+                        error = !(!sense && (errorLba.status & 0x27) == 0 && errorLba.error == 0 && cmdBuf.Length > 0);
+                    }
+                    else if(ReadLba)
+                    {
+                        sense = dev.Read(out cmdBuf, out errorLba, false, 0, (byte)blocksToRead, timeout, out duration);
+                        error = !(!sense && (errorLba.status & 0x27) == 0 && errorLba.error == 0 && cmdBuf.Length > 0);
+                    }
+
+                    if(error)
+                        blocksToRead /= 2;
+
+                    if(!error || blocksToRead == 1)
+                        break;
+                }
+
+                if(error && lbaMode)
+                {
+                    DicConsole.ErrorWriteLine("Device error {0} trying to guess ideal transfer length.", dev.LastError);
+                    return;
+                }
+
+                ulong A = 0; // <3ms
+                ulong B = 0; // >=3ms, <10ms
+                ulong C = 0; // >=10ms, <50ms
+                ulong D = 0; // >=50ms, <150ms
+                ulong E = 0; // >=150ms, <500ms
+                ulong F = 0; // >=500ms
+                ulong errored = 0;
+                DateTime start;
+                DateTime end;
+                double totalDuration = 0;
+                double totalChkDuration = 0;
+                double currentSpeed = 0;
+                double maxSpeed = double.MinValue;
+                double minSpeed = double.MaxValue;
+                List<ulong> unreadableSectors = new List<ulong>();
+                Checksum dataChk;
+
+                aborted = false;
+                System.Console.CancelKeyPress += (sender, e) =>
+                {
+                    e.Cancel = aborted = true;
+                };
+
+                DataFile dumpFile;
+
+                if(lbaMode)
+                {
+                    DicConsole.WriteLine("Reading {0} sectors at a time.", blocksToRead);
+
+                    mhddLog = new MHDDLog(outputPrefix + ".mhddlog.bin", dev, blocks, blockSize, blocksToRead);
+                    ibgLog = new IBGLog(outputPrefix + ".ibg", currentProfile);
+                    dumpFile = new DataFile(outputPrefix + ".bin");
+
+                    start = DateTime.UtcNow;
+                    for(ulong i = 0; i < blocks; i += blocksToRead)
+                    {
+                        if(aborted)
+                            break;
+
+                        double cmdDuration = 0;
+
+                        if((blocks - i) < blocksToRead)
+                            blocksToRead = (byte)(blocks - i);
+
+#pragma warning disable RECS0018 // Comparison of floating point numbers with equality operator
+                        if(currentSpeed > maxSpeed && currentSpeed != 0)
+                            maxSpeed = currentSpeed;
+                        if(currentSpeed < minSpeed && currentSpeed != 0)
+                            minSpeed = currentSpeed;
+#pragma warning restore RECS0018 // Comparison of floating point numbers with equality operator
+
+                        DicConsole.Write("\rReading sector {0} of {1} ({2:F3} MiB/sec.)", i, blocks, currentSpeed);
+
+                        error = true;
+                        byte status = 0, errorByte = 0;
+
+                        if(ReadDmaLba48)
+                        {
+                            sense = dev.ReadDma(out cmdBuf, out errorLba48, i, (byte)blocksToRead, timeout, out cmdDuration);
+                            error = !(!sense && (errorLba48.status & 0x27) == 0 && errorLba48.error == 0 && cmdBuf.Length > 0);
+                            status = errorLba48.status;
+                            errorByte = errorLba48.error;
+                        }
+                        else if(ReadLba48)
+                        {
+                            sense = dev.Read(out cmdBuf, out errorLba48, i, (byte)blocksToRead, timeout, out cmdDuration);
+                            error = !(!sense && (errorLba48.status & 0x27) == 0 && errorLba48.error == 0 && cmdBuf.Length > 0);
+                            status = errorLba48.status;
+                            errorByte = errorLba48.error;
+                        }
+                        else if(ReadDmaRetryLba)
+                        {
+                            sense = dev.ReadDma(out cmdBuf, out errorLba, true, (uint)i, (byte)blocksToRead, timeout, out cmdDuration);
+                            error = !(!sense && (errorLba.status & 0x27) == 0 && errorLba.error == 0 && cmdBuf.Length > 0);
+                            status = errorLba.status;
+                            errorByte = errorLba.error;
+                        }
+                        else if(ReadDmaLba)
+                        {
+                            sense = dev.ReadDma(out cmdBuf, out errorLba, false, (uint)i, (byte)blocksToRead, timeout, out cmdDuration);
+                            error = !(!sense && (errorLba.status & 0x27) == 0 && errorLba.error == 0 && cmdBuf.Length > 0);
+                            status = errorLba.status;
+                            errorByte = errorLba.error;
+                        }
+                        else if(ReadRetryLba)
+                        {
+                            sense = dev.Read(out cmdBuf, out errorLba, true, (uint)i, (byte)blocksToRead, timeout, out cmdDuration);
+                            error = !(!sense && (errorLba.status & 0x27) == 0 && errorLba.error == 0 && cmdBuf.Length > 0);
+                            status = errorLba.status;
+                            errorByte = errorLba.error;
+                        }
+                        else if(ReadLba)
+                        {
+                            sense = dev.Read(out cmdBuf, out errorLba, false, (uint)i, (byte)blocksToRead, timeout, out cmdDuration);
+                            error = !(!sense && (errorLba.status & 0x27) == 0 && errorLba.error == 0 && cmdBuf.Length > 0);
+                            status = errorLba.status;
+                            errorByte = errorLba.error;
+                        }
+
+                        if(!error)
+                        {
+                            if(cmdDuration >= 500)
+                            {
+                                F += blocksToRead;
+                            }
+                            else if(cmdDuration >= 150)
+                            {
+                                E += blocksToRead;
+                            }
+                            else if(cmdDuration >= 50)
+                            {
+                                D += blocksToRead;
+                            }
+                            else if(cmdDuration >= 10)
+                            {
+                                C += blocksToRead;
+                            }
+                            else if(cmdDuration >= 3)
+                            {
+                                B += blocksToRead;
+                            }
+                            else
+                            {
+                                A += blocksToRead;
+                            }
+
+                            mhddLog.Write(i, cmdDuration);
+                            ibgLog.Write(i, currentSpeed * 1024);
+                            dumpFile.Write(cmdBuf);
+                        }
+                        else
+                        {
+                            DicConsole.DebugWriteLine("Media-Scan", "ATA ERROR: {0} STATUS: {1}", errorByte, status);
+                            errored += blocksToRead;
+                            unreadableSectors.Add(i);
+                            if(cmdDuration < 500)
+                                mhddLog.Write(i, 65535);
+                            else
+                                mhddLog.Write(i, cmdDuration);
+
+                            ibgLog.Write(i, 0);
+                            dumpFile.Write(new byte[blockSize * blocksToRead]);
+                        }
+
+#pragma warning disable IDE0004 // Cast is necessary, otherwise incorrect value is created
+                        currentSpeed = ((double)blockSize * blocksToRead / (double)1048576) / (cmdDuration / (double)1000);
+#pragma warning restore IDE0004 // Cast is necessary, otherwise incorrect value is created
+                        GC.Collect();
+                    }
+                    end = DateTime.Now;
+                    DicConsole.WriteLine();
+                    mhddLog.Close();
+#pragma warning disable IDE0004 // Cast is necessary, otherwise incorrect value is created
+                    ibgLog.Close(dev, blocks, blockSize, (end - start).TotalSeconds, currentSpeed * 1024, (((double)blockSize * (double)(blocks + 1)) / 1024) / (totalDuration / 1000), devicePath);
+#pragma warning restore IDE0004 // Cast is necessary, otherwise incorrect value is created
+
+                    #region Error handling
+                    if(unreadableSectors.Count > 0 && !aborted)
+                    {
+                        List<ulong> tmpList = new List<ulong>();
+
+                        foreach(ulong ur in unreadableSectors)
+                        {
+                            for(ulong i = ur; i < ur + blocksToRead; i++)
+                                tmpList.Add(i);
+                        }
+
+                        tmpList.Sort();
+
+                        int pass = 0;
+                        bool forward = true;
+                        bool runningPersistent = false;
+
+                        unreadableSectors = tmpList;
+
+                    repeatRetryLba:
+                        ulong[] tmpArray = unreadableSectors.ToArray();
+                        foreach(ulong badSector in tmpArray)
+                        {
+                            if(aborted)
+                                break;
+
+                            double cmdDuration = 0;
+
+                            DicConsole.Write("\rRetrying sector {0}, pass {1}, {3}{2}", badSector, pass + 1, forward ? "forward" : "reverse", runningPersistent ? "recovering partial data, " : "");
+
+                            if(ReadDmaLba48)
+                            {
+                                sense = dev.ReadDma(out cmdBuf, out errorLba48, badSector, 1, timeout, out cmdDuration);
+                                error = !(!sense && (errorLba48.status & 0x27) == 0 && errorLba48.error == 0 && cmdBuf.Length > 0);
+                            }
+                            else if(ReadLba48)
+                            {
+                                sense = dev.Read(out cmdBuf, out errorLba48, badSector, 1, timeout, out cmdDuration);
+                                error = !(!sense && (errorLba48.status & 0x27) == 0 && errorLba48.error == 0 && cmdBuf.Length > 0);
+                            }
+                            else if(ReadDmaRetryLba)
+                            {
+                                sense = dev.ReadDma(out cmdBuf, out errorLba, true, (uint)badSector, 1, timeout, out cmdDuration);
+                                error = !(!sense && (errorLba.status & 0x27) == 0 && errorLba.error == 0 && cmdBuf.Length > 0);
+                            }
+                            else if(ReadDmaLba)
+                            {
+                                sense = dev.ReadDma(out cmdBuf, out errorLba, false, (uint)badSector, 1, timeout, out cmdDuration);
+                                error = !(!sense && (errorLba.status & 0x27) == 0 && errorLba.error == 0 && cmdBuf.Length > 0);
+                            }
+                            else if(ReadRetryLba)
+                            {
+                                sense = dev.Read(out cmdBuf, out errorLba, true, (uint)badSector, 1, timeout, out cmdDuration);
+                                error = !(!sense && (errorLba.status & 0x27) == 0 && errorLba.error == 0 && cmdBuf.Length > 0);
+                            }
+                            else if(ReadLba)
+                            {
+                                sense = dev.Read(out cmdBuf, out errorLba, false, (uint)badSector, 1, timeout, out cmdDuration);
+                                error = !(!sense && (errorLba.status & 0x27) == 0 && errorLba.error == 0 && cmdBuf.Length > 0);
+                            }
+
+                            totalDuration += cmdDuration;
+
+                            if(!error)
+                            {
+                                unreadableSectors.Remove(badSector);
+                                dumpFile.WriteAt(cmdBuf, badSector, blockSize);
+                            }
+                            else if(runningPersistent)
+                                dumpFile.WriteAt(cmdBuf, badSector, blockSize);
+                        }
+
+                        if(pass < retryPasses && !aborted && unreadableSectors.Count > 0)
+                        {
+                            pass++;
+                            forward = !forward;
+                            unreadableSectors.Sort();
+                            unreadableSectors.Reverse();
+                            goto repeatRetryLba;
+                        }
+
+                        DicConsole.WriteLine();
+                    }
+                    #endregion Error handling LBA
+                }
+                else
+                {
+                    mhddLog = new MHDDLog(outputPrefix + ".mhddlog.bin", dev, blocks, blockSize, blocksToRead);
+                    ibgLog = new IBGLog(outputPrefix + ".ibg", currentProfile);
+                    dumpFile = new DataFile(outputPrefix + ".bin");
+
+                    ulong currentBlock = 0;
+                    blocks = (ulong)(cylinders * heads * sectors);
+                    start = DateTime.UtcNow;
+                    for(ushort Cy = 0; Cy < cylinders; Cy++)
+                    {
+                        for(byte Hd = 0; Hd < heads; Hd++)
+                        {
+                            for(byte Sc = 1; Sc < sectors; Sc++)
+                            {
+                                if(aborted)
+                                    break;
+
+                                double cmdDuration = 0;
+
+#pragma warning disable RECS0018 // Comparison of floating point numbers with equality operator
+                                if(currentSpeed > maxSpeed && currentSpeed != 0)
+                                    maxSpeed = currentSpeed;
+                                if(currentSpeed < minSpeed && currentSpeed != 0)
+                                    minSpeed = currentSpeed;
+#pragma warning restore RECS0018 // Comparison of floating point numbers with equality operator
+
+                                DicConsole.Write("\rReading cylinder {0} head {1} sector {2} ({3:F3} MiB/sec.)", Cy, Hd, Sc, currentSpeed);
+
+                                error = true;
+                                byte status = 0, errorByte = 0;
+
+                                if(ReadDmaRetry)
+                                {
+                                    sense = dev.ReadDma(out cmdBuf, out errorChs, true, Cy, Hd, Sc, 1, timeout, out cmdDuration);
+                                    error = !(!sense && (errorChs.status & 0x27) == 0 && errorChs.error == 0 && cmdBuf.Length > 0);
+                                    status = errorChs.status;
+                                    errorByte = errorChs.error;
+                                }
+                                else if(ReadDma)
+                                {
+                                    sense = dev.ReadDma(out cmdBuf, out errorChs, false, Cy, Hd, Sc, 1, timeout, out cmdDuration);
+                                    error = !(!sense && (errorChs.status & 0x27) == 0 && errorChs.error == 0 && cmdBuf.Length > 0);
+                                    status = errorChs.status;
+                                    errorByte = errorChs.error;
+                                }
+                                else if(ReadRetry)
+                                {
+                                    sense = dev.Read(out cmdBuf, out errorChs, true, Cy, Hd, Sc, 1, timeout, out cmdDuration);
+                                    error = !(!sense && (errorChs.status & 0x27) == 0 && errorChs.error == 0 && cmdBuf.Length > 0);
+                                    status = errorChs.status;
+                                    errorByte = errorChs.error;
+                                }
+                                else if(Read)
+                                {
+                                    sense = dev.Read(out cmdBuf, out errorChs, false, Cy, Hd, Sc, 1, timeout, out cmdDuration);
+                                    error = !(!sense && (errorChs.status & 0x27) == 0 && errorChs.error == 0 && cmdBuf.Length > 0);
+                                    status = errorChs.status;
+                                    errorByte = errorChs.error;
+                                }
+
+                                totalDuration += cmdDuration;
+
+                                if(!error)
+                                {
+                                    if(cmdDuration >= 500)
+                                    {
+                                        F += blocksToRead;
+                                    }
+                                    else if(cmdDuration >= 150)
+                                    {
+                                        E += blocksToRead;
+                                    }
+                                    else if(cmdDuration >= 50)
+                                    {
+                                        D += blocksToRead;
+                                    }
+                                    else if(cmdDuration >= 10)
+                                    {
+                                        C += blocksToRead;
+                                    }
+                                    else if(cmdDuration >= 3)
+                                    {
+                                        B += blocksToRead;
+                                    }
+                                    else
+                                    {
+                                        A += blocksToRead;
+                                    }
+
+                                    mhddLog.Write(currentBlock, cmdDuration);
+                                    ibgLog.Write(currentBlock, currentSpeed * 1024);
+                                    dumpFile.Write(cmdBuf);
+                                }
+                                else
+                                {
+                                    DicConsole.DebugWriteLine("Media-Scan", "ATA ERROR: {0} STATUS: {1}", errorByte, status);
+                                    errored += blocksToRead;
+                                    unreadableSectors.Add(currentBlock);
+                                    if(cmdDuration < 500)
+                                        mhddLog.Write(currentBlock, 65535);
+                                    else
+                                        mhddLog.Write(currentBlock, cmdDuration);
+
+                                    ibgLog.Write(currentBlock, 0);
+                                    dumpFile.Write(new byte[blockSize]);
+                                }
+
+#pragma warning disable IDE0004 // Cast is necessary, otherwise incorrect value is created
+                                currentSpeed = ((double)blockSize / (double)1048576) / (cmdDuration / (double)1000);
+#pragma warning disable IDE0004 // Cast is necessary, otherwise incorrect value is created
+                                GC.Collect();
+
+                                currentBlock++;
+                            }
+                        }
+                    }
+                    end = DateTime.Now;
+                    DicConsole.WriteLine();
+                    mhddLog.Close();
+#pragma warning disable IDE0004 // Cast is necessary, otherwise incorrect value is created
+                    ibgLog.Close(dev, blocks, blockSize, (end - start).TotalSeconds, currentSpeed * 1024, (((double)blockSize * (double)(blocks + 1)) / 1024) / (totalDuration / 1000), devicePath);
+#pragma warning disable IDE0004 // Cast is necessary, otherwise incorrect value is created
+                }
+                dataChk = new Checksum();
+                dumpFile.Seek(0, SeekOrigin.Begin);
+                blocksToRead = 500;
+
+                for(ulong i = 0; i < blocks; i += blocksToRead)
+                {
+                    if(aborted)
+                        break;
+
+                    if((blocks - i) < blocksToRead)
+                        blocksToRead = (byte)(blocks - i);
+
+                    DicConsole.Write("\rChecksumming sector {0} of {1} ({2:F3} MiB/sec.)", i, blocks, currentSpeed);
+
+                    DateTime chkStart = DateTime.UtcNow;
+                    byte[] dataToCheck = new byte[blockSize * blocksToRead];
+                    dumpFile.Read(dataToCheck, 0, (int)(blockSize * blocksToRead));
+                    dataChk.Update(dataToCheck);
+                    DateTime chkEnd = DateTime.UtcNow;
+
+                    double chkDuration = (chkEnd - chkStart).TotalMilliseconds;
+                    totalChkDuration += chkDuration;
+
+                    currentSpeed = ((double)blockSize * blocksToRead / (double)1048576) / (chkDuration / (double)1000);
+                }
+                DicConsole.WriteLine();
+                dumpFile.Close();
+                end = DateTime.UtcNow;
+
+                PluginBase plugins = new PluginBase();
+                plugins.RegisterAllPlugins();
+                ImagePlugin _imageFormat;
+
+                FiltersList filtersList = new FiltersList();
+                Filter inputFilter = filtersList.GetFilter(outputPrefix + ".bin");
+
+                if(inputFilter == null)
+                {
+                    DicConsole.ErrorWriteLine("Cannot open file just created, this should not happen.");
+                    return;
+                }
+
+                _imageFormat = ImageFormat.Detect(inputFilter);
+                PartitionType[] xmlFileSysInfo = null;
+
+                try
+                {
+                    if(!_imageFormat.OpenImage(inputFilter))
+                        _imageFormat = null;
+                }
+                catch
+                {
+                    _imageFormat = null;
+                }
+
+                if(_imageFormat != null)
+                {
+                    List<Partition> partitions = new List<Partition>();
+
+                    foreach(PartPlugin _partplugin in plugins.PartPluginsList.Values)
+                    {
+                        List<Partition> _partitions;
+
+                        if(_partplugin.GetInformation(_imageFormat, out _partitions))
+                        {
+                            partitions.AddRange(_partitions);
+                            Statistics.AddPartition(_partplugin.Name);
+                        }
+                    }
+
+                    if(partitions.Count > 0)
+                    {
+                        xmlFileSysInfo = new PartitionType[partitions.Count];
+                        for(int i = 0; i < partitions.Count; i++)
+                        {
+                            xmlFileSysInfo[i] = new PartitionType();
+                            xmlFileSysInfo[i].Description = partitions[i].PartitionDescription;
+                            xmlFileSysInfo[i].EndSector = (int)(partitions[i].PartitionStartSector + partitions[i].PartitionSectors - 1);
+                            xmlFileSysInfo[i].Name = partitions[i].PartitionName;
+                            xmlFileSysInfo[i].Sequence = (int)partitions[i].PartitionSequence;
+                            xmlFileSysInfo[i].StartSector = (int)partitions[i].PartitionStartSector;
+                            xmlFileSysInfo[i].Type = partitions[i].PartitionType;
+
+                            List<FileSystemType> lstFs = new List<FileSystemType>();
+
+                            foreach(Filesystem _plugin in plugins.PluginsList.Values)
+                            {
+                                try
+                                {
+                                    if(_plugin.Identify(_imageFormat, partitions[i].PartitionStartSector, partitions[i].PartitionStartSector + partitions[i].PartitionSectors - 1))
+                                    {
+                                        string foo;
+                                        _plugin.GetInformation(_imageFormat, partitions[i].PartitionStartSector, partitions[i].PartitionStartSector + partitions[i].PartitionSectors - 1, out foo);
+                                        lstFs.Add(_plugin.XmlFSType);
+                                        Statistics.AddFilesystem(_plugin.XmlFSType.Type);
+                                    }
+                                }
+#pragma warning disable RECS0022 // A catch clause that catches System.Exception and has an empty body
+                                catch
+#pragma warning restore RECS0022 // A catch clause that catches System.Exception and has an empty body
+                                {
+                                    //DicConsole.DebugWriteLine("Dump-media command", "Plugin {0} crashed", _plugin.Name);
+                                }
+                            }
+
+                            if(lstFs.Count > 0)
+                                xmlFileSysInfo[i].FileSystems = lstFs.ToArray();
+                        }
+                    }
+                    else
+                    {
+                        xmlFileSysInfo = new PartitionType[1];
+                        xmlFileSysInfo[0] = new PartitionType();
+                        xmlFileSysInfo[0].EndSector = (int)(blocks - 1);
+                        xmlFileSysInfo[0].StartSector = 0;
+
+                        List<FileSystemType> lstFs = new List<FileSystemType>();
+
+                        foreach(Filesystem _plugin in plugins.PluginsList.Values)
+                        {
+                            try
+                            {
+                                if(_plugin.Identify(_imageFormat, (blocks - 1), 0))
+                                {
+                                    string foo;
+                                    _plugin.GetInformation(_imageFormat, (blocks - 1), 0, out foo);
+                                    lstFs.Add(_plugin.XmlFSType);
+                                    Statistics.AddFilesystem(_plugin.XmlFSType.Type);
+                                }
+                            }
+#pragma warning disable RECS0022 // A catch clause that catches System.Exception and has an empty body
+                            catch
+#pragma warning restore RECS0022 // A catch clause that catches System.Exception and has an empty body
+                            {
+                                //DicConsole.DebugWriteLine("Create-sidecar command", "Plugin {0} crashed", _plugin.Name);
+                            }
+                        }
+
+                        if(lstFs.Count > 0)
+                            xmlFileSysInfo[0].FileSystems = lstFs.ToArray();
+                    }
+                }
+
+                sidecar.BlockMedia[0].Checksums = dataChk.End().ToArray();
+                string xmlDskTyp, xmlDskSubTyp;
+                if(dev.IsCompactFlash)
+                    Metadata.MediaType.MediaTypeToString(MediaType.CompactFlash, out xmlDskTyp, out xmlDskSubTyp);
+                else if(dev.IsPCMCIA)
+                    Metadata.MediaType.MediaTypeToString(MediaType.PCCardTypeI, out xmlDskTyp, out xmlDskSubTyp);
+                else
+                    Metadata.MediaType.MediaTypeToString(MediaType.GENERIC_HDD, out xmlDskTyp, out xmlDskSubTyp);
+                sidecar.BlockMedia[0].DiskType = xmlDskTyp;
+                sidecar.BlockMedia[0].DiskSubType = xmlDskSubTyp;
+                // TODO: Implement device firmware revision
+                sidecar.BlockMedia[0].Image = new ImageType();
+                sidecar.BlockMedia[0].Image.format = "Raw disk image (sector by sector copy)";
+                sidecar.BlockMedia[0].Image.Value = outputPrefix + ".bin";
+                sidecar.BlockMedia[0].Interface = "ATA";
+                sidecar.BlockMedia[0].LogicalBlocks = (long)blocks;
+                sidecar.BlockMedia[0].PhysicalBlockSize = (int)physicalsectorsize;
+                sidecar.BlockMedia[0].LogicalBlockSize = (int)blockSize;
+                sidecar.BlockMedia[0].Manufacturer = dev.Manufacturer;
+                sidecar.BlockMedia[0].Model = dev.Model;
+                sidecar.BlockMedia[0].Serial = dev.Serial;
+                sidecar.BlockMedia[0].Size = (long)(blocks * blockSize);
+                if(xmlFileSysInfo != null)
+                    sidecar.BlockMedia[0].FileSystemInformation = xmlFileSysInfo;
+                if(cylinders > 0 && heads > 0 && sectors > 0)
+                {
+                    sidecar.BlockMedia[0].Cylinders = cylinders;
+                    sidecar.BlockMedia[0].CylindersSpecified = true;
+                    sidecar.BlockMedia[0].Heads = heads;
+                    sidecar.BlockMedia[0].HeadsSpecified = true;
+                    sidecar.BlockMedia[0].SectorsPerTrack = sectors;
+                    sidecar.BlockMedia[0].SectorsPerTrackSpecified = true;
+                }
+
+                DicConsole.WriteLine();
+
+                DicConsole.WriteLine("Took a total of {0:F3} seconds ({1:F3} processing commands, {2:F3} checksumming).", (end - start).TotalSeconds, totalDuration / 1000, totalChkDuration / 1000);
+                DicConsole.WriteLine("Avegare speed: {0:F3} MiB/sec.", (((double)blockSize * (double)(blocks + 1)) / 1048576) / (totalDuration / 1000));
+                DicConsole.WriteLine("Fastest speed burst: {0:F3} MiB/sec.", maxSpeed);
+                DicConsole.WriteLine("Slowest speed burst: {0:F3} MiB/sec.", minSpeed);
+                DicConsole.WriteLine("{0} sectors could not be read.", unreadableSectors.Count);
+                if(unreadableSectors.Count > 0)
+                {
+                    unreadableSectors.Sort();
+                    foreach(ulong bad in unreadableSectors)
+                        DicConsole.WriteLine("Sector {0} could not be read", bad);
+                }
+                DicConsole.WriteLine();
+
+                if(!aborted)
+                {
+                    DicConsole.WriteLine("Writing metadata sidecar");
+
+                    FileStream xmlFs = new FileStream(outputPrefix + ".cicm.xml",
+                                                  FileMode.Create);
+
+                    System.Xml.Serialization.XmlSerializer xmlSer = new System.Xml.Serialization.XmlSerializer(typeof(CICMMetadataType));
+                    xmlSer.Serialize(xmlFs, sidecar);
+                    xmlFs.Close();
+                }
+
+                Statistics.AddMedia(MediaType.GENERIC_HDD, true);
+            }
+            else
+                DicConsole.ErrorWriteLine("Unable to communicate with ATA device.");
+        }
+    }
+}

DiscImageChef.Core/Devices/Dumping/NVMe.cs

@@ -0,0 +1,50 @@
+// /***************************************************************************
+// The Disc Image Chef
+// ----------------------------------------------------------------------------
+//
+// Filename       : NVMe.cs
+// Version        : 1.0
+// Author(s)      : Natalia Portillo
+//
+// Component      : Component
+//
+// Revision       : $Revision$
+// Last change by : $Author$
+// Date           : $Date$
+//
+// --[ Description ] ----------------------------------------------------------
+//
+// Description
+//
+// --[ License ] --------------------------------------------------------------
+//
+//     This program is free software: you can redistribute it and/or modify
+//     it under the terms of the GNU General Public License as
+//     published by the Free Software Foundation, either version 3 of the
+//     License, or (at your option) any later version.
+//
+//     This program is distributed in the hope that it will be useful,
+//     but WITHOUT ANY WARRANTY; without even the implied warranty of
+//     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//     GNU General Public License for more details.
+//
+//     You should have received a copy of the GNU General Public License
+//     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+// ----------------------------------------------------------------------------
+// Copyright (C) 2011-2015 Claunia.com
+// ****************************************************************************/
+// //$Id$
+using System;
+using DiscImageChef.Devices;
+
+namespace DiscImageChef.Core.Devices.Dumping
+{
+    public static class NVMe
+    {
+        public static void Dump(Device dev, string devicePath, string outputPrefix, ushort retryPasses, bool force, bool dumpRaw, bool persistent, bool stopOnError)
+        {
+            throw new NotImplementedException("NVMe devices not yet supported.");
+        }
+    }
+}

DiscImageChef.Core/Devices/Dumping/SecureDigital.cs

@@ -0,0 +1,50 @@
+// /***************************************************************************
+// The Disc Image Chef
+// ----------------------------------------------------------------------------
+//
+// Filename       : SecureDigital.cs
+// Version        : 1.0
+// Author(s)      : Natalia Portillo
+//
+// Component      : Component
+//
+// Revision       : $Revision$
+// Last change by : $Author$
+// Date           : $Date$
+//
+// --[ Description ] ----------------------------------------------------------
+//
+// Description
+//
+// --[ License ] --------------------------------------------------------------
+//
+//     This program is free software: you can redistribute it and/or modify
+//     it under the terms of the GNU General Public License as
+//     published by the Free Software Foundation, either version 3 of the
+//     License, or (at your option) any later version.
+//
+//     This program is distributed in the hope that it will be useful,
+//     but WITHOUT ANY WARRANTY; without even the implied warranty of
+//     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//     GNU General Public License for more details.
+//
+//     You should have received a copy of the GNU General Public License
+//     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+// ----------------------------------------------------------------------------
+// Copyright (C) 2011-2015 Claunia.com
+// ****************************************************************************/
+// //$Id$
+using System;
+using DiscImageChef.Devices;
+
+namespace DiscImageChef.Core.Devices.Dumping
+{
+    public class SecureDigital
+    {
+        public static void Dump(Device dev, string devicePath, string outputPrefix, ushort retryPasses, bool force, bool dumpRaw, bool persistent, bool stopOnError)
+        {
+            throw new NotImplementedException("MMC/SD devices not yet supported.");
+        }
+    }
+}

DiscImageChef.Core/DiscImageChef.Core.csproj

@@ -45,6 +45,11 @@
     <Compile Include="Devices\Scanning\SecureDigital.cs" />
     <Compile Include="Devices\Scanning\NVMe.cs" />
     <Compile Include="Devices\Scanning\SCSI.cs" />
+    <Compile Include="Devices\Dumping\ATA.cs" />
+    <Compile Include="Devices\Dumping\NVMe.cs" />
+    <Compile Include="Devices\Dumping\SCSI.cs" />
+    <Compile Include="Devices\Dumping\SecureDigital.cs" />
+    <Compile Include="DataFile.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\DiscImageChef.Console\DiscImageChef.Console.csproj">
@@ -91,11 +96,16 @@
       <Project>{0BEB3088-B634-4289-AE17-CDF2D25D00D5}</Project>
       <Name>DiscImageChef.Decoders</Name>
     </ProjectReference>
+    <ProjectReference Include="..\DiscImageChef.Interop\DiscImageChef.Interop.csproj">
+      <Project>{9183F2E0-A879-4F23-9EE3-C6908F1332B2}</Project>
+      <Name>DiscImageChef.Interop</Name>
+    </ProjectReference>
   </ItemGroup>
   <ItemGroup>
     <Folder Include="Logging\" />
     <Folder Include="Devices\" />
     <Folder Include="Devices\Scanning\" />
+    <Folder Include="Devices\Dumping\" />
   </ItemGroup>
   <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
   <ProjectExtensions>

DiscImageChef/ChangeLog

@@ -1,3 +1,11 @@
+2017-05-27  Natalia Portillo  <claunia@claunia.com>
+
+	* Commands/DumpMedia.cs:
+	* Commands/MediaInfo.cs:
+	* Commands/DeviceInfo.cs:
+	  Refactor: Move dumping code, and misc file writing code, to
+	  Core.
+
 2017-05-27  Natalia Portillo  <claunia@claunia.com>
 
 	* Commands/MediaScan.cs:

DiscImageChef/Commands/DeviceInfo.cs

@@ -36,6 +36,7 @@ using System.IO;
 using DiscImageChef.Console;
 using System.Text;
 using DiscImageChef.Decoders.ATA;
+using DiscImageChef.Core;
 
 namespace DiscImageChef.Commands
 {
@@ -187,7 +188,7 @@ namespace DiscImageChef.Commands
                             break;
                         }
 
-                        doWriteFile(options.OutputPrefix, "_ata_identify.bin", "ATA IDENTIFY", ataBuf);
+                        DataFile.WriteTo("Device-Info command", options.OutputPrefix, "_ata_identify.bin", "ATA IDENTIFY", ataBuf);
 
                         DicConsole.WriteLine(Identify.Prettify(ataBuf));
 
@@ -250,7 +251,7 @@ namespace DiscImageChef.Commands
                             break;
                         }
 
-                        doWriteFile(options.OutputPrefix, "_atapi_identify.bin", "ATAPI IDENTIFY", ataBuf);
+                        DataFile.WriteTo("Device-Info command", options.OutputPrefix, "_atapi_identify.bin", "ATAPI IDENTIFY", ataBuf);
 
                         DicConsole.WriteLine(Identify.Prettify(ataBuf));
 
@@ -274,7 +275,7 @@ namespace DiscImageChef.Commands
                         if(dev.Type != DeviceType.ATAPI)
                             DicConsole.WriteLine("SCSI device");
 
-                        doWriteFile(options.OutputPrefix, "_scsi_inquiry.bin", "SCSI INQUIRY", inqBuf);
+                        DataFile.WriteTo("Device-Info command", options.OutputPrefix, "_scsi_inquiry.bin", "SCSI INQUIRY", inqBuf);
 
                         Decoders.SCSI.Inquiry.SCSIInquiry? inq = Decoders.SCSI.Inquiry.Decode(inqBuf);
                         DicConsole.WriteLine(Decoders.SCSI.Inquiry.Prettify(inq));
@@ -296,7 +297,7 @@ namespace DiscImageChef.Commands
                                         {
                                             DicConsole.WriteLine("ASCII Page {0:X2}h: {1}", page, Decoders.SCSI.EVPD.DecodeASCIIPage(inqBuf));
 
-                                            doWriteFile(options.OutputPrefix, string.Format("_scsi_evpd_{0:X2}h.bin", page), string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
+                                            DataFile.WriteTo("Device-Info command", options.OutputPrefix, string.Format("_scsi_evpd_{0:X2}h.bin", page), string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
                                         }
                                     }
                                     else if(page == 0x80)
@@ -305,7 +306,7 @@ namespace DiscImageChef.Commands
                                         if(!sense)
                                         {
                                             DicConsole.WriteLine("Unit Serial Number: {0}", Decoders.SCSI.EVPD.DecodePage80(inqBuf));
-                                            doWriteFile(options.OutputPrefix, string.Format("_scsi_evpd_{0:X2}h.bin", page), string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
+                                            DataFile.WriteTo("Device-Info command", options.OutputPrefix, string.Format("_scsi_evpd_{0:X2}h.bin", page), string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
                                         }
                                     }
                                     else if(page == 0x81)
@@ -314,7 +315,7 @@ namespace DiscImageChef.Commands
                                         if(!sense)
                                         {
                                             DicConsole.WriteLine("{0}", Decoders.SCSI.EVPD.PrettifyPage_81(inqBuf));
-                                            doWriteFile(options.OutputPrefix, string.Format("_scsi_evpd_{0:X2}h.bin", page), string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
+                                            DataFile.WriteTo("Device-Info command", options.OutputPrefix, string.Format("_scsi_evpd_{0:X2}h.bin", page), string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
                                         }
                                     }
                                     else if(page == 0x82)
@@ -323,7 +324,7 @@ namespace DiscImageChef.Commands
                                         if(!sense)
                                         {
                                             DicConsole.WriteLine("ASCII implemented operating definitions: {0}", Decoders.SCSI.EVPD.DecodePage82(inqBuf));
-                                            doWriteFile(options.OutputPrefix, string.Format("_scsi_evpd_{0:X2}h.bin", page), string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
+                                            DataFile.WriteTo("Device-Info command", options.OutputPrefix, string.Format("_scsi_evpd_{0:X2}h.bin", page), string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
                                         }
                                     }
                                     else if(page == 0x83)
@@ -332,7 +333,7 @@ namespace DiscImageChef.Commands
                                         if(!sense)
                                         {
                                             DicConsole.WriteLine("{0}", Decoders.SCSI.EVPD.PrettifyPage_83(inqBuf));
-                                            doWriteFile(options.OutputPrefix, string.Format("_scsi_evpd_{0:X2}h.bin", page), string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
+                                            DataFile.WriteTo("Device-Info command", options.OutputPrefix, string.Format("_scsi_evpd_{0:X2}h.bin", page), string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
                                         }
                                     }
                                     else if(page == 0x84)
@@ -341,7 +342,7 @@ namespace DiscImageChef.Commands
                                         if(!sense)
                                         {
                                             DicConsole.WriteLine("{0}", Decoders.SCSI.EVPD.PrettifyPage_84(inqBuf));
-                                            doWriteFile(options.OutputPrefix, string.Format("_scsi_evpd_{0:X2}h.bin", page), string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
+                                            DataFile.WriteTo("Device-Info command", options.OutputPrefix, string.Format("_scsi_evpd_{0:X2}h.bin", page), string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
                                         }
                                     }
                                     else if(page == 0x85)
@@ -350,7 +351,7 @@ namespace DiscImageChef.Commands
                                         if(!sense)
                                         {
                                             DicConsole.WriteLine("{0}", Decoders.SCSI.EVPD.PrettifyPage_85(inqBuf));
-                                            doWriteFile(options.OutputPrefix, string.Format("_scsi_evpd_{0:X2}h.bin", page), string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
+                                            DataFile.WriteTo("Device-Info command", options.OutputPrefix, string.Format("_scsi_evpd_{0:X2}h.bin", page), string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
                                         }
                                     }
                                     else if(page == 0x86)
@@ -359,7 +360,7 @@ namespace DiscImageChef.Commands
                                         if(!sense)
                                         {
                                             DicConsole.WriteLine("{0}", Decoders.SCSI.EVPD.PrettifyPage_86(inqBuf));
-                                            doWriteFile(options.OutputPrefix, string.Format("_scsi_evpd_{0:X2}h.bin", page), string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
+                                            DataFile.WriteTo("Device-Info command", options.OutputPrefix, string.Format("_scsi_evpd_{0:X2}h.bin", page), string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
                                         }
                                     }
                                     else if(page == 0x89)
@@ -368,7 +369,7 @@ namespace DiscImageChef.Commands
                                         if(!sense)
                                         {
                                             DicConsole.WriteLine("{0}", Decoders.SCSI.EVPD.PrettifyPage_89(inqBuf));
-                                            doWriteFile(options.OutputPrefix, string.Format("_scsi_evpd_{0:X2}h.bin", page), string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
+                                            DataFile.WriteTo("Device-Info command", options.OutputPrefix, string.Format("_scsi_evpd_{0:X2}h.bin", page), string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
                                         }
                                     }
                                     else if(page == 0xB0)
@@ -377,7 +378,7 @@ namespace DiscImageChef.Commands
                                         if(!sense)
                                         {
                                             DicConsole.WriteLine("{0}", Decoders.SCSI.EVPD.PrettifyPage_B0(inqBuf));
-                                            doWriteFile(options.OutputPrefix, string.Format("_scsi_evpd_{0:X2}h.bin", page), string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
+                                            DataFile.WriteTo("Device-Info command", options.OutputPrefix, string.Format("_scsi_evpd_{0:X2}h.bin", page), string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
                                         }
                                     }
                                     else if(page == 0xB1)
@@ -386,7 +387,7 @@ namespace DiscImageChef.Commands
                                         if(!sense)
                                         {
                                             DicConsole.WriteLine("Manufacturer-assigned Serial Number: {0}", Decoders.SCSI.EVPD.DecodePageB1(inqBuf));
-                                            doWriteFile(options.OutputPrefix, string.Format("_scsi_evpd_{0:X2}h.bin", page), string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
+                                            DataFile.WriteTo("Device-Info command", options.OutputPrefix, string.Format("_scsi_evpd_{0:X2}h.bin", page), string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
                                         }
                                     }
                                     else if(page == 0xB2)
@@ -395,7 +396,7 @@ namespace DiscImageChef.Commands
                                         if(!sense)
                                         {
                                             DicConsole.WriteLine("TapeAlert Supported Flags Bitmap: 0x{0:X16}", Decoders.SCSI.EVPD.DecodePageB2(inqBuf));
-                                            doWriteFile(options.OutputPrefix, string.Format("_scsi_evpd_{0:X2}h.bin", page), string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
+                                            DataFile.WriteTo("Device-Info command", options.OutputPrefix, string.Format("_scsi_evpd_{0:X2}h.bin", page), string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
                                         }
                                     }
                                     else if(page == 0xB3)
@@ -404,7 +405,7 @@ namespace DiscImageChef.Commands
                                         if(!sense)
                                         {
                                             DicConsole.WriteLine("Automation Device Serial Number: {0}", Decoders.SCSI.EVPD.DecodePageB3(inqBuf));
-                                            doWriteFile(options.OutputPrefix, string.Format("_scsi_evpd_{0:X2}h.bin", page), string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
+                                            DataFile.WriteTo("Device-Info command", options.OutputPrefix, string.Format("_scsi_evpd_{0:X2}h.bin", page), string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
                                         }
                                     }
                                     else if(page == 0xB4)
@@ -413,7 +414,7 @@ namespace DiscImageChef.Commands
                                         if(!sense)
                                         {
                                             DicConsole.WriteLine("Data Transfer Device Element Address: 0x{0}", Decoders.SCSI.EVPD.DecodePageB4(inqBuf));
-                                            doWriteFile(options.OutputPrefix, string.Format("_scsi_evpd_{0:X2}h.bin", page), string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
+                                            DataFile.WriteTo("Device-Info command", options.OutputPrefix, string.Format("_scsi_evpd_{0:X2}h.bin", page), string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
                                         }
                                     }
                                     else if(page == 0xC0 && StringHandlers.CToString(inq.Value.VendorIdentification).ToLowerInvariant().Trim() == "quantum")
@@ -422,7 +423,7 @@ namespace DiscImageChef.Commands
                                         if(!sense)
                                         {
                                             DicConsole.WriteLine("{0}", Decoders.SCSI.EVPD.PrettifyPage_C0_Quantum(inqBuf));
-                                            doWriteFile(options.OutputPrefix, string.Format("_scsi_evpd_{0:X2}h.bin", page), string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
+                                            DataFile.WriteTo("Device-Info command", options.OutputPrefix, string.Format("_scsi_evpd_{0:X2}h.bin", page), string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
                                         }
                                     }
                                     else if(page == 0xC0 && StringHandlers.CToString(inq.Value.VendorIdentification).ToLowerInvariant().Trim() == "seagate")
@@ -431,7 +432,7 @@ namespace DiscImageChef.Commands
                                         if(!sense)
                                         {
                                             DicConsole.WriteLine("{0}", Decoders.SCSI.EVPD.PrettifyPage_C0_Seagate(inqBuf));
-                                            doWriteFile(options.OutputPrefix, string.Format("_scsi_evpd_{0:X2}h.bin", page), string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
+                                            DataFile.WriteTo("Device-Info command", options.OutputPrefix, string.Format("_scsi_evpd_{0:X2}h.bin", page), string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
                                         }
                                     }
                                     else if(page == 0xC0 && StringHandlers.CToString(inq.Value.VendorIdentification).ToLowerInvariant().Trim() == "ibm")
@@ -440,7 +441,7 @@ namespace DiscImageChef.Commands
                                         if(!sense)
                                         {
                                             DicConsole.WriteLine("{0}", Decoders.SCSI.EVPD.PrettifyPage_C0_IBM(inqBuf));
-                                            doWriteFile(options.OutputPrefix, string.Format("_scsi_evpd_{0:X2}h.bin", page), string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
+                                            DataFile.WriteTo("Device-Info command", options.OutputPrefix, string.Format("_scsi_evpd_{0:X2}h.bin", page), string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
                                         }
                                     }
                                     else if(page == 0xC1 && StringHandlers.CToString(inq.Value.VendorIdentification).ToLowerInvariant().Trim() == "ibm")
@@ -449,7 +450,7 @@ namespace DiscImageChef.Commands
                                         if(!sense)
                                         {
                                             DicConsole.WriteLine("{0}", Decoders.SCSI.EVPD.PrettifyPage_C1_IBM(inqBuf));
-                                            doWriteFile(options.OutputPrefix, string.Format("_scsi_evpd_{0:X2}h.bin", page), string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
+                                            DataFile.WriteTo("Device-Info command", options.OutputPrefix, string.Format("_scsi_evpd_{0:X2}h.bin", page), string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
                                         }
                                     }
                                     else if((page == 0xC0 || page == 0xC1) && StringHandlers.CToString(inq.Value.VendorIdentification).ToLowerInvariant().Trim() == "certance")
@@ -458,7 +459,7 @@ namespace DiscImageChef.Commands
                                         if(!sense)
                                         {
                                             DicConsole.WriteLine("{0}", Decoders.SCSI.EVPD.PrettifyPage_C0_C1_Certance(inqBuf));
-                                            doWriteFile(options.OutputPrefix, string.Format("_scsi_evpd_{0:X2}h.bin", page), string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
+                                            DataFile.WriteTo("Device-Info command", options.OutputPrefix, string.Format("_scsi_evpd_{0:X2}h.bin", page), string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
                                         }
                                     }
                                     else if((page == 0xC2 || page == 0xC3 || page == 0xC4 || page == 0xC5 || page == 0xC6) &&
@@ -468,7 +469,7 @@ namespace DiscImageChef.Commands
                                         if(!sense)
                                         {
                                             DicConsole.WriteLine("{0}", Decoders.SCSI.EVPD.PrettifyPage_C2_C3_C4_C5_C6_Certance(inqBuf));
-                                            doWriteFile(options.OutputPrefix, string.Format("_scsi_evpd_{0:X2}h.bin", page), string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
+                                            DataFile.WriteTo("Device-Info command", options.OutputPrefix, string.Format("_scsi_evpd_{0:X2}h.bin", page), string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
                                         }
                                     }
                                     else if((page == 0xC0 || page == 0xC1 || page == 0xC2 || page == 0xC3 || page == 0xC4 || page == 0xC5) &&
@@ -478,7 +479,7 @@ namespace DiscImageChef.Commands
                                         if(!sense)
                                         {
                                             DicConsole.WriteLine("{0}", Decoders.SCSI.EVPD.PrettifyPage_C0_to_C5_HP(inqBuf));
-                                            doWriteFile(options.OutputPrefix, string.Format("_scsi_evpd_{0:X2}h.bin", page), string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
+                                            DataFile.WriteTo("Device-Info command", options.OutputPrefix, string.Format("_scsi_evpd_{0:X2}h.bin", page), string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
                                         }
                                     }
                                     else if(page == 0xDF && StringHandlers.CToString(inq.Value.VendorIdentification).ToLowerInvariant().Trim() == "certance")
@@ -487,7 +488,7 @@ namespace DiscImageChef.Commands
                                         if(!sense)
                                         {
                                             DicConsole.WriteLine("{0}", Decoders.SCSI.EVPD.PrettifyPage_DF_Certance(inqBuf));
-                                            doWriteFile(options.OutputPrefix, string.Format("_scsi_evpd_{0:X2}h.bin", page), string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
+                                            DataFile.WriteTo("Device-Info command", options.OutputPrefix, string.Format("_scsi_evpd_{0:X2}h.bin", page), string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
                                         }
                                     }
                                     else
@@ -499,7 +500,7 @@ namespace DiscImageChef.Commands
                                             sense = dev.ScsiInquiry(out inqBuf, out senseBuf, page);
                                             if(!sense)
                                             {
-                                                doWriteFile(options.OutputPrefix, string.Format("_scsi_evpd_{0:X2}h.bin", page), string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
+                                                DataFile.WriteTo("Device-Info command", options.OutputPrefix, string.Format("_scsi_evpd_{0:X2}h.bin", page), string.Format("SCSI INQUIRY EVPD {0:X2}h", page), inqBuf);
                                             }
                                         }
                                     }
@@ -532,7 +533,7 @@ namespace DiscImageChef.Commands
                         }
 
                         if(!sense)
-                            doWriteFile(options.OutputPrefix, "_scsi_modesense.bin", "SCSI MODE SENSE", modeBuf);
+                            DataFile.WriteTo("Device-Info command", options.OutputPrefix, "_scsi_modesense.bin", "SCSI MODE SENSE", modeBuf);
 
                         if(decMode.HasValue)
                         {
@@ -881,7 +882,7 @@ namespace DiscImageChef.Commands
 
                             if(!sense)
                             {
-                                doWriteFile(options.OutputPrefix, "_mmc_getconfiguration.bin", "MMC GET CONFIGURATION", confBuf);
+                                DataFile.WriteTo("Device-Info command", options.OutputPrefix, "_mmc_getconfiguration.bin", "MMC GET CONFIGURATION", confBuf);
 
                                 Decoders.SCSI.MMC.Features.SeparatedFeatures ftr = Decoders.SCSI.MMC.Features.Separate(confBuf);
 
@@ -1170,7 +1171,7 @@ namespace DiscImageChef.Commands
 
                                 if(!plxtSense)
                                 {
-                                    doWriteFile(options.OutputPrefix, "_plextor_eeprom.bin", "PLEXTOR READ EEPROM", plxtBuf);
+                                    DataFile.WriteTo("Device-Info command", options.OutputPrefix, "_plextor_eeprom.bin", "PLEXTOR READ EEPROM", plxtBuf);
 
                                     ushort discs;
                                     uint cdReadTime, cdWriteTime, dvdReadTime = 0, dvdWriteTime = 0;
@@ -1366,7 +1367,7 @@ namespace DiscImageChef.Commands
                                 DicConsole.ErrorWriteLine("READ BLOCK LIMITS:\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
                             else
                             {
-                                doWriteFile(options.OutputPrefix, "_ssc_readblocklimits.bin", "SSC READ BLOCK LIMITS", seqBuf);
+                                DataFile.WriteTo("Device-Info command", options.OutputPrefix, "_ssc_readblocklimits.bin", "SSC READ BLOCK LIMITS", seqBuf);
                                 DicConsole.WriteLine("Block limits for device:");
                                 DicConsole.WriteLine(Decoders.SCSI.SSC.BlockLimits.Prettify(seqBuf));
                             }
@@ -1376,7 +1377,7 @@ namespace DiscImageChef.Commands
                                 DicConsole.ErrorWriteLine("REPORT DENSITY SUPPORT:\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
                             else
                             {
-                                doWriteFile(options.OutputPrefix, "_ssc_reportdensitysupport.bin", "SSC REPORT DENSITY SUPPORT", seqBuf);
+                                DataFile.WriteTo("Device-Info command", options.OutputPrefix, "_ssc_reportdensitysupport.bin", "SSC REPORT DENSITY SUPPORT", seqBuf);
                                 Decoders.SCSI.SSC.DensitySupport.DensitySupportHeader? dens = Decoders.SCSI.SSC.DensitySupport.DecodeDensity(seqBuf);
                                 if(dens.HasValue)
                                 {
@@ -1390,7 +1391,7 @@ namespace DiscImageChef.Commands
                                 DicConsole.ErrorWriteLine("REPORT DENSITY SUPPORT (MEDIUM):\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
                             else
                             {
-                                doWriteFile(options.OutputPrefix, "_ssc_reportdensitysupport_medium.bin", "SSC REPORT DENSITY SUPPORT (MEDIUM)", seqBuf);
+                                DataFile.WriteTo("Device-Info command", options.OutputPrefix, "_ssc_reportdensitysupport_medium.bin", "SSC REPORT DENSITY SUPPORT (MEDIUM)", seqBuf);
                                 Decoders.SCSI.SSC.DensitySupport.MediaTypeSupportHeader? meds = Decoders.SCSI.SSC.DensitySupport.DecodeMediumType(seqBuf);
                                 if(meds.HasValue)
                                 {
@@ -1410,29 +1411,6 @@ namespace DiscImageChef.Commands
 
             Core.Statistics.AddCommand("device-info");
         }
-
-        static void doWriteFile(string outputPrefix, string outputSuffix, string whatWriting, byte[] data)
-        {
-            if(!string.IsNullOrEmpty(outputPrefix))
-            {
-                if(!File.Exists(outputPrefix + outputSuffix))
-                {
-                    try
-                    {
-                        DicConsole.DebugWriteLine("Device-Info command", "Writing " + whatWriting + " to {0}{1}", outputPrefix, outputSuffix);
-                        FileStream outputFs = new FileStream(outputPrefix + outputSuffix, FileMode.CreateNew);
-                        outputFs.Write(data, 0, data.Length);
-                        outputFs.Close();
-                    }
-                    catch
-                    {
-                        DicConsole.ErrorWriteLine("Unable to write file {0}{1}", outputPrefix, outputSuffix);
-                    }
-                }
-                else
-                    DicConsole.ErrorWriteLine("Not overwriting file {0}{1}", outputPrefix, outputSuffix);
-            }
-        }
     }
 }
 

DiscImageChef/Commands/MediaInfo.cs

@@ -36,6 +36,7 @@ using System.IO;
 using DiscImageChef.Devices;
 using DiscImageChef.CommonTypes;
 using System.Linq;
+using DiscImageChef.Core;
 
 namespace DiscImageChef.Commands
 {
@@ -208,7 +209,7 @@ namespace DiscImageChef.Commands
             }
 
             if(!sense)
-                doWriteFile(outputPrefix, "_scsi_modesense.bin", "SCSI MODE SENSE", modeBuf);
+                DataFile.WriteTo("Media-Info command", outputPrefix, "_scsi_modesense.bin", "SCSI MODE SENSE", modeBuf);
 
             byte scsiMediumType = 0;
             byte scsiDensityCode = 0;
@@ -234,7 +235,7 @@ namespace DiscImageChef.Commands
                 sense = dev.ReadCapacity(out cmdBuf, out senseBuf, dev.Timeout, out duration);
                 if(!sense)
                 {
-                    doWriteFile(outputPrefix, "_readcapacity.bin", "SCSI READ CAPACITY", cmdBuf);
+                    DataFile.WriteTo("Media-Info command", outputPrefix, "_readcapacity.bin", "SCSI READ CAPACITY", cmdBuf);
                     blocks = (ulong)((cmdBuf[0] << 24) + (cmdBuf[1] << 16) + (cmdBuf[2] << 8) + (cmdBuf[3]));
                     blockSize = (uint)((cmdBuf[5] << 24) + (cmdBuf[5] << 16) + (cmdBuf[6] << 8) + (cmdBuf[7]));
                 }
@@ -255,7 +256,7 @@ namespace DiscImageChef.Commands
 
                     if(!sense)
                     {
-                        doWriteFile(outputPrefix, "_readcapacity16.bin", "SCSI READ CAPACITY(16)", cmdBuf);
+                        DataFile.WriteTo("Media-Info command", outputPrefix, "_readcapacity16.bin", "SCSI READ CAPACITY(16)", cmdBuf);
                         byte[] temp = new byte[8];
 
                         Array.Copy(cmdBuf, 0, temp, 0, 8);
@@ -285,7 +286,7 @@ namespace DiscImageChef.Commands
 
                     if(!sense && !seqBuf.SequenceEqual(medBuf))
                     {
-                        doWriteFile(outputPrefix, "_ssc_reportdensitysupport_media.bin", "SSC REPORT DENSITY SUPPORT (MEDIA)", seqBuf);
+                        DataFile.WriteTo("Media-Info command", outputPrefix, "_ssc_reportdensitysupport_media.bin", "SSC REPORT DENSITY SUPPORT (MEDIA)", seqBuf);
                         Decoders.SCSI.SSC.DensitySupport.DensitySupportHeader? dens = Decoders.SCSI.SSC.DensitySupport.DecodeDensity(seqBuf);
                         if(dens.HasValue)
                         {
@@ -302,7 +303,7 @@ namespace DiscImageChef.Commands
 
                     if(!sense && !seqBuf.SequenceEqual(medBuf))
                     {
-                        doWriteFile(outputPrefix, "_ssc_reportdensitysupport_medium_media.bin", "SSC REPORT DENSITY SUPPORT (MEDIUM & MEDIA)", seqBuf);
+                        DataFile.WriteTo("Media-Info command", outputPrefix, "_ssc_reportdensitysupport_medium_media.bin", "SSC REPORT DENSITY SUPPORT (MEDIUM & MEDIA)", seqBuf);
                         Decoders.SCSI.SSC.DensitySupport.MediaTypeSupportHeader? meds = Decoders.SCSI.SSC.DensitySupport.DecodeMediumType(seqBuf);
                         if(meds.HasValue)
                         {
@@ -320,7 +321,7 @@ namespace DiscImageChef.Commands
                     DicConsole.ErrorWriteLine("SCSI READ ATTRIBUTE:\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
                 else
                 {
-                    doWriteFile(outputPrefix, "_scsi_readattribute.bin", "SCSI READ ATTRIBUTE", seqBuf);
+                    DataFile.WriteTo("Media-Info command", outputPrefix, "_scsi_readattribute.bin", "SCSI READ ATTRIBUTE", seqBuf);
                 }
                 */
             }
@@ -332,7 +333,7 @@ namespace DiscImageChef.Commands
                     DicConsole.DebugWriteLine("Media-Info command", "READ GET CONFIGURATION:\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
                 else
                 {
-                    doWriteFile(outputPrefix, "_getconfiguration_current.bin", "SCSI GET CONFIGURATION", cmdBuf);
+                    DataFile.WriteTo("Media-Info command", outputPrefix, "_getconfiguration_current.bin", "SCSI GET CONFIGURATION", cmdBuf);
 
                     Decoders.SCSI.MMC.Features.SeparatedFeatures ftr = Decoders.SCSI.MMC.Features.Separate(cmdBuf);
 
@@ -434,12 +435,12 @@ namespace DiscImageChef.Commands
                 if(sense)
                     DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: Recognized Format Layers\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
                 else
-                    doWriteFile(outputPrefix, "_readdiscstructure_formatlayers.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
+                    DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_formatlayers.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
                 sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.WriteProtectionStatus, 0, dev.Timeout, out duration);
                 if(sense)
                     DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: Write Protection Status\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
                 else
-                    doWriteFile(outputPrefix, "_readdiscstructure_writeprotection.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
+                    DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_writeprotection.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
 
                 // More like a drive information
                 /*
@@ -447,7 +448,7 @@ namespace DiscImageChef.Commands
                 if(sense)
                     DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: Capability List\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
                 else
-                    doWriteFile(outputPrefix, "_readdiscstructure_capabilitylist.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
+                    DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_capabilitylist.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
                 */
 
                 #region All DVD and HD DVD types
@@ -467,7 +468,7 @@ namespace DiscImageChef.Commands
                         DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: PFI\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
                     else
                     {
-                        doWriteFile(outputPrefix, "_readdiscstructure_dvd_pfi.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
+                        DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_pfi.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
                         Decoders.DVD.PFI.PhysicalFormatInformation? decPfi = Decoders.DVD.PFI.Decode(cmdBuf);
                         if(decPfi.HasValue)
                         {
@@ -538,7 +539,7 @@ namespace DiscImageChef.Commands
                         DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: DMI\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
                     else
                     {
-                        doWriteFile(outputPrefix, "_readdiscstructure_dvd_dmi.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
+                        DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_dmi.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
                         if(Decoders.Xbox.DMI.IsXbox(cmdBuf))
                         {
                             dskType = MediaType.XGD;
@@ -567,7 +568,7 @@ namespace DiscImageChef.Commands
                         DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: CMI\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
                     else
                     {
-                        doWriteFile(outputPrefix, "_readdiscstructure_dvd_cmi.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
+                        DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_cmi.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
                         DicConsole.WriteLine("Lead-In CMI:\n{0}", Decoders.DVD.CSS_CPRM.PrettifyLeadInCopyright(cmdBuf));
                     }
                 }
@@ -581,12 +582,12 @@ namespace DiscImageChef.Commands
                     if(sense)
                         DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: BCA\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
                     else
-                        doWriteFile(outputPrefix, "_readdiscstructure_dvd_bca.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
+                        DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_bca.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
                     sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.DVD_AACS, 0, dev.Timeout, out duration);
                     if(sense)
                         DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: DVD AACS\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
                     else
-                        doWriteFile(outputPrefix, "_readdiscstructure_dvd_aacs.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
+                        DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_aacs.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
                 }
                 #endregion DVD-ROM and HD DVD-ROM
 
@@ -596,57 +597,57 @@ namespace DiscImageChef.Commands
                 if(sense)
                     DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: Disc Key\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
                 else
-                    doWriteFile(outputPrefix, "_readdiscstructure_dvd_disckey.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
+                    DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_disckey.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
                 sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.SectorCopyrightInformation, 0, dev.Timeout, out duration);
                 if(sense)
                     DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: Sector CMI\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
                 else
-                    doWriteFile(outputPrefix, "_readdiscstructure_dvd_sectorcmi.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
+                    DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_sectorcmi.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
                 sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.MediaIdentifier, 0, dev.Timeout, out duration);
                 if(sense)
                     DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: Media ID\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
                 else
-                    doWriteFile(outputPrefix, "_readdiscstructure_dvd_mediaid.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
+                    DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_mediaid.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
                 sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.MediaKeyBlock, 0, dev.Timeout, out duration);
                 if(sense)
                     DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: MKB\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
                 else
-                    doWriteFile(outputPrefix, "_readdiscstructure_dvd_mkb.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
+                    DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_mkb.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
                 sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.AACSVolId, 0, dev.Timeout, out duration);
                 if(sense)
                     DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: AACS Volume ID\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
                 else
-                    doWriteFile(outputPrefix, "_readdiscstructure_aacsvolid.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
+                    DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_aacsvolid.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
                 sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.AACSMediaSerial, 0, dev.Timeout, out duration);
                 if(sense)
                     DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: AACS Media Serial Number\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
                 else
-                    doWriteFile(outputPrefix, "_readdiscstructure_aacssn.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
+                    DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_aacssn.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
                 sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.AACSMediaId, 0, dev.Timeout, out duration);
                 if(sense)
                     DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: AACS Media ID\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
                 else
-                    doWriteFile(outputPrefix, "_readdiscstructure_aacsmediaid.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
+                    DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_aacsmediaid.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
                 sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.AACSMKB, 0, dev.Timeout, out duration);
                 if(sense)
                     DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: AACS MKB\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
                 else
-                    doWriteFile(outputPrefix, "_readdiscstructure_aacsmkb.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
+                    DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_aacsmkb.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
                 sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.AACSLBAExtents, 0, dev.Timeout, out duration);
                 if(sense)
                     DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: AACS LBA Extents\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
                 else
-                    doWriteFile(outputPrefix, "_readdiscstructure_aacslbaextents.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
+                    DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_aacslbaextents.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
                 sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.AACSMKBCPRM, 0, dev.Timeout, out duration);
                 if(sense)
                     DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: AACS CPRM MKB\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
                 else
-                    doWriteFile(outputPrefix, "_readdiscstructure_aacscprmmkb.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
+                    DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_aacscprmmkb.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
                 sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.AACSDataKeys, 0, dev.Timeout, out duration);
                 if(sense)
                     DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: AACS Data Keys\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
                 else
-                    doWriteFile(outputPrefix, "_readdiscstructure_aacsdatakeys.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
+                    DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_aacsdatakeys.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
                 */
                 #endregion Require drive authentication, won't work
 
@@ -658,7 +659,7 @@ namespace DiscImageChef.Commands
                         DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: DDS\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
                     else
                     {
-                        doWriteFile(outputPrefix, "_readdiscstructure_dvdram_dds.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
+                        DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvdram_dds.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
                         DicConsole.WriteLine("Disc Definition Structure:\n{0}", Decoders.DVD.DDS.Prettify(cmdBuf));
                     }
                     sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.DVDRAM_MediumStatus, 0, dev.Timeout, out duration);
@@ -666,7 +667,7 @@ namespace DiscImageChef.Commands
                         DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: Medium Status\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
                     else
                     {
-                        doWriteFile(outputPrefix, "_readdiscstructure_dvdram_status.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
+                        DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvdram_status.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
                         DicConsole.WriteLine("Medium Status:\n{0}", Decoders.DVD.Cartridge.Prettify(cmdBuf));
                     }
                     sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.DVDRAM_SpareAreaInformation, 0, dev.Timeout, out duration);
@@ -674,7 +675,7 @@ namespace DiscImageChef.Commands
                         DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: SAI\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
                     else
                     {
-                        doWriteFile(outputPrefix, "_readdiscstructure_dvdram_spare.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
+                        DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvdram_spare.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
                         DicConsole.WriteLine("Spare Area Information:\n{0}", Decoders.DVD.Spare.Prettify(cmdBuf));
                     }
                 }
@@ -687,7 +688,7 @@ namespace DiscImageChef.Commands
                     if(sense)
                         DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: Last-Out Border RMD\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
                     else
-                        doWriteFile(outputPrefix, "_readdiscstructure_dvd_lastrmd.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
+                        DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_lastrmd.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
                 }
                 #endregion DVD-R and HD DVD-R
 
@@ -698,7 +699,7 @@ namespace DiscImageChef.Commands
                     if(sense)
                         DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: Pre-Recorded Info\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
                     else
-                        doWriteFile(outputPrefix, "_readdiscstructure_dvd_pri.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
+                        DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_pri.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
                 }
                 #endregion DVD-R and DVD-RW
 
@@ -709,12 +710,12 @@ namespace DiscImageChef.Commands
                     if(sense)
                         DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: DVD-R Media ID\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
                     else
-                        doWriteFile(outputPrefix, "_readdiscstructure_dvdr_mediaid.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
+                        DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvdr_mediaid.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
                     sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.DVDR_PhysicalInformation, 0, dev.Timeout, out duration);
                     if(sense)
                         DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: DVD-R PFI\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
                     else
-                        doWriteFile(outputPrefix, "_readdiscstructure_dvdr_pfi.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
+                        DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvdr_pfi.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
                 }
                 #endregion DVD-R, DVD-RW and HD DVD-R
 
@@ -726,13 +727,13 @@ namespace DiscImageChef.Commands
                     if(sense)
                         DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: ADIP\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
                     else
-                        doWriteFile(outputPrefix, "_readdiscstructure_dvd+_adip.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
+                        DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd+_adip.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
 
                     sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.DCB, 0, dev.Timeout, out duration);
                     if(sense)
                         DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: DCB\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
                     else
-                        doWriteFile(outputPrefix, "_readdiscstructure_dvd+_dcb.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
+                        DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd+_dcb.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
                 }
                 #endregion All DVD+
 
@@ -743,7 +744,7 @@ namespace DiscImageChef.Commands
                     if(sense)
                         DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: HDDVD CMI\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
                     else
-                        doWriteFile(outputPrefix, "_readdiscstructure_hddvd_cmi.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
+                        DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_hddvd_cmi.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
                 }
                 #endregion HD DVD-ROM
 
@@ -754,12 +755,12 @@ namespace DiscImageChef.Commands
                     if(sense)
                         DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: HDDVD-R Medium Status\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
                     else
-                        doWriteFile(outputPrefix, "_readdiscstructure_hddvdr_status.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
+                        DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_hddvdr_status.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
                     sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.HDDVDR_LastRMD, 0, dev.Timeout, out duration);
                     if(sense)
                         DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: Last RMD\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
                     else
-                        doWriteFile(outputPrefix, "_readdiscstructure_hddvdr_lastrmd.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
+                        DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_hddvdr_lastrmd.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
                 }
                 #endregion HD DVD-R
 
@@ -771,7 +772,7 @@ namespace DiscImageChef.Commands
                     if(sense)
                         DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: Layer Capacity\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
                     else
-                        doWriteFile(outputPrefix, "_readdiscstructure_dvdr_layercap.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
+                        DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvdr_layercap.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
                 }
                 #endregion DVD-R DL, DVD-RW DL, DVD+R DL, DVD+RW DL
 
@@ -782,22 +783,22 @@ namespace DiscImageChef.Commands
                     if(sense)
                         DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: Middle Zone Start\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
                     else
-                        doWriteFile(outputPrefix, "_readdiscstructure_dvd_mzs.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
+                        DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_mzs.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
                     sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.JumpIntervalSize, 0, dev.Timeout, out duration);
                     if(sense)
                         DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: Jump Interval Size\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
                     else
-                        doWriteFile(outputPrefix, "_readdiscstructure_dvd_jis.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
+                        DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_jis.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
                     sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.ManualLayerJumpStartLBA, 0, dev.Timeout, out duration);
                     if(sense)
                         DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: Manual Layer Jump Start LBA\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
                     else
-                        doWriteFile(outputPrefix, "_readdiscstructure_dvd_manuallj.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
+                        DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_manuallj.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
                     sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.RemapAnchorPoint, 0, dev.Timeout, out duration);
                     if(sense)
                         DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: Remap Anchor Point\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
                     else
-                        doWriteFile(outputPrefix, "_readdiscstructure_dvd_remapanchor.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
+                        DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_remapanchor.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
                 }
                 #endregion DVD-R DL
 
@@ -810,14 +811,14 @@ namespace DiscImageChef.Commands
                         DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: DI\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
                     else
                     {
-                        doWriteFile(outputPrefix, "_readdiscstructure_bd_di.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
+                        DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_bd_di.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
                         DicConsole.WriteLine("Blu-ray Disc Information:\n{0}", Decoders.Bluray.DI.Prettify(cmdBuf));
                     }
                     sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.BD, 0, 0, MmcDiscStructureFormat.PAC, 0, dev.Timeout, out duration);
                     if(sense)
                         DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: PAC\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
                     else
-                        doWriteFile(outputPrefix, "_readdiscstructure_bd_pac.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
+                        DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_bd_pac.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
                 }
                 #endregion All Blu-ray
 
@@ -829,7 +830,7 @@ namespace DiscImageChef.Commands
                         DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: BCA\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
                     else
                     {
-                        doWriteFile(outputPrefix, "_readdiscstructure_bd_bca.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
+                        DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_bd_bca.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
                         DicConsole.WriteLine("Blu-ray Burst Cutting Area:\n{0}", Decoders.Bluray.BCA.Prettify(cmdBuf));
                     }
                 }
@@ -844,7 +845,7 @@ namespace DiscImageChef.Commands
                         DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: DDS\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
                     else
                     {
-                        doWriteFile(outputPrefix, "_readdiscstructure_bd_dds.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
+                        DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_bd_dds.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
                         DicConsole.WriteLine("Blu-ray Disc Definition Structure:\n{0}", Decoders.Bluray.DDS.Prettify(cmdBuf));
                     }
                     sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.BD, 0, 0, MmcDiscStructureFormat.CartridgeStatus, 0, dev.Timeout, out duration);
@@ -852,7 +853,7 @@ namespace DiscImageChef.Commands
                         DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: Cartridge Status\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
                     else
                     {
-                        doWriteFile(outputPrefix, "_readdiscstructure_bd_cartstatus.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
+                        DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_bd_cartstatus.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
                         DicConsole.WriteLine("Blu-ray Cartridge Status:\n{0}", Decoders.Bluray.DI.Prettify(cmdBuf));
                     }
                     sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.BD, 0, 0, MmcDiscStructureFormat.BD_SpareAreaInformation, 0, dev.Timeout, out duration);
@@ -860,21 +861,21 @@ namespace DiscImageChef.Commands
                         DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: Spare Area Information\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
                     else
                     {
-                        doWriteFile(outputPrefix, "_readdiscstructure_bd_spare.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
+                        DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_bd_spare.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
                         DicConsole.WriteLine("Blu-ray Spare Area Information:\n{0}", Decoders.Bluray.DI.Prettify(cmdBuf));
                     }
                     sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.BD, 0, 0, MmcDiscStructureFormat.RawDFL, 0, dev.Timeout, out duration);
                     if(sense)
                         DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: Raw DFL\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
                     else
-                        doWriteFile(outputPrefix, "_readdiscstructure_bd_dfl.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
+                        DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_bd_dfl.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
                     sense = dev.ReadDiscInformation(out cmdBuf, out senseBuf, MmcDiscInformationDataTypes.TrackResources, dev.Timeout, out duration);
                     if(sense)
                         DicConsole.DebugWriteLine("Media-Info command", "READ DISC INFORMATION 001b\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
                     else
                     {
                         DicConsole.WriteLine("Track Resources Information:\n{0}", Decoders.SCSI.MMC.DiscInformation.Prettify(cmdBuf));
-                        doWriteFile(outputPrefix, "_readdiscinformation_001b.bin", "SCSI READ DISC INFORMATION", cmdBuf);
+                        DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscinformation_001b.bin", "SCSI READ DISC INFORMATION", cmdBuf);
                     }
                     sense = dev.ReadDiscInformation(out cmdBuf, out senseBuf, MmcDiscInformationDataTypes.POWResources, dev.Timeout, out duration);
                     if(sense)
@@ -882,7 +883,7 @@ namespace DiscImageChef.Commands
                     else
                     {
                         DicConsole.WriteLine("POW Resources Information:\n{0}", Decoders.SCSI.MMC.DiscInformation.Prettify(cmdBuf));
-                        doWriteFile(outputPrefix, "_readdiscinformation_010b.bin", "SCSI READ DISC INFORMATION", cmdBuf);
+                        DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscinformation_010b.bin", "SCSI READ DISC INFORMATION", cmdBuf);
                     }
                 }
                 #endregion Writable Blu-ray only
@@ -905,7 +906,7 @@ namespace DiscImageChef.Commands
                     {
                         toc = Decoders.CD.TOC.Decode(cmdBuf);
                         DicConsole.WriteLine("TOC:\n{0}", Decoders.CD.TOC.Prettify(toc));
-                        doWriteFile(outputPrefix, "_toc.bin", "SCSI READ TOC/PMA/ATIP", cmdBuf);
+                        DataFile.WriteTo("Media-Info command", outputPrefix, "_toc.bin", "SCSI READ TOC/PMA/ATIP", cmdBuf);
 
                         // As we have a TOC we know it is a CD
                         if(dskType == MediaType.Unknown)
@@ -918,7 +919,7 @@ namespace DiscImageChef.Commands
                         DicConsole.DebugWriteLine("Media-Info command", "READ TOC/PMA/ATIP: ATIP\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
                     else
                     {
-                        doWriteFile(outputPrefix, "_atip.bin", "SCSI READ TOC/PMA/ATIP", cmdBuf);
+                        DataFile.WriteTo("Media-Info command", outputPrefix, "_atip.bin", "SCSI READ TOC/PMA/ATIP", cmdBuf);
                         Decoders.CD.ATIP.CDATIP? atip = Decoders.CD.ATIP.Decode(cmdBuf);
                         if(atip.HasValue)
                         {
@@ -940,7 +941,7 @@ namespace DiscImageChef.Commands
                             if(discInfo.HasValue)
                             {
                                 DicConsole.WriteLine("Standard Disc Information:\n{0}", Decoders.SCSI.MMC.DiscInformation.Prettify000b(discInfo));
-                                doWriteFile(outputPrefix, "_readdiscinformation_000b.bin", "SCSI READ DISC INFORMATION", cmdBuf);
+                                DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscinformation_000b.bin", "SCSI READ DISC INFORMATION", cmdBuf);
 
                                 // If it is a read-only CD, check CD type if available
                                 if(dskType == MediaType.CD)
@@ -966,7 +967,7 @@ namespace DiscImageChef.Commands
                             DicConsole.DebugWriteLine("Media-Info command", "READ TOC/PMA/ATIP: Session info\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
                         else
                         {
-                            doWriteFile(outputPrefix, "_session.bin", "SCSI READ TOC/PMA/ATIP", cmdBuf);
+                            DataFile.WriteTo("Media-Info command", outputPrefix, "_session.bin", "SCSI READ TOC/PMA/ATIP", cmdBuf);
                             Decoders.CD.Session.CDSessionInfo? session = Decoders.CD.Session.Decode(cmdBuf);
                             DicConsole.WriteLine("Session information:\n{0}", Decoders.CD.Session.Prettify(session));
                             if(session.HasValue)
@@ -1022,7 +1023,7 @@ namespace DiscImageChef.Commands
                             DicConsole.DebugWriteLine("Media-Info command", "READ TOC/PMA/ATIP: Raw TOC\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
                         else
                         {
-                            doWriteFile(outputPrefix, "_rawtoc.bin", "SCSI READ TOC/PMA/ATIP", cmdBuf);
+                            DataFile.WriteTo("Media-Info command", outputPrefix, "_rawtoc.bin", "SCSI READ TOC/PMA/ATIP", cmdBuf);
                             DicConsole.WriteLine("Raw TOC:\n{0}", Decoders.CD.FullTOC.Prettify(cmdBuf));
                         }
                         sense = dev.ReadPma(out cmdBuf, out senseBuf, dev.Timeout, out duration);
@@ -1030,7 +1031,7 @@ namespace DiscImageChef.Commands
                             DicConsole.DebugWriteLine("Media-Info command", "READ TOC/PMA/ATIP: PMA\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
                         else
                         {
-                            doWriteFile(outputPrefix, "_pma.bin", "SCSI READ TOC/PMA/ATIP", cmdBuf);
+                            DataFile.WriteTo("Media-Info command", outputPrefix, "_pma.bin", "SCSI READ TOC/PMA/ATIP", cmdBuf);
                             DicConsole.WriteLine("PMA:\n{0}", Decoders.CD.PMA.Prettify(cmdBuf));
                         }
 
@@ -1039,7 +1040,7 @@ namespace DiscImageChef.Commands
                             DicConsole.DebugWriteLine("Media-Info command", "READ TOC/PMA/ATIP: CD-TEXT\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
                         else
                         {
-                            doWriteFile(outputPrefix, "_cdtext.bin", "SCSI READ TOC/PMA/ATIP", cmdBuf);
+                            DataFile.WriteTo("Media-Info command", outputPrefix, "_cdtext.bin", "SCSI READ TOC/PMA/ATIP", cmdBuf);
                             if(Decoders.CD.CDTextOnLeadIn.Decode(cmdBuf).HasValue)
                                 DicConsole.WriteLine("CD-TEXT on Lead-In:\n{0}", Decoders.CD.CDTextOnLeadIn.Prettify(cmdBuf));
                         }
@@ -1055,7 +1056,7 @@ namespace DiscImageChef.Commands
                         DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: PFI\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
                     else
                     {
-                        doWriteFile(outputPrefix, "_readdiscstructure_dvd_pfi.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
+                        DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_pfi.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
                         Decoders.DVD.PFI.PhysicalFormatInformation? nintendoPfi = Decoders.DVD.PFI.Decode(cmdBuf);
                         if(nintendoPfi != null)
                         {
@@ -1074,7 +1075,7 @@ namespace DiscImageChef.Commands
                     if(sense)
                         DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: DMI\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
                     else
-                        doWriteFile(outputPrefix, "_readdiscstructure_dvd_dmi.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
+                        DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_dmi.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
                 }
                 #endregion Nintendo
             }
@@ -1096,7 +1097,7 @@ namespace DiscImageChef.Commands
                         if(sense)
                             DicConsole.DebugWriteLine("Media-Info command", "KREON EXTRACT SS:\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
                         else
-                            doWriteFile(outputPrefix, "_xbox_ss.bin", "KREON EXTRACT SS", cmdBuf);
+                            DataFile.WriteTo("Media-Info command", outputPrefix, "_xbox_ss.bin", "KREON EXTRACT SS", cmdBuf);
 
                         if(Decoders.Xbox.SS.Decode(cmdBuf).HasValue)
                             DicConsole.WriteLine("Xbox Security Sector:\n{0}", Decoders.Xbox.SS.Prettify(cmdBuf));
@@ -1198,7 +1199,7 @@ namespace DiscImageChef.Commands
                 DicConsole.DebugWriteLine("Media-Info command", "READ MEDIA SERIAL NUMBER\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
             else
             {
-                doWriteFile(outputPrefix, "_mediaserialnumber.bin", "SCSI READ MEDIA SERIAL NUMBER", cmdBuf);
+                DataFile.WriteTo("Media-Info command", outputPrefix, "_mediaserialnumber.bin", "SCSI READ MEDIA SERIAL NUMBER", cmdBuf);
                 if(cmdBuf.Length >= 4)
                 {
                     DicConsole.Write("Media Serial Number: ");
@@ -1208,29 +1209,6 @@ namespace DiscImageChef.Commands
                 }
             }
         }
-
-        static void doWriteFile(string outputPrefix, string outputSuffix, string whatWriting, byte[] data)
-        {
-            if(!string.IsNullOrEmpty(outputPrefix))
-            {
-                if(!File.Exists(outputPrefix + outputSuffix))
-                {
-                    try
-                    {
-                        DicConsole.DebugWriteLine("Media-Info command", "Writing " + whatWriting + " to {0}{1}", outputPrefix, outputSuffix);
-                        FileStream outputFs = new FileStream(outputPrefix + outputSuffix, FileMode.CreateNew);
-                        outputFs.Write(data, 0, data.Length);
-                        outputFs.Close();
-                    }
-                    catch
-                    {
-                        DicConsole.ErrorWriteLine("Unable to write file {0}{1}", outputPrefix, outputSuffix);
-                    }
-                }
-                else
-                    DicConsole.ErrorWriteLine("Not overwriting file {0}{1}", outputPrefix, outputSuffix);
-            }
-        }
     }
 }