* DiscImageChef.CommonTypes/MediaTypeFromSCSI.cs:

* DiscImageChef.CommonTypes/DiscImageChef.CommonTypes.csproj:
	  Added method to calculate MediaType from SCSI parameters
	  (mode, density, medium type, device type, etc).

	* DiscImageChef.Metadata/DeviceReport.cs:
	  Added command to guess drive and media parameters and output
	  an XML report of them.

	* DiscImageChef/Commands/DeviceReport.cs:
	* DiscImageChef.Metadata/DiscImageChef.Metadata.csproj:
	  Added command to guess drive and media parameters and output
	  an XML report of them.

	* DiscImageChef/Commands/DumpMedia.cs:
	  Added preliminary command to dump media. Only SCSI for now.
	  CDs and tapes are not supported. Errors are blalanty
	  ignored. Options are incomplete. Not yet usable.

	* DiscImageChef/Core/Checksum.cs:
	* DiscImageChef/Commands/CreateSidecar.cs:
	  Moved checksum generation to a separate class.

	* CICMMetadata:
	  Added support for ADIP.

	* DiscImageChef.CommonTypes/MediaType.cs:
	  Added parameters of UDO media.
	Moved DataPlay outside of Iomega, as it's not from that
	  manufacturer.
	Added missing Exatape media and corrected 160m XL one.
	Added SyJet media.
	Added all ECMA defined magneto-optical (sectors calculated
	  from specifications, unchecked).
	Added PD media.
	Added Imation 320Gb RDX.
	Added generic USB flash drives.

	* DiscImageChef.Decoders/SCSI/Enums.cs:
	  Make enumerations public.

	* DiscImageChef.Decoders/SCSI/Inquiry.cs:
	* DiscImageChef.Devices/Device/Constructor.cs:
	  Trim space padded strings on SCSI INQUIRY.

	* DiscImageChef.Devices/Device/ScsiCommands/MMC.cs:
	  Added PREVENT ALLOW MEDIUM REMOVAL.
	Added START STOP UNIT.

	* DiscImageChef.Devices/Device/ScsiCommands/NEC.cs:
	  Rename NEC methods.

	* DiscImageChef.Devices/Device/ScsiCommands/Pioneer.cs:
	  Corrected Pioneer transfer length calculation.

	* DiscImageChef.Devices/Device/ScsiCommands/Plextor.cs:
	  Renamed Plextor methods.

	* DiscImageChef.Devices/Device/ScsiCommands/SPC.cs:
	  Renamed SSC PREVENT ALLOW MEDIUM REMOVAL to uncollide with
	  MMC same name but different command.

	* DiscImageChef.Devices/DiscImageChef.Devices.csproj:
	  Set platform target to x86 (does it really matter?).

	* DiscImageChef.Devices/Linux/Command.cs:
	  Reduced allocation for readlink() to current kernel
	  MAX_PATH.

	* DiscImageChef.Devices/Linux/Enums.cs:
	  Modified Linux ioctl to 32-bit. Works on 64-bit also. Solves
	  commands not working on 32-bit environments.

	* DiscImageChef.DiscImages/ZZZRawImage.cs:
	  Changed ECMA-184 and ECMA-183 enums.

	* DiscImageChef.Metadata/Dimensions.cs:
	  Added all ECMA defined magneto-opticals.
	Added PD media.
	Added 320Gb RDX.
	Corrected Exatape 160m XL.
	Added Exatape 22m and 28m.

	* DiscImageChef.Metadata/MediaType.cs:
	  Added 356mm magneto-optical media.
	Changed ECMA-184 and ECMA-183 enums.
	Added USB generic flash drive.

	* DiscImageChef/Commands/DeviceInfo.cs:
	  Corrected SCSI INQUIRY naming.
	Corrected SCSI MODE SENSE (6) parameters.
	Reduced SCSI MODE SENSE timeout, some devices just get stuck
	  with unsupported MODE SENSE commanda and must be left to
	  timeout.
	Changed FUJITSU vendor string comparison.

	* DiscImageChef/Commands/MediaInfo.cs:
	  Added method to calculate MediaType from SCSI parameters
	  (mode, density, medium type, device type, etc).
	Changed some error WriteLine() to debug ones. Too much
	  verbosity.
	Added DVD media type decoding from PFI.
	Found a drive that dumps ADIP, enabling it again (not
	  decoded).

	* DiscImageChef/Commands/MediaScan.cs:
	  Added option to generate ImgBurn compatible log to
	  media-scan command.

	* DiscImageChef/DiscImageChef.csproj:
	  Moved checksum generation to a separate class.
	Added command to guess drive and media parameters and output
	  an XML report of them.
	Added preliminary command to dump media. Only SCSI for now.
	  CDs and tapes are not supported. Errors are blalanty
	  ignored. Options are incomplete. Not yet usable.

	* DiscImageChef/Main.cs:
	  Added command to guess drive and media parameters and output
	  an XML report of them.
	Added preliminary command to dump media. Only SCSI for now.
	  CDs and tapes are not supported. Errors are blalanty
	  ignored. Options are incomplete. Not yet usable.

	* DiscImageChef/Options.cs:
	  Added command to guess drive and media parameters and output
	  an XML report of them.
	Added preliminary command to dump media. Only SCSI for now.
	  CDs and tapes are not supported. Errors are blalanty
	  ignored. Options are incomplete. Not yet usable.
	Added option to generate ImgBurn compatible log to media-scan
	  command.
This commit is contained in:
2016-01-31 08:05:56 +00:00
parent 04add8d634
commit bb69a1b8d9
30 changed files with 9476 additions and 944 deletions

View File

