public DeviceInfo(Device dev)
{
Type = dev.Type;
Manufacturer = dev.Manufacturer;
Model = dev.Model;
Revision = dev.Revision;
Serial = dev.Serial;
ScsiType = dev.ScsiType;
IsRemovable = dev.IsRemovable;
IsUsb = dev.IsUsb;
UsbVendorId = dev.UsbVendorId;
UsbProductId = dev.UsbProductId;
UsbDescriptors = dev.UsbDescriptors;
UsbManufacturerString = dev.UsbManufacturerString;
UsbProductString = dev.UsbProductString;
UsbSerialString = dev.UsbSerialString;
IsFireWire = dev.IsFireWire;
FireWireGuid = dev.FireWireGuid;
FireWireModel = dev.FireWireModel;
FireWireModelName = dev.FireWireModelName;
FireWireVendor = dev.FireWireVendor;
FireWireVendorName = dev.FireWireVendorName;
IsCompactFlash = dev.IsCompactFlash;
IsPcmcia = dev.IsPcmcia;
Cis = dev.Cis;
switch (dev.Type)
{
case DeviceType.ATA:
{
bool sense = dev.AtaIdentify(out byte[] ataBuf, out AtaErrorRegistersChs errorRegisters);
if (sense)
{
DicConsole.DebugWriteLine("Device-Info command", "STATUS = 0x{0:X2}", errorRegisters.Status);
DicConsole.DebugWriteLine("Device-Info command", "ERROR = 0x{0:X2}", errorRegisters.Error);
DicConsole.DebugWriteLine("Device-Info command", "NSECTOR = 0x{0:X2}",
errorRegisters.SectorCount);
DicConsole.DebugWriteLine("Device-Info command", "SECTOR = 0x{0:X2}", errorRegisters.Sector);
DicConsole.DebugWriteLine("Device-Info command", "CYLHIGH = 0x{0:X2}",
errorRegisters.CylinderHigh);
DicConsole.DebugWriteLine("Device-Info command", "CYLLOW = 0x{0:X2}",
errorRegisters.CylinderLow);
DicConsole.DebugWriteLine("Device-Info command", "DEVICE = 0x{0:X2}",
errorRegisters.DeviceHead);
DicConsole.DebugWriteLine("Device-Info command", "Error code = {0}", dev.LastError);
break;
}
if (dev.Error)
{
DicConsole.ErrorWriteLine("Error {0} querying ATA IDENTIFY", dev.LastError);
break;
}
AtaIdentify = ataBuf;
dev.EnableMediaCardPassThrough(out errorRegisters, dev.Timeout, out _);
if (errorRegisters.Sector == 0xAA && errorRegisters.SectorCount == 0x55)
{
AtaMcptError = errorRegisters;
}
break;
}
case DeviceType.ATAPI:
{
bool sense = dev.AtapiIdentify(out byte[] ataBuf, out AtaErrorRegistersChs errorRegisters);
if (sense)
{
DicConsole.DebugWriteLine("Device-Info command", "STATUS = 0x{0:X2}", errorRegisters.Status);
DicConsole.DebugWriteLine("Device-Info command", "ERROR = 0x{0:X2}", errorRegisters.Error);
DicConsole.DebugWriteLine("Device-Info command", "NSECTOR = 0x{0:X2}",
errorRegisters.SectorCount);
DicConsole.DebugWriteLine("Device-Info command", "SECTOR = 0x{0:X2}", errorRegisters.Sector);
DicConsole.DebugWriteLine("Device-Info command", "CYLHIGH = 0x{0:X2}",
errorRegisters.CylinderHigh);
DicConsole.DebugWriteLine("Device-Info command", "CYLLOW = 0x{0:X2}",
errorRegisters.CylinderLow);
DicConsole.DebugWriteLine("Device-Info command", "DEVICE = 0x{0:X2}",
errorRegisters.DeviceHead);
DicConsole.DebugWriteLine("Device-Info command", "Error code = {0}", dev.LastError);
break;
}
if (!dev.Error)
{
AtapiIdentify = ataBuf;
}
else
{
DicConsole.ErrorWriteLine("Error {0} querying ATA PACKET IDENTIFY", dev.LastError);
}
// ATAPI devices are also SCSI devices
goto case DeviceType.SCSI;
}
case DeviceType.SCSI:
{
bool sense = dev.ScsiInquiry(out byte[] inqBuf, out byte[] senseBuf);
if (sense)
{
DicConsole.ErrorWriteLine("SCSI error:\n{0}", Sense.PrettifySense(senseBuf));
break;
}
ScsiInquiryData = inqBuf;
ScsiInquiry = Inquiry.Decode(inqBuf);
sense = dev.ScsiInquiry(out inqBuf, out senseBuf, 0x00);
if (!sense)
{
ScsiEvpdPages = new Dictionary <byte, byte[]>();
byte[] pages = EVPD.DecodePage00(inqBuf);
if (pages != null)
{
foreach (byte page in pages)
{
sense = dev.ScsiInquiry(out inqBuf, out senseBuf, page);
if (sense)
{
continue;
}
ScsiEvpdPages.Add(page, inqBuf);
}
}
}
PeripheralDeviceTypes devType = (PeripheralDeviceTypes)ScsiInquiry.Value.PeripheralDeviceType;
sense = dev.ModeSense10(out byte[] modeBuf, out senseBuf, false, true,
ScsiModeSensePageControl.Current, 0x3F, 0xFF, 5, out _);
if (!sense && !dev.Error)
{
ScsiModeSense10 = modeBuf;
}
if (sense || dev.Error)
{
sense = dev.ModeSense10(out modeBuf, out senseBuf, false, true,
ScsiModeSensePageControl.Current, 0x3F, 0x00, 5, out _);
if (!sense && !dev.Error)
{
ScsiModeSense10 = modeBuf;
}
}
if (!sense && !dev.Error)
{
ScsiMode = Modes.DecodeMode10(modeBuf, devType);
}
bool useMode10 = !(sense || dev.Error || !ScsiMode.HasValue);
sense = dev.ModeSense6(out modeBuf, out senseBuf, false, ScsiModeSensePageControl.Current, 0x3F,
0xFF, 5, out _);
if (!sense && !dev.Error)
{
ScsiModeSense6 = modeBuf;
}
if (sense || dev.Error)
{
sense = dev.ModeSense6(out modeBuf, out senseBuf, false, ScsiModeSensePageControl.Current, 0x3F,
0x00, 5, out _);
if (!sense && !dev.Error)
{
ScsiModeSense6 = modeBuf;
}
}
if (sense || dev.Error)
{
sense = dev.ModeSense(out modeBuf, out senseBuf, 5, out _);
if (!sense && !dev.Error)
{
ScsiModeSense6 = modeBuf;
}
}
if (!sense && !dev.Error && !useMode10)
{
ScsiMode = Modes.DecodeMode6(modeBuf, devType);
}
switch (devType)
{
case PeripheralDeviceTypes.MultiMediaDevice:
{
sense = dev.GetConfiguration(out byte[] confBuf, out senseBuf, dev.Timeout, out _);
if (!sense)
{
MmcConfiguration = confBuf;
}
// TODO: DVD drives respond correctly to BD status.
// While specification says if no medium is present
// it should inform all possible capabilities,
// testing drives show only supported media capabilities.
/*
* byte[] strBuf;
* sense = dev.ReadDiscStructure(out strBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.CapabilityList, 0, dev.Timeout, out _);
*
* if (!sense)
* {
* Decoders.SCSI.DiscStructureCapabilities.Capability[] caps = Decoders.SCSI.DiscStructureCapabilities.Decode(strBuf);
* if (caps != null)
* {
* foreach (Decoders.SCSI.DiscStructureCapabilities.Capability cap in caps)
* {
* if (cap.SDS && cap.RDS)
* DicConsole.WriteLine("Drive can READ/SEND DISC STRUCTURE format {0:X2}h", cap.FormatCode);
* else if (cap.SDS)
* DicConsole.WriteLine("Drive can SEND DISC STRUCTURE format {0:X2}h", cap.FormatCode);
* else if (cap.RDS)
* DicConsole.WriteLine("Drive can READ DISC STRUCTURE format {0:X2}h", cap.FormatCode);
* }
* }
* }
*
* sense = dev.ReadDiscStructure(out strBuf, out senseBuf, MmcDiscStructureMediaType.BD, 0, 0, MmcDiscStructureFormat.CapabilityList, 0, dev.Timeout, out _);
*
* if (!sense)
* {
* Decoders.SCSI.DiscStructureCapabilities.Capability[] caps = Decoders.SCSI.DiscStructureCapabilities.Decode(strBuf);
* if (caps != null)
* {
* foreach (Decoders.SCSI.DiscStructureCapabilities.Capability cap in caps)
* {
* if (cap.SDS && cap.RDS)
* DicConsole.WriteLine("Drive can READ/SEND DISC STRUCTURE format {0:X2}h", cap.FormatCode);
* else if (cap.SDS)
* DicConsole.WriteLine("Drive can SEND DISC STRUCTURE format {0:X2}h", cap.FormatCode);
* else if (cap.RDS)
* DicConsole.WriteLine("Drive can READ DISC STRUCTURE format {0:X2}h", cap.FormatCode);
* }
* }
* }
*/
#region Plextor
if (dev.Manufacturer == "PLEXTOR")
{
bool plxtSense = true;
bool plxtDvd = false;
byte[] plxtBuf = null;
switch (dev.Model)
{
case "DVDR PX-708A":
case "DVDR PX-708A2":
case "DVDR PX-712A":
plxtDvd = true;
plxtSense = dev.PlextorReadEeprom(out plxtBuf, out senseBuf, dev.Timeout,
out _);
break;
case "DVDR PX-714A":
case "DVDR PX-716A":
case "DVDR PX-716AL":
case "DVDR PX-755A":
case "DVDR PX-760A":
{
plxtBuf = new byte[256 * 4];
for (byte i = 0; i < 4; i++)
{
plxtSense = dev.PlextorReadEepromBlock(out byte[] plxtBufSmall,
out senseBuf, i, 256, dev.Timeout,
out _);
if (plxtSense)
{
break;
}
Array.Copy(plxtBufSmall, 0, plxtBuf, i * 256, 256);
}
plxtDvd = true;
break;
}
default:
{
if (dev.Model.StartsWith("CD-R ", StringComparison.Ordinal))
{
plxtSense = dev.PlextorReadEepromCdr(out plxtBuf, out senseBuf, dev.Timeout,
out _);
}
break;
}
}
PlextorFeatures = new Plextor {
IsDvd = plxtDvd
};
if (!plxtSense)
{
PlextorFeatures.Eeprom = plxtBuf;
if (plxtDvd)
{
PlextorFeatures.Discs = BigEndianBitConverter.ToUInt16(plxtBuf, 0x0120);
PlextorFeatures.CdReadTime = BigEndianBitConverter.ToUInt32(plxtBuf, 0x0122);
PlextorFeatures.CdWriteTime = BigEndianBitConverter.ToUInt32(plxtBuf, 0x0126);
PlextorFeatures.DvdReadTime = BigEndianBitConverter.ToUInt32(plxtBuf, 0x012A);
PlextorFeatures.DvdWriteTime = BigEndianBitConverter.ToUInt32(plxtBuf, 0x012E);
}
else
{
PlextorFeatures.Discs = BigEndianBitConverter.ToUInt16(plxtBuf, 0x0078);
PlextorFeatures.CdReadTime = BigEndianBitConverter.ToUInt32(plxtBuf, 0x006C);
PlextorFeatures.CdWriteTime = BigEndianBitConverter.ToUInt32(plxtBuf, 0x007A);
}
}
plxtSense = dev.PlextorGetPoweRec(out senseBuf, out bool plxtPwrRecEnabled,
out ushort plxtPwrRecSpeed, dev.Timeout, out _);
if (!plxtSense)
{
PlextorFeatures.PoweRec = true;
if (plxtPwrRecEnabled)
{
PlextorFeatures.PoweRecEnabled = true;
PlextorFeatures.PoweRecRecommendedSpeed = plxtPwrRecSpeed;
plxtSense = dev.PlextorGetSpeeds(out senseBuf, out ushort plxtPwrRecSelected,
out ushort plxtPwrRecMax,
out ushort plxtPwrRecLast, dev.Timeout, out _);
if (!plxtSense)
{
PlextorFeatures.PoweRecSelected = plxtPwrRecSelected;
PlextorFeatures.PoweRecMax = plxtPwrRecMax;
PlextorFeatures.PoweRecLast = plxtPwrRecLast;
}
}
}
// TODO: Check it with a drive
plxtSense = dev.PlextorGetSilentMode(out plxtBuf, out senseBuf, dev.Timeout, out _);
if (!plxtSense)
{
if (plxtBuf[0] == 1)
{
PlextorFeatures.SilentModeEnabled = true;
PlextorFeatures.AccessTimeLimit = plxtBuf[1];
PlextorFeatures.CdReadSpeedLimit = plxtBuf[2];
PlextorFeatures.DvdReadSpeedLimit = plxtBuf[3];
PlextorFeatures.CdWriteSpeedLimit = plxtBuf[4];
// TODO: Check which one is each one
/*
* if(plxtBuf[6] > 0)
* DicConsole.WriteLine("\tTray eject speed limited to {0}",
* -(plxtBuf[6] + 48));
* if(plxtBuf[7] > 0)
* DicConsole.WriteLine("\tTray eject speed limited to {0}",
* plxtBuf[7] - 47);
*/
}
}
plxtSense = dev.PlextorGetGigaRec(out plxtBuf, out senseBuf, dev.Timeout, out _);
if (!plxtSense)
{
PlextorFeatures.GigaRec = true;
}
plxtSense = dev.PlextorGetSecuRec(out plxtBuf, out senseBuf, dev.Timeout, out _);
if (!plxtSense)
{
PlextorFeatures.SecuRec = true;
}
plxtSense = dev.PlextorGetSpeedRead(out plxtBuf, out senseBuf, dev.Timeout, out _);
if (!plxtSense)
{
PlextorFeatures.SpeedRead = true;
if ((plxtBuf[2] & 0x01) == 0x01)
{
PlextorFeatures.SpeedReadEnabled = true;
}
}
plxtSense = dev.PlextorGetHiding(out plxtBuf, out senseBuf, dev.Timeout, out _);
if (!plxtSense)
{
PlextorFeatures.Hiding = true;
if ((plxtBuf[2] & 0x02) == 0x02)
{
PlextorFeatures.HidesRecordables = true;
}
if ((plxtBuf[2] & 0x01) == 0x01)
{
PlextorFeatures.HidesSessions = true;
}
}
plxtSense = dev.PlextorGetVariRec(out plxtBuf, out senseBuf, false, dev.Timeout, out _);
if (!plxtSense)
{
PlextorFeatures.VariRec = true;
}
if (plxtDvd)
{
plxtSense = dev.PlextorGetVariRec(out plxtBuf, out senseBuf, true, dev.Timeout,
out _);
if (!plxtSense)
{
PlextorFeatures.VariRecDvd = true;
}
plxtSense = dev.PlextorGetBitsetting(out plxtBuf, out senseBuf, false, dev.Timeout,
out _);
if (!plxtSense)
{
PlextorFeatures.BitSetting = true;
}
plxtSense = dev.PlextorGetBitsetting(out plxtBuf, out senseBuf, true, dev.Timeout,
out _);
if (!plxtSense)
{
PlextorFeatures.BitSettingDl = true;
}
plxtSense = dev.PlextorGetTestWriteDvdPlus(out plxtBuf, out senseBuf, dev.Timeout,
out _);
if (!plxtSense)
{
PlextorFeatures.DvdPlusWriteTest = true;
}
}
}
#endregion Plextor
if (ScsiInquiry.Value.KreonPresent)
{
if (!dev.KreonGetFeatureList(out senseBuf, out KreonFeatures krFeatures, dev.Timeout,
out _))
{
KreonFeatures = krFeatures;
}
}
break;
}
case PeripheralDeviceTypes.SequentialAccess:
{
sense = dev.ReadBlockLimits(out byte[] seqBuf, out senseBuf, dev.Timeout, out _);
if (sense)
{
DicConsole.ErrorWriteLine("READ BLOCK LIMITS:\n{0}", Sense.PrettifySense(senseBuf));
}
else
{
BlockLimits = seqBuf;
}
sense = dev.ReportDensitySupport(out seqBuf, out senseBuf, dev.Timeout, out _);
if (sense)
{
DicConsole.ErrorWriteLine("REPORT DENSITY SUPPORT:\n{0}",
Sense.PrettifySense(senseBuf));
}
else
{
DensitySupport = seqBuf;
DensitySupportHeader = Decoders.SCSI.SSC.DensitySupport.DecodeDensity(seqBuf);
}
sense = dev.ReportDensitySupport(out seqBuf, out senseBuf, true, false, dev.Timeout, out _);
if (sense)
{
DicConsole.ErrorWriteLine("REPORT DENSITY SUPPORT (MEDIUM):\n{0}",
Sense.PrettifySense(senseBuf));
}
else
{
MediumDensitySupport = seqBuf;
MediaTypeSupportHeader = Decoders.SCSI.SSC.DensitySupport.DecodeMediumType(seqBuf);
}
break;
}
}
break;
}
case DeviceType.MMC:
{
bool sense = dev.ReadCid(out byte[] mmcBuf, out _, dev.Timeout, out _);
if (!sense)
{
CID = mmcBuf;
}
sense = dev.ReadCsd(out mmcBuf, out _, dev.Timeout, out _);
if (!sense)
{
CSD = mmcBuf;
}
sense = dev.ReadOcr(out mmcBuf, out _, dev.Timeout, out _);
if (!sense)
{
OCR = mmcBuf;
}
sense = dev.ReadExtendedCsd(out mmcBuf, out _, dev.Timeout, out _);
if (!sense)
{
ExtendedCSD = mmcBuf;
}
}
break;
case DeviceType.SecureDigital:
{
bool sense = dev.ReadCid(out byte[] sdBuf, out _, dev.Timeout, out _);
if (!sense)
{
CID = sdBuf;
}
sense = dev.ReadCsd(out sdBuf, out _, dev.Timeout, out _);
if (!sense)
{
CSD = sdBuf;
}
sense = dev.ReadSdocr(out sdBuf, out _, dev.Timeout, out _);
if (!sense)
{
OCR = sdBuf;
}
sense = dev.ReadScr(out sdBuf, out _, dev.Timeout, out _);
if (!sense)
{
SCR = sdBuf;
}
}
break;
default:
DicConsole.ErrorWriteLine("Unknown device type {0}, cannot get information.", dev.Type);
break;
}
}
/// <summary>Dumps an optical disc</summary>
void Mmc()
{
MediaType dskType = MediaType.Unknown;
bool sense;
byte[] tmpBuf;
bool compactDisc = true;
bool isXbox = false;
_speedMultiplier = 1;
// TODO: Log not only what is it reading, but if it was read correctly or not.
sense = _dev.GetConfiguration(out byte[] cmdBuf, out _, 0, MmcGetConfigurationRt.Current, _dev.Timeout,
out _);
if (!sense)
{
Features.SeparatedFeatures ftr = Features.Separate(cmdBuf);
_dumpLog.WriteLine("Device reports current profile is 0x{0:X4}", ftr.CurrentProfile);
switch (ftr.CurrentProfile)
{
case 0x0001:
dskType = MediaType.GENERIC_HDD;
_speedMultiplier = -1;
goto default;
case 0x0002:
dskType = MediaType.PD650;
_speedMultiplier = -1;
goto default;
case 0x0005:
dskType = MediaType.CDMO;
break;
case 0x0008:
dskType = MediaType.CD;
break;
case 0x0009:
dskType = MediaType.CDR;
break;
case 0x000A:
dskType = MediaType.CDRW;
break;
case 0x0010:
dskType = MediaType.DVDROM;
_speedMultiplier = 9;
goto default;
case 0x0011:
dskType = MediaType.DVDR;
_speedMultiplier = 9;
goto default;
case 0x0012:
dskType = MediaType.DVDRAM;
_speedMultiplier = 9;
goto default;
case 0x0013:
case 0x0014:
dskType = MediaType.DVDRW;
_speedMultiplier = 9;
goto default;
case 0x0015:
case 0x0016:
dskType = MediaType.DVDRDL;
_speedMultiplier = 9;
goto default;
case 0x0017:
dskType = MediaType.DVDRWDL;
_speedMultiplier = 9;
goto default;
case 0x0018:
dskType = MediaType.DVDDownload;
_speedMultiplier = 9;
goto default;
case 0x001A:
dskType = MediaType.DVDPRW;
_speedMultiplier = 9;
goto default;
case 0x001B:
dskType = MediaType.DVDPR;
_speedMultiplier = 9;
goto default;
case 0x0020:
dskType = MediaType.DDCD;
goto default;
case 0x0021:
dskType = MediaType.DDCDR;
goto default;
case 0x0022:
dskType = MediaType.DDCDRW;
goto default;
case 0x002A:
dskType = MediaType.DVDPRWDL;
_speedMultiplier = 9;
goto default;
case 0x002B:
dskType = MediaType.DVDPRDL;
_speedMultiplier = 9;
goto default;
case 0x0040:
dskType = MediaType.BDROM;
_speedMultiplier = 30;
goto default;
case 0x0041:
case 0x0042:
dskType = MediaType.BDR;
_speedMultiplier = 30;
goto default;
case 0x0043:
dskType = MediaType.BDRE;
_speedMultiplier = 30;
goto default;
case 0x0050:
dskType = MediaType.HDDVDROM;
_speedMultiplier = 30;
goto default;
case 0x0051:
dskType = MediaType.HDDVDR;
_speedMultiplier = 30;
goto default;
case 0x0052:
dskType = MediaType.HDDVDRAM;
_speedMultiplier = 30;
goto default;
case 0x0053:
dskType = MediaType.HDDVDRW;
_speedMultiplier = 30;
goto default;
case 0x0058:
dskType = MediaType.HDDVDRDL;
_speedMultiplier = 30;
goto default;
case 0x005A:
dskType = MediaType.HDDVDRWDL;
_speedMultiplier = 30;
goto default;
default:
compactDisc = false;
break;
}
}
if (compactDisc)
{
_speedMultiplier *= 177;
CompactDisc();
return;
}
_speedMultiplier *= 150;
var scsiReader = new Reader(_dev, _dev.Timeout, null, _errorLog, _dumpRaw);
ulong blocks = scsiReader.GetDeviceBlocks();
_dumpLog.WriteLine("Device reports disc has {0} blocks", blocks);
Dictionary <MediaTagType, byte[]> mediaTags = new Dictionary <MediaTagType, byte[]>();
if (dskType == MediaType.PD650)
{
switch (blocks + 1)
{
case 1281856:
dskType = MediaType.PD650_WORM;
break;
case 58620544:
dskType = MediaType.REV120;
break;
case 17090880:
dskType = MediaType.REV35;
break;
// TODO: Unknown value
default:
dskType = MediaType.REV70;
break;
}
}
#region Nintendo
switch (dskType)
{
case MediaType.Unknown when blocks > 0:
_dumpLog.WriteLine("Reading Physical Format Information");
sense = _dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.PhysicalInformation, 0, _dev.Timeout, out _);
if (!sense)
{
PFI.PhysicalFormatInformation?nintendoPfi = PFI.Decode(cmdBuf);
if (nintendoPfi?.DiskCategory == DiskCategory.Nintendo &&
nintendoPfi.Value.PartVersion == 15)
{
_dumpLog.WriteLine("Dumping Nintendo GameCube or Wii discs is not yet implemented.");
StoppingErrorMessage?.
Invoke("Dumping Nintendo GameCube or Wii discs is not yet implemented.");
return;
}
}
break;
case MediaType.DVDDownload:
case MediaType.DVDPR:
case MediaType.DVDPRDL:
case MediaType.DVDPRW:
case MediaType.DVDPRWDL:
case MediaType.DVDR:
case MediaType.DVDRAM:
case MediaType.DVDRDL:
case MediaType.DVDROM:
case MediaType.DVDRW:
case MediaType.DVDRWDL:
case MediaType.HDDVDR:
case MediaType.HDDVDRAM:
case MediaType.HDDVDRDL:
case MediaType.HDDVDROM:
case MediaType.HDDVDRW:
case MediaType.HDDVDRWDL:
_dumpLog.WriteLine("Reading Physical Format Information");
sense = _dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.PhysicalInformation, 0, _dev.Timeout, out _);
if (!sense)
{
if (PFI.Decode(cmdBuf).HasValue)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.DVD_PFI, tmpBuf);
PFI.PhysicalFormatInformation decPfi = PFI.Decode(cmdBuf).Value;
UpdateStatus?.Invoke($"PFI:\n{PFI.Prettify(decPfi)}");
// False book types
if (dskType == MediaType.DVDROM)
{
switch (decPfi.DiskCategory)
{
case DiskCategory.DVDPR:
dskType = MediaType.DVDPR;
break;
case DiskCategory.DVDPRDL:
dskType = MediaType.DVDPRDL;
break;
case DiskCategory.DVDPRW:
dskType = MediaType.DVDPRW;
break;
case DiskCategory.DVDPRWDL:
dskType = MediaType.DVDPRWDL;
break;
case DiskCategory.DVDR:
dskType = decPfi.PartVersion == 6 ? MediaType.DVDRDL : MediaType.DVDR;
break;
case DiskCategory.DVDRAM:
dskType = MediaType.DVDRAM;
break;
default:
dskType = MediaType.DVDROM;
break;
case DiskCategory.DVDRW:
dskType = decPfi.PartVersion == 3 ? MediaType.DVDRWDL : MediaType.DVDRW;
break;
case DiskCategory.HDDVDR:
dskType = MediaType.HDDVDR;
break;
case DiskCategory.HDDVDRAM:
dskType = MediaType.HDDVDRAM;
break;
case DiskCategory.HDDVDROM:
dskType = MediaType.HDDVDROM;
break;
case DiskCategory.HDDVDRW:
dskType = MediaType.HDDVDRW;
break;
case DiskCategory.Nintendo:
dskType = decPfi.DiscSize == DVDSize.Eighty ? MediaType.GOD : MediaType.WOD;
break;
case DiskCategory.UMD:
dskType = MediaType.UMD;
break;
}
}
}
}
_dumpLog.WriteLine("Reading Disc Manufacturing Information");
sense = _dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.DiscManufacturingInformation, 0, _dev.Timeout,
out _);
if (!sense)
{
if (DMI.IsXbox(cmdBuf) ||
DMI.IsXbox360(cmdBuf))
{
if (DMI.IsXbox(cmdBuf))
{
dskType = MediaType.XGD;
}
else if (DMI.IsXbox360(cmdBuf))
{
dskType = MediaType.XGD2;
// All XGD3 all have the same number of blocks
if (blocks == 25063 || // Locked (or non compatible drive)
blocks == 4229664 || // Xtreme unlock
blocks == 4246304) // Wxripper unlock
{
dskType = MediaType.XGD3;
}
}
sense = _dev.ScsiInquiry(out byte[] inqBuf, out _);
if (sense ||
!Inquiry.Decode(inqBuf).HasValue ||
(Inquiry.Decode(inqBuf).HasValue&& !Inquiry.Decode(inqBuf).Value.KreonPresent))
{
_dumpLog.WriteLine("Dumping Xbox Game Discs requires a drive with Kreon firmware.");
StoppingErrorMessage?.
Invoke("Dumping Xbox Game Discs requires a drive with Kreon firmware.");
return;
}
if (_dumpRaw && !_force)
{
StoppingErrorMessage?.
Invoke("Not continuing. If you want to continue reading cooked data when raw is not available use the force option.");
// TODO: Exit more gracefully
return;
}
isXbox = true;
}
if (cmdBuf.Length == 2052)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.DVD_DMI, tmpBuf);
}
}
break;
}
#endregion Nintendo
#region All DVD and HD DVD types
#endregion All DVD and HD DVD types
#region DVD-ROM
if (dskType == MediaType.DVDDownload ||
dskType == MediaType.DVDROM)
{
_dumpLog.WriteLine("Reading Lead-in Copyright Information.");
sense = _dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.CopyrightInformation, 0, _dev.Timeout, out _);
if (!sense)
{
if (CSS_CPRM.DecodeLeadInCopyright(cmdBuf).HasValue)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.DVD_CMI, tmpBuf);
}
}
}
#endregion DVD-ROM
switch (dskType)
{
#region DVD-ROM and HD DVD-ROM
case MediaType.DVDDownload:
case MediaType.DVDROM:
case MediaType.HDDVDROM:
_dumpLog.WriteLine("Reading Burst Cutting Area.");
sense = _dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.BurstCuttingArea, 0, _dev.Timeout, out _);
if (!sense)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.DVD_BCA, tmpBuf);
}
break;
#endregion DVD-ROM and HD DVD-ROM
#region DVD-RAM and HD DVD-RAM
case MediaType.DVDRAM:
case MediaType.HDDVDRAM:
_dumpLog.WriteLine("Reading Disc Description Structure.");
sense = _dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.DvdramDds, 0, _dev.Timeout, out _);
if (!sense)
{
if (DDS.Decode(cmdBuf).HasValue)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.DVDRAM_DDS, tmpBuf);
}
}
_dumpLog.WriteLine("Reading Spare Area Information.");
sense = _dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.DvdramSpareAreaInformation, 0, _dev.Timeout,
out _);
if (!sense)
{
if (Spare.Decode(cmdBuf).HasValue)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.DVDRAM_SpareArea, tmpBuf);
}
}
break;
#endregion DVD-RAM and HD DVD-RAM
#region DVD-R and DVD-RW
case MediaType.DVDR:
case MediaType.DVDRW:
_dumpLog.WriteLine("Reading Pre-Recorded Information.");
sense = _dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.PreRecordedInfo, 0, _dev.Timeout, out _);
if (!sense)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.DVDR_PreRecordedInfo, tmpBuf);
}
break;
#endregion DVD-R and DVD-RW
}
switch (dskType)
{
#region DVD-R, DVD-RW and HD DVD-R
case MediaType.DVDR:
case MediaType.DVDRW:
case MediaType.HDDVDR:
_dumpLog.WriteLine("Reading Media Identifier.");
sense = _dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.DvdrMediaIdentifier, 0, _dev.Timeout, out _);
if (!sense)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.DVDR_MediaIdentifier, tmpBuf);
}
_dumpLog.WriteLine("Reading Recordable Physical Information.");
sense = _dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.DvdrPhysicalInformation, 0, _dev.Timeout,
out _);
if (!sense)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.DVDR_PFI, tmpBuf);
}
break;
#endregion DVD-R, DVD-RW and HD DVD-R
#region All DVD+
case MediaType.DVDPR:
case MediaType.DVDPRDL:
case MediaType.DVDPRW:
case MediaType.DVDPRWDL:
_dumpLog.WriteLine("Reading ADdress In Pregroove.");
sense = _dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.Adip, 0, _dev.Timeout, out _);
if (!sense)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.DVD_ADIP, tmpBuf);
}
_dumpLog.WriteLine("Reading Disc Control Blocks.");
sense = _dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.Dcb, 0, _dev.Timeout, out _);
if (!sense)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.DCB, tmpBuf);
}
break;
#endregion All DVD+
#region HD DVD-ROM
case MediaType.HDDVDROM:
_dumpLog.WriteLine("Reading Lead-in Copyright Information.");
sense = _dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.HddvdCopyrightInformation, 0, _dev.Timeout,
out _);
if (!sense)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.HDDVD_CPI, tmpBuf);
}
break;
#endregion HD DVD-ROM
#region All Blu-ray
case MediaType.BDR:
case MediaType.BDRE:
case MediaType.BDROM:
case MediaType.BDRXL:
case MediaType.BDREXL:
_dumpLog.WriteLine("Reading Disc Information.");
sense = _dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Bd, 0, 0,
MmcDiscStructureFormat.DiscInformation, 0, _dev.Timeout, out _);
if (!sense)
{
if (DI.Decode(cmdBuf).HasValue)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.BD_DI, tmpBuf);
}
}
// TODO: PAC
/*
* dumpLog.WriteLine("Reading PAC.");
* sense = dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Bd, 0, 0,
* MmcDiscStructureFormat.Pac, 0, dev.Timeout, out _);
* if(!sense)
* {
* tmpBuf = new byte[cmdBuf.Length - 4];
* Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
* mediaTags.Add(MediaTagType.PAC, tmpBuf);
* }*/
break;
#endregion All Blu-ray
}
switch (dskType)
{
#region BD-ROM only
case MediaType.BDROM:
_dumpLog.WriteLine("Reading Burst Cutting Area.");
sense = _dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Bd, 0, 0,
MmcDiscStructureFormat.BdBurstCuttingArea, 0, _dev.Timeout, out _);
if (!sense)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.BD_BCA, tmpBuf);
}
break;
#endregion BD-ROM only
#region Writable Blu-ray only
case MediaType.BDR:
case MediaType.BDRE:
case MediaType.BDRXL:
case MediaType.BDREXL:
_dumpLog.WriteLine("Reading Disc Definition Structure.");
sense = _dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Bd, 0, 0,
MmcDiscStructureFormat.BdDds, 0, _dev.Timeout, out _);
if (!sense)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.BD_DDS, tmpBuf);
}
_dumpLog.WriteLine("Reading Spare Area Information.");
sense = _dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Bd, 0, 0,
MmcDiscStructureFormat.BdSpareAreaInformation, 0, _dev.Timeout,
out _);
if (!sense)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.BD_SpareArea, tmpBuf);
}
break;
#endregion Writable Blu-ray only
}
if (isXbox)
{
Xgd(mediaTags, dskType);
return;
}
Sbc(mediaTags, dskType, true);
}
/// <summary>Gets a list of all known storage devices on FreeBSD</summary>
/// <returns>List of devices</returns>
internal static DeviceInfo[] GetList()
{
string[] passDevices = Directory.GetFiles("/dev/", "pass*", SearchOption.TopDirectoryOnly);
List <DeviceInfo> listDevices = new List <DeviceInfo>();
foreach (string passDevice in passDevices)
{
var deviceInfo = new DeviceInfo();
IntPtr dev = cam_open_device(passDevice, FileFlags.ReadWrite);
var camDevice = (CamDevice)Marshal.PtrToStructure(dev, typeof(CamDevice));
IntPtr ccbPtr = cam_getccb(dev);
if (ccbPtr.ToInt64() == 0)
{
continue;
}
var cgd = (CcbGetdev)Marshal.PtrToStructure(ccbPtr, typeof(CcbGetdev));
cgd.ccb_h.func_code = XptOpcode.XptGdevType;
Marshal.StructureToPtr(cgd, ccbPtr, false);
int error = cam_send_ccb(dev, ccbPtr);
if (error < 0)
{
cam_freeccb(ccbPtr);
continue;
}
cgd = (CcbGetdev)Marshal.PtrToStructure(ccbPtr, typeof(CcbGetdev));
cam_freeccb(ccbPtr);
cam_close_device(dev);
string simName = StringHandlers.CToString(camDevice.SimName);
deviceInfo.Path = passDevice;
byte[] serialNumber = new byte[camDevice.SerialNumLen];
Array.Copy(camDevice.SerialNum, 0, serialNumber, 0, serialNumber.Length);
deviceInfo.Serial = StringHandlers.CToString(serialNumber);
switch (cgd.protocol)
{
case CamProto.ProtoAta:
case CamProto.ProtoAtapi:
case CamProto.ProtoSatapm:
{
// Little-endian FreeBSD gives it resorted
// Big-endian FreeBSD, no idea
byte[] atadTneid = new byte[512];
for (int aIndex = 0; aIndex < 512; aIndex += 2)
{
atadTneid[aIndex] = cgd.ident_data[aIndex + 1];
atadTneid[aIndex + 1] = cgd.ident_data[aIndex];
}
Identify.IdentifyDevice?idt = Identify.Decode(atadTneid);
if (idt.HasValue)
{
string[] separated = idt.Value.Model.Split(' ');
if (separated.Length == 1)
{
deviceInfo.Vendor = "ATA";
deviceInfo.Model = separated[0];
}
else
{
deviceInfo.Vendor = separated[0];
deviceInfo.Model = separated[separated.Length - 1];
}
deviceInfo.Serial = idt.Value.SerialNumber;
deviceInfo.Bus = simName == "ahcich" ? "SATA" : "ATA";
deviceInfo.Supported = simName != "ata";
}
if (cgd.protocol == CamProto.ProtoAtapi)
{
goto case CamProto.ProtoScsi;
}
break;
}
case CamProto.ProtoScsi:
{
Inquiry?inq = Inquiry.Decode(cgd.inq_data);
if (inq.HasValue)
{
deviceInfo.Vendor = StringHandlers.CToString(inq.Value.VendorIdentification).Trim();
deviceInfo.Model = StringHandlers.CToString(inq.Value.ProductIdentification).Trim();
deviceInfo.Bus = simName == "ata" || simName == "ahcich" ? "ATAPI" : "SCSI";
deviceInfo.Supported = simName != "ata";
}
break;
}
case CamProto.ProtoNvme:
deviceInfo.Bus = "NVMe";
deviceInfo.Supported = false;
break;
case CamProto.ProtoMmcsd:
deviceInfo.Model = "Unknown card";
deviceInfo.Bus = "MMC/SD";
deviceInfo.Supported = false;
break;
}
listDevices.Add(deviceInfo);
}
return(listDevices.Count > 0 ? listDevices.OrderBy(t => t.Path).ToArray() : null);
}
/// <summary>
/// Dumps an optical disc
/// </summary>
/// <param name="dev">Device</param>
/// <param name="devicePath">Path to the device</param>
/// <param name="outputPrefix">Prefix for output data files</param>
/// <param name="outputPlugin">Plugin for output file</param>
/// <param name="retryPasses">How many times to retry</param>
/// <param name="force">Force to continue dump whenever possible</param>
/// <param name="dumpRaw">Dump raw/long sectors</param>
/// <param name="persistent">Store whatever data the drive returned on error</param>
/// <param name="stopOnError">Stop dump on first error</param>
/// <param name="resume">Information for dump resuming</param>
/// <param name="dumpLog">Dump logger</param>
/// <param name="encoding">Encoding to use when analyzing dump</param>
/// <param name="dskType">Disc type as detected in MMC layer</param>
/// <param name="dumpLeadIn">Try to read and dump as much Lead-in as possible</param>
/// <param name="outputPath">Path to output file</param>
/// <param name="formatOptions">Formats to pass to output file plugin</param>
/// <exception cref="NotImplementedException">If trying to dump GOD or WOD, or XGDs without a Kreon drive</exception>
internal static void Dump(Device dev, string devicePath,
IWritableImage outputPlugin, ushort retryPasses,
bool force, bool dumpRaw,
bool persistent, bool stopOnError, ref MediaType dskType,
ref Resume resume, ref DumpLog dumpLog,
bool dumpLeadIn, Encoding encoding,
string outputPrefix, string outputPath,
Dictionary <string, string> formatOptions,
CICMMetadataType preSidecar, uint skip,
bool nometadata, bool notrim)
{
bool sense;
byte[] tmpBuf;
bool compactDisc = true;
bool isXbox = false;
// TODO: Log not only what is it reading, but if it was read correctly or not.
sense = dev.GetConfiguration(out byte[] cmdBuf, out _, 0, MmcGetConfigurationRt.Current, dev.Timeout,
out _);
if (!sense)
{
Features.SeparatedFeatures ftr = Features.Separate(cmdBuf);
dumpLog.WriteLine("Device reports current profile is 0x{0:X4}", ftr.CurrentProfile);
switch (ftr.CurrentProfile)
{
case 0x0001:
dskType = MediaType.GENERIC_HDD;
goto default;
case 0x0005:
dskType = MediaType.CDMO;
break;
case 0x0008:
dskType = MediaType.CD;
break;
case 0x0009:
dskType = MediaType.CDR;
break;
case 0x000A:
dskType = MediaType.CDRW;
break;
case 0x0010:
dskType = MediaType.DVDROM;
goto default;
case 0x0011:
dskType = MediaType.DVDR;
goto default;
case 0x0012:
dskType = MediaType.DVDRAM;
goto default;
case 0x0013:
case 0x0014:
dskType = MediaType.DVDRW;
goto default;
case 0x0015:
case 0x0016:
dskType = MediaType.DVDRDL;
goto default;
case 0x0017:
dskType = MediaType.DVDRWDL;
goto default;
case 0x0018:
dskType = MediaType.DVDDownload;
goto default;
case 0x001A:
dskType = MediaType.DVDPRW;
goto default;
case 0x001B:
dskType = MediaType.DVDPR;
goto default;
case 0x0020:
dskType = MediaType.DDCD;
goto default;
case 0x0021:
dskType = MediaType.DDCDR;
goto default;
case 0x0022:
dskType = MediaType.DDCDRW;
goto default;
case 0x002A:
dskType = MediaType.DVDPRWDL;
goto default;
case 0x002B:
dskType = MediaType.DVDPRDL;
goto default;
case 0x0040:
dskType = MediaType.BDROM;
goto default;
case 0x0041:
case 0x0042:
dskType = MediaType.BDR;
goto default;
case 0x0043:
dskType = MediaType.BDRE;
goto default;
case 0x0050:
dskType = MediaType.HDDVDROM;
goto default;
case 0x0051:
dskType = MediaType.HDDVDR;
goto default;
case 0x0052:
dskType = MediaType.HDDVDRAM;
goto default;
case 0x0053:
dskType = MediaType.HDDVDRW;
goto default;
case 0x0058:
dskType = MediaType.HDDVDRDL;
goto default;
case 0x005A:
dskType = MediaType.HDDVDRWDL;
goto default;
default:
compactDisc = false;
break;
}
}
if (compactDisc)
{
CompactDisc.Dump(dev, devicePath, outputPlugin, retryPasses, force, dumpRaw, persistent, stopOnError,
ref dskType, ref resume, ref dumpLog, dumpLeadIn, encoding, outputPrefix, outputPath,
formatOptions, preSidecar, skip, nometadata, notrim);
return;
}
Reader scsiReader = new Reader(dev, dev.Timeout, null, dumpRaw);
ulong blocks = scsiReader.GetDeviceBlocks();
dumpLog.WriteLine("Device reports disc has {0} blocks", blocks);
Dictionary <MediaTagType, byte[]> mediaTags = new Dictionary <MediaTagType, byte[]>();
#region Nintendo
switch (dskType)
{
case MediaType.Unknown when blocks > 0:
dumpLog.WriteLine("Reading Physical Format Information");
sense = dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.PhysicalInformation, 0, dev.Timeout, out _);
if (!sense)
{
PFI.PhysicalFormatInformation?nintendoPfi = PFI.Decode(cmdBuf);
if (nintendoPfi != null)
{
if (nintendoPfi.Value.DiskCategory == DiskCategory.Nintendo &&
nintendoPfi.Value.PartVersion == 15)
{
dumpLog.WriteLine("Dumping Nintendo GameCube or Wii discs is not yet implemented.");
throw new
NotImplementedException("Dumping Nintendo GameCube or Wii discs is not yet implemented.");
}
}
}
break;
case MediaType.DVDDownload:
case MediaType.DVDPR:
case MediaType.DVDPRDL:
case MediaType.DVDPRW:
case MediaType.DVDPRWDL:
case MediaType.DVDR:
case MediaType.DVDRAM:
case MediaType.DVDRDL:
case MediaType.DVDROM:
case MediaType.DVDRW:
case MediaType.DVDRWDL:
case MediaType.HDDVDR:
case MediaType.HDDVDRAM:
case MediaType.HDDVDRDL:
case MediaType.HDDVDROM:
case MediaType.HDDVDRW:
case MediaType.HDDVDRWDL:
dumpLog.WriteLine("Reading Physical Format Information");
sense = dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.PhysicalInformation, 0, dev.Timeout, out _);
if (!sense)
{
if (PFI.Decode(cmdBuf).HasValue)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.DVD_PFI, tmpBuf);
PFI.PhysicalFormatInformation decPfi = PFI.Decode(cmdBuf).Value;
DicConsole.WriteLine("PFI:\n{0}", PFI.Prettify(decPfi));
// False book types
if (dskType == MediaType.DVDROM)
{
switch (decPfi.DiskCategory)
{
case DiskCategory.DVDPR:
dskType = MediaType.DVDPR;
break;
case DiskCategory.DVDPRDL:
dskType = MediaType.DVDPRDL;
break;
case DiskCategory.DVDPRW:
dskType = MediaType.DVDPRW;
break;
case DiskCategory.DVDPRWDL:
dskType = MediaType.DVDPRWDL;
break;
case DiskCategory.DVDR:
dskType = decPfi.PartVersion == 6 ? MediaType.DVDRDL : MediaType.DVDR;
break;
case DiskCategory.DVDRAM:
dskType = MediaType.DVDRAM;
break;
default:
dskType = MediaType.DVDROM;
break;
case DiskCategory.DVDRW:
dskType = decPfi.PartVersion == 3 ? MediaType.DVDRWDL : MediaType.DVDRW;
break;
case DiskCategory.HDDVDR:
dskType = MediaType.HDDVDR;
break;
case DiskCategory.HDDVDRAM:
dskType = MediaType.HDDVDRAM;
break;
case DiskCategory.HDDVDROM:
dskType = MediaType.HDDVDROM;
break;
case DiskCategory.HDDVDRW:
dskType = MediaType.HDDVDRW;
break;
case DiskCategory.Nintendo:
dskType = decPfi.DiscSize == DVDSize.Eighty ? MediaType.GOD : MediaType.WOD;
break;
case DiskCategory.UMD:
dskType = MediaType.UMD;
break;
}
}
}
}
dumpLog.WriteLine("Reading Disc Manufacturing Information");
sense = dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.DiscManufacturingInformation, 0, dev.Timeout,
out _);
if (!sense)
{
if (DMI.IsXbox(cmdBuf) || DMI.IsXbox360(cmdBuf))
{
if (DMI.IsXbox(cmdBuf))
{
dskType = MediaType.XGD;
}
else if (DMI.IsXbox360(cmdBuf))
{
dskType = MediaType.XGD2;
// All XGD3 all have the same number of blocks
if (blocks == 25063 || // Locked (or non compatible drive)
blocks == 4229664 || // Xtreme unlock
blocks == 4246304) // Wxripper unlock
{
dskType = MediaType.XGD3;
}
}
sense = dev.ScsiInquiry(out byte[] inqBuf, out _);
if (sense || !Inquiry.Decode(inqBuf).HasValue || Inquiry.Decode(inqBuf).HasValue&&
!Inquiry.Decode(inqBuf).Value.KreonPresent)
{
dumpLog.WriteLine("Dumping Xbox Game Discs requires a drive with Kreon firmware.");
throw new
NotImplementedException("Dumping Xbox Game Discs requires a drive with Kreon firmware.");
}
if (dumpRaw && !force)
{
DicConsole
.ErrorWriteLine("Not continuing. If you want to continue reading cooked data when raw is not available use the force option.");
// TODO: Exit more gracefully
return;
}
isXbox = true;
}
if (cmdBuf.Length == 2052)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.DVD_DMI, tmpBuf);
}
}
break;
}
#endregion Nintendo
#region All DVD and HD DVD types
#endregion All DVD and HD DVD types
#region DVD-ROM
if (dskType == MediaType.DVDDownload || dskType == MediaType.DVDROM)
{
dumpLog.WriteLine("Reading Lead-in Copyright Information.");
sense = dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.CopyrightInformation, 0, dev.Timeout, out _);
if (!sense)
{
if (CSS_CPRM.DecodeLeadInCopyright(cmdBuf).HasValue)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.DVD_CMI, tmpBuf);
}
}
}
#endregion DVD-ROM
switch (dskType)
{
#region DVD-ROM and HD DVD-ROM
case MediaType.DVDDownload:
case MediaType.DVDROM:
case MediaType.HDDVDROM:
dumpLog.WriteLine("Reading Burst Cutting Area.");
sense = dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.BurstCuttingArea, 0, dev.Timeout, out _);
if (!sense)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.DVD_BCA, tmpBuf);
}
break;
#endregion DVD-ROM and HD DVD-ROM
#region DVD-RAM and HD DVD-RAM
case MediaType.DVDRAM:
case MediaType.HDDVDRAM:
dumpLog.WriteLine("Reading Disc Description Structure.");
sense = dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.DvdramDds, 0, dev.Timeout, out _);
if (!sense)
{
if (DDS.Decode(cmdBuf).HasValue)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.DVDRAM_DDS, tmpBuf);
}
}
dumpLog.WriteLine("Reading Spare Area Information.");
sense = dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.DvdramSpareAreaInformation, 0, dev.Timeout,
out _);
if (!sense)
{
if (Spare.Decode(cmdBuf).HasValue)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.DVDRAM_SpareArea, tmpBuf);
}
}
break;
#endregion DVD-RAM and HD DVD-RAM
#region DVD-R and DVD-RW
case MediaType.DVDR:
case MediaType.DVDRW:
dumpLog.WriteLine("Reading Pre-Recorded Information.");
sense = dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.PreRecordedInfo, 0, dev.Timeout, out _);
if (!sense)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.DVDR_PreRecordedInfo, tmpBuf);
}
break;
#endregion DVD-R and DVD-RW
}
switch (dskType)
{
#region DVD-R, DVD-RW and HD DVD-R
case MediaType.DVDR:
case MediaType.DVDRW:
case MediaType.HDDVDR:
dumpLog.WriteLine("Reading Media Identifier.");
sense = dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.DvdrMediaIdentifier, 0, dev.Timeout, out _);
if (!sense)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.DVDR_MediaIdentifier, tmpBuf);
}
dumpLog.WriteLine("Reading Recordable Physical Information.");
sense = dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.DvdrPhysicalInformation, 0, dev.Timeout,
out _);
if (!sense)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.DVDR_PFI, tmpBuf);
}
break;
#endregion DVD-R, DVD-RW and HD DVD-R
#region All DVD+
case MediaType.DVDPR:
case MediaType.DVDPRDL:
case MediaType.DVDPRW:
case MediaType.DVDPRWDL:
dumpLog.WriteLine("Reading ADdress In Pregroove.");
sense = dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.Adip, 0, dev.Timeout, out _);
if (!sense)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.DVD_ADIP, tmpBuf);
}
dumpLog.WriteLine("Reading Disc Control Blocks.");
sense = dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.Dcb, 0, dev.Timeout, out _);
if (!sense)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.DCB, tmpBuf);
}
break;
#endregion All DVD+
#region HD DVD-ROM
case MediaType.HDDVDROM:
dumpLog.WriteLine("Reading Lead-in Copyright Information.");
sense = dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.HddvdCopyrightInformation, 0, dev.Timeout,
out _);
if (!sense)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.HDDVD_CPI, tmpBuf);
}
break;
#endregion HD DVD-ROM
#region All Blu-ray
case MediaType.BDR:
case MediaType.BDRE:
case MediaType.BDROM:
case MediaType.BDRXL:
case MediaType.BDREXL:
dumpLog.WriteLine("Reading Disc Information.");
sense = dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Bd, 0, 0,
MmcDiscStructureFormat.DiscInformation, 0, dev.Timeout, out _);
if (!sense)
{
if (DI.Decode(cmdBuf).HasValue)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.BD_DI, tmpBuf);
}
}
// TODO: PAC
/*
* dumpLog.WriteLine("Reading PAC.");
* sense = dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Bd, 0, 0,
* MmcDiscStructureFormat.Pac, 0, dev.Timeout, out _);
* if(!sense)
* {
* tmpBuf = new byte[cmdBuf.Length - 4];
* Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
* mediaTags.Add(MediaTagType.PAC, tmpBuf);
* }*/
break;
#endregion All Blu-ray
}
switch (dskType)
{
#region BD-ROM only
case MediaType.BDROM:
dumpLog.WriteLine("Reading Burst Cutting Area.");
sense = dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Bd, 0, 0,
MmcDiscStructureFormat.BdBurstCuttingArea, 0, dev.Timeout, out _);
if (!sense)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.BD_BCA, tmpBuf);
}
break;
#endregion BD-ROM only
#region Writable Blu-ray only
case MediaType.BDR:
case MediaType.BDRE:
case MediaType.BDRXL:
case MediaType.BDREXL:
dumpLog.WriteLine("Reading Disc Definition Structure.");
sense = dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Bd, 0, 0,
MmcDiscStructureFormat.BdDds, 0, dev.Timeout, out _);
if (!sense)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.BD_DDS, tmpBuf);
}
dumpLog.WriteLine("Reading Spare Area Information.");
sense = dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Bd, 0, 0,
MmcDiscStructureFormat.BdSpareAreaInformation, 0, dev.Timeout, out _);
if (!sense)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.BD_SpareArea, tmpBuf);
}
break;
#endregion Writable Blu-ray only
}
if (isXbox)
{
Xgd.Dump(dev, devicePath, outputPlugin, retryPasses, force, dumpRaw, persistent, stopOnError, mediaTags,
ref dskType, ref resume, ref dumpLog, encoding, outputPrefix, outputPath, formatOptions,
preSidecar, skip, nometadata, notrim);
return;
}
Sbc.Dump(dev, devicePath, outputPlugin, retryPasses, force, dumpRaw, persistent, stopOnError, mediaTags,
ref dskType, true, ref resume, ref dumpLog, encoding, outputPrefix, outputPath, formatOptions,
preSidecar, skip, nometadata, notrim);
}
