mirror of
https://github.com/aaru-dps/Aaru.git
synced 2025-12-16 19:24:25 +00:00
1597 lines
78 KiB
C#
1597 lines
78 KiB
C#
// /***************************************************************************
|
|
// Aaru Data Preservation Suite
|
|
// ----------------------------------------------------------------------------
|
|
//
|
|
// Filename : DeviceReport.cs
|
|
// Author(s) : Natalia Portillo <claunia@claunia.com>
|
|
//
|
|
// Component : Commands.
|
|
//
|
|
// --[ Description ] ----------------------------------------------------------
|
|
//
|
|
// Implements the 'report' command.
|
|
//
|
|
// --[ 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 © 2011-2022 Natalia Portillo
|
|
// ****************************************************************************/
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.CommandLine;
|
|
using System.CommandLine.NamingConventionBinder;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Threading;
|
|
using Aaru.CommonTypes.Enums;
|
|
using Aaru.CommonTypes.Interop;
|
|
using Aaru.CommonTypes.Metadata;
|
|
using Aaru.CommonTypes.Structs.Devices.ATA;
|
|
using Aaru.CommonTypes.Structs.Devices.SCSI;
|
|
using Aaru.Console;
|
|
using Aaru.Core;
|
|
using Aaru.Database;
|
|
using Aaru.Database.Models;
|
|
using Aaru.Decoders.SCSI;
|
|
using Aaru.Decoders.SCSI.MMC;
|
|
using Aaru.Helpers;
|
|
using Aaru.Localization;
|
|
using Newtonsoft.Json;
|
|
using Spectre.Console;
|
|
using Command = System.CommandLine.Command;
|
|
using DeviceReport = Aaru.Core.Devices.Report.DeviceReport;
|
|
using Profile = Aaru.Decoders.SCSI.MMC.Profile;
|
|
|
|
namespace Aaru.Commands.Device;
|
|
|
|
sealed class DeviceReportCommand : Command
|
|
{
|
|
public DeviceReportCommand() : base("report", UI.Device_Report_Command_Description)
|
|
{
|
|
AddArgument(new Argument<string>
|
|
{
|
|
Arity = ArgumentArity.ExactlyOne,
|
|
Description = UI.Device_path,
|
|
Name = "device-path"
|
|
});
|
|
|
|
Add(new Option<bool>(new[]
|
|
{
|
|
"--trap-disc", "-t"
|
|
}, () => false, UI.Device_report_using_trap_disc));
|
|
|
|
Handler = CommandHandler.Create(GetType().GetMethod(nameof(Invoke)));
|
|
}
|
|
|
|
public static int Invoke(bool debug, bool verbose, string devicePath, bool trapDisc)
|
|
{
|
|
MainClass.PrintCopyright();
|
|
|
|
if(debug)
|
|
{
|
|
IAnsiConsole stderrConsole = AnsiConsole.Create(new AnsiConsoleSettings
|
|
{
|
|
Out = new AnsiConsoleOutput(System.Console.Error)
|
|
});
|
|
|
|
AaruConsole.DebugWriteLineEvent += (format, objects) =>
|
|
{
|
|
if(objects is null)
|
|
stderrConsole.MarkupLine(format);
|
|
else
|
|
stderrConsole.MarkupLine(format, objects);
|
|
};
|
|
}
|
|
|
|
if(verbose)
|
|
AaruConsole.WriteEvent += (format, objects) =>
|
|
{
|
|
if(objects is null)
|
|
AnsiConsole.Markup(format);
|
|
else
|
|
AnsiConsole.Markup(format, objects);
|
|
};
|
|
|
|
Statistics.AddCommand("device-report");
|
|
|
|
AaruConsole.DebugWriteLine("Device-Report command", "--debug={0}", debug);
|
|
AaruConsole.DebugWriteLine("Device-Report command", "--device={0}", devicePath);
|
|
AaruConsole.DebugWriteLine("Device-Report command", "--verbose={0}", verbose);
|
|
|
|
if(devicePath.Length == 2 &&
|
|
devicePath[1] == ':' &&
|
|
devicePath[0] != '/' &&
|
|
char.IsLetter(devicePath[0]))
|
|
devicePath = "\\\\.\\" + char.ToUpper(devicePath[0]) + ':';
|
|
|
|
var dev = Devices.Device.Create(devicePath, out ErrorNumber devErrno);
|
|
|
|
switch(dev)
|
|
{
|
|
case null:
|
|
AaruConsole.ErrorWriteLine(string.Format(UI.Could_not_open_device_error_0, devErrno));
|
|
|
|
return (int)devErrno;
|
|
case Devices.Remote.Device remoteDev:
|
|
Statistics.AddRemote(remoteDev.RemoteApplication, remoteDev.RemoteVersion,
|
|
remoteDev.RemoteOperatingSystem, remoteDev.RemoteOperatingSystemVersion,
|
|
remoteDev.RemoteArchitecture);
|
|
|
|
break;
|
|
}
|
|
|
|
if(dev.Error)
|
|
{
|
|
AaruConsole.ErrorWriteLine(Error.Print(dev.LastError));
|
|
|
|
return (int)ErrorNumber.CannotOpenDevice;
|
|
}
|
|
|
|
Statistics.AddDevice(dev);
|
|
|
|
bool isAdmin = dev is Devices.Remote.Device remoteDev2 ? remoteDev2.IsAdmin : DetectOS.IsAdmin;
|
|
|
|
if(!isAdmin)
|
|
{
|
|
AaruConsole.ErrorWriteLine(UI.Device_report_must_be_run_as_admin);
|
|
|
|
AaruConsole.ErrorWriteLine(UI.Not_continuing);
|
|
|
|
return (int)ErrorNumber.NotPermitted;
|
|
}
|
|
|
|
var report = new DeviceReportV2
|
|
{
|
|
Manufacturer = dev.Manufacturer,
|
|
Model = dev.Model,
|
|
Revision = dev.FirmwareRevision,
|
|
Type = dev.Type
|
|
};
|
|
|
|
bool removable = false;
|
|
string jsonFile;
|
|
|
|
switch(string.IsNullOrWhiteSpace(dev.Manufacturer))
|
|
{
|
|
case false when !string.IsNullOrWhiteSpace(dev.FirmwareRevision):
|
|
jsonFile = dev.Manufacturer + "_" + dev.Model + "_" + dev.FirmwareRevision + ".json";
|
|
|
|
break;
|
|
case false:
|
|
jsonFile = dev.Manufacturer + "_" + dev.Model + ".json";
|
|
|
|
break;
|
|
default:
|
|
{
|
|
if(!string.IsNullOrWhiteSpace(dev.FirmwareRevision))
|
|
jsonFile = dev.Model + "_" + dev.FirmwareRevision + ".json";
|
|
else
|
|
jsonFile = dev.Model + ".json";
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
jsonFile = jsonFile.Replace('\\', '_').Replace('/', '_').Replace('?', '_');
|
|
|
|
if(trapDisc && dev.ScsiType != PeripheralDeviceTypes.MultiMediaDevice)
|
|
{
|
|
AaruConsole.ErrorWriteLine(UI.Device_does_not_report_with_trap_discs);
|
|
|
|
return (int)ErrorNumber.InvalidArgument;
|
|
}
|
|
|
|
var reporter = new DeviceReport(dev);
|
|
|
|
if(dev.IsUsb)
|
|
if(AnsiConsole.Confirm($"[italic]{UI.Is_the_device_natively_USB}[/]"))
|
|
{
|
|
Core.Spectre.ProgressSingleSpinner(ctx =>
|
|
{
|
|
ctx.AddTask(Localization.Core.Querying_USB_information).IsIndeterminate();
|
|
report.USB = reporter.UsbReport();
|
|
});
|
|
|
|
report.USB.RemovableMedia = AnsiConsole.Confirm($"[italic]{UI.Is_the_media_removable}[/]");
|
|
|
|
removable = report.USB.RemovableMedia;
|
|
}
|
|
|
|
if(dev.IsFireWire)
|
|
if(AnsiConsole.Confirm($"[italic]{UI.Is_the_device_natively_FireWire}[/]"))
|
|
{
|
|
Core.Spectre.ProgressSingleSpinner(ctx =>
|
|
{
|
|
ctx.AddTask("Querying FireWire information...").IsIndeterminate();
|
|
report.FireWire = reporter.FireWireReport();
|
|
});
|
|
|
|
report.FireWire.RemovableMedia = AnsiConsole.Confirm($"[italic]{UI.Is_the_media_removable}[/]");
|
|
|
|
removable = report.FireWire.RemovableMedia;
|
|
}
|
|
|
|
if(dev.IsPcmcia)
|
|
Core.Spectre.ProgressSingleSpinner(ctx =>
|
|
{
|
|
ctx.AddTask(Localization.Core.Querying_PCMCIA_information).IsIndeterminate();
|
|
report.PCMCIA = reporter.PcmciaReport();
|
|
});
|
|
|
|
byte[] buffer = Array.Empty<byte>();
|
|
string mediumTypeName;
|
|
string mediumModel;
|
|
|
|
switch(dev.Type)
|
|
{
|
|
case DeviceType.ATA:
|
|
{
|
|
Core.Spectre.ProgressSingleSpinner(ctx =>
|
|
{
|
|
ctx.AddTask(Localization.Core.Querying_ATA_IDENTIFY).IsIndeterminate();
|
|
dev.AtaIdentify(out buffer, out _, dev.Timeout, out _);
|
|
});
|
|
|
|
if(!Identify.Decode(buffer).HasValue)
|
|
break;
|
|
|
|
report.ATA = new Ata
|
|
{
|
|
Identify = DeviceReport.ClearIdentify(buffer)
|
|
};
|
|
|
|
if(report.ATA.IdentifyDevice == null)
|
|
break;
|
|
|
|
if((ushort)report.ATA.IdentifyDevice?.GeneralConfiguration == 0x848A)
|
|
{
|
|
report.CompactFlash = true;
|
|
removable = false;
|
|
}
|
|
else if(!removable &&
|
|
report.ATA.IdentifyDevice?.GeneralConfiguration.HasFlag(Identify.GeneralConfigurationBit.
|
|
Removable) == true)
|
|
removable = AnsiConsole.Confirm($"[italic]{UI.Is_the_media_removable}[/]");
|
|
|
|
if(removable)
|
|
{
|
|
AaruConsole.WriteLine(UI.Please_remove_any_media);
|
|
|
|
System.Console.ReadKey(true);
|
|
|
|
Core.Spectre.ProgressSingleSpinner(ctx =>
|
|
{
|
|
ctx.AddTask(Localization.Core.Querying_ATA_IDENTIFY).IsIndeterminate();
|
|
dev.AtaIdentify(out buffer, out _, dev.Timeout, out _);
|
|
});
|
|
|
|
report.ATA.Identify = DeviceReport.ClearIdentify(buffer);
|
|
List<TestedMedia> mediaTests = new();
|
|
|
|
while(AnsiConsole.Confirm($"[italic]{UI.Do_you_have_media_you_can_insert}[/]"))
|
|
{
|
|
AaruConsole.WriteLine(UI.Please_insert_it_in_the_drive);
|
|
System.Console.ReadKey(true);
|
|
|
|
mediumTypeName = AnsiConsole.Ask<string>(UI.Please_write_description_of_media_type);
|
|
|
|
mediumModel = AnsiConsole.Ask<string>(UI.Please_write_media_model);
|
|
|
|
TestedMedia mediaTest = reporter.ReportAtaMedia();
|
|
mediaTest.MediumTypeName = mediumTypeName;
|
|
mediaTest.Model = mediumModel;
|
|
|
|
mediaTests.Add(mediaTest);
|
|
}
|
|
|
|
report.ATA.RemovableMedias = mediaTests;
|
|
}
|
|
else
|
|
report.ATA.ReadCapabilities = reporter.ReportAta(report.ATA.IdentifyDevice.Value);
|
|
|
|
break;
|
|
}
|
|
|
|
case DeviceType.MMC:
|
|
report.MultiMediaCard = reporter.MmcSdReport();
|
|
|
|
break;
|
|
case DeviceType.SecureDigital:
|
|
report.SecureDigital = reporter.MmcSdReport();
|
|
|
|
break;
|
|
case DeviceType.NVMe: throw new NotImplementedException(Localization.Core.NVMe_devices_not_yet_supported);
|
|
case DeviceType.ATAPI:
|
|
Core.Spectre.ProgressSingleSpinner(ctx =>
|
|
{
|
|
ctx.AddTask(Localization.Core.Querying_ATAPI_IDENTIFY).IsIndeterminate();
|
|
dev.AtapiIdentify(out buffer, out _, dev.Timeout, out _);
|
|
});
|
|
|
|
if(Identify.Decode(buffer).HasValue)
|
|
report.ATAPI = new Ata
|
|
{
|
|
Identify = DeviceReport.ClearIdentify(buffer)
|
|
};
|
|
|
|
goto case DeviceType.SCSI;
|
|
case DeviceType.SCSI:
|
|
switch(dev.ScsiType)
|
|
{
|
|
case PeripheralDeviceTypes.DirectAccess:
|
|
case PeripheralDeviceTypes.SequentialAccess:
|
|
case PeripheralDeviceTypes.WriteOnceDevice:
|
|
case PeripheralDeviceTypes.MultiMediaDevice:
|
|
case PeripheralDeviceTypes.OpticalDevice:
|
|
case PeripheralDeviceTypes.BridgingExpander
|
|
when dev.Model.StartsWith("MDM", StringComparison.Ordinal) ||
|
|
dev.Model.StartsWith("MDH", StringComparison.Ordinal):
|
|
case PeripheralDeviceTypes.SCSIZonedBlockDevice: break;
|
|
default:
|
|
{
|
|
AaruConsole.ErrorWriteLine(UI.Unsupported_device_type_for_report);
|
|
|
|
throw new IOException();
|
|
}
|
|
}
|
|
|
|
if(!dev.IsUsb &&
|
|
!dev.IsFireWire &&
|
|
dev.IsRemovable)
|
|
removable = AnsiConsole.Confirm($"[italic]{UI.Is_the_media_removable_flash_is_not}[/]");
|
|
|
|
if(removable)
|
|
{
|
|
switch(dev.ScsiType)
|
|
{
|
|
case PeripheralDeviceTypes.MultiMediaDevice:
|
|
case PeripheralDeviceTypes.BridgingExpander
|
|
when dev.Model.StartsWith("MDM", StringComparison.Ordinal) ||
|
|
dev.Model.StartsWith("MDH", StringComparison.Ordinal):
|
|
dev.AllowMediumRemoval(out buffer, dev.Timeout, out _);
|
|
dev.EjectTray(out buffer, dev.Timeout, out _);
|
|
|
|
break;
|
|
case PeripheralDeviceTypes.SequentialAccess:
|
|
dev.SpcAllowMediumRemoval(out buffer, dev.Timeout, out _);
|
|
|
|
Core.Spectre.ProgressSingleSpinner(ctx =>
|
|
{
|
|
ctx.AddTask(UI.Asking_drive_to_unload_tape).IsIndeterminate();
|
|
|
|
dev.Unload(out buffer, dev.Timeout, out _);
|
|
});
|
|
|
|
break;
|
|
}
|
|
|
|
AaruConsole.WriteLine(UI.Please_remove_any_media);
|
|
|
|
System.Console.ReadKey(true);
|
|
}
|
|
|
|
report.SCSI = reporter.ReportScsiInquiry();
|
|
|
|
if(report.SCSI == null)
|
|
break;
|
|
|
|
report.SCSI.EVPDPages =
|
|
reporter.ReportEvpdPages(StringHandlers.CToString(report.SCSI.Inquiry?.VendorIdentification)?.
|
|
Trim().ToLowerInvariant());
|
|
|
|
reporter.ReportScsiModes(ref report, out byte[] cdromMode, out MediumTypes mediumType);
|
|
|
|
string mediumManufacturer;
|
|
byte[] senseBuffer = Array.Empty<byte>();
|
|
bool sense = true;
|
|
|
|
switch(dev.ScsiType)
|
|
{
|
|
case PeripheralDeviceTypes.MultiMediaDevice:
|
|
{
|
|
if(dev.IsUsb &&
|
|
mediumType is MediumTypes.UnknownBlockDevice or MediumTypes.ReadOnlyBlockDevice
|
|
or MediumTypes.ReadWriteBlockDevice)
|
|
goto default;
|
|
|
|
bool iomegaRev = dev.Manufacturer.ToLowerInvariant() == "iomega" && dev.Model.
|
|
ToLowerInvariant().StartsWith("rrd", StringComparison.OrdinalIgnoreCase);
|
|
|
|
if(trapDisc)
|
|
{
|
|
if(iomegaRev)
|
|
{
|
|
AaruConsole.ErrorWriteLine(UI.Device_does_not_report_with_trap_discs);
|
|
|
|
return (int)ErrorNumber.InvalidArgument;
|
|
}
|
|
|
|
if(!AnsiConsole.Confirm($"[italic]{UI.Sure_report_trap_disc}[/]"))
|
|
return (int)ErrorNumber.NoError;
|
|
|
|
if(!AnsiConsole.Confirm($"[italic]{UI.Do_you_have_audio_trap_disc}[/]"))
|
|
{
|
|
AaruConsole.ErrorWriteLine(UI.Please_burn_audio_trap_disc);
|
|
|
|
return (int)ErrorNumber.NoError;
|
|
}
|
|
|
|
if(AnsiConsole.Confirm($"[italic]{UI.Do_you_have_GD_ROM_disc}[/]"))
|
|
reporter.ReportGdRomSwapTrick(ref report);
|
|
else
|
|
return (int)ErrorNumber.NoError;
|
|
}
|
|
else
|
|
{
|
|
List<string> mediaTypes = new();
|
|
|
|
report.SCSI.MultiMediaDevice = new Mmc
|
|
{
|
|
ModeSense2AData = cdromMode,
|
|
Features = reporter.ReportMmcFeatures()
|
|
};
|
|
|
|
if(report.SCSI.MultiMediaDevice.Features?.BinaryData != null)
|
|
{
|
|
Features.SeparatedFeatures ftr =
|
|
Features.Separate(report.SCSI.MultiMediaDevice.Features.BinaryData);
|
|
|
|
if(ftr.Descriptors != null)
|
|
foreach(Profile prof in from desc in ftr.Descriptors where desc.Code == 0x0000
|
|
select Features.Decode_0000(desc.Data) into ftr0000
|
|
where ftr0000 != null from prof in ftr0000.Value.Profiles
|
|
select prof)
|
|
switch(prof.Number)
|
|
{
|
|
case ProfileNumber.CDROM:
|
|
case ProfileNumber.CDR:
|
|
case ProfileNumber.CDRW:
|
|
mediaTypes.Add("CD-ROM");
|
|
mediaTypes.Add("Audio CD");
|
|
mediaTypes.Add("Enhanced CD (aka E-CD, CD-Plus or CD+)");
|
|
mediaTypes.Add("CD-R");
|
|
mediaTypes.Add("CD-RW Ultra Speed (marked 16x or higher)");
|
|
mediaTypes.Add("CD-RW High Speed (marked between 8x and 12x)");
|
|
mediaTypes.Add("CD-RW (marked 4x or lower)");
|
|
|
|
break;
|
|
case ProfileNumber.DVDRWRes:
|
|
case ProfileNumber.DVDRWSeq:
|
|
case ProfileNumber.DVDRDLSeq:
|
|
case ProfileNumber.DVDRDLJump:
|
|
case ProfileNumber.DVDRWDL:
|
|
case ProfileNumber.DVDDownload:
|
|
case ProfileNumber.DVDRWPlus:
|
|
case ProfileNumber.DVDRPlus:
|
|
case ProfileNumber.DVDRSeq:
|
|
case ProfileNumber.DVDRWDLPlus:
|
|
case ProfileNumber.DVDRDLPlus:
|
|
|
|
case ProfileNumber.DVDROM:
|
|
mediaTypes.Add("DVD-ROM");
|
|
mediaTypes.Add("DVD-R");
|
|
mediaTypes.Add("DVD-RW");
|
|
mediaTypes.Add("DVD+R");
|
|
mediaTypes.Add("DVD+RW");
|
|
mediaTypes.Add("DVD-R DL");
|
|
mediaTypes.Add("DVD+R DL");
|
|
mediaTypes.Add("Nintendo GameCube game");
|
|
mediaTypes.Add("Nintendo Wii game");
|
|
|
|
break;
|
|
case ProfileNumber.DVDRAM:
|
|
mediaTypes.Add("DVD-RAM (1st gen, marked 2.6Gb or 5.2Gb)");
|
|
mediaTypes.Add("DVD-RAM (2nd gen, marked 4.7Gb or 9.4Gb)");
|
|
|
|
break;
|
|
case ProfileNumber.DDCDROM:
|
|
case ProfileNumber.DDCDR:
|
|
case ProfileNumber.DDCDRW:
|
|
mediaTypes.Add("DDCD-ROM");
|
|
mediaTypes.Add("DDCD-R");
|
|
mediaTypes.Add("DDCD-RW");
|
|
|
|
break;
|
|
case ProfileNumber.BDROM:
|
|
case ProfileNumber.BDRSeq:
|
|
case ProfileNumber.BDRRdm:
|
|
case ProfileNumber.BDRE:
|
|
mediaTypes.Add("BD-ROM");
|
|
mediaTypes.Add("BD-R HTL (not LTH)");
|
|
mediaTypes.Add("BD-RE");
|
|
mediaTypes.Add("BD-R LTH");
|
|
mediaTypes.Add("BD-R Triple Layer (100Gb)");
|
|
mediaTypes.Add("BD-R Quad Layer (128Gb)");
|
|
mediaTypes.Add("Ultra HD Blu-ray movie");
|
|
mediaTypes.Add("PlayStation 3 game");
|
|
mediaTypes.Add("PlayStation 4 game");
|
|
mediaTypes.Add("PlayStation 5 game");
|
|
mediaTypes.Add("Xbox One game");
|
|
mediaTypes.Add("Nintendo Wii U game");
|
|
|
|
break;
|
|
case ProfileNumber.HDDVDROM:
|
|
case ProfileNumber.HDDVDR:
|
|
case ProfileNumber.HDDVDRW:
|
|
case ProfileNumber.HDDVDRDL:
|
|
case ProfileNumber.HDDVDRWDL:
|
|
mediaTypes.Add("HD DVD-ROM");
|
|
mediaTypes.Add("HD DVD-R");
|
|
mediaTypes.Add("HD DVD-RW");
|
|
|
|
break;
|
|
case ProfileNumber.HDDVDRAM:
|
|
mediaTypes.Add("HD DVD-RAM");
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(cdromMode != null &&
|
|
!iomegaRev)
|
|
{
|
|
mediaTypes.Add("CD-ROM");
|
|
mediaTypes.Add("Audio CD");
|
|
mediaTypes.Add("Enhanced CD (aka E-CD, CD-Plus or CD+)");
|
|
|
|
if(report.SCSI.MultiMediaDevice.ModeSense2A.ReadCDR)
|
|
mediaTypes.Add("CD-R");
|
|
|
|
if(report.SCSI.MultiMediaDevice.ModeSense2A.ReadCDRW)
|
|
{
|
|
mediaTypes.Add("CD-RW Ultra Speed (marked 16x or higher)");
|
|
mediaTypes.Add("CD-RW High Speed (marked between 8x and 12x)");
|
|
mediaTypes.Add("CD-RW (marked 4x or lower)");
|
|
}
|
|
|
|
if(report.SCSI.MultiMediaDevice.ModeSense2A.ReadDVDROM)
|
|
mediaTypes.Add("DVD-ROM");
|
|
|
|
if(report.SCSI.MultiMediaDevice.ModeSense2A.ReadDVDRAM)
|
|
{
|
|
mediaTypes.Add("DVD-RAM (1st gen, marked 2.6Gb or 5.2Gb)");
|
|
mediaTypes.Add("DVD-RAM (2nd gen, marked 4.7Gb or 9.4Gb)");
|
|
}
|
|
|
|
if(report.SCSI.MultiMediaDevice.ModeSense2A.ReadDVDR)
|
|
mediaTypes.Add("DVD-R");
|
|
}
|
|
|
|
if(report.SCSI.MultiMediaDevice.Features != null &&
|
|
!iomegaRev)
|
|
{
|
|
if(report.SCSI.MultiMediaDevice.Features.CanReadBD ||
|
|
report.SCSI.MultiMediaDevice.Features.CanReadBDR ||
|
|
report.SCSI.MultiMediaDevice.Features.CanReadBDRE1 ||
|
|
report.SCSI.MultiMediaDevice.Features.CanReadBDRE2 ||
|
|
report.SCSI.MultiMediaDevice.Features.CanReadBDROM ||
|
|
report.SCSI.MultiMediaDevice.Features.CanReadOldBDR ||
|
|
report.SCSI.MultiMediaDevice.Features.CanReadOldBDRE ||
|
|
report.SCSI.MultiMediaDevice.Features.CanReadOldBDROM)
|
|
{
|
|
mediaTypes.Add("BD-ROM");
|
|
mediaTypes.Add("BD-R HTL (not LTH)");
|
|
mediaTypes.Add("BD-RE");
|
|
mediaTypes.Add("BD-R LTH");
|
|
mediaTypes.Add("BD-R Triple Layer (100Gb)");
|
|
mediaTypes.Add("BD-R Quad Layer (128Gb)");
|
|
mediaTypes.Add("Ultra HD Blu-ray movie");
|
|
mediaTypes.Add("PlayStation 3 game");
|
|
mediaTypes.Add("PlayStation 4 game");
|
|
mediaTypes.Add("PlayStation 5 game");
|
|
mediaTypes.Add("Xbox One game");
|
|
mediaTypes.Add("Nintendo Wii U game");
|
|
}
|
|
|
|
if(report.SCSI.MultiMediaDevice.Features.CanReadCD ||
|
|
report.SCSI.MultiMediaDevice.Features.MultiRead)
|
|
{
|
|
mediaTypes.Add("CD-ROM");
|
|
mediaTypes.Add("Audio CD");
|
|
mediaTypes.Add("Enhanced CD (aka E-CD, CD-Plus or CD+)");
|
|
mediaTypes.Add("CD-R");
|
|
mediaTypes.Add("CD-RW Ultra Speed (marked 16x or higher)");
|
|
mediaTypes.Add("CD-RW High Speed (marked between 8x and 12x)");
|
|
mediaTypes.Add("CD-RW (marked 4x or lower)");
|
|
}
|
|
|
|
if(report.SCSI.MultiMediaDevice.Features.CanReadCDMRW)
|
|
mediaTypes.Add("CD-MRW");
|
|
|
|
if(report.SCSI.MultiMediaDevice.Features.CanReadDDCD)
|
|
{
|
|
mediaTypes.Add("DDCD-ROM");
|
|
mediaTypes.Add("DDCD-R");
|
|
mediaTypes.Add("DDCD-RW");
|
|
}
|
|
|
|
if(report.SCSI.MultiMediaDevice.Features.CanReadDVD ||
|
|
report.SCSI.MultiMediaDevice.Features.DVDMultiRead ||
|
|
report.SCSI.MultiMediaDevice.Features.CanReadDVDPlusR ||
|
|
report.SCSI.MultiMediaDevice.Features.CanReadDVDPlusRDL ||
|
|
report.SCSI.MultiMediaDevice.Features.CanReadDVDPlusRW ||
|
|
report.SCSI.MultiMediaDevice.Features.CanReadDVDPlusRWDL)
|
|
{
|
|
mediaTypes.Add("DVD-ROM");
|
|
mediaTypes.Add("DVD-R");
|
|
mediaTypes.Add("DVD-RW");
|
|
mediaTypes.Add("DVD+R");
|
|
mediaTypes.Add("DVD+RW");
|
|
mediaTypes.Add("DVD-R DL");
|
|
mediaTypes.Add("DVD+R DL");
|
|
mediaTypes.Add("Nintendo GameCube game");
|
|
mediaTypes.Add("Nintendo Wii game");
|
|
mediaTypes.Add("DVD-RAM (1st gen, marked 2.6Gb or 5.2Gb)");
|
|
mediaTypes.Add("DVD-RAM (2nd gen, marked 4.7Gb or 9.4Gb)");
|
|
}
|
|
|
|
if(report.SCSI.MultiMediaDevice.Features.CanReadDVDPlusMRW)
|
|
mediaTypes.Add("DVD+MRW");
|
|
|
|
if(report.SCSI.MultiMediaDevice.Features.CanReadHDDVD ||
|
|
report.SCSI.MultiMediaDevice.Features.CanReadHDDVDR)
|
|
{
|
|
mediaTypes.Add("HD DVD-ROM");
|
|
mediaTypes.Add("HD DVD-R");
|
|
mediaTypes.Add("HD DVD-RW");
|
|
}
|
|
|
|
if(report.SCSI.MultiMediaDevice.Features.CanReadHDDVDRAM)
|
|
mediaTypes.Add("HD DVD-RAM");
|
|
}
|
|
|
|
if(iomegaRev)
|
|
{
|
|
mediaTypes.Add("REV 35Gb");
|
|
mediaTypes.Add("REV 70Gb");
|
|
mediaTypes.Add("REV 120Gb");
|
|
}
|
|
|
|
// Very old CD drives do not contain mode page 2Ah neither GET CONFIGURATION, so just try all CDs on them
|
|
// Also don't get confident, some drives didn't know CD-RW but are able to read them
|
|
if(mediaTypes.Count == 0 ||
|
|
mediaTypes.Contains("CD-ROM"))
|
|
{
|
|
mediaTypes.Add("CD-ROM");
|
|
mediaTypes.Add("Audio CD");
|
|
mediaTypes.Add("CD-R");
|
|
mediaTypes.Add("CD-RW Ultra Speed (marked 16x or higher)");
|
|
mediaTypes.Add("CD-RW High Speed (marked between 8x and 12x)");
|
|
mediaTypes.Add("CD-RW (marked 4x or lower)");
|
|
mediaTypes.Add("Enhanced CD (aka E-CD, CD-Plus or CD+)");
|
|
}
|
|
|
|
mediaTypes = mediaTypes.Distinct().ToList();
|
|
mediaTypes.Sort();
|
|
|
|
bool tryPlextor = false, tryHldtst = false, tryPioneer = false, tryNec = false,
|
|
tryMediaTekF106 = false;
|
|
|
|
tryPlextor |= dev.Manufacturer.ToLowerInvariant() == "plextor";
|
|
tryHldtst |= dev.Manufacturer.ToLowerInvariant() == "hl-dt-st";
|
|
tryPioneer |= dev.Manufacturer.ToLowerInvariant() == "pioneer";
|
|
tryNec |= dev.Manufacturer.ToLowerInvariant() == "nec";
|
|
|
|
if(!iomegaRev)
|
|
{
|
|
if(!tryPlextor)
|
|
tryPlextor |=
|
|
AnsiConsole.
|
|
Confirm($"[italic]{UI.Do_you_want_to_try_Plextor_commands} [red]{UI.This_is_dangerous}[/][/]",
|
|
false);
|
|
|
|
if(!tryNec)
|
|
tryNec |=
|
|
AnsiConsole.
|
|
Confirm($"[italic]{UI.Do_you_want_to_try_NEC_commands} [red]{UI.This_is_dangerous}[/][/]",
|
|
false);
|
|
|
|
if(!tryPioneer)
|
|
tryPioneer |=
|
|
AnsiConsole.
|
|
Confirm($"[italic]{UI.Do_you_want_to_try_Pioneer_commands} [red]{UI.This_is_dangerous}[/][/]",
|
|
false);
|
|
|
|
if(!tryHldtst)
|
|
tryHldtst |=
|
|
AnsiConsole.
|
|
Confirm($"[italic]{UI.Do_you_want_to_try_HLDTST_commands} [red]{UI.This_is_dangerous}[/][/]",
|
|
false);
|
|
|
|
tryMediaTekF106 =
|
|
AnsiConsole.
|
|
Confirm($"[italic]{UI.Do_you_want_to_try_MediaTek_commands} [red]{UI.This_is_dangerous}[/][/]",
|
|
false);
|
|
}
|
|
|
|
if(dev.Model.StartsWith("PD-", StringComparison.Ordinal))
|
|
mediaTypes.Add("PD-650");
|
|
|
|
List<TestedMedia> mediaTests = new();
|
|
|
|
foreach(string mediaType in mediaTypes)
|
|
{
|
|
if(!AnsiConsole.Confirm($"[italic]{string.Format(UI.Do_you_have_a_0_disc, mediaType)
|
|
}[/]"))
|
|
continue;
|
|
|
|
AaruConsole.WriteLine(UI.Please_insert_it_in_the_drive);
|
|
|
|
System.Console.ReadKey(true);
|
|
|
|
bool mediaIsRecognized = true;
|
|
|
|
Core.Spectre.ProgressSingleSpinner(ctx =>
|
|
{
|
|
ctx.AddTask(Localization.Core.Waiting_for_drive_to_become_ready).IsIndeterminate();
|
|
sense = dev.ScsiTestUnitReady(out senseBuffer, dev.Timeout, out _);
|
|
|
|
if(!sense)
|
|
return;
|
|
|
|
DecodedSense? decSense = Sense.Decode(senseBuffer);
|
|
|
|
if(decSense.HasValue)
|
|
switch(decSense.Value.ASC)
|
|
{
|
|
case 0x3A:
|
|
{
|
|
int leftRetries = 50;
|
|
|
|
while(leftRetries > 0)
|
|
{
|
|
Thread.Sleep(2000);
|
|
|
|
sense = dev.ScsiTestUnitReady(out senseBuffer, dev.Timeout, out _);
|
|
|
|
if(!sense)
|
|
break;
|
|
|
|
leftRetries--;
|
|
}
|
|
|
|
AaruConsole.WriteLine();
|
|
|
|
mediaIsRecognized &= !sense;
|
|
|
|
break;
|
|
}
|
|
|
|
// These should be trapped by the OS but seems in some cases they're not
|
|
case 0x04 when decSense.Value.ASCQ == 0x01:
|
|
{
|
|
int leftRetries = 50;
|
|
|
|
while(leftRetries > 0)
|
|
{
|
|
Thread.Sleep(2000);
|
|
|
|
sense = dev.ScsiTestUnitReady(out senseBuffer, dev.Timeout, out _);
|
|
|
|
if(!sense)
|
|
break;
|
|
|
|
leftRetries--;
|
|
}
|
|
|
|
AaruConsole.WriteLine();
|
|
|
|
mediaIsRecognized &= !sense;
|
|
|
|
break;
|
|
}
|
|
case 0x28:
|
|
{
|
|
int leftRetries = 50;
|
|
|
|
while(leftRetries > 0)
|
|
{
|
|
Thread.Sleep(2000);
|
|
|
|
sense = dev.ScsiTestUnitReady(out senseBuffer, dev.Timeout, out _);
|
|
|
|
if(!sense)
|
|
break;
|
|
|
|
leftRetries--;
|
|
}
|
|
|
|
AaruConsole.WriteLine();
|
|
|
|
mediaIsRecognized &= !sense;
|
|
|
|
break;
|
|
}
|
|
default:
|
|
AaruConsole.DebugWriteLine("Device-Report command",
|
|
Localization.Core.Device_not_ready_Sense,
|
|
decSense.Value.SenseKey, decSense.Value.ASC,
|
|
decSense.Value.ASCQ);
|
|
|
|
mediaIsRecognized = false;
|
|
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
AaruConsole.DebugWriteLine("Device-Report command",
|
|
Localization.Core.
|
|
Got_sense_status_but_no_sense_buffer);
|
|
|
|
mediaIsRecognized = false;
|
|
}
|
|
});
|
|
|
|
var mediaTest = new TestedMedia();
|
|
|
|
if(mediaIsRecognized)
|
|
{
|
|
mediaTest = reporter.ReportMmcMedia(mediaType, tryPlextor, tryPioneer, tryNec,
|
|
tryHldtst, tryMediaTekF106);
|
|
|
|
if(mediaTest is null)
|
|
continue;
|
|
|
|
if((mediaTest.SupportsReadLong == true || mediaTest.SupportsReadLong16 == true) &&
|
|
mediaTest.LongBlockSize == mediaTest.BlockSize &&
|
|
AnsiConsole.Confirm($"[italic]{Localization.Core.Try_to_find_SCSI_READ_LONG_size
|
|
}[/]"))
|
|
AnsiConsole.Progress().AutoClear(true).HideCompleted(true).
|
|
Columns(new TaskDescriptionColumn(), new ProgressBarColumn(),
|
|
new PercentageColumn()).Start(ctx =>
|
|
{
|
|
ProgressTask task =
|
|
ctx.AddTask(Localization.Core.Trying_to_READ_LONG);
|
|
|
|
task.MaxValue = ushort.MaxValue;
|
|
|
|
for(ushort i = (ushort)mediaTest.BlockSize;; i++)
|
|
{
|
|
task.Description =
|
|
string.
|
|
Format(Localization.Core.Trying_READ_LONG_with_size_0,
|
|
i);
|
|
|
|
task.Value = i;
|
|
|
|
sense = mediaTest.SupportsReadLong16 == true
|
|
? dev.ReadLong16(out buffer, out senseBuffer,
|
|
false, 0, i, dev.Timeout, out _)
|
|
: dev.ReadLong10(out buffer, out senseBuffer,
|
|
false, false, 0, i, dev.Timeout,
|
|
out _);
|
|
|
|
if(!sense)
|
|
{
|
|
mediaTest.LongBlockSize = i;
|
|
|
|
break;
|
|
}
|
|
|
|
if(i == ushort.MaxValue)
|
|
break;
|
|
}
|
|
});
|
|
|
|
if(mediaTest.SupportsReadLong == true &&
|
|
mediaTest.LongBlockSize != mediaTest.BlockSize)
|
|
{
|
|
Core.Spectre.ProgressSingleSpinner(ctx =>
|
|
{
|
|
ctx.AddTask(Localization.Core.Trying_SCSI_READ_LONG_10).IsIndeterminate();
|
|
|
|
sense = dev.ReadLong10(out buffer, out senseBuffer, false, false, 0,
|
|
(ushort)mediaTest.LongBlockSize, dev.Timeout, out _);
|
|
});
|
|
|
|
if(!sense)
|
|
mediaTest.ReadLong10Data = buffer;
|
|
}
|
|
|
|
if(mediaTest.SupportsReadLong16 == true &&
|
|
mediaTest.LongBlockSize != mediaTest.BlockSize)
|
|
{
|
|
Core.Spectre.ProgressSingleSpinner(ctx =>
|
|
{
|
|
ctx.AddTask(Localization.Core.Trying_SCSI_READ_LONG_16).IsIndeterminate();
|
|
|
|
sense = dev.ReadLong16(out buffer, out senseBuffer, false, 0,
|
|
mediaTest.LongBlockSize.Value, dev.Timeout, out _);
|
|
});
|
|
|
|
if(!sense)
|
|
mediaTest.ReadLong16Data = buffer;
|
|
}
|
|
}
|
|
|
|
mediaTest.MediumTypeName = mediaType;
|
|
mediaTest.MediaIsRecognized = mediaIsRecognized;
|
|
mediaTests.Add(mediaTest);
|
|
|
|
dev.AllowMediumRemoval(out buffer, dev.Timeout, out _);
|
|
dev.EjectTray(out buffer, dev.Timeout, out _);
|
|
}
|
|
|
|
report.SCSI.MultiMediaDevice.TestedMedia = mediaTests;
|
|
}
|
|
}
|
|
|
|
break;
|
|
case PeripheralDeviceTypes.SequentialAccess:
|
|
{
|
|
report.SCSI.SequentialDevice = reporter.ReportScsiSsc();
|
|
|
|
List<TestedSequentialMedia> seqTests = new();
|
|
|
|
while(AnsiConsole.Confirm($"[italic]{UI.Do_you_have_media_you_can_insert}[/]"))
|
|
{
|
|
AaruConsole.WriteLine(UI.Please_insert_it_in_the_drive);
|
|
|
|
System.Console.ReadKey(true);
|
|
|
|
mediumTypeName = AnsiConsole.Ask<string>(UI.Please_write_description_of_media_type);
|
|
|
|
mediumManufacturer =
|
|
AnsiConsole.Ask<string>(Localization.Core.Please_write_media_manufacturer);
|
|
|
|
mediumModel = AnsiConsole.Ask<string>(UI.Please_write_media_model);
|
|
|
|
bool mediaIsRecognized = true;
|
|
|
|
Core.Spectre.ProgressSingleSpinner(ctx =>
|
|
{
|
|
ctx.AddTask(Localization.Core.Waiting_for_drive_to_become_ready).IsIndeterminate();
|
|
|
|
sense = dev.ScsiTestUnitReady(out senseBuffer, dev.Timeout, out _);
|
|
AaruConsole.DebugWriteLine("Device reporting", "sense = {0}", sense);
|
|
|
|
if(!sense)
|
|
return;
|
|
|
|
DecodedSense? decSense = Sense.Decode(senseBuffer);
|
|
|
|
if(decSense.HasValue)
|
|
switch(decSense.Value.ASC)
|
|
{
|
|
case 0x3A:
|
|
{
|
|
int leftRetries = 50;
|
|
|
|
while(leftRetries > 0)
|
|
{
|
|
Thread.Sleep(2000);
|
|
|
|
sense = dev.ScsiTestUnitReady(out senseBuffer, dev.Timeout, out _);
|
|
|
|
if(!sense)
|
|
break;
|
|
|
|
leftRetries--;
|
|
}
|
|
|
|
AaruConsole.WriteLine();
|
|
|
|
mediaIsRecognized &= !sense;
|
|
|
|
break;
|
|
}
|
|
|
|
// These should be trapped by the OS but seems in some cases they're not
|
|
case 0x04 when decSense.Value.ASCQ == 0x01:
|
|
{
|
|
int leftRetries = 50;
|
|
|
|
while(leftRetries > 0)
|
|
{
|
|
Thread.Sleep(2000);
|
|
|
|
sense = dev.ScsiTestUnitReady(out senseBuffer, dev.Timeout, out _);
|
|
|
|
if(!sense)
|
|
break;
|
|
|
|
leftRetries--;
|
|
}
|
|
|
|
AaruConsole.WriteLine();
|
|
|
|
mediaIsRecognized &= !sense;
|
|
|
|
break;
|
|
}
|
|
case 0x28:
|
|
{
|
|
int leftRetries = 50;
|
|
|
|
while(leftRetries > 0)
|
|
{
|
|
Thread.Sleep(2000);
|
|
|
|
sense = dev.ScsiTestUnitReady(out senseBuffer, dev.Timeout, out _);
|
|
|
|
if(!sense)
|
|
break;
|
|
|
|
leftRetries--;
|
|
}
|
|
|
|
AaruConsole.WriteLine();
|
|
|
|
mediaIsRecognized &= !sense;
|
|
|
|
break;
|
|
}
|
|
default:
|
|
AaruConsole.DebugWriteLine("Device-Report command",
|
|
Localization.Core.Device_not_ready_Sense,
|
|
decSense.Value.SenseKey, decSense.Value.ASC,
|
|
decSense.Value.ASCQ);
|
|
|
|
mediaIsRecognized = false;
|
|
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
AaruConsole.DebugWriteLine("Device-Report command",
|
|
Localization.Core.Got_sense_status_but_no_sense_buffer);
|
|
|
|
mediaIsRecognized = false;
|
|
}
|
|
});
|
|
|
|
var seqTest = new TestedSequentialMedia();
|
|
|
|
if(mediaIsRecognized)
|
|
seqTest = reporter.ReportSscMedia();
|
|
|
|
seqTest.MediumTypeName = mediumTypeName;
|
|
seqTest.Manufacturer = mediumManufacturer;
|
|
seqTest.Model = mediumModel;
|
|
seqTest.MediaIsRecognized = mediaIsRecognized;
|
|
|
|
seqTests.Add(seqTest);
|
|
|
|
Core.Spectre.ProgressSingleSpinner(ctx =>
|
|
{
|
|
ctx.AddTask(UI.Asking_drive_to_unload_tape).IsIndeterminate();
|
|
|
|
dev.SpcAllowMediumRemoval(out buffer, dev.Timeout, out _);
|
|
dev.Unload(out buffer, dev.Timeout, out _);
|
|
});
|
|
}
|
|
|
|
report.SCSI.SequentialDevice.TestedMedia = seqTests;
|
|
}
|
|
|
|
break;
|
|
case PeripheralDeviceTypes.BridgingExpander
|
|
when dev.Model.StartsWith("MDM", StringComparison.Ordinal) ||
|
|
dev.Model.StartsWith("MDH", StringComparison.Ordinal):
|
|
{
|
|
List<string> mediaTypes = new()
|
|
{
|
|
Localization.Core.Media_Type_Name_MMD_140A,
|
|
Localization.Core.Media_Type_Name_MDW_60,
|
|
Localization.Core.Media_Type_Name_MDW_74,
|
|
Localization.Core.Media_Type_Name_MDW_80,
|
|
Localization.Core.Media_Type_Name_MiniDisc
|
|
};
|
|
|
|
mediaTypes.Sort();
|
|
|
|
List<TestedMedia> mediaTests = new();
|
|
|
|
foreach(string mediaType in mediaTypes)
|
|
{
|
|
if(!AnsiConsole.Confirm($"[italic]{string.Format(UI.Do_you_have_a_0_disc, mediaType)}[/]"))
|
|
continue;
|
|
|
|
AaruConsole.WriteLine(UI.Please_insert_it_in_the_drive);
|
|
|
|
System.Console.ReadKey(true);
|
|
|
|
bool mediaIsRecognized = true;
|
|
|
|
Core.Spectre.ProgressSingleSpinner(ctx =>
|
|
{
|
|
ctx.AddTask(Localization.Core.Waiting_for_drive_to_become_ready).IsIndeterminate();
|
|
|
|
sense = dev.ScsiTestUnitReady(out senseBuffer, dev.Timeout, out _);
|
|
|
|
if(!sense)
|
|
return;
|
|
|
|
DecodedSense? decSense = Sense.Decode(senseBuffer);
|
|
|
|
if(decSense.HasValue)
|
|
switch(decSense.Value.ASC)
|
|
{
|
|
case 0x3A:
|
|
{
|
|
int leftRetries = 50;
|
|
|
|
while(leftRetries > 0)
|
|
{
|
|
Thread.Sleep(2000);
|
|
|
|
sense = dev.ScsiTestUnitReady(out senseBuffer, dev.Timeout, out _);
|
|
|
|
if(!sense)
|
|
break;
|
|
|
|
leftRetries--;
|
|
}
|
|
|
|
mediaIsRecognized &= !sense;
|
|
|
|
break;
|
|
}
|
|
|
|
// These should be trapped by the OS but seems in some cases they're not
|
|
case 0x04 when decSense.Value.ASCQ == 0x01:
|
|
{
|
|
int leftRetries = 50;
|
|
|
|
while(leftRetries > 0)
|
|
{
|
|
Thread.Sleep(2000);
|
|
|
|
sense = dev.ScsiTestUnitReady(out senseBuffer, dev.Timeout, out _);
|
|
|
|
if(!sense)
|
|
break;
|
|
|
|
leftRetries--;
|
|
}
|
|
|
|
mediaIsRecognized &= !sense;
|
|
|
|
break;
|
|
}
|
|
case 0x28:
|
|
{
|
|
int leftRetries = 50;
|
|
|
|
while(leftRetries > 0)
|
|
{
|
|
Thread.Sleep(2000);
|
|
|
|
sense = dev.ScsiTestUnitReady(out senseBuffer, dev.Timeout, out _);
|
|
|
|
if(!sense)
|
|
break;
|
|
|
|
leftRetries--;
|
|
}
|
|
|
|
mediaIsRecognized &= !sense;
|
|
|
|
break;
|
|
}
|
|
default:
|
|
AaruConsole.DebugWriteLine("Device-Report command",
|
|
Localization.Core.Device_not_ready_Sense,
|
|
decSense.Value.SenseKey, decSense.Value.ASC,
|
|
decSense.Value.ASCQ);
|
|
|
|
mediaIsRecognized = false;
|
|
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
AaruConsole.DebugWriteLine("Device-Report command",
|
|
Localization.Core.Got_sense_status_but_no_sense_buffer);
|
|
|
|
mediaIsRecognized = false;
|
|
}
|
|
});
|
|
|
|
var mediaTest = new TestedMedia();
|
|
|
|
if(mediaIsRecognized)
|
|
{
|
|
mediaTest = reporter.ReportScsiMedia();
|
|
|
|
if(mediaTest is null)
|
|
continue;
|
|
|
|
if((mediaTest.SupportsReadLong == true || mediaTest.SupportsReadLong16 == true) &&
|
|
mediaTest.LongBlockSize == mediaTest.BlockSize &&
|
|
AnsiConsole.Confirm($"[italic]{Localization.Core.Try_to_find_SCSI_READ_LONG_size
|
|
}[/]"))
|
|
AnsiConsole.Progress().AutoClear(true).HideCompleted(true).
|
|
Columns(new TaskDescriptionColumn(), new ProgressBarColumn(),
|
|
new PercentageColumn()).Start(ctx =>
|
|
{
|
|
ProgressTask task =
|
|
ctx.AddTask(Localization.Core.Trying_to_READ_LONG);
|
|
|
|
task.MaxValue = ushort.MaxValue;
|
|
|
|
for(ushort i = (ushort)mediaTest.BlockSize;; i++)
|
|
{
|
|
task.Value = i;
|
|
|
|
task.Description =
|
|
string.
|
|
Format(Localization.Core.Trying_READ_LONG_with_size_0,
|
|
i);
|
|
|
|
sense = mediaTest.SupportsReadLong16 == true
|
|
? dev.ReadLong16(out buffer, out senseBuffer, false,
|
|
0, i, dev.Timeout, out _)
|
|
: dev.ReadLong10(out buffer, out senseBuffer, false,
|
|
false, 0, i, dev.Timeout, out _);
|
|
|
|
if(!sense)
|
|
{
|
|
mediaTest.LongBlockSize = i;
|
|
|
|
break;
|
|
}
|
|
|
|
if(i == ushort.MaxValue)
|
|
break;
|
|
}
|
|
|
|
AaruConsole.WriteLine();
|
|
});
|
|
|
|
if(mediaTest.SupportsReadLong == true &&
|
|
mediaTest.LongBlockSize != mediaTest.BlockSize)
|
|
{
|
|
Core.Spectre.ProgressSingleSpinner(ctx =>
|
|
{
|
|
ctx.AddTask(Localization.Core.Trying_SCSI_READ_LONG_10).IsIndeterminate();
|
|
|
|
sense = dev.ReadLong10(out buffer, out senseBuffer, false, false, 0,
|
|
(ushort)mediaTest.LongBlockSize, dev.Timeout, out _);
|
|
});
|
|
|
|
if(!sense)
|
|
mediaTest.ReadLong10Data = buffer;
|
|
}
|
|
|
|
if(mediaTest.SupportsReadLong16 == true &&
|
|
mediaTest.LongBlockSize != mediaTest.BlockSize)
|
|
{
|
|
Core.Spectre.ProgressSingleSpinner(ctx =>
|
|
{
|
|
ctx.AddTask(Localization.Core.Trying_SCSI_READ_LONG_16).IsIndeterminate();
|
|
|
|
sense = dev.ReadLong16(out buffer, out senseBuffer, false, 0,
|
|
(ushort)mediaTest.LongBlockSize, dev.Timeout, out _);
|
|
});
|
|
|
|
if(!sense)
|
|
mediaTest.ReadLong16Data = buffer;
|
|
}
|
|
}
|
|
|
|
if(mediaType == Localization.Core.Media_Type_Name_MMD_140A)
|
|
mediaTest.MediumTypeName = "MMD-140A";
|
|
else if(mediaType == Localization.Core.Media_Type_Name_MDW_60)
|
|
mediaTest.MediumTypeName = "MDW-60";
|
|
else if(mediaType == Localization.Core.Media_Type_Name_MDW_74)
|
|
mediaTest.MediumTypeName = "MDW-74";
|
|
else if(mediaType == Localization.Core.Media_Type_Name_MDW_80)
|
|
mediaTest.MediumTypeName = "MDW-80";
|
|
else if(mediaType == Localization.Core.Media_Type_Name_MiniDisc)
|
|
mediaTest.MediumTypeName = "MiniDisc";
|
|
|
|
mediaTest.Manufacturer = "SONY";
|
|
mediaTest.MediaIsRecognized = mediaIsRecognized;
|
|
mediaTests.Add(mediaTest);
|
|
|
|
dev.AllowMediumRemoval(out buffer, dev.Timeout, out _);
|
|
dev.EjectTray(out buffer, dev.Timeout, out _);
|
|
}
|
|
|
|
report.SCSI.RemovableMedias = mediaTests;
|
|
}
|
|
|
|
break;
|
|
default:
|
|
{
|
|
if(removable)
|
|
{
|
|
List<TestedMedia> mediaTests = new();
|
|
|
|
while(AnsiConsole.Confirm($"[italic]{UI.Do_you_have_media_you_can_insert}[/]"))
|
|
{
|
|
AaruConsole.WriteLine(UI.Please_insert_it_in_the_drive);
|
|
|
|
System.Console.ReadKey(true);
|
|
|
|
mediumTypeName = AnsiConsole.Ask<string>(UI.Please_write_description_of_media_type);
|
|
|
|
mediumManufacturer =
|
|
AnsiConsole.Ask<string>(Localization.Core.Please_write_media_manufacturer);
|
|
|
|
mediumModel = AnsiConsole.Ask<string>(UI.Please_write_media_model);
|
|
|
|
bool mediaIsRecognized = true;
|
|
|
|
Core.Spectre.ProgressSingleSpinner(ctx =>
|
|
{
|
|
ctx.AddTask(Localization.Core.Waiting_for_drive_to_become_ready).IsIndeterminate();
|
|
sense = dev.ScsiTestUnitReady(out senseBuffer, dev.Timeout, out _);
|
|
|
|
if(!sense)
|
|
return;
|
|
|
|
DecodedSense? decSense = Sense.Decode(senseBuffer);
|
|
|
|
if(decSense.HasValue)
|
|
switch(decSense.Value.ASC)
|
|
{
|
|
case 0x3A:
|
|
{
|
|
int leftRetries = 20;
|
|
|
|
while(leftRetries > 0)
|
|
{
|
|
Thread.Sleep(2000);
|
|
|
|
sense = dev.ScsiTestUnitReady(out senseBuffer, dev.Timeout, out _);
|
|
|
|
if(!sense)
|
|
break;
|
|
|
|
leftRetries--;
|
|
}
|
|
|
|
mediaIsRecognized &= !sense;
|
|
|
|
break;
|
|
}
|
|
case 0x04 when decSense.Value.ASCQ == 0x01:
|
|
{
|
|
int leftRetries = 20;
|
|
|
|
while(leftRetries > 0)
|
|
{
|
|
Thread.Sleep(2000);
|
|
|
|
sense = dev.ScsiTestUnitReady(out senseBuffer, dev.Timeout, out _);
|
|
|
|
if(!sense)
|
|
break;
|
|
|
|
leftRetries--;
|
|
}
|
|
|
|
mediaIsRecognized &= !sense;
|
|
|
|
break;
|
|
}
|
|
default:
|
|
mediaIsRecognized = false;
|
|
|
|
break;
|
|
}
|
|
else
|
|
mediaIsRecognized = false;
|
|
});
|
|
|
|
var mediaTest = new TestedMedia();
|
|
|
|
if(mediaIsRecognized)
|
|
{
|
|
mediaTest = reporter.ReportScsiMedia();
|
|
|
|
if((mediaTest.SupportsReadLong == true || mediaTest.SupportsReadLong16 == true) &&
|
|
mediaTest.LongBlockSize == mediaTest.BlockSize &&
|
|
AnsiConsole.Confirm($"[italic]{Localization.Core.Try_to_find_SCSI_READ_LONG_size
|
|
}[/]"))
|
|
AnsiConsole.Progress().AutoClear(true).HideCompleted(true).
|
|
Columns(new TaskDescriptionColumn(), new ProgressBarColumn(),
|
|
new PercentageColumn()).Start(ctx =>
|
|
{
|
|
ProgressTask task =
|
|
ctx.AddTask(Localization.Core.Trying_to_READ_LONG);
|
|
|
|
task.MaxValue = ushort.MaxValue;
|
|
|
|
for(ushort i = (ushort)mediaTest.BlockSize;; i++)
|
|
{
|
|
task.Value = i;
|
|
|
|
task.Description =
|
|
string.
|
|
Format(Localization.Core.Trying_READ_LONG_with_size_0,
|
|
i);
|
|
|
|
sense = mediaTest.SupportsReadLong16 == true
|
|
? dev.ReadLong16(out buffer, out senseBuffer,
|
|
false, 0, i, dev.Timeout, out _)
|
|
: dev.ReadLong10(out buffer, out senseBuffer,
|
|
false, false, 0, i, dev.Timeout,
|
|
out _);
|
|
|
|
if(!sense)
|
|
{
|
|
mediaTest.LongBlockSize = i;
|
|
|
|
break;
|
|
}
|
|
|
|
if(i == ushort.MaxValue)
|
|
break;
|
|
}
|
|
|
|
AaruConsole.WriteLine();
|
|
});
|
|
|
|
if(mediaTest.SupportsReadLong == true &&
|
|
mediaTest.LongBlockSize != mediaTest.BlockSize)
|
|
{
|
|
Core.Spectre.ProgressSingleSpinner(ctx =>
|
|
{
|
|
ctx.AddTask(Localization.Core.Trying_SCSI_READ_LONG_10).IsIndeterminate();
|
|
|
|
sense = dev.ReadLong10(out buffer, out senseBuffer, false, false, 0,
|
|
(ushort)mediaTest.LongBlockSize, dev.Timeout, out _);
|
|
});
|
|
|
|
if(!sense)
|
|
mediaTest.ReadLong10Data = buffer;
|
|
}
|
|
|
|
if(mediaTest.SupportsReadLong16 == true &&
|
|
mediaTest.LongBlockSize != mediaTest.BlockSize)
|
|
{
|
|
Core.Spectre.ProgressSingleSpinner(ctx =>
|
|
{
|
|
ctx.AddTask(Localization.Core.Trying_SCSI_READ_LONG_16).IsIndeterminate();
|
|
|
|
sense = dev.ReadLong16(out buffer, out senseBuffer, false, 0,
|
|
(ushort)mediaTest.LongBlockSize, dev.Timeout, out _);
|
|
});
|
|
|
|
if(!sense)
|
|
mediaTest.ReadLong16Data = buffer;
|
|
}
|
|
}
|
|
|
|
mediaTest.MediumTypeName = mediumTypeName;
|
|
mediaTest.Manufacturer = mediumManufacturer;
|
|
mediaTest.Model = mediumModel;
|
|
mediaTest.MediaIsRecognized = mediaIsRecognized;
|
|
|
|
mediaTests.Add(mediaTest);
|
|
|
|
dev.AllowMediumRemoval(out buffer, dev.Timeout, out _);
|
|
dev.EjectTray(out buffer, dev.Timeout, out _);
|
|
}
|
|
|
|
report.SCSI.RemovableMedias = mediaTests;
|
|
}
|
|
else
|
|
{
|
|
report.SCSI.ReadCapabilities = reporter.ReportScsi();
|
|
|
|
if((report.SCSI.ReadCapabilities.SupportsReadLong == true ||
|
|
report.SCSI.ReadCapabilities.SupportsReadLong16 == true) &&
|
|
report.SCSI.ReadCapabilities.LongBlockSize == report.SCSI.ReadCapabilities.BlockSize)
|
|
if(AnsiConsole.Confirm($"[italic]{Localization.Core.Try_to_find_SCSI_READ_LONG_size
|
|
}[/]"))
|
|
AnsiConsole.Progress().AutoClear(true).HideCompleted(true).
|
|
Columns(new TaskDescriptionColumn(), new ProgressBarColumn(),
|
|
new PercentageColumn()).Start(ctx =>
|
|
{
|
|
ProgressTask task =
|
|
ctx.AddTask(Localization.Core.Trying_to_READ_LONG);
|
|
|
|
task.MaxValue = ushort.MaxValue;
|
|
|
|
for(ushort i = (ushort)report.SCSI.ReadCapabilities.BlockSize;; i++)
|
|
{
|
|
task.Value = i;
|
|
|
|
task.Description =
|
|
string.
|
|
Format(Localization.Core.Trying_READ_LONG_with_size_0,
|
|
i);
|
|
|
|
sense = report.SCSI.ReadCapabilities.SupportsReadLong16 == true
|
|
? dev.ReadLong16(out buffer, out senseBuffer, false,
|
|
0, i, dev.Timeout, out _)
|
|
: dev.ReadLong10(out buffer, out senseBuffer, false,
|
|
false, 0, i, dev.Timeout, out _);
|
|
|
|
if(!sense)
|
|
{
|
|
report.SCSI.ReadCapabilities.LongBlockSize = i;
|
|
|
|
break;
|
|
}
|
|
|
|
if(i == ushort.MaxValue)
|
|
break;
|
|
}
|
|
|
|
AaruConsole.WriteLine();
|
|
});
|
|
|
|
if(report.SCSI.ReadCapabilities.SupportsReadLong == true &&
|
|
report.SCSI.ReadCapabilities.LongBlockSize != report.SCSI.ReadCapabilities.BlockSize)
|
|
{
|
|
Core.Spectre.ProgressSingleSpinner(ctx =>
|
|
{
|
|
ctx.AddTask(Localization.Core.Trying_SCSI_READ_LONG_10).IsIndeterminate();
|
|
|
|
sense = dev.ReadLong10(out buffer, out senseBuffer, false, false, 0,
|
|
(ushort)report.SCSI.ReadCapabilities.LongBlockSize,
|
|
dev.Timeout, out _);
|
|
});
|
|
|
|
if(!sense)
|
|
report.SCSI.ReadCapabilities.ReadLong10Data = buffer;
|
|
}
|
|
|
|
if(report.SCSI.ReadCapabilities.SupportsReadLong16 == true &&
|
|
report.SCSI.ReadCapabilities.LongBlockSize != report.SCSI.ReadCapabilities.BlockSize)
|
|
{
|
|
Core.Spectre.ProgressSingleSpinner(ctx =>
|
|
{
|
|
ctx.AddTask(Localization.Core.Trying_SCSI_READ_LONG_16).IsIndeterminate();
|
|
|
|
sense = dev.ReadLong16(out buffer, out senseBuffer, false, 0,
|
|
report.SCSI.ReadCapabilities.LongBlockSize.Value,
|
|
dev.Timeout, out _);
|
|
});
|
|
|
|
if(!sense)
|
|
report.SCSI.ReadCapabilities.ReadLong16Data = buffer;
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
break;
|
|
default: throw new NotSupportedException(Localization.Core.Unknown_device_type);
|
|
}
|
|
|
|
var jsonFs = new FileStream(jsonFile, FileMode.Create);
|
|
var jsonSw = new StreamWriter(jsonFs);
|
|
|
|
jsonSw.Write(JsonConvert.SerializeObject(report, Formatting.Indented, new JsonSerializerSettings
|
|
{
|
|
NullValueHandling = NullValueHandling.Ignore
|
|
}));
|
|
|
|
jsonSw.Close();
|
|
jsonFs.Close();
|
|
|
|
using(var ctx = AaruContext.Create(Settings.Settings.LocalDbPath))
|
|
{
|
|
ctx.Reports.Add(new Report(report));
|
|
ctx.SaveChanges();
|
|
}
|
|
|
|
// TODO:
|
|
if(Settings.Settings.Current.ShareReports)
|
|
Remote.SubmitReport(report);
|
|
|
|
return (int)ErrorNumber.NoError;
|
|
}
|
|
} |