@@ -96,64 +96,7 @@ namespace DiscImageChef.Commands
FileInfo fi = new FileInfo(options.InputFile);
FileStream fs = new FileStream(options.InputFile, FileMode.Open, FileAccess.Read);
Adler32Context adler32ctx = new Adler32Context();
CRC16Context crc16ctx = new CRC16Context();
CRC32Context crc32ctx = new CRC32Context();
CRC64Context crc64ctx = new CRC64Context();
MD5Context md5ctx = new MD5Context();
RIPEMD160Context ripemd160ctx = new RIPEMD160Context();
SHA1Context sha1ctx = new SHA1Context();
SHA256Context sha256ctx = new SHA256Context();
SHA384Context sha384ctx = new SHA384Context();
SHA512Context sha512ctx = new SHA512Context();
SpamSumContext ssctx = new SpamSumContext();
Thread adlerThread = new Thread(updateAdler);
Thread crc16Thread = new Thread(updateCRC16);
Thread crc32Thread = new Thread(updateCRC32);
Thread crc64Thread = new Thread(updateCRC64);
Thread md5Thread = new Thread(updateMD5);
Thread ripemd160Thread = new Thread(updateRIPEMD160);
Thread sha1Thread = new Thread(updateSHA1);
Thread sha256Thread = new Thread(updateSHA256);
Thread sha384Thread = new Thread(updateSHA384);
Thread sha512Thread = new Thread(updateSHA512);
Thread spamsumThread = new Thread(updateSpamSum);
adlerPacket adlerPkt = new adlerPacket();
crc16Packet crc16Pkt = new crc16Packet();
crc32Packet crc32Pkt = new crc32Packet();
crc64Packet crc64Pkt = new crc64Packet();
md5Packet md5Pkt = new md5Packet();
ripemd160Packet ripemd160Pkt = new ripemd160Packet();
sha1Packet sha1Pkt = new sha1Packet();
sha256Packet sha256Pkt = new sha256Packet();
sha384Packet sha384Pkt = new sha384Packet();
sha512Packet sha512Pkt = new sha512Packet();
spamsumPacket spamsumPkt = new spamsumPacket();
adler32ctx.Init();
adlerPkt.context = adler32ctx;
crc16ctx.Init();
crc16Pkt.context = crc16ctx;
crc32ctx.Init();
crc32Pkt.context = crc32ctx;
crc64ctx.Init();
crc64Pkt.context = crc64ctx;
md5ctx.Init();
md5Pkt.context = md5ctx;
ripemd160ctx.Init();
ripemd160Pkt.context = ripemd160ctx;
sha1ctx.Init();
sha1Pkt.context = sha1ctx;
sha256ctx.Init();
sha256Pkt.context = sha256ctx;
sha384ctx.Init();
sha384Pkt.context = sha384ctx;
sha512ctx.Init();
sha512Pkt.context = sha512ctx;
ssctx.Init();
spamsumPkt.context = ssctx;
Core.Checksum imgChkWorker = new DiscImageChef.Core.Checksum();
byte[] data;
long position = 0;
@@ -164,49 +107,7 @@ namespace DiscImageChef.Commands
DicConsole.Write("\rHashing image file byte {0} of {1}", position, fi.Length);
adlerPkt.data = data;
adlerThread.Start(adlerPkt);
crc16Pkt.data = data;
crc16Thread.Start(crc16Pkt);
crc32Pkt.data = data;
crc32Thread.Start(crc32Pkt);
crc64Pkt.data = data;
crc64Thread.Start(crc64Pkt);
md5Pkt.data = data;
md5Thread.Start(md5Pkt);
ripemd160Pkt.data = data;
ripemd160Thread.Start(ripemd160Pkt);
sha1Pkt.data = data;
sha1Thread.Start(sha1Pkt);
sha256Pkt.data = data;
sha256Thread.Start(sha256Pkt);
sha384Pkt.data = data;
sha384Thread.Start(sha384Pkt);
sha512Pkt.data = data;
sha512Thread.Start(sha512Pkt);
spamsumPkt.data = data;
spamsumThread.Start(spamsumPkt);
while (adlerThread.IsAlive || crc16Thread.IsAlive ||
crc32Thread.IsAlive || crc64Thread.IsAlive ||
md5Thread.IsAlive || ripemd160Thread.IsAlive ||
sha1Thread.IsAlive || sha256Thread.IsAlive ||
sha384Thread.IsAlive || sha512Thread.IsAlive ||
spamsumThread.IsAlive)
{
}
adlerThread = new Thread(updateAdler);
crc16Thread = new Thread(updateCRC16);
crc32Thread = new Thread(updateCRC32);
crc64Thread = new Thread(updateCRC64);
md5Thread = new Thread(updateMD5);
ripemd160Thread = new Thread(updateRIPEMD160);
sha1Thread = new Thread(updateSHA1);
sha256Thread = new Thread(updateSHA256);
sha384Thread = new Thread(updateSHA384);
sha512Thread = new Thread(updateSHA512);
spamsumThread = new Thread(updateSpamSum);
imgChkWorker.Update(data);
position += 1048576;
}
@@ -216,97 +117,12 @@ namespace DiscImageChef.Commands
DicConsole.Write("\rHashing image file byte {0} of {1}", position, fi.Length);
adlerPkt.data = data;
adlerThread.Start(adlerPkt);
crc16Pkt.data = data;
crc16Thread.Start(crc16Pkt);
crc32Pkt.data = data;
crc32Thread.Start(crc32Pkt);
crc64Pkt.data = data;
crc64Thread.Start(crc64Pkt);
md5Pkt.data = data;
md5Thread.Start(md5Pkt);
ripemd160Pkt.data = data;
ripemd160Thread.Start(ripemd160Pkt);
sha1Pkt.data = data;
sha1Thread.Start(sha1Pkt);
sha256Pkt.data = data;
sha256Thread.Start(sha256Pkt);
sha384Pkt.data = data;
sha384Thread.Start(sha384Pkt);
sha512Pkt.data = data;
sha512Thread.Start(sha512Pkt);
spamsumPkt.data = data;
spamsumThread.Start(spamsumPkt);
while (adlerThread.IsAlive || crc16Thread.IsAlive ||
crc32Thread.IsAlive || crc64Thread.IsAlive ||
md5Thread.IsAlive || ripemd160Thread.IsAlive ||
sha1Thread.IsAlive || sha256Thread.IsAlive ||
sha384Thread.IsAlive || sha512Thread.IsAlive ||
spamsumThread.IsAlive)
{
}
imgChkWorker.Update(data);
DicConsole.WriteLine();
fs.Close();
List<ChecksumType> imgChecksums = new List<ChecksumType>();
ChecksumType chk = new ChecksumType();
chk.type = ChecksumTypeType.adler32;
chk.Value = adler32ctx.End();
imgChecksums.Add(chk);
chk = new ChecksumType();
chk.type = ChecksumTypeType.crc16;
chk.Value = crc16ctx.End();
imgChecksums.Add(chk);
chk = new ChecksumType();
chk.type = ChecksumTypeType.crc32;
chk.Value = crc32ctx.End();
imgChecksums.Add(chk);
chk = new ChecksumType();
chk.type = ChecksumTypeType.crc64;
chk.Value = crc64ctx.End();
imgChecksums.Add(chk);
chk = new ChecksumType();
chk.type = ChecksumTypeType.md5;
chk.Value = md5ctx.End();
imgChecksums.Add(chk);
chk = new ChecksumType();
chk.type = ChecksumTypeType.ripemd160;
chk.Value = ripemd160ctx.End();
imgChecksums.Add(chk);
chk = new ChecksumType();
chk.type = ChecksumTypeType.sha1;
chk.Value = sha1ctx.End();
imgChecksums.Add(chk);
chk = new ChecksumType();
chk.type = ChecksumTypeType.sha256;
chk.Value = sha256ctx.End();
imgChecksums.Add(chk);
chk = new ChecksumType();
chk.type = ChecksumTypeType.sha384;
chk.Value = sha384ctx.End();
imgChecksums.Add(chk);
chk = new ChecksumType();
chk.type = ChecksumTypeType.sha512;
chk.Value = sha512ctx.End();
imgChecksums.Add(chk);
chk = new ChecksumType();
chk.type = ChecksumTypeType.spamsum;
chk.Value = ssctx.End();
imgChecksums.Add(chk);
List<ChecksumType> imgChecksums = imgChkWorker.End();
switch (_imageFormat.ImageInfo.xmlMediaType)
{
@@ -342,7 +158,7 @@ namespace DiscImageChef.Commands
{
case MediaTagType.CD_ATIP:
sidecar.OpticalDisc[0].ATIP = new DumpType();
sidecar.OpticalDisc[0].ATIP.Checksums = GetChecksums(_imageFormat.ReadDiskTag(MediaTagType.CD_ATIP)).ToArray();
sidecar.OpticalDisc[0].ATIP.Checksums = Core.Checksum.GetChecksums(_imageFormat.ReadDiskTag(MediaTagType.CD_ATIP)).ToArray();
sidecar.OpticalDisc[0].ATIP.Size = _imageFormat.ReadDiskTag(MediaTagType.CD_ATIP).Length;
Decoders.CD.ATIP.CDATIP? atip = Decoders.CD.ATIP.Decode(_imageFormat.ReadDiskTag(MediaTagType.CD_ATIP));
if (atip.HasValue)
@@ -355,12 +171,12 @@ namespace DiscImageChef.Commands
break;
case MediaTagType.DVD_BCA:
sidecar.OpticalDisc[0].BCA = new DumpType();
sidecar.OpticalDisc[0].BCA.Checksums = GetChecksums(_imageFormat.ReadDiskTag(MediaTagType.DVD_BCA)).ToArray();
sidecar.OpticalDisc[0].BCA.Checksums = Core.Checksum.GetChecksums(_imageFormat.ReadDiskTag(MediaTagType.DVD_BCA)).ToArray();
sidecar.OpticalDisc[0].BCA.Size = _imageFormat.ReadDiskTag(MediaTagType.DVD_BCA).Length;
break;
case MediaTagType.BD_BCA:
sidecar.OpticalDisc[0].BCA = new DumpType();
sidecar.OpticalDisc[0].BCA.Checksums = GetChecksums(_imageFormat.ReadDiskTag(MediaTagType.BD_BCA)).ToArray();
sidecar.OpticalDisc[0].BCA.Checksums = Core.Checksum.GetChecksums(_imageFormat.ReadDiskTag(MediaTagType.BD_BCA)).ToArray();
sidecar.OpticalDisc[0].BCA.Size = _imageFormat.ReadDiskTag(MediaTagType.BD_BCA).Length;
break;
case MediaTagType.DVD_CMI:
@@ -381,12 +197,12 @@ namespace DiscImageChef.Commands
break;
}
}
sidecar.OpticalDisc[0].CMI.Checksums = GetChecksums(_imageFormat.ReadDiskTag(MediaTagType.DVD_CMI)).ToArray();
sidecar.OpticalDisc[0].CMI.Checksums = Core.Checksum.GetChecksums(_imageFormat.ReadDiskTag(MediaTagType.DVD_CMI)).ToArray();
sidecar.OpticalDisc[0].CMI.Size = _imageFormat.ReadDiskTag(MediaTagType.DVD_CMI).Length;
break;
case MediaTagType.DVD_DMI:
sidecar.OpticalDisc[0].DMI = new DumpType();
sidecar.OpticalDisc[0].DMI.Checksums = GetChecksums(_imageFormat.ReadDiskTag(MediaTagType.DVD_DMI)).ToArray();
sidecar.OpticalDisc[0].DMI.Checksums = Core.Checksum.GetChecksums(_imageFormat.ReadDiskTag(MediaTagType.DVD_DMI)).ToArray();
sidecar.OpticalDisc[0].DMI.Size = _imageFormat.ReadDiskTag(MediaTagType.DVD_DMI).Length;
if (Decoders.Xbox.DMI.IsXbox(_imageFormat.ReadDiskTag(MediaTagType.DVD_DMI)))
{
@@ -403,7 +219,7 @@ namespace DiscImageChef.Commands
break;
case MediaTagType.DVD_PFI:
sidecar.OpticalDisc[0].PFI = new DumpType();
sidecar.OpticalDisc[0].PFI.Checksums = GetChecksums(_imageFormat.ReadDiskTag(MediaTagType.DVD_PFI)).ToArray();
sidecar.OpticalDisc[0].PFI.Checksums = Core.Checksum.GetChecksums(_imageFormat.ReadDiskTag(MediaTagType.DVD_PFI)).ToArray();
sidecar.OpticalDisc[0].PFI.Size = _imageFormat.ReadDiskTag(MediaTagType.DVD_PFI).Length;
Decoders.DVD.PFI.PhysicalFormatInformation? pfi = Decoders.DVD.PFI.Decode(_imageFormat.ReadDiskTag(MediaTagType.DVD_PFI));
if (pfi.HasValue)
@@ -477,7 +293,7 @@ namespace DiscImageChef.Commands
break;
case MediaTagType.CD_PMA:
sidecar.OpticalDisc[0].PMA = new DumpType();
sidecar.OpticalDisc[0].PMA.Checksums = GetChecksums(_imageFormat.ReadDiskTag(MediaTagType.CD_PMA)).ToArray();
sidecar.OpticalDisc[0].PMA.Checksums = Core.Checksum.GetChecksums(_imageFormat.ReadDiskTag(MediaTagType.CD_PMA)).ToArray();
sidecar.OpticalDisc[0].PMA.Size = _imageFormat.ReadDiskTag(MediaTagType.CD_PMA).Length;
break;
}
@@ -583,64 +399,7 @@ namespace DiscImageChef.Commands
uint sectorsToRead = 512;
adler32ctx = new Adler32Context();
crc16ctx = new CRC16Context();
crc32ctx = new CRC32Context();
crc64ctx = new CRC64Context();
md5ctx = new MD5Context();
ripemd160ctx = new RIPEMD160Context();
sha1ctx = new SHA1Context();
sha256ctx = new SHA256Context();
sha384ctx = new SHA384Context();
sha512ctx = new SHA512Context();
ssctx = new SpamSumContext();
adlerThread = new Thread(updateAdler);
crc16Thread = new Thread(updateCRC16);
crc32Thread = new Thread(updateCRC32);
crc64Thread = new Thread(updateCRC64);
md5Thread = new Thread(updateMD5);
ripemd160Thread = new Thread(updateRIPEMD160);
sha1Thread = new Thread(updateSHA1);
sha256Thread = new Thread(updateSHA256);
sha384Thread = new Thread(updateSHA384);
sha512Thread = new Thread(updateSHA512);
spamsumThread = new Thread(updateSpamSum);
adlerPkt = new adlerPacket();
crc16Pkt = new crc16Packet();
crc32Pkt = new crc32Packet();
crc64Pkt = new crc64Packet();
md5Pkt = new md5Packet();
ripemd160Pkt = new ripemd160Packet();
sha1Pkt = new sha1Packet();
sha256Pkt = new sha256Packet();
sha384Pkt = new sha384Packet();
sha512Pkt = new sha512Packet();
spamsumPkt = new spamsumPacket();
adler32ctx.Init();
adlerPkt.context = adler32ctx;
crc16ctx.Init();
crc16Pkt.context = crc16ctx;
crc32ctx.Init();
crc32Pkt.context = crc32ctx;
crc64ctx.Init();
crc64Pkt.context = crc64ctx;
md5ctx.Init();
md5Pkt.context = md5ctx;
ripemd160ctx.Init();
ripemd160Pkt.context = ripemd160ctx;
sha1ctx.Init();
sha1Pkt.context = sha1ctx;
sha256ctx.Init();
sha256Pkt.context = sha256ctx;
sha384ctx.Init();
sha384Pkt.context = sha384ctx;
sha512ctx.Init();
sha512Pkt.context = sha512ctx;
ssctx.Init();
spamsumPkt.context = ssctx;
Core.Checksum trkChkWorker = new DiscImageChef.Core.Checksum();
ulong sectors = (ulong)(xmlTrk.EndSector - xmlTrk.StartSector + 1);
ulong doneSectors = 0;
@@ -662,107 +421,10 @@ namespace DiscImageChef.Commands
doneSectors += (sectors - doneSectors);
}
adlerPkt.data = sector;
adlerThread.Start(adlerPkt);
crc16Pkt.data = sector;
crc16Thread.Start(crc16Pkt);
crc32Pkt.data = sector;
crc32Thread.Start(crc32Pkt);
crc64Pkt.data = sector;
crc64Thread.Start(crc64Pkt);
md5Pkt.data = sector;
md5Thread.Start(md5Pkt);
ripemd160Pkt.data = sector;
ripemd160Thread.Start(ripemd160Pkt);
sha1Pkt.data = sector;
sha1Thread.Start(sha1Pkt);
sha256Pkt.data = sector;
sha256Thread.Start(sha256Pkt);
sha384Pkt.data = sector;
sha384Thread.Start(sha384Pkt);
sha512Pkt.data = sector;
sha512Thread.Start(sha512Pkt);
spamsumPkt.data = sector;
spamsumThread.Start(spamsumPkt);
while (adlerThread.IsAlive || crc16Thread.IsAlive ||
crc32Thread.IsAlive || crc64Thread.IsAlive ||
md5Thread.IsAlive || ripemd160Thread.IsAlive ||
sha1Thread.IsAlive || sha256Thread.IsAlive ||
sha384Thread.IsAlive || sha512Thread.IsAlive ||
spamsumThread.IsAlive)
{
}
adlerThread = new Thread(updateAdler);
crc16Thread = new Thread(updateCRC16);
crc32Thread = new Thread(updateCRC32);
crc64Thread = new Thread(updateCRC64);
md5Thread = new Thread(updateMD5);
ripemd160Thread = new Thread(updateRIPEMD160);
sha1Thread = new Thread(updateSHA1);
sha256Thread = new Thread(updateSHA256);
sha384Thread = new Thread(updateSHA384);
sha512Thread = new Thread(updateSHA512);
spamsumThread = new Thread(updateSpamSum);
trkChkWorker.Update(sector);
}
List<ChecksumType> trkChecksums = new List<ChecksumType>();
chk = new ChecksumType();
chk.type = ChecksumTypeType.adler32;
chk.Value = adler32ctx.End();
trkChecksums.Add(chk);
chk = new ChecksumType();
chk.type = ChecksumTypeType.crc16;
chk.Value = crc16ctx.End();
trkChecksums.Add(chk);
chk = new ChecksumType();
chk.type = ChecksumTypeType.crc32;
chk.Value = crc32ctx.End();
trkChecksums.Add(chk);
chk = new ChecksumType();
chk.type = ChecksumTypeType.crc64;
chk.Value = crc64ctx.End();
trkChecksums.Add(chk);
chk = new ChecksumType();
chk.type = ChecksumTypeType.md5;
chk.Value = md5ctx.End();
trkChecksums.Add(chk);
chk = new ChecksumType();
chk.type = ChecksumTypeType.ripemd160;
chk.Value = ripemd160ctx.End();
trkChecksums.Add(chk);
chk = new ChecksumType();
chk.type = ChecksumTypeType.sha1;
chk.Value = sha1ctx.End();
trkChecksums.Add(chk);
chk = new ChecksumType();
chk.type = ChecksumTypeType.sha256;
chk.Value = sha256ctx.End();
trkChecksums.Add(chk);
chk = new ChecksumType();
chk.type = ChecksumTypeType.sha384;
chk.Value = sha384ctx.End();
trkChecksums.Add(chk);
chk = new ChecksumType();
chk.type = ChecksumTypeType.sha512;
chk.Value = sha512ctx.End();
trkChecksums.Add(chk);
chk = new ChecksumType();
chk.type = ChecksumTypeType.spamsum;
chk.Value = ssctx.End();
trkChecksums.Add(chk);
List<ChecksumType> trkChecksums = trkChkWorker.End();
xmlTrk.Checksums = trkChecksums.ToArray();
@@ -794,64 +456,7 @@ namespace DiscImageChef.Commands
// TODO: Packed subchannel has different size?
xmlTrk.SubChannel.Size = (xmlTrk.EndSector - xmlTrk.StartSector + 1) * 96;
adler32ctx = new Adler32Context();
crc16ctx = new CRC16Context();
crc32ctx = new CRC32Context();
crc64ctx = new CRC64Context();
md5ctx = new MD5Context();
ripemd160ctx = new RIPEMD160Context();
sha1ctx = new SHA1Context();
sha256ctx = new SHA256Context();
sha384ctx = new SHA384Context();
sha512ctx = new SHA512Context();
ssctx = new SpamSumContext();
adlerThread = new Thread(updateAdler);
crc16Thread = new Thread(updateCRC16);
crc32Thread = new Thread(updateCRC32);
crc64Thread = new Thread(updateCRC64);
md5Thread = new Thread(updateMD5);
ripemd160Thread = new Thread(updateRIPEMD160);
sha1Thread = new Thread(updateSHA1);
sha256Thread = new Thread(updateSHA256);
sha384Thread = new Thread(updateSHA384);
sha512Thread = new Thread(updateSHA512);
spamsumThread = new Thread(updateSpamSum);
adlerPkt = new adlerPacket();
crc16Pkt = new crc16Packet();
crc32Pkt = new crc32Packet();
crc64Pkt = new crc64Packet();
md5Pkt = new md5Packet();
ripemd160Pkt = new ripemd160Packet();
sha1Pkt = new sha1Packet();
sha256Pkt = new sha256Packet();
sha384Pkt = new sha384Packet();
sha512Pkt = new sha512Packet();
spamsumPkt = new spamsumPacket();
adler32ctx.Init();
adlerPkt.context = adler32ctx;
crc16ctx.Init();
crc16Pkt.context = crc16ctx;
crc32ctx.Init();
crc32Pkt.context = crc32ctx;
crc64ctx.Init();
crc64Pkt.context = crc64ctx;
md5ctx.Init();
md5Pkt.context = md5ctx;
ripemd160ctx.Init();
ripemd160Pkt.context = ripemd160ctx;
sha1ctx.Init();
sha1Pkt.context = sha1ctx;
sha256ctx.Init();
sha256Pkt.context = sha256ctx;
sha384ctx.Init();
sha384Pkt.context = sha384ctx;
sha512ctx.Init();
sha512Pkt.context = sha512ctx;
ssctx.Init();
spamsumPkt.context = ssctx;
Core.Checksum subChkWorker = new DiscImageChef.Core.Checksum();
sectors = (ulong)(xmlTrk.EndSector - xmlTrk.StartSector + 1);
doneSectors = 0;
@@ -873,107 +478,10 @@ namespace DiscImageChef.Commands
doneSectors += (sectors - doneSectors);
}
adlerPkt.data = sector;
adlerThread.Start(adlerPkt);
crc16Pkt.data = sector;
crc16Thread.Start(crc16Pkt);
crc32Pkt.data = sector;
crc32Thread.Start(crc32Pkt);
crc64Pkt.data = sector;
crc64Thread.Start(crc64Pkt);
md5Pkt.data = sector;
md5Thread.Start(md5Pkt);
ripemd160Pkt.data = sector;
ripemd160Thread.Start(ripemd160Pkt);
sha1Pkt.data = sector;
sha1Thread.Start(sha1Pkt);
sha256Pkt.data = sector;
sha256Thread.Start(sha256Pkt);
sha384Pkt.data = sector;
sha384Thread.Start(sha384Pkt);
sha512Pkt.data = sector;
sha512Thread.Start(sha512Pkt);
spamsumPkt.data = sector;
spamsumThread.Start(spamsumPkt);
while (adlerThread.IsAlive || crc16Thread.IsAlive ||
crc32Thread.IsAlive || crc64Thread.IsAlive ||
md5Thread.IsAlive || ripemd160Thread.IsAlive ||
sha1Thread.IsAlive || sha256Thread.IsAlive ||
sha384Thread.IsAlive || sha512Thread.IsAlive ||
spamsumThread.IsAlive)
{
}
adlerThread = new Thread(updateAdler);
crc16Thread = new Thread(updateCRC16);
crc32Thread = new Thread(updateCRC32);
crc64Thread = new Thread(updateCRC64);
md5Thread = new Thread(updateMD5);
ripemd160Thread = new Thread(updateRIPEMD160);
sha1Thread = new Thread(updateSHA1);
sha256Thread = new Thread(updateSHA256);
sha384Thread = new Thread(updateSHA384);
sha512Thread = new Thread(updateSHA512);
spamsumThread = new Thread(updateSpamSum);
subChkWorker.Update(sector);
}
List<ChecksumType> subChecksums = new List<ChecksumType>();
chk = new ChecksumType();
chk.type = ChecksumTypeType.adler32;
chk.Value = adler32ctx.End();
subChecksums.Add(chk);
chk = new ChecksumType();
chk.type = ChecksumTypeType.crc16;
chk.Value = crc16ctx.End();
subChecksums.Add(chk);
chk = new ChecksumType();
chk.type = ChecksumTypeType.crc32;
chk.Value = crc32ctx.End();
subChecksums.Add(chk);
chk = new ChecksumType();
chk.type = ChecksumTypeType.crc64;
chk.Value = crc64ctx.End();
subChecksums.Add(chk);
chk = new ChecksumType();
chk.type = ChecksumTypeType.md5;
chk.Value = md5ctx.End();
subChecksums.Add(chk);
chk = new ChecksumType();
chk.type = ChecksumTypeType.ripemd160;
chk.Value = ripemd160ctx.End();
subChecksums.Add(chk);
chk = new ChecksumType();
chk.type = ChecksumTypeType.sha1;
chk.Value = sha1ctx.End();
subChecksums.Add(chk);
chk = new ChecksumType();
chk.type = ChecksumTypeType.sha256;
chk.Value = sha256ctx.End();
subChecksums.Add(chk);
chk = new ChecksumType();
chk.type = ChecksumTypeType.sha384;
chk.Value = sha384ctx.End();
subChecksums.Add(chk);
chk = new ChecksumType();
chk.type = ChecksumTypeType.sha512;
chk.Value = sha512ctx.End();
subChecksums.Add(chk);
chk = new ChecksumType();
chk.type = ChecksumTypeType.spamsum;
chk.Value = ssctx.End();
subChecksums.Add(chk);
List<ChecksumType> subChecksums = subChkWorker.End();
xmlTrk.SubChannel.Checksums = subChecksums.ToArray();
@@ -1103,46 +611,46 @@ namespace DiscImageChef.Commands
case MediaTagType.ATAPI_IDENTIFY:
sidecar.BlockMedia[0].ATA = new ATAType();
sidecar.BlockMedia[0].ATA.Identify = new DumpType();
sidecar.BlockMedia[0].ATA.Identify.Checksums = GetChecksums(_imageFormat.ReadDiskTag(MediaTagType.ATAPI_IDENTIFY)).ToArray();
sidecar.BlockMedia[0].ATA.Identify.Checksums = Core.Checksum.GetChecksums(_imageFormat.ReadDiskTag(MediaTagType.ATAPI_IDENTIFY)).ToArray();
sidecar.BlockMedia[0].ATA.Identify.Size = _imageFormat.ReadDiskTag(MediaTagType.ATAPI_IDENTIFY).Length;
break;
case MediaTagType.ATA_IDENTIFY:
sidecar.BlockMedia[0].ATA = new ATAType();
sidecar.BlockMedia[0].ATA.Identify = new DumpType();
sidecar.BlockMedia[0].ATA.Identify.Checksums = GetChecksums(_imageFormat.ReadDiskTag(MediaTagType.ATA_IDENTIFY)).ToArray();
sidecar.BlockMedia[0].ATA.Identify.Checksums = Core.Checksum.GetChecksums(_imageFormat.ReadDiskTag(MediaTagType.ATA_IDENTIFY)).ToArray();
sidecar.BlockMedia[0].ATA.Identify.Size = _imageFormat.ReadDiskTag(MediaTagType.ATA_IDENTIFY).Length;
break;
case MediaTagType.PCMCIA_CIS:
sidecar.BlockMedia[0].PCMCIA = new PCMCIAType();
sidecar.BlockMedia[0].PCMCIA.CIS = new DumpType();
sidecar.BlockMedia[0].PCMCIA.CIS.Checksums = GetChecksums(_imageFormat.ReadDiskTag(MediaTagType.PCMCIA_CIS)).ToArray();
sidecar.BlockMedia[0].PCMCIA.CIS.Checksums = Core.Checksum.GetChecksums(_imageFormat.ReadDiskTag(MediaTagType.PCMCIA_CIS)).ToArray();
sidecar.BlockMedia[0].PCMCIA.CIS.Size = _imageFormat.ReadDiskTag(MediaTagType.PCMCIA_CIS).Length;
break;
case MediaTagType.SCSI_INQUIRY:
sidecar.BlockMedia[0].SCSI = new SCSIType();
sidecar.BlockMedia[0].SCSI.Inquiry = new DumpType();
sidecar.BlockMedia[0].SCSI.Inquiry.Checksums = GetChecksums(_imageFormat.ReadDiskTag(MediaTagType.SCSI_INQUIRY)).ToArray();
sidecar.BlockMedia[0].SCSI.Inquiry.Checksums = Core.Checksum.GetChecksums(_imageFormat.ReadDiskTag(MediaTagType.SCSI_INQUIRY)).ToArray();
sidecar.BlockMedia[0].SCSI.Inquiry.Size = _imageFormat.ReadDiskTag(MediaTagType.SCSI_INQUIRY).Length;
break;
case MediaTagType.SD_CID:
if(sidecar.BlockMedia[0].SecureDigital == null)
sidecar.BlockMedia[0].SecureDigital = new SecureDigitalType();
sidecar.BlockMedia[0].SecureDigital.CID = new DumpType();
sidecar.BlockMedia[0].SecureDigital.CID.Checksums = GetChecksums(_imageFormat.ReadDiskTag(MediaTagType.SD_CID)).ToArray();
sidecar.BlockMedia[0].SecureDigital.CID.Checksums = Core.Checksum.GetChecksums(_imageFormat.ReadDiskTag(MediaTagType.SD_CID)).ToArray();
sidecar.BlockMedia[0].SecureDigital.CID.Size = _imageFormat.ReadDiskTag(MediaTagType.SD_CID).Length;
break;
case MediaTagType.SD_CSD:
if(sidecar.BlockMedia[0].SecureDigital == null)
sidecar.BlockMedia[0].SecureDigital = new SecureDigitalType();
sidecar.BlockMedia[0].SecureDigital.CSD = new DumpType();
sidecar.BlockMedia[0].SecureDigital.CSD.Checksums = GetChecksums(_imageFormat.ReadDiskTag(MediaTagType.SD_CSD)).ToArray();
sidecar.BlockMedia[0].SecureDigital.CSD.Checksums = Core.Checksum.GetChecksums(_imageFormat.ReadDiskTag(MediaTagType.SD_CSD)).ToArray();
sidecar.BlockMedia[0].SecureDigital.CSD.Size = _imageFormat.ReadDiskTag(MediaTagType.SD_CSD).Length;
break;
case MediaTagType.SD_ExtendedCSD:
if(sidecar.BlockMedia[0].SecureDigital == null)
sidecar.BlockMedia[0].SecureDigital = new SecureDigitalType();
sidecar.BlockMedia[0].SecureDigital.ExtendedCSD = new DumpType();
sidecar.BlockMedia[0].SecureDigital.ExtendedCSD.Checksums = GetChecksums(_imageFormat.ReadDiskTag(MediaTagType.SD_ExtendedCSD)).ToArray();
sidecar.BlockMedia[0].SecureDigital.ExtendedCSD.Checksums = Core.Checksum.GetChecksums(_imageFormat.ReadDiskTag(MediaTagType.SD_ExtendedCSD)).ToArray();
sidecar.BlockMedia[0].SecureDigital.ExtendedCSD.Size = _imageFormat.ReadDiskTag(MediaTagType.SD_ExtendedCSD).Length;
break;
}
@@ -1360,297 +868,6 @@ namespace DiscImageChef.Commands
return String.Format("{3}:{0:D2}:{1:D2}:{2:D2}", m, s, f, h);
}
static List<ChecksumType> GetChecksums(byte[] data)
{
Adler32Context adler32ctx = new Adler32Context();
CRC16Context crc16ctx = new CRC16Context();
CRC32Context crc32ctx = new CRC32Context();
CRC64Context crc64ctx = new CRC64Context();
MD5Context md5ctx = new MD5Context();
RIPEMD160Context ripemd160ctx = new RIPEMD160Context();
SHA1Context sha1ctx = new SHA1Context();
SHA256Context sha256ctx = new SHA256Context();
SHA384Context sha384ctx = new SHA384Context();
SHA512Context sha512ctx = new SHA512Context();
SpamSumContext ssctx = new SpamSumContext();
Thread adlerThread = new Thread(updateAdler);
Thread crc16Thread = new Thread(updateCRC16);
Thread crc32Thread = new Thread(updateCRC32);
Thread crc64Thread = new Thread(updateCRC64);
Thread md5Thread = new Thread(updateMD5);
Thread ripemd160Thread = new Thread(updateRIPEMD160);
Thread sha1Thread = new Thread(updateSHA1);
Thread sha256Thread = new Thread(updateSHA256);
Thread sha384Thread = new Thread(updateSHA384);
Thread sha512Thread = new Thread(updateSHA512);
Thread spamsumThread = new Thread(updateSpamSum);
adlerPacket adlerPkt = new adlerPacket();
crc16Packet crc16Pkt = new crc16Packet();
crc32Packet crc32Pkt = new crc32Packet();
crc64Packet crc64Pkt = new crc64Packet();
md5Packet md5Pkt = new md5Packet();
ripemd160Packet ripemd160Pkt = new ripemd160Packet();
sha1Packet sha1Pkt = new sha1Packet();
sha256Packet sha256Pkt = new sha256Packet();
sha384Packet sha384Pkt = new sha384Packet();
sha512Packet sha512Pkt = new sha512Packet();
spamsumPacket spamsumPkt = new spamsumPacket();
adler32ctx.Init();
adlerPkt.context = adler32ctx;
crc16ctx.Init();
crc16Pkt.context = crc16ctx;
crc32ctx.Init();
crc32Pkt.context = crc32ctx;
crc64ctx.Init();
crc64Pkt.context = crc64ctx;
md5ctx.Init();
md5Pkt.context = md5ctx;
ripemd160ctx.Init();
ripemd160Pkt.context = ripemd160ctx;
sha1ctx.Init();
sha1Pkt.context = sha1ctx;
sha256ctx.Init();
sha256Pkt.context = sha256ctx;
sha384ctx.Init();
sha384Pkt.context = sha384ctx;
sha512ctx.Init();
sha512Pkt.context = sha512ctx;
ssctx.Init();
spamsumPkt.context = ssctx;
adlerPkt.data = data;
adlerThread.Start(adlerPkt);
crc16Pkt.data = data;
crc16Thread.Start(crc16Pkt);
crc32Pkt.data = data;
crc32Thread.Start(crc32Pkt);
crc64Pkt.data = data;
crc64Thread.Start(crc64Pkt);
md5Pkt.data = data;
md5Thread.Start(md5Pkt);
ripemd160Pkt.data = data;
ripemd160Thread.Start(ripemd160Pkt);
sha1Pkt.data = data;
sha1Thread.Start(sha1Pkt);
sha256Pkt.data = data;
sha256Thread.Start(sha256Pkt);
sha384Pkt.data = data;
sha384Thread.Start(sha384Pkt);
sha512Pkt.data = data;
sha512Thread.Start(sha512Pkt);
spamsumPkt.data = data;
spamsumThread.Start(spamsumPkt);
while (adlerThread.IsAlive || crc16Thread.IsAlive ||
crc32Thread.IsAlive || crc64Thread.IsAlive ||
md5Thread.IsAlive || ripemd160Thread.IsAlive ||
sha1Thread.IsAlive || sha256Thread.IsAlive ||
sha384Thread.IsAlive || sha512Thread.IsAlive ||
spamsumThread.IsAlive)
{
}
List<ChecksumType> imgChecksums = new List<ChecksumType>();
ChecksumType chk = new ChecksumType();
chk.type = ChecksumTypeType.adler32;
chk.Value = adler32ctx.End();
imgChecksums.Add(chk);
chk.type = ChecksumTypeType.crc16;
chk.Value = crc16ctx.End();
imgChecksums.Add(chk);
chk.type = ChecksumTypeType.crc32;
chk.Value = crc32ctx.End();
imgChecksums.Add(chk);
chk.type = ChecksumTypeType.crc64;
chk.Value = crc64ctx.End();
imgChecksums.Add(chk);
chk.type = ChecksumTypeType.md5;
chk.Value = md5ctx.End();
imgChecksums.Add(chk);
chk.type = ChecksumTypeType.ripemd160;
chk.Value = ripemd160ctx.End();
imgChecksums.Add(chk);
chk.type = ChecksumTypeType.sha1;
chk.Value = sha1ctx.End();
imgChecksums.Add(chk);
chk.type = ChecksumTypeType.sha256;
chk.Value = sha256ctx.End();
imgChecksums.Add(chk);
chk.type = ChecksumTypeType.sha384;
chk.Value = sha384ctx.End();
imgChecksums.Add(chk);
chk.type = ChecksumTypeType.sha512;
chk.Value = sha512ctx.End();
imgChecksums.Add(chk);
chk.type = ChecksumTypeType.spamsum;
chk.Value = ssctx.End();
imgChecksums.Add(chk);
return imgChecksums;
}
#region Threading helpers
struct adlerPacket
{
public Adler32Context context;
public byte[] data;
}
struct crc16Packet
{
public CRC16Context context;
public byte[] data;
}
struct crc32Packet
{
public CRC32Context context;
public byte[] data;
}
struct crc64Packet
{
public CRC64Context context;
public byte[] data;
}
/*struct fletcher16Packet
{
public Fletcher16Context context;
public byte[] data;
}
struct fletcher32Packet
{
public Fletcher32Context context;
public byte[] data;
}*/
struct md5Packet
{
public MD5Context context;
public byte[] data;
}
struct ripemd160Packet
{
public RIPEMD160Context context;
public byte[] data;
}
struct sha1Packet
{
public SHA1Context context;
public byte[] data;
}
struct sha256Packet
{
public SHA256Context context;
public byte[] data;
}
struct sha384Packet
{
public SHA384Context context;
public byte[] data;
}
struct sha512Packet
{
public SHA512Context context;
public byte[] data;
}
struct spamsumPacket
{
public SpamSumContext context;
public byte[] data;
}
static void updateAdler(object packet)
{
((adlerPacket)packet).context.Update(((adlerPacket)packet).data);
}
static void updateCRC16(object packet)
{
((crc16Packet)packet).context.Update(((crc16Packet)packet).data);
}
static void updateCRC32(object packet)
{
((crc32Packet)packet).context.Update(((crc32Packet)packet).data);
}
static void updateCRC64(object packet)
{
((crc64Packet)packet).context.Update(((crc64Packet)packet).data);
}
/*static void updateFletcher16(object packet)
{
((fletcher16Packet)packet).context.Update(((fletcher16Packet)packet).data);
}
static void updateFletcher32(object packet)
{
((fletcher32Packet)packet).context.Update(((fletcher32Packet)packet).data);
}*/
static void updateMD5(object packet)
{
((md5Packet)packet).context.Update(((md5Packet)packet).data);
}
static void updateRIPEMD160(object packet)
{
((ripemd160Packet)packet).context.Update(((ripemd160Packet)packet).data);
}
static void updateSHA1(object packet)
{
((sha1Packet)packet).context.Update(((sha1Packet)packet).data);
}
static void updateSHA256(object packet)
{
((sha256Packet)packet).context.Update(((sha256Packet)packet).data);
}
static void updateSHA384(object packet)
{
((sha384Packet)packet).context.Update(((sha384Packet)packet).data);
}
static void updateSHA512(object packet)
{
((sha512Packet)packet).context.Update(((sha512Packet)packet).data);
}
static void updateSpamSum(object packet)
{
((spamsumPacket)packet).context.Update(((spamsumPacket)packet).data);
}
#endregion Threading helpers
}
}

