/// <summary>Sends an ATA command in 48-bit format</summary>
/// <returns>0 if no error occurred, otherwise, errno</returns>
/// <param name="ptId">Platform ID for executing the command</param>
/// <param name="fd">File handle</param>
/// <param name="buffer">Buffer for SCSI command response</param>
/// <param name="timeout">Timeout in seconds</param>
/// <param name="duration">Time it took to execute the command in milliseconds</param>
/// <param name="sense"><c>True</c> if ATA returned non-OK status</param>
/// <param name="registers">Registers to send to the device</param>
/// <param name="errorRegisters">Registers returned by the device</param>
/// <param name="protocol">ATA protocol to use</param>
/// <param name="transferRegister">What register contains the transfer length</param>
/// <param name="transferBlocks">Set to <c>true</c> if the transfer length is in block, otherwise it is in bytes</param>
/// <exception cref="InvalidOperationException">If the specified platform is not supported</exception>
internal static int SendAtaCommand(PlatformID ptId, object fd, AtaRegistersLba48 registers,
out AtaErrorRegistersLba48 errorRegisters, AtaProtocol protocol,
AtaTransferRegister transferRegister, ref byte[] buffer, uint timeout,
bool transferBlocks, out double duration, out bool sense)
{
switch (ptId)
{
case PlatformID.Win32NT:
{
// No check for Windows version. A 48-bit ATA disk simply does not work on earlier systems
return(Windows.Command.SendAtaCommand((SafeFileHandle)fd, registers, out errorRegisters, protocol,
ref buffer, timeout, out duration, out sense));
}
case PlatformID.Linux:
{
return(Linux.Command.SendAtaCommand((int)fd, registers, out errorRegisters, protocol,
transferRegister, ref buffer, timeout, transferBlocks,
out duration, out sense));
}
case PlatformID.FreeBSD:
{
return(FreeBSD.Command.SendAtaCommand((IntPtr)fd, registers, out errorRegisters, protocol,
ref buffer, timeout, out duration, out sense));
}
default: throw new InvalidOperationException($"Platform {ptId} not yet supported.");
}
}
/// <summary>Sends a SCSI command</summary>
/// <returns>0 if no error occurred, otherwise, errno</returns>
/// <param name="fd">File handle</param>
/// <param name="cdb">SCSI CDB</param>
/// <param name="buffer">Buffer for SCSI command response</param>
/// <param name="senseBuffer">Buffer with the SCSI sense</param>
/// <param name="timeout">Timeout in seconds</param>
/// <param name="direction">SCSI command transfer direction</param>
/// <param name="duration">Time it took to execute the command in milliseconds</param>
/// <param name="sense">
/// <c>True</c> if SCSI error returned non-OK status and <paramref name="senseBuffer" /> contains SCSI
/// sense
/// </param>
/// <exception cref="InvalidOperationException">If the specified platform is not supported</exception>
internal static int SendScsiCommand(object fd, byte[] cdb, ref byte[] buffer, out byte[] senseBuffer,
uint timeout, ScsiDirection direction, out double duration, out bool sense)
{
PlatformID ptId = DetectOS.GetRealPlatformID();
return(SendScsiCommand(ptId, fd, cdb, ref buffer, out senseBuffer, timeout, direction, out duration,
out sense));
}
/// <summary>Sends a MMC/SD command</summary>
/// <returns>The result of the command.</returns>
/// <param name="fd">File handle</param>
/// <param name="command">MMC/SD opcode</param>
/// <param name="buffer">Buffer for MMC/SD command response</param>
/// <param name="timeout">Timeout in seconds</param>
/// <param name="duration">Time it took to execute the command in milliseconds</param>
/// <param name="sense"><c>True</c> if MMC/SD returned non-OK status</param>
/// <param name="write"><c>True</c> if data is sent from host to card</param>
/// <param name="isApplication"><c>True</c> if command should be preceded with CMD55</param>
/// <param name="flags">Flags indicating kind and place of response</param>
/// <param name="blocks">How many blocks to transfer</param>
/// <param name="argument">Command argument</param>
/// <param name="response">Response registers</param>
/// <param name="blockSize">Size of block in bytes</param>
/// <exception cref="InvalidOperationException">If the specified platform is not supported</exception>
internal static int SendMmcCommand(object fd, MmcCommands command, bool write, bool isApplication,
MmcFlags flags, uint argument, uint blockSize, uint blocks,
ref byte[] buffer, out uint[] response, out double duration, out bool sense,
uint timeout = 0)
{
PlatformID ptId = DetectOS.GetRealPlatformID();
return(SendMmcCommand(ptId, (int)fd, command, write, isApplication, flags, argument, blockSize, blocks,
ref buffer, out response, out duration, out sense, timeout));
}
/// <summary>Sends an ATA command in 48-bit LBA format</summary>
/// <returns>0 if no error occurred, otherwise, errno</returns>
/// <param name="fd">File handle</param>
/// <param name="buffer">Buffer for SCSI command response</param>
/// <param name="timeout">Timeout in seconds</param>
/// <param name="duration">Time it took to execute the command in milliseconds</param>
/// <param name="sense"><c>True</c> if ATA returned non-OK status</param>
/// <param name="registers">Registers to send to the device</param>
/// <param name="errorRegisters">Registers returned by the device</param>
/// <param name="protocol">ATA protocol to use</param>
/// <param name="transferRegister">What register contains the transfer length</param>
/// <param name="transferBlocks">Set to <c>true</c> if the transfer length is in block, otherwise it is in bytes</param>
/// <exception cref="InvalidOperationException">If the specified platform is not supported</exception>
internal static int SendAtaCommand(object fd, AtaRegistersLba48 registers,
out AtaErrorRegistersLba48 errorRegisters, AtaProtocol protocol,
AtaTransferRegister transferRegister, ref byte[] buffer, uint timeout,
bool transferBlocks, out double duration, out bool sense)
{
PlatformID ptId = DetectOS.GetRealPlatformID();
return(SendAtaCommand(ptId, fd, registers, out errorRegisters, protocol, transferRegister, ref buffer,
timeout, transferBlocks, out duration, out sense));
}
internal static int ReOpen(PlatformID ptId, string devicePath, object fd, out object newFd)
{
switch (ptId)
{
case PlatformID.Win32NT: return(Windows.Command.ReOpen(devicePath, (SafeFileHandle)fd, out newFd));
case PlatformID.Linux: return(Linux.Command.ReOpen(devicePath, (int)fd, out newFd));
default: throw new InvalidOperationException($"Platform {ptId} not yet supported.");
}
}
internal static int BufferedOsRead(PlatformID ptId, object fd, out byte[] buffer, long offset, uint length,
out double duration)
{
switch (ptId)
{
case PlatformID.Win32NT:
return(Windows.Command.BufferedOsRead((SafeFileHandle)fd, out buffer, offset, length, out duration));
case PlatformID.Linux:
return(Linux.Command.BufferedOsRead((int)fd, out buffer, offset, length, out duration));
default: throw new InvalidOperationException($"Platform {ptId} not yet supported.");
}
}
internal static int SendMultipleMmcCommands(PlatformID ptId, object fd, Device.MmcSingleCommand[] commands,
out double duration, out bool sense, uint timeout = 0)
{
switch (ptId)
{
case PlatformID.Win32NT:
return(Windows.Command.SendMultipleMmcCommands((SafeFileHandle)fd, commands, out duration,
out sense, timeout));
case PlatformID.Linux:
return(Linux.Command.SendMultipleMmcCommands((int)fd, commands, out duration, out sense, timeout));
default: throw new InvalidOperationException($"Platform {ptId} not yet supported.");
}
}
/// <summary>Sends an ATA command in 28-bit LBA format</summary>
/// <returns>0 if no error occurred, otherwise, errno</returns>
/// <param name="ptId">Platform ID for executing the command</param>
/// <param name="fd">File handle</param>
/// <param name="buffer">Buffer for SCSI command response</param>
/// <param name="timeout">Timeout in seconds</param>
/// <param name="duration">Time it took to execute the command in milliseconds</param>
/// <param name="sense"><c>True</c> if ATA returned non-OK status</param>
/// <param name="registers">Registers to send to the device</param>
/// <param name="errorRegisters">Registers returned by the device</param>
/// <param name="protocol">ATA protocol to use</param>
/// <param name="transferRegister">What register contains the transfer length</param>
/// <param name="transferBlocks">Set to <c>true</c> if the transfer length is in block, otherwise it is in bytes</param>
/// <exception cref="InvalidOperationException">If the specified platform is not supported</exception>
internal static int SendAtaCommand(PlatformID ptId, object fd, AtaRegistersLba28 registers,
out AtaErrorRegistersLba28 errorRegisters, AtaProtocol protocol,
AtaTransferRegister transferRegister, ref byte[] buffer, uint timeout,
bool transferBlocks, out double duration, out bool sense)
{
switch (ptId)
{
case PlatformID.Win32NT:
{
if ((Environment.OSVersion.Version.Major == 5 && Environment.OSVersion.Version.Minor == 1 &&
(Environment.OSVersion.ServicePack == "Service Pack 1" ||
Environment.OSVersion.ServicePack == "")) ||
(Environment.OSVersion.Version.Major == 5 && Environment.OSVersion.Version.Minor == 0))
{
throw new InvalidOperationException("Windows XP or earlier is not supported.");
}
// Windows NT 4 or earlier, requires special ATA pass thru SCSI. But Aaru cannot run there (or can it?)
if (Environment.OSVersion.Version.Major <= 4)
{
throw new InvalidOperationException("Windows NT 4.0 or earlier is not supported.");
}
return(Windows.Command.SendAtaCommand((SafeFileHandle)fd, registers, out errorRegisters, protocol,
ref buffer, timeout, out duration, out sense));
}
case PlatformID.Linux:
{
return(Linux.Command.SendAtaCommand((int)fd, registers, out errorRegisters, protocol,
transferRegister, ref buffer, timeout, transferBlocks,
out duration, out sense));
}
case PlatformID.FreeBSD:
{
return(FreeBSD.Command.SendAtaCommand((IntPtr)fd, registers, out errorRegisters, protocol,
ref buffer, timeout, out duration, out sense));
}
default: throw new InvalidOperationException($"Platform {ptId} not yet supported.");
}
}
/// <summary>Sends a MMC/SD command</summary>
/// <returns>The result of the command.</returns>
/// <param name="ptId">Platform ID for executing the command</param>
/// <param name="fd">File handle</param>
/// <param name="command">MMC/SD opcode</param>
/// <param name="buffer">Buffer for MMC/SD command response</param>
/// <param name="timeout">Timeout in seconds</param>
/// <param name="duration">Time it took to execute the command in milliseconds</param>
/// <param name="sense"><c>True</c> if MMC/SD returned non-OK status</param>
/// <param name="write"><c>True</c> if data is sent from host to card</param>
/// <param name="isApplication"><c>True</c> if command should be preceded with CMD55</param>
/// <param name="flags">Flags indicating kind and place of response</param>
/// <param name="blocks">How many blocks to transfer</param>
/// <param name="argument">Command argument</param>
/// <param name="response">Response registers</param>
/// <param name="blockSize">Size of block in bytes</param>
/// <exception cref="InvalidOperationException">If the specified platform is not supported</exception>
internal static int SendMmcCommand(PlatformID ptId, object fd, MmcCommands command, bool write,
bool isApplication, MmcFlags flags, uint argument, uint blockSize,
uint blocks, ref byte[] buffer, out uint[] response, out double duration,
out bool sense, uint timeout = 0)
{
switch (ptId)
{
case PlatformID.Win32NT:
return(Windows.Command.SendMmcCommand((SafeFileHandle)fd, command, write, isApplication, flags,
argument, blockSize, blocks, ref buffer, out response,
out duration, out sense, timeout));
case PlatformID.Linux:
return(Linux.Command.SendMmcCommand((int)fd, command, write, isApplication, flags, argument,
blockSize, blocks, ref buffer, out response, out duration,
out sense, timeout));
default: throw new InvalidOperationException($"Platform {ptId} not yet supported.");
}
}
/// <summary>Sends a SCSI command</summary>
/// <returns>0 if no error occurred, otherwise, errno</returns>
/// <param name="ptId">Platform ID for executing the command</param>
/// <param name="fd">File handle</param>
/// <param name="cdb">SCSI CDB</param>
/// <param name="buffer">Buffer for SCSI command response</param>
/// <param name="senseBuffer">Buffer with the SCSI sense</param>
/// <param name="timeout">Timeout in seconds</param>
/// <param name="direction">SCSI command transfer direction</param>
/// <param name="duration">Time it took to execute the command in milliseconds</param>
/// <param name="sense">
/// <c>True</c> if SCSI error returned non-OK status and <paramref name="senseBuffer" /> contains SCSI
/// sense
/// </param>
/// <exception cref="InvalidOperationException">If the specified platform is not supported</exception>
internal static int SendScsiCommand(PlatformID ptId, object fd, byte[] cdb, ref byte[] buffer,
out byte[] senseBuffer, uint timeout, ScsiDirection direction,
out double duration, out bool sense)
{
switch (ptId)
{
case PlatformID.Win32NT:
{
ScsiIoctlDirection dir;
switch (direction)
{
case ScsiDirection.In:
dir = ScsiIoctlDirection.In;
break;
case ScsiDirection.Out:
dir = ScsiIoctlDirection.Out;
break;
default:
dir = ScsiIoctlDirection.Unspecified;
break;
}
return(Windows.Command.SendScsiCommand((SafeFileHandle)fd, cdb, ref buffer, out senseBuffer,
timeout, dir, out duration, out sense));
}
case PlatformID.Linux:
{
Linux.ScsiIoctlDirection dir;
switch (direction)
{
case ScsiDirection.In:
dir = Linux.ScsiIoctlDirection.In;
break;
case ScsiDirection.Out:
dir = Linux.ScsiIoctlDirection.Out;
break;
case ScsiDirection.Bidirectional:
dir = Linux.ScsiIoctlDirection.Unspecified;
break;
case ScsiDirection.None:
dir = Linux.ScsiIoctlDirection.None;
break;
default:
dir = Linux.ScsiIoctlDirection.Unknown;
break;
}
return(Linux.Command.SendScsiCommand((int)fd, cdb, ref buffer, out senseBuffer, timeout, dir,
out duration, out sense));
}
case PlatformID.FreeBSD:
{
CcbFlags flags = 0;
switch (direction)
{
case ScsiDirection.In:
flags = CcbFlags.CamDirIn;
break;
case ScsiDirection.Out:
flags = CcbFlags.CamDirOut;
break;
case ScsiDirection.Bidirectional:
flags = CcbFlags.CamDirBoth;
break;
case ScsiDirection.None:
flags = CcbFlags.CamDirNone;
break;
}
return(IntPtr.Size == 8
? FreeBSD.Command.SendScsiCommand64((IntPtr)fd, cdb, ref buffer, out senseBuffer,
timeout, flags, out duration, out sense)
: FreeBSD.Command.SendScsiCommand((IntPtr)fd, cdb, ref buffer, out senseBuffer, timeout,
flags, out duration, out sense));
}
default: throw new InvalidOperationException($"Platform {ptId} not yet supported.");
}
}
/// <summary>Initializes the dump log</summary>
/// <param name="outputFile">Output log file</param>
/// <param name="dev">Device</param>
/// <param name="private">Disable saving paths or serial numbers in log</param>
public DumpLog(string outputFile, Device dev, bool @private)
{
if (string.IsNullOrEmpty(outputFile))
{
return;
}
_logSw = new StreamWriter(outputFile, true);
_logSw.WriteLine("Start logging at {0}", DateTime.Now);
PlatformID platId = DetectOS.GetRealPlatformID();
string platVer = DetectOS.GetVersion();
var assemblyVersion =
Attribute.GetCustomAttribute(typeof(DumpLog).Assembly, typeof(AssemblyInformationalVersionAttribute)) as
AssemblyInformationalVersionAttribute;
_logSw.WriteLine("################# System information #################");
_logSw.WriteLine("{0} {1} ({2}-bit)", DetectOS.GetPlatformName(platId, platVer), platVer,
Environment.Is64BitOperatingSystem ? 64 : 32);
if (DetectOS.IsMono)
{
_logSw.WriteLine("Mono {0}", Version.GetMonoVersion());
}
else if (DetectOS.IsNetCore)
{
_logSw.WriteLine(".NET Core {0}", Version.GetNetCoreVersion());
}
else
{
_logSw.WriteLine(RuntimeInformation.FrameworkDescription);
}
_logSw.WriteLine();
_logSw.WriteLine("################# Program information ################");
_logSw.WriteLine("Aaru {0}", assemblyVersion?.InformationalVersion);
_logSw.WriteLine("Running in {0}-bit", Environment.Is64BitProcess ? 64 : 32);
_logSw.WriteLine("Running as superuser: {0}", DetectOS.IsAdmin ? "Yes" : "No");
#if DEBUG
_logSw.WriteLine("DEBUG version");
#endif
if (@private)
{
string[] args = Environment.GetCommandLineArgs();
for (int i = 0; i < args.Length; i++)
{
if (args[i].StartsWith("/dev", StringComparison.OrdinalIgnoreCase) ||
args[i].StartsWith("aaru://", StringComparison.OrdinalIgnoreCase))
{
continue;
}
try
{
args[i] = Path.GetFileName(args[i]);
}
catch
{
// Do nothing
}
}
_logSw.WriteLine("Command line: {0}", string.Join(" ", args));
}
else
{
_logSw.WriteLine("Command line: {0}", Environment.CommandLine);
}
_logSw.WriteLine();
if (dev.IsRemote)
{
_logSw.WriteLine("################# Remote information #################");
_logSw.WriteLine("Server: {0}", dev.RemoteApplication);
_logSw.WriteLine("Version: {0}", dev.RemoteVersion);
_logSw.WriteLine("Operating system: {0} {1}", dev.RemoteOperatingSystem,
dev.RemoteOperatingSystemVersion);
_logSw.WriteLine("Architecture: {0}", dev.RemoteArchitecture);
_logSw.WriteLine("Protocol version: {0}", dev.RemoteProtocolVersion);
_logSw.WriteLine("Running as superuser: {0}", dev.IsRemoteAdmin ? "Yes" : "No");
_logSw.WriteLine("######################################################");
}
_logSw.WriteLine("################# Device information #################");
_logSw.WriteLine("Manufacturer: {0}", dev.Manufacturer);
_logSw.WriteLine("Model: {0}", dev.Model);
_logSw.WriteLine("Firmware revision: {0}", dev.FirmwareRevision);
if (!@private)
{
_logSw.WriteLine("Serial number: {0}", dev.Serial);
}
_logSw.WriteLine("Removable device: {0}", dev.IsRemovable);
_logSw.WriteLine("Device type: {0}", dev.Type);
_logSw.WriteLine("CompactFlash device: {0}", dev.IsCompactFlash);
_logSw.WriteLine("PCMCIA device: {0}", dev.IsPcmcia);
_logSw.WriteLine("USB device: {0}", dev.IsUsb);
if (dev.IsUsb)
{
_logSw.WriteLine("USB manufacturer: {0}", dev.UsbManufacturerString);
_logSw.WriteLine("USB product: {0}", dev.UsbProductString);
if (!@private)
{
_logSw.WriteLine("USB serial: {0}", dev.UsbSerialString);
}
_logSw.WriteLine("USB vendor ID: {0:X4}h", dev.UsbVendorId);
_logSw.WriteLine("USB product ID: {0:X4}h", dev.UsbProductId);
}
_logSw.WriteLine("FireWire device: {0}", dev.IsFireWire);
if (dev.IsFireWire)
{
_logSw.WriteLine("FireWire vendor: {0}", dev.FireWireVendorName);
_logSw.WriteLine("FireWire model: {0}", dev.FireWireModelName);
if (!@private)
{
_logSw.WriteLine("FireWire GUID: 0x{0:X16}", dev.FireWireGuid);
}
_logSw.WriteLine("FireWire vendor ID: 0x{0:X8}", dev.FireWireVendor);
_logSw.WriteLine("FireWire product ID: 0x{0:X8}", dev.FireWireModel);
}
_logSw.WriteLine("######################################################");
_logSw.WriteLine();
_logSw.WriteLine("################ Dumping progress log ################");
_logSw.Flush();
}
protected void OnBtnSaveClicked(object sender, EventArgs e)
{
var dlgSave = new SaveFileDialog
{
CheckFileExists = true
};
dlgSave.Filters.Add(new FileFilter
{
Extensions = new[]
{
"log"
},
Name = "Log files"
});
DialogResult result = dlgSave.ShowDialog(this);
if (result != DialogResult.Ok)
{
return;
}
try
{
var logFs = new FileStream(dlgSave.FileName, FileMode.Create, FileAccess.ReadWrite);
var logSw = new StreamWriter(logFs);
logSw.WriteLine("Log saved at {0}", DateTime.Now);
PlatformID platId = DetectOS.GetRealPlatformID();
string platVer = DetectOS.GetVersion();
var assemblyVersion =
Attribute.GetCustomAttribute(typeof(AaruConsole).Assembly,
typeof(AssemblyInformationalVersionAttribute)) as
AssemblyInformationalVersionAttribute;
logSw.WriteLine("################# System information #################");
logSw.WriteLine("{0} {1} ({2}-bit)", DetectOS.GetPlatformName(platId, platVer), platVer,
Environment.Is64BitOperatingSystem ? 64 : 32);
if (DetectOS.IsMono)
{
logSw.WriteLine("Mono {0}", Version.GetMonoVersion());
}
else if (DetectOS.IsNetCore)
{
logSw.WriteLine(".NET Core {0}", Version.GetNetCoreVersion());
}
else
{
logSw.WriteLine(RuntimeInformation.FrameworkDescription);
}
logSw.WriteLine();
logSw.WriteLine("################# Program information ################");
logSw.WriteLine("Aaru {0}", assemblyVersion?.InformationalVersion);
logSw.WriteLine("Running in {0}-bit", Environment.Is64BitProcess ? 64 : 32);
logSw.WriteLine("Running GUI mode using {0}", Application.Instance.Platform.ID);
#if DEBUG
logSw.WriteLine("DEBUG version");
#endif
logSw.WriteLine("Command line: {0}", Environment.CommandLine);
logSw.WriteLine();
logSw.WriteLine("################# Console ################");
foreach (LogEntry entry in ConsoleHandler.Entries)
{
if (entry.Type != "Info")
{
logSw.WriteLine("{0}: ({1}) {2}", entry.Timestamp, entry.Type.ToLower(), entry.Message);
}
else
{
logSw.WriteLine("{0}: {1}", entry.Timestamp, entry.Message);
}
}
logSw.Close();
logFs.Close();
}
catch (Exception exception)
{
MessageBox.Show("Exception {0} trying to save logfile, details has been sent to console.",
exception.Message);
AaruConsole.ErrorWriteLine("Console", exception.Message);
AaruConsole.ErrorWriteLine("Console", exception.StackTrace);
}
}
public static void SaveSettings()
{
try
{
PlatformID ptId = DetectOS.GetRealPlatformID();
switch (ptId)
{
// In case of macOS or iOS settings will be saved in ~/Library/Preferences/com.claunia.aaru.plist
case PlatformID.MacOSX:
case PlatformID.iOS:
{
var root = new NSDictionary
{
{
"SaveReportsGlobally", Current.SaveReportsGlobally
},
{
"ShareReports", Current.ShareReports
},
{
"GdprCompliance", Current.GdprCompliance
},
{
"EnableDecryption", Current.EnableDecryption
}
};
if (Current.Stats != null)
{
var stats = new NSDictionary
{
{
"ShareStats", Current.Stats.ShareStats
},
{
"CommandStats", Current.Stats.CommandStats
},
{
"DeviceStats", Current.Stats.DeviceStats
},
{
"FilesystemStats", Current.Stats.FilesystemStats
},
{
"FilterStats", Current.Stats.FilterStats
},
{
"MediaImageStats", Current.Stats.MediaImageStats
},
{
"MediaScanStats", Current.Stats.MediaScanStats
},
{
"PartitionStats", Current.Stats.PartitionStats
},
{
"MediaStats", Current.Stats.MediaStats
},
{
"VerifyStats", Current.Stats.VerifyStats
}
};
root.Add("Stats", stats);
}
string preferencesPath =
Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), "Library",
"Preferences");
string preferencesFilePath = Path.Combine(preferencesPath, "com.claunia.aaru.plist");
var fs = new FileStream(preferencesFilePath, FileMode.Create);
BinaryPropertyListWriter.Write(fs, root);
fs.Close();
}
break;
#if !NETSTANDARD2_0
// In case of Windows settings will be saved in the registry: HKLM/SOFTWARE/Claunia.com/Aaru
case PlatformID.Win32NT:
case PlatformID.Win32S:
case PlatformID.Win32Windows:
case PlatformID.WinCE:
case PlatformID.WindowsPhone:
{
RegistryKey parentKey = Registry.CurrentUser.OpenSubKey("SOFTWARE", true)?.
CreateSubKey("Claunia.com");
RegistryKey key = parentKey?.CreateSubKey("Aaru");
if (key != null)
{
key.SetValue("SaveReportsGlobally", Current.SaveReportsGlobally);
key.SetValue("ShareReports", Current.ShareReports);
key.SetValue("GdprCompliance", Current.GdprCompliance);
key.SetValue("EnableDecryption", Current.EnableDecryption);
if (Current.Stats != null)
{
key.SetValue("Statistics", true);
key.SetValue("ShareStats", Current.Stats.ShareStats);
key.SetValue("CommandStats", Current.Stats.CommandStats);
key.SetValue("DeviceStats", Current.Stats.DeviceStats);
key.SetValue("FilesystemStats", Current.Stats.FilesystemStats);
key.SetValue("FilterStats", Current.Stats.FilterStats);
key.SetValue("MediaImageStats", Current.Stats.MediaImageStats);
key.SetValue("MediaScanStats", Current.Stats.MediaScanStats);
key.SetValue("PartitionStats", Current.Stats.PartitionStats);
key.SetValue("MediaStats", Current.Stats.MediaStats);
key.SetValue("VerifyStats", Current.Stats.VerifyStats);
}
else
{
key.SetValue("Statistics", true);
key.DeleteValue("ShareStats", false);
key.DeleteValue("CommandStats", false);
key.DeleteValue("DeviceStats", false);
key.DeleteValue("FilesystemStats", false);
key.DeleteValue("MediaImageStats", false);
key.DeleteValue("MediaScanStats", false);
key.DeleteValue("PartitionStats", false);
key.DeleteValue("MediaStats", false);
key.DeleteValue("VerifyStats", false);
}
}
}
break;
#endif
// Otherwise, settings will be saved in ~/.config/Aaru.xml
default:
{
string homePath = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
string xdgConfigPath =
Path.Combine(homePath,
Environment.GetEnvironmentVariable(XDG_CONFIG_HOME) ??
XDG_CONFIG_HOME_RESOLVED);
string settingsPath = Path.Combine(xdgConfigPath, "Aaru.xml");
if (!Directory.Exists(xdgConfigPath))
{
Directory.CreateDirectory(xdgConfigPath);
}
var fs = new FileStream(settingsPath, FileMode.Create);
var xs = new XmlSerializer(Current.GetType());
xs.Serialize(fs, Current);
fs.Close();
}
break;
}
}
#pragma warning disable RECS0022 // A catch clause that catches System.Exception and has an empty body
catch
{
// ignored
}
#pragma warning restore RECS0022 // A catch clause that catches System.Exception and has an empty body
}
/// <summary>Loads settings</summary>
public static void LoadSettings()
{
Current = new DicSettings();
PlatformID ptId = DetectOS.GetRealPlatformID();
string homePath = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
LocalDbPath = "local.db";
string oldMainDbPath = "master.db";
MainDbPath = "main.db";
try
{
switch (ptId)
{
// In case of macOS or iOS statistics and reports will be saved in ~/Library/Application Support/Claunia.com/Aaru
case PlatformID.MacOSX:
case PlatformID.iOS:
{
string appSupportPath =
Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), "Library",
"Application Support", "Claunia.com");
if (!Directory.Exists(appSupportPath))
{
Directory.CreateDirectory(appSupportPath);
}
string dicPath = Path.Combine(appSupportPath, "DiscImageChef");
string aaruPath = Path.Combine(appSupportPath, "Aaru");
if (Directory.Exists(dicPath) &&
!Directory.Exists(aaruPath))
{
Directory.Move(dicPath, aaruPath);
}
if (!Directory.Exists(aaruPath))
{
Directory.CreateDirectory(aaruPath);
}
LocalDbPath = Path.Combine(aaruPath, LocalDbPath);
MainDbPath = Path.Combine(aaruPath, MainDbPath);
oldMainDbPath = Path.Combine(aaruPath, oldMainDbPath);
ReportsPath = Path.Combine(aaruPath, "Reports");
if (!Directory.Exists(ReportsPath))
{
Directory.CreateDirectory(ReportsPath);
}
StatsPath = Path.Combine(aaruPath, "Statistics");
if (!Directory.Exists(StatsPath))
{
Directory.CreateDirectory(StatsPath);
}
}
break;
// In case of Windows statistics and reports will be saved in %APPDATA%\Claunia.com\Aaru
case PlatformID.Win32NT:
case PlatformID.Win32S:
case PlatformID.Win32Windows:
case PlatformID.WinCE:
case PlatformID.WindowsPhone:
{
string appSupportPath =
Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
"Claunia.com");
if (!Directory.Exists(appSupportPath))
{
Directory.CreateDirectory(appSupportPath);
}
string dicPath = Path.Combine(appSupportPath, "DiscImageChef");
string aaruPath = Path.Combine(appSupportPath, "Aaru");
if (Directory.Exists(dicPath) &&
!Directory.Exists(aaruPath))
{
Directory.Move(dicPath, aaruPath);
}
if (!Directory.Exists(aaruPath))
{
Directory.CreateDirectory(aaruPath);
}
LocalDbPath = Path.Combine(aaruPath, LocalDbPath);
MainDbPath = Path.Combine(aaruPath, MainDbPath);
oldMainDbPath = Path.Combine(aaruPath, oldMainDbPath);
ReportsPath = Path.Combine(aaruPath, "Reports");
if (!Directory.Exists(ReportsPath))
{
Directory.CreateDirectory(ReportsPath);
}
StatsPath = Path.Combine(aaruPath, "Statistics");
if (!Directory.Exists(StatsPath))
{
Directory.CreateDirectory(StatsPath);
}
}
break;
// Otherwise, statistics and reports will be saved in ~/.claunia.com/Aaru
default:
{
string xdgDataPath =
Path.Combine(homePath,
Environment.GetEnvironmentVariable(XDG_DATA_HOME) ?? XDG_DATA_HOME_RESOLVED);
string oldDicPath = Path.Combine(homePath, ".claunia.com", "DiscImageChef");
string dicPath = Path.Combine(xdgDataPath, "DiscImageChef");
string aaruPath = Path.Combine(xdgDataPath, "Aaru");
if (Directory.Exists(oldDicPath) &&
!Directory.Exists(aaruPath))
{
Directory.Move(oldDicPath, aaruPath);
Directory.Delete(Path.Combine(homePath, ".claunia.com"));
}
if (Directory.Exists(dicPath) &&
!Directory.Exists(aaruPath))
{
Directory.Move(dicPath, aaruPath);
}
if (!Directory.Exists(aaruPath))
{
Directory.CreateDirectory(aaruPath);
}
LocalDbPath = Path.Combine(aaruPath, LocalDbPath);
MainDbPath = Path.Combine(aaruPath, MainDbPath);
oldMainDbPath = Path.Combine(aaruPath, oldMainDbPath);
ReportsPath = Path.Combine(aaruPath, "Reports");
if (!Directory.Exists(ReportsPath))
{
Directory.CreateDirectory(ReportsPath);
}
StatsPath = Path.Combine(aaruPath, "Statistics");
if (!Directory.Exists(StatsPath))
{
Directory.CreateDirectory(StatsPath);
}
}
break;
}
if (File.Exists(oldMainDbPath))
{
File.Move(oldMainDbPath, MainDbPath);
}
}
catch
{
ReportsPath = null;
}
FileStream prefsFs = null;
StreamReader prefsSr = null;
try
{
switch (ptId)
{
// In case of macOS or iOS settings will be saved in ~/Library/Preferences/com.claunia.aaru.plist
case PlatformID.MacOSX:
case PlatformID.iOS:
{
string preferencesPath =
Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), "Library",
"Preferences");
string dicPreferencesFilePath =
Path.Combine(preferencesPath, "com.claunia.discimagechef.plist");
string preferencesFilePath = Path.Combine(preferencesPath, "com.claunia.aaru.plist");
if (File.Exists(dicPreferencesFilePath))
{
File.Move(dicPreferencesFilePath, preferencesFilePath);
}
if (!File.Exists(preferencesFilePath))
{
SetDefaultSettings();
SaveSettings();
}
prefsFs = new FileStream(preferencesFilePath, FileMode.Open, FileAccess.Read);
var parsedPreferences = (NSDictionary)BinaryPropertyListParser.Parse(prefsFs);
if (parsedPreferences != null)
{
Current.SaveReportsGlobally =
parsedPreferences.TryGetValue("SaveReportsGlobally", out NSObject obj) &&
((NSNumber)obj).ToBool();
Current.ShareReports = parsedPreferences.TryGetValue("ShareReports", out obj) &&
((NSNumber)obj).ToBool();
Current.EnableDecryption = parsedPreferences.TryGetValue("EnableDecryption", out obj) &&
((NSNumber)obj).ToBool();
if (parsedPreferences.TryGetValue("Stats", out obj))
{
var stats = (NSDictionary)obj;
if (stats != null)
{
Current.Stats = new StatsSettings
{
ShareStats = stats.TryGetValue("ShareStats", out NSObject obj2) &&
((NSNumber)obj2).ToBool(),
CommandStats = stats.TryGetValue("CommandStats", out obj2) &&
((NSNumber)obj2).ToBool(),
DeviceStats = stats.TryGetValue("DeviceStats", out obj2) &&
((NSNumber)obj2).ToBool(),
FilesystemStats =
stats.TryGetValue("FilesystemStats", out obj2) && ((NSNumber)obj2).ToBool(),
FilterStats = stats.TryGetValue("FilterStats", out obj2) &&
((NSNumber)obj2).ToBool(),
MediaImageStats =
stats.TryGetValue("MediaImageStats", out obj2) && ((NSNumber)obj2).ToBool(),
MediaScanStats =
stats.TryGetValue("MediaScanStats", out obj2) && ((NSNumber)obj2).ToBool(),
PartitionStats =
stats.TryGetValue("PartitionStats", out obj2) && ((NSNumber)obj2).ToBool(),
MediaStats = stats.TryGetValue("MediaStats", out obj2) &&
((NSNumber)obj2).ToBool(),
VerifyStats = stats.TryGetValue("VerifyStats", out obj2) &&
((NSNumber)obj2).ToBool()
}
}
;
}
else
{
Current.Stats = null;
}
Current.GdprCompliance = parsedPreferences.TryGetValue("GdprCompliance", out obj)
? (ulong)((NSNumber)obj).ToLong() : 0;
prefsFs.Close();
}
else
{
prefsFs.Close();
SetDefaultSettings();
SaveSettings();
}
}
break;
#if !NETSTANDARD2_0
// In case of Windows settings will be saved in the registry: HKLM/SOFTWARE/Claunia.com/Aaru
case PlatformID.Win32NT:
case PlatformID.Win32S:
case PlatformID.Win32Windows:
case PlatformID.WinCE:
case PlatformID.WindowsPhone:
{
RegistryKey parentKey = Registry.CurrentUser.OpenSubKey("SOFTWARE")?.OpenSubKey("Claunia.com");
if (parentKey == null)
{
SetDefaultSettings();
SaveSettings();
return;
}
RegistryKey dicKey = parentKey.OpenSubKey("DiscImageChef");
RegistryKey key = parentKey.OpenSubKey("Aaru");
bool stats;
if (dicKey != null &&
key == null)
{
Current.SaveReportsGlobally = Convert.ToBoolean(dicKey.GetValue("SaveReportsGlobally"));
Current.ShareReports = Convert.ToBoolean(dicKey.GetValue("ShareReports"));
Current.GdprCompliance = Convert.ToUInt64(dicKey.GetValue("GdprCompliance"));
Current.EnableDecryption = Convert.ToBoolean(dicKey.GetValue("EnableDecryption"));
stats = Convert.ToBoolean(dicKey.GetValue("Statistics"));
if (stats)
{
Current.Stats = new StatsSettings
{
ShareStats = Convert.ToBoolean(dicKey.GetValue("ShareStats")),
CommandStats = Convert.ToBoolean(dicKey.GetValue("CommandStats")),
DeviceStats = Convert.ToBoolean(dicKey.GetValue("DeviceStats")),
FilesystemStats = Convert.ToBoolean(dicKey.GetValue("FilesystemStats")),
FilterStats = Convert.ToBoolean(dicKey.GetValue("FilterStats")),
MediaImageStats = Convert.ToBoolean(dicKey.GetValue("MediaImageStats")),
MediaScanStats = Convert.ToBoolean(dicKey.GetValue("MediaScanStats")),
PartitionStats = Convert.ToBoolean(dicKey.GetValue("PartitionStats")),
MediaStats = Convert.ToBoolean(dicKey.GetValue("MediaStats")),
VerifyStats = Convert.ToBoolean(dicKey.GetValue("VerifyStats"))
}
}
;
SaveSettings();
parentKey.DeleteSubKeyTree("DiscImageChef");
return;
}
if (key == null)
{
SetDefaultSettings();
SaveSettings();
return;
}
Current.SaveReportsGlobally = Convert.ToBoolean(key.GetValue("SaveReportsGlobally"));
Current.ShareReports = Convert.ToBoolean(key.GetValue("ShareReports"));
Current.GdprCompliance = Convert.ToUInt64(key.GetValue("GdprCompliance"));
Current.EnableDecryption = Convert.ToBoolean(key.GetValue("EnableDecryption"));
stats = Convert.ToBoolean(key.GetValue("Statistics"));
if (stats)
{
Current.Stats = new StatsSettings
{
ShareStats = Convert.ToBoolean(key.GetValue("ShareStats")),
CommandStats = Convert.ToBoolean(key.GetValue("CommandStats")),
DeviceStats = Convert.ToBoolean(key.GetValue("DeviceStats")),
FilesystemStats = Convert.ToBoolean(key.GetValue("FilesystemStats")),
FilterStats = Convert.ToBoolean(key.GetValue("FilterStats")),
MediaImageStats = Convert.ToBoolean(key.GetValue("MediaImageStats")),
MediaScanStats = Convert.ToBoolean(key.GetValue("MediaScanStats")),
PartitionStats = Convert.ToBoolean(key.GetValue("PartitionStats")),
MediaStats = Convert.ToBoolean(key.GetValue("MediaStats")),
VerifyStats = Convert.ToBoolean(key.GetValue("VerifyStats"))
}
}
;
}
break;
#endif
// Otherwise, settings will be saved in ~/.config/Aaru.xml
default:
{
string oldConfigPath =
Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".config");
string oldSettingsPath = Path.Combine(oldConfigPath, "DiscImageChef.xml");
string xdgConfigPath =
Path.Combine(homePath,
Environment.GetEnvironmentVariable(XDG_CONFIG_HOME) ??
XDG_CONFIG_HOME_RESOLVED);
string dicSettingsPath = Path.Combine(xdgConfigPath, "DiscImageChef.xml");
string settingsPath = Path.Combine(xdgConfigPath, "Aaru.xml");
if (File.Exists(oldSettingsPath) &&
!File.Exists(settingsPath))
{
if (!Directory.Exists(xdgConfigPath))
{
Directory.CreateDirectory(xdgConfigPath);
}
File.Move(oldSettingsPath, settingsPath);
}
if (File.Exists(dicSettingsPath) &&
!File.Exists(settingsPath))
{
File.Move(dicSettingsPath, settingsPath);
}
if (!File.Exists(settingsPath))
{
SetDefaultSettings();
SaveSettings();
return;
}
var xs = new XmlSerializer(Current.GetType());
prefsSr = new StreamReader(settingsPath);
Current = (DicSettings)xs.Deserialize(prefsSr);
}
break;
}
}
catch
{
prefsFs?.Close();
prefsSr?.Close();
SetDefaultSettings();
SaveSettings();
}
}
/// <summary>Loads settings</summary>
public static void LoadSettings()
{
Current = new SetSettings();
PlatformID ptId = DetectOS.GetRealPlatformID();
string homePath = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
FileStream prefsFs = null;
StreamReader prefsSr = null;
try
{
switch (ptId)
{
// In case of macOS or iOS settings will be saved in ~/Library/Preferences/com.claunia.romrepomgr.plist
case PlatformID.MacOSX:
case PlatformID.iOS:
{
string preferencesPath =
Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), "Library",
"Preferences");
string preferencesFilePath = Path.Combine(preferencesPath, "com.claunia.romrepomgr.plist");
if (!File.Exists(preferencesFilePath))
{
SetDefaultSettings();
SaveSettings();
}
prefsFs = new FileStream(preferencesFilePath, FileMode.Open, FileAccess.Read);
var parsedPreferences = (NSDictionary)BinaryPropertyListParser.Parse(prefsFs);
if (parsedPreferences != null)
{
NSObject obj;
Current.DatabasePath = parsedPreferences.TryGetValue("DatabasePath", out obj)
? ((NSString)obj).ToString() : null;
Current.RepositoryPath = parsedPreferences.TryGetValue("RepositoryPath", out obj)
? ((NSString)obj).ToString() : null;
Current.TemporaryFolder = parsedPreferences.TryGetValue("TemporaryFolder", out obj)
? ((NSString)obj).ToString() : null;
Current.UnArchiverPath = parsedPreferences.TryGetValue("UnArchiverPath", out obj)
? ((NSString)obj).ToString() : null;
prefsFs.Close();
}
else
{
prefsFs.Close();
SetDefaultSettings();
SaveSettings();
}
}
break;
#if !NETSTANDARD2_0
// In case of Windows settings will be saved in the registry: HKLM/SOFTWARE/Claunia.com/RomRepoMgr
case PlatformID.Win32NT when OperatingSystem.IsWindows():
case PlatformID.Win32S when OperatingSystem.IsWindows():
case PlatformID.Win32Windows when OperatingSystem.IsWindows():
case PlatformID.WinCE when OperatingSystem.IsWindows():
case PlatformID.WindowsPhone when OperatingSystem.IsWindows():
{
RegistryKey parentKey = Registry.CurrentUser.OpenSubKey("SOFTWARE")?.OpenSubKey("Claunia.com");
if (parentKey == null)
{
SetDefaultSettings();
SaveSettings();
return;
}
RegistryKey key = parentKey.OpenSubKey("RomRepoMgr");
if (key == null)
{
SetDefaultSettings();
SaveSettings();
return;
}
Current.DatabasePath = key.GetValue("DatabasePath") as string;
Current.RepositoryPath = key.GetValue("RepositoryPath") as string;
Current.TemporaryFolder = key.GetValue("TemporaryFolder") as string;
Current.UnArchiverPath = key.GetValue("UnArchiverPath") as string;
}
break;
#endif
// Otherwise, settings will be saved in ~/.config/RomRepoMgr.json
default:
{
string xdgConfigPath =
Path.Combine(homePath,
Environment.GetEnvironmentVariable(XDG_CONFIG_HOME) ??
XDG_CONFIG_HOME_RESOLVED);
string settingsPath = Path.Combine(xdgConfigPath, "RomRepoMgr.json");
if (!File.Exists(settingsPath))
{
SetDefaultSettings();
SaveSettings();
return;
}
prefsSr = new StreamReader(settingsPath);
Current = JsonSerializer.Deserialize <SetSettings>(prefsSr.ReadToEnd(), new JsonSerializerOptions
{
AllowTrailingCommas = true,
PropertyNameCaseInsensitive = true,
ReadCommentHandling = JsonCommentHandling.Skip,
WriteIndented = true
});
}
break;
}
}
catch
{
prefsFs?.Close();
prefsSr?.Close();
SetDefaultSettings();
SaveSettings();
}
}
public static void SaveSettings()
{
try
{
PlatformID ptId = DetectOS.GetRealPlatformID();
switch (ptId)
{
// In case of macOS or iOS settings will be saved in ~/Library/Preferences/com.claunia.romrepomgr.plist
case PlatformID.MacOSX:
case PlatformID.iOS:
{
var root = new NSDictionary
{
{
"DatabasePath", Current.DatabasePath
},
{
"RepositoryPath", Current.RepositoryPath
},
{
"TemporaryFolder", Current.TemporaryFolder
},
{
"UnArchiverPath", Current.UnArchiverPath
}
};
string preferencesPath =
Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), "Library",
"Preferences");
string preferencesFilePath = Path.Combine(preferencesPath, "com.claunia.romrepomgr.plist");
var fs = new FileStream(preferencesFilePath, FileMode.Create);
BinaryPropertyListWriter.Write(fs, root);
fs.Close();
}
break;
#if !NETSTANDARD2_0
// In case of Windows settings will be saved in the registry: HKLM/SOFTWARE/Claunia.com/RomRepoMgr
case PlatformID.Win32NT when OperatingSystem.IsWindows():
case PlatformID.Win32S when OperatingSystem.IsWindows():
case PlatformID.Win32Windows when OperatingSystem.IsWindows():
case PlatformID.WinCE when OperatingSystem.IsWindows():
case PlatformID.WindowsPhone when OperatingSystem.IsWindows():
{
RegistryKey parentKey = Registry.CurrentUser.OpenSubKey("SOFTWARE", true)?.
CreateSubKey("Claunia.com");
RegistryKey key = parentKey?.CreateSubKey("RomRepoMgr");
key?.SetValue("DatabasePath", Current.DatabasePath);
key?.SetValue("RepositoryPath", Current.RepositoryPath);
key?.SetValue("TemporaryFolder", Current.TemporaryFolder);
key?.SetValue("UnArchiverPath", Current.UnArchiverPath);
}
break;
#endif
// Otherwise, settings will be saved in ~/.config/RomRepoMgr.json
default:
{
string homePath = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
string xdgConfigPath =
Path.Combine(homePath,
Environment.GetEnvironmentVariable(XDG_CONFIG_HOME) ??
XDG_CONFIG_HOME_RESOLVED);
string settingsPath = Path.Combine(xdgConfigPath, "RomRepoMgr.json");
if (!Directory.Exists(xdgConfigPath))
{
Directory.CreateDirectory(xdgConfigPath);
}
var prefsSr = new StreamWriter(settingsPath);
prefsSr.Write(JsonSerializer.Serialize(Current, new JsonSerializerOptions
{
AllowTrailingCommas = true,
PropertyNameCaseInsensitive = true,
ReadCommentHandling = JsonCommentHandling.Skip,
WriteIndented = true
}));
prefsSr.Close();
}
break;
}
}
#pragma warning disable RECS0022 // A catch clause that catches System.Exception and has an empty body
catch
{
// ignored
}
#pragma warning restore RECS0022 // A catch clause that catches System.Exception and has an empty body
}