View File

@@ -164,7 +164,7 @@ namespace DiscImageChef.Commands
if (dev.Type != DeviceType.ATAPI)
DicConsole.WriteLine("SCSI device");
doWriteFile(options.OutputPrefix, "_scsi_inquiry.bin", "SCSI IDENTIFY", inqBuf);
doWriteFile(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));
@@ -237,10 +237,10 @@ namespace DiscImageChef.Commands
Decoders.SCSI.Modes.DecodedMode? decMode = null;
Decoders.SCSI.PeripheralDeviceTypes devType = (DiscImageChef.Decoders.SCSI.PeripheralDeviceTypes)inq.Value.PeripheralDeviceType;
sense = dev.ModeSense10(out modeBuf, out senseBuf, false, true, ScsiModeSensePageControl.Current, 0x3F, 0xFF, dev.Timeout, out duration);
sense = dev.ModeSense10(out modeBuf, out senseBuf, false, true, ScsiModeSensePageControl.Current, 0x3F, 0xFF, 5, out duration);
if (sense || dev.Error)
{
sense = dev.ModeSense10(out modeBuf, out senseBuf, false, true, ScsiModeSensePageControl.Current, 0x3F, 0x00, dev.Timeout, out duration);
sense = dev.ModeSense10(out modeBuf, out senseBuf, false, true, ScsiModeSensePageControl.Current, 0x3F, 0x00, 5, out duration);
}
if (!sense && !dev.Error)
@@ -250,11 +250,11 @@ namespace DiscImageChef.Commands
if(sense || dev.Error || !decMode.HasValue)
{
sense = dev.ModeSense6(out modeBuf, out senseBuf, false, ScsiModeSensePageControl.Current, 0x3F, 0x00, dev.Timeout, out duration);
sense = dev.ModeSense6(out modeBuf, out senseBuf, false, ScsiModeSensePageControl.Current, 0x3F, 0xFF, 5, out duration);
if (sense || dev.Error)
sense = dev.ModeSense6(out modeBuf, out senseBuf, false, ScsiModeSensePageControl.Current, 0x3F, 0x00, dev.Timeout, out duration);
sense = dev.ModeSense6(out modeBuf, out senseBuf, false, ScsiModeSensePageControl.Current, 0x3F, 0x00, 5, out duration);
if (sense || dev.Error)
sense = dev.ModeSense(out modeBuf, out senseBuf, 15000, out duration);
sense = dev.ModeSense(out modeBuf, out senseBuf, 5, out duration);
if (!sense && !dev.Error)
decMode = Decoders.SCSI.Modes.DecodeMode6(modeBuf, devType);
@@ -477,7 +477,7 @@ namespace DiscImageChef.Commands
}
case 0x3E:
{
if (StringHandlers.SpacePaddedToString(inq.Value.VendorIdentification) == "FUJITSU")
if (StringHandlers.CToString(inq.Value.VendorIdentification).Trim() == "FUJITSU")
DicConsole.WriteLine(Decoders.SCSI.Modes.PrettifyFujitsuModePage_3E(page.PageResponse));
else
goto default;

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@@ -175,6 +175,51 @@ namespace DiscImageChef.Commands
}
}
byte[] modeBuf;
Decoders.SCSI.Modes.DecodedMode? decMode = null;
Decoders.SCSI.PeripheralDeviceTypes devType = dev.SCSIType;
sense = dev.ModeSense10(out modeBuf, out senseBuf, false, true, ScsiModeSensePageControl.Current, 0x3F, 0xFF, 5, out duration);
if (sense || dev.Error)
{
sense = dev.ModeSense10(out modeBuf, out senseBuf, false, true, ScsiModeSensePageControl.Current, 0x3F, 0x00, 5, out duration);
}
if (!sense && !dev.Error)
{
decMode = Decoders.SCSI.Modes.DecodeMode10(modeBuf, devType);
}
if(sense || dev.Error || !decMode.HasValue)
{
sense = dev.ModeSense6(out modeBuf, out senseBuf, false, ScsiModeSensePageControl.Current, 0x3F, 0x00, 5, out duration);
if (sense || dev.Error)
sense = dev.ModeSense6(out modeBuf, out senseBuf, false, ScsiModeSensePageControl.Current, 0x3F, 0x00, 5, out duration);
if (sense || dev.Error)
sense = dev.ModeSense(out modeBuf, out senseBuf, 5, out duration);
if (!sense && !dev.Error)
decMode = Decoders.SCSI.Modes.DecodeMode6(modeBuf, devType);
}
if (!sense)
doWriteFile(outputPrefix, "_scsi_modesense.bin", "SCSI MODE SENSE", modeBuf);
byte scsiMediumType = 0;
byte scsiDensityCode = 0;
bool containsFloppyPage = false;
if(decMode.HasValue)
{
scsiMediumType = (byte)decMode.Value.Header.MediumType;
if(decMode.Value.Header.BlockDescriptors != null && decMode.Value.Header.BlockDescriptors.Length >= 1)
scsiDensityCode = (byte)decMode.Value.Header.BlockDescriptors[0].Density;
foreach(Decoders.SCSI.Modes.ModePage modePage in decMode.Value.Pages)
if(modePage.Page == 0x05)
containsFloppyPage = true;
}
if (dev.SCSIType == DiscImageChef.Decoders.SCSI.PeripheralDeviceTypes.DirectAccess ||
dev.SCSIType == DiscImageChef.Decoders.SCSI.PeripheralDeviceTypes.MultiMediaDevice ||
dev.SCSIType == DiscImageChef.Decoders.SCSI.PeripheralDeviceTypes.OCRWDevice ||
@@ -280,7 +325,7 @@ namespace DiscImageChef.Commands
{
sense = dev.GetConfiguration(out cmdBuf, out senseBuf, 0, MmcGetConfigurationRt.Current, dev.Timeout, out duration);
if (sense)
DicConsole.ErrorWriteLine("READ GET CONFIGURATION:\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
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);
@@ -383,12 +428,12 @@ namespace DiscImageChef.Commands
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.RecognizedFormatLayers, 0, dev.Timeout, out duration);
if (sense)
DicConsole.ErrorWriteLine("READ DISC STRUCTURE: Recognized Format Layers\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
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);
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.WriteProtectionStatus, 0, dev.Timeout, out duration);
if (sense)
DicConsole.ErrorWriteLine("READ DISC STRUCTURE: Write Protection Status\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
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);
@@ -396,7 +441,7 @@ namespace DiscImageChef.Commands
/*
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.CapabilityList, 0, dev.Timeout, out duration);
if(sense)
DicConsole.ErrorWriteLine("READ DISC STRUCTURE: Capability List\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
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);
*/
@@ -415,15 +460,78 @@ namespace DiscImageChef.Commands
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.PhysicalInformation, 0, dev.Timeout, out duration);
if (sense)
DicConsole.ErrorWriteLine("READ DISC STRUCTURE: PFI\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
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);
DicConsole.WriteLine("PFI:\n{0}", Decoders.DVD.PFI.Prettify(cmdBuf));
Decoders.DVD.PFI.PhysicalFormatInformation? decPfi = Decoders.DVD.PFI.Decode(cmdBuf);
if(decPfi.HasValue)
{
DicConsole.WriteLine("PFI:\n{0}", Decoders.DVD.PFI.Prettify(decPfi));
// False book types
if(dskType == MediaType.DVDROM)
{
switch(decPfi.Value.DiskCategory)
{
case Decoders.DVD.DiskCategory.DVDPR:
dskType = MediaType.DVDPR;
break;
case Decoders.DVD.DiskCategory.DVDPRDL:
dskType = MediaType.DVDPRDL;
break;
case Decoders.DVD.DiskCategory.DVDPRW:
dskType = MediaType.DVDPRW;
break;
case Decoders.DVD.DiskCategory.DVDPRWDL:
dskType = MediaType.DVDPRWDL;
break;
case Decoders.DVD.DiskCategory.DVDR:
if(decPfi.Value.PartVersion == 6)
dskType = MediaType.DVDRDL;
else
dskType = MediaType.DVDR;
break;
case Decoders.DVD.DiskCategory.DVDRAM:
dskType = MediaType.DVDRAM;
break;
default:
dskType = MediaType.DVDROM;
break;
case Decoders.DVD.DiskCategory.DVDRW:
if(decPfi.Value.PartVersion == 3)
dskType = MediaType.DVDRWDL;
else
dskType = MediaType.DVDRW;
break;
case Decoders.DVD.DiskCategory.HDDVDR:
dskType = MediaType.HDDVDR;
break;
case Decoders.DVD.DiskCategory.HDDVDRAM:
dskType = MediaType.HDDVDRAM;
break;
case Decoders.DVD.DiskCategory.HDDVDROM:
dskType = MediaType.HDDVDROM;
break;
case Decoders.DVD.DiskCategory.HDDVDRW:
dskType = MediaType.HDDVDRW;
break;
case Decoders.DVD.DiskCategory.Nintendo:
if(decPfi.Value.DiscSize == DiscImageChef.Decoders.DVD.DVDSize.Eighty)
dskType = MediaType.GOD;
else
dskType = MediaType.WOD;
break;
case Decoders.DVD.DiskCategory.UMD:
dskType = MediaType.UMD;
break;
}
}
}
}
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.DiscManufacturingInformation, 0, dev.Timeout, out duration);
if (sense)
DicConsole.ErrorWriteLine("READ DISC STRUCTURE: DMI\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
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);
@@ -445,7 +553,7 @@ namespace DiscImageChef.Commands
{
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.CopyrightInformation, 0, dev.Timeout, out duration);
if (sense)
DicConsole.ErrorWriteLine("READ DISC STRUCTURE: CMI\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
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);
@@ -460,12 +568,12 @@ namespace DiscImageChef.Commands
{
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.BurstCuttingArea, 0, dev.Timeout, out duration);
if (sense)
DicConsole.ErrorWriteLine("READ DISC STRUCTURE: BCA\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
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);
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.DVD_AACS, 0, dev.Timeout, out duration);
if (sense)
DicConsole.ErrorWriteLine("READ DISC STRUCTURE: DVD AACS\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
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);
}
@@ -475,57 +583,57 @@ namespace DiscImageChef.Commands
/*
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.DiscKey, 0, dev.Timeout, out duration);
if(sense)
DicConsole.ErrorWriteLine("READ DISC STRUCTURE: Disc Key\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
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);
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.SectorCopyrightInformation, 0, dev.Timeout, out duration);
if(sense)
DicConsole.ErrorWriteLine("READ DISC STRUCTURE: Sector CMI\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
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);
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.MediaIdentifier, 0, dev.Timeout, out duration);
if(sense)
DicConsole.ErrorWriteLine("READ DISC STRUCTURE: Media ID\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
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);
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.MediaKeyBlock, 0, dev.Timeout, out duration);
if(sense)
DicConsole.ErrorWriteLine("READ DISC STRUCTURE: MKB\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
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);
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.AACSVolId, 0, dev.Timeout, out duration);
if(sense)
DicConsole.ErrorWriteLine("READ DISC STRUCTURE: AACS Volume ID\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
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);
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.AACSMediaSerial, 0, dev.Timeout, out duration);
if(sense)
DicConsole.ErrorWriteLine("READ DISC STRUCTURE: AACS Media Serial Number\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
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);
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.AACSMediaId, 0, dev.Timeout, out duration);
if(sense)
DicConsole.ErrorWriteLine("READ DISC STRUCTURE: AACS Media ID\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
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);
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.AACSMKB, 0, dev.Timeout, out duration);
if(sense)
DicConsole.ErrorWriteLine("READ DISC STRUCTURE: AACS MKB\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
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);
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.AACSLBAExtents, 0, dev.Timeout, out duration);
if(sense)
DicConsole.ErrorWriteLine("READ DISC STRUCTURE: AACS LBA Extents\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
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);
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.AACSMKBCPRM, 0, dev.Timeout, out duration);
if(sense)
DicConsole.ErrorWriteLine("READ DISC STRUCTURE: AACS CPRM MKB\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
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);
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.AACSDataKeys, 0, dev.Timeout, out duration);
if(sense)
DicConsole.ErrorWriteLine("READ DISC STRUCTURE: AACS Data Keys\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
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);
*/
@@ -536,7 +644,7 @@ namespace DiscImageChef.Commands
{
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.DVDRAM_DDS, 0, dev.Timeout, out duration);
if (sense)
DicConsole.ErrorWriteLine("READ DISC STRUCTURE: DDS\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
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);
@@ -544,7 +652,7 @@ namespace DiscImageChef.Commands
}
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.DVDRAM_MediumStatus, 0, dev.Timeout, out duration);
if (sense)
DicConsole.ErrorWriteLine("READ DISC STRUCTURE: Medium Status\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
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);
@@ -552,7 +660,7 @@ namespace DiscImageChef.Commands
}
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.DVDRAM_SpareAreaInformation, 0, dev.Timeout, out duration);
if (sense)
DicConsole.ErrorWriteLine("READ DISC STRUCTURE: SAI\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
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);
@@ -566,7 +674,7 @@ namespace DiscImageChef.Commands
{
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.LastBorderOutRMD, 0, dev.Timeout, out duration);
if (sense)
DicConsole.ErrorWriteLine("READ DISC STRUCTURE: Last-Out Border RMD\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
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);
}
@@ -577,7 +685,7 @@ namespace DiscImageChef.Commands
{
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.PreRecordedInfo, 0, dev.Timeout, out duration);
if (sense)
DicConsole.ErrorWriteLine("READ DISC STRUCTURE: Pre-Recorded Info\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
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);
}
@@ -588,12 +696,12 @@ namespace DiscImageChef.Commands
{
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.DVDR_MediaIdentifier, 0, dev.Timeout, out duration);
if (sense)
DicConsole.ErrorWriteLine("READ DISC STRUCTURE: DVD-R Media ID\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
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);
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.DVDR_PhysicalInformation, 0, dev.Timeout, out duration);
if (sense)
DicConsole.ErrorWriteLine("READ DISC STRUCTURE: DVD-R PFI\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
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);
}
@@ -603,18 +711,15 @@ namespace DiscImageChef.Commands
if (dskType == MediaType.DVDPR || dskType == MediaType.DVDPRDL ||
dskType == MediaType.DVDPRW || dskType == MediaType.DVDPRWDL)
{
// TODO: None of my test discs return an ADIP. Also, it just seems to contain pre-recorded PFI, and drive is returning it on blank media using standard PFI command
/*
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.ADIP, 0, dev.Timeout, out duration);
if(sense)
DicConsole.ErrorWriteLine("READ DISC STRUCTURE: ADIP\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
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);
*/
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.DCB, 0, dev.Timeout, out duration);
if (sense)
DicConsole.ErrorWriteLine("READ DISC STRUCTURE: DCB\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
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);
}
@@ -625,7 +730,7 @@ namespace DiscImageChef.Commands
{
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.HDDVD_CopyrightInformation, 0, dev.Timeout, out duration);
if (sense)
DicConsole.ErrorWriteLine("READ DISC STRUCTURE: HDDVD CMI\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
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);
}
@@ -636,12 +741,12 @@ namespace DiscImageChef.Commands
{
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.HDDVDR_MediumStatus, 0, dev.Timeout, out duration);
if (sense)
DicConsole.ErrorWriteLine("READ DISC STRUCTURE: HDDVD-R Medium Status\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
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);
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.HDDVDR_LastRMD, 0, dev.Timeout, out duration);
if (sense)
DicConsole.ErrorWriteLine("READ DISC STRUCTURE: Last RMD\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
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);
}
@@ -653,7 +758,7 @@ namespace DiscImageChef.Commands
{
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.DVDR_LayerCapacity, 0, dev.Timeout, out duration);
if (sense)
DicConsole.ErrorWriteLine("READ DISC STRUCTURE: Layer Capacity\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
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);
}
@@ -664,22 +769,22 @@ namespace DiscImageChef.Commands
{
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.MiddleZoneStart, 0, dev.Timeout, out duration);
if (sense)
DicConsole.ErrorWriteLine("READ DISC STRUCTURE: Middle Zone Start\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
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);
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.JumpIntervalSize, 0, dev.Timeout, out duration);
if (sense)
DicConsole.ErrorWriteLine("READ DISC STRUCTURE: Jump Interval Size\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
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);
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.ManualLayerJumpStartLBA, 0, dev.Timeout, out duration);
if (sense)
DicConsole.ErrorWriteLine("READ DISC STRUCTURE: Manual Layer Jump Start LBA\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
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);
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.RemapAnchorPoint, 0, dev.Timeout, out duration);
if (sense)
DicConsole.ErrorWriteLine("READ DISC STRUCTURE: Remap Anchor Point\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
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);
}
@@ -691,7 +796,7 @@ namespace DiscImageChef.Commands
{
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.BD, 0, 0, MmcDiscStructureFormat.DiscInformation, 0, dev.Timeout, out duration);
if (sense)
DicConsole.ErrorWriteLine("READ DISC STRUCTURE: DI\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
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);
@@ -699,7 +804,7 @@ namespace DiscImageChef.Commands
}
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.BD, 0, 0, MmcDiscStructureFormat.PAC, 0, dev.Timeout, out duration);
if (sense)
DicConsole.ErrorWriteLine("READ DISC STRUCTURE: PAC\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
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);
}
@@ -710,7 +815,7 @@ namespace DiscImageChef.Commands
{
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.BD, 0, 0, MmcDiscStructureFormat.BD_BurstCuttingArea, 0, dev.Timeout, out duration);
if (sense)
DicConsole.ErrorWriteLine("READ DISC STRUCTURE: BCA\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
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);
@@ -725,7 +830,7 @@ namespace DiscImageChef.Commands
{
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.BD, 0, 0, MmcDiscStructureFormat.BD_DDS, 0, dev.Timeout, out duration);
if (sense)
DicConsole.ErrorWriteLine("READ DISC STRUCTURE: DDS\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
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);
@@ -733,7 +838,7 @@ namespace DiscImageChef.Commands
}
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.BD, 0, 0, MmcDiscStructureFormat.CartridgeStatus, 0, dev.Timeout, out duration);
if (sense)
DicConsole.ErrorWriteLine("READ DISC STRUCTURE: Cartridge Status\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
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);
@@ -741,7 +846,7 @@ namespace DiscImageChef.Commands
}
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.BD, 0, 0, MmcDiscStructureFormat.BD_SpareAreaInformation, 0, dev.Timeout, out duration);
if (sense)
DicConsole.ErrorWriteLine("READ DISC STRUCTURE: Spare Area Information\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
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);
@@ -749,12 +854,12 @@ namespace DiscImageChef.Commands
}
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.BD, 0, 0, MmcDiscStructureFormat.RawDFL, 0, dev.Timeout, out duration);
if (sense)
DicConsole.ErrorWriteLine("READ DISC STRUCTURE: Raw DFL\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
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);
sense = dev.ReadDiscInformation(out cmdBuf, out senseBuf, MmcDiscInformationDataTypes.TrackResources, dev.Timeout, out duration);
if (sense)
DicConsole.ErrorWriteLine("READ DISC INFORMATION 001b\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
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));
@@ -762,7 +867,7 @@ namespace DiscImageChef.Commands
}
sense = dev.ReadDiscInformation(out cmdBuf, out senseBuf, MmcDiscInformationDataTypes.POWResources, dev.Timeout, out duration);
if (sense)
DicConsole.ErrorWriteLine("READ DISC INFORMATION 010b\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
DicConsole.DebugWriteLine("Media-Info command", "READ DISC INFORMATION 010b\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
else
{
DicConsole.WriteLine("POW Resources Information:\n{0}", Decoders.SCSI.MMC.DiscInformation.Prettify(cmdBuf));
@@ -784,7 +889,7 @@ namespace DiscImageChef.Commands
// No TOC, no CD (or an empty one)
bool tocSense = dev.ReadTocPmaAtip(out cmdBuf, out senseBuf, false, 0, 0, dev.Timeout, out duration);
if (tocSense)
DicConsole.ErrorWriteLine("READ TOC/PMA/ATIP: TOC\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
DicConsole.DebugWriteLine("Media-Info command", "READ TOC/PMA/ATIP: TOC\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
else
{
toc = Decoders.CD.TOC.Decode(cmdBuf);
@@ -799,7 +904,7 @@ namespace DiscImageChef.Commands
// ATIP exists on blank CDs
sense = dev.ReadAtip(out cmdBuf, out senseBuf, dev.Timeout, out duration);
if (sense)
DicConsole.ErrorWriteLine("READ TOC/PMA/ATIP: ATIP\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
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);
@@ -817,7 +922,7 @@ namespace DiscImageChef.Commands
{
sense = dev.ReadDiscInformation(out cmdBuf, out senseBuf, MmcDiscInformationDataTypes.DiscInformation, dev.Timeout, out duration);
if (sense)
DicConsole.ErrorWriteLine("READ DISC INFORMATION 000b\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
DicConsole.DebugWriteLine("Media-Info command", "READ DISC INFORMATION 000b\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
else
{
Decoders.SCSI.MMC.DiscInformation.StandardDiscInformation? discInfo = Decoders.SCSI.MMC.DiscInformation.Decode000b(cmdBuf);
@@ -847,7 +952,7 @@ namespace DiscImageChef.Commands
sense = dev.ReadSessionInfo(out cmdBuf, out senseBuf, dev.Timeout, out duration);
if (sense)
DicConsole.ErrorWriteLine("READ TOC/PMA/ATIP: Session info\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
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);
@@ -904,7 +1009,7 @@ namespace DiscImageChef.Commands
sense = dev.ReadRawToc(out cmdBuf, out senseBuf, 1, dev.Timeout, out duration);
if (sense)
DicConsole.ErrorWriteLine("READ TOC/PMA/ATIP: Raw TOC\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
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);
@@ -912,7 +1017,7 @@ namespace DiscImageChef.Commands
}
sense = dev.ReadPma(out cmdBuf, out senseBuf, dev.Timeout, out duration);
if (sense)
DicConsole.ErrorWriteLine("READ TOC/PMA/ATIP: PMA\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
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);
@@ -921,7 +1026,7 @@ namespace DiscImageChef.Commands
sense = dev.ReadCdText(out cmdBuf, out senseBuf, dev.Timeout, out duration);
if (sense)
DicConsole.ErrorWriteLine("READ TOC/PMA/ATIP: CD-TEXT\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
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);
@@ -937,7 +1042,7 @@ namespace DiscImageChef.Commands
{
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.PhysicalInformation, 0, dev.Timeout, out duration);
if (sense)
DicConsole.ErrorWriteLine("READ DISC STRUCTURE: PFI\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
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);
@@ -957,18 +1062,24 @@ namespace DiscImageChef.Commands
}
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.DiscManufacturingInformation, 0, dev.Timeout, out duration);
if (sense)
DicConsole.ErrorWriteLine("READ DISC STRUCTURE: DMI\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
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);
}
#endregion Nintendo
}
if(dskType == MediaType.Unknown)
dskType = MediaTypeFromSCSI.Get((byte)dev.SCSIType, dev.Manufacturer, dev.Model, scsiMediumType, scsiDensityCode, blocks, blockSize);
if(dskType == MediaType.Unknown && dev.IsUSB && containsFloppyPage)
dskType = MediaType.FlashDrive;
DicConsole.WriteLine("Media identified as {0}", dskType);
sense = dev.ReadMediaSerialNumber(out cmdBuf, out senseBuf, dev.Timeout, out duration);
if (sense)
DicConsole.ErrorWriteLine("READ MEDIA SERIAL NUMBER\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
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);

View File

@@ -41,6 +41,7 @@ using System.IO;
using DiscImageChef.Devices;
using System.Text;
using System.Collections.Generic;
using System.Globalization;
namespace DiscImageChef.Commands
{
@@ -48,6 +49,22 @@ namespace DiscImageChef.Commands
{
static bool aborted;
static FileStream mhddFs;
static FileStream ibgFs;
static StringBuilder ibgSb;
static DateTime ibgDatePoint;
static CultureInfo ibgCulture;
static double ibgStartSpeed;
static string ibgMediaType;
static double ibgDivider;
static bool ibgStartSet;
static int ibgMinSampleRate;
static double ibgMaxSpeed;
static double ibgIntSpeed;
static int ibgSnaps;
static ulong ibgIntSector = 0;
static double ibgIntTime = 0;
static int ibgSampleRate;
public static void doMediaScan(MediaScanSubOptions options)
{
@@ -55,6 +72,7 @@ namespace DiscImageChef.Commands
DicConsole.DebugWriteLine("Media-Scan command", "--verbose={0}", options.Verbose);
DicConsole.DebugWriteLine("Media-Scan command", "--device={0}", options.DevicePath);
DicConsole.DebugWriteLine("Media-Scan command", "--mhdd-log={0}", options.MHDDLogPath);
DicConsole.DebugWriteLine("Media-Scan command", "--ibg-log={0}", options.IBGLogPath);
if (options.DevicePath.Length == 2 && options.DevicePath[1] == ':' &&
options.DevicePath[0] != '/' && Char.IsLetter(options.DevicePath[0]))
@@ -63,6 +81,7 @@ namespace DiscImageChef.Commands
}
mhddFs = null;
ibgFs = null;
Device dev = new Device(options.DevicePath);
@@ -75,40 +94,40 @@ namespace DiscImageChef.Commands
switch (dev.Type)
{
case DeviceType.ATA:
doATAMediaScan(options.MHDDLogPath, dev);
doATAMediaScan(options.MHDDLogPath, options.IBGLogPath, options.DevicePath, dev);
break;
case DeviceType.MMC:
case DeviceType.SecureDigital:
doSDMediaScan(options.MHDDLogPath, dev);
doSDMediaScan(options.MHDDLogPath, options.IBGLogPath, options.DevicePath, dev);
break;
case DeviceType.NVMe:
doNVMeMediaScan(options.MHDDLogPath, dev);
doNVMeMediaScan(options.MHDDLogPath, options.IBGLogPath, options.DevicePath, dev);
break;
case DeviceType.ATAPI:
case DeviceType.SCSI:
doSCSIMediaScan(options.MHDDLogPath, dev);
doSCSIMediaScan(options.MHDDLogPath, options.IBGLogPath, options.DevicePath, dev);
break;
default:
throw new NotSupportedException("Unknown device type.");
}
}
static void doATAMediaScan(string MHDDLogPath, Device dev)
static void doATAMediaScan(string MHDDLogPath, string IBGLogPath, string devicePath, Device dev)
{
throw new NotImplementedException("ATA devices not yet supported.");
}
static void doNVMeMediaScan(string MHDDLogPath, Device dev)
static void doNVMeMediaScan(string MHDDLogPath, string IBGLogPath, string devicePath, Device dev)
{
throw new NotImplementedException("NVMe devices not yet supported.");
}
static void doSDMediaScan(string MHDDLogPath, Device dev)
static void doSDMediaScan(string MHDDLogPath, string IBGLogPath, string devicePath, Device dev)
{
throw new NotImplementedException("MMC/SD devices not yet supported.");
}
static void doSCSIMediaScan(string MHDDLogPath, Device dev)
static void doSCSIMediaScan(string MHDDLogPath, string IBGLogPath, string devicePath, Device dev)
{
byte[] cmdBuf;
byte[] senseBuf;
@@ -116,6 +135,7 @@ namespace DiscImageChef.Commands
double duration;
ulong blocks = 0;
uint blockSize = 0;
ushort currentProfile = 0x0001;
if (dev.IsRemovable)
{
@@ -249,6 +269,8 @@ namespace DiscImageChef.Commands
{
Decoders.SCSI.MMC.Features.SeparatedFeatures ftr = Decoders.SCSI.MMC.Features.Separate(cmdBuf);
currentProfile = ftr.CurrentProfile;
switch (ftr.CurrentProfile)
{
case 0x0005:
@@ -267,6 +289,7 @@ namespace DiscImageChef.Commands
if (compactDisc)
{
currentProfile = 0x0008;
// We discarded all discs that falsify a TOC before requesting a real TOC
// No TOC, no CD (or an empty one)
bool tocSense = dev.ReadRawToc(out cmdBuf, out senseBuf, 1, dev.Timeout, out duration);
@@ -342,6 +365,7 @@ namespace DiscImageChef.Commands
DicConsole.WriteLine("Reading {0} sectors at a time.", blocksToRead);
initMHDDLogFile(MHDDLogPath, dev, blocks, blockSize, blocksToRead);
initIBGLogFile(IBGLogPath, currentProfile);
for (ulong i = 0; i < blocks; i += blocksToRead)
{
@@ -395,6 +419,7 @@ namespace DiscImageChef.Commands
}
writeMHDDLogFile(i, cmdDuration);
writeIBGLogFile(i, currentSpeed * 1024);
}
else
{
@@ -416,6 +441,8 @@ namespace DiscImageChef.Commands
writeMHDDLogFile(i, 65535);
else
writeMHDDLogFile(i, cmdDuration);
writeIBGLogFile(i, 0);
}
}
else
@@ -426,6 +453,8 @@ namespace DiscImageChef.Commands
writeMHDDLogFile(i, 65535);
else
writeMHDDLogFile(i, cmdDuration);
writeIBGLogFile(i, 0);
}
}
@@ -435,6 +464,7 @@ namespace DiscImageChef.Commands
end = DateTime.UtcNow;
DicConsole.WriteLine();
closeMHDDLogFile();
closeIBGLogFile(dev, blocks, blockSize, (end - start).TotalSeconds, currentSpeed * 1024, (((double)blockSize * (double)(blocks + 1)) / 1024) / (totalDuration / 1000), devicePath);
}
else
{
@@ -460,7 +490,7 @@ namespace DiscImageChef.Commands
if (!read16 && blocks > ((long)0xFFFFFFFF + (long)1))
{
DicConsole.ErrorWriteLine("Device only supports SCSI READ (16) but has more than {0} blocks ({1} blocks total)", (long)0xFFFFFFFF + (long)1, blocks);
DicConsole.ErrorWriteLine("Device only supports SCSI READ (10) but has more than {0} blocks ({1} blocks total)", (long)0xFFFFFFFF + (long)1, blocks);
return;
}
@@ -515,6 +545,7 @@ namespace DiscImageChef.Commands
DicConsole.WriteLine("Reading {0} sectors at a time.", blocksToRead);
initMHDDLogFile(MHDDLogPath, dev, blocks, blockSize, blocksToRead);
initIBGLogFile(IBGLogPath, currentProfile);
for (ulong i = 0; i < blocks; i += blocksToRead)
{
@@ -570,6 +601,7 @@ namespace DiscImageChef.Commands
A += blocksToRead;
writeMHDDLogFile(i, cmdDuration);
writeIBGLogFile(i, currentSpeed * 1024);
}
// TODO: Separate errors on kind of errors.
else
@@ -581,6 +613,7 @@ namespace DiscImageChef.Commands
writeMHDDLogFile(i, 65535);
else
writeMHDDLogFile(i, cmdDuration);
writeIBGLogFile(i, 0);
}
currentSpeed = ((double)blockSize * blocksToRead / (double)1048576) / (cmdDuration / (double)1000);
@@ -588,6 +621,7 @@ namespace DiscImageChef.Commands
end = DateTime.UtcNow;
DicConsole.WriteLine();
closeMHDDLogFile();
closeIBGLogFile(dev, blocks, blockSize, (end - start).TotalSeconds, currentSpeed * 1024, (((double)blockSize * (double)(blocks + 1)) / 1024) / (totalDuration / 1000), devicePath);
}
bool seek6, seek10;
@@ -800,6 +834,245 @@ namespace DiscImageChef.Commands
mhddFs.Write(durationBytes, 0, 8);
}
}
static void writeIBGLogFile(ulong sector, double currentSpeed)
{
if (ibgFs != null)
{
ibgIntSpeed += currentSpeed;
ibgSampleRate += (int)Math.Floor((DateTime.Now - ibgDatePoint).TotalMilliseconds);
ibgSnaps++;
if(ibgSampleRate >= 100)
{
if (ibgIntSpeed > 0 && !ibgStartSet)
{
ibgStartSpeed = ibgIntSpeed / ibgSnaps / ibgDivider;
ibgStartSet = true;
}
ibgSb.AppendFormat("{0:0.00},{1},{2:0},0", ibgIntSpeed / ibgSnaps / ibgDivider, ibgIntSector, ibgSampleRate).AppendLine();
if ((ibgIntSpeed / ibgSnaps / ibgDivider) > ibgMaxSpeed)
ibgMaxSpeed = ibgIntSpeed / ibgDivider;
ibgDatePoint = DateTime.Now;
ibgIntSpeed = 0;
ibgSampleRate = 0;
ibgSnaps = 0;
ibgIntSector = sector;
}
}
}
static void initIBGLogFile(string outputFile, ushort currentProfile)
{
if (!string.IsNullOrEmpty(outputFile))
{
ibgFs = new FileStream(outputFile, FileMode.Create);
ibgSb = new StringBuilder();
ibgDatePoint = DateTime.Now;
ibgCulture = new CultureInfo("en-US");
ibgStartSet = false;
ibgMinSampleRate = int.MaxValue;
ibgMaxSpeed = 0;
ibgIntSpeed = 0;
ibgSnaps = 0;
ibgIntSector = 0;
ibgIntTime = 0;
switch (currentProfile)
{
case 0x0001:
ibgMediaType = "HDD";
ibgDivider = 1353;
break;
case 0x0005:
ibgMediaType = "CD-MO";
ibgDivider = 150;
break;
case 0x0008:
ibgMediaType = "CD-ROM";
ibgDivider = 150;
break;
case 0x0009:
ibgMediaType = "CD-R";
ibgDivider = 150;
break;
case 0x000A:
ibgMediaType = "CD-RW";
ibgDivider = 150;
break;
case 0x0010:
ibgMediaType = "DVD-ROM";
ibgDivider = 1353;
break;
case 0x0011:
ibgMediaType = "DVD-R";
ibgDivider = 1353;
break;
case 0x0012:
ibgMediaType = "DVD-RAM";
ibgDivider = 1353;
break;
case 0x0013:
case 0x0014:
ibgMediaType = "DVD-RW";
ibgDivider = 1353;
break;
case 0x0015:
case 0x0016:
ibgMediaType = "DVD-R DL";
ibgDivider = 1353;
break;
case 0x0017:
ibgMediaType = "DVD-RW DL";
ibgDivider = 1353;
break;
case 0x0018:
ibgMediaType = "DVD-Download";
ibgDivider = 1353;
break;
case 0x001A:
ibgMediaType = "DVD+RW";
ibgDivider = 1353;
break;
case 0x001B:
ibgMediaType = "DVD+R";
ibgDivider = 1353;
break;
case 0x0020:
ibgMediaType = "DDCD-ROM";
ibgDivider = 150;
break;
case 0x0021:
ibgMediaType = "DDCD-R";
ibgDivider = 150;
break;
case 0x0022:
ibgMediaType = "DDCD-RW";
ibgDivider = 150;
break;
case 0x002A:
ibgMediaType = "DVD+RW DL";
ibgDivider = 1353;
break;
case 0x002B:
ibgMediaType = "DVD+R DL";
ibgDivider = 1353;
break;
case 0x0040:
ibgMediaType = "BD-ROM";
ibgDivider = 4500;
break;
case 0x0041:
case 0x0042:
ibgMediaType = "BD-R";
ibgDivider = 4500;
break;
case 0x0043:
ibgMediaType = "BD-RE";
ibgDivider = 4500;
break;
case 0x0050:
ibgMediaType = "HD DVD-ROM";
ibgDivider = 4500;
break;
case 0x0051:
ibgMediaType = "HD DVD-R";
ibgDivider = 4500;
break;
case 0x0052:
ibgMediaType = "HD DVD-RAM";
ibgDivider = 4500;
break;
case 0x0053:
ibgMediaType = "HD DVD-RW";
ibgDivider = 4500;
break;
case 0x0058:
ibgMediaType = "HD DVD-R DL";
ibgDivider = 4500;
break;
case 0x005A:
ibgMediaType = "HD DVD-RW DL";
ibgDivider = 4500;
break;
default:
ibgMediaType = "Unknown";
ibgDivider = 1353;
break;
}
}
}
static void closeIBGLogFile(Device dev, ulong blocks, ulong blockSize, double totalSeconds, double currentSpeed, double averageSpeed, string devicePath)
{
if (ibgFs != null)
{
StringBuilder ibgHeader = new StringBuilder();
string ibgBusType;
if (dev.IsUSB)
ibgBusType = "USB";
else if (dev.IsFireWire)
ibgBusType = "FireWire";
else
ibgBusType = dev.Type.ToString();
ibgHeader.AppendLine("IBGD");
ibgHeader.AppendLine();
ibgHeader.AppendLine("[START_CONFIGURATION]");
ibgHeader.AppendLine("IBGD_VERSION=2");
ibgHeader.AppendLine();
ibgHeader.AppendFormat("DATE={0}", DateTime.Now).AppendLine();
ibgHeader.AppendLine();
ibgHeader.AppendFormat("SAMPLE_RATE={0}", 100).AppendLine();
ibgHeader.AppendLine();
ibgHeader.AppendFormat("DEVICE=[0:0:0] {0} {1} ({2}) ({3})",
dev.Manufacturer, dev.Model, devicePath, ibgBusType).AppendLine();
ibgHeader.AppendLine("DEVICE_ADDRESS=0:0:0");
ibgHeader.AppendFormat("DEVICE_MAKEMODEL={0} {1}", dev.Manufacturer, dev.Model).AppendLine();
ibgHeader.AppendFormat("DEVICE_FIRMWAREVERSION={0}", dev.Revision).AppendLine();
ibgHeader.AppendFormat("DEVICE_DRIVELETTER={0}", devicePath).AppendLine();
ibgHeader.AppendFormat("DEVICE_BUSTYPE={0}", ibgBusType).AppendLine();
ibgHeader.AppendLine();
ibgHeader.AppendFormat("MEDIA_TYPE={0}", ibgMediaType).AppendLine();
ibgHeader.AppendLine("MEDIA_BOOKTYPE=Unknown");
ibgHeader.AppendLine("MEDIA_ID=N/A");
ibgHeader.AppendLine("MEDIA_TRACKPATH=PTP");
ibgHeader.AppendLine("MEDIA_SPEEDS=N/A");
ibgHeader.AppendFormat("MEDIA_CAPACITY={0}", blocks).AppendLine();
ibgHeader.AppendLine("MEDIA_LAYER_BREAK=0");
ibgHeader.AppendLine();
ibgHeader.AppendLine("DATA_IMAGEFILE=/dev/null");
ibgHeader.AppendFormat("DATA_SECTORS={0}", blocks).AppendLine();
ibgHeader.AppendFormat("DATA_TYPE=MODE1/{0}", blockSize).AppendLine();
ibgHeader.AppendLine("DATA_VOLUMEIDENTIFIER=");
ibgHeader.AppendLine();
ibgHeader.AppendFormat(ibgCulture, "VERIFY_SPEED_START={0:0.00}", ibgStartSpeed).AppendLine();
ibgHeader.AppendFormat(ibgCulture, "VERIFY_SPEED_END={0:0.00}", currentSpeed / ibgDivider).AppendLine();
ibgHeader.AppendFormat(ibgCulture, "VERIFY_SPEED_AVERAGE={0:0.00}", averageSpeed / ibgDivider).AppendLine();
ibgHeader.AppendFormat(ibgCulture, "VERIFY_SPEED_MAX={0:0.00}", ibgMaxSpeed).AppendLine();
ibgHeader.AppendFormat(ibgCulture, "VERIFY_TIME_TAKEN={0:0}", Math.Floor(totalSeconds)).AppendLine();
ibgHeader.AppendLine("[END_CONFIGURATION]");
ibgHeader.AppendLine();
ibgHeader.AppendLine("HRPC=True");
ibgHeader.AppendLine();
ibgHeader.AppendLine("[START_VERIFY_GRAPH_VALUES]");
ibgHeader.Append(ibgSb.ToString());
ibgHeader.AppendLine("[END_VERIFY_GRAPH_VALUES]");
ibgHeader.AppendLine();
ibgHeader.Replace("\r\n", "\n").Replace("\r", "\n").Replace("\n", "\r\n");
StreamWriter sr = new StreamWriter(ibgFs);
sr.Write(ibgHeader.ToString());
sr.Close();
ibgFs.Close();
}
}
}
}

View File

@@ -0,0 +1,558 @@
// /***************************************************************************
// The Disc Image Chef
// ----------------------------------------------------------------------------
//
// Filename : GetChecksum.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 DiscImageChef.Checksums;
using Schemas;
using System.Threading;
using System.IO;
namespace DiscImageChef.Core
{
class Checksum
{
Adler32Context adler32ctx;
CRC16Context crc16ctx;
CRC32Context crc32ctx;
CRC64Context crc64ctx;
MD5Context md5ctx;
RIPEMD160Context ripemd160ctx;
SHA1Context sha1ctx;
SHA256Context sha256ctx;
SHA384Context sha384ctx;
SHA512Context sha512ctx;
SpamSumContext ssctx;
Thread adlerThread;
Thread crc16Thread;
Thread crc32Thread;
Thread crc64Thread;
Thread md5Thread;
Thread ripemd160Thread;
Thread sha1Thread;
Thread sha256Thread;
Thread sha384Thread;
Thread sha512Thread;
Thread spamsumThread;
adlerPacket adlerPkt;
crc16Packet crc16Pkt;
crc32Packet crc32Pkt;
crc64Packet crc64Pkt;
md5Packet md5Pkt;
ripemd160Packet ripemd160Pkt;
sha1Packet sha1Pkt;
sha256Packet sha256Pkt;
sha384Packet sha384Pkt;
sha512Packet sha512Pkt;
spamsumPacket spamsumPkt;
internal Checksum()
{
adler32ctx = new Adler32Context();
crc16ctx = new CRC16Context();
crc32ctx = new CRC32Context();
crc64ctx = new CRC64Context();
md5ctx = new MD5Context();
ripemd160ctx = new RIPEMD160Context();
sha1ctx = new SHA1Context();
sha256ctx = new SHA256Context();
sha384ctx = new SHA384Context();
sha512ctx = new SHA512Context();
ssctx = new SpamSumContext();
adlerThread = new Thread(updateAdler);
crc16Thread = new Thread(updateCRC16);
crc32Thread = new Thread(updateCRC32);
crc64Thread = new Thread(updateCRC64);
md5Thread = new Thread(updateMD5);
ripemd160Thread = new Thread(updateRIPEMD160);
sha1Thread = new Thread(updateSHA1);
sha256Thread = new Thread(updateSHA256);
sha384Thread = new Thread(updateSHA384);
sha512Thread = new Thread(updateSHA512);
spamsumThread = new Thread(updateSpamSum);
adlerPkt = new adlerPacket();
crc16Pkt = new crc16Packet();
crc32Pkt = new crc32Packet();
crc64Pkt = new crc64Packet();
md5Pkt = new md5Packet();
ripemd160Pkt = new ripemd160Packet();
sha1Pkt = new sha1Packet();
sha256Pkt = new sha256Packet();
sha384Pkt = new sha384Packet();
sha512Pkt = new sha512Packet();
spamsumPkt = new spamsumPacket();
adler32ctx.Init();
adlerPkt.context = adler32ctx;
crc16ctx.Init();
crc16Pkt.context = crc16ctx;
crc32ctx.Init();
crc32Pkt.context = crc32ctx;
crc64ctx.Init();
crc64Pkt.context = crc64ctx;
md5ctx.Init();
md5Pkt.context = md5ctx;
ripemd160ctx.Init();
ripemd160Pkt.context = ripemd160ctx;
sha1ctx.Init();
sha1Pkt.context = sha1ctx;
sha256ctx.Init();
sha256Pkt.context = sha256ctx;
sha384ctx.Init();
sha384Pkt.context = sha384ctx;
sha512ctx.Init();
sha512Pkt.context = sha512ctx;
ssctx.Init();
spamsumPkt.context = ssctx;
}
internal void Update(byte[] data)
{
adlerPkt.data = data;
adlerThread.Start(adlerPkt);
crc16Pkt.data = data;
crc16Thread.Start(crc16Pkt);
crc32Pkt.data = data;
crc32Thread.Start(crc32Pkt);
crc64Pkt.data = data;
crc64Thread.Start(crc64Pkt);
md5Pkt.data = data;
md5Thread.Start(md5Pkt);
ripemd160Pkt.data = data;
ripemd160Thread.Start(ripemd160Pkt);
sha1Pkt.data = data;
sha1Thread.Start(sha1Pkt);
sha256Pkt.data = data;
sha256Thread.Start(sha256Pkt);
sha384Pkt.data = data;
sha384Thread.Start(sha384Pkt);
sha512Pkt.data = data;
sha512Thread.Start(sha512Pkt);
spamsumPkt.data = data;
spamsumThread.Start(spamsumPkt);
while (adlerThread.IsAlive || crc16Thread.IsAlive ||
crc32Thread.IsAlive || crc64Thread.IsAlive ||
md5Thread.IsAlive || ripemd160Thread.IsAlive ||
sha1Thread.IsAlive || sha256Thread.IsAlive ||
sha384Thread.IsAlive || sha512Thread.IsAlive ||
spamsumThread.IsAlive)
{
}
adlerThread = new Thread(updateAdler);
crc16Thread = new Thread(updateCRC16);
crc32Thread = new Thread(updateCRC32);
crc64Thread = new Thread(updateCRC64);
md5Thread = new Thread(updateMD5);
ripemd160Thread = new Thread(updateRIPEMD160);
sha1Thread = new Thread(updateSHA1);
sha256Thread = new Thread(updateSHA256);
sha384Thread = new Thread(updateSHA384);
sha512Thread = new Thread(updateSHA512);
spamsumThread = new Thread(updateSpamSum);
}
internal List<ChecksumType> End()
{
List<ChecksumType> Checksums = new List<ChecksumType>();
ChecksumType chk = new ChecksumType();
chk.type = ChecksumTypeType.adler32;
chk.Value = adler32ctx.End();
Checksums.Add(chk);
chk = new ChecksumType();
chk.type = ChecksumTypeType.crc16;
chk.Value = crc16ctx.End();
Checksums.Add(chk);
chk = new ChecksumType();
chk.type = ChecksumTypeType.crc32;
chk.Value = crc32ctx.End();
Checksums.Add(chk);
chk = new ChecksumType();
chk.type = ChecksumTypeType.crc64;
chk.Value = crc64ctx.End();
Checksums.Add(chk);
chk = new ChecksumType();
chk.type = ChecksumTypeType.md5;
chk.Value = md5ctx.End();
Checksums.Add(chk);
chk = new ChecksumType();
chk.type = ChecksumTypeType.ripemd160;
chk.Value = ripemd160ctx.End();
Checksums.Add(chk);
chk = new ChecksumType();
chk.type = ChecksumTypeType.sha1;
chk.Value = sha1ctx.End();
Checksums.Add(chk);
chk = new ChecksumType();
chk.type = ChecksumTypeType.sha256;
chk.Value = sha256ctx.End();
Checksums.Add(chk);
chk = new ChecksumType();
chk.type = ChecksumTypeType.sha384;
chk.Value = sha384ctx.End();
Checksums.Add(chk);
chk = new ChecksumType();
chk.type = ChecksumTypeType.sha512;
chk.Value = sha512ctx.End();
Checksums.Add(chk);
chk = new ChecksumType();
chk.type = ChecksumTypeType.spamsum;
chk.Value = ssctx.End();
Checksums.Add(chk);
return Checksums;
}
internal static List<ChecksumType> GetChecksums(byte[] data)
{
Adler32Context adler32ctxData = new Adler32Context();
CRC16Context crc16ctxData = new CRC16Context();
CRC32Context crc32ctxData = new CRC32Context();
CRC64Context crc64ctxData = new CRC64Context();
MD5Context md5ctxData = new MD5Context();
RIPEMD160Context ripemd160ctxData = new RIPEMD160Context();
SHA1Context sha1ctxData = new SHA1Context();
SHA256Context sha256ctxData = new SHA256Context();
SHA384Context sha384ctxData = new SHA384Context();
SHA512Context sha512ctxData = new SHA512Context();
SpamSumContext ssctxData = new SpamSumContext();
Thread adlerThreadData = new Thread(updateAdler);
Thread crc16ThreadData = new Thread(updateCRC16);
Thread crc32ThreadData = new Thread(updateCRC32);
Thread crc64ThreadData = new Thread(updateCRC64);
Thread md5ThreadData = new Thread(updateMD5);
Thread ripemd160ThreadData = new Thread(updateRIPEMD160);
Thread sha1ThreadData = new Thread(updateSHA1);
Thread sha256ThreadData = new Thread(updateSHA256);
Thread sha384ThreadData = new Thread(updateSHA384);
Thread sha512ThreadData = new Thread(updateSHA512);
Thread spamsumThreadData = new Thread(updateSpamSum);
adlerPacket adlerPktData = new adlerPacket();
crc16Packet crc16PktData = new crc16Packet();
crc32Packet crc32PktData = new crc32Packet();
crc64Packet crc64PktData = new crc64Packet();
md5Packet md5PktData = new md5Packet();
ripemd160Packet ripemd160PktData = new ripemd160Packet();
sha1Packet sha1PktData = new sha1Packet();
sha256Packet sha256PktData = new sha256Packet();
sha384Packet sha384PktData = new sha384Packet();
sha512Packet sha512PktData = new sha512Packet();
spamsumPacket spamsumPktData = new spamsumPacket();
adler32ctxData.Init();
adlerPktData.context = adler32ctxData;
crc16ctxData.Init();
crc16PktData.context = crc16ctxData;
crc32ctxData.Init();
crc32PktData.context = crc32ctxData;
crc64ctxData.Init();
crc64PktData.context = crc64ctxData;
md5ctxData.Init();
md5PktData.context = md5ctxData;
ripemd160ctxData.Init();
ripemd160PktData.context = ripemd160ctxData;
sha1ctxData.Init();
sha1PktData.context = sha1ctxData;
sha256ctxData.Init();
sha256PktData.context = sha256ctxData;
sha384ctxData.Init();
sha384PktData.context = sha384ctxData;
sha512ctxData.Init();
sha512PktData.context = sha512ctxData;
ssctxData.Init();
spamsumPktData.context = ssctxData;
adlerPktData.data = data;
adlerThreadData.Start(adlerPktData);
crc16PktData.data = data;
crc16ThreadData.Start(crc16PktData);
crc32PktData.data = data;
crc32ThreadData.Start(crc32PktData);
crc64PktData.data = data;
crc64ThreadData.Start(crc64PktData);
md5PktData.data = data;
md5ThreadData.Start(md5PktData);
ripemd160PktData.data = data;
ripemd160ThreadData.Start(ripemd160PktData);
sha1PktData.data = data;
sha1ThreadData.Start(sha1PktData);
sha256PktData.data = data;
sha256ThreadData.Start(sha256PktData);
sha384PktData.data = data;
sha384ThreadData.Start(sha384PktData);
sha512PktData.data = data;
sha512ThreadData.Start(sha512PktData);
spamsumPktData.data = data;
spamsumThreadData.Start(spamsumPktData);
while (adlerThreadData.IsAlive || crc16ThreadData.IsAlive ||
crc32ThreadData.IsAlive || crc64ThreadData.IsAlive ||
md5ThreadData.IsAlive || ripemd160ThreadData.IsAlive ||
sha1ThreadData.IsAlive || sha256ThreadData.IsAlive ||
sha384ThreadData.IsAlive || sha512ThreadData.IsAlive ||
spamsumThreadData.IsAlive)
{
}
List<ChecksumType> dataChecksums = new List<ChecksumType>();
ChecksumType chk;
chk = new ChecksumType();
chk.type = ChecksumTypeType.adler32;
chk.Value = adler32ctxData.End();
dataChecksums.Add(chk);
chk = new ChecksumType();
chk.type = ChecksumTypeType.crc16;
chk.Value = crc16ctxData.End();
dataChecksums.Add(chk);
chk = new ChecksumType();
chk.type = ChecksumTypeType.crc32;
chk.Value = crc32ctxData.End();
dataChecksums.Add(chk);
chk = new ChecksumType();
chk.type = ChecksumTypeType.crc64;
chk.Value = crc64ctxData.End();
dataChecksums.Add(chk);
chk = new ChecksumType();
chk.type = ChecksumTypeType.md5;
chk.Value = md5ctxData.End();
dataChecksums.Add(chk);
chk = new ChecksumType();
chk.type = ChecksumTypeType.ripemd160;
chk.Value = ripemd160ctxData.End();
dataChecksums.Add(chk);
chk = new ChecksumType();
chk.type = ChecksumTypeType.sha1;
chk.Value = sha1ctxData.End();
dataChecksums.Add(chk);
chk = new ChecksumType();
chk.type = ChecksumTypeType.sha256;
chk.Value = sha256ctxData.End();
dataChecksums.Add(chk);
chk = new ChecksumType();
chk.type = ChecksumTypeType.sha384;
chk.Value = sha384ctxData.End();
dataChecksums.Add(chk);
chk = new ChecksumType();
chk.type = ChecksumTypeType.sha512;
chk.Value = sha512ctxData.End();
dataChecksums.Add(chk);
chk = new ChecksumType();
chk.type = ChecksumTypeType.spamsum;
chk.Value = ssctxData.End();
dataChecksums.Add(chk);
return dataChecksums;
}
#region Threading helpers
struct adlerPacket
{
public Adler32Context context;
public byte[] data;
}
struct crc16Packet
{
public CRC16Context context;
public byte[] data;
}
struct crc32Packet
{
public CRC32Context context;
public byte[] data;
}
struct crc64Packet
{
public CRC64Context context;
public byte[] data;
}
/*struct fletcher16Packet
{
public Fletcher16Context context;
public byte[] data;
}
struct fletcher32Packet
{
public Fletcher32Context context;
public byte[] data;
}*/
struct md5Packet
{
public MD5Context context;
public byte[] data;
}
struct ripemd160Packet
{
public RIPEMD160Context context;
public byte[] data;
}
struct sha1Packet
{
public SHA1Context context;
public byte[] data;
}
struct sha256Packet
{
public SHA256Context context;
public byte[] data;
}
struct sha384Packet
{
public SHA384Context context;
public byte[] data;
}
struct sha512Packet
{
public SHA512Context context;
public byte[] data;
}
struct spamsumPacket
{
public SpamSumContext context;
public byte[] data;
}
static void updateAdler(object packet)
{
((adlerPacket)packet).context.Update(((adlerPacket)packet).data);
}
static void updateCRC16(object packet)
{
((crc16Packet)packet).context.Update(((crc16Packet)packet).data);
}
static void updateCRC32(object packet)
{
((crc32Packet)packet).context.Update(((crc32Packet)packet).data);
}
static void updateCRC64(object packet)
{
((crc64Packet)packet).context.Update(((crc64Packet)packet).data);
}
/*static void updateFletcher16(object packet)
{
((fletcher16Packet)packet).context.Update(((fletcher16Packet)packet).data);
}
static void updateFletcher32(object packet)
{
((fletcher32Packet)packet).context.Update(((fletcher32Packet)packet).data);
}*/
static void updateMD5(object packet)
{
((md5Packet)packet).context.Update(((md5Packet)packet).data);
}
static void updateRIPEMD160(object packet)
{
((ripemd160Packet)packet).context.Update(((ripemd160Packet)packet).data);
}
static void updateSHA1(object packet)
{
((sha1Packet)packet).context.Update(((sha1Packet)packet).data);
}
static void updateSHA256(object packet)
{
((sha256Packet)packet).context.Update(((sha256Packet)packet).data);
}
static void updateSHA384(object packet)
{
((sha384Packet)packet).context.Update(((sha384Packet)packet).data);
}
static void updateSHA512(object packet)
{
((sha512Packet)packet).context.Update(((sha512Packet)packet).data);
}
static void updateSpamSum(object packet)
{
((spamsumPacket)packet).context.Update(((spamsumPacket)packet).data);
}
#endregion Threading helpers
}
}

View File

@@ -58,10 +58,14 @@
</Compile>
<Compile Include="Commands\CreateSidecar.cs" />
<Compile Include="Commands\MediaScan.cs" />
<Compile Include="Commands\DumpMedia.cs" />
<Compile Include="Core\Checksum.cs" />
<Compile Include="Commands\DeviceReport.cs" />
</ItemGroup>
<Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Folder Include="Commands\" />
<Folder Include="Core\" />
</ItemGroup>
<ProjectExtensions>
<MonoDevelop>

View File

@@ -186,6 +186,22 @@ namespace DiscImageChef
DicConsole.VerboseWriteLineEvent += System.Console.WriteLine;
Commands.MediaScan.doMediaScan(MediaScanOptions);
break;
case "dump-media":
DumpMediaSubOptions DumpMediaOptions = (DumpMediaSubOptions)invokedVerbInstance;
if (DumpMediaOptions.Debug)
DicConsole.DebugWriteLineEvent += System.Console.Error.WriteLine;
if (DumpMediaOptions.Verbose)
DicConsole.VerboseWriteLineEvent += System.Console.WriteLine;
Commands.DumpMedia.doDumpMedia(DumpMediaOptions);
break;
case "device-report":
DeviceReportSubOptions DeviceReportOptions = (DeviceReportSubOptions)invokedVerbInstance;
if (DeviceReportOptions.Debug)
DicConsole.DebugWriteLineEvent += System.Console.Error.WriteLine;
if (DeviceReportOptions.Verbose)
DicConsole.VerboseWriteLineEvent += System.Console.WriteLine;
Commands.DeviceReport.doDeviceReport(DeviceReportOptions);
break;
default:
throw new ArgumentException("Should never arrive here!");
}

View File

@@ -239,6 +239,9 @@ namespace DiscImageChef
[Option('m', "mhdd-log", Required = false, DefaultValue = "", HelpText = "Write a log of the scan in the format used by MHDD.")]
public string MHDDLogPath { get; set; }
[Option('b', "ibg-log", Required = false, DefaultValue = "", HelpText = "Write a log of the scan in the format used by ImgBurn.")]
public string IBGLogPath { get; set; }
}
public class FormatsSubOptions : CommonSubOptions
@@ -260,6 +263,38 @@ namespace DiscImageChef
public string InputFile { get; set; }
}
// TODO: Add more options
public class DumpMediaSubOptions : CommonSubOptions
{
[Option('i', "device", Required = true, HelpText = "Device path.")]
public string DevicePath { get; set; }
[Option('w', "output-prefix", Required = true, HelpText = "Prefix for media dump.")]
public string OutputPrefix { get; set; }
[Option('r', "raw", DefaultValue = false,
HelpText = "Print sectors with tags included.")]
public bool Raw { get; set; }
[Option('s', "stop-on-error", DefaultValue = false,
HelpText = "Print sectors with tags included.")]
public bool StopOnError { get; set; }
[Option('f', "force", DefaultValue = false,
HelpText = "Continue dump whatever happens.")]
public bool Force { get; set; }
[Option("reset", DefaultValue = (ushort)0,
HelpText = "Reset the device after these many errors. 0 to disable.")]
public ushort Reset { get; set; }
}
public class DeviceReportSubOptions : CommonSubOptions
{
[Option('i', "device", Required = true, HelpText = "Device path.")]
public string DevicePath { get; set; }
}
public class Options
{
public Options()
@@ -277,6 +312,8 @@ namespace DiscImageChef
BenchmarkVerb = new BenchmarkSubOptions();
CreateSidecarVerb = new CreateSidecarSubOptions();
MediaScanVerb = new MediaScanSubOptions();
DumpMediaVerb = new DumpMediaSubOptions();
DeviceReportVerb = new DeviceReportSubOptions();
}
[VerbOption("analyze", HelpText = "Analyzes a disc image and searches for partitions and/or filesystems.")]
@@ -318,6 +355,12 @@ namespace DiscImageChef
[VerbOption("media-scan", HelpText = "Scans the media inserted on a device.")]
public MediaScanSubOptions MediaScanVerb { get; set; }
[VerbOption("dump-media", HelpText = "Dumps the media inserted on a device to a media image.")]
public DumpMediaSubOptions DumpMediaVerb { get; set; }
[VerbOption("device-report", HelpText = "Tests the device capabilities and creates an XML report of them.")]
public DeviceReportSubOptions DeviceReportVerb { get; set; }
[HelpVerbOption]
public string DoHelpForVerb(string verbName)
{