aaru-dps/Aaru
1
0
Fork 0
mirror of https://github.com/aaru-dps/Aaru.git synced 2025-12-16 19:24:25 +00:00
Code Issues Packages Projects Releases Wiki Activity

🎨REFACTOR: Use auto-properties.

Browse Source
This commit is contained in:
Natalia Portillo
2017-12-26 08:01:40 +00:00
parent 94d8173b3a
commit 18f9a349c9
80 changed files with 947 additions and 1134 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
DiscImageChef.Filesystems/AODOS.cs
View File

@@ -31,7 +31,6 @@
// ****************************************************************************/ // ****************************************************************************/
using System; using System;
using System.Collections.Generic;
using System.Linq; using System.Linq;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
using System.Text; using System.Text;
@@ -46,12 +45,10 @@ namespace DiscImageChef.Filesystems
public class AODOS : IFilesystem public class AODOS : IFilesystem
{ {
readonly byte[] AODOSIdentifier = {0x20, 0x41, 0x4F, 0x2D, 0x44, 0x4F, 0x53, 0x20}; readonly byte[] AODOSIdentifier = {0x20, 0x41, 0x4F, 0x2D, 0x44, 0x4F, 0x53, 0x20};
Encoding currentEncoding; public FileSystemType XmlFsType { get; private set; }
FileSystemType xmlFsType;
public FileSystemType XmlFsType => xmlFsType;
public string Name => "Alexander Osipov DOS file system"; public string Name => "Alexander Osipov DOS file system";
public Guid Id => new Guid("668E5039-9DDD-442A-BE1B-A315D6E38E26"); public Guid Id => new Guid("668E5039-9DDD-442A-BE1B-A315D6E38E26");
public Encoding Encoding => currentEncoding; public Encoding Encoding { get; private set; }
public bool Identify(IMediaImage imagePlugin, Partition partition) public bool Identify(IMediaImage imagePlugin, Partition partition)
{ {
@@ -74,9 +71,10 @@ namespace DiscImageChef.Filesystems
return bb.identifier.SequenceEqual(AODOSIdentifier); return bb.identifier.SequenceEqual(AODOSIdentifier);
} }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, Encoding encoding) public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding)
{ {
currentEncoding = Encoding.GetEncoding("koi8-r"); Encoding = Encoding.GetEncoding("koi8-r");
byte[] sector = imagePlugin.ReadSector(0); byte[] sector = imagePlugin.ReadSector(0);
AODOS_BootBlock bb = new AODOS_BootBlock(); AODOS_BootBlock bb = new AODOS_BootBlock();
IntPtr bbPtr = Marshal.AllocHGlobal(Marshal.SizeOf(bb)); IntPtr bbPtr = Marshal.AllocHGlobal(Marshal.SizeOf(bb));
@@ -88,7 +86,7 @@ namespace DiscImageChef.Filesystems
sbInformation.AppendLine("Alexander Osipov DOS file system"); sbInformation.AppendLine("Alexander Osipov DOS file system");
xmlFsType = new FileSystemType XmlFsType = new FileSystemType
{ {
Type = "Alexander Osipov DOS file system", Type = "Alexander Osipov DOS file system",
Clusters = (long)imagePlugin.Info.Sectors, Clusters = (long)imagePlugin.Info.Sectors,
@@ -97,13 +95,13 @@ namespace DiscImageChef.Filesystems
FilesSpecified = true, FilesSpecified = true,
FreeClusters = (long)(imagePlugin.Info.Sectors - bb.usedSectors), FreeClusters = (long)(imagePlugin.Info.Sectors - bb.usedSectors),
FreeClustersSpecified = true, FreeClustersSpecified = true,
VolumeName = StringHandlers.SpacePaddedToString(bb.volumeLabel, currentEncoding), VolumeName = StringHandlers.SpacePaddedToString(bb.volumeLabel, Encoding),
Bootable = true Bootable = true
}; };
sbInformation.AppendFormat("{0} files on volume", bb.files).AppendLine(); sbInformation.AppendFormat("{0} files on volume", bb.files).AppendLine();
sbInformation.AppendFormat("{0} used sectors on volume", bb.usedSectors).AppendLine(); sbInformation.AppendFormat("{0} used sectors on volume", bb.usedSectors).AppendLine();
sbInformation.AppendFormat("Disk name: {0}", StringHandlers.CToString(bb.volumeLabel, currentEncoding)) sbInformation.AppendFormat("Disk name: {0}", StringHandlers.CToString(bb.volumeLabel, Encoding))
.AppendLine(); .AppendLine();
information = sbInformation.ToString(); information = sbInformation.ToString();

15
DiscImageChef.Filesystems/APFS.cs
View File

@@ -31,7 +31,6 @@
// ****************************************************************************/ // ****************************************************************************/
using System; using System;
using System.Collections.Generic;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
using System.Text; using System.Text;
using DiscImageChef.CommonTypes; using DiscImageChef.CommonTypes;
@@ -44,11 +43,9 @@ namespace DiscImageChef.Filesystems
{ {
const uint APFS_CONTAINER_MAGIC = 0x4253584E; // "NXSB" const uint APFS_CONTAINER_MAGIC = 0x4253584E; // "NXSB"
const uint APFS_VOLUME_MAGIC = 0x42535041; // "APSB" const uint APFS_VOLUME_MAGIC = 0x42535041; // "APSB"
FileSystemType xmlFsType;
public FileSystemType XmlFsType => xmlFsType;
Encoding currentEncoding; public FileSystemType XmlFsType { get; private set; }
public Encoding Encoding => currentEncoding; public Encoding Encoding { get; private set; }
public string Name => "Apple File System"; public string Name => "Apple File System";
public Guid Id => new Guid("A4060F9D-2909-42E2-9D95-DB31FA7EA797"); public Guid Id => new Guid("A4060F9D-2909-42E2-9D95-DB31FA7EA797");
@@ -72,11 +69,11 @@ namespace DiscImageChef.Filesystems
} }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding) Encoding encoding)
{ {
currentEncoding = Encoding.UTF8; Encoding = Encoding.UTF8;
StringBuilder sbInformation = new StringBuilder(); StringBuilder sbInformation = new StringBuilder();
xmlFsType = new FileSystemType(); XmlFsType = new FileSystemType();
information = ""; information = "";
if(partition.Start >= partition.End) return; if(partition.Start >= partition.End) return;
@@ -103,7 +100,7 @@ namespace DiscImageChef.Filesystems
information = sbInformation.ToString(); information = sbInformation.ToString();
xmlFsType = new FileSystemType XmlFsType = new FileSystemType
{ {
Bootable = false, Bootable = false,
Clusters = (long)nxSb.containerBlocks, Clusters = (long)nxSb.containerBlocks,

39
DiscImageChef.Filesystems/Acorn.cs
View File

@@ -76,13 +76,11 @@ namespace DiscImageChef.Filesystems
/// Old directory format magic number, "Hugo" /// Old directory format magic number, "Hugo"
/// </summary> /// </summary>
const uint OLD_DIR_MAGIC = 0x6F677548; const uint OLD_DIR_MAGIC = 0x6F677548;
Encoding currentEncoding;
FileSystemType xmlFsType; public FileSystemType XmlFsType { get; private set; }
public FileSystemType XmlFsType => xmlFsType;
public string Name => "Acorn Advanced Disc Filing System"; public string Name => "Acorn Advanced Disc Filing System";
public Guid Id => new Guid("BAFC1E50-9C64-4CD3-8400-80628CC27AFA"); public Guid Id => new Guid("BAFC1E50-9C64-4CD3-8400-80628CC27AFA");
public Encoding Encoding => currentEncoding; public Encoding Encoding { get; private set; }
// TODO: BBC Master hard disks are untested... // TODO: BBC Master hard disks are untested...
public bool Identify(IMediaImage imagePlugin, Partition partition) public bool Identify(IMediaImage imagePlugin, Partition partition)
@@ -250,11 +248,12 @@ namespace DiscImageChef.Filesystems
// TODO: Find root directory on volumes with DiscRecord // TODO: Find root directory on volumes with DiscRecord
// TODO: Support big directories (ADFS-G?) // TODO: Support big directories (ADFS-G?)
// TODO: Find the real freemap on volumes with DiscRecord, as DiscRecord's discid may be empty but this one isn't // TODO: Find the real freemap on volumes with DiscRecord, as DiscRecord's discid may be empty but this one isn't
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, Encoding encoding) public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding)
{ {
currentEncoding = encoding ?? Encoding.GetEncoding("iso-8859-1"); Encoding = encoding ?? Encoding.GetEncoding("iso-8859-1");
StringBuilder sbInformation = new StringBuilder(); StringBuilder sbInformation = new StringBuilder();
xmlFsType = new FileSystemType(); XmlFsType = new FileSystemType();
information = ""; information = "";
ulong sbSector; ulong sbSector;
@@ -300,7 +299,7 @@ namespace DiscImageChef.Filesystems
namebytes[i * 2 + 1] = oldMap1.name[i]; namebytes[i * 2 + 1] = oldMap1.name[i];
} }
xmlFsType = new FileSystemType XmlFsType = new FileSystemType
{ {
Bootable = oldMap1.boot != 0, // Or not? Bootable = oldMap1.boot != 0, // Or not?
Clusters = (long)(bytes / imagePlugin.Info.SectorSize), Clusters = (long)(bytes / imagePlugin.Info.SectorSize),
@@ -373,15 +372,15 @@ namespace DiscImageChef.Filesystems
sbInformation.AppendLine(); sbInformation.AppendLine();
sbInformation.AppendFormat("{0} bytes per sector", imagePlugin.Info.SectorSize).AppendLine(); sbInformation.AppendFormat("{0} bytes per sector", imagePlugin.Info.SectorSize).AppendLine();
sbInformation.AppendFormat("Volume has {0} bytes", bytes).AppendLine(); sbInformation.AppendFormat("Volume has {0} bytes", bytes).AppendLine();
sbInformation.AppendFormat("Volume name: {0}", StringHandlers.CToString(namebytes, currentEncoding)) sbInformation.AppendFormat("Volume name: {0}", StringHandlers.CToString(namebytes, Encoding))
.AppendLine(); .AppendLine();
if(oldMap1.discId > 0) if(oldMap1.discId > 0)
{ {
xmlFsType.VolumeSerial = $"{oldMap1.discId:X4}"; XmlFsType.VolumeSerial = $"{oldMap1.discId:X4}";
sbInformation.AppendFormat("Volume ID: {0:X4}", oldMap1.discId).AppendLine(); sbInformation.AppendFormat("Volume ID: {0:X4}", oldMap1.discId).AppendLine();
} }
if(!ArrayHelpers.ArrayIsNullOrEmpty(namebytes)) if(!ArrayHelpers.ArrayIsNullOrEmpty(namebytes))
xmlFsType.VolumeName = StringHandlers.CToString(namebytes, currentEncoding); XmlFsType.VolumeName = StringHandlers.CToString(namebytes, Encoding);
information = sbInformation.ToString(); information = sbInformation.ToString();
@@ -439,7 +438,7 @@ namespace DiscImageChef.Filesystems
DicConsole.DebugWriteLine("ADFS Plugin", "drSb.disc_size = {0}", drSb.disc_size); DicConsole.DebugWriteLine("ADFS Plugin", "drSb.disc_size = {0}", drSb.disc_size);
DicConsole.DebugWriteLine("ADFS Plugin", "drSb.disc_id = {0}", drSb.disc_id); DicConsole.DebugWriteLine("ADFS Plugin", "drSb.disc_id = {0}", drSb.disc_id);
DicConsole.DebugWriteLine("ADFS Plugin", "drSb.disc_name = {0}", DicConsole.DebugWriteLine("ADFS Plugin", "drSb.disc_name = {0}",
StringHandlers.CToString(drSb.disc_name, currentEncoding)); StringHandlers.CToString(drSb.disc_name, Encoding));
DicConsole.DebugWriteLine("ADFS Plugin", "drSb.disc_type = {0}", drSb.disc_type); DicConsole.DebugWriteLine("ADFS Plugin", "drSb.disc_type = {0}", drSb.disc_type);
DicConsole.DebugWriteLine("ADFS Plugin", "drSb.disc_size_high = {0}", drSb.disc_size_high); DicConsole.DebugWriteLine("ADFS Plugin", "drSb.disc_size_high = {0}", drSb.disc_size_high);
DicConsole.DebugWriteLine("ADFS Plugin", "drSb.flags = {0}", drSb.flags); DicConsole.DebugWriteLine("ADFS Plugin", "drSb.flags = {0}", drSb.flags);
@@ -465,7 +464,7 @@ namespace DiscImageChef.Filesystems
if(bytes > imagePlugin.Info.Sectors * imagePlugin.Info.SectorSize) return; if(bytes > imagePlugin.Info.Sectors * imagePlugin.Info.SectorSize) return;
xmlFsType = new FileSystemType(); XmlFsType = new FileSystemType();
sbInformation.AppendLine("Acorn Advanced Disc Filing System"); sbInformation.AppendLine("Acorn Advanced Disc Filing System");
sbInformation.AppendLine(); sbInformation.AppendLine();
@@ -483,22 +482,22 @@ namespace DiscImageChef.Filesystems
sbInformation.AppendFormat("Volume flags: 0x{0:X4}", drSb.flags).AppendLine(); sbInformation.AppendFormat("Volume flags: 0x{0:X4}", drSb.flags).AppendLine();
if(drSb.disc_id > 0) if(drSb.disc_id > 0)
{ {
xmlFsType.VolumeSerial = $"{drSb.disc_id:X4}"; XmlFsType.VolumeSerial = $"{drSb.disc_id:X4}";
sbInformation.AppendFormat("Volume ID: {0:X4}", drSb.disc_id).AppendLine(); sbInformation.AppendFormat("Volume ID: {0:X4}", drSb.disc_id).AppendLine();
} }
if(!ArrayHelpers.ArrayIsNullOrEmpty(drSb.disc_name)) if(!ArrayHelpers.ArrayIsNullOrEmpty(drSb.disc_name))
{ {
string discname = StringHandlers.CToString(drSb.disc_name, currentEncoding); string discname = StringHandlers.CToString(drSb.disc_name, Encoding);
xmlFsType.VolumeName = discname; XmlFsType.VolumeName = discname;
sbInformation.AppendFormat("Volume name: {0}", discname).AppendLine(); sbInformation.AppendFormat("Volume name: {0}", discname).AppendLine();
} }
information = sbInformation.ToString(); information = sbInformation.ToString();
xmlFsType.Bootable |= drSb.bootoption != 0; // Or not? XmlFsType.Bootable |= drSb.bootoption != 0; // Or not?
xmlFsType.Clusters = (long)(bytes / (ulong)(1 << drSb.log2secsize)); XmlFsType.Clusters = (long)(bytes / (ulong)(1 << drSb.log2secsize));
xmlFsType.ClusterSize = 1 << drSb.log2secsize; XmlFsType.ClusterSize = 1 << drSb.log2secsize;
xmlFsType.Type = "Acorn Advanced Disc Filing System"; XmlFsType.Type = "Acorn Advanced Disc Filing System";
} }
byte AcornMapChecksum(byte[] data, int length) byte AcornMapChecksum(byte[] data, int length)

52
DiscImageChef.Filesystems/AmigaDOS.cs
View File

@@ -31,7 +31,6 @@
// ****************************************************************************/ // ****************************************************************************/
using System; using System;
using System.Collections.Generic;
using System.Linq; using System.Linq;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
using System.Text; using System.Text;
@@ -50,13 +49,11 @@ namespace DiscImageChef.Filesystems
const uint TYPE_HEADER = 2; const uint TYPE_HEADER = 2;
const uint SUBTYPE_ROOT = 1; const uint SUBTYPE_ROOT = 1;
Encoding currentEncoding;
FileSystemType xmlFsType; public FileSystemType XmlFsType { get; private set; }
public FileSystemType XmlFsType => xmlFsType;
public string Name => "Amiga DOS filesystem"; public string Name => "Amiga DOS filesystem";
public Guid Id => new Guid("3c882400-208c-427d-a086-9119852a1bc7"); public Guid Id => new Guid("3c882400-208c-427d-a086-9119852a1bc7");
public Encoding Encoding => currentEncoding; public Encoding Encoding { get; private set; }
public bool Identify(IMediaImage imagePlugin, Partition partition) public bool Identify(IMediaImage imagePlugin, Partition partition)
{ {
@@ -154,11 +151,12 @@ namespace DiscImageChef.Filesystems
return false; return false;
} }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, Encoding encoding) public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding)
{ {
currentEncoding = encoding ?? Encoding.GetEncoding("iso-8859-1"); Encoding = encoding ?? Encoding.GetEncoding("iso-8859-1");
StringBuilder sbInformation = new StringBuilder(); StringBuilder sbInformation = new StringBuilder();
xmlFsType = new FileSystemType(); XmlFsType = new FileSystemType();
information = null; information = null;
BigEndianBitConverter.IsLittleEndian = BitConverter.IsLittleEndian; BigEndianBitConverter.IsLittleEndian = BitConverter.IsLittleEndian;
@@ -242,41 +240,41 @@ namespace DiscImageChef.Filesystems
rootBlk = MarshalRootBlock(rootBlockSector); rootBlk = MarshalRootBlock(rootBlockSector);
string diskName = StringHandlers.PascalToString(rootBlk.diskName, currentEncoding); string diskName = StringHandlers.PascalToString(rootBlk.diskName, Encoding);
switch(bootBlk.diskType & 0xFF) switch(bootBlk.diskType & 0xFF)
{ {
case 0: case 0:
sbInformation.Append("Amiga Original File System"); sbInformation.Append("Amiga Original File System");
xmlFsType.Type = "Amiga OFS"; XmlFsType.Type = "Amiga OFS";
break; break;
case 1: case 1:
sbInformation.Append("Amiga Fast File System"); sbInformation.Append("Amiga Fast File System");
xmlFsType.Type = "Amiga FFS"; XmlFsType.Type = "Amiga FFS";
break; break;
case 2: case 2:
sbInformation.Append("Amiga Original File System with international characters"); sbInformation.Append("Amiga Original File System with international characters");
xmlFsType.Type = "Amiga OFS"; XmlFsType.Type = "Amiga OFS";
break; break;
case 3: case 3:
sbInformation.Append("Amiga Fast File System with international characters"); sbInformation.Append("Amiga Fast File System with international characters");
xmlFsType.Type = "Amiga FFS"; XmlFsType.Type = "Amiga FFS";
break; break;
case 4: case 4:
sbInformation.Append("Amiga Original File System with directory cache"); sbInformation.Append("Amiga Original File System with directory cache");
xmlFsType.Type = "Amiga OFS"; XmlFsType.Type = "Amiga OFS";
break; break;
case 5: case 5:
sbInformation.Append("Amiga Fast File System with directory cache"); sbInformation.Append("Amiga Fast File System with directory cache");
xmlFsType.Type = "Amiga FFS"; XmlFsType.Type = "Amiga FFS";
break; break;
case 6: case 6:
sbInformation.Append("Amiga Original File System with long filenames"); sbInformation.Append("Amiga Original File System with long filenames");
xmlFsType.Type = "Amiga OFS2"; XmlFsType.Type = "Amiga OFS2";
break; break;
case 7: case 7:
sbInformation.Append("Amiga Fast File System with long filenames"); sbInformation.Append("Amiga Fast File System with long filenames");
xmlFsType.Type = "Amiga FFS2"; XmlFsType.Type = "Amiga FFS2";
break; break;
} }
@@ -319,17 +317,17 @@ namespace DiscImageChef.Filesystems
sbInformation.AppendFormat("Root block checksum is 0x{0:X8}", rootBlk.checksum).AppendLine(); sbInformation.AppendFormat("Root block checksum is 0x{0:X8}", rootBlk.checksum).AppendLine();
information = sbInformation.ToString(); information = sbInformation.ToString();
xmlFsType.CreationDate = DateHandlers.AmigaToDateTime(rootBlk.cDays, rootBlk.cMins, rootBlk.cTicks); XmlFsType.CreationDate = DateHandlers.AmigaToDateTime(rootBlk.cDays, rootBlk.cMins, rootBlk.cTicks);
xmlFsType.CreationDateSpecified = true; XmlFsType.CreationDateSpecified = true;
xmlFsType.ModificationDate = DateHandlers.AmigaToDateTime(rootBlk.vDays, rootBlk.vMins, rootBlk.vTicks); XmlFsType.ModificationDate = DateHandlers.AmigaToDateTime(rootBlk.vDays, rootBlk.vMins, rootBlk.vTicks);
xmlFsType.ModificationDateSpecified = true; XmlFsType.ModificationDateSpecified = true;
xmlFsType.Dirty = rootBlk.bitmapFlag != 0xFFFFFFFF; XmlFsType.Dirty = rootBlk.bitmapFlag != 0xFFFFFFFF;
xmlFsType.Clusters = blocks; XmlFsType.Clusters = blocks;
xmlFsType.ClusterSize = (int)blockSize; XmlFsType.ClusterSize = (int)blockSize;
xmlFsType.VolumeName = diskName; XmlFsType.VolumeName = diskName;
xmlFsType.Bootable = bsum == bootBlk.checksum; XmlFsType.Bootable = bsum == bootBlk.checksum;
// Useful as a serial // Useful as a serial
xmlFsType.VolumeSerial = $"{rootBlk.checksum:X8}"; XmlFsType.VolumeSerial = $"{rootBlk.checksum:X8}";
} }
static RootBlock MarshalRootBlock(byte[] block) static RootBlock MarshalRootBlock(byte[] block)

12
DiscImageChef.Filesystems/AppleDOS/AppleDOS.cs
View File

@@ -32,19 +32,16 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using Claunia.Encoding; using System.Text;
using DiscImageChef.CommonTypes;
using DiscImageChef.DiscImages; using DiscImageChef.DiscImages;
using Schemas; using Schemas;
using Encoding = System.Text.Encoding;
namespace DiscImageChef.Filesystems.AppleDOS namespace DiscImageChef.Filesystems.AppleDOS
{ {
public partial class AppleDOS : IReadOnlyFilesystem public partial class AppleDOS : IReadOnlyFilesystem
{ {
IMediaImage device;
Encoding currentEncoding;
bool debug; bool debug;
IMediaImage device;
bool mounted; bool mounted;
int sectorsPerTrack; int sectorsPerTrack;
ulong start; ulong start;
@@ -55,9 +52,8 @@ namespace DiscImageChef.Filesystems.AppleDOS
Vtoc vtoc; Vtoc vtoc;
FileSystemType xmlFsType; public FileSystemType XmlFsType { get; private set; }
public FileSystemType XmlFsType => xmlFsType; public Encoding Encoding { get; private set; }
public Encoding Encoding => currentEncoding;
public string Name => "Apple DOS File System"; public string Name => "Apple DOS File System";
public Guid Id => new Guid("8658A1E9-B2E7-4BCC-9638-157A31B0A700\n"); public Guid Id => new Guid("8658A1E9-B2E7-4BCC-9638-157A31B0A700\n");

2
DiscImageChef.Filesystems/AppleDOS/Dir.cs
View File

@@ -111,7 +111,7 @@ namespace DiscImageChef.Filesystems.AppleDOS
// Apple DOS has high byte set over ASCII. // Apple DOS has high byte set over ASCII.
for(int i = 0; i < 30; i++) filenameB[i] = (byte)(entry.filename[i] & 0x7F); for(int i = 0; i < 30; i++) filenameB[i] = (byte)(entry.filename[i] & 0x7F);
string filename = StringHandlers.SpacePaddedToString(filenameB, currentEncoding); string filename = StringHandlers.SpacePaddedToString(filenameB, Encoding);
if(!catalogCache.ContainsKey(filename)) catalogCache.Add(filename, ts); if(!catalogCache.ContainsKey(filename)) catalogCache.Add(filename, ts);

7
DiscImageChef.Filesystems/AppleDOS/Info.cs
View File

@@ -63,10 +63,11 @@ namespace DiscImageChef.Filesystems.AppleDOS
vtoc.sectorsPerTrack == spt && vtoc.bytesPerSector == 256; vtoc.sectorsPerTrack == spt && vtoc.bytesPerSector == 256;
} }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, Encoding encoding) public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding)
{ {
// TODO: Until Apple ][ encoding is implemented // TODO: Until Apple ][ encoding is implemented
currentEncoding = new LisaRoman(); Encoding = new LisaRoman();
information = ""; information = "";
StringBuilder sb = new StringBuilder(); StringBuilder sb = new StringBuilder();
@@ -95,7 +96,7 @@ namespace DiscImageChef.Filesystems.AppleDOS
information = sb.ToString(); information = sb.ToString();
xmlFsType = new FileSystemType XmlFsType = new FileSystemType
{ {
Bootable = true, Bootable = true,
Clusters = (long)imagePlugin.Info.Sectors, Clusters = (long)imagePlugin.Info.Sectors,

6
DiscImageChef.Filesystems/AppleDOS/Super.cs
View File

@@ -51,7 +51,7 @@ namespace DiscImageChef.Filesystems.AppleDOS
device = imagePlugin; device = imagePlugin;
start = partition.Start; start = partition.Start;
// TODO: Until Apple ][ encoding is implemented // TODO: Until Apple ][ encoding is implemented
currentEncoding = new LisaRoman(); Encoding = new LisaRoman();
if(device.Info.Sectors != 455 && device.Info.Sectors != 560) if(device.Info.Sectors != 455 && device.Info.Sectors != 560)
{ {
@@ -100,7 +100,7 @@ namespace DiscImageChef.Filesystems.AppleDOS
} }
// Create XML metadata for mounted filesystem // Create XML metadata for mounted filesystem
xmlFsType = new FileSystemType XmlFsType = new FileSystemType
{ {
Bootable = true, Bootable = true,
Clusters = (long)device.Info.Sectors, Clusters = (long)device.Info.Sectors,
@@ -110,7 +110,7 @@ namespace DiscImageChef.Filesystems.AppleDOS
FreeClustersSpecified = true, FreeClustersSpecified = true,
Type = "Apple DOS" Type = "Apple DOS"
}; };
xmlFsType.FreeClusters = xmlFsType.Clusters - usedSectors; XmlFsType.FreeClusters = XmlFsType.Clusters - usedSectors;
this.debug = debug; this.debug = debug;
mounted = true; mounted = true;

71
DiscImageChef.Filesystems/AppleHFS.cs
View File

@@ -31,7 +31,6 @@
// ****************************************************************************/ // ****************************************************************************/
using System; using System;
using System.Collections.Generic;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
using System.Text; using System.Text;
using DiscImageChef.CommonTypes; using DiscImageChef.CommonTypes;
@@ -56,11 +55,9 @@ namespace DiscImageChef.Filesystems
/// "LK", HFS bootblock magic /// "LK", HFS bootblock magic
/// </summary> /// </summary>
const ushort HFSBB_MAGIC = 0x4C4B; const ushort HFSBB_MAGIC = 0x4C4B;
Encoding currentEncoding;
FileSystemType xmlFsType;
public FileSystemType XmlFsType => xmlFsType;
public Encoding Encoding => currentEncoding; public FileSystemType XmlFsType { get; private set; }
public Encoding Encoding { get; private set; }
public string Name => "Apple Hierarchical File System"; public string Name => "Apple Hierarchical File System";
public Guid Id => new Guid("36405F8D-0D26-6ECC-0BBB-1D5225FF404F"); public Guid Id => new Guid("36405F8D-0D26-6ECC-0BBB-1D5225FF404F");
@@ -103,9 +100,9 @@ namespace DiscImageChef.Filesystems
} }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding) Encoding encoding)
{ {
currentEncoding = encoding ?? Encoding.GetEncoding("macintosh"); Encoding = encoding ?? Encoding.GetEncoding("macintosh");
information = ""; information = "";
StringBuilder sb = new StringBuilder(); StringBuilder sb = new StringBuilder();
@@ -193,7 +190,7 @@ namespace DiscImageChef.Filesystems
sb.AppendFormat("{0} bytes in the Extents B-Tree", MDB.drXTFlSize).AppendLine(); sb.AppendFormat("{0} bytes in the Extents B-Tree", MDB.drXTFlSize).AppendLine();
sb.AppendFormat("{0} bytes in the Catalog B-Tree", MDB.drCTFlSize).AppendLine(); sb.AppendFormat("{0} bytes in the Catalog B-Tree", MDB.drCTFlSize).AppendLine();
sb.AppendFormat("Volume name: {0}", StringHandlers.PascalToString(MDB.drVN, currentEncoding)).AppendLine(); sb.AppendFormat("Volume name: {0}", StringHandlers.PascalToString(MDB.drVN, Encoding)).AppendLine();
sb.AppendLine("Finder info:"); sb.AppendLine("Finder info:");
sb.AppendFormat("CNID of bootable system's directory: {0}", MDB.drFndrInfo0).AppendLine(); sb.AppendFormat("CNID of bootable system's directory: {0}", MDB.drFndrInfo0).AppendLine();
@@ -229,20 +226,20 @@ namespace DiscImageChef.Filesystems
if(BB.boot_flags > 0) sb.AppendLine("Allocate secondary sound buffer at boot."); if(BB.boot_flags > 0) sb.AppendLine("Allocate secondary sound buffer at boot.");
else if(BB.boot_flags < 0) sb.AppendLine("Allocate secondary sound and video buffers at boot."); else if(BB.boot_flags < 0) sb.AppendLine("Allocate secondary sound and video buffers at boot.");
sb.AppendFormat("System filename: {0}", sb.AppendFormat("System filename: {0}", StringHandlers.PascalToString(BB.system_name, Encoding))
StringHandlers.PascalToString(BB.system_name, currentEncoding)).AppendLine(); .AppendLine();
sb.AppendFormat("Finder filename: {0}", sb.AppendFormat("Finder filename: {0}", StringHandlers.PascalToString(BB.finder_name, Encoding))
StringHandlers.PascalToString(BB.finder_name, currentEncoding)).AppendLine(); .AppendLine();
sb.AppendFormat("Debugger filename: {0}", sb.AppendFormat("Debugger filename: {0}", StringHandlers.PascalToString(BB.debug_name, Encoding))
StringHandlers.PascalToString(BB.debug_name, currentEncoding)).AppendLine(); .AppendLine();
sb.AppendFormat("Disassembler filename: {0}", sb.AppendFormat("Disassembler filename: {0}",
StringHandlers.PascalToString(BB.disasm_name, currentEncoding)).AppendLine(); StringHandlers.PascalToString(BB.disasm_name, Encoding)).AppendLine();
sb.AppendFormat("Startup screen filename: {0}", sb.AppendFormat("Startup screen filename: {0}",
StringHandlers.PascalToString(BB.stupscr_name, currentEncoding)).AppendLine(); StringHandlers.PascalToString(BB.stupscr_name, Encoding)).AppendLine();
sb.AppendFormat("First program to execute at boot: {0}", sb.AppendFormat("First program to execute at boot: {0}",
StringHandlers.PascalToString(BB.bootup_name, currentEncoding)).AppendLine(); StringHandlers.PascalToString(BB.bootup_name, Encoding)).AppendLine();
sb.AppendFormat("Clipboard filename: {0}", sb.AppendFormat("Clipboard filename: {0}", StringHandlers.PascalToString(BB.clipbrd_name, Encoding))
StringHandlers.PascalToString(BB.clipbrd_name, currentEncoding)).AppendLine(); .AppendLine();
sb.AppendFormat("Maximum opened files: {0}", BB.max_files * 4).AppendLine(); sb.AppendFormat("Maximum opened files: {0}", BB.max_files * 4).AppendLine();
sb.AppendFormat("Event queue size: {0}", BB.queue_size).AppendLine(); sb.AppendFormat("Event queue size: {0}", BB.queue_size).AppendLine();
sb.AppendFormat("Heap size with 128KiB of RAM: {0} bytes", BB.heap_128k).AppendLine(); sb.AppendFormat("Heap size with 128KiB of RAM: {0} bytes", BB.heap_128k).AppendLine();
@@ -256,35 +253,35 @@ namespace DiscImageChef.Filesystems
information = sb.ToString(); information = sb.ToString();
xmlFsType = new FileSystemType(); XmlFsType = new FileSystemType();
if(MDB.drVolBkUp > 0) if(MDB.drVolBkUp > 0)
{ {
xmlFsType.BackupDate = DateHandlers.MacToDateTime(MDB.drVolBkUp); XmlFsType.BackupDate = DateHandlers.MacToDateTime(MDB.drVolBkUp);
xmlFsType.BackupDateSpecified = true; XmlFsType.BackupDateSpecified = true;
} }
xmlFsType.Bootable = BB.signature == HFSBB_MAGIC || MDB.drFndrInfo0 != 0 || MDB.drFndrInfo3 != 0 || XmlFsType.Bootable = BB.signature == HFSBB_MAGIC || MDB.drFndrInfo0 != 0 || MDB.drFndrInfo3 != 0 ||
MDB.drFndrInfo5 != 0; MDB.drFndrInfo5 != 0;
xmlFsType.Clusters = MDB.drNmAlBlks; XmlFsType.Clusters = MDB.drNmAlBlks;
xmlFsType.ClusterSize = (int)MDB.drAlBlkSiz; XmlFsType.ClusterSize = (int)MDB.drAlBlkSiz;
if(MDB.drCrDate > 0) if(MDB.drCrDate > 0)
{ {
xmlFsType.CreationDate = DateHandlers.MacToDateTime(MDB.drCrDate); XmlFsType.CreationDate = DateHandlers.MacToDateTime(MDB.drCrDate);
xmlFsType.CreationDateSpecified = true; XmlFsType.CreationDateSpecified = true;
} }
xmlFsType.Dirty = (MDB.drAtrb & 0x100) != 0x100; XmlFsType.Dirty = (MDB.drAtrb & 0x100) != 0x100;
xmlFsType.Files = MDB.drFilCnt; XmlFsType.Files = MDB.drFilCnt;
xmlFsType.FilesSpecified = true; XmlFsType.FilesSpecified = true;
xmlFsType.FreeClusters = MDB.drFreeBks; XmlFsType.FreeClusters = MDB.drFreeBks;
xmlFsType.FreeClustersSpecified = true; XmlFsType.FreeClustersSpecified = true;
if(MDB.drLsMod > 0) if(MDB.drLsMod > 0)
{ {
xmlFsType.ModificationDate = DateHandlers.MacToDateTime(MDB.drLsMod); XmlFsType.ModificationDate = DateHandlers.MacToDateTime(MDB.drLsMod);
xmlFsType.ModificationDateSpecified = true; XmlFsType.ModificationDateSpecified = true;
} }
xmlFsType.Type = "HFS"; XmlFsType.Type = "HFS";
xmlFsType.VolumeName = StringHandlers.PascalToString(MDB.drVN, currentEncoding); XmlFsType.VolumeName = StringHandlers.PascalToString(MDB.drVN, Encoding);
if(MDB.drFndrInfo6 != 0 && MDB.drFndrInfo7 != 0) if(MDB.drFndrInfo6 != 0 && MDB.drFndrInfo7 != 0)
xmlFsType.VolumeSerial = $"{MDB.drFndrInfo6:X8}{MDB.drFndrInfo7:X8}"; XmlFsType.VolumeSerial = $"{MDB.drFndrInfo6:X8}{MDB.drFndrInfo7:X8}";
} }
static byte[] Read2048SectorAs512(IMediaImage imagePlugin, ulong lba) static byte[] Read2048SectorAs512(IMediaImage imagePlugin, ulong lba)

50
DiscImageChef.Filesystems/AppleHFSPlus.cs
View File

@@ -31,7 +31,6 @@
// ****************************************************************************/ // ****************************************************************************/
using System; using System;
using System.Collections.Generic;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
using System.Text; using System.Text;
using DiscImageChef.CommonTypes; using DiscImageChef.CommonTypes;
@@ -56,11 +55,8 @@ namespace DiscImageChef.Filesystems
/// </summary> /// </summary>
const ushort HFSX_MAGIC = 0x4858; const ushort HFSX_MAGIC = 0x4858;
Encoding currentEncoding; public FileSystemType XmlFsType { get; private set; }
FileSystemType xmlFsType; public Encoding Encoding { get; private set; }
public FileSystemType XmlFsType => xmlFsType;
public Encoding Encoding => currentEncoding;
public string Name => "Apple HFS+ filesystem"; public string Name => "Apple HFS+ filesystem";
public Guid Id => new Guid("36405F8D-0D26-6EBE-436F-62F0586B4F08"); public Guid Id => new Guid("36405F8D-0D26-6EBE-436F-62F0586B4F08");
@@ -104,9 +100,9 @@ namespace DiscImageChef.Filesystems
} }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding) Encoding encoding)
{ {
currentEncoding = Encoding.BigEndianUnicode; Encoding = Encoding.BigEndianUnicode;
information = ""; information = "";
ushort drSigWord; ushort drSigWord;
@@ -219,35 +215,35 @@ namespace DiscImageChef.Filesystems
sb.AppendFormat("Mac OS X Volume ID: {0:X8}{1:X8}", HPVH.drFndrInfo6, HPVH.drFndrInfo7) sb.AppendFormat("Mac OS X Volume ID: {0:X8}{1:X8}", HPVH.drFndrInfo6, HPVH.drFndrInfo7)
.AppendLine(); .AppendLine();
xmlFsType = new FileSystemType(); XmlFsType = new FileSystemType();
if(HPVH.backupDate > 0) if(HPVH.backupDate > 0)
{ {
xmlFsType.BackupDate = DateHandlers.MacToDateTime(HPVH.backupDate); XmlFsType.BackupDate = DateHandlers.MacToDateTime(HPVH.backupDate);
xmlFsType.BackupDateSpecified = true; XmlFsType.BackupDateSpecified = true;
} }
xmlFsType.Bootable |= HPVH.drFndrInfo0 != 0 || HPVH.drFndrInfo3 != 0 || HPVH.drFndrInfo5 != 0; XmlFsType.Bootable |= HPVH.drFndrInfo0 != 0 || HPVH.drFndrInfo3 != 0 || HPVH.drFndrInfo5 != 0;
xmlFsType.Clusters = HPVH.totalBlocks; XmlFsType.Clusters = HPVH.totalBlocks;
xmlFsType.ClusterSize = (int)HPVH.blockSize; XmlFsType.ClusterSize = (int)HPVH.blockSize;
if(HPVH.createDate > 0) if(HPVH.createDate > 0)
{ {
xmlFsType.CreationDate = DateHandlers.MacToDateTime(HPVH.createDate); XmlFsType.CreationDate = DateHandlers.MacToDateTime(HPVH.createDate);
xmlFsType.CreationDateSpecified = true; XmlFsType.CreationDateSpecified = true;
} }
xmlFsType.Dirty = (HPVH.attributes & 0x100) != 0x100; XmlFsType.Dirty = (HPVH.attributes & 0x100) != 0x100;
xmlFsType.Files = HPVH.fileCount; XmlFsType.Files = HPVH.fileCount;
xmlFsType.FilesSpecified = true; XmlFsType.FilesSpecified = true;
xmlFsType.FreeClusters = HPVH.freeBlocks; XmlFsType.FreeClusters = HPVH.freeBlocks;
xmlFsType.FreeClustersSpecified = true; XmlFsType.FreeClustersSpecified = true;
if(HPVH.modifyDate > 0) if(HPVH.modifyDate > 0)
{ {
xmlFsType.ModificationDate = DateHandlers.MacToDateTime(HPVH.modifyDate); XmlFsType.ModificationDate = DateHandlers.MacToDateTime(HPVH.modifyDate);
xmlFsType.ModificationDateSpecified = true; XmlFsType.ModificationDateSpecified = true;
} }
if(HPVH.signature == 0x482B) xmlFsType.Type = "HFS+"; if(HPVH.signature == 0x482B) XmlFsType.Type = "HFS+";
if(HPVH.signature == 0x4858) xmlFsType.Type = "HFSX"; if(HPVH.signature == 0x4858) XmlFsType.Type = "HFSX";
if(HPVH.drFndrInfo6 != 0 && HPVH.drFndrInfo7 != 0) if(HPVH.drFndrInfo6 != 0 && HPVH.drFndrInfo7 != 0)
xmlFsType.VolumeSerial = $"{HPVH.drFndrInfo6:X8}{HPVH.drFndrInfo7:X8}"; XmlFsType.VolumeSerial = $"{HPVH.drFndrInfo6:X8}{HPVH.drFndrInfo7:X8}";
xmlFsType.SystemIdentifier = Encoding.ASCII.GetString(HPVH.lastMountedVersion); XmlFsType.SystemIdentifier = Encoding.ASCII.GetString(HPVH.lastMountedVersion);
} }
else else
{ {

12
DiscImageChef.Filesystems/AppleMFS/AppleMFS.cs
View File

@@ -62,29 +62,27 @@ namespace DiscImageChef.Filesystems.AppleMFS
byte[] mdbTags; byte[] mdbTags;
byte[] directoryTags; byte[] directoryTags;
byte[] bitmapTags; byte[] bitmapTags;
Encoding currentEncoding;
FileSystemType xmlFsType; public FileSystemType XmlFsType { get; private set; }
public FileSystemType XmlFsType => xmlFsType;
public string Name => "Apple Macintosh File System"; public string Name => "Apple Macintosh File System";
public Guid Id => new Guid("36405F8D-0D26-4066-6538-5DBF5D065C3A"); public Guid Id => new Guid("36405F8D-0D26-4066-6538-5DBF5D065C3A");
public Encoding Encoding => currentEncoding; public Encoding Encoding { get; private set; }
public AppleMFS() public AppleMFS()
{ {
currentEncoding = Encoding.GetEncoding("macintosh"); Encoding = Encoding.GetEncoding("macintosh");
} }
public AppleMFS(Encoding encoding) public AppleMFS(Encoding encoding)
{ {
currentEncoding = encoding ?? Encoding.GetEncoding("macintosh"); Encoding = encoding ?? Encoding.GetEncoding("macintosh");
} }
public AppleMFS(IMediaImage imagePlugin, Partition partition, Encoding encoding) public AppleMFS(IMediaImage imagePlugin, Partition partition, Encoding encoding)
{ {
device = imagePlugin; device = imagePlugin;
partitionStart = partition.Start; partitionStart = partition.Start;
currentEncoding = encoding ?? Encoding.GetEncoding("macintosh"); Encoding = encoding ?? Encoding.GetEncoding("macintosh");
} }
} }
} }

6
DiscImageChef.Filesystems/AppleMFS/Dir.cs
View File

@@ -92,7 +92,7 @@ namespace DiscImageChef.Filesystems.AppleMFS
entry.flNam = new byte[directoryBlocks[offset + 50] + 1]; entry.flNam = new byte[directoryBlocks[offset + 50] + 1];
Array.Copy(directoryBlocks, offset + 50, entry.flNam, 0, entry.flNam.Length); Array.Copy(directoryBlocks, offset + 50, entry.flNam, 0, entry.flNam.Length);
string lowerFilename = StringHandlers string lowerFilename = StringHandlers
.PascalToString(entry.flNam, currentEncoding).ToLowerInvariant().Replace('/', ':'); .PascalToString(entry.flNam, Encoding).ToLowerInvariant().Replace('/', ':');
if(entry.flFlags.HasFlag(MFS_FileFlags.Used) && !idToFilename.ContainsKey(entry.flFlNum) && if(entry.flFlags.HasFlag(MFS_FileFlags.Used) && !idToFilename.ContainsKey(entry.flFlNum) &&
!idToEntry.ContainsKey(entry.flFlNum) && !filenameToId.ContainsKey(lowerFilename) && !idToEntry.ContainsKey(entry.flFlNum) && !filenameToId.ContainsKey(lowerFilename) &&
@@ -100,7 +100,7 @@ namespace DiscImageChef.Filesystems.AppleMFS
{ {
idToEntry.Add(entry.flFlNum, entry); idToEntry.Add(entry.flFlNum, entry);
idToFilename.Add(entry.flFlNum, idToFilename.Add(entry.flFlNum,
StringHandlers.PascalToString(entry.flNam, currentEncoding).Replace('/', ':')); StringHandlers.PascalToString(entry.flNam, Encoding).Replace('/', ':'));
filenameToId.Add(lowerFilename, entry.flFlNum); filenameToId.Add(lowerFilename, entry.flFlNum);
DicConsole.DebugWriteLine("DEBUG (AppleMFS plugin)", "entry.flFlags = {0}", entry.flFlags); DicConsole.DebugWriteLine("DEBUG (AppleMFS plugin)", "entry.flFlags = {0}", entry.flFlags);
@@ -117,7 +117,7 @@ namespace DiscImageChef.Filesystems.AppleMFS
DicConsole.DebugWriteLine("DEBUG (AppleMFS plugin)", "entry.flMdDat = {0}", DicConsole.DebugWriteLine("DEBUG (AppleMFS plugin)", "entry.flMdDat = {0}",
DateHandlers.MacToDateTime(entry.flMdDat)); DateHandlers.MacToDateTime(entry.flMdDat));
DicConsole.DebugWriteLine("DEBUG (AppleMFS plugin)", "entry.flNam0 = {0}", DicConsole.DebugWriteLine("DEBUG (AppleMFS plugin)", "entry.flNam0 = {0}",
StringHandlers.PascalToString(entry.flNam, currentEncoding)); StringHandlers.PascalToString(entry.flNam, Encoding));
} }
offset += 50 + entry.flNam.Length; offset += 50 + entry.flNam.Length;

47
DiscImageChef.Filesystems/AppleMFS/Info.cs
View File

@@ -56,7 +56,8 @@ namespace DiscImageChef.Filesystems.AppleMFS
return drSigWord == MFS_MAGIC; return drSigWord == MFS_MAGIC;
} }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, Encoding encoding) public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding)
{ {
information = ""; information = "";
@@ -90,7 +91,7 @@ namespace DiscImageChef.Filesystems.AppleMFS
MDB.drVNSiz = mdbSector[0x024]; MDB.drVNSiz = mdbSector[0x024];
byte[] variableSize = new byte[MDB.drVNSiz + 1]; byte[] variableSize = new byte[MDB.drVNSiz + 1];
Array.Copy(mdbSector, 0x024, variableSize, 0, MDB.drVNSiz + 1); Array.Copy(mdbSector, 0x024, variableSize, 0, MDB.drVNSiz + 1);
MDB.drVN = StringHandlers.PascalToString(variableSize, currentEncoding); MDB.drVN = StringHandlers.PascalToString(variableSize, Encoding);
BB.signature = BigEndianBitConverter.ToUInt16(bbSector, 0x000); BB.signature = BigEndianBitConverter.ToUInt16(bbSector, 0x000);
@@ -103,19 +104,19 @@ namespace DiscImageChef.Filesystems.AppleMFS
BB.sec_sv_pages = BigEndianBitConverter.ToInt16(bbSector, 0x008); BB.sec_sv_pages = BigEndianBitConverter.ToInt16(bbSector, 0x008);
Array.Copy(mdbSector, 0x00A, pString, 0, 16); Array.Copy(mdbSector, 0x00A, pString, 0, 16);
BB.system_name = StringHandlers.PascalToString(pString, currentEncoding); BB.system_name = StringHandlers.PascalToString(pString, Encoding);
Array.Copy(mdbSector, 0x01A, pString, 0, 16); Array.Copy(mdbSector, 0x01A, pString, 0, 16);
BB.finder_name = StringHandlers.PascalToString(pString, currentEncoding); BB.finder_name = StringHandlers.PascalToString(pString, Encoding);
Array.Copy(mdbSector, 0x02A, pString, 0, 16); Array.Copy(mdbSector, 0x02A, pString, 0, 16);
BB.debug_name = StringHandlers.PascalToString(pString, currentEncoding); BB.debug_name = StringHandlers.PascalToString(pString, Encoding);
Array.Copy(mdbSector, 0x03A, pString, 0, 16); Array.Copy(mdbSector, 0x03A, pString, 0, 16);
BB.disasm_name = StringHandlers.PascalToString(pString, currentEncoding); BB.disasm_name = StringHandlers.PascalToString(pString, Encoding);
Array.Copy(mdbSector, 0x04A, pString, 0, 16); Array.Copy(mdbSector, 0x04A, pString, 0, 16);
BB.stupscr_name = StringHandlers.PascalToString(pString, currentEncoding); BB.stupscr_name = StringHandlers.PascalToString(pString, Encoding);
Array.Copy(mdbSector, 0x05A, pString, 0, 16); Array.Copy(mdbSector, 0x05A, pString, 0, 16);
BB.bootup_name = StringHandlers.PascalToString(pString, currentEncoding); BB.bootup_name = StringHandlers.PascalToString(pString, Encoding);
Array.Copy(mdbSector, 0x06A, pString, 0, 16); Array.Copy(mdbSector, 0x06A, pString, 0, 16);
BB.clipbrd_name = StringHandlers.PascalToString(pString, currentEncoding); BB.clipbrd_name = StringHandlers.PascalToString(pString, Encoding);
BB.max_files = BigEndianBitConverter.ToUInt16(bbSector, 0x07A); BB.max_files = BigEndianBitConverter.ToUInt16(bbSector, 0x07A);
BB.queue_size = BigEndianBitConverter.ToUInt16(bbSector, 0x07C); BB.queue_size = BigEndianBitConverter.ToUInt16(bbSector, 0x07C);
@@ -173,26 +174,26 @@ namespace DiscImageChef.Filesystems.AppleMFS
information = sb.ToString(); information = sb.ToString();
xmlFsType = new FileSystemType(); XmlFsType = new FileSystemType();
if(MDB.drLsBkUp > 0) if(MDB.drLsBkUp > 0)
{ {
xmlFsType.BackupDate = DateHandlers.MacToDateTime(MDB.drLsBkUp); XmlFsType.BackupDate = DateHandlers.MacToDateTime(MDB.drLsBkUp);
xmlFsType.BackupDateSpecified = true; XmlFsType.BackupDateSpecified = true;
} }
xmlFsType.Bootable = BB.signature == MFSBB_MAGIC; XmlFsType.Bootable = BB.signature == MFSBB_MAGIC;
xmlFsType.Clusters = MDB.drNmAlBlks; XmlFsType.Clusters = MDB.drNmAlBlks;
xmlFsType.ClusterSize = (int)MDB.drAlBlkSiz; XmlFsType.ClusterSize = (int)MDB.drAlBlkSiz;
if(MDB.drCrDate > 0) if(MDB.drCrDate > 0)
{ {
xmlFsType.CreationDate = DateHandlers.MacToDateTime(MDB.drCrDate); XmlFsType.CreationDate = DateHandlers.MacToDateTime(MDB.drCrDate);
xmlFsType.CreationDateSpecified = true; XmlFsType.CreationDateSpecified = true;
} }
xmlFsType.Files = MDB.drNmFls; XmlFsType.Files = MDB.drNmFls;
xmlFsType.FilesSpecified = true; XmlFsType.FilesSpecified = true;
xmlFsType.FreeClusters = MDB.drFreeBks; XmlFsType.FreeClusters = MDB.drFreeBks;
xmlFsType.FreeClustersSpecified = true; XmlFsType.FreeClustersSpecified = true;
xmlFsType.Type = "MFS"; XmlFsType.Type = "MFS";
xmlFsType.VolumeName = MDB.drVN; XmlFsType.VolumeName = MDB.drVN;
} }
} }
} }

32
DiscImageChef.Filesystems/AppleMFS/Super.cs
View File

@@ -45,7 +45,7 @@ namespace DiscImageChef.Filesystems.AppleMFS
{ {
device = imagePlugin; device = imagePlugin;
partitionStart = partition.Start; partitionStart = partition.Start;
currentEncoding = encoding ?? Encoding.GetEncoding("macintosh"); Encoding = encoding ?? Encoding.GetEncoding("macintosh");
this.debug = debug; this.debug = debug;
volMDB = new MFS_MasterDirectoryBlock(); volMDB = new MFS_MasterDirectoryBlock();
@@ -72,7 +72,7 @@ namespace DiscImageChef.Filesystems.AppleMFS
volMDB.drVNSiz = mdbBlocks[0x024]; volMDB.drVNSiz = mdbBlocks[0x024];
byte[] variableSize = new byte[volMDB.drVNSiz + 1]; byte[] variableSize = new byte[volMDB.drVNSiz + 1];
Array.Copy(mdbBlocks, 0x024, variableSize, 0, volMDB.drVNSiz + 1); Array.Copy(mdbBlocks, 0x024, variableSize, 0, volMDB.drVNSiz + 1);
volMDB.drVN = StringHandlers.PascalToString(variableSize, currentEncoding); volMDB.drVN = StringHandlers.PascalToString(variableSize, Encoding);
directoryBlocks = device.ReadSectors(volMDB.drDirSt + partitionStart, volMDB.drBlLen); directoryBlocks = device.ReadSectors(volMDB.drDirSt + partitionStart, volMDB.drBlLen);
int bytesInBlockMap = volMDB.drNmAlBlks * 12 / 8 + volMDB.drNmAlBlks * 12 % 8; int bytesInBlockMap = volMDB.drNmAlBlks * 12 / 8 + volMDB.drNmAlBlks * 12 % 8;
@@ -130,26 +130,26 @@ namespace DiscImageChef.Filesystems.AppleMFS
if(bbSig != MFSBB_MAGIC) bootBlocks = null; if(bbSig != MFSBB_MAGIC) bootBlocks = null;
xmlFsType = new FileSystemType(); XmlFsType = new FileSystemType();
if(volMDB.drLsBkUp > 0) if(volMDB.drLsBkUp > 0)
{ {
xmlFsType.BackupDate = DateHandlers.MacToDateTime(volMDB.drLsBkUp); XmlFsType.BackupDate = DateHandlers.MacToDateTime(volMDB.drLsBkUp);
xmlFsType.BackupDateSpecified = true; XmlFsType.BackupDateSpecified = true;
} }
xmlFsType.Bootable = bbSig == MFSBB_MAGIC; XmlFsType.Bootable = bbSig == MFSBB_MAGIC;
xmlFsType.Clusters = volMDB.drNmAlBlks; XmlFsType.Clusters = volMDB.drNmAlBlks;
xmlFsType.ClusterSize = (int)volMDB.drAlBlkSiz; XmlFsType.ClusterSize = (int)volMDB.drAlBlkSiz;
if(volMDB.drCrDate > 0) if(volMDB.drCrDate > 0)
{ {
xmlFsType.CreationDate = DateHandlers.MacToDateTime(volMDB.drCrDate); XmlFsType.CreationDate = DateHandlers.MacToDateTime(volMDB.drCrDate);
xmlFsType.CreationDateSpecified = true; XmlFsType.CreationDateSpecified = true;
} }
xmlFsType.Files = volMDB.drNmFls; XmlFsType.Files = volMDB.drNmFls;
xmlFsType.FilesSpecified = true; XmlFsType.FilesSpecified = true;
xmlFsType.FreeClusters = volMDB.drFreeBks; XmlFsType.FreeClusters = volMDB.drFreeBks;
xmlFsType.FreeClustersSpecified = true; XmlFsType.FreeClustersSpecified = true;
xmlFsType.Type = "MFS"; XmlFsType.Type = "MFS";
xmlFsType.VolumeName = volMDB.drVN; XmlFsType.VolumeName = volMDB.drVN;
return Errno.NoError; return Errno.NoError;
} }

17
DiscImageChef.Filesystems/AtheOS.cs
View File

@@ -31,7 +31,6 @@
// ****************************************************************************/ // ****************************************************************************/
using System; using System;
using System.Collections.Generic;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
using System.Text; using System.Text;
using DiscImageChef.CommonTypes; using DiscImageChef.CommonTypes;
@@ -49,11 +48,9 @@ namespace DiscImageChef.Filesystems
// Common constants // Common constants
const uint AFS_SUPERBLOCK_SIZE = 1024; const uint AFS_SUPERBLOCK_SIZE = 1024;
const uint AFS_BOOTBLOCK_SIZE = AFS_SUPERBLOCK_SIZE; const uint AFS_BOOTBLOCK_SIZE = AFS_SUPERBLOCK_SIZE;
Encoding currentEncoding;
FileSystemType xmlFsType;
public FileSystemType XmlFsType => xmlFsType;
public Encoding Encoding => currentEncoding; public FileSystemType XmlFsType { get; private set; }
public Encoding Encoding { get; private set; }
public string Name => "AtheOS Filesystem"; public string Name => "AtheOS Filesystem";
public Guid Id => new Guid("AAB2C4F1-DC07-49EE-A948-576CC51B58C5"); public Guid Id => new Guid("AAB2C4F1-DC07-49EE-A948-576CC51B58C5");
@@ -80,9 +77,9 @@ namespace DiscImageChef.Filesystems
} }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding) Encoding encoding)
{ {
currentEncoding = encoding ?? Encoding.GetEncoding("iso-8859-15"); Encoding = encoding ?? Encoding.GetEncoding("iso-8859-15");
information = ""; information = "";
StringBuilder sb = new StringBuilder(); StringBuilder sb = new StringBuilder();
@@ -107,7 +104,7 @@ namespace DiscImageChef.Filesystems
if(afsSb.flags == 1) sb.AppendLine("Filesystem is read-only"); if(afsSb.flags == 1) sb.AppendLine("Filesystem is read-only");
sb.AppendFormat("Volume name: {0}", StringHandlers.CToString(afsSb.name, currentEncoding)).AppendLine(); sb.AppendFormat("Volume name: {0}", StringHandlers.CToString(afsSb.name, Encoding)).AppendLine();
sb.AppendFormat("{0} bytes per block", afsSb.block_size).AppendLine(); sb.AppendFormat("{0} bytes per block", afsSb.block_size).AppendLine();
sb.AppendFormat("{0} blocks in volume ({1} bytes)", afsSb.num_blocks, afsSb.num_blocks * afsSb.block_size) sb.AppendFormat("{0} blocks in volume ({1} bytes)", afsSb.num_blocks, afsSb.num_blocks * afsSb.block_size)
.AppendLine(); .AppendLine();
@@ -139,7 +136,7 @@ namespace DiscImageChef.Filesystems
information = sb.ToString(); information = sb.ToString();
xmlFsType = new FileSystemType XmlFsType = new FileSystemType
{ {
Clusters = afsSb.num_blocks, Clusters = afsSb.num_blocks,
ClusterSize = (int)afsSb.block_size, ClusterSize = (int)afsSb.block_size,
@@ -147,7 +144,7 @@ namespace DiscImageChef.Filesystems
FreeClusters = afsSb.num_blocks - afsSb.used_blocks, FreeClusters = afsSb.num_blocks - afsSb.used_blocks,
FreeClustersSpecified = true, FreeClustersSpecified = true,
Type = "AtheOS filesystem", Type = "AtheOS filesystem",
VolumeName = StringHandlers.CToString(afsSb.name, currentEncoding) VolumeName = StringHandlers.CToString(afsSb.name, Encoding)
}; };
} }

18
DiscImageChef.Filesystems/BFS.cs
View File

@@ -31,7 +31,6 @@
// ****************************************************************************/ // ****************************************************************************/
using System; using System;
using System.Collections.Generic;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
using System.Text; using System.Text;
using DiscImageChef.CommonTypes; using DiscImageChef.CommonTypes;
@@ -54,11 +53,9 @@ namespace DiscImageChef.Filesystems
// Common constants // Common constants
const uint BEFS_CLEAN = 0x434C454E; const uint BEFS_CLEAN = 0x434C454E;
const uint BEFS_DIRTY = 0x44495254; const uint BEFS_DIRTY = 0x44495254;
Encoding currentEncoding;
FileSystemType xmlFsType;
public FileSystemType XmlFsType => xmlFsType;
public Encoding Encoding => currentEncoding; public FileSystemType XmlFsType { get; private set; }
public Encoding Encoding { get; private set; }
public string Name => "Be Filesystem"; public string Name => "Be Filesystem";
public Guid Id => new Guid("dc8572b3-b6ad-46e4-8de9-cbe123ff6672"); public Guid Id => new Guid("dc8572b3-b6ad-46e4-8de9-cbe123ff6672");
@@ -92,9 +89,10 @@ namespace DiscImageChef.Filesystems
return magic == BEFS_MAGIC1 || magicBe == BEFS_MAGIC1; return magic == BEFS_MAGIC1 || magicBe == BEFS_MAGIC1;
} }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, Encoding encoding) public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding)
{ {
currentEncoding = encoding ?? Encoding.GetEncoding("iso-8859-15"); Encoding = encoding ?? Encoding.GetEncoding("iso-8859-15");
information = ""; information = "";
StringBuilder sb = new StringBuilder(); StringBuilder sb = new StringBuilder();
@@ -170,7 +168,7 @@ namespace DiscImageChef.Filesystems
break; break;
} }
sb.AppendFormat("Volume name: {0}", StringHandlers.CToString(besb.name, currentEncoding)).AppendLine(); sb.AppendFormat("Volume name: {0}", StringHandlers.CToString(besb.name, Encoding)).AppendLine();
sb.AppendFormat("{0} bytes per block", besb.block_size).AppendLine(); sb.AppendFormat("{0} bytes per block", besb.block_size).AppendLine();
sb.AppendFormat("{0} blocks in volume ({1} bytes)", besb.num_blocks, besb.num_blocks * besb.block_size) sb.AppendFormat("{0} blocks in volume ({1} bytes)", besb.num_blocks, besb.num_blocks * besb.block_size)
.AppendLine(); .AppendLine();
@@ -196,7 +194,7 @@ namespace DiscImageChef.Filesystems
information = sb.ToString(); information = sb.ToString();
xmlFsType = new FileSystemType XmlFsType = new FileSystemType
{ {
Clusters = besb.num_blocks, Clusters = besb.num_blocks,
ClusterSize = (int)besb.block_size, ClusterSize = (int)besb.block_size,
@@ -204,7 +202,7 @@ namespace DiscImageChef.Filesystems
FreeClusters = besb.num_blocks - besb.used_blocks, FreeClusters = besb.num_blocks - besb.used_blocks,
FreeClustersSpecified = true, FreeClustersSpecified = true,
Type = "BeFS", Type = "BeFS",
VolumeName = StringHandlers.CToString(besb.name, currentEncoding) VolumeName = StringHandlers.CToString(besb.name, Encoding)
}; };
} }

17
DiscImageChef.Filesystems/BTRFS.cs
View File

@@ -31,7 +31,6 @@
// ****************************************************************************/ // ****************************************************************************/
using System; using System;
using System.Collections.Generic;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
using System.Text; using System.Text;
using DiscImageChef.CommonTypes; using DiscImageChef.CommonTypes;
@@ -47,11 +46,9 @@ namespace DiscImageChef.Filesystems
/// BTRFS magic "_BHRfS_M" /// BTRFS magic "_BHRfS_M"
/// </summary> /// </summary>
const ulong btrfsMagic = 0x4D5F53665248425F; const ulong btrfsMagic = 0x4D5F53665248425F;
FileSystemType xmlFsType;
public FileSystemType XmlFsType => xmlFsType;
Encoding currentEncoding; public FileSystemType XmlFsType { get; private set; }
public Encoding Encoding => currentEncoding; public Encoding Encoding { get; private set; }
public string Name => "B-tree file system"; public string Name => "B-tree file system";
public Guid Id => new Guid("C904CF15-5222-446B-B7DB-02EAC5D781B3"); public Guid Id => new Guid("C904CF15-5222-446B-B7DB-02EAC5D781B3");
@@ -84,11 +81,11 @@ namespace DiscImageChef.Filesystems
} }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding) Encoding encoding)
{ {
currentEncoding = encoding ?? Encoding.GetEncoding("iso-8859-15"); Encoding = encoding ?? Encoding.GetEncoding("iso-8859-15");
StringBuilder sbInformation = new StringBuilder(); StringBuilder sbInformation = new StringBuilder();
xmlFsType = new FileSystemType(); XmlFsType = new FileSystemType();
information = ""; information = "";
ulong sbSectorOff = 0x10000 / imagePlugin.Info.SectorSize; ulong sbSectorOff = 0x10000 / imagePlugin.Info.SectorSize;
@@ -171,7 +168,7 @@ namespace DiscImageChef.Filesystems
information = sbInformation.ToString(); information = sbInformation.ToString();
xmlFsType = new FileSystemType XmlFsType = new FileSystemType
{ {
Clusters = (long)(btrfsSb.total_bytes / btrfsSb.sectorsize), Clusters = (long)(btrfsSb.total_bytes / btrfsSb.sectorsize),
ClusterSize = (int)btrfsSb.sectorsize, ClusterSize = (int)btrfsSb.sectorsize,
@@ -181,7 +178,7 @@ namespace DiscImageChef.Filesystems
VolumeSetIdentifier = $"{btrfsSb.dev_item.device_uuid}", VolumeSetIdentifier = $"{btrfsSb.dev_item.device_uuid}",
Type = Name Type = Name
}; };
xmlFsType.FreeClusters = xmlFsType.Clusters - (long)(btrfsSb.bytes_used / btrfsSb.sectorsize); XmlFsType.FreeClusters = XmlFsType.Clusters - (long)(btrfsSb.bytes_used / btrfsSb.sectorsize);
} }
[StructLayout(LayoutKind.Sequential, Pack = 1)] [StructLayout(LayoutKind.Sequential, Pack = 1)]

27
DiscImageChef.Filesystems/CBM.cs
View File

@@ -31,7 +31,6 @@
// ****************************************************************************/ // ****************************************************************************/
using System; using System;
using System.Collections.Generic;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
using System.Text; using System.Text;
using Claunia.Encoding; using Claunia.Encoding;
@@ -44,13 +43,10 @@ namespace DiscImageChef.Filesystems
{ {
public class CBM : IFilesystem public class CBM : IFilesystem
{ {
Encoding currentEncoding; public FileSystemType XmlFsType { get; private set; }
FileSystemType xmlFsType;
public FileSystemType XmlFsType => xmlFsType;
public string Name => "Commodore file system"; public string Name => "Commodore file system";
public Guid Id => new Guid("D104744E-A376-450C-BAC0-1347C93F983B"); public Guid Id => new Guid("D104744E-A376-450C-BAC0-1347C93F983B");
public Encoding Encoding => currentEncoding; public Encoding Encoding { get; private set; }
public bool Identify(IMediaImage imagePlugin, Partition partition) public bool Identify(IMediaImage imagePlugin, Partition partition)
{ {
@@ -91,16 +87,17 @@ namespace DiscImageChef.Filesystems
return false; return false;
} }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, Encoding encoding) public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding)
{ {
currentEncoding = new PETSCII(); Encoding = new PETSCII();
byte[] sector; byte[] sector;
StringBuilder sbInformation = new StringBuilder(); StringBuilder sbInformation = new StringBuilder();
sbInformation.AppendLine("Commodore file system"); sbInformation.AppendLine("Commodore file system");
xmlFsType = new FileSystemType XmlFsType = new FileSystemType
{ {
Type = "Commodore file system", Type = "Commodore file system",
Clusters = (long)imagePlugin.Info.Sectors, Clusters = (long)imagePlugin.Info.Sectors,
@@ -126,11 +123,11 @@ namespace DiscImageChef.Filesystems
sbInformation.AppendFormat("Disk Version: {0}", Encoding.ASCII.GetString(new[] {cbmHdr.diskVersion})) sbInformation.AppendFormat("Disk Version: {0}", Encoding.ASCII.GetString(new[] {cbmHdr.diskVersion}))
.AppendLine(); .AppendLine();
sbInformation.AppendFormat("Disk ID: {0}", cbmHdr.diskId).AppendLine(); sbInformation.AppendFormat("Disk ID: {0}", cbmHdr.diskId).AppendLine();
sbInformation.AppendFormat("Disk name: {0}", StringHandlers.CToString(cbmHdr.name, currentEncoding)) sbInformation.AppendFormat("Disk name: {0}", StringHandlers.CToString(cbmHdr.name, Encoding))
.AppendLine(); .AppendLine();
xmlFsType.VolumeName = StringHandlers.CToString(cbmHdr.name, currentEncoding); XmlFsType.VolumeName = StringHandlers.CToString(cbmHdr.name, Encoding);
xmlFsType.VolumeSerial = $"{cbmHdr.diskId}"; XmlFsType.VolumeSerial = $"{cbmHdr.diskId}";
} }
else else
{ {
@@ -149,11 +146,11 @@ namespace DiscImageChef.Filesystems
sbInformation.AppendFormat("DOS Version: {0}", Encoding.ASCII.GetString(new[] {cbmBam.dosVersion})) sbInformation.AppendFormat("DOS Version: {0}", Encoding.ASCII.GetString(new[] {cbmBam.dosVersion}))
.AppendLine(); .AppendLine();
sbInformation.AppendFormat("Disk ID: {0}", cbmBam.diskId).AppendLine(); sbInformation.AppendFormat("Disk ID: {0}", cbmBam.diskId).AppendLine();
sbInformation.AppendFormat("Disk name: {0}", StringHandlers.CToString(cbmBam.name, currentEncoding)) sbInformation.AppendFormat("Disk name: {0}", StringHandlers.CToString(cbmBam.name, Encoding))
.AppendLine(); .AppendLine();
xmlFsType.VolumeName = StringHandlers.CToString(cbmBam.name, currentEncoding); XmlFsType.VolumeName = StringHandlers.CToString(cbmBam.name, Encoding);
xmlFsType.VolumeSerial = $"{cbmBam.diskId}"; XmlFsType.VolumeSerial = $"{cbmBam.diskId}";
} }
information = sbInformation.ToString(); information = sbInformation.ToString();

7
DiscImageChef.Filesystems/CPM/CPM.cs
View File

@@ -51,7 +51,6 @@ namespace DiscImageChef.Filesystems.CPM
/// </summary> /// </summary>
FileSystemInfo cpmStat; FileSystemInfo cpmStat;
Encoding currentEncoding;
/// <summary> /// <summary>
/// Cached file passwords, decoded /// Cached file passwords, decoded
/// </summary> /// </summary>
@@ -112,9 +111,9 @@ namespace DiscImageChef.Filesystems.CPM
/// If <see cref="Identify" /> thinks this is a CP/M filesystem, this is the definition for it /// If <see cref="Identify" /> thinks this is a CP/M filesystem, this is the definition for it
/// </summary> /// </summary>
CpmDefinition workingDefinition; CpmDefinition workingDefinition;
FileSystemType xmlFsType;
public FileSystemType XmlFsType => xmlFsType; public FileSystemType XmlFsType { get; private set; }
public Encoding Encoding => currentEncoding; public Encoding Encoding { get; private set; }
public string Name => "CP/M File System"; public string Name => "CP/M File System";
public Guid Id => new Guid("AA2B8585-41DF-4E3B-8A35-D1A935E2F8A1"); public Guid Id => new Guid("AA2B8585-41DF-4E3B-8A35-D1A935E2F8A1");
} }

2
DiscImageChef.Filesystems/CPM/File.cs
View File

@@ -107,7 +107,7 @@ namespace DiscImageChef.Filesystems.CPM
if(labelCreationDate != null) stat.CreationTime = DateHandlers.CpmToDateTime(labelCreationDate); if(labelCreationDate != null) stat.CreationTime = DateHandlers.CpmToDateTime(labelCreationDate);
if(labelUpdateDate != null) stat.StatusChangeTime = DateHandlers.CpmToDateTime(labelUpdateDate); if(labelUpdateDate != null) stat.StatusChangeTime = DateHandlers.CpmToDateTime(labelUpdateDate);
stat.Attributes = FileAttributes.Directory; stat.Attributes = FileAttributes.Directory;
stat.BlockSize = xmlFsType.ClusterSize; stat.BlockSize = XmlFsType.ClusterSize;
return Errno.NoError; return Errno.NoError;
} }

30
DiscImageChef.Filesystems/CPM/Info.cs
View File

@@ -203,8 +203,7 @@ namespace DiscImageChef.Filesystems.CPM
sectorSize = (ulong)(128 << amsSb.psh); sectorSize = (ulong)(128 << amsSb.psh);
// Compare device limits from superblock to real limits // Compare device limits from superblock to real limits
if(sectorSize == imagePlugin.Info.SectorSize && if(sectorSize == imagePlugin.Info.SectorSize && sectorCount == imagePlugin.Info.Sectors)
sectorCount == imagePlugin.Info.Sectors)
{ {
cpmFound = true; cpmFound = true;
firstDirectorySector = (ulong)(amsSb.off * amsSb.spt); firstDirectorySector = (ulong)(amsSb.off * amsSb.spt);
@@ -976,9 +975,10 @@ namespace DiscImageChef.Filesystems.CPM
} }
} }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, Encoding encoding) public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding)
{ {
currentEncoding = encoding ?? Encoding.GetEncoding("IBM437"); Encoding = encoding ?? Encoding.GetEncoding("IBM437");
information = ""; information = "";
// As the identification is so complex, just call Identify() and relay on its findings // As the identification is so complex, just call Identify() and relay on its findings
if(!Identify(imagePlugin, partition) || !cpmFound || workingDefinition == null || dpb == null) return; if(!Identify(imagePlugin, partition) || !cpmFound || workingDefinition == null || dpb == null) return;
@@ -1051,23 +1051,23 @@ namespace DiscImageChef.Filesystems.CPM
if(labelUpdateDate != null) if(labelUpdateDate != null)
sb.AppendFormat("Volume updated on {0}", DateHandlers.CpmToDateTime(labelUpdateDate)).AppendLine(); sb.AppendFormat("Volume updated on {0}", DateHandlers.CpmToDateTime(labelUpdateDate)).AppendLine();
xmlFsType = new FileSystemType(); XmlFsType = new FileSystemType();
xmlFsType.Bootable |= workingDefinition.sofs > 0 || workingDefinition.ofs > 0; XmlFsType.Bootable |= workingDefinition.sofs > 0 || workingDefinition.ofs > 0;
xmlFsType.ClusterSize = 128 << dpb.bsh; XmlFsType.ClusterSize = 128 << dpb.bsh;
if(dpb.dsm > 0) xmlFsType.Clusters = dpb.dsm; if(dpb.dsm > 0) XmlFsType.Clusters = dpb.dsm;
else xmlFsType.Clusters = (long)(partition.End - partition.Start); else XmlFsType.Clusters = (long)(partition.End - partition.Start);
if(labelCreationDate != null) if(labelCreationDate != null)
{ {
xmlFsType.CreationDate = DateHandlers.CpmToDateTime(labelCreationDate); XmlFsType.CreationDate = DateHandlers.CpmToDateTime(labelCreationDate);
xmlFsType.CreationDateSpecified = true; XmlFsType.CreationDateSpecified = true;
} }
if(labelUpdateDate != null) if(labelUpdateDate != null)
{ {
xmlFsType.ModificationDate = DateHandlers.CpmToDateTime(labelUpdateDate); XmlFsType.ModificationDate = DateHandlers.CpmToDateTime(labelUpdateDate);
xmlFsType.ModificationDateSpecified = true; XmlFsType.ModificationDateSpecified = true;
} }
xmlFsType.Type = "CP/M"; XmlFsType.Type = "CP/M";
xmlFsType.VolumeName = label; XmlFsType.VolumeName = label;
information = sb.ToString(); information = sb.ToString();
} }

16
DiscImageChef.Filesystems/CPM/Super.cs
View File

@@ -50,8 +50,8 @@ namespace DiscImageChef.Filesystems.CPM
public Errno Mount(IMediaImage imagePlugin, Partition partition1, Encoding encoding, bool debug) public Errno Mount(IMediaImage imagePlugin, Partition partition1, Encoding encoding, bool debug)
{ {
device = imagePlugin; device = imagePlugin;
this.partition = partition; partition = partition;
currentEncoding = encoding ?? Encoding.GetEncoding("IBM437"); Encoding = encoding ?? Encoding.GetEncoding("IBM437");
// As the identification is so complex, just call Identify() and relay on its findings // As the identification is so complex, just call Identify() and relay on its findings
if(!Identify(device, partition) || !cpmFound || workingDefinition == null || dpb == null) if(!Identify(device, partition) || !cpmFound || workingDefinition == null || dpb == null)
@@ -656,7 +656,7 @@ namespace DiscImageChef.Filesystems.CPM
cpmStat.Type = "CP/M filesystem"; cpmStat.Type = "CP/M filesystem";
// Generate XML info // Generate XML info
xmlFsType = new FileSystemType XmlFsType = new FileSystemType
{ {
Clusters = cpmStat.Blocks, Clusters = cpmStat.Blocks,
ClusterSize = blockSize, ClusterSize = blockSize,
@@ -668,15 +668,15 @@ namespace DiscImageChef.Filesystems.CPM
}; };
if(labelCreationDate != null) if(labelCreationDate != null)
{ {
xmlFsType.CreationDate = DateHandlers.CpmToDateTime(labelCreationDate); XmlFsType.CreationDate = DateHandlers.CpmToDateTime(labelCreationDate);
xmlFsType.CreationDateSpecified = true; XmlFsType.CreationDateSpecified = true;
} }
if(labelUpdateDate != null) if(labelUpdateDate != null)
{ {
xmlFsType.ModificationDate = DateHandlers.CpmToDateTime(labelUpdateDate); XmlFsType.ModificationDate = DateHandlers.CpmToDateTime(labelUpdateDate);
xmlFsType.ModificationDateSpecified = true; XmlFsType.ModificationDateSpecified = true;
} }
if(!string.IsNullOrEmpty(label)) xmlFsType.VolumeName = label; if(!string.IsNullOrEmpty(label)) XmlFsType.VolumeName = label;
mounted = true; mounted = true;
return Errno.NoError; return Errno.NoError;

19
DiscImageChef.Filesystems/Cram.cs
View File

@@ -31,7 +31,6 @@
// ****************************************************************************/ // ****************************************************************************/
using System; using System;
using System.Collections.Generic;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
using System.Text; using System.Text;
using DiscImageChef.CommonTypes; using DiscImageChef.CommonTypes;
@@ -47,11 +46,9 @@ namespace DiscImageChef.Filesystems
/// </summary> /// </summary>
const uint CRAM_MAGIC = 0x28CD3D45; const uint CRAM_MAGIC = 0x28CD3D45;
const uint CRAM_CIGAM = 0x453DCD28; const uint CRAM_CIGAM = 0x453DCD28;
Encoding currentEncoding;
FileSystemType xmlFsType;
public FileSystemType XmlFsType => xmlFsType;
public Encoding Encoding => currentEncoding; public FileSystemType XmlFsType { get; private set; }
public Encoding Encoding { get; private set; }
public string Name => "Cram filesystem"; public string Name => "Cram filesystem";
public Guid Id => new Guid("F8F6E46F-7A2A-48E3-9C0A-46AF4DC29E09"); public Guid Id => new Guid("F8F6E46F-7A2A-48E3-9C0A-46AF4DC29E09");
@@ -66,9 +63,10 @@ namespace DiscImageChef.Filesystems
return magic == CRAM_MAGIC || magic == CRAM_CIGAM; return magic == CRAM_MAGIC || magic == CRAM_CIGAM;
} }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, Encoding encoding) public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding)
{ {
currentEncoding = encoding ?? Encoding.GetEncoding("iso-8859-15"); Encoding = encoding ?? Encoding.GetEncoding("iso-8859-15");
byte[] sector = imagePlugin.ReadSector(partition.Start); byte[] sector = imagePlugin.ReadSector(partition.Start);
uint magic = BitConverter.ToUInt32(sector, 0x00); uint magic = BitConverter.ToUInt32(sector, 0x00);
@@ -94,17 +92,16 @@ namespace DiscImageChef.Filesystems
sbInformation.AppendLine("Cram file system"); sbInformation.AppendLine("Cram file system");
sbInformation.AppendLine(littleEndian ? "Little-endian" : "Big-endian"); sbInformation.AppendLine(littleEndian ? "Little-endian" : "Big-endian");
sbInformation.AppendFormat("Volume edition {0}", crSb.edition).AppendLine(); sbInformation.AppendFormat("Volume edition {0}", crSb.edition).AppendLine();
sbInformation.AppendFormat("Volume name: {0}", StringHandlers.CToString(crSb.name, currentEncoding)) sbInformation.AppendFormat("Volume name: {0}", StringHandlers.CToString(crSb.name, Encoding)).AppendLine();
.AppendLine();
sbInformation.AppendFormat("Volume has {0} bytes", crSb.size).AppendLine(); sbInformation.AppendFormat("Volume has {0} bytes", crSb.size).AppendLine();
sbInformation.AppendFormat("Volume has {0} blocks", crSb.blocks).AppendLine(); sbInformation.AppendFormat("Volume has {0} blocks", crSb.blocks).AppendLine();
sbInformation.AppendFormat("Volume has {0} files", crSb.files).AppendLine(); sbInformation.AppendFormat("Volume has {0} files", crSb.files).AppendLine();
information = sbInformation.ToString(); information = sbInformation.ToString();
xmlFsType = new FileSystemType XmlFsType = new FileSystemType
{ {
VolumeName = StringHandlers.CToString(crSb.name, currentEncoding), VolumeName = StringHandlers.CToString(crSb.name, Encoding),
Type = "Cram file system", Type = "Cram file system",
Clusters = crSb.blocks, Clusters = crSb.blocks,
Files = crSb.files, Files = crSb.files,

13
DiscImageChef.Filesystems/ECMA67.cs
View File

@@ -31,7 +31,6 @@
// ****************************************************************************/ // ****************************************************************************/
using System; using System;
using System.Collections.Generic;
using System.Linq; using System.Linq;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
using System.Text; using System.Text;
@@ -45,12 +44,10 @@ namespace DiscImageChef.Filesystems
{ {
readonly byte[] ECMA67_Magic = {0x56, 0x4F, 0x4C}; readonly byte[] ECMA67_Magic = {0x56, 0x4F, 0x4C};
Encoding currentEncoding; public Encoding Encoding { get; private set; }
public Encoding Encoding => currentEncoding;
public string Name => "ECMA-67"; public string Name => "ECMA-67";
public Guid Id => new Guid("62A2D44A-CBC1-4377-B4B6-28C5C92034A1"); public Guid Id => new Guid("62A2D44A-CBC1-4377-B4B6-28C5C92034A1");
FileSystemType xmlFsType; public FileSystemType XmlFsType { get; private set; }
public FileSystemType XmlFsType => xmlFsType;
public bool Identify(IMediaImage imagePlugin, Partition partition) public bool Identify(IMediaImage imagePlugin, Partition partition)
{ {
@@ -72,9 +69,9 @@ namespace DiscImageChef.Filesystems
} }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding) Encoding encoding)
{ {
currentEncoding = encoding ?? Encoding.GetEncoding("iso-8859-1"); Encoding = encoding ?? Encoding.GetEncoding("iso-8859-1");
byte[] sector = imagePlugin.ReadSector(6); byte[] sector = imagePlugin.ReadSector(6);
StringBuilder sbInformation = new StringBuilder(); StringBuilder sbInformation = new StringBuilder();
@@ -90,7 +87,7 @@ namespace DiscImageChef.Filesystems
sbInformation.AppendFormat("Volume name: {0}", Encoding.ASCII.GetString(vol.volumeIdentifier)).AppendLine(); sbInformation.AppendFormat("Volume name: {0}", Encoding.ASCII.GetString(vol.volumeIdentifier)).AppendLine();
sbInformation.AppendFormat("Volume owner: {0}", Encoding.ASCII.GetString(vol.owner)).AppendLine(); sbInformation.AppendFormat("Volume owner: {0}", Encoding.ASCII.GetString(vol.owner)).AppendLine();
xmlFsType = new FileSystemType XmlFsType = new FileSystemType
{ {
Type = "ECMA-67", Type = "ECMA-67",
ClusterSize = 256, ClusterSize = 256,

20
DiscImageChef.Filesystems/EFS.cs
View File

@@ -31,7 +31,6 @@
// ****************************************************************************/ // ****************************************************************************/
using System; using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis; using System.Diagnostics.CodeAnalysis;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
using System.Text; using System.Text;
@@ -46,11 +45,9 @@ namespace DiscImageChef.Filesystems
{ {
const uint EFS_MAGIC = 0x00072959; const uint EFS_MAGIC = 0x00072959;
const uint EFS_MAGIC_NEW = 0x0007295A; const uint EFS_MAGIC_NEW = 0x0007295A;
Encoding currentEncoding;
FileSystemType xmlFsType;
public FileSystemType XmlFsType => xmlFsType;
public Encoding Encoding => currentEncoding; public FileSystemType XmlFsType { get; private set; }
public Encoding Encoding { get; private set; }
public string Name => "Extent File System Plugin"; public string Name => "Extent File System Plugin";
public Guid Id => new Guid("52A43F90-9AF3-4391-ADFE-65598DEEABAB"); public Guid Id => new Guid("52A43F90-9AF3-4391-ADFE-65598DEEABAB");
@@ -101,9 +98,10 @@ namespace DiscImageChef.Filesystems
return false; return false;
} }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, Encoding encoding) public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding)
{ {
currentEncoding = encoding ?? Encoding.GetEncoding("iso-8859-15"); Encoding = encoding ?? Encoding.GetEncoding("iso-8859-15");
information = ""; information = "";
if(imagePlugin.Info.SectorSize < 512) return; if(imagePlugin.Info.SectorSize < 512) return;
@@ -164,12 +162,12 @@ namespace DiscImageChef.Filesystems
if(efsSb.sb_lastinode > 0) sb.AppendFormat("Last inode allocated: {0}", efsSb.sb_lastinode).AppendLine(); if(efsSb.sb_lastinode > 0) sb.AppendFormat("Last inode allocated: {0}", efsSb.sb_lastinode).AppendLine();
if(efsSb.sb_dirty > 0) sb.AppendLine("Volume is dirty"); if(efsSb.sb_dirty > 0) sb.AppendLine("Volume is dirty");
sb.AppendFormat("Checksum: 0x{0:X8}", efsSb.sb_checksum).AppendLine(); sb.AppendFormat("Checksum: 0x{0:X8}", efsSb.sb_checksum).AppendLine();
sb.AppendFormat("Volume name: {0}", StringHandlers.CToString(efsSb.sb_fname, currentEncoding)).AppendLine(); sb.AppendFormat("Volume name: {0}", StringHandlers.CToString(efsSb.sb_fname, Encoding)).AppendLine();
sb.AppendFormat("Volume pack: {0}", StringHandlers.CToString(efsSb.sb_fpack, currentEncoding)).AppendLine(); sb.AppendFormat("Volume pack: {0}", StringHandlers.CToString(efsSb.sb_fpack, Encoding)).AppendLine();
information = sb.ToString(); information = sb.ToString();
xmlFsType = new FileSystemType XmlFsType = new FileSystemType
{ {
Type = "Extent File System", Type = "Extent File System",
ClusterSize = 512, ClusterSize = 512,
@@ -177,7 +175,7 @@ namespace DiscImageChef.Filesystems
FreeClusters = efsSb.sb_tfree, FreeClusters = efsSb.sb_tfree,
FreeClustersSpecified = true, FreeClustersSpecified = true,
Dirty = efsSb.sb_dirty > 0, Dirty = efsSb.sb_dirty > 0,
VolumeName = StringHandlers.CToString(efsSb.sb_fname, currentEncoding), VolumeName = StringHandlers.CToString(efsSb.sb_fname, Encoding),
VolumeSerial = $"{efsSb.sb_checksum:X8}", VolumeSerial = $"{efsSb.sb_checksum:X8}",
CreationDate = DateHandlers.UnixToDateTime(efsSb.sb_time), CreationDate = DateHandlers.UnixToDateTime(efsSb.sb_time),
CreationDateSpecified = true CreationDateSpecified = true

14
DiscImageChef.Filesystems/F2FS.cs
View File

@@ -31,7 +31,6 @@
// ****************************************************************************/ // ****************************************************************************/
using System; using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis; using System.Diagnostics.CodeAnalysis;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
using System.Text; using System.Text;
@@ -49,11 +48,8 @@ namespace DiscImageChef.Filesystems
const uint F2FS_MAX_SECTOR = 4096; const uint F2FS_MAX_SECTOR = 4096;
const uint F2FS_BLOCK_SIZE = 4096; const uint F2FS_BLOCK_SIZE = 4096;
Encoding currentEncoding; public FileSystemType XmlFsType { get; private set; }
FileSystemType xmlFsType; public Encoding Encoding { get; private set; }
public FileSystemType XmlFsType => xmlFsType;
public Encoding Encoding => currentEncoding;
public string Name => "F2FS Plugin"; public string Name => "F2FS Plugin";
public Guid Id => new Guid("82B0920F-5F0D-4063-9F57-ADE0AE02ECE5"); public Guid Id => new Guid("82B0920F-5F0D-4063-9F57-ADE0AE02ECE5");
@@ -84,9 +80,9 @@ namespace DiscImageChef.Filesystems
} }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding) Encoding encoding)
{ {
currentEncoding = Encoding.Unicode; Encoding = Encoding.Unicode;
information = ""; information = "";
if(imagePlugin.Info.SectorSize < F2FS_MIN_SECTOR || imagePlugin.Info.SectorSize > F2FS_MAX_SECTOR) return; if(imagePlugin.Info.SectorSize < F2FS_MIN_SECTOR || imagePlugin.Info.SectorSize > F2FS_MAX_SECTOR) return;
@@ -132,7 +128,7 @@ namespace DiscImageChef.Filesystems
information = sb.ToString(); information = sb.ToString();
xmlFsType = new FileSystemType XmlFsType = new FileSystemType
{ {
Type = "F2FS filesystem", Type = "F2FS filesystem",
SystemIdentifier = Encoding.ASCII.GetString(f2fsSb.version), SystemIdentifier = Encoding.ASCII.GetString(f2fsSb.version),

123
DiscImageChef.Filesystems/FAT.cs
View File

@@ -31,7 +31,6 @@
// ****************************************************************************/ // ****************************************************************************/
using System; using System;
using System.Collections.Generic;
using System.IO; using System.IO;
using System.Linq; using System.Linq;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
@@ -53,11 +52,9 @@ namespace DiscImageChef.Filesystems
const uint FSINFO_SIGNATURE2 = 0x61417272; const uint FSINFO_SIGNATURE2 = 0x61417272;
const uint FSINFO_SIGNATURE3 = 0xAA550000; const uint FSINFO_SIGNATURE3 = 0xAA550000;
Encoding currentEncoding; public FileSystemType XmlFsType { get; private set; }
FileSystemType xmlFsType;
public FileSystemType XmlFsType => xmlFsType;
public Encoding Encoding => currentEncoding; public Encoding Encoding { get; private set; }
public string Name => "Microsoft File Allocation Table"; public string Name => "Microsoft File Allocation Table";
public Guid Id => new Guid("33513B2C-0D26-0D2D-32C3-79D8611158E0"); public Guid Id => new Guid("33513B2C-0D26-0D2D-32C3-79D8611158E0");
@@ -314,13 +311,14 @@ namespace DiscImageChef.Filesystems
return fatId == fat2Sector[0]; return fatId == fat2Sector[0];
} }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, Encoding encoding) public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding)
{ {
currentEncoding = encoding ?? Encoding.GetEncoding("IBM437"); Encoding = encoding ?? Encoding.GetEncoding("IBM437");
information = ""; information = "";
StringBuilder sb = new StringBuilder(); StringBuilder sb = new StringBuilder();
xmlFsType = new FileSystemType(); XmlFsType = new FileSystemType();
bool useAtariBpb = false; bool useAtariBpb = false;
bool useMsxBpb = false; bool useMsxBpb = false;
@@ -625,7 +623,7 @@ namespace DiscImageChef.Filesystems
fakeBpb.heads = 1; fakeBpb.heads = 1;
fakeBpb.hsectors = 0; fakeBpb.hsectors = 0;
fakeBpb.spfat = 3; fakeBpb.spfat = 3;
xmlFsType.Bootable = true; XmlFsType.Bootable = true;
fakeBpb.boot_code = bpbSector; fakeBpb.boot_code = bpbSector;
isFat12 = true; isFat12 = true;
} }
@@ -799,7 +797,7 @@ namespace DiscImageChef.Filesystems
} }
// This assumes a bootable sector will jump somewhere or disable interrupts in x86 code // This assumes a bootable sector will jump somewhere or disable interrupts in x86 code
xmlFsType.Bootable |= bpbSector[0] == 0xFA || bpbSector[0] == 0xEB && bpbSector[1] <= 0x7F; XmlFsType.Bootable |= bpbSector[0] == 0xFA || bpbSector[0] == 0xEB && bpbSector[1] <= 0x7F;
fakeBpb.boot_code = bpbSector; fakeBpb.boot_code = bpbSector;
} }
else if(useShortFat32 || useLongFat32) else if(useShortFat32 || useLongFat32)
@@ -819,38 +817,38 @@ namespace DiscImageChef.Filesystems
if(fat32Bpb.version != 0) if(fat32Bpb.version != 0)
{ {
sb.AppendLine("FAT+"); sb.AppendLine("FAT+");
xmlFsType.Type = "FAT+"; XmlFsType.Type = "FAT+";
} }
else else
{ {
sb.AppendLine("Microsoft FAT32"); sb.AppendLine("Microsoft FAT32");
xmlFsType.Type = "FAT32"; XmlFsType.Type = "FAT32";
} }
if(fat32Bpb.oem_name != null) if(fat32Bpb.oem_name != null)
if(fat32Bpb.oem_name[5] == 0x49 && fat32Bpb.oem_name[6] == 0x48 && fat32Bpb.oem_name[7] == 0x43) if(fat32Bpb.oem_name[5] == 0x49 && fat32Bpb.oem_name[6] == 0x48 && fat32Bpb.oem_name[7] == 0x43)
sb.AppendLine("Volume has been modified by Windows 9x/Me Volume Tracker."); sb.AppendLine("Volume has been modified by Windows 9x/Me Volume Tracker.");
else xmlFsType.SystemIdentifier = StringHandlers.CToString(fat32Bpb.oem_name); else XmlFsType.SystemIdentifier = StringHandlers.CToString(fat32Bpb.oem_name);
if(!string.IsNullOrEmpty(xmlFsType.SystemIdentifier)) if(!string.IsNullOrEmpty(XmlFsType.SystemIdentifier))
sb.AppendFormat("OEM Name: {0}", xmlFsType.SystemIdentifier.Trim()).AppendLine(); sb.AppendFormat("OEM Name: {0}", XmlFsType.SystemIdentifier.Trim()).AppendLine();
sb.AppendFormat("{0} bytes per sector.", fat32Bpb.bps).AppendLine(); sb.AppendFormat("{0} bytes per sector.", fat32Bpb.bps).AppendLine();
sb.AppendFormat("{0} sectors per cluster.", fat32Bpb.spc).AppendLine(); sb.AppendFormat("{0} sectors per cluster.", fat32Bpb.spc).AppendLine();
xmlFsType.ClusterSize = fat32Bpb.bps * fat32Bpb.spc; XmlFsType.ClusterSize = fat32Bpb.bps * fat32Bpb.spc;
sb.AppendFormat("{0} sectors reserved between BPB and FAT.", fat32Bpb.rsectors).AppendLine(); sb.AppendFormat("{0} sectors reserved between BPB and FAT.", fat32Bpb.rsectors).AppendLine();
if(fat32Bpb.big_sectors == 0 && fat32Bpb.signature == 0x28) if(fat32Bpb.big_sectors == 0 && fat32Bpb.signature == 0x28)
{ {
sb.AppendFormat("{0} sectors on volume ({1} bytes).", shortFat32Bpb.huge_sectors, sb.AppendFormat("{0} sectors on volume ({1} bytes).", shortFat32Bpb.huge_sectors,
shortFat32Bpb.huge_sectors * shortFat32Bpb.bps).AppendLine(); shortFat32Bpb.huge_sectors * shortFat32Bpb.bps).AppendLine();
xmlFsType.Clusters = (long)(shortFat32Bpb.huge_sectors / shortFat32Bpb.spc); XmlFsType.Clusters = (long)(shortFat32Bpb.huge_sectors / shortFat32Bpb.spc);
} }
else else
{ {
sb.AppendFormat("{0} sectors on volume ({1} bytes).", fat32Bpb.big_sectors, sb.AppendFormat("{0} sectors on volume ({1} bytes).", fat32Bpb.big_sectors,
fat32Bpb.big_sectors * fat32Bpb.bps).AppendLine(); fat32Bpb.big_sectors * fat32Bpb.bps).AppendLine();
xmlFsType.Clusters = fat32Bpb.big_sectors / fat32Bpb.spc; XmlFsType.Clusters = fat32Bpb.big_sectors / fat32Bpb.spc;
} }
sb.AppendFormat("{0} clusters on volume.", xmlFsType.Clusters).AppendLine(); sb.AppendFormat("{0} clusters on volume.", XmlFsType.Clusters).AppendLine();
sb.AppendFormat("Media descriptor: 0x{0:X2}", fat32Bpb.media).AppendLine(); sb.AppendFormat("Media descriptor: 0x{0:X2}", fat32Bpb.media).AppendLine();
sb.AppendFormat("{0} sectors per FAT.", fat32Bpb.big_spfat).AppendLine(); sb.AppendFormat("{0} sectors per FAT.", fat32Bpb.big_spfat).AppendLine();
sb.AppendFormat("{0} sectors per track.", fat32Bpb.sptrk).AppendLine(); sb.AppendFormat("{0} sectors per track.", fat32Bpb.sptrk).AppendLine();
@@ -861,14 +859,14 @@ namespace DiscImageChef.Filesystems
sb.AppendFormat("Sector of backup FAT32 parameter block: {0}", fat32Bpb.backup_sector).AppendLine(); sb.AppendFormat("Sector of backup FAT32 parameter block: {0}", fat32Bpb.backup_sector).AppendLine();
sb.AppendFormat("Drive number: 0x{0:X2}", fat32Bpb.drive_no).AppendLine(); sb.AppendFormat("Drive number: 0x{0:X2}", fat32Bpb.drive_no).AppendLine();
sb.AppendFormat("Volume Serial Number: 0x{0:X8}", fat32Bpb.serial_no).AppendLine(); sb.AppendFormat("Volume Serial Number: 0x{0:X8}", fat32Bpb.serial_no).AppendLine();
xmlFsType.VolumeSerial = $"{fat32Bpb.serial_no:X8}"; XmlFsType.VolumeSerial = $"{fat32Bpb.serial_no:X8}";
if((fat32Bpb.flags & 0xF8) == 0x00) if((fat32Bpb.flags & 0xF8) == 0x00)
{ {
if((fat32Bpb.flags & 0x01) == 0x01) if((fat32Bpb.flags & 0x01) == 0x01)
{ {
sb.AppendLine("Volume should be checked on next mount."); sb.AppendLine("Volume should be checked on next mount.");
xmlFsType.Dirty = true; XmlFsType.Dirty = true;
} }
if((fat32Bpb.flags & 0x02) == 0x02) sb.AppendLine("Disk surface should be on next mount."); if((fat32Bpb.flags & 0x02) == 0x02) sb.AppendLine("Disk surface should be on next mount.");
} }
@@ -884,7 +882,7 @@ namespace DiscImageChef.Filesystems
if(fat32Bpb.signature == 0x29) if(fat32Bpb.signature == 0x29)
{ {
xmlFsType.VolumeName = Encoding.ASCII.GetString(fat32Bpb.volume_label); XmlFsType.VolumeName = Encoding.ASCII.GetString(fat32Bpb.volume_label);
sb.AppendFormat("Filesystem type: {0}", Encoding.ASCII.GetString(fat32Bpb.fs_type)).AppendLine(); sb.AppendFormat("Filesystem type: {0}", Encoding.ASCII.GetString(fat32Bpb.fs_type)).AppendLine();
bootChk = sha1Ctx.Data(fat32Bpb.boot_code, out _); bootChk = sha1Ctx.Data(fat32Bpb.boot_code, out _);
} }
@@ -892,7 +890,7 @@ namespace DiscImageChef.Filesystems
// Check that jumps to a correct boot code position and has boot signature set. // Check that jumps to a correct boot code position and has boot signature set.
// This will mean that the volume will boot, even if just to say "this is not bootable change disk"...... // This will mean that the volume will boot, even if just to say "this is not bootable change disk"......
xmlFsType.Bootable |= fat32Bpb.jump[0] == 0xEB && fat32Bpb.jump[1] > 0x58 && fat32Bpb.jump[1] < 0x80 && XmlFsType.Bootable |= fat32Bpb.jump[0] == 0xEB && fat32Bpb.jump[1] > 0x58 && fat32Bpb.jump[1] < 0x80 &&
fat32Bpb.boot_signature == 0xAA55; fat32Bpb.boot_signature == 0xAA55;
sectorsPerRealSector = fat32Bpb.bps / imagePlugin.Info.SectorSize; sectorsPerRealSector = fat32Bpb.bps / imagePlugin.Info.SectorSize;
@@ -916,8 +914,8 @@ namespace DiscImageChef.Filesystems
if(fsInfo.free_clusters < 0xFFFFFFFF) if(fsInfo.free_clusters < 0xFFFFFFFF)
{ {
sb.AppendFormat("{0} free clusters", fsInfo.free_clusters).AppendLine(); sb.AppendFormat("{0} free clusters", fsInfo.free_clusters).AppendLine();
xmlFsType.FreeClusters = fsInfo.free_clusters; XmlFsType.FreeClusters = fsInfo.free_clusters;
xmlFsType.FreeClustersSpecified = true; XmlFsType.FreeClustersSpecified = true;
} }
if(fsInfo.last_cluster > 2 && fsInfo.last_cluster < 0xFFFFFFFF) if(fsInfo.last_cluster > 2 && fsInfo.last_cluster < 0xFFFFFFFF)
@@ -1039,7 +1037,7 @@ namespace DiscImageChef.Filesystems
fakeBpb.boot_signature = msxBpb.boot_signature; fakeBpb.boot_signature = msxBpb.boot_signature;
fakeBpb.serial_no = msxBpb.serial_no; fakeBpb.serial_no = msxBpb.serial_no;
// TODO: Is there any way to check this? // TODO: Is there any way to check this?
xmlFsType.Bootable = true; XmlFsType.Bootable = true;
} }
else if(useAtariBpb) else if(useAtariBpb)
{ {
@@ -1064,7 +1062,7 @@ namespace DiscImageChef.Filesystems
// TODO: Check this // TODO: Check this
if(sum == 0x1234) if(sum == 0x1234)
{ {
xmlFsType.Bootable = true; XmlFsType.Bootable = true;
StringBuilder atariSb = new StringBuilder(); StringBuilder atariSb = new StringBuilder();
atariSb.AppendFormat("cmdload will be loaded with value {0:X4}h", atariSb.AppendFormat("cmdload will be loaded with value {0:X4}h",
BigEndianBitConverter.ToUInt16(bpbSector, 0x01E)).AppendLine(); BigEndianBitConverter.ToUInt16(bpbSector, 0x01E)).AppendLine();
@@ -1107,7 +1105,7 @@ namespace DiscImageChef.Filesystems
fakeBpb.media = apricotBpb.mainBPB.media; fakeBpb.media = apricotBpb.mainBPB.media;
fakeBpb.spfat = apricotBpb.mainBPB.spfat; fakeBpb.spfat = apricotBpb.mainBPB.spfat;
fakeBpb.sptrk = apricotBpb.spt; fakeBpb.sptrk = apricotBpb.spt;
xmlFsType.Bootable = apricotBpb.bootType > 0; XmlFsType.Bootable = apricotBpb.bootType > 0;
if(apricotBpb.bootLocation > 0 && if(apricotBpb.bootLocation > 0 &&
apricotBpb.bootLocation + apricotBpb.bootSize < imagePlugin.Info.Sectors) apricotBpb.bootLocation + apricotBpb.bootSize < imagePlugin.Info.Sectors)
@@ -1152,12 +1150,12 @@ namespace DiscImageChef.Filesystems
if(useAtariBpb) sb.AppendLine("Atari FAT12"); if(useAtariBpb) sb.AppendLine("Atari FAT12");
else if(useApricotBpb) sb.AppendLine("Apricot FAT12"); else if(useApricotBpb) sb.AppendLine("Apricot FAT12");
else sb.AppendLine("Microsoft FAT12"); else sb.AppendLine("Microsoft FAT12");
xmlFsType.Type = "FAT12"; XmlFsType.Type = "FAT12";
} }
else if(isFat16) else if(isFat16)
{ {
sb.AppendLine(useAtariBpb ? "Atari FAT16" : "Microsoft FAT16"); sb.AppendLine(useAtariBpb ? "Atari FAT16" : "Microsoft FAT16");
xmlFsType.Type = "FAT16"; XmlFsType.Type = "FAT16";
} }
if(useAtariBpb) if(useAtariBpb)
@@ -1165,11 +1163,11 @@ namespace DiscImageChef.Filesystems
if(atariBpb.serial_no[0] == 0x49 && atariBpb.serial_no[1] == 0x48 && atariBpb.serial_no[2] == 0x43) if(atariBpb.serial_no[0] == 0x49 && atariBpb.serial_no[1] == 0x48 && atariBpb.serial_no[2] == 0x43)
sb.AppendLine("Volume has been modified by Windows 9x/Me Volume Tracker."); sb.AppendLine("Volume has been modified by Windows 9x/Me Volume Tracker.");
else else
xmlFsType.VolumeSerial = XmlFsType.VolumeSerial =
$"{atariBpb.serial_no[0]:X2}{atariBpb.serial_no[1]:X2}{atariBpb.serial_no[2]:X2}"; $"{atariBpb.serial_no[0]:X2}{atariBpb.serial_no[1]:X2}{atariBpb.serial_no[2]:X2}";
xmlFsType.SystemIdentifier = StringHandlers.CToString(atariBpb.oem_name); XmlFsType.SystemIdentifier = StringHandlers.CToString(atariBpb.oem_name);
if(string.IsNullOrEmpty(xmlFsType.SystemIdentifier)) xmlFsType.SystemIdentifier = null; if(string.IsNullOrEmpty(XmlFsType.SystemIdentifier)) XmlFsType.SystemIdentifier = null;
} }
else if(fakeBpb.oem_name != null) else if(fakeBpb.oem_name != null)
{ {
@@ -1185,7 +1183,7 @@ namespace DiscImageChef.Filesystems
fakeBpb.oem_name[4] <= 0x7F && fakeBpb.oem_name[5] >= 0x20 && fakeBpb.oem_name[5] <= 0x7F && fakeBpb.oem_name[4] <= 0x7F && fakeBpb.oem_name[5] >= 0x20 && fakeBpb.oem_name[5] <= 0x7F &&
fakeBpb.oem_name[6] >= 0x20 && fakeBpb.oem_name[6] <= 0x7F && fakeBpb.oem_name[7] >= 0x20 && fakeBpb.oem_name[6] >= 0x20 && fakeBpb.oem_name[6] <= 0x7F && fakeBpb.oem_name[7] >= 0x20 &&
fakeBpb.oem_name[7] <= 0x7F) fakeBpb.oem_name[7] <= 0x7F)
xmlFsType.SystemIdentifier = StringHandlers.CToString(fakeBpb.oem_name); XmlFsType.SystemIdentifier = StringHandlers.CToString(fakeBpb.oem_name);
else if(fakeBpb.oem_name[0] < 0x20 && fakeBpb.oem_name[1] >= 0x20 && else if(fakeBpb.oem_name[0] < 0x20 && fakeBpb.oem_name[1] >= 0x20 &&
fakeBpb.oem_name[1] <= 0x7F && fakeBpb.oem_name[2] >= 0x20 && fakeBpb.oem_name[1] <= 0x7F && fakeBpb.oem_name[2] >= 0x20 &&
fakeBpb.oem_name[2] <= 0x7F && fakeBpb.oem_name[3] >= 0x20 && fakeBpb.oem_name[2] <= 0x7F && fakeBpb.oem_name[3] >= 0x20 &&
@@ -1194,33 +1192,32 @@ namespace DiscImageChef.Filesystems
fakeBpb.oem_name[5] <= 0x7F && fakeBpb.oem_name[6] >= 0x20 && fakeBpb.oem_name[5] <= 0x7F && fakeBpb.oem_name[6] >= 0x20 &&
fakeBpb.oem_name[6] <= 0x7F && fakeBpb.oem_name[7] >= 0x20 && fakeBpb.oem_name[6] <= 0x7F && fakeBpb.oem_name[7] >= 0x20 &&
fakeBpb.oem_name[7] <= 0x7F) fakeBpb.oem_name[7] <= 0x7F)
xmlFsType.SystemIdentifier = XmlFsType.SystemIdentifier = StringHandlers.CToString(fakeBpb.oem_name, Encoding, start: 1);
StringHandlers.CToString(fakeBpb.oem_name, currentEncoding, start: 1);
} }
if(fakeBpb.signature == 0x28 || fakeBpb.signature == 0x29) if(fakeBpb.signature == 0x28 || fakeBpb.signature == 0x29)
xmlFsType.VolumeSerial = $"{fakeBpb.serial_no:X8}"; XmlFsType.VolumeSerial = $"{fakeBpb.serial_no:X8}";
} }
if(xmlFsType.SystemIdentifier != null) if(XmlFsType.SystemIdentifier != null)
sb.AppendFormat("OEM Name: {0}", xmlFsType.SystemIdentifier.Trim()).AppendLine(); sb.AppendFormat("OEM Name: {0}", XmlFsType.SystemIdentifier.Trim()).AppendLine();
sb.AppendFormat("{0} bytes per sector.", fakeBpb.bps).AppendLine(); sb.AppendFormat("{0} bytes per sector.", fakeBpb.bps).AppendLine();
if(fakeBpb.sectors == 0) if(fakeBpb.sectors == 0)
{ {
sb.AppendFormat("{0} sectors on volume ({1} bytes).", fakeBpb.big_sectors, sb.AppendFormat("{0} sectors on volume ({1} bytes).", fakeBpb.big_sectors,
fakeBpb.big_sectors * fakeBpb.bps).AppendLine(); fakeBpb.big_sectors * fakeBpb.bps).AppendLine();
xmlFsType.Clusters = fakeBpb.spc == 0 ? fakeBpb.big_sectors : fakeBpb.big_sectors / fakeBpb.spc; XmlFsType.Clusters = fakeBpb.spc == 0 ? fakeBpb.big_sectors : fakeBpb.big_sectors / fakeBpb.spc;
} }
else else
{ {
sb.AppendFormat("{0} sectors on volume ({1} bytes).", fakeBpb.sectors, sb.AppendFormat("{0} sectors on volume ({1} bytes).", fakeBpb.sectors,
fakeBpb.sectors * fakeBpb.bps).AppendLine(); fakeBpb.sectors * fakeBpb.bps).AppendLine();
xmlFsType.Clusters = fakeBpb.spc == 0 ? fakeBpb.sectors : fakeBpb.sectors / fakeBpb.spc; XmlFsType.Clusters = fakeBpb.spc == 0 ? fakeBpb.sectors : fakeBpb.sectors / fakeBpb.spc;
} }
sb.AppendFormat("{0} sectors per cluster.", fakeBpb.spc).AppendLine(); sb.AppendFormat("{0} sectors per cluster.", fakeBpb.spc).AppendLine();
sb.AppendFormat("{0} clusters on volume.", xmlFsType.Clusters).AppendLine(); sb.AppendFormat("{0} clusters on volume.", XmlFsType.Clusters).AppendLine();
xmlFsType.ClusterSize = fakeBpb.bps * fakeBpb.spc; XmlFsType.ClusterSize = fakeBpb.bps * fakeBpb.spc;
sb.AppendFormat("{0} sectors reserved between BPB and FAT.", fakeBpb.rsectors).AppendLine(); sb.AppendFormat("{0} sectors reserved between BPB and FAT.", fakeBpb.rsectors).AppendLine();
sb.AppendFormat("{0} FATs.", fakeBpb.fats_no).AppendLine(); sb.AppendFormat("{0} FATs.", fakeBpb.fats_no).AppendLine();
sb.AppendFormat("{0} entries on root directory.", fakeBpb.root_ent).AppendLine(); sb.AppendFormat("{0} entries on root directory.", fakeBpb.root_ent).AppendLine();
@@ -1241,34 +1238,34 @@ namespace DiscImageChef.Filesystems
{ {
sb.AppendFormat("Drive number: 0x{0:X2}", fakeBpb.drive_no).AppendLine(); sb.AppendFormat("Drive number: 0x{0:X2}", fakeBpb.drive_no).AppendLine();
if(xmlFsType.VolumeSerial != null) if(XmlFsType.VolumeSerial != null)
sb.AppendFormat("Volume Serial Number: {0}", xmlFsType.VolumeSerial).AppendLine(); sb.AppendFormat("Volume Serial Number: {0}", XmlFsType.VolumeSerial).AppendLine();
if((fakeBpb.flags & 0xF8) == 0x00) if((fakeBpb.flags & 0xF8) == 0x00)
{ {
if((fakeBpb.flags & 0x01) == 0x01) if((fakeBpb.flags & 0x01) == 0x01)
{ {
sb.AppendLine("Volume should be checked on next mount."); sb.AppendLine("Volume should be checked on next mount.");
xmlFsType.Dirty = true; XmlFsType.Dirty = true;
} }
if((fakeBpb.flags & 0x02) == 0x02) sb.AppendLine("Disk surface should be on next mount."); if((fakeBpb.flags & 0x02) == 0x02) sb.AppendLine("Disk surface should be on next mount.");
} }
if(fakeBpb.signature == 0x29 || andosOemCorrect) if(fakeBpb.signature == 0x29 || andosOemCorrect)
{ {
xmlFsType.VolumeName = Encoding.ASCII.GetString(fakeBpb.volume_label); XmlFsType.VolumeName = Encoding.ASCII.GetString(fakeBpb.volume_label);
sb.AppendFormat("Filesystem type: {0}", Encoding.ASCII.GetString(fakeBpb.fs_type)).AppendLine(); sb.AppendFormat("Filesystem type: {0}", Encoding.ASCII.GetString(fakeBpb.fs_type)).AppendLine();
} }
} }
else if(useAtariBpb && xmlFsType.VolumeSerial != null) else if(useAtariBpb && XmlFsType.VolumeSerial != null)
sb.AppendFormat("Volume Serial Number: {0}", xmlFsType.VolumeSerial).AppendLine(); sb.AppendFormat("Volume Serial Number: {0}", XmlFsType.VolumeSerial).AppendLine();
bootChk = sha1Ctx.Data(fakeBpb.boot_code, out _); bootChk = sha1Ctx.Data(fakeBpb.boot_code, out _);
// Check that jumps to a correct boot code position and has boot signature set. // Check that jumps to a correct boot code position and has boot signature set.
// This will mean that the volume will boot, even if just to say "this is not bootable change disk"...... // This will mean that the volume will boot, even if just to say "this is not bootable change disk"......
if(xmlFsType.Bootable == false && fakeBpb.jump != null) if(XmlFsType.Bootable == false && fakeBpb.jump != null)
xmlFsType.Bootable |= fakeBpb.jump[0] == 0xEB && fakeBpb.jump[1] > 0x58 && fakeBpb.jump[1] < 0x80 && XmlFsType.Bootable |= fakeBpb.jump[0] == 0xEB && fakeBpb.jump[1] > 0x58 && fakeBpb.jump[1] < 0x80 &&
fakeBpb.boot_signature == 0xAA55; fakeBpb.boot_signature == 0xAA55;
sectorsPerRealSector = fakeBpb.bps / imagePlugin.Info.SectorSize; sectorsPerRealSector = fakeBpb.bps / imagePlugin.Info.SectorSize;
@@ -1314,24 +1311,24 @@ namespace DiscImageChef.Filesystems
byte[] fullname = new byte[11]; byte[] fullname = new byte[11];
Array.Copy(entry.filename, 0, fullname, 0, 8); Array.Copy(entry.filename, 0, fullname, 0, 8);
Array.Copy(entry.extension, 0, fullname, 8, 3); Array.Copy(entry.extension, 0, fullname, 8, 3);
string volname = currentEncoding.GetString(fullname).Trim(); string volname = Encoding.GetString(fullname).Trim();
if(!string.IsNullOrEmpty(volname)) if(!string.IsNullOrEmpty(volname))
xmlFsType.VolumeName = (entry.caseinfo & 0x0C) > 0 ? volname.ToLower() : volname; XmlFsType.VolumeName = (entry.caseinfo & 0x0C) > 0 ? volname.ToLower() : volname;
if(entry.ctime > 0 && entry.cdate > 0) if(entry.ctime > 0 && entry.cdate > 0)
{ {
xmlFsType.CreationDate = DateHandlers.DosToDateTime(entry.cdate, entry.ctime); XmlFsType.CreationDate = DateHandlers.DosToDateTime(entry.cdate, entry.ctime);
if(entry.ctime_ms > 0) if(entry.ctime_ms > 0)
xmlFsType.CreationDate = xmlFsType.CreationDate.AddMilliseconds(entry.ctime_ms * 10); XmlFsType.CreationDate = XmlFsType.CreationDate.AddMilliseconds(entry.ctime_ms * 10);
xmlFsType.CreationDateSpecified = true; XmlFsType.CreationDateSpecified = true;
sb.AppendFormat("Volume created on {0}", xmlFsType.CreationDate).AppendLine(); sb.AppendFormat("Volume created on {0}", XmlFsType.CreationDate).AppendLine();
} }
if(entry.mtime > 0 && entry.mdate > 0) if(entry.mtime > 0 && entry.mdate > 0)
{ {
xmlFsType.ModificationDate = DateHandlers.DosToDateTime(entry.mdate, entry.mtime); XmlFsType.ModificationDate = DateHandlers.DosToDateTime(entry.mdate, entry.mtime);
xmlFsType.ModificationDateSpecified = true; XmlFsType.ModificationDateSpecified = true;
sb.AppendFormat("Volume last modified on {0}", xmlFsType.ModificationDate).AppendLine(); sb.AppendFormat("Volume last modified on {0}", XmlFsType.ModificationDate).AppendLine();
} }
if(entry.adate > 0) if(entry.adate > 0)
@@ -1342,9 +1339,9 @@ namespace DiscImageChef.Filesystems
} }
} }
if(!string.IsNullOrEmpty(xmlFsType.VolumeName)) if(!string.IsNullOrEmpty(XmlFsType.VolumeName))
sb.AppendFormat("Volume label: {0}", xmlFsType.VolumeName).AppendLine(); sb.AppendFormat("Volume label: {0}", XmlFsType.VolumeName).AppendLine();
if(xmlFsType.Bootable) if(XmlFsType.Bootable)
{ {
sb.AppendLine("Volume is bootable"); sb.AppendLine("Volume is bootable");
sb.AppendFormat("Boot code's SHA1: {0}", bootChk).AppendLine(); sb.AppendFormat("Boot code's SHA1: {0}", bootChk).AppendLine();

18
DiscImageChef.Filesystems/FATX.cs
View File

@@ -31,7 +31,6 @@
// ****************************************************************************/ // ****************************************************************************/
using System; using System;
using System.Collections.Generic;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
using System.Text; using System.Text;
using DiscImageChef.CommonTypes; using DiscImageChef.CommonTypes;
@@ -44,11 +43,8 @@ namespace DiscImageChef.Filesystems
{ {
const uint FATX_MAGIC = 0x58544146; const uint FATX_MAGIC = 0x58544146;
Encoding currentEncoding; public FileSystemType XmlFsType { get; private set; }
FileSystemType xmlFsType; public Encoding Encoding { get; private set; }
public FileSystemType XmlFsType => xmlFsType;
public Encoding Encoding => currentEncoding;
public string Name => "FATX Filesystem Plugin"; public string Name => "FATX Filesystem Plugin";
public Guid Id => new Guid("ED27A721-4A17-4649-89FD-33633B46E228"); public Guid Id => new Guid("ED27A721-4A17-4649-89FD-33633B46E228");
@@ -65,9 +61,9 @@ namespace DiscImageChef.Filesystems
} }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding) Encoding encoding)
{ {
currentEncoding = Encoding.UTF8; Encoding = Encoding.UTF8;
information = ""; information = "";
if(imagePlugin.Info.SectorSize < 512) return; if(imagePlugin.Info.SectorSize < 512) return;
@@ -89,13 +85,13 @@ namespace DiscImageChef.Filesystems
information = sb.ToString(); information = sb.ToString();
xmlFsType = new FileSystemType XmlFsType = new FileSystemType
{ {
Type = "FATX filesystem", Type = "FATX filesystem",
ClusterSize = (int)(fatxSb.sectorsPerCluster * imagePlugin.Info.SectorSize) ClusterSize = (int)(fatxSb.sectorsPerCluster * imagePlugin.Info.SectorSize)
}; };
xmlFsType.Clusters = (long)((partition.End - partition.Start + 1) * imagePlugin.Info.SectorSize / XmlFsType.Clusters = (long)((partition.End - partition.Start + 1) * imagePlugin.Info.SectorSize /
(ulong)xmlFsType.ClusterSize); (ulong)XmlFsType.ClusterSize);
} }
[StructLayout(LayoutKind.Sequential, Pack = 1)] [StructLayout(LayoutKind.Sequential, Pack = 1)]

57
DiscImageChef.Filesystems/FFS.cs
View File

@@ -31,7 +31,6 @@
// ****************************************************************************/ // ****************************************************************************/
using System; using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis; using System.Diagnostics.CodeAnalysis;
using System.Linq; using System.Linq;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
@@ -81,11 +80,8 @@ namespace DiscImageChef.Filesystems
// Big-endian incomplete newfs // Big-endian incomplete newfs
const uint UFS_BAD_CIGAM = 0x08049619; const uint UFS_BAD_CIGAM = 0x08049619;
Encoding currentEncoding; public FileSystemType XmlFsType { get; private set; }
FileSystemType xmlFsType; public Encoding Encoding { get; private set; }
public FileSystemType XmlFsType => xmlFsType;
public Encoding Encoding => currentEncoding;
public string Name => "BSD Fast File System (aka UNIX File System, UFS)"; public string Name => "BSD Fast File System (aka UNIX File System, UFS)";
public Guid Id => new Guid("CC90D342-05DB-48A8-988C-C1FE000034A3"); public Guid Id => new Guid("CC90D342-05DB-48A8-988C-C1FE000034A3");
@@ -114,9 +110,10 @@ namespace DiscImageChef.Filesystems
magic == UFS_BAD_MAGIC || magic == UFS_BAD_CIGAM); magic == UFS_BAD_MAGIC || magic == UFS_BAD_CIGAM);
} }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, Encoding encoding) public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding)
{ {
currentEncoding = encoding ?? Encoding.GetEncoding("iso-8859-15"); Encoding = encoding ?? Encoding.GetEncoding("iso-8859-15");
information = ""; information = "";
StringBuilder sbInformation = new StringBuilder(); StringBuilder sbInformation = new StringBuilder();
@@ -164,43 +161,43 @@ namespace DiscImageChef.Filesystems
return; return;
} }
xmlFsType = new FileSystemType(); XmlFsType = new FileSystemType();
switch(magic) switch(magic)
{ {
case UFS_MAGIC: case UFS_MAGIC:
sbInformation.AppendLine("UFS filesystem"); sbInformation.AppendLine("UFS filesystem");
xmlFsType.Type = "UFS"; XmlFsType.Type = "UFS";
break; break;
case UFS_CIGAM: case UFS_CIGAM:
sbInformation.AppendLine("Big-endian UFS filesystem"); sbInformation.AppendLine("Big-endian UFS filesystem");
xmlFsType.Type = "UFS"; XmlFsType.Type = "UFS";
break; break;
case UFS_MAGIC_BW: case UFS_MAGIC_BW:
sbInformation.AppendLine("BorderWare UFS filesystem"); sbInformation.AppendLine("BorderWare UFS filesystem");
xmlFsType.Type = "UFS"; XmlFsType.Type = "UFS";
break; break;
case UFS_CIGAM_BW: case UFS_CIGAM_BW:
sbInformation.AppendLine("Big-endian BorderWare UFS filesystem"); sbInformation.AppendLine("Big-endian BorderWare UFS filesystem");
xmlFsType.Type = "UFS"; XmlFsType.Type = "UFS";
break; break;
case UFS2_MAGIC: case UFS2_MAGIC:
sbInformation.AppendLine("UFS2 filesystem"); sbInformation.AppendLine("UFS2 filesystem");
xmlFsType.Type = "UFS2"; XmlFsType.Type = "UFS2";
break; break;
case UFS2_CIGAM: case UFS2_CIGAM:
sbInformation.AppendLine("Big-endian UFS2 filesystem"); sbInformation.AppendLine("Big-endian UFS2 filesystem");
xmlFsType.Type = "UFS2"; XmlFsType.Type = "UFS2";
break; break;
case UFS_BAD_MAGIC: case UFS_BAD_MAGIC:
sbInformation.AppendLine("Incompletely initialized UFS filesystem"); sbInformation.AppendLine("Incompletely initialized UFS filesystem");
sbInformation.AppendLine("BEWARE!!! Following information may be completely wrong!"); sbInformation.AppendLine("BEWARE!!! Following information may be completely wrong!");
xmlFsType.Type = "UFS"; XmlFsType.Type = "UFS";
break; break;
case UFS_BAD_CIGAM: case UFS_BAD_CIGAM:
sbInformation.AppendLine("Incompletely initialized big-endian UFS filesystem"); sbInformation.AppendLine("Incompletely initialized big-endian UFS filesystem");
sbInformation.AppendLine("BEWARE!!! Following information may be completely wrong!"); sbInformation.AppendLine("BEWARE!!! Following information may be completely wrong!");
xmlFsType.Type = "UFS"; XmlFsType.Type = "UFS";
break; break;
} }
@@ -346,12 +343,12 @@ namespace DiscImageChef.Filesystems
sbInformation.AppendFormat("Cylinder group offset in cylinder: {0}", ufs_sb.fs_old_cgoffset).AppendLine(); sbInformation.AppendFormat("Cylinder group offset in cylinder: {0}", ufs_sb.fs_old_cgoffset).AppendLine();
sbInformation.AppendFormat("Volume last written on {0}", DateHandlers.UnixToDateTime(ufs_sb.fs_old_time)) sbInformation.AppendFormat("Volume last written on {0}", DateHandlers.UnixToDateTime(ufs_sb.fs_old_time))
.AppendLine(); .AppendLine();
xmlFsType.ModificationDate = DateHandlers.UnixToDateTime(ufs_sb.fs_old_time); XmlFsType.ModificationDate = DateHandlers.UnixToDateTime(ufs_sb.fs_old_time);
xmlFsType.ModificationDateSpecified = true; XmlFsType.ModificationDateSpecified = true;
sbInformation.AppendFormat("{0} blocks in volume ({1} bytes)", ufs_sb.fs_old_size, sbInformation.AppendFormat("{0} blocks in volume ({1} bytes)", ufs_sb.fs_old_size,
(long)ufs_sb.fs_old_size * ufs_sb.fs_fsize).AppendLine(); (long)ufs_sb.fs_old_size * ufs_sb.fs_fsize).AppendLine();
xmlFsType.Clusters = ufs_sb.fs_old_size; XmlFsType.Clusters = ufs_sb.fs_old_size;
xmlFsType.ClusterSize = ufs_sb.fs_fsize; XmlFsType.ClusterSize = ufs_sb.fs_fsize;
sbInformation.AppendFormat("{0} data blocks in volume ({1} bytes)", ufs_sb.fs_old_dsize, sbInformation.AppendFormat("{0} data blocks in volume ({1} bytes)", ufs_sb.fs_old_dsize,
(long)ufs_sb.fs_old_dsize * ufs_sb.fs_fsize).AppendLine(); (long)ufs_sb.fs_old_dsize * ufs_sb.fs_fsize).AppendLine();
sbInformation.AppendFormat("{0} cylinder groups in volume", ufs_sb.fs_ncg).AppendLine(); sbInformation.AppendFormat("{0} cylinder groups in volume", ufs_sb.fs_ncg).AppendLine();
@@ -411,14 +408,14 @@ namespace DiscImageChef.Filesystems
sbInformation.AppendFormat("{0} directories", ufs_sb.fs_old_cstotal.cs_ndir).AppendLine(); sbInformation.AppendFormat("{0} directories", ufs_sb.fs_old_cstotal.cs_ndir).AppendLine();
sbInformation.AppendFormat("{0} free blocks ({1} bytes)", ufs_sb.fs_old_cstotal.cs_nbfree, sbInformation.AppendFormat("{0} free blocks ({1} bytes)", ufs_sb.fs_old_cstotal.cs_nbfree,
(long)ufs_sb.fs_old_cstotal.cs_nbfree * ufs_sb.fs_fsize).AppendLine(); (long)ufs_sb.fs_old_cstotal.cs_nbfree * ufs_sb.fs_fsize).AppendLine();
xmlFsType.FreeClusters = ufs_sb.fs_old_cstotal.cs_nbfree; XmlFsType.FreeClusters = ufs_sb.fs_old_cstotal.cs_nbfree;
xmlFsType.FreeClustersSpecified = true; XmlFsType.FreeClustersSpecified = true;
sbInformation.AppendFormat("{0} free inodes", ufs_sb.fs_old_cstotal.cs_nifree).AppendLine(); sbInformation.AppendFormat("{0} free inodes", ufs_sb.fs_old_cstotal.cs_nifree).AppendLine();
sbInformation.AppendFormat("{0} free frags", ufs_sb.fs_old_cstotal.cs_nffree).AppendLine(); sbInformation.AppendFormat("{0} free frags", ufs_sb.fs_old_cstotal.cs_nffree).AppendLine();
if(ufs_sb.fs_fmod == 1) if(ufs_sb.fs_fmod == 1)
{ {
sbInformation.AppendLine("Superblock is under modification"); sbInformation.AppendLine("Superblock is under modification");
xmlFsType.Dirty = true; XmlFsType.Dirty = true;
} }
if(ufs_sb.fs_clean == 1) sbInformation.AppendLine("Volume is clean"); if(ufs_sb.fs_clean == 1) sbInformation.AppendLine("Volume is clean");
if(ufs_sb.fs_ronly == 1) sbInformation.AppendLine("Volume is read-only"); if(ufs_sb.fs_ronly == 1) sbInformation.AppendLine("Volume is read-only");
@@ -432,7 +429,7 @@ namespace DiscImageChef.Filesystems
.AppendLine(); .AppendLine();
sbInformation.AppendFormat("Volume name: \"{0}\"", StringHandlers.CToString(ufs_sb.fs_volname)) sbInformation.AppendFormat("Volume name: \"{0}\"", StringHandlers.CToString(ufs_sb.fs_volname))
.AppendLine(); .AppendLine();
xmlFsType.VolumeName = StringHandlers.CToString(ufs_sb.fs_volname); XmlFsType.VolumeName = StringHandlers.CToString(ufs_sb.fs_volname);
sbInformation.AppendFormat("Volume ID: 0x{0:X16}", ufs_sb.fs_swuid).AppendLine(); sbInformation.AppendFormat("Volume ID: 0x{0:X16}", ufs_sb.fs_swuid).AppendLine();
//xmlFSType.VolumeSerial = string.Format("{0:X16}", ufs_sb.fs_swuid); //xmlFSType.VolumeSerial = string.Format("{0:X16}", ufs_sb.fs_swuid);
sbInformation.AppendFormat("Last searched cylinder group: {0}", ufs_sb.fs_cgrotor).AppendLine(); sbInformation.AppendFormat("Last searched cylinder group: {0}", ufs_sb.fs_cgrotor).AppendLine();
@@ -441,18 +438,18 @@ namespace DiscImageChef.Filesystems
sbInformation.AppendFormat("{0} directories", ufs_sb.fs_cstotal.cs_ndir).AppendLine(); sbInformation.AppendFormat("{0} directories", ufs_sb.fs_cstotal.cs_ndir).AppendLine();
sbInformation.AppendFormat("{0} free blocks ({1} bytes)", ufs_sb.fs_cstotal.cs_nbfree, sbInformation.AppendFormat("{0} free blocks ({1} bytes)", ufs_sb.fs_cstotal.cs_nbfree,
ufs_sb.fs_cstotal.cs_nbfree * ufs_sb.fs_fsize).AppendLine(); ufs_sb.fs_cstotal.cs_nbfree * ufs_sb.fs_fsize).AppendLine();
xmlFsType.FreeClusters = ufs_sb.fs_cstotal.cs_nbfree; XmlFsType.FreeClusters = ufs_sb.fs_cstotal.cs_nbfree;
xmlFsType.FreeClustersSpecified = true; XmlFsType.FreeClustersSpecified = true;
sbInformation.AppendFormat("{0} free inodes", ufs_sb.fs_cstotal.cs_nifree).AppendLine(); sbInformation.AppendFormat("{0} free inodes", ufs_sb.fs_cstotal.cs_nifree).AppendLine();
sbInformation.AppendFormat("{0} free frags", ufs_sb.fs_cstotal.cs_nffree).AppendLine(); sbInformation.AppendFormat("{0} free frags", ufs_sb.fs_cstotal.cs_nffree).AppendLine();
sbInformation.AppendFormat("{0} free clusters", ufs_sb.fs_cstotal.cs_numclusters).AppendLine(); sbInformation.AppendFormat("{0} free clusters", ufs_sb.fs_cstotal.cs_numclusters).AppendLine();
sbInformation.AppendFormat("Volume last written on {0}", DateHandlers.UnixToDateTime(ufs_sb.fs_time)) sbInformation.AppendFormat("Volume last written on {0}", DateHandlers.UnixToDateTime(ufs_sb.fs_time))
.AppendLine(); .AppendLine();
xmlFsType.ModificationDate = DateHandlers.UnixToDateTime(ufs_sb.fs_time); XmlFsType.ModificationDate = DateHandlers.UnixToDateTime(ufs_sb.fs_time);
xmlFsType.ModificationDateSpecified = true; XmlFsType.ModificationDateSpecified = true;
sbInformation.AppendFormat("{0} blocks ({1} bytes)", ufs_sb.fs_size, ufs_sb.fs_size * ufs_sb.fs_fsize) sbInformation.AppendFormat("{0} blocks ({1} bytes)", ufs_sb.fs_size, ufs_sb.fs_size * ufs_sb.fs_fsize)
.AppendLine(); .AppendLine();
xmlFsType.Clusters = ufs_sb.fs_size; XmlFsType.Clusters = ufs_sb.fs_size;
sbInformation sbInformation
.AppendFormat("{0} data blocks ({1} bytes)", ufs_sb.fs_dsize, ufs_sb.fs_dsize * ufs_sb.fs_fsize) .AppendFormat("{0} data blocks ({1} bytes)", ufs_sb.fs_dsize, ufs_sb.fs_dsize * ufs_sb.fs_fsize)
.AppendLine(); .AppendLine();

20
DiscImageChef.Filesystems/Fossil.cs
View File

@@ -31,7 +31,6 @@
// ****************************************************************************/ // ****************************************************************************/
using System; using System;
using System.Collections.Generic;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
using System.Text; using System.Text;
using DiscImageChef.CommonTypes; using DiscImageChef.CommonTypes;
@@ -48,11 +47,8 @@ namespace DiscImageChef.Filesystems
// Fossil header starts at 128KiB // Fossil header starts at 128KiB
const ulong HEADER_POS = 128 * 1024; const ulong HEADER_POS = 128 * 1024;
Encoding currentEncoding; public FileSystemType XmlFsType { get; private set; }
FileSystemType xmlFsType; public Encoding Encoding { get; private set; }
public FileSystemType XmlFsType => xmlFsType;
public Encoding Encoding => currentEncoding;
public string Name => "Fossil Filesystem Plugin"; public string Name => "Fossil Filesystem Plugin";
public Guid Id => new Guid("932BF104-43F6-494F-973C-45EF58A51DA9"); public Guid Id => new Guid("932BF104-43F6-494F-973C-45EF58A51DA9");
@@ -73,10 +69,11 @@ namespace DiscImageChef.Filesystems
return hdr.magic == FOSSIL_HDR_MAGIC; return hdr.magic == FOSSIL_HDR_MAGIC;
} }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, Encoding encoding) public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding)
{ {
// Technically everything on Plan 9 from Bell Labs is in UTF-8 // Technically everything on Plan 9 from Bell Labs is in UTF-8
currentEncoding = Encoding.UTF8; Encoding = Encoding.UTF8;
information = ""; information = "";
if(imagePlugin.Info.SectorSize < 512) return; if(imagePlugin.Info.SectorSize < 512) return;
@@ -102,7 +99,7 @@ namespace DiscImageChef.Filesystems
ulong sbLocation = hdr.super * (hdr.blockSize / imagePlugin.Info.SectorSize) + partition.Start; ulong sbLocation = hdr.super * (hdr.blockSize / imagePlugin.Info.SectorSize) + partition.Start;
xmlFsType = new FileSystemType XmlFsType = new FileSystemType
{ {
Type = "Fossil filesystem", Type = "Fossil filesystem",
ClusterSize = hdr.blockSize, ClusterSize = hdr.blockSize,
@@ -125,9 +122,8 @@ namespace DiscImageChef.Filesystems
sb.AppendFormat("Active root block {0}", fsb.active).AppendLine(); sb.AppendFormat("Active root block {0}", fsb.active).AppendLine();
sb.AppendFormat("Next root block {0}", fsb.next).AppendLine(); sb.AppendFormat("Next root block {0}", fsb.next).AppendLine();
sb.AppendFormat("Curren root block {0}", fsb.current).AppendLine(); sb.AppendFormat("Curren root block {0}", fsb.current).AppendLine();
sb.AppendFormat("Volume label: \"{0}\"", StringHandlers.CToString(fsb.name, currentEncoding)) sb.AppendFormat("Volume label: \"{0}\"", StringHandlers.CToString(fsb.name, Encoding)).AppendLine();
.AppendLine(); XmlFsType.VolumeName = StringHandlers.CToString(fsb.name, Encoding);
xmlFsType.VolumeName = StringHandlers.CToString(fsb.name, currentEncoding);
} }
} }

30
DiscImageChef.Filesystems/HAMMER.cs
View File

@@ -31,7 +31,6 @@
// ****************************************************************************/ // ****************************************************************************/
using System; using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis; using System.Diagnostics.CodeAnalysis;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
using System.Text; using System.Text;
@@ -53,11 +52,8 @@ namespace DiscImageChef.Filesystems
const uint HAMMER_VOLHDR_SIZE = 1928; const uint HAMMER_VOLHDR_SIZE = 1928;
const int HAMMER_BIGBLOCK_SIZE = 8192 * 1024; const int HAMMER_BIGBLOCK_SIZE = 8192 * 1024;
Encoding currentEncoding; public FileSystemType XmlFsType { get; private set; }
FileSystemType xmlFsType; public Encoding Encoding { get; private set; }
public FileSystemType XmlFsType => xmlFsType;
public Encoding Encoding => currentEncoding;
public string Name => "HAMMER Filesystem"; public string Name => "HAMMER Filesystem";
public Guid Id => new Guid("91A188BF-5FD7-4677-BBD3-F59EBA9C864D"); public Guid Id => new Guid("91A188BF-5FD7-4677-BBD3-F59EBA9C864D");
@@ -78,9 +74,10 @@ namespace DiscImageChef.Filesystems
return magic == HAMMER_FSBUF_VOLUME || magic == HAMMER_FSBUF_VOLUME_REV; return magic == HAMMER_FSBUF_VOLUME || magic == HAMMER_FSBUF_VOLUME_REV;
} }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, Encoding encoding) public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding)
{ {
currentEncoding = encoding ?? Encoding.GetEncoding("iso-8859-15"); Encoding = encoding ?? Encoding.GetEncoding("iso-8859-15");
information = ""; information = "";
StringBuilder sb = new StringBuilder(); StringBuilder sb = new StringBuilder();
@@ -111,8 +108,7 @@ namespace DiscImageChef.Filesystems
sb.AppendFormat("Volume version: {0}", hammerSb.vol_version).AppendLine(); sb.AppendFormat("Volume version: {0}", hammerSb.vol_version).AppendLine();
sb.AppendFormat("Volume {0} of {1} on this filesystem", hammerSb.vol_no + 1, hammerSb.vol_count) sb.AppendFormat("Volume {0} of {1} on this filesystem", hammerSb.vol_no + 1, hammerSb.vol_count)
.AppendLine(); .AppendLine();
sb.AppendFormat("Volume name: {0}", StringHandlers.CToString(hammerSb.vol_label, currentEncoding)) sb.AppendFormat("Volume name: {0}", StringHandlers.CToString(hammerSb.vol_label, Encoding)).AppendLine();
.AppendLine();
sb.AppendFormat("Volume serial: {0}", hammerSb.vol_fsid).AppendLine(); sb.AppendFormat("Volume serial: {0}", hammerSb.vol_fsid).AppendLine();
sb.AppendFormat("Filesystem type: {0}", hammerSb.vol_fstype).AppendLine(); sb.AppendFormat("Filesystem type: {0}", hammerSb.vol_fstype).AppendLine();
sb.AppendFormat("Boot area starts at {0}", hammerSb.vol_bot_beg).AppendLine(); sb.AppendFormat("Boot area starts at {0}", hammerSb.vol_bot_beg).AppendLine();
@@ -120,13 +116,13 @@ namespace DiscImageChef.Filesystems
sb.AppendFormat("First volume buffer starts at {0}", hammerSb.vol_buf_beg).AppendLine(); sb.AppendFormat("First volume buffer starts at {0}", hammerSb.vol_buf_beg).AppendLine();
sb.AppendFormat("Volume ends at {0}", hammerSb.vol_buf_end).AppendLine(); sb.AppendFormat("Volume ends at {0}", hammerSb.vol_buf_end).AppendLine();
xmlFsType = new FileSystemType XmlFsType = new FileSystemType
{ {
Clusters = (long)(partition.Size / HAMMER_BIGBLOCK_SIZE), Clusters = (long)(partition.Size / HAMMER_BIGBLOCK_SIZE),
ClusterSize = HAMMER_BIGBLOCK_SIZE, ClusterSize = HAMMER_BIGBLOCK_SIZE,
Dirty = false, Dirty = false,
Type = "HAMMER", Type = "HAMMER",
VolumeName = StringHandlers.CToString(hammerSb.vol_label, currentEncoding), VolumeName = StringHandlers.CToString(hammerSb.vol_label, Encoding),
VolumeSerial = hammerSb.vol_fsid.ToString() VolumeSerial = hammerSb.vol_fsid.ToString()
}; };
@@ -138,11 +134,11 @@ namespace DiscImageChef.Filesystems
hammerSb.vol0_stat_freebigblocks * HAMMER_BIGBLOCK_SIZE).AppendLine(); hammerSb.vol0_stat_freebigblocks * HAMMER_BIGBLOCK_SIZE).AppendLine();
sb.AppendFormat("Filesystem has {0} inode used", hammerSb.vol0_stat_inodes).AppendLine(); sb.AppendFormat("Filesystem has {0} inode used", hammerSb.vol0_stat_inodes).AppendLine();
xmlFsType.Clusters = hammerSb.vol0_stat_bigblocks; XmlFsType.Clusters = hammerSb.vol0_stat_bigblocks;
xmlFsType.FreeClusters = hammerSb.vol0_stat_freebigblocks; XmlFsType.FreeClusters = hammerSb.vol0_stat_freebigblocks;
xmlFsType.FreeClustersSpecified = true; XmlFsType.FreeClustersSpecified = true;
xmlFsType.Files = hammerSb.vol0_stat_inodes; XmlFsType.Files = hammerSb.vol0_stat_inodes;
xmlFsType.FilesSpecified = true; XmlFsType.FilesSpecified = true;
} }
// 0 ? // 0 ?
//sb.AppendFormat("Volume header CRC: 0x{0:X8}", afs_sb.vol_crc).AppendLine(); //sb.AppendFormat("Volume header CRC: 0x{0:X8}", afs_sb.vol_crc).AppendLine();

34
DiscImageChef.Filesystems/HPFS.cs
View File

@@ -31,7 +31,6 @@
// ****************************************************************************/ // ****************************************************************************/
using System; using System;
using System.Collections.Generic;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
using System.Text; using System.Text;
using DiscImageChef.Checksums; using DiscImageChef.Checksums;
@@ -44,11 +43,8 @@ namespace DiscImageChef.Filesystems
// Information from an old unnamed document // Information from an old unnamed document
public class HPFS : IFilesystem public class HPFS : IFilesystem
{ {
Encoding currentEncoding; public FileSystemType XmlFsType { get; private set; }
FileSystemType xmlFsType; public Encoding Encoding { get; private set; }
public FileSystemType XmlFsType => xmlFsType;
public Encoding Encoding => currentEncoding;
public string Name => "OS/2 High Performance File System"; public string Name => "OS/2 High Performance File System";
public Guid Id => new Guid("33513B2C-f590-4acb-8bf2-0b1d5e19dec5"); public Guid Id => new Guid("33513B2C-f590-4acb-8bf2-0b1d5e19dec5");
@@ -66,9 +62,10 @@ namespace DiscImageChef.Filesystems
return magic1 == 0xF995E849 && magic2 == 0xFA53E9C5; return magic1 == 0xF995E849 && magic2 == 0xFA53E9C5;
} }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, Encoding encoding) public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding)
{ {
currentEncoding = encoding ?? Encoding.GetEncoding("ibm850"); Encoding = encoding ?? Encoding.GetEncoding("ibm850");
information = ""; information = "";
StringBuilder sb = new StringBuilder(); StringBuilder sb = new StringBuilder();
@@ -126,8 +123,7 @@ namespace DiscImageChef.Filesystems
sb.AppendFormat("NT Flags: 0x{0:X2}", hpfsBpb.nt_flags).AppendLine(); sb.AppendFormat("NT Flags: 0x{0:X2}", hpfsBpb.nt_flags).AppendLine();
sb.AppendFormat("Signature: 0x{0:X2}", hpfsBpb.signature).AppendLine(); sb.AppendFormat("Signature: 0x{0:X2}", hpfsBpb.signature).AppendLine();
sb.AppendFormat("Serial number: 0x{0:X8}", hpfsBpb.serial_no).AppendLine(); sb.AppendFormat("Serial number: 0x{0:X8}", hpfsBpb.serial_no).AppendLine();
sb.AppendFormat("Volume label: {0}", StringHandlers.CToString(hpfsBpb.volume_label, currentEncoding)) sb.AppendFormat("Volume label: {0}", StringHandlers.CToString(hpfsBpb.volume_label, Encoding)).AppendLine();
.AppendLine();
// sb.AppendFormat("Filesystem type: \"{0}\"", hpfs_bpb.fs_type).AppendLine(); // sb.AppendFormat("Filesystem type: \"{0}\"", hpfs_bpb.fs_type).AppendLine();
DateTime lastChk = DateHandlers.UnixToDateTime(hpfsSb.last_chkdsk); DateTime lastChk = DateHandlers.UnixToDateTime(hpfsSb.last_chkdsk);
@@ -177,13 +173,13 @@ namespace DiscImageChef.Filesystems
if((hpfsSp.flags2 & 0x40) == 0x40) sb.AppendLine("Unknown flag 0x40 on flags2 is active"); if((hpfsSp.flags2 & 0x40) == 0x40) sb.AppendLine("Unknown flag 0x40 on flags2 is active");
if((hpfsSp.flags2 & 0x80) == 0x80) sb.AppendLine("Unknown flag 0x80 on flags2 is active"); if((hpfsSp.flags2 & 0x80) == 0x80) sb.AppendLine("Unknown flag 0x80 on flags2 is active");
xmlFsType = new FileSystemType(); XmlFsType = new FileSystemType();
// Theoretically everything from BPB to SB is boot code, should I hash everything or only the sector loaded by BIOS itself? // Theoretically everything from BPB to SB is boot code, should I hash everything or only the sector loaded by BIOS itself?
if(hpfsBpb.jump[0] == 0xEB && hpfsBpb.jump[1] > 0x3C && hpfsBpb.jump[1] < 0x80 && if(hpfsBpb.jump[0] == 0xEB && hpfsBpb.jump[1] > 0x3C && hpfsBpb.jump[1] < 0x80 &&
hpfsBpb.signature2 == 0xAA55) hpfsBpb.signature2 == 0xAA55)
{ {
xmlFsType.Bootable = true; XmlFsType.Bootable = true;
Sha1Context sha1Ctx = new Sha1Context(); Sha1Context sha1Ctx = new Sha1Context();
sha1Ctx.Init(); sha1Ctx.Init();
string bootChk = sha1Ctx.Data(hpfsBpb.boot_code, out byte[] sha1_out); string bootChk = sha1Ctx.Data(hpfsBpb.boot_code, out byte[] sha1_out);
@@ -191,13 +187,13 @@ namespace DiscImageChef.Filesystems
sb.AppendFormat("Boot code's SHA1: {0}", bootChk).AppendLine(); sb.AppendFormat("Boot code's SHA1: {0}", bootChk).AppendLine();
} }
xmlFsType.Dirty |= (hpfsSp.flags1 & 0x01) == 0x01; XmlFsType.Dirty |= (hpfsSp.flags1 & 0x01) == 0x01;
xmlFsType.Clusters = hpfsSb.sectors; XmlFsType.Clusters = hpfsSb.sectors;
xmlFsType.ClusterSize = hpfsBpb.bps; XmlFsType.ClusterSize = hpfsBpb.bps;
xmlFsType.Type = "HPFS"; XmlFsType.Type = "HPFS";
xmlFsType.VolumeName = StringHandlers.CToString(hpfsBpb.volume_label, currentEncoding); XmlFsType.VolumeName = StringHandlers.CToString(hpfsBpb.volume_label, Encoding);
xmlFsType.VolumeSerial = $"{hpfsBpb.serial_no:X8}"; XmlFsType.VolumeSerial = $"{hpfsBpb.serial_no:X8}";
xmlFsType.SystemIdentifier = StringHandlers.CToString(hpfsBpb.oem_name); XmlFsType.SystemIdentifier = StringHandlers.CToString(hpfsBpb.oem_name);
information = sb.ToString(); information = sb.ToString();
} }

9
DiscImageChef.Filesystems/ISO9660/ISO9660.cs
View File

@@ -32,8 +32,6 @@
using System; using System;
using System.Text; using System.Text;
using DiscImageChef.CommonTypes;
using DiscImageChef.DiscImages;
using Schemas; using Schemas;
namespace DiscImageChef.Filesystems.ISO9660 namespace DiscImageChef.Filesystems.ISO9660
@@ -41,11 +39,8 @@ namespace DiscImageChef.Filesystems.ISO9660
// This is coded following ECMA-119. // This is coded following ECMA-119.
public partial class ISO9660 : IFilesystem public partial class ISO9660 : IFilesystem
{ {
Encoding currentEncoding; public FileSystemType XmlFsType { get; private set; }
FileSystemType xmlFsType; public Encoding Encoding { get; private set; }
public FileSystemType XmlFsType => xmlFsType;
public Encoding Encoding => currentEncoding;
public string Name => "ISO9660 Filesystem"; public string Name => "ISO9660 Filesystem";
public Guid Id => new Guid("d812f4d3-c357-400d-90fd-3b22ef786aa8"); public Guid Id => new Guid("d812f4d3-c357-400d-90fd-3b22ef786aa8");
} }

104
DiscImageChef.Filesystems/ISO9660/Info.cs
View File

@@ -77,9 +77,10 @@ namespace DiscImageChef.Filesystems.ISO9660
Encoding.ASCII.GetString(vdMagic) == CDI_MAGIC; Encoding.ASCII.GetString(vdMagic) == CDI_MAGIC;
} }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, Encoding encoding) public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding)
{ {
currentEncoding = encoding ?? Encoding.ASCII; Encoding = encoding ?? Encoding.ASCII;
information = ""; information = "";
StringBuilder isoMetadata = new StringBuilder(); StringBuilder isoMetadata = new StringBuilder();
byte[] vdMagic = new byte[5]; // Volume Descriptor magic "CD001" byte[] vdMagic = new byte[5]; // Volume Descriptor magic "CD001"
@@ -105,7 +106,7 @@ namespace DiscImageChef.Filesystems.ISO9660
byte[] vdSector = imagePlugin.ReadSector(16 + counter + partition.Start); byte[] vdSector = imagePlugin.ReadSector(16 + counter + partition.Start);
int xaOff = vdSector.Length == 2336 ? 8 : 0; int xaOff = vdSector.Length == 2336 ? 8 : 0;
Array.Copy(vdSector, 0x009 + xaOff, hsMagic, 0, 5); Array.Copy(vdSector, 0x009 + xaOff, hsMagic, 0, 5);
bool highSierra = currentEncoding.GetString(hsMagic) == HIGH_SIERRA_MAGIC; bool highSierra = Encoding.GetString(hsMagic) == HIGH_SIERRA_MAGIC;
int hsOff = 0; int hsOff = 0;
if(highSierra) hsOff = 8; if(highSierra) hsOff = 8;
bool cdi = false; bool cdi = false;
@@ -132,9 +133,8 @@ namespace DiscImageChef.Filesystems.ISO9660
Array.Copy(vdSector, 0x001, vdMagic, 0, 5); Array.Copy(vdSector, 0x001, vdMagic, 0, 5);
Array.Copy(vdSector, 0x009, hsMagic, 0, 5); Array.Copy(vdSector, 0x009, hsMagic, 0, 5);
if(currentEncoding.GetString(vdMagic) != ISO_MAGIC && if(Encoding.GetString(vdMagic) != ISO_MAGIC && Encoding.GetString(hsMagic) != HIGH_SIERRA_MAGIC &&
currentEncoding.GetString(hsMagic) != HIGH_SIERRA_MAGIC && Encoding.GetString(vdMagic) != CDI_MAGIC
currentEncoding.GetString(vdMagic) != CDI_MAGIC
) // Recognized, it is an ISO9660, now check for rest of data. ) // Recognized, it is an ISO9660, now check for rest of data.
{ {
if(counter == 0) return; if(counter == 0) return;
@@ -142,7 +142,7 @@ namespace DiscImageChef.Filesystems.ISO9660
break; break;
} }
cdi |= currentEncoding.GetString(vdMagic) == CDI_MAGIC; cdi |= Encoding.GetString(vdMagic) == CDI_MAGIC;
switch(vdType) switch(vdType)
{ {
@@ -155,7 +155,7 @@ namespace DiscImageChef.Filesystems.ISO9660
bootSpec = "Unknown"; bootSpec = "Unknown";
if(currentEncoding.GetString(bvd.Value.system_id).Substring(0, 23) == "EL TORITO SPECIFICATION") if(Encoding.GetString(bvd.Value.system_id).Substring(0, 23) == "EL TORITO SPECIFICATION")
{ {
bootSpec = "El Torito"; bootSpec = "El Torito";
ptr = Marshal.AllocHGlobal(2048); ptr = Marshal.AllocHGlobal(2048);
@@ -214,7 +214,7 @@ namespace DiscImageChef.Filesystems.ISO9660
DecodedVolumeDescriptor decodedVd; DecodedVolumeDescriptor decodedVd;
DecodedVolumeDescriptor decodedJolietVd = new DecodedVolumeDescriptor(); DecodedVolumeDescriptor decodedJolietVd = new DecodedVolumeDescriptor();
xmlFsType = new FileSystemType(); XmlFsType = new FileSystemType();
if(pvd == null && hsvd == null && fsvd == null) if(pvd == null && hsvd == null && fsvd == null)
{ {
@@ -449,10 +449,9 @@ namespace DiscImageChef.Filesystems.ISO9660
foreach(byte[] erb in refareas) foreach(byte[] erb in refareas)
{ {
ReferenceArea er = BigEndianMarshal.ByteArrayToStructureBigEndian<ReferenceArea>(erb); ReferenceArea er = BigEndianMarshal.ByteArrayToStructureBigEndian<ReferenceArea>(erb);
string extId = currentEncoding.GetString(erb, Marshal.SizeOf(er), er.id_len); string extId = Encoding.GetString(erb, Marshal.SizeOf(er), er.id_len);
string extDes = currentEncoding.GetString(erb, Marshal.SizeOf(er) + er.id_len, er.des_len); string extDes = Encoding.GetString(erb, Marshal.SizeOf(er) + er.id_len, er.des_len);
string extSrc = string extSrc = Encoding.GetString(erb, Marshal.SizeOf(er) + er.id_len + er.des_len, er.src_len);
currentEncoding.GetString(erb, Marshal.SizeOf(er) + er.id_len + er.des_len, er.src_len);
suspInformation.AppendFormat("Extension: {0}", counter).AppendLine(); suspInformation.AppendFormat("Extension: {0}", counter).AppendLine();
suspInformation.AppendFormat("\tID: {0}, version {1}", extId, er.ext_ver).AppendLine(); suspInformation.AppendFormat("\tID: {0}, version {1}", extId, er.ext_ver).AppendLine();
suspInformation.AppendFormat("\tDescription: {0}", extDes).AppendLine(); suspInformation.AppendFormat("\tDescription: {0}", extDes).AppendLine();
@@ -582,8 +581,7 @@ namespace DiscImageChef.Filesystems.ISO9660
isoMetadata.AppendLine("----------------------"); isoMetadata.AppendLine("----------------------");
isoMetadata.AppendLine("Initial entry:"); isoMetadata.AppendLine("Initial entry:");
isoMetadata.AppendFormat("\tDeveloper ID: {0}", currentEncoding.GetString(valentry.developer_id)) isoMetadata.AppendFormat("\tDeveloper ID: {0}", Encoding.GetString(valentry.developer_id)).AppendLine();
.AppendLine();
if(initialEntry.bootable == ElToritoIndicator.Bootable) if(initialEntry.bootable == ElToritoIndicator.Bootable)
{ {
isoMetadata.AppendFormat("\tBootable on {0}", valentry.platform_id).AppendLine(); isoMetadata.AppendFormat("\tBootable on {0}", valentry.platform_id).AppendLine();
@@ -637,7 +635,7 @@ namespace DiscImageChef.Filesystems.ISO9660
toritoOff += EL_TORITO_ENTRY_SIZE; toritoOff += EL_TORITO_ENTRY_SIZE;
isoMetadata.AppendFormat("Boot section {0}:", SECTION_COUNTER); isoMetadata.AppendFormat("Boot section {0}:", SECTION_COUNTER);
isoMetadata.AppendFormat("\tSection ID: {0}", currentEncoding.GetString(sectionHeader.identifier)) isoMetadata.AppendFormat("\tSection ID: {0}", Encoding.GetString(sectionHeader.identifier))
.AppendLine(); .AppendLine();
for(int entryCounter = 1; entryCounter <= sectionHeader.entries && toritoOff < vdSector.Length; for(int entryCounter = 1; entryCounter <= sectionHeader.entries && toritoOff < vdSector.Length;
@@ -725,85 +723,85 @@ namespace DiscImageChef.Filesystems.ISO9660
exit_torito: exit_torito:
if(refareas.Count > 0) isoMetadata.Append(suspInformation); if(refareas.Count > 0) isoMetadata.Append(suspInformation);
xmlFsType.Type = fsFormat; XmlFsType.Type = fsFormat;
if(jolietvd != null) if(jolietvd != null)
{ {
xmlFsType.VolumeName = decodedJolietVd.VolumeIdentifier; XmlFsType.VolumeName = decodedJolietVd.VolumeIdentifier;
if(decodedJolietVd.SystemIdentifier == null || if(decodedJolietVd.SystemIdentifier == null ||
decodedVd.SystemIdentifier.Length > decodedJolietVd.SystemIdentifier.Length) decodedVd.SystemIdentifier.Length > decodedJolietVd.SystemIdentifier.Length)
xmlFsType.SystemIdentifier = decodedVd.SystemIdentifier; XmlFsType.SystemIdentifier = decodedVd.SystemIdentifier;
else xmlFsType.SystemIdentifier = decodedJolietVd.SystemIdentifier; else XmlFsType.SystemIdentifier = decodedJolietVd.SystemIdentifier;
if(decodedJolietVd.VolumeSetIdentifier == null || decodedVd.VolumeSetIdentifier.Length > if(decodedJolietVd.VolumeSetIdentifier == null || decodedVd.VolumeSetIdentifier.Length >
decodedJolietVd.VolumeSetIdentifier.Length) decodedJolietVd.VolumeSetIdentifier.Length)
xmlFsType.VolumeSetIdentifier = decodedVd.VolumeSetIdentifier; XmlFsType.VolumeSetIdentifier = decodedVd.VolumeSetIdentifier;
else xmlFsType.VolumeSetIdentifier = decodedJolietVd.VolumeSetIdentifier; else XmlFsType.VolumeSetIdentifier = decodedJolietVd.VolumeSetIdentifier;
if(decodedJolietVd.PublisherIdentifier == null || decodedVd.PublisherIdentifier.Length > if(decodedJolietVd.PublisherIdentifier == null || decodedVd.PublisherIdentifier.Length >
decodedJolietVd.PublisherIdentifier.Length) decodedJolietVd.PublisherIdentifier.Length)
xmlFsType.PublisherIdentifier = decodedVd.PublisherIdentifier; XmlFsType.PublisherIdentifier = decodedVd.PublisherIdentifier;
else xmlFsType.PublisherIdentifier = decodedJolietVd.PublisherIdentifier; else XmlFsType.PublisherIdentifier = decodedJolietVd.PublisherIdentifier;
if(decodedJolietVd.DataPreparerIdentifier == null || decodedVd.DataPreparerIdentifier.Length > if(decodedJolietVd.DataPreparerIdentifier == null || decodedVd.DataPreparerIdentifier.Length >
decodedJolietVd.DataPreparerIdentifier.Length) decodedJolietVd.DataPreparerIdentifier.Length)
xmlFsType.DataPreparerIdentifier = decodedVd.DataPreparerIdentifier; XmlFsType.DataPreparerIdentifier = decodedVd.DataPreparerIdentifier;
else xmlFsType.DataPreparerIdentifier = decodedJolietVd.SystemIdentifier; else XmlFsType.DataPreparerIdentifier = decodedJolietVd.SystemIdentifier;
if(decodedJolietVd.ApplicationIdentifier == null || decodedVd.ApplicationIdentifier.Length > if(decodedJolietVd.ApplicationIdentifier == null || decodedVd.ApplicationIdentifier.Length >
decodedJolietVd.ApplicationIdentifier.Length) decodedJolietVd.ApplicationIdentifier.Length)
xmlFsType.ApplicationIdentifier = decodedVd.ApplicationIdentifier; XmlFsType.ApplicationIdentifier = decodedVd.ApplicationIdentifier;
else xmlFsType.ApplicationIdentifier = decodedJolietVd.SystemIdentifier; else XmlFsType.ApplicationIdentifier = decodedJolietVd.SystemIdentifier;
xmlFsType.CreationDate = decodedJolietVd.CreationTime; XmlFsType.CreationDate = decodedJolietVd.CreationTime;
xmlFsType.CreationDateSpecified = true; XmlFsType.CreationDateSpecified = true;
if(decodedJolietVd.HasModificationTime) if(decodedJolietVd.HasModificationTime)
{ {
xmlFsType.ModificationDate = decodedJolietVd.ModificationTime; XmlFsType.ModificationDate = decodedJolietVd.ModificationTime;
xmlFsType.ModificationDateSpecified = true; XmlFsType.ModificationDateSpecified = true;
} }
if(decodedJolietVd.HasExpirationTime) if(decodedJolietVd.HasExpirationTime)
{ {
xmlFsType.ExpirationDate = decodedJolietVd.ExpirationTime; XmlFsType.ExpirationDate = decodedJolietVd.ExpirationTime;
xmlFsType.ExpirationDateSpecified = true; XmlFsType.ExpirationDateSpecified = true;
} }
if(decodedJolietVd.HasEffectiveTime) if(decodedJolietVd.HasEffectiveTime)
{ {
xmlFsType.EffectiveDate = decodedJolietVd.EffectiveTime; XmlFsType.EffectiveDate = decodedJolietVd.EffectiveTime;
xmlFsType.EffectiveDateSpecified = true; XmlFsType.EffectiveDateSpecified = true;
} }
} }
else else
{ {
xmlFsType.SystemIdentifier = decodedVd.SystemIdentifier; XmlFsType.SystemIdentifier = decodedVd.SystemIdentifier;
xmlFsType.VolumeName = decodedVd.VolumeIdentifier; XmlFsType.VolumeName = decodedVd.VolumeIdentifier;
xmlFsType.VolumeSetIdentifier = decodedVd.VolumeSetIdentifier; XmlFsType.VolumeSetIdentifier = decodedVd.VolumeSetIdentifier;
xmlFsType.PublisherIdentifier = decodedVd.PublisherIdentifier; XmlFsType.PublisherIdentifier = decodedVd.PublisherIdentifier;
xmlFsType.DataPreparerIdentifier = decodedVd.DataPreparerIdentifier; XmlFsType.DataPreparerIdentifier = decodedVd.DataPreparerIdentifier;
xmlFsType.ApplicationIdentifier = decodedVd.ApplicationIdentifier; XmlFsType.ApplicationIdentifier = decodedVd.ApplicationIdentifier;
xmlFsType.CreationDate = decodedVd.CreationTime; XmlFsType.CreationDate = decodedVd.CreationTime;
xmlFsType.CreationDateSpecified = true; XmlFsType.CreationDateSpecified = true;
if(decodedVd.HasModificationTime) if(decodedVd.HasModificationTime)
{ {
xmlFsType.ModificationDate = decodedVd.ModificationTime; XmlFsType.ModificationDate = decodedVd.ModificationTime;
xmlFsType.ModificationDateSpecified = true; XmlFsType.ModificationDateSpecified = true;
} }
if(decodedVd.HasExpirationTime) if(decodedVd.HasExpirationTime)
{ {
xmlFsType.ExpirationDate = decodedVd.ExpirationTime; XmlFsType.ExpirationDate = decodedVd.ExpirationTime;
xmlFsType.ExpirationDateSpecified = true; XmlFsType.ExpirationDateSpecified = true;
} }
if(decodedVd.HasEffectiveTime) if(decodedVd.HasEffectiveTime)
{ {
xmlFsType.EffectiveDate = decodedVd.EffectiveTime; XmlFsType.EffectiveDate = decodedVd.EffectiveTime;
xmlFsType.EffectiveDateSpecified = true; XmlFsType.EffectiveDateSpecified = true;
} }
} }
xmlFsType.Bootable |= bvd != null || segaCd != null || saturn != null || dreamcast != null; XmlFsType.Bootable |= bvd != null || segaCd != null || saturn != null || dreamcast != null;
xmlFsType.Clusters = decodedVd.Blocks; XmlFsType.Clusters = decodedVd.Blocks;
xmlFsType.ClusterSize = decodedVd.BlockSize; XmlFsType.ClusterSize = decodedVd.BlockSize;
information = isoMetadata.ToString(); information = isoMetadata.ToString();
} }

23
DiscImageChef.Filesystems/JFS.cs
View File

@@ -31,7 +31,6 @@
// ****************************************************************************/ // ****************************************************************************/
using System; using System;
using System.Collections.Generic;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
using System.Text; using System.Text;
using DiscImageChef.CommonTypes; using DiscImageChef.CommonTypes;
@@ -45,11 +44,8 @@ namespace DiscImageChef.Filesystems
const uint JFS_BOOT_BLOCKS_SIZE = 0x8000; const uint JFS_BOOT_BLOCKS_SIZE = 0x8000;
const uint JFS_MAGIC = 0x3153464A; const uint JFS_MAGIC = 0x3153464A;
Encoding currentEncoding; public FileSystemType XmlFsType { get; private set; }
FileSystemType xmlFsType; public Encoding Encoding { get; private set; }
public FileSystemType XmlFsType => xmlFsType;
public Encoding Encoding => currentEncoding;
public string Name => "JFS Plugin"; public string Name => "JFS Plugin";
public Guid Id => new Guid("D3BE2A41-8F28-4055-94DC-BB6C72A0E9C4"); public Guid Id => new Guid("D3BE2A41-8F28-4055-94DC-BB6C72A0E9C4");
@@ -70,9 +66,10 @@ namespace DiscImageChef.Filesystems
return jfsSb.s_magic == JFS_MAGIC; return jfsSb.s_magic == JFS_MAGIC;
} }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, Encoding encoding) public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding)
{ {
currentEncoding = encoding ?? Encoding.GetEncoding("iso-8859-15"); Encoding = encoding ?? Encoding.GetEncoding("iso-8859-15");
information = ""; information = "";
StringBuilder sb = new StringBuilder(); StringBuilder sb = new StringBuilder();
uint bootSectors = JFS_BOOT_BLOCKS_SIZE / imagePlugin.Info.SectorSize; uint bootSectors = JFS_BOOT_BLOCKS_SIZE / imagePlugin.Info.SectorSize;
@@ -120,22 +117,22 @@ namespace DiscImageChef.Filesystems
DateHandlers.UnixUnsignedToDateTime(jfsSb.s_time.tv_sec, jfsSb.s_time.tv_nsec)) DateHandlers.UnixUnsignedToDateTime(jfsSb.s_time.tv_sec, jfsSb.s_time.tv_nsec))
.AppendLine(); .AppendLine();
if(jfsSb.s_version == 1) if(jfsSb.s_version == 1)
sb.AppendFormat("Volume name: {0}", currentEncoding.GetString(jfsSb.s_fpack)).AppendLine(); sb.AppendFormat("Volume name: {0}", Encoding.GetString(jfsSb.s_fpack)).AppendLine();
else sb.AppendFormat("Volume name: {0}", currentEncoding.GetString(jfsSb.s_label)).AppendLine(); else sb.AppendFormat("Volume name: {0}", Encoding.GetString(jfsSb.s_label)).AppendLine();
sb.AppendFormat("Volume UUID: {0}", jfsSb.s_uuid).AppendLine(); sb.AppendFormat("Volume UUID: {0}", jfsSb.s_uuid).AppendLine();
xmlFsType = new FileSystemType XmlFsType = new FileSystemType
{ {
Type = "JFS filesystem", Type = "JFS filesystem",
Clusters = (long)jfsSb.s_size, Clusters = (long)jfsSb.s_size,
ClusterSize = (int)jfsSb.s_bsize, ClusterSize = (int)jfsSb.s_bsize,
Bootable = true, Bootable = true,
VolumeName = currentEncoding.GetString(jfsSb.s_version == 1 ? jfsSb.s_fpack : jfsSb.s_label), VolumeName = Encoding.GetString(jfsSb.s_version == 1 ? jfsSb.s_fpack : jfsSb.s_label),
VolumeSerial = $"{jfsSb.s_uuid}", VolumeSerial = $"{jfsSb.s_uuid}",
ModificationDate = DateHandlers.UnixUnsignedToDateTime(jfsSb.s_time.tv_sec, jfsSb.s_time.tv_nsec), ModificationDate = DateHandlers.UnixUnsignedToDateTime(jfsSb.s_time.tv_sec, jfsSb.s_time.tv_nsec),
ModificationDateSpecified = true ModificationDateSpecified = true
}; };
if(jfsSb.s_state != 0) xmlFsType.Dirty = true; if(jfsSb.s_state != 0) XmlFsType.Dirty = true;
information = sb.ToString(); information = sb.ToString();
} }

20
DiscImageChef.Filesystems/LIF.cs
View File

@@ -31,7 +31,6 @@
// ****************************************************************************/ // ****************************************************************************/
using System; using System;
using System.Collections.Generic;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
using System.Text; using System.Text;
using DiscImageChef.CommonTypes; using DiscImageChef.CommonTypes;
@@ -46,11 +45,8 @@ namespace DiscImageChef.Filesystems
{ {
const uint LIF_MAGIC = 0x8000; const uint LIF_MAGIC = 0x8000;
Encoding currentEncoding; public FileSystemType XmlFsType { get; private set; }
FileSystemType xmlFsType; public Encoding Encoding { get; private set; }
public FileSystemType XmlFsType => xmlFsType;
public Encoding Encoding => currentEncoding;
public string Name => "HP Logical Interchange Format Plugin"; public string Name => "HP Logical Interchange Format Plugin";
public Guid Id => new Guid("41535647-77A5-477B-9206-DA727ACDC704"); public Guid Id => new Guid("41535647-77A5-477B-9206-DA727ACDC704");
@@ -65,9 +61,10 @@ namespace DiscImageChef.Filesystems
return lifSb.magic == LIF_MAGIC; return lifSb.magic == LIF_MAGIC;
} }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, Encoding encoding) public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding)
{ {
currentEncoding = encoding ?? Encoding.GetEncoding("iso-8859-15"); Encoding = encoding ?? Encoding.GetEncoding("iso-8859-15");
information = ""; information = "";
if(imagePlugin.Info.SectorSize < 256) return; if(imagePlugin.Info.SectorSize < 256) return;
@@ -88,20 +85,19 @@ namespace DiscImageChef.Filesystems
sb.AppendFormat("{0} tracks", lifSb.tracks).AppendLine(); sb.AppendFormat("{0} tracks", lifSb.tracks).AppendLine();
sb.AppendFormat("{0} heads", lifSb.heads).AppendLine(); sb.AppendFormat("{0} heads", lifSb.heads).AppendLine();
sb.AppendFormat("{0} sectors", lifSb.sectors).AppendLine(); sb.AppendFormat("{0} sectors", lifSb.sectors).AppendLine();
sb.AppendFormat("Volume name: {0}", StringHandlers.CToString(lifSb.volumeLabel, currentEncoding)) sb.AppendFormat("Volume name: {0}", StringHandlers.CToString(lifSb.volumeLabel, Encoding)).AppendLine();
.AppendLine();
sb.AppendFormat("Volume created on {0}", DateHandlers.LifToDateTime(lifSb.creationDate)).AppendLine(); sb.AppendFormat("Volume created on {0}", DateHandlers.LifToDateTime(lifSb.creationDate)).AppendLine();
information = sb.ToString(); information = sb.ToString();
xmlFsType = new FileSystemType XmlFsType = new FileSystemType
{ {
Type = "HP Logical Interchange Format", Type = "HP Logical Interchange Format",
ClusterSize = 256, ClusterSize = 256,
Clusters = (long)(partition.Size / 256), Clusters = (long)(partition.Size / 256),
CreationDate = DateHandlers.LifToDateTime(lifSb.creationDate), CreationDate = DateHandlers.LifToDateTime(lifSb.creationDate),
CreationDateSpecified = true, CreationDateSpecified = true,
VolumeName = StringHandlers.CToString(lifSb.volumeLabel, currentEncoding) VolumeName = StringHandlers.CToString(lifSb.volumeLabel, Encoding)
}; };
} }

20
DiscImageChef.Filesystems/LisaFS/Dir.cs
View File

@@ -92,7 +92,7 @@ namespace DiscImageChef.Filesystems.LisaFS
// as '-' is the path separator in Lisa OS // as '-' is the path separator in Lisa OS
contents = (from entry in catalogCache contents = (from entry in catalogCache
where entry.parentID == dirId where entry.parentID == dirId
select StringHandlers.CToString(entry.filename, currentEncoding).Replace('/', '-')).ToList(); select StringHandlers.CToString(entry.filename, Encoding).Replace('/', '-')).ToList();
return Errno.NoError; return Errno.NoError;
} }
@@ -118,15 +118,17 @@ namespace DiscImageChef.Filesystems.LisaFS
// For each entry on the catalog // For each entry on the catalog
while(offset + 54 < buf.Length) while(offset + 54 < buf.Length)
{ {
CatalogEntryV2 entV2 = new CatalogEntryV2(); CatalogEntryV2 entV2 = new CatalogEntryV2
entV2.filenameLen = buf[offset]; {
entV2.filename = new byte[E_NAME]; filenameLen = buf[offset],
filename = new byte[E_NAME],
unknown1 = buf[offset + 0x21],
fileType = buf[offset + 0x22],
unknown2 = buf[offset + 0x23],
fileID = BigEndianBitConverter.ToInt16(buf, offset + 0x24),
unknown3 = new byte[16]
};
Array.Copy(buf, offset + 0x01, entV2.filename, 0, E_NAME); Array.Copy(buf, offset + 0x01, entV2.filename, 0, E_NAME);
entV2.unknown1 = buf[offset + 0x21];
entV2.fileType = buf[offset + 0x22];
entV2.unknown2 = buf[offset + 0x23];
entV2.fileID = BigEndianBitConverter.ToInt16(buf, offset + 0x24);
entV2.unknown3 = new byte[16];
Array.Copy(buf, offset + 0x26, entV2.unknown3, 0, 16); Array.Copy(buf, offset + 0x26, entV2.unknown3, 0, 16);
offset += 54; offset += 54;

4
DiscImageChef.Filesystems/LisaFS/Extent.cs
View File

@@ -185,7 +185,7 @@ namespace DiscImageChef.Filesystems.LisaFS
DicConsole.DebugWriteLine("LisaFS plugin", "ExtentFile[{0}].filenameLen = {1}", fileId, file.filenameLen); DicConsole.DebugWriteLine("LisaFS plugin", "ExtentFile[{0}].filenameLen = {1}", fileId, file.filenameLen);
DicConsole.DebugWriteLine("LisaFS plugin", "ExtentFile[{0}].filename = {1}", fileId, DicConsole.DebugWriteLine("LisaFS plugin", "ExtentFile[{0}].filename = {1}", fileId,
StringHandlers.CToString(file.filename, currentEncoding)); StringHandlers.CToString(file.filename, Encoding));
DicConsole.DebugWriteLine("LisaFS plugin", "ExtentFile[{0}].unknown1 = 0x{1:X4}", fileId, file.unknown1); DicConsole.DebugWriteLine("LisaFS plugin", "ExtentFile[{0}].unknown1 = 0x{1:X4}", fileId, file.unknown1);
DicConsole.DebugWriteLine("LisaFS plugin", "ExtentFile[{0}].file_uid = 0x{1:X16}", fileId, file.file_uid); DicConsole.DebugWriteLine("LisaFS plugin", "ExtentFile[{0}].file_uid = 0x{1:X16}", fileId, file.file_uid);
DicConsole.DebugWriteLine("LisaFS plugin", "ExtentFile[{0}].unknown2 = 0x{1:X2}", fileId, file.unknown2); DicConsole.DebugWriteLine("LisaFS plugin", "ExtentFile[{0}].unknown2 = 0x{1:X2}", fileId, file.unknown2);
@@ -219,7 +219,7 @@ namespace DiscImageChef.Filesystems.LisaFS
DicConsole.DebugWriteLine("LisaFS plugin", "ExtentFile[{0}].password_valid = {1}", fileId, DicConsole.DebugWriteLine("LisaFS plugin", "ExtentFile[{0}].password_valid = {1}", fileId,
file.password_valid > 0); file.password_valid > 0);
DicConsole.DebugWriteLine("LisaFS plugin", "ExtentFile[{0}].password = {1}", fileId, DicConsole.DebugWriteLine("LisaFS plugin", "ExtentFile[{0}].password = {1}", fileId,
currentEncoding.GetString(file.password)); Encoding.GetString(file.password));
DicConsole.DebugWriteLine("LisaFS plugin", "ExtentFile[{0}].unknown7 = 0x{1:X2}{2:X2}{3:X2}", fileId, DicConsole.DebugWriteLine("LisaFS plugin", "ExtentFile[{0}].unknown7 = 0x{1:X2}{2:X2}{3:X2}", fileId,
file.unknown7[0], file.unknown7[1], file.unknown7[2]); file.unknown7[0], file.unknown7[1], file.unknown7[2]);
DicConsole.DebugWriteLine("LisaFS plugin", "ExtentFile[{0}].overhead = {1}", fileId, file.overhead); DicConsole.DebugWriteLine("LisaFS plugin", "ExtentFile[{0}].overhead = {1}", fileId, file.overhead);

2
DiscImageChef.Filesystems/LisaFS/File.cs
View File

@@ -423,7 +423,7 @@ namespace DiscImageChef.Filesystems.LisaFS
foreach(CatalogEntry entry in catalogCache) foreach(CatalogEntry entry in catalogCache)
{ {
string filename = StringHandlers.CToString(entry.filename, currentEncoding); string filename = StringHandlers.CToString(entry.filename, Encoding);
// LisaOS is case insensitive // LisaOS is case insensitive
if(string.Compare(wantedFilename, filename, StringComparison.InvariantCultureIgnoreCase) != 0 || if(string.Compare(wantedFilename, filename, StringComparison.InvariantCultureIgnoreCase) != 0 ||

45
DiscImageChef.Filesystems/LisaFS/Info.cs
View File

@@ -85,14 +85,12 @@ namespace DiscImageChef.Filesystems.LisaFS
DicConsole.DebugWriteLine("LisaFS plugin", "Current sector = {0}", i); DicConsole.DebugWriteLine("LisaFS plugin", "Current sector = {0}", i);
DicConsole.DebugWriteLine("LisaFS plugin", "mddf.mddf_block = {0}", infoMddf.mddf_block); DicConsole.DebugWriteLine("LisaFS plugin", "mddf.mddf_block = {0}", infoMddf.mddf_block);
DicConsole.DebugWriteLine("LisaFS plugin", "Disk size = {0} sectors", DicConsole.DebugWriteLine("LisaFS plugin", "Disk size = {0} sectors", imagePlugin.Info.Sectors);
imagePlugin.Info.Sectors);
DicConsole.DebugWriteLine("LisaFS plugin", "mddf.vol_size = {0} sectors", infoMddf.vol_size); DicConsole.DebugWriteLine("LisaFS plugin", "mddf.vol_size = {0} sectors", infoMddf.vol_size);
DicConsole.DebugWriteLine("LisaFS plugin", "mddf.vol_size - 1 = {0}", infoMddf.volsize_minus_one); DicConsole.DebugWriteLine("LisaFS plugin", "mddf.vol_size - 1 = {0}", infoMddf.volsize_minus_one);
DicConsole.DebugWriteLine("LisaFS plugin", "mddf.vol_size - mddf.mddf_block -1 = {0}", DicConsole.DebugWriteLine("LisaFS plugin", "mddf.vol_size - mddf.mddf_block -1 = {0}",
infoMddf.volsize_minus_mddf_minus_one); infoMddf.volsize_minus_mddf_minus_one);
DicConsole.DebugWriteLine("LisaFS plugin", "Disk sector = {0} bytes", DicConsole.DebugWriteLine("LisaFS plugin", "Disk sector = {0} bytes", imagePlugin.Info.SectorSize);
imagePlugin.Info.SectorSize);
DicConsole.DebugWriteLine("LisaFS plugin", "mddf.blocksize = {0} bytes", infoMddf.blocksize); DicConsole.DebugWriteLine("LisaFS plugin", "mddf.blocksize = {0} bytes", infoMddf.blocksize);
DicConsole.DebugWriteLine("LisaFS plugin", "mddf.datasize = {0} bytes", infoMddf.datasize); DicConsole.DebugWriteLine("LisaFS plugin", "mddf.datasize = {0} bytes", infoMddf.datasize);
@@ -120,9 +118,10 @@ namespace DiscImageChef.Filesystems.LisaFS
} }
} }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, Encoding encoding) public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding)
{ {
currentEncoding = new LisaRoman(); Encoding = new LisaRoman();
information = ""; information = "";
StringBuilder sb = new StringBuilder(); StringBuilder sb = new StringBuilder();
@@ -161,11 +160,11 @@ namespace DiscImageChef.Filesystems.LisaFS
infoMddf.volid = BigEndianBitConverter.ToUInt64(sector, 0x02); infoMddf.volid = BigEndianBitConverter.ToUInt64(sector, 0x02);
infoMddf.volnum = BigEndianBitConverter.ToUInt16(sector, 0x0A); infoMddf.volnum = BigEndianBitConverter.ToUInt16(sector, 0x0A);
Array.Copy(sector, 0x0C, pString, 0, 33); Array.Copy(sector, 0x0C, pString, 0, 33);
infoMddf.volname = StringHandlers.PascalToString(pString, currentEncoding); infoMddf.volname = StringHandlers.PascalToString(pString, Encoding);
infoMddf.unknown1 = sector[0x2D]; infoMddf.unknown1 = sector[0x2D];
Array.Copy(sector, 0x2E, pString, 0, 33); Array.Copy(sector, 0x2E, pString, 0, 33);
// Prevent garbage // Prevent garbage
infoMddf.password = pString[0] <= 32 ? StringHandlers.PascalToString(pString, currentEncoding) : ""; infoMddf.password = pString[0] <= 32 ? StringHandlers.PascalToString(pString, Encoding) : "";
infoMddf.unknown2 = sector[0x4F]; infoMddf.unknown2 = sector[0x4F];
infoMddf.machine_id = BigEndianBitConverter.ToUInt32(sector, 0x50); infoMddf.machine_id = BigEndianBitConverter.ToUInt32(sector, 0x50);
infoMddf.master_copy_id = BigEndianBitConverter.ToUInt32(sector, 0x54); infoMddf.master_copy_id = BigEndianBitConverter.ToUInt32(sector, 0x54);
@@ -351,27 +350,27 @@ namespace DiscImageChef.Filesystems.LisaFS
information = sb.ToString(); information = sb.ToString();
xmlFsType = new FileSystemType(); XmlFsType = new FileSystemType();
if(DateTime.Compare(infoMddf.dtvb, DateHandlers.LisaToDateTime(0)) > 0) if(DateTime.Compare(infoMddf.dtvb, DateHandlers.LisaToDateTime(0)) > 0)
{ {
xmlFsType.BackupDate = infoMddf.dtvb; XmlFsType.BackupDate = infoMddf.dtvb;
xmlFsType.BackupDateSpecified = true; XmlFsType.BackupDateSpecified = true;
} }
xmlFsType.Clusters = infoMddf.vol_size; XmlFsType.Clusters = infoMddf.vol_size;
xmlFsType.ClusterSize = infoMddf.clustersize * infoMddf.datasize; XmlFsType.ClusterSize = infoMddf.clustersize * infoMddf.datasize;
if(DateTime.Compare(infoMddf.dtvc, DateHandlers.LisaToDateTime(0)) > 0) if(DateTime.Compare(infoMddf.dtvc, DateHandlers.LisaToDateTime(0)) > 0)
{ {
xmlFsType.CreationDate = infoMddf.dtvc; XmlFsType.CreationDate = infoMddf.dtvc;
xmlFsType.CreationDateSpecified = true; XmlFsType.CreationDateSpecified = true;
} }
xmlFsType.Dirty = infoMddf.vol_left_mounted != 0; XmlFsType.Dirty = infoMddf.vol_left_mounted != 0;
xmlFsType.Files = infoMddf.filecount; XmlFsType.Files = infoMddf.filecount;
xmlFsType.FilesSpecified = true; XmlFsType.FilesSpecified = true;
xmlFsType.FreeClusters = infoMddf.freecount; XmlFsType.FreeClusters = infoMddf.freecount;
xmlFsType.FreeClustersSpecified = true; XmlFsType.FreeClustersSpecified = true;
xmlFsType.Type = "LisaFS"; XmlFsType.Type = "LisaFS";
xmlFsType.VolumeName = infoMddf.volname; XmlFsType.VolumeName = infoMddf.volname;
xmlFsType.VolumeSerial = $"{infoMddf.volid:X16}"; XmlFsType.VolumeSerial = $"{infoMddf.volid:X16}";
return; return;
} }

12
DiscImageChef.Filesystems/LisaFS/LisaFS.cs
View File

@@ -32,11 +32,9 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using Claunia.Encoding; using System.Text;
using DiscImageChef.CommonTypes;
using DiscImageChef.DiscImages; using DiscImageChef.DiscImages;
using Schemas; using Schemas;
using Encoding = System.Text.Encoding;
namespace DiscImageChef.Filesystems.LisaFS namespace DiscImageChef.Filesystems.LisaFS
{ {
@@ -44,9 +42,8 @@ namespace DiscImageChef.Filesystems.LisaFS
// Variable names from Lisa API // Variable names from Lisa API
public partial class LisaFS : IReadOnlyFilesystem public partial class LisaFS : IReadOnlyFilesystem
{ {
IMediaImage device;
Encoding currentEncoding;
bool debug; bool debug;
IMediaImage device;
int devTagSize; int devTagSize;
MDDF mddf; MDDF mddf;
@@ -56,9 +53,8 @@ namespace DiscImageChef.Filesystems.LisaFS
public string Name => "Apple Lisa File System"; public string Name => "Apple Lisa File System";
public Guid Id => new Guid("7E6034D1-D823-4248-A54D-239742B28391"); public Guid Id => new Guid("7E6034D1-D823-4248-A54D-239742B28391");
public Encoding Encoding => currentEncoding; public Encoding Encoding { get; private set; }
FileSystemType xmlFsType; public FileSystemType XmlFsType { get; private set; }
public FileSystemType XmlFsType => xmlFsType;
#region Caches #region Caches
/// <summary>Caches Extents Files</summary> /// <summary>Caches Extents Files</summary>

36
DiscImageChef.Filesystems/LisaFS/Super.cs
View File

@@ -52,7 +52,7 @@ namespace DiscImageChef.Filesystems.LisaFS
try try
{ {
device = imagePlugin; device = imagePlugin;
currentEncoding = new LisaRoman(); Encoding = new LisaRoman();
// Lisa OS is unable to work on disks without tags. // Lisa OS is unable to work on disks without tags.
// This code is designed like that. // This code is designed like that.
@@ -100,11 +100,11 @@ namespace DiscImageChef.Filesystems.LisaFS
mddf.volid = BigEndianBitConverter.ToUInt64(sector, 0x02); mddf.volid = BigEndianBitConverter.ToUInt64(sector, 0x02);
mddf.volnum = BigEndianBitConverter.ToUInt16(sector, 0x0A); mddf.volnum = BigEndianBitConverter.ToUInt16(sector, 0x0A);
Array.Copy(sector, 0x0C, pString, 0, 33); Array.Copy(sector, 0x0C, pString, 0, 33);
mddf.volname = StringHandlers.PascalToString(pString, currentEncoding); mddf.volname = StringHandlers.PascalToString(pString, Encoding);
mddf.unknown1 = sector[0x2D]; mddf.unknown1 = sector[0x2D];
Array.Copy(sector, 0x2E, pString, 0, 33); Array.Copy(sector, 0x2E, pString, 0, 33);
// Prevent garbage // Prevent garbage
mddf.password = pString[0] <= 32 ? StringHandlers.PascalToString(pString, currentEncoding) : ""; mddf.password = pString[0] <= 32 ? StringHandlers.PascalToString(pString, Encoding) : "";
mddf.unknown2 = sector[0x4F]; mddf.unknown2 = sector[0x4F];
mddf.machine_id = BigEndianBitConverter.ToUInt32(sector, 0x50); mddf.machine_id = BigEndianBitConverter.ToUInt32(sector, 0x50);
mddf.master_copy_id = BigEndianBitConverter.ToUInt32(sector, 0x54); mddf.master_copy_id = BigEndianBitConverter.ToUInt32(sector, 0x54);
@@ -281,27 +281,27 @@ namespace DiscImageChef.Filesystems.LisaFS
} }
// Create XML metadata for mounted filesystem // Create XML metadata for mounted filesystem
xmlFsType = new FileSystemType(); XmlFsType = new FileSystemType();
if(DateTime.Compare(mddf.dtvb, DateHandlers.LisaToDateTime(0)) > 0) if(DateTime.Compare(mddf.dtvb, DateHandlers.LisaToDateTime(0)) > 0)
{ {
xmlFsType.BackupDate = mddf.dtvb; XmlFsType.BackupDate = mddf.dtvb;
xmlFsType.BackupDateSpecified = true; XmlFsType.BackupDateSpecified = true;
} }
xmlFsType.Clusters = mddf.vol_size; XmlFsType.Clusters = mddf.vol_size;
xmlFsType.ClusterSize = mddf.clustersize * mddf.datasize; XmlFsType.ClusterSize = mddf.clustersize * mddf.datasize;
if(DateTime.Compare(mddf.dtvc, DateHandlers.LisaToDateTime(0)) > 0) if(DateTime.Compare(mddf.dtvc, DateHandlers.LisaToDateTime(0)) > 0)
{ {
xmlFsType.CreationDate = mddf.dtvc; XmlFsType.CreationDate = mddf.dtvc;
xmlFsType.CreationDateSpecified = true; XmlFsType.CreationDateSpecified = true;
} }
xmlFsType.Dirty = mddf.vol_left_mounted != 0; XmlFsType.Dirty = mddf.vol_left_mounted != 0;
xmlFsType.Files = mddf.filecount; XmlFsType.Files = mddf.filecount;
xmlFsType.FilesSpecified = true; XmlFsType.FilesSpecified = true;
xmlFsType.FreeClusters = mddf.freecount; XmlFsType.FreeClusters = mddf.freecount;
xmlFsType.FreeClustersSpecified = true; XmlFsType.FreeClustersSpecified = true;
xmlFsType.Type = "LisaFS"; XmlFsType.Type = "LisaFS";
xmlFsType.VolumeName = mddf.volname; XmlFsType.VolumeName = mddf.volname;
xmlFsType.VolumeSerial = $"{mddf.volid:X16}"; XmlFsType.VolumeSerial = $"{mddf.volid:X16}";
return Errno.NoError; return Errno.NoError;
} }

19
DiscImageChef.Filesystems/Locus.cs
View File

@@ -31,7 +31,6 @@
// ****************************************************************************/ // ****************************************************************************/
using System; using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis; using System.Diagnostics.CodeAnalysis;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
using System.Text; using System.Text;
@@ -68,11 +67,8 @@ namespace DiscImageChef.Filesystems
const uint Locus_OldMagic = 0xFFEEDDCC; const uint Locus_OldMagic = 0xFFEEDDCC;
const uint Locus_OldCigam = 0xCCDDEEFF; const uint Locus_OldCigam = 0xCCDDEEFF;
Encoding currentEncoding; public FileSystemType XmlFsType { get; private set; }
FileSystemType xmlFsType; public Encoding Encoding { get; private set; }
public FileSystemType XmlFsType => xmlFsType;
public Encoding Encoding => currentEncoding;
public string Name => "Locus Filesystem Plugin"; public string Name => "Locus Filesystem Plugin";
public Guid Id => new Guid("1A70B30A-437D-479A-88E1-D0C9C1797FF4"); public Guid Id => new Guid("1A70B30A-437D-479A-88E1-D0C9C1797FF4");
@@ -106,9 +102,10 @@ namespace DiscImageChef.Filesystems
return false; return false;
} }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, Encoding encoding) public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding)
{ {
currentEncoding = encoding ?? Encoding.GetEncoding("iso-8859-15"); Encoding = encoding ?? Encoding.GetEncoding("iso-8859-15");
information = ""; information = "";
if(imagePlugin.Info.SectorSize < 512) return; if(imagePlugin.Info.SectorSize < 512) return;
@@ -149,8 +146,8 @@ namespace DiscImageChef.Filesystems
int blockSize = LocusSb.s_version == LocusVersion.SB_SB4096 ? 4096 : 1024; int blockSize = LocusSb.s_version == LocusVersion.SB_SB4096 ? 4096 : 1024;
string s_fsmnt = StringHandlers.CToString(LocusSb.s_fsmnt, currentEncoding); string s_fsmnt = StringHandlers.CToString(LocusSb.s_fsmnt, Encoding);
string s_fpack = StringHandlers.CToString(LocusSb.s_fpack, currentEncoding); string s_fpack = StringHandlers.CToString(LocusSb.s_fpack, Encoding);
DicConsole.DebugWriteLine("Locus plugin", "LocusSb.s_magic = 0x{0:X8}", LocusSb.s_magic); DicConsole.DebugWriteLine("Locus plugin", "LocusSb.s_magic = 0x{0:X8}", LocusSb.s_magic);
DicConsole.DebugWriteLine("Locus plugin", "LocusSb.s_gfs = {0}", LocusSb.s_gfs); DicConsole.DebugWriteLine("Locus plugin", "LocusSb.s_gfs = {0}", LocusSb.s_gfs);
@@ -203,7 +200,7 @@ namespace DiscImageChef.Filesystems
information = sb.ToString(); information = sb.ToString();
xmlFsType = new FileSystemType XmlFsType = new FileSystemType
{ {
Type = "Locus filesystem", Type = "Locus filesystem",
ClusterSize = blockSize, ClusterSize = blockSize,

13
DiscImageChef.Filesystems/MicroDOS.cs
View File

@@ -31,7 +31,6 @@
// ****************************************************************************/ // ****************************************************************************/
using System; using System;
using System.Collections.Generic;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
using System.Text; using System.Text;
using DiscImageChef.CommonTypes; using DiscImageChef.CommonTypes;
@@ -46,11 +45,9 @@ namespace DiscImageChef.Filesystems
{ {
const ushort MAGIC = 0xA72E; const ushort MAGIC = 0xA72E;
const ushort MAGIC2 = 0x530C; const ushort MAGIC2 = 0x530C;
FileSystemType xmlFsType;
public FileSystemType XmlFsType => xmlFsType;
Encoding currentEncoding; public FileSystemType XmlFsType { get; private set; }
public Encoding Encoding => currentEncoding; public Encoding Encoding { get; private set; }
public string Name => "MicroDOS file system"; public string Name => "MicroDOS file system";
public Guid Id => new Guid("9F9A364A-1A27-48A3-B730-7A7122000324"); public Guid Id => new Guid("9F9A364A-1A27-48A3-B730-7A7122000324");
@@ -71,9 +68,9 @@ namespace DiscImageChef.Filesystems
} }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding) Encoding encoding)
{ {
currentEncoding = encoding ?? Encoding.GetEncoding("koi8-r"); Encoding = encoding ?? Encoding.GetEncoding("koi8-r");
information = ""; information = "";
StringBuilder sb = new StringBuilder(); StringBuilder sb = new StringBuilder();
@@ -92,7 +89,7 @@ namespace DiscImageChef.Filesystems
sb.AppendFormat("Volume contains {0} files", block0.files).AppendLine(); sb.AppendFormat("Volume contains {0} files", block0.files).AppendLine();
sb.AppendFormat("First used block is {0}", block0.firstUsedBlock).AppendLine(); sb.AppendFormat("First used block is {0}", block0.firstUsedBlock).AppendLine();
xmlFsType = new FileSystemType XmlFsType = new FileSystemType
{ {
Type = "MicroDOS", Type = "MicroDOS",
ClusterSize = 512, ClusterSize = 512,

43
DiscImageChef.Filesystems/MinixFS.cs
View File

@@ -31,7 +31,6 @@
// ****************************************************************************/ // ****************************************************************************/
using System; using System;
using System.Collections.Generic;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
using System.Text; using System.Text;
using DiscImageChef.CommonTypes; using DiscImageChef.CommonTypes;
@@ -64,11 +63,9 @@ namespace DiscImageChef.Filesystems
const ushort MINIX2_CIGAM2 = 0x7824; const ushort MINIX2_CIGAM2 = 0x7824;
/// <summary>Minix v3, 60 char filenames</summary> /// <summary>Minix v3, 60 char filenames</summary>
const ushort MINIX3_CIGAM = 0x5A4D; const ushort MINIX3_CIGAM = 0x5A4D;
FileSystemType xmlFsType;
public FileSystemType XmlFsType => xmlFsType;
Encoding currentEncoding; public FileSystemType XmlFsType { get; private set; }
public Encoding Encoding => currentEncoding; public Encoding Encoding { get; private set; }
public string Name => "Minix Filesystem"; public string Name => "Minix Filesystem";
public Guid Id => new Guid("FE248C3B-B727-4AE5-A39F-79EA9A07D4B3"); public Guid Id => new Guid("FE248C3B-B727-4AE5-A39F-79EA9A07D4B3");
@@ -111,9 +108,9 @@ namespace DiscImageChef.Filesystems
} }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding) Encoding encoding)
{ {
currentEncoding = encoding ?? Encoding.GetEncoding("iso-8859-15"); Encoding = encoding ?? Encoding.GetEncoding("iso-8859-15");
information = ""; information = "";
StringBuilder sb = new StringBuilder(); StringBuilder sb = new StringBuilder();
@@ -143,7 +140,7 @@ namespace DiscImageChef.Filesystems
magic = BitConverter.ToUInt16(minixSbSector, 0x018); magic = BitConverter.ToUInt16(minixSbSector, 0x018);
xmlFsType = new FileSystemType(); XmlFsType = new FileSystemType();
bool littleEndian; bool littleEndian;
@@ -158,16 +155,16 @@ namespace DiscImageChef.Filesystems
case MINIX3_MAGIC: case MINIX3_MAGIC:
case MINIX3_CIGAM: case MINIX3_CIGAM:
minixVersion = "Minix v3 filesystem"; minixVersion = "Minix v3 filesystem";
xmlFsType.Type = "Minix v3"; XmlFsType.Type = "Minix v3";
break; break;
case MINIX2_MAGIC: case MINIX2_MAGIC:
case MINIX2_CIGAM: case MINIX2_CIGAM:
minixVersion = "Minix 3 v2 filesystem"; minixVersion = "Minix 3 v2 filesystem";
xmlFsType.Type = "Minix 3 v2"; XmlFsType.Type = "Minix 3 v2";
break; break;
default: default:
minixVersion = "Minix 3 v1 filesystem"; minixVersion = "Minix 3 v1 filesystem";
xmlFsType.Type = "Minix 3 v1"; XmlFsType.Type = "Minix 3 v1";
break; break;
} }
@@ -183,49 +180,49 @@ namespace DiscImageChef.Filesystems
filenamesize = 14; filenamesize = 14;
minixVersion = "Minix v1 filesystem"; minixVersion = "Minix v1 filesystem";
littleEndian = true; littleEndian = true;
xmlFsType.Type = "Minix v1"; XmlFsType.Type = "Minix v1";
break; break;
case MINIX_MAGIC2: case MINIX_MAGIC2:
filenamesize = 30; filenamesize = 30;
minixVersion = "Minix v1 filesystem"; minixVersion = "Minix v1 filesystem";
littleEndian = true; littleEndian = true;
xmlFsType.Type = "Minix v1"; XmlFsType.Type = "Minix v1";
break; break;
case MINIX2_MAGIC: case MINIX2_MAGIC:
filenamesize = 14; filenamesize = 14;
minixVersion = "Minix v2 filesystem"; minixVersion = "Minix v2 filesystem";
littleEndian = true; littleEndian = true;
xmlFsType.Type = "Minix v2"; XmlFsType.Type = "Minix v2";
break; break;
case MINIX2_MAGIC2: case MINIX2_MAGIC2:
filenamesize = 30; filenamesize = 30;
minixVersion = "Minix v2 filesystem"; minixVersion = "Minix v2 filesystem";
littleEndian = true; littleEndian = true;
xmlFsType.Type = "Minix v2"; XmlFsType.Type = "Minix v2";
break; break;
case MINIX_CIGAM: case MINIX_CIGAM:
filenamesize = 14; filenamesize = 14;
minixVersion = "Minix v1 filesystem"; minixVersion = "Minix v1 filesystem";
littleEndian = false; littleEndian = false;
xmlFsType.Type = "Minix v1"; XmlFsType.Type = "Minix v1";
break; break;
case MINIX_CIGAM2: case MINIX_CIGAM2:
filenamesize = 30; filenamesize = 30;
minixVersion = "Minix v1 filesystem"; minixVersion = "Minix v1 filesystem";
littleEndian = false; littleEndian = false;
xmlFsType.Type = "Minix v1"; XmlFsType.Type = "Minix v1";
break; break;
case MINIX2_CIGAM: case MINIX2_CIGAM:
filenamesize = 14; filenamesize = 14;
minixVersion = "Minix v2 filesystem"; minixVersion = "Minix v2 filesystem";
littleEndian = false; littleEndian = false;
xmlFsType.Type = "Minix v2"; XmlFsType.Type = "Minix v2";
break; break;
case MINIX2_CIGAM2: case MINIX2_CIGAM2:
filenamesize = 30; filenamesize = 30;
minixVersion = "Minix v2 filesystem"; minixVersion = "Minix v2 filesystem";
littleEndian = false; littleEndian = false;
xmlFsType.Type = "Minix v2"; XmlFsType.Type = "Minix v2";
break; break;
default: return; default: return;
} }
@@ -265,8 +262,8 @@ namespace DiscImageChef.Filesystems
sb.AppendFormat("{0} bytes maximum per file", mnxSb.s_max_size).AppendLine(); sb.AppendFormat("{0} bytes maximum per file", mnxSb.s_max_size).AppendLine();
sb.AppendFormat("On-disk filesystem version: {0}", mnxSb.s_disk_version).AppendLine(); sb.AppendFormat("On-disk filesystem version: {0}", mnxSb.s_disk_version).AppendLine();
xmlFsType.ClusterSize = mnxSb.s_blocksize; XmlFsType.ClusterSize = mnxSb.s_blocksize;
xmlFsType.Clusters = mnxSb.s_zones > 0 ? mnxSb.s_zones : mnxSb.s_nzones; XmlFsType.Clusters = mnxSb.s_zones > 0 ? mnxSb.s_zones : mnxSb.s_nzones;
} }
else else
{ {
@@ -298,8 +295,8 @@ namespace DiscImageChef.Filesystems
//sb.AppendFormat("log2 of blocks/zone: {0}", mnx_sb.s_log_zone_size).AppendLine(); // Apparently 0 //sb.AppendFormat("log2 of blocks/zone: {0}", mnx_sb.s_log_zone_size).AppendLine(); // Apparently 0
sb.AppendFormat("{0} bytes maximum per file", mnxSb.s_max_size).AppendLine(); sb.AppendFormat("{0} bytes maximum per file", mnxSb.s_max_size).AppendLine();
sb.AppendFormat("Filesystem state: {0:X4}", mnxSb.s_state).AppendLine(); sb.AppendFormat("Filesystem state: {0:X4}", mnxSb.s_state).AppendLine();
xmlFsType.ClusterSize = 1024; XmlFsType.ClusterSize = 1024;
xmlFsType.Clusters = mnxSb.s_zones > 0 ? mnxSb.s_zones : mnxSb.s_nzones; XmlFsType.Clusters = mnxSb.s_zones > 0 ? mnxSb.s_zones : mnxSb.s_nzones;
} }
information = sb.ToString(); information = sb.ToString();
} }

24
DiscImageChef.Filesystems/NILFS2.cs
View File

@@ -31,7 +31,6 @@
// ****************************************************************************/ // ****************************************************************************/
using System; using System;
using System.Collections.Generic;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
using System.Text; using System.Text;
using DiscImageChef.CommonTypes; using DiscImageChef.CommonTypes;
@@ -45,11 +44,8 @@ namespace DiscImageChef.Filesystems
const ushort NILFS2_MAGIC = 0x3434; const ushort NILFS2_MAGIC = 0x3434;
const uint NILFS2_SUPER_OFFSET = 1024; const uint NILFS2_SUPER_OFFSET = 1024;
Encoding currentEncoding; public FileSystemType XmlFsType { get; private set; }
FileSystemType xmlFsType; public Encoding Encoding { get; private set; }
public FileSystemType XmlFsType => xmlFsType;
public Encoding Encoding => currentEncoding;
public string Name => "NILFS2 Plugin"; public string Name => "NILFS2 Plugin";
public Guid Id => new Guid("35224226-C5CC-48B5-8FFD-3781E91E86B6"); public Guid Id => new Guid("35224226-C5CC-48B5-8FFD-3781E91E86B6");
@@ -78,9 +74,10 @@ namespace DiscImageChef.Filesystems
return nilfsSb.magic == NILFS2_MAGIC; return nilfsSb.magic == NILFS2_MAGIC;
} }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, Encoding encoding) public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding)
{ {
currentEncoding = encoding ?? Encoding.UTF8; Encoding = encoding ?? Encoding.UTF8;
information = ""; information = "";
if(imagePlugin.Info.SectorSize < 512) return; if(imagePlugin.Info.SectorSize < 512) return;
@@ -114,8 +111,7 @@ namespace DiscImageChef.Filesystems
else sb.AppendFormat("Creator OS code: {0}", nilfsSb.creator_os).AppendLine(); else sb.AppendFormat("Creator OS code: {0}", nilfsSb.creator_os).AppendLine();
sb.AppendFormat("{0} bytes per inode", nilfsSb.inode_size).AppendLine(); sb.AppendFormat("{0} bytes per inode", nilfsSb.inode_size).AppendLine();
sb.AppendFormat("Volume UUID: {0}", nilfsSb.uuid).AppendLine(); sb.AppendFormat("Volume UUID: {0}", nilfsSb.uuid).AppendLine();
sb.AppendFormat("Volume name: {0}", StringHandlers.CToString(nilfsSb.volume_name, currentEncoding)) sb.AppendFormat("Volume name: {0}", StringHandlers.CToString(nilfsSb.volume_name, Encoding)).AppendLine();
.AppendLine();
sb.AppendFormat("Volume created on {0}", DateHandlers.UnixUnsignedToDateTime(nilfsSb.ctime)).AppendLine(); sb.AppendFormat("Volume created on {0}", DateHandlers.UnixUnsignedToDateTime(nilfsSb.ctime)).AppendLine();
sb.AppendFormat("Volume last mounted on {0}", DateHandlers.UnixUnsignedToDateTime(nilfsSb.mtime)) sb.AppendFormat("Volume last mounted on {0}", DateHandlers.UnixUnsignedToDateTime(nilfsSb.mtime))
.AppendLine(); .AppendLine();
@@ -124,19 +120,19 @@ namespace DiscImageChef.Filesystems
information = sb.ToString(); information = sb.ToString();
xmlFsType = new FileSystemType XmlFsType = new FileSystemType
{ {
Type = "NILFS2 filesystem", Type = "NILFS2 filesystem",
ClusterSize = 1 << (int)(nilfsSb.log_block_size + 10), ClusterSize = 1 << (int)(nilfsSb.log_block_size + 10),
VolumeName = StringHandlers.CToString(nilfsSb.volume_name, currentEncoding), VolumeName = StringHandlers.CToString(nilfsSb.volume_name, Encoding),
VolumeSerial = nilfsSb.uuid.ToString(), VolumeSerial = nilfsSb.uuid.ToString(),
CreationDate = DateHandlers.UnixUnsignedToDateTime(nilfsSb.ctime), CreationDate = DateHandlers.UnixUnsignedToDateTime(nilfsSb.ctime),
CreationDateSpecified = true, CreationDateSpecified = true,
ModificationDate = DateHandlers.UnixUnsignedToDateTime(nilfsSb.wtime), ModificationDate = DateHandlers.UnixUnsignedToDateTime(nilfsSb.wtime),
ModificationDateSpecified = true ModificationDateSpecified = true
}; };
if(nilfsSb.creator_os == 0) xmlFsType.SystemIdentifier = "Linux"; if(nilfsSb.creator_os == 0) XmlFsType.SystemIdentifier = "Linux";
xmlFsType.Clusters = (long)nilfsSb.dev_size / xmlFsType.ClusterSize; XmlFsType.Clusters = (long)nilfsSb.dev_size / XmlFsType.ClusterSize;
} }
enum NILFS2_State : ushort enum NILFS2_State : ushort

24
DiscImageChef.Filesystems/NTFS.cs
View File

@@ -31,7 +31,6 @@
// ****************************************************************************/ // ****************************************************************************/
using System; using System;
using System.Collections.Generic;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
using System.Text; using System.Text;
using DiscImageChef.Checksums; using DiscImageChef.Checksums;
@@ -44,10 +43,8 @@ namespace DiscImageChef.Filesystems
// Information from Inside Windows NT // Information from Inside Windows NT
public class NTFS : IFilesystem public class NTFS : IFilesystem
{ {
Encoding currentEncoding; public FileSystemType XmlFsType { get; private set; }
FileSystemType xmlFsType; public Encoding Encoding { get; private set; }
public FileSystemType XmlFsType => xmlFsType;
public Encoding Encoding => currentEncoding;
public string Name => "New Technology File System (NTFS)"; public string Name => "New Technology File System (NTFS)";
public Guid Id => new Guid("33513B2C-1e6d-4d21-a660-0bbc789c3871"); public Guid Id => new Guid("33513B2C-1e6d-4d21-a660-0bbc789c3871");
@@ -79,9 +76,10 @@ namespace DiscImageChef.Filesystems
return signature == 0xAA55; return signature == 0xAA55;
} }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, Encoding encoding) public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding)
{ {
currentEncoding = Encoding.Unicode; Encoding = Encoding.Unicode;
information = ""; information = "";
StringBuilder sb = new StringBuilder(); StringBuilder sb = new StringBuilder();
@@ -125,11 +123,11 @@ namespace DiscImageChef.Filesystems
sb.AppendFormat("Volume serial number: {0:X16}", ntfsBb.serial_no).AppendLine(); sb.AppendFormat("Volume serial number: {0:X16}", ntfsBb.serial_no).AppendLine();
// sb.AppendFormat("Signature 2: 0x{0:X4}", ntfs_bb.signature2).AppendLine(); // sb.AppendFormat("Signature 2: 0x{0:X4}", ntfs_bb.signature2).AppendLine();
xmlFsType = new FileSystemType(); XmlFsType = new FileSystemType();
if(ntfsBb.jump[0] == 0xEB && ntfsBb.jump[1] > 0x4E && ntfsBb.jump[1] < 0x80 && ntfsBb.signature2 == 0xAA55) if(ntfsBb.jump[0] == 0xEB && ntfsBb.jump[1] > 0x4E && ntfsBb.jump[1] < 0x80 && ntfsBb.signature2 == 0xAA55)
{ {
xmlFsType.Bootable = true; XmlFsType.Bootable = true;
Sha1Context sha1Ctx = new Sha1Context(); Sha1Context sha1Ctx = new Sha1Context();
sha1Ctx.Init(); sha1Ctx.Init();
string bootChk = sha1Ctx.Data(ntfsBb.boot_code, out _); string bootChk = sha1Ctx.Data(ntfsBb.boot_code, out _);
@@ -137,10 +135,10 @@ namespace DiscImageChef.Filesystems
sb.AppendFormat("Boot code's SHA1: {0}", bootChk).AppendLine(); sb.AppendFormat("Boot code's SHA1: {0}", bootChk).AppendLine();
} }
xmlFsType.ClusterSize = ntfsBb.spc * ntfsBb.bps; XmlFsType.ClusterSize = ntfsBb.spc * ntfsBb.bps;
xmlFsType.Clusters = ntfsBb.sectors / ntfsBb.spc; XmlFsType.Clusters = ntfsBb.sectors / ntfsBb.spc;
xmlFsType.VolumeSerial = $"{ntfsBb.serial_no:X16}"; XmlFsType.VolumeSerial = $"{ntfsBb.serial_no:X16}";
xmlFsType.Type = "NTFS"; XmlFsType.Type = "NTFS";
information = sb.ToString(); information = sb.ToString();
} }

29
DiscImageChef.Filesystems/Nintendo.cs
View File

@@ -31,7 +31,6 @@
// ****************************************************************************/ // ****************************************************************************/
using System; using System;
using System.Collections.Generic;
using System.Text; using System.Text;
using DiscImageChef.CommonTypes; using DiscImageChef.CommonTypes;
using DiscImageChef.Console; using DiscImageChef.Console;
@@ -42,11 +41,8 @@ namespace DiscImageChef.Filesystems
{ {
public class NintendoPlugin : IFilesystem public class NintendoPlugin : IFilesystem
{ {
Encoding currentEncoding; public FileSystemType XmlFsType { get; private set; }
FileSystemType xmlFsType; public Encoding Encoding { get; private set; }
public FileSystemType XmlFsType => xmlFsType;
public Encoding Encoding => currentEncoding;
public string Name => "Nintendo optical filesystems"; public string Name => "Nintendo optical filesystems";
public Guid Id => new Guid("4675fcb4-4418-4288-9e4a-33d6a4ac1126"); public Guid Id => new Guid("4675fcb4-4418-4288-9e4a-33d6a4ac1126");
@@ -66,12 +62,13 @@ namespace DiscImageChef.Filesystems
return magicGc == 0xC2339F3D || magicWii == 0x5D1C9EA3; return magicGc == 0xC2339F3D || magicWii == 0x5D1C9EA3;
} }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, Encoding encoding) public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding)
{ {
currentEncoding = encoding ?? Encoding.GetEncoding("shift_jis"); Encoding = encoding ?? Encoding.GetEncoding("shift_jis");
StringBuilder sbInformation = new StringBuilder(); StringBuilder sbInformation = new StringBuilder();
information = ""; information = "";
xmlFsType = new FileSystemType(); XmlFsType = new FileSystemType();
NintendoFields fields = new NintendoFields(); NintendoFields fields = new NintendoFields();
BigEndianBitConverter.IsLittleEndian = BitConverter.IsLittleEndian; BigEndianBitConverter.IsLittleEndian = BitConverter.IsLittleEndian;
@@ -97,7 +94,7 @@ namespace DiscImageChef.Filesystems
fields.StreamBufferSize = header[9]; fields.StreamBufferSize = header[9];
byte[] temp = new byte[64]; byte[] temp = new byte[64];
Array.Copy(header, 0x20, temp, 0, 64); Array.Copy(header, 0x20, temp, 0, 64);
fields.Title = StringHandlers.CToString(temp, currentEncoding); fields.Title = StringHandlers.CToString(temp, Encoding);
if(!wii) if(!wii)
{ {
@@ -291,12 +288,12 @@ namespace DiscImageChef.Filesystems
.AppendLine(); .AppendLine();
information = sbInformation.ToString(); information = sbInformation.ToString();
xmlFsType.Bootable = true; XmlFsType.Bootable = true;
xmlFsType.Clusters = (long)(imagePlugin.Info.Sectors * imagePlugin.Info.SectorSize / 2048); XmlFsType.Clusters = (long)(imagePlugin.Info.Sectors * imagePlugin.Info.SectorSize / 2048);
xmlFsType.ClusterSize = 2048; XmlFsType.ClusterSize = 2048;
xmlFsType.Type = wii ? "Nintendo Wii filesystem" : "Nintendo Gamecube filesystem"; XmlFsType.Type = wii ? "Nintendo Wii filesystem" : "Nintendo Gamecube filesystem";
xmlFsType.VolumeName = fields.Title; XmlFsType.VolumeName = fields.Title;
xmlFsType.VolumeSerial = fields.DiscId; XmlFsType.VolumeSerial = fields.DiscId;
} }
static string DiscTypeToString(string discType) static string DiscTypeToString(string discType)

39
DiscImageChef.Filesystems/ODS.cs
View File

@@ -31,7 +31,6 @@
// ****************************************************************************/ // ****************************************************************************/
using System; using System;
using System.Collections.Generic;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
using System.Text; using System.Text;
using DiscImageChef.CommonTypes; using DiscImageChef.CommonTypes;
@@ -52,11 +51,8 @@ namespace DiscImageChef.Filesystems
// TODO: Implement checksum // TODO: Implement checksum
public class ODS : IFilesystem public class ODS : IFilesystem
{ {
Encoding currentEncoding; public FileSystemType XmlFsType { get; private set; }
FileSystemType xmlFsType; public Encoding Encoding { get; private set; }
public FileSystemType XmlFsType => xmlFsType;
public Encoding Encoding => currentEncoding;
public string Name => "Files-11 On-Disk Structure"; public string Name => "Files-11 On-Disk Structure";
public Guid Id => new Guid("de20633c-8021-4384-aeb0-83b0df14491f"); public Guid Id => new Guid("de20633c-8021-4384-aeb0-83b0df14491f");
@@ -91,9 +87,10 @@ namespace DiscImageChef.Filesystems
return magic == "DECFILE11A " || magic == "DECFILE11B "; return magic == "DECFILE11A " || magic == "DECFILE11B ";
} }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, Encoding encoding) public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding)
{ {
currentEncoding = encoding ?? Encoding.GetEncoding("iso-8859-1"); Encoding = encoding ?? Encoding.GetEncoding("iso-8859-1");
information = ""; information = "";
StringBuilder sb = new StringBuilder(); StringBuilder sb = new StringBuilder();
@@ -129,8 +126,8 @@ namespace DiscImageChef.Filesystems
sb.AppendLine("The following information may be incorrect for this volume."); sb.AppendLine("The following information may be incorrect for this volume.");
if(homeblock.resfiles < 5 || homeblock.devtype != 0) sb.AppendLine("This volume may be corrupted."); if(homeblock.resfiles < 5 || homeblock.devtype != 0) sb.AppendLine("This volume may be corrupted.");
sb.AppendFormat("Volume format is {0}", sb.AppendFormat("Volume format is {0}", StringHandlers.SpacePaddedToString(homeblock.format, Encoding))
StringHandlers.SpacePaddedToString(homeblock.format, currentEncoding)).AppendLine(); .AppendLine();
sb.AppendFormat("Volume is Level {0} revision {1}", (homeblock.struclev & 0xFF00) >> 8, sb.AppendFormat("Volume is Level {0} revision {1}", (homeblock.struclev & 0xFF00) >> 8,
homeblock.struclev & 0xFF).AppendLine(); homeblock.struclev & 0xFF).AppendLine();
sb.AppendFormat("Lowest structure in the volume is Level {0}, revision {1}", sb.AppendFormat("Lowest structure in the volume is Level {0}, revision {1}",
@@ -154,12 +151,12 @@ namespace DiscImageChef.Filesystems
if(homeblock.rvn > 0 && homeblock.setcount > 0 && if(homeblock.rvn > 0 && homeblock.setcount > 0 &&
StringHandlers.CToString(homeblock.strucname) != " ") StringHandlers.CToString(homeblock.strucname) != " ")
sb.AppendFormat("Volume is {0} of {1} in set \"{2}\".", homeblock.rvn, homeblock.setcount, sb.AppendFormat("Volume is {0} of {1} in set \"{2}\".", homeblock.rvn, homeblock.setcount,
StringHandlers.SpacePaddedToString(homeblock.strucname, currentEncoding)).AppendLine(); StringHandlers.SpacePaddedToString(homeblock.strucname, Encoding)).AppendLine();
sb.AppendFormat("Volume owner is \"{0}\" (ID 0x{1:X8})", sb.AppendFormat("Volume owner is \"{0}\" (ID 0x{1:X8})",
StringHandlers.SpacePaddedToString(homeblock.ownername, currentEncoding), StringHandlers.SpacePaddedToString(homeblock.ownername, Encoding), homeblock.volowner)
homeblock.volowner).AppendLine(); .AppendLine();
sb.AppendFormat("Volume label: \"{0}\"", sb.AppendFormat("Volume label: \"{0}\"", StringHandlers.SpacePaddedToString(homeblock.volname, Encoding))
StringHandlers.SpacePaddedToString(homeblock.volname, currentEncoding)).AppendLine(); .AppendLine();
sb.AppendFormat("Drive serial number: 0x{0:X8}", homeblock.serialnum).AppendLine(); sb.AppendFormat("Drive serial number: 0x{0:X8}", homeblock.serialnum).AppendLine();
sb.AppendFormat("Volume was created on {0}", DateHandlers.VmsToDateTime(homeblock.credate)).AppendLine(); sb.AppendFormat("Volume was created on {0}", DateHandlers.VmsToDateTime(homeblock.credate)).AppendLine();
if(homeblock.revdate > 0) if(homeblock.revdate > 0)
@@ -207,23 +204,23 @@ namespace DiscImageChef.Filesystems
sb.AppendFormat("File protection: 0x{0:X4}", homeblock.fileprot).AppendLine(); sb.AppendFormat("File protection: 0x{0:X4}", homeblock.fileprot).AppendLine();
sb.AppendFormat("Record protection: 0x{0:X4}", homeblock.recprot).AppendLine(); sb.AppendFormat("Record protection: 0x{0:X4}", homeblock.recprot).AppendLine();
xmlFsType = new FileSystemType XmlFsType = new FileSystemType
{ {
Type = "FILES-11", Type = "FILES-11",
ClusterSize = homeblock.cluster * 512, ClusterSize = homeblock.cluster * 512,
Clusters = (long)partition.Size / (homeblock.cluster * 512), Clusters = (long)partition.Size / (homeblock.cluster * 512),
VolumeName = StringHandlers.SpacePaddedToString(homeblock.volname, currentEncoding), VolumeName = StringHandlers.SpacePaddedToString(homeblock.volname, Encoding),
VolumeSerial = $"{homeblock.serialnum:X8}" VolumeSerial = $"{homeblock.serialnum:X8}"
}; };
if(homeblock.credate > 0) if(homeblock.credate > 0)
{ {
xmlFsType.CreationDate = DateHandlers.VmsToDateTime(homeblock.credate); XmlFsType.CreationDate = DateHandlers.VmsToDateTime(homeblock.credate);
xmlFsType.CreationDateSpecified = true; XmlFsType.CreationDateSpecified = true;
} }
if(homeblock.revdate > 0) if(homeblock.revdate > 0)
{ {
xmlFsType.ModificationDate = DateHandlers.VmsToDateTime(homeblock.revdate); XmlFsType.ModificationDate = DateHandlers.VmsToDateTime(homeblock.revdate);
xmlFsType.ModificationDateSpecified = true; XmlFsType.ModificationDateSpecified = true;
} }
information = sb.ToString(); information = sb.ToString();

29
DiscImageChef.Filesystems/Opera.cs
View File

@@ -31,7 +31,6 @@
// ****************************************************************************/ // ****************************************************************************/
using System; using System;
using System.Collections.Generic;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
using System.Text; using System.Text;
using DiscImageChef.CommonTypes; using DiscImageChef.CommonTypes;
@@ -42,11 +41,8 @@ namespace DiscImageChef.Filesystems
{ {
public class OperaFS : IFilesystem public class OperaFS : IFilesystem
{ {
Encoding currentEncoding; public FileSystemType XmlFsType { get; private set; }
FileSystemType xmlFsType; public Encoding Encoding { get; private set; }
public FileSystemType XmlFsType => xmlFsType;
public Encoding Encoding => currentEncoding;
public string Name => "Opera Filesystem Plugin"; public string Name => "Opera Filesystem Plugin";
public Guid Id => new Guid("0ec84ec7-eae6-4196-83fe-943b3fe46dbd"); public Guid Id => new Guid("0ec84ec7-eae6-4196-83fe-943b3fe46dbd");
@@ -67,10 +63,11 @@ namespace DiscImageChef.Filesystems
return Encoding.ASCII.GetString(syncBytes) == "ZZZZZ"; return Encoding.ASCII.GetString(syncBytes) == "ZZZZZ";
} }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, Encoding encoding) public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding)
{ {
// TODO: Find correct default encoding // TODO: Find correct default encoding
currentEncoding = Encoding.ASCII; Encoding = Encoding.ASCII;
information = ""; information = "";
StringBuilder superBlockMetadata = new StringBuilder(); StringBuilder superBlockMetadata = new StringBuilder();
@@ -83,14 +80,14 @@ namespace DiscImageChef.Filesystems
if(Encoding.ASCII.GetString(sb.sync_bytes) != "ZZZZZ") return; if(Encoding.ASCII.GetString(sb.sync_bytes) != "ZZZZZ") return;
superBlockMetadata.AppendFormat("Opera filesystem disc.").AppendLine(); superBlockMetadata.AppendFormat("Opera filesystem disc.").AppendLine();
if(!string.IsNullOrEmpty(StringHandlers.CToString(sb.volume_label, currentEncoding))) if(!string.IsNullOrEmpty(StringHandlers.CToString(sb.volume_label, Encoding)))
superBlockMetadata superBlockMetadata
.AppendFormat("Volume label: {0}", StringHandlers.CToString(sb.volume_label, currentEncoding)) .AppendFormat("Volume label: {0}", StringHandlers.CToString(sb.volume_label, Encoding))
.AppendLine();
if(!string.IsNullOrEmpty(StringHandlers.CToString(sb.volume_comment, Encoding)))
superBlockMetadata
.AppendFormat("Volume comment: {0}", StringHandlers.CToString(sb.volume_comment, Encoding))
.AppendLine(); .AppendLine();
if(!string.IsNullOrEmpty(StringHandlers.CToString(sb.volume_comment, currentEncoding)))
superBlockMetadata.AppendFormat("Volume comment: {0}",
StringHandlers.CToString(sb.volume_comment, currentEncoding))
.AppendLine();
superBlockMetadata.AppendFormat("Volume identifier: 0x{0:X8}", sb.volume_id).AppendLine(); superBlockMetadata.AppendFormat("Volume identifier: 0x{0:X8}", sb.volume_id).AppendLine();
superBlockMetadata.AppendFormat("Block size: {0} bytes", sb.block_size).AppendLine(); superBlockMetadata.AppendFormat("Block size: {0} bytes", sb.block_size).AppendLine();
if(imagePlugin.Info.SectorSize == 2336 || imagePlugin.Info.SectorSize == 2352 || if(imagePlugin.Info.SectorSize == 2336 || imagePlugin.Info.SectorSize == 2352 ||
@@ -120,10 +117,10 @@ namespace DiscImageChef.Filesystems
information = superBlockMetadata.ToString(); information = superBlockMetadata.ToString();
xmlFsType = new FileSystemType XmlFsType = new FileSystemType
{ {
Type = "Opera", Type = "Opera",
VolumeName = StringHandlers.CToString(sb.volume_label, currentEncoding), VolumeName = StringHandlers.CToString(sb.volume_label, Encoding),
ClusterSize = sb.block_size, ClusterSize = sb.block_size,
Clusters = sb.block_count Clusters = sb.block_count
}; };

13
DiscImageChef.Filesystems/PCEngine.cs
View File

@@ -31,7 +31,6 @@
// ****************************************************************************/ // ****************************************************************************/
using System; using System;
using System.Collections.Generic;
using System.Text; using System.Text;
using DiscImageChef.CommonTypes; using DiscImageChef.CommonTypes;
using DiscImageChef.DiscImages; using DiscImageChef.DiscImages;
@@ -41,10 +40,8 @@ namespace DiscImageChef.Filesystems
{ {
public class PCEnginePlugin : IFilesystem public class PCEnginePlugin : IFilesystem
{ {
Encoding currentEncoding; public FileSystemType XmlFsType { get; private set; }
FileSystemType xmlFsType; public Encoding Encoding { get; private set; }
public FileSystemType XmlFsType => xmlFsType;
public Encoding Encoding => currentEncoding;
public string Name => "PC Engine CD Plugin"; public string Name => "PC Engine CD Plugin";
public Guid Id => new Guid("e5ee6d7c-90fa-49bd-ac89-14ef750b8af3"); public Guid Id => new Guid("e5ee6d7c-90fa-49bd-ac89-14ef750b8af3");
@@ -61,11 +58,11 @@ namespace DiscImageChef.Filesystems
} }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding) Encoding encoding)
{ {
currentEncoding = encoding ?? Encoding.GetEncoding("shift_jis"); Encoding = encoding ?? Encoding.GetEncoding("shift_jis");
information = ""; information = "";
xmlFsType = new FileSystemType XmlFsType = new FileSystemType
{ {
Type = "PC Engine filesystem", Type = "PC Engine filesystem",
Clusters = (long)((partition.End - partition.Start + 1) / imagePlugin.Info.SectorSize * 2048), Clusters = (long)((partition.End - partition.Start + 1) / imagePlugin.Info.SectorSize * 2048),

40
DiscImageChef.Filesystems/PFS.cs
View File

@@ -31,7 +31,6 @@
// ****************************************************************************/ // ****************************************************************************/
using System; using System;
using System.Collections.Generic;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
using System.Text; using System.Text;
using DiscImageChef.CommonTypes; using DiscImageChef.CommonTypes;
@@ -63,11 +62,8 @@ namespace DiscImageChef.Filesystems
/// </summary> /// </summary>
const uint MUPFS_DISK = 0x6D755046; const uint MUPFS_DISK = 0x6D755046;
Encoding currentEncoding; public FileSystemType XmlFsType { get; private set; }
FileSystemType xmlFsType; public Encoding Encoding { get; private set; }
public FileSystemType XmlFsType => xmlFsType;
public Encoding Encoding => currentEncoding;
public string Name => "Professional File System"; public string Name => "Professional File System";
public Guid Id => new Guid("68DE769E-D957-406A-8AE4-3781CA8CDA77"); public Guid Id => new Guid("68DE769E-D957-406A-8AE4-3781CA8CDA77");
@@ -85,30 +81,31 @@ namespace DiscImageChef.Filesystems
magic == MUPFS_DISK; magic == MUPFS_DISK;
} }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, Encoding encoding) public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding)
{ {
currentEncoding = encoding ?? Encoding.GetEncoding("iso-8859-1"); Encoding = encoding ?? Encoding.GetEncoding("iso-8859-1");
byte[] rootBlockSector = imagePlugin.ReadSector(2 + partition.Start); byte[] rootBlockSector = imagePlugin.ReadSector(2 + partition.Start);
RootBlock rootBlock = BigEndianMarshal.ByteArrayToStructureBigEndian<RootBlock>(rootBlockSector); RootBlock rootBlock = BigEndianMarshal.ByteArrayToStructureBigEndian<RootBlock>(rootBlockSector);
StringBuilder sbInformation = new StringBuilder(); StringBuilder sbInformation = new StringBuilder();
xmlFsType = new FileSystemType(); XmlFsType = new FileSystemType();
switch(rootBlock.diskType) switch(rootBlock.diskType)
{ {
case AFS_DISK: case AFS_DISK:
case MUAF_DISK: case MUAF_DISK:
sbInformation.Append("Professional File System v1"); sbInformation.Append("Professional File System v1");
xmlFsType.Type = "PFS v1"; XmlFsType.Type = "PFS v1";
break; break;
case PFS2_DISK: case PFS2_DISK:
sbInformation.Append("Professional File System v2"); sbInformation.Append("Professional File System v2");
xmlFsType.Type = "PFS v2"; XmlFsType.Type = "PFS v2";
break; break;
case PFS_DISK: case PFS_DISK:
case MUPFS_DISK: case MUPFS_DISK:
sbInformation.Append("Professional File System v3"); sbInformation.Append("Professional File System v3");
xmlFsType.Type = "PFS v3"; XmlFsType.Type = "PFS v3";
break; break;
} }
@@ -117,9 +114,8 @@ namespace DiscImageChef.Filesystems
sbInformation.AppendLine(); sbInformation.AppendLine();
sbInformation sbInformation.AppendFormat("Volume name: {0}", StringHandlers.PascalToString(rootBlock.diskname, Encoding))
.AppendFormat("Volume name: {0}", StringHandlers.PascalToString(rootBlock.diskname, currentEncoding)) .AppendLine();
.AppendLine();
sbInformation.AppendFormat("Volume has {0} free sectors of {1}", rootBlock.blocksfree, rootBlock.diskSize) sbInformation.AppendFormat("Volume has {0} free sectors of {1}", rootBlock.blocksfree, rootBlock.diskSize)
.AppendLine(); .AppendLine();
sbInformation.AppendFormat("Volume created on {0}", sbInformation.AppendFormat("Volume created on {0}",
@@ -131,14 +127,14 @@ namespace DiscImageChef.Filesystems
information = sbInformation.ToString(); information = sbInformation.ToString();
xmlFsType.CreationDate = XmlFsType.CreationDate =
DateHandlers.AmigaToDateTime(rootBlock.creationday, rootBlock.creationminute, rootBlock.creationtick); DateHandlers.AmigaToDateTime(rootBlock.creationday, rootBlock.creationminute, rootBlock.creationtick);
xmlFsType.CreationDateSpecified = true; XmlFsType.CreationDateSpecified = true;
xmlFsType.FreeClusters = rootBlock.blocksfree; XmlFsType.FreeClusters = rootBlock.blocksfree;
xmlFsType.FreeClustersSpecified = true; XmlFsType.FreeClustersSpecified = true;
xmlFsType.Clusters = rootBlock.diskSize; XmlFsType.Clusters = rootBlock.diskSize;
xmlFsType.ClusterSize = (int)imagePlugin.Info.SectorSize; XmlFsType.ClusterSize = (int)imagePlugin.Info.SectorSize;
xmlFsType.VolumeName = StringHandlers.PascalToString(rootBlock.diskname, currentEncoding); XmlFsType.VolumeName = StringHandlers.PascalToString(rootBlock.diskname, Encoding);
} }
/// <summary> /// <summary>

35
DiscImageChef.Filesystems/ProDOS.cs
View File

@@ -31,7 +31,6 @@
// ****************************************************************************/ // ****************************************************************************/
using System; using System;
using System.Collections.Generic;
using System.Linq; using System.Linq;
using System.Text; using System.Text;
using Claunia.Encoding; using Claunia.Encoding;
@@ -84,11 +83,8 @@ namespace DiscImageChef.Filesystems
const byte ENTRY_LENGTH = 0x27; const byte ENTRY_LENGTH = 0x27;
const byte ENTRIES_PER_BLOCK = 0x0D; const byte ENTRIES_PER_BLOCK = 0x0D;
Encoding currentEncoding; public FileSystemType XmlFsType { get; private set; }
FileSystemType xmlFsType; public Encoding Encoding { get; private set; }
public FileSystemType XmlFsType => xmlFsType;
public Encoding Encoding => currentEncoding;
public string Name => "Apple ProDOS filesystem"; public string Name => "Apple ProDOS filesystem";
public Guid Id => new Guid("43874265-7B8A-4739-BCF7-07F80D5932BF"); public Guid Id => new Guid("43874265-7B8A-4739-BCF7-07F80D5932BF");
@@ -154,10 +150,11 @@ namespace DiscImageChef.Filesystems
return totalBlocks <= partition.End - partition.Start + 1; return totalBlocks <= partition.End - partition.Start + 1;
} }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, Encoding encoding) public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding)
{ {
// TODO: Until Apple ][ encoding is implemented // TODO: Until Apple ][ encoding is implemented
currentEncoding = new LisaRoman(); Encoding = new LisaRoman();
StringBuilder sbInformation = new StringBuilder(); StringBuilder sbInformation = new StringBuilder();
// Blocks 0 and 1 are boot code // Blocks 0 and 1 are boot code
@@ -201,7 +198,7 @@ namespace DiscImageChef.Filesystems
rootDirectoryKeyBlock.header.name_length = (byte)(rootDirectoryKeyBlockBytes[0x04] & NAME_LENGTH_MASK); rootDirectoryKeyBlock.header.name_length = (byte)(rootDirectoryKeyBlockBytes[0x04] & NAME_LENGTH_MASK);
byte[] temporal = new byte[rootDirectoryKeyBlock.header.name_length]; byte[] temporal = new byte[rootDirectoryKeyBlock.header.name_length];
Array.Copy(rootDirectoryKeyBlockBytes, 0x05, temporal, 0, rootDirectoryKeyBlock.header.name_length); Array.Copy(rootDirectoryKeyBlockBytes, 0x05, temporal, 0, rootDirectoryKeyBlock.header.name_length);
rootDirectoryKeyBlock.header.volume_name = currentEncoding.GetString(temporal); rootDirectoryKeyBlock.header.volume_name = Encoding.GetString(temporal);
rootDirectoryKeyBlock.header.reserved = BitConverter.ToUInt64(rootDirectoryKeyBlockBytes, 0x14); rootDirectoryKeyBlock.header.reserved = BitConverter.ToUInt64(rootDirectoryKeyBlockBytes, 0x14);
ushort tempTimestampLeft = BitConverter.ToUInt16(rootDirectoryKeyBlockBytes, 0x1C); ushort tempTimestampLeft = BitConverter.ToUInt16(rootDirectoryKeyBlockBytes, 0x1C);
@@ -296,19 +293,19 @@ namespace DiscImageChef.Filesystems
information = sbInformation.ToString(); information = sbInformation.ToString();
xmlFsType = new FileSystemType(); XmlFsType = new FileSystemType();
xmlFsType.VolumeName = rootDirectoryKeyBlock.header.volume_name; XmlFsType.VolumeName = rootDirectoryKeyBlock.header.volume_name;
if(dateCorrect) if(dateCorrect)
{ {
xmlFsType.CreationDate = rootDirectoryKeyBlock.header.creation_time; XmlFsType.CreationDate = rootDirectoryKeyBlock.header.creation_time;
xmlFsType.CreationDateSpecified = true; XmlFsType.CreationDateSpecified = true;
} }
xmlFsType.Files = rootDirectoryKeyBlock.header.file_count; XmlFsType.Files = rootDirectoryKeyBlock.header.file_count;
xmlFsType.FilesSpecified = true; XmlFsType.FilesSpecified = true;
xmlFsType.Clusters = rootDirectoryKeyBlock.header.total_blocks; XmlFsType.Clusters = rootDirectoryKeyBlock.header.total_blocks;
xmlFsType.ClusterSize = (int)((partition.End - partition.Start + 1) * imagePlugin.Info.SectorSize / XmlFsType.ClusterSize = (int)((partition.End - partition.Start + 1) * imagePlugin.Info.SectorSize /
(ulong)xmlFsType.Clusters); (ulong)XmlFsType.Clusters);
xmlFsType.Type = "ProDOS"; XmlFsType.Type = "ProDOS";
} }
/// <summary> /// <summary>

15
DiscImageChef.Filesystems/QNX4.cs
View File

@@ -31,7 +31,6 @@
// ****************************************************************************/ // ****************************************************************************/
using System; using System;
using System.Collections.Generic;
using System.Linq; using System.Linq;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
using System.Text; using System.Text;
@@ -46,10 +45,8 @@ namespace DiscImageChef.Filesystems
readonly byte[] QNX4_RootDir_Fname = readonly byte[] QNX4_RootDir_Fname =
{0x2F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; {0x2F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
Encoding currentEncoding; public FileSystemType XmlFsType { get; private set; }
FileSystemType xmlFsType; public Encoding Encoding { get; private set; }
public FileSystemType XmlFsType => xmlFsType;
public Encoding Encoding => currentEncoding;
public string Name => "QNX4 Plugin"; public string Name => "QNX4 Plugin";
public Guid Id => new Guid("E73A63FA-B5B0-48BF-BF82-DA5F0A8170D2"); public Guid Id => new Guid("E73A63FA-B5B0-48BF-BF82-DA5F0A8170D2");
@@ -87,9 +84,9 @@ namespace DiscImageChef.Filesystems
} }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding) Encoding encoding)
{ {
currentEncoding = encoding ?? Encoding.GetEncoding("iso-8859-15"); Encoding = encoding ?? Encoding.GetEncoding("iso-8859-15");
information = ""; information = "";
byte[] sector = imagePlugin.ReadSector(partition.Start + 1); byte[] sector = imagePlugin.ReadSector(partition.Start + 1);
if(sector.Length < 512) return; if(sector.Length < 512) return;
@@ -177,7 +174,7 @@ namespace DiscImageChef.Filesystems
information = information =
$"QNX4 filesystem\nCreated on {DateHandlers.UnixUnsignedToDateTime(qnxSb.rootDir.di_ftime)}\n"; $"QNX4 filesystem\nCreated on {DateHandlers.UnixUnsignedToDateTime(qnxSb.rootDir.di_ftime)}\n";
xmlFsType = new FileSystemType XmlFsType = new FileSystemType
{ {
Type = "QNX4 filesystem", Type = "QNX4 filesystem",
Clusters = (long)partition.Length, Clusters = (long)partition.Length,
@@ -187,7 +184,7 @@ namespace DiscImageChef.Filesystems
ModificationDate = DateHandlers.UnixUnsignedToDateTime(qnxSb.rootDir.di_mtime), ModificationDate = DateHandlers.UnixUnsignedToDateTime(qnxSb.rootDir.di_mtime),
ModificationDateSpecified = true ModificationDateSpecified = true
}; };
xmlFsType.Bootable |= qnxSb.boot.di_size != 0 || qnxSb.altBoot.di_size != 0; XmlFsType.Bootable |= qnxSb.boot.di_size != 0 || qnxSb.altBoot.di_size != 0;
} }
struct QNX4_Extent struct QNX4_Extent

15
DiscImageChef.Filesystems/QNX6.cs
View File

@@ -31,7 +31,6 @@
// ****************************************************************************/ // ****************************************************************************/
using System; using System;
using System.Collections.Generic;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
using System.Text; using System.Text;
using DiscImageChef.CommonTypes; using DiscImageChef.CommonTypes;
@@ -46,10 +45,8 @@ namespace DiscImageChef.Filesystems
const uint QNX6_BOOT_BLOCKS_SIZE = 0x2000; const uint QNX6_BOOT_BLOCKS_SIZE = 0x2000;
const uint QNX6_MAGIC = 0x68191122; const uint QNX6_MAGIC = 0x68191122;
Encoding currentEncoding; public FileSystemType XmlFsType { get; private set; }
FileSystemType xmlFsType; public Encoding Encoding { get; private set; }
public FileSystemType XmlFsType => xmlFsType;
public Encoding Encoding => currentEncoding;
public string Name => "QNX6 Plugin"; public string Name => "QNX6 Plugin";
public Guid Id => new Guid("3E610EA2-4D08-4D70-8947-830CD4C74FC0"); public Guid Id => new Guid("3E610EA2-4D08-4D70-8947-830CD4C74FC0");
@@ -80,9 +77,9 @@ namespace DiscImageChef.Filesystems
} }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding) Encoding encoding)
{ {
currentEncoding = encoding ?? Encoding.GetEncoding("iso-8859-15"); Encoding = encoding ?? Encoding.GetEncoding("iso-8859-15");
information = ""; information = "";
StringBuilder sb = new StringBuilder(); StringBuilder sb = new StringBuilder();
uint sectors = QNX6_SUPER_BLOCK_SIZE / imagePlugin.Info.SectorSize; uint sectors = QNX6_SUPER_BLOCK_SIZE / imagePlugin.Info.SectorSize;
@@ -117,7 +114,7 @@ namespace DiscImageChef.Filesystems
audiSb.freeBlocks * audiSb.blockSize, audiSb.numBlocks, audiSb.freeBlocks * audiSb.blockSize, audiSb.numBlocks,
audiSb.numBlocks * audiSb.blockSize).AppendLine(); audiSb.numBlocks * audiSb.blockSize).AppendLine();
xmlFsType = new FileSystemType XmlFsType = new FileSystemType
{ {
Type = "QNX6 (Audi) filesystem", Type = "QNX6 (Audi) filesystem",
Clusters = audiSb.numBlocks, Clusters = audiSb.numBlocks,
@@ -150,7 +147,7 @@ namespace DiscImageChef.Filesystems
qnxSb.freeBlocks * qnxSb.blockSize, qnxSb.numBlocks, qnxSb.numBlocks * qnxSb.blockSize) qnxSb.freeBlocks * qnxSb.blockSize, qnxSb.numBlocks, qnxSb.numBlocks * qnxSb.blockSize)
.AppendLine(); .AppendLine();
xmlFsType = new FileSystemType XmlFsType = new FileSystemType
{ {
Type = "QNX6 filesystem", Type = "QNX6 filesystem",
Clusters = qnxSb.numBlocks, Clusters = qnxSb.numBlocks,

28
DiscImageChef.Filesystems/RBF.cs
View File

@@ -31,7 +31,6 @@
// ****************************************************************************/ // ****************************************************************************/
using System; using System;
using System.Collections.Generic;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
using System.Text; using System.Text;
using DiscImageChef.CommonTypes; using DiscImageChef.CommonTypes;
@@ -47,11 +46,8 @@ namespace DiscImageChef.Filesystems
const uint RBF_SYNC = 0x4372757A; const uint RBF_SYNC = 0x4372757A;
const uint RBF_CNYS = 0x7A757243; const uint RBF_CNYS = 0x7A757243;
Encoding currentEncoding; public FileSystemType XmlFsType { get; private set; }
FileSystemType xmlFsType; public Encoding Encoding { get; private set; }
public FileSystemType XmlFsType => xmlFsType;
public Encoding Encoding => currentEncoding;
public string Name => "OS-9 Random Block File Plugin"; public string Name => "OS-9 Random Block File Plugin";
public Guid Id => new Guid("E864E45B-0B52-4D29-A858-7BDFA9199FB2"); public Guid Id => new Guid("E864E45B-0B52-4D29-A858-7BDFA9199FB2");
@@ -88,9 +84,10 @@ namespace DiscImageChef.Filesystems
return false; return false;
} }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, Encoding encoding) public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding)
{ {
currentEncoding = encoding ?? Encoding.GetEncoding("iso-8859-15"); Encoding = encoding ?? Encoding.GetEncoding("iso-8859-15");
information = ""; information = "";
if(imagePlugin.Info.SectorSize < 256) return; if(imagePlugin.Info.SectorSize < 256) return;
@@ -154,10 +151,10 @@ namespace DiscImageChef.Filesystems
.AppendLine(); .AppendLine();
sb.AppendFormat("Volume's identification block was last written on {0}", sb.AppendFormat("Volume's identification block was last written on {0}",
DateHandlers.UnixToDateTime(rbf9000Sb.rid_mtime)).AppendLine(); DateHandlers.UnixToDateTime(rbf9000Sb.rid_mtime)).AppendLine();
sb.AppendFormat("Volume name: {0}", StringHandlers.CToString(rbf9000Sb.rid_name, currentEncoding)) sb.AppendFormat("Volume name: {0}", StringHandlers.CToString(rbf9000Sb.rid_name, Encoding))
.AppendLine(); .AppendLine();
xmlFsType = new FileSystemType XmlFsType = new FileSystemType
{ {
Type = "OS-9 Random Block File", Type = "OS-9 Random Block File",
Bootable = rbf9000Sb.rid_bootfile > 0, Bootable = rbf9000Sb.rid_bootfile > 0,
@@ -167,7 +164,7 @@ namespace DiscImageChef.Filesystems
CreationDateSpecified = true, CreationDateSpecified = true,
ModificationDate = DateHandlers.UnixToDateTime(rbf9000Sb.rid_mtime), ModificationDate = DateHandlers.UnixToDateTime(rbf9000Sb.rid_mtime),
ModificationDateSpecified = true, ModificationDateSpecified = true,
VolumeName = StringHandlers.CToString(rbf9000Sb.rid_name, currentEncoding), VolumeName = StringHandlers.CToString(rbf9000Sb.rid_name, Encoding),
VolumeSerial = $"{rbf9000Sb.rid_diskid:X8}" VolumeSerial = $"{rbf9000Sb.rid_diskid:X8}"
}; };
} }
@@ -198,12 +195,11 @@ namespace DiscImageChef.Filesystems
sb.AppendFormat("Disk is owned by user {0}", rbfSb.dd_own).AppendLine(); sb.AppendFormat("Disk is owned by user {0}", rbfSb.dd_own).AppendLine();
sb.AppendFormat("Volume was created on {0}", DateHandlers.Os9ToDateTime(rbfSb.dd_dat)).AppendLine(); sb.AppendFormat("Volume was created on {0}", DateHandlers.Os9ToDateTime(rbfSb.dd_dat)).AppendLine();
sb.AppendFormat("Volume attributes: {0:X2}", rbfSb.dd_att).AppendLine(); sb.AppendFormat("Volume attributes: {0:X2}", rbfSb.dd_att).AppendLine();
sb.AppendFormat("Volume name: {0}", StringHandlers.CToString(rbfSb.dd_nam, currentEncoding)) sb.AppendFormat("Volume name: {0}", StringHandlers.CToString(rbfSb.dd_nam, Encoding)).AppendLine();
.AppendLine(); sb.AppendFormat("Path descriptor options: {0}", StringHandlers.CToString(rbfSb.dd_opt, Encoding))
sb.AppendFormat("Path descriptor options: {0}", StringHandlers.CToString(rbfSb.dd_opt, currentEncoding))
.AppendLine(); .AppendLine();
xmlFsType = new FileSystemType XmlFsType = new FileSystemType
{ {
Type = "OS-9 Random Block File", Type = "OS-9 Random Block File",
Bootable = LSNToUInt32(rbfSb.dd_bt) > 0 && rbfSb.dd_bsz > 0, Bootable = LSNToUInt32(rbfSb.dd_bt) > 0 && rbfSb.dd_bsz > 0,
@@ -211,7 +207,7 @@ namespace DiscImageChef.Filesystems
Clusters = LSNToUInt32(rbfSb.dd_tot), Clusters = LSNToUInt32(rbfSb.dd_tot),
CreationDate = DateHandlers.Os9ToDateTime(rbfSb.dd_dat), CreationDate = DateHandlers.Os9ToDateTime(rbfSb.dd_dat),
CreationDateSpecified = true, CreationDateSpecified = true,
VolumeName = StringHandlers.CToString(rbfSb.dd_nam, currentEncoding), VolumeName = StringHandlers.CToString(rbfSb.dd_nam, Encoding),
VolumeSerial = $"{rbfSb.dd_dsk:X4}" VolumeSerial = $"{rbfSb.dd_dsk:X4}"
}; };
} }

27
DiscImageChef.Filesystems/RT11.cs
View File

@@ -31,7 +31,6 @@
// ****************************************************************************/ // ****************************************************************************/
using System; using System;
using System.Collections.Generic;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
using System.Text; using System.Text;
using DiscImageChef.CommonTypes; using DiscImageChef.CommonTypes;
@@ -44,11 +43,8 @@ namespace DiscImageChef.Filesystems
// TODO: Implement Radix-50 // TODO: Implement Radix-50
public class RT11 : IFilesystem public class RT11 : IFilesystem
{ {
Encoding currentEncoding; public FileSystemType XmlFsType { get; private set; }
FileSystemType xmlFsType; public Encoding Encoding { get; private set; }
public FileSystemType XmlFsType => xmlFsType;
public Encoding Encoding => currentEncoding;
public string Name => "RT-11 file system"; public string Name => "RT-11 file system";
public Guid Id => new Guid("DB3E2F98-8F98-463C-8126-E937843DA024"); public Guid Id => new Guid("DB3E2F98-8F98-463C-8126-E937843DA024");
@@ -67,9 +63,10 @@ namespace DiscImageChef.Filesystems
return magic == "DECRT11A "; return magic == "DECRT11A ";
} }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, Encoding encoding) public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding)
{ {
currentEncoding = encoding ?? Encoding.GetEncoding("iso-8859-1"); Encoding = encoding ?? Encoding.GetEncoding("iso-8859-1");
information = ""; information = "";
StringBuilder sb = new StringBuilder(); StringBuilder sb = new StringBuilder();
@@ -93,25 +90,25 @@ namespace DiscImageChef.Filesystems
ushort check = 0; ushort check = 0;
for(int i = 0; i < 512; i += 2) check += BitConverter.ToUInt16(hbSector, i); for(int i = 0; i < 512; i += 2) check += BitConverter.ToUInt16(hbSector, i);
sb.AppendFormat("Volume format is {0}", sb.AppendFormat("Volume format is {0}", StringHandlers.SpacePaddedToString(homeblock.format, Encoding))
StringHandlers.SpacePaddedToString(homeblock.format, currentEncoding)).AppendLine(); .AppendLine();
sb.AppendFormat("{0} sectors per cluster ({1} bytes)", homeblock.cluster, homeblock.cluster * 512) sb.AppendFormat("{0} sectors per cluster ({1} bytes)", homeblock.cluster, homeblock.cluster * 512)
.AppendLine(); .AppendLine();
sb.AppendFormat("First directory segment starts at block {0}", homeblock.rootBlock).AppendLine(); sb.AppendFormat("First directory segment starts at block {0}", homeblock.rootBlock).AppendLine();
sb.AppendFormat("Volume owner is \"{0}\"", sb.AppendFormat("Volume owner is \"{0}\"",
StringHandlers.SpacePaddedToString(homeblock.ownername, currentEncoding)).AppendLine(); StringHandlers.SpacePaddedToString(homeblock.ownername, Encoding)).AppendLine();
sb.AppendFormat("Volume label: \"{0}\"", sb.AppendFormat("Volume label: \"{0}\"", StringHandlers.SpacePaddedToString(homeblock.volname, Encoding))
StringHandlers.SpacePaddedToString(homeblock.volname, currentEncoding)).AppendLine(); .AppendLine();
sb.AppendFormat("Checksum: 0x{0:X4} (calculated 0x{1:X4})", homeblock.checksum, check).AppendLine(); sb.AppendFormat("Checksum: 0x{0:X4} (calculated 0x{1:X4})", homeblock.checksum, check).AppendLine();
byte[] bootBlock = imagePlugin.ReadSector(0); byte[] bootBlock = imagePlugin.ReadSector(0);
xmlFsType = new FileSystemType XmlFsType = new FileSystemType
{ {
Type = "RT-11", Type = "RT-11",
ClusterSize = homeblock.cluster * 512, ClusterSize = homeblock.cluster * 512,
Clusters = homeblock.cluster, Clusters = homeblock.cluster,
VolumeName = StringHandlers.SpacePaddedToString(homeblock.volname, currentEncoding), VolumeName = StringHandlers.SpacePaddedToString(homeblock.volname, Encoding),
Bootable = !ArrayHelpers.ArrayIsNullOrEmpty(bootBlock) Bootable = !ArrayHelpers.ArrayIsNullOrEmpty(bootBlock)
}; };

37
DiscImageChef.Filesystems/Reiser.cs
View File

@@ -31,7 +31,6 @@
// ****************************************************************************/ // ****************************************************************************/
using System; using System;
using System.Collections.Generic;
using System.Linq; using System.Linq;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
using System.Text; using System.Text;
@@ -49,11 +48,8 @@ namespace DiscImageChef.Filesystems
readonly byte[] Reiser36_Magic = {0x52, 0x65, 0x49, 0x73, 0x45, 0x72, 0x32, 0x46, 0x73, 0x00}; readonly byte[] Reiser36_Magic = {0x52, 0x65, 0x49, 0x73, 0x45, 0x72, 0x32, 0x46, 0x73, 0x00};
readonly byte[] ReiserJr_Magic = {0x52, 0x65, 0x49, 0x73, 0x45, 0x72, 0x33, 0x46, 0x73, 0x00}; readonly byte[] ReiserJr_Magic = {0x52, 0x65, 0x49, 0x73, 0x45, 0x72, 0x33, 0x46, 0x73, 0x00};
Encoding currentEncoding; public FileSystemType XmlFsType { get; private set; }
FileSystemType xmlFsType; public Encoding Encoding { get; private set; }
public FileSystemType XmlFsType => xmlFsType;
public Encoding Encoding => currentEncoding;
public string Name => "Reiser Filesystem Plugin"; public string Name => "Reiser Filesystem Plugin";
public Guid Id => new Guid("1D8CD8B8-27E6-410F-9973-D16409225FBA"); public Guid Id => new Guid("1D8CD8B8-27E6-410F-9973-D16409225FBA");
@@ -83,9 +79,10 @@ namespace DiscImageChef.Filesystems
ReiserJr_Magic.SequenceEqual(reiserSb.magic); ReiserJr_Magic.SequenceEqual(reiserSb.magic);
} }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, Encoding encoding) public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding)
{ {
currentEncoding = encoding ?? Encoding.GetEncoding("iso-8859-15"); Encoding = encoding ?? Encoding.GetEncoding("iso-8859-15");
information = ""; information = "";
if(imagePlugin.Info.SectorSize < 512) return; if(imagePlugin.Info.SectorSize < 512) return;
@@ -123,24 +120,24 @@ namespace DiscImageChef.Filesystems
if(reiserSb.version >= 2) if(reiserSb.version >= 2)
{ {
sb.AppendFormat("Volume UUID: {0}", reiserSb.uuid).AppendLine(); sb.AppendFormat("Volume UUID: {0}", reiserSb.uuid).AppendLine();
sb.AppendFormat("Volume name: {0}", currentEncoding.GetString(reiserSb.label)).AppendLine(); sb.AppendFormat("Volume name: {0}", Encoding.GetString(reiserSb.label)).AppendLine();
} }
information = sb.ToString(); information = sb.ToString();
xmlFsType = new FileSystemType(); XmlFsType = new FileSystemType();
if(Reiser35_Magic.SequenceEqual(reiserSb.magic)) xmlFsType.Type = "Reiser 3.5 filesystem"; if(Reiser35_Magic.SequenceEqual(reiserSb.magic)) XmlFsType.Type = "Reiser 3.5 filesystem";
else if(Reiser36_Magic.SequenceEqual(reiserSb.magic)) xmlFsType.Type = "Reiser 3.6 filesystem"; else if(Reiser36_Magic.SequenceEqual(reiserSb.magic)) XmlFsType.Type = "Reiser 3.6 filesystem";
else if(ReiserJr_Magic.SequenceEqual(reiserSb.magic)) xmlFsType.Type = "Reiser Jr. filesystem"; else if(ReiserJr_Magic.SequenceEqual(reiserSb.magic)) XmlFsType.Type = "Reiser Jr. filesystem";
xmlFsType.ClusterSize = reiserSb.blocksize; XmlFsType.ClusterSize = reiserSb.blocksize;
xmlFsType.Clusters = reiserSb.block_count; XmlFsType.Clusters = reiserSb.block_count;
xmlFsType.FreeClusters = reiserSb.free_blocks; XmlFsType.FreeClusters = reiserSb.free_blocks;
xmlFsType.FreeClustersSpecified = true; XmlFsType.FreeClustersSpecified = true;
xmlFsType.Dirty = reiserSb.umount_state == 2; XmlFsType.Dirty = reiserSb.umount_state == 2;
if(reiserSb.version < 2) return; if(reiserSb.version < 2) return;
xmlFsType.VolumeName = currentEncoding.GetString(reiserSb.label); XmlFsType.VolumeName = Encoding.GetString(reiserSb.label);
xmlFsType.VolumeSerial = reiserSb.uuid.ToString(); XmlFsType.VolumeSerial = reiserSb.uuid.ToString();
} }
[StructLayout(LayoutKind.Sequential, Pack = 1)] [StructLayout(LayoutKind.Sequential, Pack = 1)]

19
DiscImageChef.Filesystems/Reiser4.cs
View File

@@ -31,7 +31,6 @@
// ****************************************************************************/ // ****************************************************************************/
using System; using System;
using System.Collections.Generic;
using System.Linq; using System.Linq;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
using System.Text; using System.Text;
@@ -48,11 +47,8 @@ namespace DiscImageChef.Filesystems
readonly byte[] Reiser4_Magic = readonly byte[] Reiser4_Magic =
{0x52, 0x65, 0x49, 0x73, 0x45, 0x72, 0x34, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; {0x52, 0x65, 0x49, 0x73, 0x45, 0x72, 0x34, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
Encoding currentEncoding; public FileSystemType XmlFsType { get; private set; }
FileSystemType xmlFsType; public Encoding Encoding { get; private set; }
public FileSystemType XmlFsType => xmlFsType;
public Encoding Encoding => currentEncoding;
public string Name => "Reiser4 Filesystem Plugin"; public string Name => "Reiser4 Filesystem Plugin";
public Guid Id => new Guid("301F2D00-E8D5-4F04-934E-81DFB21D15BA"); public Guid Id => new Guid("301F2D00-E8D5-4F04-934E-81DFB21D15BA");
@@ -81,9 +77,10 @@ namespace DiscImageChef.Filesystems
return Reiser4_Magic.SequenceEqual(reiserSb.magic); return Reiser4_Magic.SequenceEqual(reiserSb.magic);
} }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, Encoding encoding) public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding)
{ {
currentEncoding = encoding ?? Encoding.GetEncoding("iso-8859-15"); Encoding = encoding ?? Encoding.GetEncoding("iso-8859-15");
information = ""; information = "";
if(imagePlugin.Info.SectorSize < 512) return; if(imagePlugin.Info.SectorSize < 512) return;
@@ -111,16 +108,16 @@ namespace DiscImageChef.Filesystems
sb.AppendFormat("{0} bytes per block", reiserSb.blocksize).AppendLine(); sb.AppendFormat("{0} bytes per block", reiserSb.blocksize).AppendLine();
sb.AppendFormat("Volume disk format: {0}", reiserSb.diskformat).AppendLine(); sb.AppendFormat("Volume disk format: {0}", reiserSb.diskformat).AppendLine();
sb.AppendFormat("Volume UUID: {0}", reiserSb.uuid).AppendLine(); sb.AppendFormat("Volume UUID: {0}", reiserSb.uuid).AppendLine();
sb.AppendFormat("Volume name: {0}", StringHandlers.CToString(reiserSb.label, currentEncoding)).AppendLine(); sb.AppendFormat("Volume name: {0}", StringHandlers.CToString(reiserSb.label, Encoding)).AppendLine();
information = sb.ToString(); information = sb.ToString();
xmlFsType = new FileSystemType XmlFsType = new FileSystemType
{ {
Type = "Reiser 4 filesystem", Type = "Reiser 4 filesystem",
ClusterSize = reiserSb.blocksize, ClusterSize = reiserSb.blocksize,
Clusters = (long)((partition.End - partition.Start) * imagePlugin.Info.SectorSize / reiserSb.blocksize), Clusters = (long)((partition.End - partition.Start) * imagePlugin.Info.SectorSize / reiserSb.blocksize),
VolumeName = StringHandlers.CToString(reiserSb.label, currentEncoding), VolumeName = StringHandlers.CToString(reiserSb.label, Encoding),
VolumeSerial = reiserSb.uuid.ToString() VolumeSerial = reiserSb.uuid.ToString()
}; };
} }

14
DiscImageChef.Filesystems/SFS.cs
View File

@@ -31,7 +31,6 @@
// ****************************************************************************/ // ****************************************************************************/
using System; using System;
using System.Collections.Generic;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
using System.Text; using System.Text;
using DiscImageChef.CommonTypes; using DiscImageChef.CommonTypes;
@@ -46,11 +45,9 @@ namespace DiscImageChef.Filesystems
const uint SFS_MAGIC = 0x53465300; const uint SFS_MAGIC = 0x53465300;
/// <summary>Identifier for SFS v2</summary> /// <summary>Identifier for SFS v2</summary>
const uint SFS2_MAGIC = 0x53465302; const uint SFS2_MAGIC = 0x53465302;
FileSystemType xmlFsType;
public FileSystemType XmlFsType => xmlFsType;
Encoding currentEncoding; public FileSystemType XmlFsType { get; private set; }
public Encoding Encoding => currentEncoding; public Encoding Encoding { get; private set; }
public string Name => "SmartFileSystem"; public string Name => "SmartFileSystem";
public Guid Id => new Guid("26550C19-3671-4A2D-BC2F-F20CEB7F48DC"); public Guid Id => new Guid("26550C19-3671-4A2D-BC2F-F20CEB7F48DC");
@@ -67,9 +64,10 @@ namespace DiscImageChef.Filesystems
return magic == SFS_MAGIC || magic == SFS2_MAGIC; return magic == SFS_MAGIC || magic == SFS2_MAGIC;
} }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, Encoding encoding) public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding)
{ {
currentEncoding = encoding ?? Encoding.GetEncoding("iso-8859-1"); Encoding = encoding ?? Encoding.GetEncoding("iso-8859-1");
byte[] rootBlockSector = imagePlugin.ReadSector(partition.Start); byte[] rootBlockSector = imagePlugin.ReadSector(partition.Start);
RootBlock rootBlock = BigEndianMarshal.ByteArrayToStructureBigEndian<RootBlock>(rootBlockSector); RootBlock rootBlock = BigEndianMarshal.ByteArrayToStructureBigEndian<RootBlock>(rootBlockSector);
@@ -100,7 +98,7 @@ namespace DiscImageChef.Filesystems
sbInformation.AppendLine("Volume moves deleted files to a recycled folder"); sbInformation.AppendLine("Volume moves deleted files to a recycled folder");
information = sbInformation.ToString(); information = sbInformation.ToString();
xmlFsType = new FileSystemType XmlFsType = new FileSystemType
{ {
CreationDate = DateHandlers.UnixUnsignedToDateTime(rootBlock.datecreated).AddYears(8), CreationDate = DateHandlers.UnixUnsignedToDateTime(rootBlock.datecreated).AddYears(8),
CreationDateSpecified = true, CreationDateSpecified = true,

19
DiscImageChef.Filesystems/SolarFS.cs
View File

@@ -31,7 +31,6 @@
// ****************************************************************************/ // ****************************************************************************/
using System; using System;
using System.Collections.Generic;
using System.Text; using System.Text;
using DiscImageChef.CommonTypes; using DiscImageChef.CommonTypes;
using DiscImageChef.Console; using DiscImageChef.Console;
@@ -43,11 +42,8 @@ namespace DiscImageChef.Filesystems
// Based on FAT's BPB, cannot find a FAT or directory // Based on FAT's BPB, cannot find a FAT or directory
public class SolarFS : IFilesystem public class SolarFS : IFilesystem
{ {
Encoding currentEncoding; public FileSystemType XmlFsType { get; private set; }
FileSystemType xmlFsType; public Encoding Encoding { get; private set; }
public FileSystemType XmlFsType => xmlFsType;
public Encoding Encoding => currentEncoding;
public string Name => "Solar_OS filesystem"; public string Name => "Solar_OS filesystem";
public Guid Id => new Guid("EA3101C1-E777-4B4F-B5A3-8C57F50F6E65"); public Guid Id => new Guid("EA3101C1-E777-4B4F-B5A3-8C57F50F6E65");
@@ -68,9 +64,10 @@ namespace DiscImageChef.Filesystems
return signature == 0x29 && fsType == "SOL_FS "; return signature == 0x29 && fsType == "SOL_FS ";
} }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, Encoding encoding) public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding)
{ {
currentEncoding = encoding ?? Encoding.GetEncoding("iso-8859-15"); Encoding = encoding ?? Encoding.GetEncoding("iso-8859-15");
information = ""; information = "";
StringBuilder sb = new StringBuilder(); StringBuilder sb = new StringBuilder();
@@ -92,10 +89,10 @@ namespace DiscImageChef.Filesystems
bpb.OEMName = StringHandlers.CToString(bpbStrings); bpb.OEMName = StringHandlers.CToString(bpbStrings);
bpbStrings = new byte[8]; bpbStrings = new byte[8];
Array.Copy(bpbSector, 0x2A, bpbStrings, 0, 11); Array.Copy(bpbSector, 0x2A, bpbStrings, 0, 11);
bpb.vol_name = StringHandlers.CToString(bpbStrings, currentEncoding); bpb.vol_name = StringHandlers.CToString(bpbStrings, Encoding);
bpbStrings = new byte[8]; bpbStrings = new byte[8];
Array.Copy(bpbSector, 0x35, bpbStrings, 0, 8); Array.Copy(bpbSector, 0x35, bpbStrings, 0, 8);
bpb.fs_type = StringHandlers.CToString(bpbStrings, currentEncoding); bpb.fs_type = StringHandlers.CToString(bpbStrings, Encoding);
bpb.x86_jump = new byte[3]; bpb.x86_jump = new byte[3];
Array.Copy(bpbSector, 0x00, bpb.x86_jump, 0, 3); Array.Copy(bpbSector, 0x00, bpb.x86_jump, 0, 3);
@@ -149,7 +146,7 @@ namespace DiscImageChef.Filesystems
sb.AppendFormat("{0} sectors per track", bpb.sptrk).AppendLine(); sb.AppendFormat("{0} sectors per track", bpb.sptrk).AppendLine();
sb.AppendFormat("Volume name: {0}", bpb.vol_name).AppendLine(); sb.AppendFormat("Volume name: {0}", bpb.vol_name).AppendLine();
xmlFsType = new FileSystemType XmlFsType = new FileSystemType
{ {
Type = "SolarFS", Type = "SolarFS",
Clusters = bpb.sectors, Clusters = bpb.sectors,

13
DiscImageChef.Filesystems/Squash.cs
View File

@@ -31,7 +31,6 @@
// ****************************************************************************/ // ****************************************************************************/
using System; using System;
using System.Collections.Generic;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
using System.Text; using System.Text;
using DiscImageChef.CommonTypes; using DiscImageChef.CommonTypes;
@@ -48,10 +47,8 @@ namespace DiscImageChef.Filesystems
const uint SQUASH_MAGIC = 0x73717368; const uint SQUASH_MAGIC = 0x73717368;
const uint SQUASH_CIGAM = 0x68737173; const uint SQUASH_CIGAM = 0x68737173;
Encoding currentEncoding; public FileSystemType XmlFsType { get; private set; }
FileSystemType xmlFsType; public Encoding Encoding { get; private set; }
public FileSystemType XmlFsType => xmlFsType;
public Encoding Encoding => currentEncoding;
public string Name => "Squash filesystem"; public string Name => "Squash filesystem";
public Guid Id => new Guid("F8F6E46F-7A2A-48E3-9C0A-46AF4DC29E09"); public Guid Id => new Guid("F8F6E46F-7A2A-48E3-9C0A-46AF4DC29E09");
@@ -67,9 +64,9 @@ namespace DiscImageChef.Filesystems
} }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding) Encoding encoding)
{ {
currentEncoding = encoding ?? Encoding.UTF8; Encoding = encoding ?? Encoding.UTF8;
byte[] sector = imagePlugin.ReadSector(partition.Start); byte[] sector = imagePlugin.ReadSector(partition.Start);
uint magic = BitConverter.ToUInt32(sector, 0x00); uint magic = BitConverter.ToUInt32(sector, 0x00);
@@ -128,7 +125,7 @@ namespace DiscImageChef.Filesystems
information = sbInformation.ToString(); information = sbInformation.ToString();
xmlFsType = new FileSystemType XmlFsType = new FileSystemType
{ {
Type = "Squash file system", Type = "Squash file system",
CreationDate = DateHandlers.UnixUnsignedToDateTime(sqSb.mkfs_time), CreationDate = DateHandlers.UnixUnsignedToDateTime(sqSb.mkfs_time),

99
DiscImageChef.Filesystems/SysV.cs
View File

@@ -63,11 +63,8 @@ namespace DiscImageChef.Filesystems
const ushort V7_NICFREE = 100; const ushort V7_NICFREE = 100;
const uint V7_MAXSIZE = 0x00FFFFFF; const uint V7_MAXSIZE = 0x00FFFFFF;
Encoding currentEncoding; public FileSystemType XmlFsType { get; private set; }
FileSystemType xmlFsType; public Encoding Encoding { get; private set; }
public FileSystemType XmlFsType => xmlFsType;
public Encoding Encoding => currentEncoding;
public string Name => "UNIX System V filesystem"; public string Name => "UNIX System V filesystem";
public Guid Id => new Guid("9B8D016A-8561-400E-A12A-A198283C211D"); public Guid Id => new Guid("9B8D016A-8561-400E-A12A-A198283C211D");
@@ -154,7 +151,7 @@ namespace DiscImageChef.Filesystems
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, Encoding encoding) public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, Encoding encoding)
{ {
currentEncoding = encoding ?? Encoding.GetEncoding("iso-8859-15"); Encoding = encoding ?? Encoding.GetEncoding("iso-8859-15");
information = ""; information = "";
StringBuilder sb = new StringBuilder(); StringBuilder sb = new StringBuilder();
@@ -254,9 +251,9 @@ namespace DiscImageChef.Filesystems
byte[] coherent_string = new byte[6]; byte[] coherent_string = new byte[6];
Array.Copy(sb_sector, 0x1E4, coherent_string, 0, 6); // Coherent UNIX s_fname location Array.Copy(sb_sector, 0x1E4, coherent_string, 0, 6); // Coherent UNIX s_fname location
string s_fname = StringHandlers.CToString(coherent_string, currentEncoding); string s_fname = StringHandlers.CToString(coherent_string, Encoding);
Array.Copy(sb_sector, 0x1EA, coherent_string, 0, 6); // Coherent UNIX s_fpack location Array.Copy(sb_sector, 0x1EA, coherent_string, 0, 6); // Coherent UNIX s_fpack location
string s_fpack = StringHandlers.CToString(coherent_string, currentEncoding); string s_fpack = StringHandlers.CToString(coherent_string, Encoding);
if(s_fname == COH_FNAME && s_fpack == COH_FPACK || s_fname == COH_XXXXX && s_fpack == COH_XXXXX || if(s_fname == COH_FNAME && s_fpack == COH_FPACK || s_fname == COH_XXXXX && s_fpack == COH_XXXXX ||
s_fname == COH_XXXXS && s_fpack == COH_XXXXN) s_fname == COH_XXXXS && s_fpack == COH_XXXXN)
@@ -300,7 +297,7 @@ namespace DiscImageChef.Filesystems
if(!sys7th && !sysv && !coherent && !xenix && !xenix3) return; if(!sys7th && !sysv && !coherent && !xenix && !xenix3) return;
xmlFsType = new FileSystemType(); XmlFsType = new FileSystemType();
if(xenix || xenix3) if(xenix || xenix3)
{ {
@@ -326,9 +323,9 @@ namespace DiscImageChef.Filesystems
xnx_sb.s_dinfo0 = BigEndianBitConverter.ToUInt16(sb_sector, 0x1AC); xnx_sb.s_dinfo0 = BigEndianBitConverter.ToUInt16(sb_sector, 0x1AC);
xnx_sb.s_dinfo1 = BigEndianBitConverter.ToUInt16(sb_sector, 0x1AE); xnx_sb.s_dinfo1 = BigEndianBitConverter.ToUInt16(sb_sector, 0x1AE);
Array.Copy(sb_sector, 0x1B0, xenix_strings, 0, 6); Array.Copy(sb_sector, 0x1B0, xenix_strings, 0, 6);
xnx_sb.s_fname = StringHandlers.CToString(xenix_strings, currentEncoding); xnx_sb.s_fname = StringHandlers.CToString(xenix_strings, Encoding);
Array.Copy(sb_sector, 0x1B6, xenix_strings, 0, 6); Array.Copy(sb_sector, 0x1B6, xenix_strings, 0, 6);
xnx_sb.s_fpack = StringHandlers.CToString(xenix_strings, currentEncoding); xnx_sb.s_fpack = StringHandlers.CToString(xenix_strings, Encoding);
xnx_sb.s_clean = sb_sector[0x1BC]; xnx_sb.s_clean = sb_sector[0x1BC];
xnx_sb.s_magic = BigEndianBitConverter.ToUInt32(sb_sector, 0x1F0); xnx_sb.s_magic = BigEndianBitConverter.ToUInt32(sb_sector, 0x1F0);
xnx_sb.s_type = BigEndianBitConverter.ToUInt32(sb_sector, 0x1F4); xnx_sb.s_type = BigEndianBitConverter.ToUInt32(sb_sector, 0x1F4);
@@ -351,9 +348,9 @@ namespace DiscImageChef.Filesystems
xnx_sb.s_dinfo0 = BigEndianBitConverter.ToUInt16(sb_sector, 0x274); xnx_sb.s_dinfo0 = BigEndianBitConverter.ToUInt16(sb_sector, 0x274);
xnx_sb.s_dinfo1 = BigEndianBitConverter.ToUInt16(sb_sector, 0x276); xnx_sb.s_dinfo1 = BigEndianBitConverter.ToUInt16(sb_sector, 0x276);
Array.Copy(sb_sector, 0x278, xenix_strings, 0, 6); Array.Copy(sb_sector, 0x278, xenix_strings, 0, 6);
xnx_sb.s_fname = StringHandlers.CToString(xenix_strings, currentEncoding); xnx_sb.s_fname = StringHandlers.CToString(xenix_strings, Encoding);
Array.Copy(sb_sector, 0x27E, xenix_strings, 0, 6); Array.Copy(sb_sector, 0x27E, xenix_strings, 0, 6);
xnx_sb.s_fpack = StringHandlers.CToString(xenix_strings, currentEncoding); xnx_sb.s_fpack = StringHandlers.CToString(xenix_strings, Encoding);
xnx_sb.s_clean = sb_sector[0x284]; xnx_sb.s_clean = sb_sector[0x284];
xnx_sb.s_magic = BigEndianBitConverter.ToUInt32(sb_sector, 0x3F8); xnx_sb.s_magic = BigEndianBitConverter.ToUInt32(sb_sector, 0x3F8);
xnx_sb.s_type = BigEndianBitConverter.ToUInt32(sb_sector, 0x3FC); xnx_sb.s_type = BigEndianBitConverter.ToUInt32(sb_sector, 0x3FC);
@@ -361,22 +358,22 @@ namespace DiscImageChef.Filesystems
uint bs = 512; uint bs = 512;
sb.AppendLine("XENIX filesystem"); sb.AppendLine("XENIX filesystem");
xmlFsType.Type = "XENIX fs"; XmlFsType.Type = "XENIX fs";
switch(xnx_sb.s_type) switch(xnx_sb.s_type)
{ {
case 1: case 1:
sb.AppendLine("512 bytes per block"); sb.AppendLine("512 bytes per block");
xmlFsType.ClusterSize = 512; XmlFsType.ClusterSize = 512;
break; break;
case 2: case 2:
sb.AppendLine("1024 bytes per block"); sb.AppendLine("1024 bytes per block");
bs = 1024; bs = 1024;
xmlFsType.ClusterSize = 1024; XmlFsType.ClusterSize = 1024;
break; break;
case 3: case 3:
sb.AppendLine("2048 bytes per block"); sb.AppendLine("2048 bytes per block");
bs = 2048; bs = 2048;
xmlFsType.ClusterSize = 2048; XmlFsType.ClusterSize = 2048;
break; break;
default: default:
sb.AppendFormat("Unknown s_type value: 0x{0:X8}", xnx_sb.s_type).AppendLine(); sb.AppendFormat("Unknown s_type value: 0x{0:X8}", xnx_sb.s_type).AppendLine();
@@ -417,17 +414,17 @@ namespace DiscImageChef.Filesystems
.AppendLine(); .AppendLine();
if(xnx_sb.s_time != 0) if(xnx_sb.s_time != 0)
{ {
xmlFsType.ModificationDate = DateHandlers.UnixToDateTime(xnx_sb.s_time); XmlFsType.ModificationDate = DateHandlers.UnixToDateTime(xnx_sb.s_time);
xmlFsType.ModificationDateSpecified = true; XmlFsType.ModificationDateSpecified = true;
} }
sb.AppendFormat("Volume name: {0}", xnx_sb.s_fname).AppendLine(); sb.AppendFormat("Volume name: {0}", xnx_sb.s_fname).AppendLine();
xmlFsType.VolumeName = xnx_sb.s_fname; XmlFsType.VolumeName = xnx_sb.s_fname;
sb.AppendFormat("Pack name: {0}", xnx_sb.s_fpack).AppendLine(); sb.AppendFormat("Pack name: {0}", xnx_sb.s_fpack).AppendLine();
if(xnx_sb.s_clean == 0x46) sb.AppendLine("Volume is clean"); if(xnx_sb.s_clean == 0x46) sb.AppendLine("Volume is clean");
else else
{ {
sb.AppendLine("Volume is dirty"); sb.AppendLine("Volume is dirty");
xmlFsType.Dirty = true; XmlFsType.Dirty = true;
} }
} }
@@ -444,15 +441,15 @@ namespace DiscImageChef.Filesystems
switch(sysv_sb.s_type) switch(sysv_sb.s_type)
{ {
case 1: case 1:
xmlFsType.ClusterSize = 512; XmlFsType.ClusterSize = 512;
break; break;
case 2: case 2:
bs = 1024; bs = 1024;
xmlFsType.ClusterSize = 1024; XmlFsType.ClusterSize = 1024;
break; break;
case 3: case 3:
bs = 2048; bs = 2048;
xmlFsType.ClusterSize = 2048; XmlFsType.ClusterSize = 2048;
break; break;
default: default:
sb.AppendFormat("Unknown s_type value: 0x{0:X8}", sysv_sb.s_type).AppendLine(); sb.AppendFormat("Unknown s_type value: 0x{0:X8}", sysv_sb.s_type).AppendLine();
@@ -483,11 +480,11 @@ namespace DiscImageChef.Filesystems
sysv_sb.s_tfree = BigEndianBitConverter.ToUInt32(sb_sector, 0x1B0 + offset); sysv_sb.s_tfree = BigEndianBitConverter.ToUInt32(sb_sector, 0x1B0 + offset);
sysv_sb.s_tinode = BigEndianBitConverter.ToUInt16(sb_sector, 0x1B4 + offset); sysv_sb.s_tinode = BigEndianBitConverter.ToUInt16(sb_sector, 0x1B4 + offset);
Array.Copy(sb_sector, 0x1B6 + offset, sysv_strings, 0, 6); Array.Copy(sb_sector, 0x1B6 + offset, sysv_strings, 0, 6);
sysv_sb.s_fname = StringHandlers.CToString(sysv_strings, currentEncoding); sysv_sb.s_fname = StringHandlers.CToString(sysv_strings, Encoding);
Array.Copy(sb_sector, 0x1BC + offset, sysv_strings, 0, 6); Array.Copy(sb_sector, 0x1BC + offset, sysv_strings, 0, 6);
sysv_sb.s_fpack = StringHandlers.CToString(sysv_strings, currentEncoding); sysv_sb.s_fpack = StringHandlers.CToString(sysv_strings, Encoding);
sb.AppendLine("System V Release 4 filesystem"); sb.AppendLine("System V Release 4 filesystem");
xmlFsType.Type = "SVR4 fs"; XmlFsType.Type = "SVR4 fs";
} }
else else
{ {
@@ -509,15 +506,15 @@ namespace DiscImageChef.Filesystems
sysv_sb.s_tfree = BigEndianBitConverter.ToUInt32(sb_sector, 0x1AA + offset); sysv_sb.s_tfree = BigEndianBitConverter.ToUInt32(sb_sector, 0x1AA + offset);
sysv_sb.s_tinode = BigEndianBitConverter.ToUInt16(sb_sector, 0x1AE + offset); sysv_sb.s_tinode = BigEndianBitConverter.ToUInt16(sb_sector, 0x1AE + offset);
Array.Copy(sb_sector, 0x1B0 + offset, sysv_strings, 0, 6); Array.Copy(sb_sector, 0x1B0 + offset, sysv_strings, 0, 6);
sysv_sb.s_fname = StringHandlers.CToString(sysv_strings, currentEncoding); sysv_sb.s_fname = StringHandlers.CToString(sysv_strings, Encoding);
Array.Copy(sb_sector, 0x1B6 + offset, sysv_strings, 0, 6); Array.Copy(sb_sector, 0x1B6 + offset, sysv_strings, 0, 6);
sysv_sb.s_fpack = StringHandlers.CToString(sysv_strings, currentEncoding); sysv_sb.s_fpack = StringHandlers.CToString(sysv_strings, Encoding);
sb.AppendLine("System V Release 2 filesystem"); sb.AppendLine("System V Release 2 filesystem");
xmlFsType.Type = "SVR2 fs"; XmlFsType.Type = "SVR2 fs";
} }
sb.AppendFormat("{0} bytes per block", bs).AppendLine(); sb.AppendFormat("{0} bytes per block", bs).AppendLine();
xmlFsType.Clusters = sysv_sb.s_fsize; XmlFsType.Clusters = sysv_sb.s_fsize;
sb.AppendFormat("{0} zones on volume ({1} bytes)", sysv_sb.s_fsize, sysv_sb.s_fsize * bs).AppendLine(); sb.AppendFormat("{0} zones on volume ({1} bytes)", sysv_sb.s_fsize, sysv_sb.s_fsize * bs).AppendLine();
sb.AppendFormat("{0} free zones on volume ({1} bytes)", sysv_sb.s_tfree, sysv_sb.s_tfree * bs) sb.AppendFormat("{0} free zones on volume ({1} bytes)", sysv_sb.s_tfree, sysv_sb.s_tfree * bs)
.AppendLine(); .AppendLine();
@@ -538,17 +535,17 @@ namespace DiscImageChef.Filesystems
.AppendLine(); .AppendLine();
if(sysv_sb.s_time != 0) if(sysv_sb.s_time != 0)
{ {
xmlFsType.ModificationDate = DateHandlers.UnixUnsignedToDateTime(sysv_sb.s_time); XmlFsType.ModificationDate = DateHandlers.UnixUnsignedToDateTime(sysv_sb.s_time);
xmlFsType.ModificationDateSpecified = true; XmlFsType.ModificationDateSpecified = true;
} }
sb.AppendFormat("Volume name: {0}", sysv_sb.s_fname).AppendLine(); sb.AppendFormat("Volume name: {0}", sysv_sb.s_fname).AppendLine();
xmlFsType.VolumeName = sysv_sb.s_fname; XmlFsType.VolumeName = sysv_sb.s_fname;
sb.AppendFormat("Pack name: {0}", sysv_sb.s_fpack).AppendLine(); sb.AppendFormat("Pack name: {0}", sysv_sb.s_fpack).AppendLine();
if(sysv_sb.s_state == 0x7C269D38 - sysv_sb.s_time) sb.AppendLine("Volume is clean"); if(sysv_sb.s_state == 0x7C269D38 - sysv_sb.s_time) sb.AppendLine("Volume is clean");
else else
{ {
sb.AppendLine("Volume is dirty"); sb.AppendLine("Volume is dirty");
xmlFsType.Dirty = true; XmlFsType.Dirty = true;
} }
} }
@@ -572,13 +569,13 @@ namespace DiscImageChef.Filesystems
coh_sb.s_int_m = BitConverter.ToUInt16(sb_sector, 0x1E0); coh_sb.s_int_m = BitConverter.ToUInt16(sb_sector, 0x1E0);
coh_sb.s_int_n = BitConverter.ToUInt16(sb_sector, 0x1E2); coh_sb.s_int_n = BitConverter.ToUInt16(sb_sector, 0x1E2);
Array.Copy(sb_sector, 0x1E4, coh_strings, 0, 6); Array.Copy(sb_sector, 0x1E4, coh_strings, 0, 6);
coh_sb.s_fname = StringHandlers.CToString(coh_strings, currentEncoding); coh_sb.s_fname = StringHandlers.CToString(coh_strings, Encoding);
Array.Copy(sb_sector, 0x1EA, coh_strings, 0, 6); Array.Copy(sb_sector, 0x1EA, coh_strings, 0, 6);
coh_sb.s_fpack = StringHandlers.CToString(coh_strings, currentEncoding); coh_sb.s_fpack = StringHandlers.CToString(coh_strings, Encoding);
xmlFsType.Type = "Coherent fs"; XmlFsType.Type = "Coherent fs";
xmlFsType.ClusterSize = 512; XmlFsType.ClusterSize = 512;
xmlFsType.Clusters = coh_sb.s_fsize; XmlFsType.Clusters = coh_sb.s_fsize;
sb.AppendLine("Coherent UNIX filesystem"); sb.AppendLine("Coherent UNIX filesystem");
if(imagePlugin.Info.SectorSize != 512) if(imagePlugin.Info.SectorSize != 512)
@@ -601,11 +598,11 @@ namespace DiscImageChef.Filesystems
.AppendLine(); .AppendLine();
if(coh_sb.s_time != 0) if(coh_sb.s_time != 0)
{ {
xmlFsType.ModificationDate = DateHandlers.UnixUnsignedToDateTime(coh_sb.s_time); XmlFsType.ModificationDate = DateHandlers.UnixUnsignedToDateTime(coh_sb.s_time);
xmlFsType.ModificationDateSpecified = true; XmlFsType.ModificationDateSpecified = true;
} }
sb.AppendFormat("Volume name: {0}", coh_sb.s_fname).AppendLine(); sb.AppendFormat("Volume name: {0}", coh_sb.s_fname).AppendLine();
xmlFsType.VolumeName = coh_sb.s_fname; XmlFsType.VolumeName = coh_sb.s_fname;
sb.AppendFormat("Pack name: {0}", coh_sb.s_fpack).AppendLine(); sb.AppendFormat("Pack name: {0}", coh_sb.s_fpack).AppendLine();
} }
@@ -629,13 +626,13 @@ namespace DiscImageChef.Filesystems
v7_sb.s_int_m = BigEndianBitConverter.ToUInt16(sb_sector, 0x1A8); v7_sb.s_int_m = BigEndianBitConverter.ToUInt16(sb_sector, 0x1A8);
v7_sb.s_int_n = BigEndianBitConverter.ToUInt16(sb_sector, 0x1AA); v7_sb.s_int_n = BigEndianBitConverter.ToUInt16(sb_sector, 0x1AA);
Array.Copy(sb_sector, 0x1AC, sys7_strings, 0, 6); Array.Copy(sb_sector, 0x1AC, sys7_strings, 0, 6);
v7_sb.s_fname = StringHandlers.CToString(sys7_strings, currentEncoding); v7_sb.s_fname = StringHandlers.CToString(sys7_strings, Encoding);
Array.Copy(sb_sector, 0x1B2, sys7_strings, 0, 6); Array.Copy(sb_sector, 0x1B2, sys7_strings, 0, 6);
v7_sb.s_fpack = StringHandlers.CToString(sys7_strings, currentEncoding); v7_sb.s_fpack = StringHandlers.CToString(sys7_strings, Encoding);
xmlFsType.Type = "UNIX 7th Edition fs"; XmlFsType.Type = "UNIX 7th Edition fs";
xmlFsType.ClusterSize = 512; XmlFsType.ClusterSize = 512;
xmlFsType.Clusters = v7_sb.s_fsize; XmlFsType.Clusters = v7_sb.s_fsize;
sb.AppendLine("UNIX 7th Edition filesystem"); sb.AppendLine("UNIX 7th Edition filesystem");
if(imagePlugin.Info.SectorSize != 512) if(imagePlugin.Info.SectorSize != 512)
sb sb
@@ -656,11 +653,11 @@ namespace DiscImageChef.Filesystems
.AppendLine(); .AppendLine();
if(v7_sb.s_time != 0) if(v7_sb.s_time != 0)
{ {
xmlFsType.ModificationDate = DateHandlers.UnixUnsignedToDateTime(v7_sb.s_time); XmlFsType.ModificationDate = DateHandlers.UnixUnsignedToDateTime(v7_sb.s_time);
xmlFsType.ModificationDateSpecified = true; XmlFsType.ModificationDateSpecified = true;
} }
sb.AppendFormat("Volume name: {0}", v7_sb.s_fname).AppendLine(); sb.AppendFormat("Volume name: {0}", v7_sb.s_fname).AppendLine();
xmlFsType.VolumeName = v7_sb.s_fname; XmlFsType.VolumeName = v7_sb.s_fname;
sb.AppendFormat("Pack name: {0}", v7_sb.s_fpack).AppendLine(); sb.AppendFormat("Pack name: {0}", v7_sb.s_fpack).AppendLine();
} }

2
DiscImageChef.Filesystems/UCSDPascal/Dir.cs
View File

@@ -46,7 +46,7 @@ namespace DiscImageChef.Filesystems.UCSDPascal
if(!string.IsNullOrEmpty(path) && string.Compare(path, "/", StringComparison.OrdinalIgnoreCase) != 0) if(!string.IsNullOrEmpty(path) && string.Compare(path, "/", StringComparison.OrdinalIgnoreCase) != 0)
return Errno.NotSupported; return Errno.NotSupported;
contents = fileEntries.Select(ent => StringHandlers.PascalToString(ent.filename, currentEncoding)).ToList(); contents = fileEntries.Select(ent => StringHandlers.PascalToString(ent.filename, Encoding)).ToList();
if(debug) if(debug)
{ {

5
DiscImageChef.Filesystems/UCSDPascal/File.cs
View File

@@ -79,8 +79,7 @@ namespace DiscImageChef.Filesystems.UCSDPascal
if(error != Errno.NoError) return error; if(error != Errno.NoError) return error;
byte[] tmp = device.ReadSectors((ulong)entry.firstBlock, (uint)(entry.lastBlock - entry.firstBlock)); byte[] tmp = device.ReadSectors((ulong)entry.firstBlock, (uint)(entry.lastBlock - entry.firstBlock));
file = new byte[(entry.lastBlock - entry.firstBlock - 1) * device.Info.SectorSize + file = new byte[(entry.lastBlock - entry.firstBlock - 1) * device.Info.SectorSize + entry.lastBytes];
entry.lastBytes];
Array.Copy(tmp, 0, file, 0, file.Length); Array.Copy(tmp, 0, file, 0, file.Length);
} }
@@ -164,7 +163,7 @@ namespace DiscImageChef.Filesystems.UCSDPascal
string.Compare(path, string.Compare(path,
StringHandlers StringHandlers
.PascalToString(ent.filename, .PascalToString(ent.filename,
currentEncoding), Encoding),
StringComparison StringComparison
.InvariantCultureIgnoreCase) == 0)) .InvariantCultureIgnoreCase) == 0))
{ {

10
DiscImageChef.Filesystems/UCSDPascal/Info.cs
View File

@@ -83,7 +83,8 @@ namespace DiscImageChef.Filesystems.UCSDPascal
return volEntry.files >= 0; return volEntry.files >= 0;
} }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, Encoding encoding) public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding)
{ {
StringBuilder sbInformation = new StringBuilder(); StringBuilder sbInformation = new StringBuilder();
information = ""; information = "";
@@ -129,8 +130,7 @@ namespace DiscImageChef.Filesystems.UCSDPascal
sbInformation.AppendFormat("Volume record spans from block {0} to block {1}", volEntry.firstBlock, sbInformation.AppendFormat("Volume record spans from block {0} to block {1}", volEntry.firstBlock,
volEntry.lastBlock).AppendLine(); volEntry.lastBlock).AppendLine();
sbInformation.AppendFormat("Volume name: {0}", sbInformation.AppendFormat("Volume name: {0}", StringHandlers.PascalToString(volEntry.volumeName, Encoding))
StringHandlers.PascalToString(volEntry.volumeName, currentEncoding))
.AppendLine(); .AppendLine();
sbInformation.AppendFormat("Volume has {0} blocks", volEntry.blocks).AppendLine(); sbInformation.AppendFormat("Volume has {0} blocks", volEntry.blocks).AppendLine();
sbInformation.AppendFormat("Volume has {0} files", volEntry.files).AppendLine(); sbInformation.AppendFormat("Volume has {0} files", volEntry.files).AppendLine();
@@ -140,7 +140,7 @@ namespace DiscImageChef.Filesystems.UCSDPascal
information = sbInformation.ToString(); information = sbInformation.ToString();
xmlFsType = new FileSystemType XmlFsType = new FileSystemType
{ {
Bootable = !ArrayHelpers.ArrayIsNullOrEmpty(imagePlugin.ReadSectors(partition.Start, 2)), Bootable = !ArrayHelpers.ArrayIsNullOrEmpty(imagePlugin.ReadSectors(partition.Start, 2)),
Clusters = volEntry.blocks, Clusters = volEntry.blocks,
@@ -148,7 +148,7 @@ namespace DiscImageChef.Filesystems.UCSDPascal
Files = volEntry.files, Files = volEntry.files,
FilesSpecified = true, FilesSpecified = true,
Type = "UCSD Pascal", Type = "UCSD Pascal",
VolumeName = StringHandlers.PascalToString(volEntry.volumeName, currentEncoding) VolumeName = StringHandlers.PascalToString(volEntry.volumeName, Encoding)
}; };
} }
} }

6
DiscImageChef.Filesystems/UCSDPascal/Super.cs
View File

@@ -47,7 +47,7 @@ namespace DiscImageChef.Filesystems.UCSDPascal
{ {
device = imagePlugin; device = imagePlugin;
// TODO: Until Apple ][ encoding is implemented // TODO: Until Apple ][ encoding is implemented
currentEncoding = new LisaRoman(); Encoding = new LisaRoman();
this.debug = debug; this.debug = debug;
if(device.Info.Sectors < 3) return Errno.InvalidArgument; if(device.Info.Sectors < 3) return Errno.InvalidArgument;
@@ -98,7 +98,7 @@ namespace DiscImageChef.Filesystems.UCSDPascal
bootBlocks = device.ReadSectors(0, 2); bootBlocks = device.ReadSectors(0, 2);
xmlFsType = new FileSystemType XmlFsType = new FileSystemType
{ {
Bootable = !ArrayHelpers.ArrayIsNullOrEmpty(bootBlocks), Bootable = !ArrayHelpers.ArrayIsNullOrEmpty(bootBlocks),
Clusters = mountedVolEntry.blocks, Clusters = mountedVolEntry.blocks,
@@ -106,7 +106,7 @@ namespace DiscImageChef.Filesystems.UCSDPascal
Files = mountedVolEntry.files, Files = mountedVolEntry.files,
FilesSpecified = true, FilesSpecified = true,
Type = "UCSD Pascal", Type = "UCSD Pascal",
VolumeName = StringHandlers.PascalToString(mountedVolEntry.volumeName, currentEncoding) VolumeName = StringHandlers.PascalToString(mountedVolEntry.volumeName, Encoding)
}; };
mounted = true; mounted = true;

13
DiscImageChef.Filesystems/UCSDPascal/UCSDPascal.cs
View File

@@ -32,32 +32,29 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using Claunia.Encoding; using System.Text;
using DiscImageChef.CommonTypes;
using DiscImageChef.DiscImages; using DiscImageChef.DiscImages;
using Schemas; using Schemas;
using Encoding = System.Text.Encoding;
namespace DiscImageChef.Filesystems.UCSDPascal namespace DiscImageChef.Filesystems.UCSDPascal
{ {
// Information from Call-A.P.P.L.E. Pascal Disk Directory Structure // Information from Call-A.P.P.L.E. Pascal Disk Directory Structure
public partial class PascalPlugin : IReadOnlyFilesystem public partial class PascalPlugin : IReadOnlyFilesystem
{ {
IMediaImage device;
byte[] bootBlocks; byte[] bootBlocks;
byte[] catalogBlocks; byte[] catalogBlocks;
Encoding currentEncoding;
bool debug; bool debug;
IMediaImage device;
List<PascalFileEntry> fileEntries; List<PascalFileEntry> fileEntries;
bool mounted; bool mounted;
FileSystemType xmlFsType;
public FileSystemType XmlFsType => xmlFsType;
PascalVolumeEntry mountedVolEntry; PascalVolumeEntry mountedVolEntry;
public FileSystemType XmlFsType { get; private set; }
public string Name => "U.C.S.D. Pascal filesystem"; public string Name => "U.C.S.D. Pascal filesystem";
public Guid Id => new Guid("B0AC2CB5-72AA-473A-9200-270B5A2C2D53"); public Guid Id => new Guid("B0AC2CB5-72AA-473A-9200-270B5A2C2D53");
public Encoding Encoding => currentEncoding; public Encoding Encoding { get; private set; }
public Errno ListXAttr(string path, ref List<string> xattrs) public Errno ListXAttr(string path, ref List<string> xattrs)
{ {

29
DiscImageChef.Filesystems/UDF.cs
View File

@@ -31,7 +31,6 @@
// ****************************************************************************/ // ****************************************************************************/
using System; using System;
using System.Collections.Generic;
using System.Linq; using System.Linq;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
using System.Text; using System.Text;
@@ -51,11 +50,8 @@ namespace DiscImageChef.Filesystems
0x74, 0x00, 0x00, 0x00, 0x00 0x74, 0x00, 0x00, 0x00, 0x00
}; };
Encoding currentEncoding; public FileSystemType XmlFsType { get; private set; }
FileSystemType xmlFsType; public Encoding Encoding { get; private set; }
public FileSystemType XmlFsType => xmlFsType;
public Encoding Encoding => currentEncoding;
public string Name => "Universal Disk Format"; public string Name => "Universal Disk Format";
public Guid Id => new Guid("83976FEC-A91B-464B-9293-56C719461BAB"); public Guid Id => new Guid("83976FEC-A91B-464B-9293-56C719461BAB");
@@ -146,10 +142,11 @@ namespace DiscImageChef.Filesystems
return false; return false;
} }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, Encoding encoding) public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding)
{ {
// UDF is always UTF-8 // UDF is always UTF-8
currentEncoding = Encoding.UTF8; Encoding = Encoding.UTF8;
byte[] sector; byte[] sector;
StringBuilder sbInformation = new StringBuilder(); StringBuilder sbInformation = new StringBuilder();
@@ -255,11 +252,10 @@ namespace DiscImageChef.Filesystems
.AppendFormat("Volume contains {0} files and {1} directories", lvidiu.files, lvidiu.directories) .AppendFormat("Volume contains {0} files and {1} directories", lvidiu.files, lvidiu.directories)
.AppendLine(); .AppendLine();
sbInformation.AppendFormat("Volume conforms to {0}", sbInformation.AppendFormat("Volume conforms to {0}",
currentEncoding.GetString(lvd.domainIdentifier.identifier).TrimEnd('\u0000')) Encoding.GetString(lvd.domainIdentifier.identifier).TrimEnd('\u0000'))
.AppendLine(); .AppendLine();
sbInformation.AppendFormat("Volume was last written by: {0}", sbInformation.AppendFormat("Volume was last written by: {0}",
currentEncoding Encoding.GetString(pvd.implementationIdentifier.identifier).TrimEnd('\u0000'))
.GetString(pvd.implementationIdentifier.identifier).TrimEnd('\u0000'))
.AppendLine(); .AppendLine();
sbInformation.AppendFormat("Volume requires UDF version {0}.{1:X2} to be read", sbInformation.AppendFormat("Volume requires UDF version {0}.{1:X2} to be read",
Convert.ToInt32($"{(lvidiu.minimumReadUDF & 0xFF00) >> 8}", 10), Convert.ToInt32($"{(lvidiu.minimumReadUDF & 0xFF00) >> 8}", 10),
@@ -271,12 +267,11 @@ namespace DiscImageChef.Filesystems
Convert.ToInt32($"{(lvidiu.maximumWriteUDF & 0xFF00) >> 8}", 10), Convert.ToInt32($"{(lvidiu.maximumWriteUDF & 0xFF00) >> 8}", 10),
Convert.ToInt32($"{lvidiu.maximumWriteUDF & 0xFF}", 10)).AppendLine(); Convert.ToInt32($"{lvidiu.maximumWriteUDF & 0xFF}", 10)).AppendLine();
xmlFsType = new FileSystemType XmlFsType = new FileSystemType
{ {
Type = Type =
$"UDF v{Convert.ToInt32($"{(lvidiu.maximumWriteUDF & 0xFF00) >> 8}", 10)}.{Convert.ToInt32($"{lvidiu.maximumWriteUDF & 0xFF}", 10):X2}", $"UDF v{Convert.ToInt32($"{(lvidiu.maximumWriteUDF & 0xFF00) >> 8}", 10)}.{Convert.ToInt32($"{lvidiu.maximumWriteUDF & 0xFF}", 10):X2}",
ApplicationIdentifier = ApplicationIdentifier = Encoding.GetString(pvd.implementationIdentifier.identifier).TrimEnd('\u0000'),
currentEncoding.GetString(pvd.implementationIdentifier.identifier).TrimEnd('\u0000'),
ClusterSize = (int)lvd.logicalBlockSize, ClusterSize = (int)lvd.logicalBlockSize,
ModificationDate = EcmaToDateTime(lvid.recordingDateTime), ModificationDate = EcmaToDateTime(lvid.recordingDateTime),
ModificationDateSpecified = true, ModificationDateSpecified = true,
@@ -284,10 +279,10 @@ namespace DiscImageChef.Filesystems
FilesSpecified = true, FilesSpecified = true,
VolumeName = StringHandlers.DecompressUnicode(lvd.logicalVolumeIdentifier), VolumeName = StringHandlers.DecompressUnicode(lvd.logicalVolumeIdentifier),
VolumeSetIdentifier = StringHandlers.DecompressUnicode(pvd.volumeSetIdentifier), VolumeSetIdentifier = StringHandlers.DecompressUnicode(pvd.volumeSetIdentifier),
SystemIdentifier = currentEncoding.GetString(pvd.implementationIdentifier.identifier).TrimEnd('\u0000') SystemIdentifier = Encoding.GetString(pvd.implementationIdentifier.identifier).TrimEnd('\u0000')
}; };
xmlFsType.Clusters = (long)((partition.End - partition.Start + 1) * imagePlugin.Info.SectorSize / XmlFsType.Clusters = (long)((partition.End - partition.Start + 1) * imagePlugin.Info.SectorSize /
(ulong)xmlFsType.ClusterSize); (ulong)XmlFsType.ClusterSize);
information = sbInformation.ToString(); information = sbInformation.ToString();
} }

22
DiscImageChef.Filesystems/UNICOS.cs
View File

@@ -31,7 +31,6 @@
// ****************************************************************************/ // ****************************************************************************/
using System; using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis; using System.Diagnostics.CodeAnalysis;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
using System.Text; using System.Text;
@@ -57,11 +56,8 @@ namespace DiscImageChef.Filesystems
const ulong UNICOS_Magic = 0x6e6331667331636e; const ulong UNICOS_Magic = 0x6e6331667331636e;
const ulong UNICOS_Secure = 0xcd076d1771d670cd; const ulong UNICOS_Secure = 0xcd076d1771d670cd;
Encoding currentEncoding; public FileSystemType XmlFsType { get; private set; }
FileSystemType xmlFsType; public Encoding Encoding { get; private set; }
public FileSystemType XmlFsType => xmlFsType;
public Encoding Encoding => currentEncoding;
public string Name => "UNICOS Filesystem Plugin"; public string Name => "UNICOS Filesystem Plugin";
public Guid Id => new Guid("61712F04-066C-44D5-A2A0-1E44C66B33F0"); public Guid Id => new Guid("61712F04-066C-44D5-A2A0-1E44C66B33F0");
@@ -85,9 +81,10 @@ namespace DiscImageChef.Filesystems
return unicosSb.s_magic == UNICOS_Magic; return unicosSb.s_magic == UNICOS_Magic;
} }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, Encoding encoding) public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding)
{ {
currentEncoding = encoding ?? Encoding.GetEncoding("iso-8859-15"); Encoding = encoding ?? Encoding.GetEncoding("iso-8859-15");
information = ""; information = "";
if(imagePlugin.Info.SectorSize < 512) return; if(imagePlugin.Info.SectorSize < 512) return;
@@ -116,21 +113,20 @@ namespace DiscImageChef.Filesystems
sb.AppendFormat("Volume last updated on {0}", DateHandlers.UnixToDateTime(unicosSb.s_time)).AppendLine(); sb.AppendFormat("Volume last updated on {0}", DateHandlers.UnixToDateTime(unicosSb.s_time)).AppendLine();
if(unicosSb.s_error > 0) if(unicosSb.s_error > 0)
sb.AppendFormat("Volume is dirty, error code = 0x{0:X16}", unicosSb.s_error).AppendLine(); sb.AppendFormat("Volume is dirty, error code = 0x{0:X16}", unicosSb.s_error).AppendLine();
sb.AppendFormat("Volume name: {0}", StringHandlers.CToString(unicosSb.s_fname, currentEncoding)) sb.AppendFormat("Volume name: {0}", StringHandlers.CToString(unicosSb.s_fname, Encoding)).AppendLine();
.AppendLine();
information = sb.ToString(); information = sb.ToString();
xmlFsType = new FileSystemType XmlFsType = new FileSystemType
{ {
Type = "UNICOS filesystem", Type = "UNICOS filesystem",
ClusterSize = 4096, ClusterSize = 4096,
Clusters = unicosSb.s_fsize, Clusters = unicosSb.s_fsize,
VolumeName = StringHandlers.CToString(unicosSb.s_fname, currentEncoding), VolumeName = StringHandlers.CToString(unicosSb.s_fname, Encoding),
ModificationDate = DateHandlers.UnixToDateTime(unicosSb.s_time), ModificationDate = DateHandlers.UnixToDateTime(unicosSb.s_time),
ModificationDateSpecified = true ModificationDateSpecified = true
}; };
xmlFsType.Dirty |= unicosSb.s_error > 0; XmlFsType.Dirty |= unicosSb.s_error > 0;
} }
[StructLayout(LayoutKind.Sequential, Pack = 1)] [StructLayout(LayoutKind.Sequential, Pack = 1)]

19
DiscImageChef.Filesystems/UNIXBFS.cs
View File

@@ -31,7 +31,6 @@
// ****************************************************************************/ // ****************************************************************************/
using System; using System;
using System.Collections.Generic;
using System.Text; using System.Text;
using DiscImageChef.CommonTypes; using DiscImageChef.CommonTypes;
using DiscImageChef.Console; using DiscImageChef.Console;
@@ -45,11 +44,8 @@ namespace DiscImageChef.Filesystems
{ {
const uint BFS_MAGIC = 0x1BADFACE; const uint BFS_MAGIC = 0x1BADFACE;
Encoding currentEncoding; public FileSystemType XmlFsType { get; private set; }
FileSystemType xmlFsType; public Encoding Encoding { get; private set; }
public FileSystemType XmlFsType => xmlFsType;
public Encoding Encoding => currentEncoding;
public string Name => "UNIX Boot filesystem"; public string Name => "UNIX Boot filesystem";
public Guid Id => new Guid("1E6E0DA6-F7E4-494C-80C6-CB5929E96155"); public Guid Id => new Guid("1E6E0DA6-F7E4-494C-80C6-CB5929E96155");
@@ -64,9 +60,10 @@ namespace DiscImageChef.Filesystems
return magic == BFS_MAGIC; return magic == BFS_MAGIC;
} }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, Encoding encoding) public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding)
{ {
currentEncoding = encoding ?? Encoding.GetEncoding("iso-8859-15"); Encoding = encoding ?? Encoding.GetEncoding("iso-8859-15");
information = ""; information = "";
StringBuilder sb = new StringBuilder(); StringBuilder sb = new StringBuilder();
@@ -85,9 +82,9 @@ namespace DiscImageChef.Filesystems
}; };
Array.Copy(bfsSbSector, 0x1C, sbStrings, 0, 6); Array.Copy(bfsSbSector, 0x1C, sbStrings, 0, 6);
bfsSb.s_fsname = StringHandlers.CToString(sbStrings, currentEncoding); bfsSb.s_fsname = StringHandlers.CToString(sbStrings, Encoding);
Array.Copy(bfsSbSector, 0x22, sbStrings, 0, 6); Array.Copy(bfsSbSector, 0x22, sbStrings, 0, 6);
bfsSb.s_volume = StringHandlers.CToString(sbStrings, currentEncoding); bfsSb.s_volume = StringHandlers.CToString(sbStrings, Encoding);
DicConsole.DebugWriteLine("BFS plugin", "bfs_sb.s_magic: 0x{0:X8}", bfsSb.s_magic); DicConsole.DebugWriteLine("BFS plugin", "bfs_sb.s_magic: 0x{0:X8}", bfsSb.s_magic);
DicConsole.DebugWriteLine("BFS plugin", "bfs_sb.s_start: 0x{0:X8}", bfsSb.s_start); DicConsole.DebugWriteLine("BFS plugin", "bfs_sb.s_start: 0x{0:X8}", bfsSb.s_start);
@@ -105,7 +102,7 @@ namespace DiscImageChef.Filesystems
sb.AppendFormat("Filesystem name: {0}", bfsSb.s_fsname).AppendLine(); sb.AppendFormat("Filesystem name: {0}", bfsSb.s_fsname).AppendLine();
sb.AppendFormat("Volume name: {0}", bfsSb.s_volume).AppendLine(); sb.AppendFormat("Volume name: {0}", bfsSb.s_volume).AppendLine();
xmlFsType = new FileSystemType XmlFsType = new FileSystemType
{ {
Type = "BFS", Type = "BFS",
VolumeName = bfsSb.s_volume, VolumeName = bfsSb.s_volume,

17
DiscImageChef.Filesystems/VMfs.cs
View File

@@ -31,7 +31,6 @@
// ****************************************************************************/ // ****************************************************************************/
using System; using System;
using System.Collections.Generic;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
using System.Text; using System.Text;
using DiscImageChef.CommonTypes; using DiscImageChef.CommonTypes;
@@ -48,11 +47,8 @@ namespace DiscImageChef.Filesystems
const uint VMFS_MAGIC = 0xC001D00D; const uint VMFS_MAGIC = 0xC001D00D;
const uint VMFS_BASE = 0x00100000; const uint VMFS_BASE = 0x00100000;
Encoding currentEncoding; public FileSystemType XmlFsType { get; private set; }
FileSystemType xmlFsType; public Encoding Encoding { get; private set; }
public FileSystemType XmlFsType => xmlFsType;
public Encoding Encoding => currentEncoding;
public string Name => "VMware filesystem"; public string Name => "VMware filesystem";
public Guid Id => new Guid("EE52BDB8-B49C-4122-A3DA-AD21CBE79843"); public Guid Id => new Guid("EE52BDB8-B49C-4122-A3DA-AD21CBE79843");
@@ -71,9 +67,10 @@ namespace DiscImageChef.Filesystems
return magic == VMFS_MAGIC; return magic == VMFS_MAGIC;
} }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, Encoding encoding) public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding)
{ {
currentEncoding = encoding ?? Encoding.UTF8; Encoding = encoding ?? Encoding.UTF8;
ulong vmfsSuperOff = VMFS_BASE / imagePlugin.Info.SectorSize; ulong vmfsSuperOff = VMFS_BASE / imagePlugin.Info.SectorSize;
byte[] sector = imagePlugin.ReadSector(partition.Start + vmfsSuperOff); byte[] sector = imagePlugin.ReadSector(partition.Start + vmfsSuperOff);
@@ -93,7 +90,7 @@ namespace DiscImageChef.Filesystems
uint mtimeNanoSecs = (uint)(volInfo.mtime % 1000000); uint mtimeNanoSecs = (uint)(volInfo.mtime % 1000000);
sbInformation.AppendFormat("Volume version {0}", volInfo.version).AppendLine(); sbInformation.AppendFormat("Volume version {0}", volInfo.version).AppendLine();
sbInformation.AppendFormat("Volume name {0}", StringHandlers.CToString(volInfo.name, currentEncoding)) sbInformation.AppendFormat("Volume name {0}", StringHandlers.CToString(volInfo.name, Encoding))
.AppendLine(); .AppendLine();
sbInformation.AppendFormat("Volume size {0} bytes", volInfo.size * 256).AppendLine(); sbInformation.AppendFormat("Volume size {0} bytes", volInfo.size * 256).AppendLine();
sbInformation.AppendFormat("Volume UUID {0}", volInfo.uuid).AppendLine(); sbInformation.AppendFormat("Volume UUID {0}", volInfo.uuid).AppendLine();
@@ -105,7 +102,7 @@ namespace DiscImageChef.Filesystems
information = sbInformation.ToString(); information = sbInformation.ToString();
xmlFsType = new FileSystemType XmlFsType = new FileSystemType
{ {
Type = "VMware file system", Type = "VMware file system",
CreationDate = DateHandlers.UnixUnsignedToDateTime(ctimeSecs, ctimeNanoSecs), CreationDate = DateHandlers.UnixUnsignedToDateTime(ctimeSecs, ctimeNanoSecs),

17
DiscImageChef.Filesystems/VxFS.cs
View File

@@ -31,7 +31,6 @@
// ****************************************************************************/ // ****************************************************************************/
using System; using System;
using System.Collections.Generic;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
using System.Text; using System.Text;
using DiscImageChef.CommonTypes; using DiscImageChef.CommonTypes;
@@ -48,11 +47,8 @@ namespace DiscImageChef.Filesystems
const uint VXFS_MAGIC = 0xA501FCF5; const uint VXFS_MAGIC = 0xA501FCF5;
const uint VXFS_BASE = 0x400; const uint VXFS_BASE = 0x400;
Encoding currentEncoding; public FileSystemType XmlFsType { get; private set; }
FileSystemType xmlFsType; public Encoding Encoding { get; private set; }
public FileSystemType XmlFsType => xmlFsType;
public Encoding Encoding => currentEncoding;
public string Name => "Veritas filesystem"; public string Name => "Veritas filesystem";
public Guid Id => new Guid("EC372605-7687-453C-8BEA-7E0DFF79CB03"); public Guid Id => new Guid("EC372605-7687-453C-8BEA-7E0DFF79CB03");
@@ -69,9 +65,10 @@ namespace DiscImageChef.Filesystems
return magic == VXFS_MAGIC; return magic == VXFS_MAGIC;
} }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, Encoding encoding) public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding)
{ {
currentEncoding = encoding ?? Encoding.UTF8; Encoding = encoding ?? Encoding.UTF8;
ulong vmfsSuperOff = VXFS_BASE / imagePlugin.Info.SectorSize; ulong vmfsSuperOff = VXFS_BASE / imagePlugin.Info.SectorSize;
byte[] sector = imagePlugin.ReadSector(partition.Start + vmfsSuperOff); byte[] sector = imagePlugin.ReadSector(partition.Start + vmfsSuperOff);
@@ -86,7 +83,7 @@ namespace DiscImageChef.Filesystems
sbInformation.AppendLine("Veritas file system"); sbInformation.AppendLine("Veritas file system");
sbInformation.AppendFormat("Volume version {0}", vxSb.vs_version).AppendLine(); sbInformation.AppendFormat("Volume version {0}", vxSb.vs_version).AppendLine();
sbInformation.AppendFormat("Volume name {0}", StringHandlers.CToString(vxSb.vs_fname, currentEncoding)) sbInformation.AppendFormat("Volume name {0}", StringHandlers.CToString(vxSb.vs_fname, Encoding))
.AppendLine(); .AppendLine();
sbInformation.AppendFormat("Volume has {0} blocks of {1} bytes each", vxSb.vs_bsize, vxSb.vs_size) sbInformation.AppendFormat("Volume has {0} blocks of {1} bytes each", vxSb.vs_bsize, vxSb.vs_size)
.AppendLine(); .AppendLine();
@@ -101,7 +98,7 @@ namespace DiscImageChef.Filesystems
information = sbInformation.ToString(); information = sbInformation.ToString();
xmlFsType = new FileSystemType XmlFsType = new FileSystemType
{ {
Type = "Veritas file system", Type = "Veritas file system",
CreationDate = DateHandlers.UnixUnsignedToDateTime(vxSb.vs_ctime, vxSb.vs_cutime), CreationDate = DateHandlers.UnixUnsignedToDateTime(vxSb.vs_ctime, vxSb.vs_cutime),

19
DiscImageChef.Filesystems/XFS.cs
View File

@@ -31,7 +31,6 @@
// ****************************************************************************/ // ****************************************************************************/
using System; using System;
using System.Collections.Generic;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
using System.Text; using System.Text;
using DiscImageChef.CommonTypes; using DiscImageChef.CommonTypes;
@@ -45,11 +44,8 @@ namespace DiscImageChef.Filesystems
{ {
const uint XFS_MAGIC = 0x58465342; const uint XFS_MAGIC = 0x58465342;
Encoding currentEncoding; public FileSystemType XmlFsType { get; private set; }
FileSystemType xmlFsType; public Encoding Encoding { get; private set; }
public FileSystemType XmlFsType => xmlFsType;
public Encoding Encoding => currentEncoding;
public string Name => "XFS Filesystem Plugin"; public string Name => "XFS Filesystem Plugin";
public Guid Id => new Guid("1D8CD8B8-27E6-410F-9973-D16409225FBA"); public Guid Id => new Guid("1D8CD8B8-27E6-410F-9973-D16409225FBA");
@@ -104,9 +100,10 @@ namespace DiscImageChef.Filesystems
return false; return false;
} }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, Encoding encoding) public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding)
{ {
currentEncoding = encoding ?? Encoding.GetEncoding("iso-8859-15"); Encoding = encoding ?? Encoding.GetEncoding("iso-8859-15");
information = ""; information = "";
if(imagePlugin.Info.SectorSize < 512) return; if(imagePlugin.Info.SectorSize < 512) return;
@@ -166,12 +163,12 @@ namespace DiscImageChef.Filesystems
sb.AppendFormat("{0} allocation groups in volume", xfsSb.agcount).AppendLine(); sb.AppendFormat("{0} allocation groups in volume", xfsSb.agcount).AppendLine();
sb.AppendFormat("{0} inodes in volume, {1} free", xfsSb.icount, xfsSb.ifree).AppendLine(); sb.AppendFormat("{0} inodes in volume, {1} free", xfsSb.icount, xfsSb.ifree).AppendLine();
if(xfsSb.inprogress > 0) sb.AppendLine("fsck in progress"); if(xfsSb.inprogress > 0) sb.AppendLine("fsck in progress");
sb.AppendFormat("Volume name: {0}", StringHandlers.CToString(xfsSb.fname, currentEncoding)).AppendLine(); sb.AppendFormat("Volume name: {0}", StringHandlers.CToString(xfsSb.fname, Encoding)).AppendLine();
sb.AppendFormat("Volume UUID: {0}", xfsSb.uuid).AppendLine(); sb.AppendFormat("Volume UUID: {0}", xfsSb.uuid).AppendLine();
information = sb.ToString(); information = sb.ToString();
xmlFsType = new FileSystemType XmlFsType = new FileSystemType
{ {
Type = "XFS filesystem", Type = "XFS filesystem",
ClusterSize = (int)xfsSb.blocksize, ClusterSize = (int)xfsSb.blocksize,
@@ -181,7 +178,7 @@ namespace DiscImageChef.Filesystems
Files = (long)(xfsSb.icount - xfsSb.ifree), Files = (long)(xfsSb.icount - xfsSb.ifree),
FilesSpecified = true, FilesSpecified = true,
Dirty = xfsSb.inprogress > 0, Dirty = xfsSb.inprogress > 0,
VolumeName = StringHandlers.CToString(xfsSb.fname, currentEncoding), VolumeName = StringHandlers.CToString(xfsSb.fname, Encoding),
VolumeSerial = xfsSb.uuid.ToString() VolumeSerial = xfsSb.uuid.ToString()
}; };
} }

14
DiscImageChef.Filesystems/Xia.cs
View File

@@ -31,7 +31,6 @@
// ****************************************************************************/ // ****************************************************************************/
using System; using System;
using System.Collections.Generic;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
using System.Text; using System.Text;
using DiscImageChef.CommonTypes; using DiscImageChef.CommonTypes;
@@ -51,10 +50,8 @@ namespace DiscImageChef.Filesystems
const int XIAFS_NUM_BLOCK_POINTERS = 10; const int XIAFS_NUM_BLOCK_POINTERS = 10;
const int XIAFS_NAME_LEN = 248; const int XIAFS_NAME_LEN = 248;
Encoding currentEncoding; public FileSystemType XmlFsType { get; private set; }
FileSystemType xmlFsType; public Encoding Encoding { get; private set; }
public FileSystemType XmlFsType => xmlFsType;
public Encoding Encoding => currentEncoding;
public string Name => "Xia filesystem"; public string Name => "Xia filesystem";
public Guid Id => new Guid("169E1DE5-24F2-4EF6-A04D-A4B2CA66DE9D"); public Guid Id => new Guid("169E1DE5-24F2-4EF6-A04D-A4B2CA66DE9D");
@@ -74,9 +71,10 @@ namespace DiscImageChef.Filesystems
return supblk.s_magic == XIAFS_SUPER_MAGIC; return supblk.s_magic == XIAFS_SUPER_MAGIC;
} }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, Encoding encoding) public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding)
{ {
currentEncoding = encoding ?? Encoding.GetEncoding("iso-8859-15"); Encoding = encoding ?? Encoding.GetEncoding("iso-8859-15");
information = ""; information = "";
StringBuilder sb = new StringBuilder(); StringBuilder sb = new StringBuilder();
@@ -108,7 +106,7 @@ namespace DiscImageChef.Filesystems
supblk.s_kernzones * supblk.s_zone_size).AppendLine(); supblk.s_kernzones * supblk.s_zone_size).AppendLine();
sb.AppendFormat("First kernel zone: {0}", supblk.s_firstkernzone).AppendLine(); sb.AppendFormat("First kernel zone: {0}", supblk.s_firstkernzone).AppendLine();
xmlFsType = new FileSystemType XmlFsType = new FileSystemType
{ {
Bootable = !ArrayHelpers.ArrayIsNullOrEmpty(supblk.s_boot_segment), Bootable = !ArrayHelpers.ArrayIsNullOrEmpty(supblk.s_boot_segment),
Clusters = supblk.s_nzones, Clusters = supblk.s_nzones,

16
DiscImageChef.Filesystems/ZFS.cs
View File

@@ -76,10 +76,8 @@ namespace DiscImageChef.Filesystems
const uint ZFS_MAGIC = 0x58465342; const uint ZFS_MAGIC = 0x58465342;
Encoding currentEncoding; public FileSystemType XmlFsType { get; private set; }
FileSystemType xmlFsType; public Encoding Encoding { get; private set; }
public FileSystemType XmlFsType => xmlFsType;
public Encoding Encoding => currentEncoding;
public string Name => "ZFS Filesystem Plugin"; public string Name => "ZFS Filesystem Plugin";
public Guid Id => new Guid("0750014F-A714-4692-A369-E23F6EC3659C"); public Guid Id => new Guid("0750014F-A714-4692-A369-E23F6EC3659C");
@@ -108,7 +106,7 @@ namespace DiscImageChef.Filesystems
Encoding encoding) Encoding encoding)
{ {
// ZFS is always UTF-8 // ZFS is always UTF-8
currentEncoding = Encoding.UTF8; Encoding = Encoding.UTF8;
information = ""; information = "";
if(imagePlugin.Info.SectorSize < 512) return; if(imagePlugin.Info.SectorSize < 512) return;
@@ -143,11 +141,11 @@ namespace DiscImageChef.Filesystems
information = sb.ToString(); information = sb.ToString();
xmlFsType = new FileSystemType {Type = "ZFS filesystem"}; XmlFsType = new FileSystemType {Type = "ZFS filesystem"};
if(decodedNvList.TryGetValue("name", out NVS_Item tmpObj)) xmlFsType.VolumeName = (string)tmpObj.value; if(decodedNvList.TryGetValue("name", out NVS_Item tmpObj)) XmlFsType.VolumeName = (string)tmpObj.value;
if(decodedNvList.TryGetValue("guid", out tmpObj)) xmlFsType.VolumeSerial = $"{(ulong)tmpObj.value}"; if(decodedNvList.TryGetValue("guid", out tmpObj)) XmlFsType.VolumeSerial = $"{(ulong)tmpObj.value}";
if(decodedNvList.TryGetValue("pool_guid", out tmpObj)) if(decodedNvList.TryGetValue("pool_guid", out tmpObj))
xmlFsType.VolumeSetIdentifier = $"{(ulong)tmpObj.value}"; XmlFsType.VolumeSetIdentifier = $"{(ulong)tmpObj.value}";
} }
static bool DecodeNvList(byte[] nvlist, out Dictionary<string, NVS_Item> decodedNvList) static bool DecodeNvList(byte[] nvlist, out Dictionary<string, NVS_Item> decodedNvList)

73
DiscImageChef.Filesystems/dump.cs
View File

@@ -31,7 +31,6 @@
// ****************************************************************************/ // ****************************************************************************/
using System; using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis; using System.Diagnostics.CodeAnalysis;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
using System.Text; using System.Text;
@@ -99,12 +98,10 @@ namespace DiscImageChef.Filesystems
const int NDADDR = 12; const int NDADDR = 12;
const int NIADDR = 3; const int NIADDR = 3;
Encoding currentEncoding; public Encoding Encoding { get; private set; }
public Encoding Encoding => currentEncoding;
public string Name => "dump(8) Plugin"; public string Name => "dump(8) Plugin";
public Guid Id => new Guid("E53B4D28-C858-4800-B092-DDAE80D361B9"); public Guid Id => new Guid("E53B4D28-C858-4800-B092-DDAE80D361B9");
FileSystemType xmlFsType; public FileSystemType XmlFsType { get; private set; }
public FileSystemType XmlFsType => xmlFsType;
public bool Identify(IMediaImage imagePlugin, Partition partition) public bool Identify(IMediaImage imagePlugin, Partition partition)
{ {
@@ -148,9 +145,9 @@ namespace DiscImageChef.Filesystems
} }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding) Encoding encoding)
{ {
currentEncoding = encoding ?? Encoding.GetEncoding("iso-8859-15"); Encoding = encoding ?? Encoding.GetEncoding("iso-8859-15");
information = ""; information = "";
if(imagePlugin.Info.SectorSize < 512) return; if(imagePlugin.Info.SectorSize < 512) return;
@@ -213,71 +210,71 @@ namespace DiscImageChef.Filesystems
StringBuilder sb = new StringBuilder(); StringBuilder sb = new StringBuilder();
xmlFsType = new FileSystemType {ClusterSize = 1024, Clusters = (long)(partition.Size / 1024)}; XmlFsType = new FileSystemType {ClusterSize = 1024, Clusters = (long)(partition.Size / 1024)};
if(useOld) if(useOld)
{ {
xmlFsType.Type = "Old 16-bit dump(8)"; XmlFsType.Type = "Old 16-bit dump(8)";
sb.AppendLine(xmlFsType.Type); sb.AppendLine(XmlFsType.Type);
if(oldHdr.c_date > 0) if(oldHdr.c_date > 0)
{ {
xmlFsType.CreationDate = DateHandlers.UnixToDateTime(oldHdr.c_date); XmlFsType.CreationDate = DateHandlers.UnixToDateTime(oldHdr.c_date);
xmlFsType.CreationDateSpecified = true; XmlFsType.CreationDateSpecified = true;
sb.AppendFormat("Dump created on {0}", xmlFsType.CreationDate).AppendLine(); sb.AppendFormat("Dump created on {0}", XmlFsType.CreationDate).AppendLine();
} }
if(oldHdr.c_ddate > 0) if(oldHdr.c_ddate > 0)
{ {
xmlFsType.BackupDate = DateHandlers.UnixToDateTime(oldHdr.c_ddate); XmlFsType.BackupDate = DateHandlers.UnixToDateTime(oldHdr.c_ddate);
xmlFsType.BackupDateSpecified = true; XmlFsType.BackupDateSpecified = true;
sb.AppendFormat("Previous dump created on {0}", xmlFsType.BackupDate).AppendLine(); sb.AppendFormat("Previous dump created on {0}", XmlFsType.BackupDate).AppendLine();
} }
sb.AppendFormat("Dump volume number: {0}", oldHdr.c_volume).AppendLine(); sb.AppendFormat("Dump volume number: {0}", oldHdr.c_volume).AppendLine();
} }
else if(useAix) else if(useAix)
{ {
xmlFsType.Type = "AIX dump(8)"; XmlFsType.Type = "AIX dump(8)";
sb.AppendLine(xmlFsType.Type); sb.AppendLine(XmlFsType.Type);
if(aixHdr.c_date > 0) if(aixHdr.c_date > 0)
{ {
xmlFsType.CreationDate = DateHandlers.UnixToDateTime(aixHdr.c_date); XmlFsType.CreationDate = DateHandlers.UnixToDateTime(aixHdr.c_date);
xmlFsType.CreationDateSpecified = true; XmlFsType.CreationDateSpecified = true;
sb.AppendFormat("Dump created on {0}", xmlFsType.CreationDate).AppendLine(); sb.AppendFormat("Dump created on {0}", XmlFsType.CreationDate).AppendLine();
} }
if(aixHdr.c_ddate > 0) if(aixHdr.c_ddate > 0)
{ {
xmlFsType.BackupDate = DateHandlers.UnixToDateTime(aixHdr.c_ddate); XmlFsType.BackupDate = DateHandlers.UnixToDateTime(aixHdr.c_ddate);
xmlFsType.BackupDateSpecified = true; XmlFsType.BackupDateSpecified = true;
sb.AppendFormat("Previous dump created on {0}", xmlFsType.BackupDate).AppendLine(); sb.AppendFormat("Previous dump created on {0}", XmlFsType.BackupDate).AppendLine();
} }
sb.AppendFormat("Dump volume number: {0}", aixHdr.c_volume).AppendLine(); sb.AppendFormat("Dump volume number: {0}", aixHdr.c_volume).AppendLine();
} }
else else
{ {
xmlFsType.Type = "dump(8)"; XmlFsType.Type = "dump(8)";
sb.AppendLine(xmlFsType.Type); sb.AppendLine(XmlFsType.Type);
if(newHdr.c_ndate > 0) if(newHdr.c_ndate > 0)
{ {
xmlFsType.CreationDate = DateHandlers.UnixToDateTime(newHdr.c_ndate); XmlFsType.CreationDate = DateHandlers.UnixToDateTime(newHdr.c_ndate);
xmlFsType.CreationDateSpecified = true; XmlFsType.CreationDateSpecified = true;
sb.AppendFormat("Dump created on {0}", xmlFsType.CreationDate).AppendLine(); sb.AppendFormat("Dump created on {0}", XmlFsType.CreationDate).AppendLine();
} }
else if(newHdr.c_date > 0) else if(newHdr.c_date > 0)
{ {
xmlFsType.CreationDate = DateHandlers.UnixToDateTime(newHdr.c_date); XmlFsType.CreationDate = DateHandlers.UnixToDateTime(newHdr.c_date);
xmlFsType.CreationDateSpecified = true; XmlFsType.CreationDateSpecified = true;
sb.AppendFormat("Dump created on {0}", xmlFsType.CreationDate).AppendLine(); sb.AppendFormat("Dump created on {0}", XmlFsType.CreationDate).AppendLine();
} }
if(newHdr.c_nddate > 0) if(newHdr.c_nddate > 0)
{ {
xmlFsType.BackupDate = DateHandlers.UnixToDateTime(newHdr.c_nddate); XmlFsType.BackupDate = DateHandlers.UnixToDateTime(newHdr.c_nddate);
xmlFsType.BackupDateSpecified = true; XmlFsType.BackupDateSpecified = true;
sb.AppendFormat("Previous dump created on {0}", xmlFsType.BackupDate).AppendLine(); sb.AppendFormat("Previous dump created on {0}", XmlFsType.BackupDate).AppendLine();
} }
else if(newHdr.c_ddate > 0) else if(newHdr.c_ddate > 0)
{ {
xmlFsType.BackupDate = DateHandlers.UnixToDateTime(newHdr.c_ddate); XmlFsType.BackupDate = DateHandlers.UnixToDateTime(newHdr.c_ddate);
xmlFsType.BackupDateSpecified = true; XmlFsType.BackupDateSpecified = true;
sb.AppendFormat("Previous dump created on {0}", xmlFsType.BackupDate).AppendLine(); sb.AppendFormat("Previous dump created on {0}", XmlFsType.BackupDate).AppendLine();
} }
sb.AppendFormat("Dump volume number: {0}", newHdr.c_volume).AppendLine(); sb.AppendFormat("Dump volume number: {0}", newHdr.c_volume).AppendLine();
sb.AppendFormat("Dump level: {0}", newHdr.c_level).AppendLine(); sb.AppendFormat("Dump level: {0}", newHdr.c_level).AppendLine();

23
DiscImageChef.Filesystems/exFAT.cs
View File

@@ -31,7 +31,6 @@
// ****************************************************************************/ // ****************************************************************************/
using System; using System;
using System.Collections.Generic;
using System.Linq; using System.Linq;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
using System.Text; using System.Text;
@@ -47,11 +46,9 @@ namespace DiscImageChef.Filesystems
readonly Guid OEM_FLASH_PARAMETER_GUID = new Guid("0A0C7E46-3399-4021-90C8-FA6D389C4BA2"); readonly Guid OEM_FLASH_PARAMETER_GUID = new Guid("0A0C7E46-3399-4021-90C8-FA6D389C4BA2");
readonly byte[] Signature = {0x45, 0x58, 0x46, 0x41, 0x54, 0x20, 0x20, 0x20}; readonly byte[] Signature = {0x45, 0x58, 0x46, 0x41, 0x54, 0x20, 0x20, 0x20};
FileSystemType xmlFsType;
public FileSystemType XmlFsType => xmlFsType;
Encoding currentEncoding; public FileSystemType XmlFsType { get; private set; }
public Encoding Encoding => currentEncoding; public Encoding Encoding { get; private set; }
public string Name => "Microsoft Extended File Allocation Table"; public string Name => "Microsoft Extended File Allocation Table";
public Guid Id => new Guid("8271D088-1533-4CB3-AC28-D802B68BB95C"); public Guid Id => new Guid("8271D088-1533-4CB3-AC28-D802B68BB95C");
@@ -71,13 +68,13 @@ namespace DiscImageChef.Filesystems
} }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding) Encoding encoding)
{ {
currentEncoding = encoding ?? Encoding.GetEncoding("iso-8859-15"); Encoding = encoding ?? Encoding.GetEncoding("iso-8859-15");
information = ""; information = "";
StringBuilder sb = new StringBuilder(); StringBuilder sb = new StringBuilder();
xmlFsType = new FileSystemType(); XmlFsType = new FileSystemType();
byte[] vbrSector = imagePlugin.ReadSector(0 + partition.Start); byte[] vbrSector = imagePlugin.ReadSector(0 + partition.Start);
IntPtr vbrPtr = Marshal.AllocHGlobal(512); IntPtr vbrPtr = Marshal.AllocHGlobal(512);
@@ -139,11 +136,11 @@ namespace DiscImageChef.Filesystems
sb.AppendFormat("Checksum 0x{0:X8}", chksector.checksum[0]).AppendLine(); sb.AppendFormat("Checksum 0x{0:X8}", chksector.checksum[0]).AppendLine();
xmlFsType.ClusterSize = (1 << vbr.sectorShift) * (1 << vbr.clusterShift); XmlFsType.ClusterSize = (1 << vbr.sectorShift) * (1 << vbr.clusterShift);
xmlFsType.Clusters = vbr.clusterHeapLength; XmlFsType.Clusters = vbr.clusterHeapLength;
xmlFsType.Dirty = vbr.flags.HasFlag(VolumeFlags.VolumeDirty); XmlFsType.Dirty = vbr.flags.HasFlag(VolumeFlags.VolumeDirty);
xmlFsType.Type = "exFAT"; XmlFsType.Type = "exFAT";
xmlFsType.VolumeSerial = $"{vbr.volumeSerial:X8}"; XmlFsType.VolumeSerial = $"{vbr.volumeSerial:X8}";
information = sb.ToString(); information = sb.ToString();
} }

61
DiscImageChef.Filesystems/ext2FS.cs
View File

@@ -31,7 +31,6 @@
// ****************************************************************************/ // ****************************************************************************/
using System; using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis; using System.Diagnostics.CodeAnalysis;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
using System.Text; using System.Text;
@@ -162,11 +161,8 @@ namespace DiscImageChef.Filesystems
/// <summary>Testing development code</summary> /// <summary>Testing development code</summary>
const uint EXT2_FLAGS_TEST_FILESYS = 0x00000004; const uint EXT2_FLAGS_TEST_FILESYS = 0x00000004;
Encoding currentEncoding; public FileSystemType XmlFsType { get; private set; }
FileSystemType xmlFsType; public Encoding Encoding { get; private set; }
public FileSystemType XmlFsType => xmlFsType;
public Encoding Encoding => currentEncoding;
public string Name => "Linux extended Filesystem 2, 3 and 4"; public string Name => "Linux extended Filesystem 2, 3 and 4";
public Guid Id => new Guid("6AA91B88-150B-4A7B-AD56-F84FB2DF4184"); public Guid Id => new Guid("6AA91B88-150B-4A7B-AD56-F84FB2DF4184");
@@ -190,9 +186,10 @@ namespace DiscImageChef.Filesystems
return magic == EXT2_MAGIC || magic == EXT2_MAGIC_OLD; return magic == EXT2_MAGIC || magic == EXT2_MAGIC_OLD;
} }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, Encoding encoding) public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding)
{ {
currentEncoding = encoding ?? Encoding.GetEncoding("iso-8859-15"); Encoding = encoding ?? Encoding.GetEncoding("iso-8859-15");
information = ""; information = "";
StringBuilder sb = new StringBuilder(); StringBuilder sb = new StringBuilder();
@@ -216,13 +213,13 @@ namespace DiscImageChef.Filesystems
ext2FSSuperBlock supblk = (ext2FSSuperBlock)Marshal.PtrToStructure(sbPtr, typeof(ext2FSSuperBlock)); ext2FSSuperBlock supblk = (ext2FSSuperBlock)Marshal.PtrToStructure(sbPtr, typeof(ext2FSSuperBlock));
Marshal.FreeHGlobal(sbPtr); Marshal.FreeHGlobal(sbPtr);
xmlFsType = new FileSystemType(); XmlFsType = new FileSystemType();
switch(supblk.magic) switch(supblk.magic)
{ {
case EXT2_MAGIC_OLD: case EXT2_MAGIC_OLD:
sb.AppendLine("ext2 (old) filesystem"); sb.AppendLine("ext2 (old) filesystem");
xmlFsType.Type = "ext2"; XmlFsType.Type = "ext2";
break; break;
case EXT2_MAGIC: case EXT2_MAGIC:
ext3 |= (supblk.ftr_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL) == EXT3_FEATURE_COMPAT_HAS_JOURNAL || ext3 |= (supblk.ftr_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL) == EXT3_FEATURE_COMPAT_HAS_JOURNAL ||
@@ -250,17 +247,17 @@ namespace DiscImageChef.Filesystems
if(newExt2) if(newExt2)
{ {
sb.AppendLine("ext2 filesystem"); sb.AppendLine("ext2 filesystem");
xmlFsType.Type = "ext2"; XmlFsType.Type = "ext2";
} }
if(ext3) if(ext3)
{ {
sb.AppendLine("ext3 filesystem"); sb.AppendLine("ext3 filesystem");
xmlFsType.Type = "ext3"; XmlFsType.Type = "ext3";
} }
if(ext4) if(ext4)
{ {
sb.AppendLine("ext4 filesystem"); sb.AppendLine("ext4 filesystem");
xmlFsType.Type = "ext4"; XmlFsType.Type = "ext4";
} }
break; break;
default: default:
@@ -291,14 +288,14 @@ namespace DiscImageChef.Filesystems
break; break;
} }
xmlFsType.SystemIdentifier = extOs; XmlFsType.SystemIdentifier = extOs;
if(supblk.mkfs_t > 0) if(supblk.mkfs_t > 0)
{ {
sb.AppendFormat("Volume was created on {0} for {1}", DateHandlers.UnixUnsignedToDateTime(supblk.mkfs_t), sb.AppendFormat("Volume was created on {0} for {1}", DateHandlers.UnixUnsignedToDateTime(supblk.mkfs_t),
extOs).AppendLine(); extOs).AppendLine();
xmlFsType.CreationDate = DateHandlers.UnixUnsignedToDateTime(supblk.mkfs_t); XmlFsType.CreationDate = DateHandlers.UnixUnsignedToDateTime(supblk.mkfs_t);
xmlFsType.CreationDateSpecified = true; XmlFsType.CreationDateSpecified = true;
} }
else sb.AppendFormat("Volume was created for {0}", extOs).AppendLine(); else sb.AppendFormat("Volume was created for {0}", extOs).AppendLine();
@@ -356,8 +353,8 @@ namespace DiscImageChef.Filesystems
sb.AppendFormat("Volume has {0} blocks of {1} bytes, for a total of {2} bytes", blocks, sb.AppendFormat("Volume has {0} blocks of {1} bytes, for a total of {2} bytes", blocks,
1024 << (int)supblk.block_size, blocks * (ulong)(1024 << (int)supblk.block_size)) 1024 << (int)supblk.block_size, blocks * (ulong)(1024 << (int)supblk.block_size))
.AppendLine(); .AppendLine();
xmlFsType.Clusters = (long)blocks; XmlFsType.Clusters = (long)blocks;
xmlFsType.ClusterSize = 1024 << (int)supblk.block_size; XmlFsType.ClusterSize = 1024 << (int)supblk.block_size;
if(supblk.mount_t > 0 || supblk.mount_c > 0) if(supblk.mount_t > 0 || supblk.mount_c > 0)
{ {
if(supblk.mount_t > 0) if(supblk.mount_t > 0)
@@ -369,12 +366,12 @@ namespace DiscImageChef.Filesystems
else else
sb.AppendFormat("Volume has been mounted {0} times with no maximum no. of mounts before checking", sb.AppendFormat("Volume has been mounted {0} times with no maximum no. of mounts before checking",
supblk.mount_c).AppendLine(); supblk.mount_c).AppendLine();
if(!string.IsNullOrEmpty(StringHandlers.CToString(supblk.last_mount_dir, currentEncoding))) if(!string.IsNullOrEmpty(StringHandlers.CToString(supblk.last_mount_dir, Encoding)))
sb.AppendFormat("Last mounted on: \"{0}\"", sb.AppendFormat("Last mounted on: \"{0}\"",
StringHandlers.CToString(supblk.last_mount_dir, currentEncoding)).AppendLine(); StringHandlers.CToString(supblk.last_mount_dir, Encoding)).AppendLine();
if(!string.IsNullOrEmpty(StringHandlers.CToString(supblk.mount_options, currentEncoding))) if(!string.IsNullOrEmpty(StringHandlers.CToString(supblk.mount_options, Encoding)))
sb.AppendFormat("Last used mount options were: {0}", sb.AppendFormat("Last used mount options were: {0}",
StringHandlers.CToString(supblk.mount_options, currentEncoding)).AppendLine(); StringHandlers.CToString(supblk.mount_options, Encoding)).AppendLine();
} }
else else
{ {
@@ -403,17 +400,17 @@ namespace DiscImageChef.Filesystems
{ {
sb.AppendFormat("Last written on {0}", DateHandlers.UnixUnsignedToDateTime(supblk.write_t)) sb.AppendFormat("Last written on {0}", DateHandlers.UnixUnsignedToDateTime(supblk.write_t))
.AppendLine(); .AppendLine();
xmlFsType.ModificationDate = DateHandlers.UnixUnsignedToDateTime(supblk.write_t); XmlFsType.ModificationDate = DateHandlers.UnixUnsignedToDateTime(supblk.write_t);
xmlFsType.ModificationDateSpecified = true; XmlFsType.ModificationDateSpecified = true;
} }
else sb.AppendLine("Volume has never been written"); else sb.AppendLine("Volume has never been written");
xmlFsType.Dirty = true; XmlFsType.Dirty = true;
switch(supblk.state) switch(supblk.state)
{ {
case EXT2_VALID_FS: case EXT2_VALID_FS:
sb.AppendLine("Volume is clean"); sb.AppendLine("Volume is clean");
xmlFsType.Dirty = false; XmlFsType.Dirty = false;
break; break;
case EXT2_ERROR_FS: case EXT2_ERROR_FS:
sb.AppendLine("Volume is dirty"); sb.AppendLine("Volume is dirty");
@@ -426,11 +423,11 @@ namespace DiscImageChef.Filesystems
break; break;
} }
if(!string.IsNullOrEmpty(StringHandlers.CToString(supblk.volume_name, currentEncoding))) if(!string.IsNullOrEmpty(StringHandlers.CToString(supblk.volume_name, Encoding)))
{ {
sb.AppendFormat("Volume name: \"{0}\"", StringHandlers.CToString(supblk.volume_name, currentEncoding)) sb.AppendFormat("Volume name: \"{0}\"", StringHandlers.CToString(supblk.volume_name, Encoding))
.AppendLine(); .AppendLine();
xmlFsType.VolumeName = StringHandlers.CToString(supblk.volume_name, currentEncoding); XmlFsType.VolumeName = StringHandlers.CToString(supblk.volume_name, Encoding);
} }
switch(supblk.err_behaviour) switch(supblk.err_behaviour)
@@ -456,15 +453,15 @@ namespace DiscImageChef.Filesystems
if(supblk.uuid != Guid.Empty) if(supblk.uuid != Guid.Empty)
{ {
sb.AppendFormat("Volume UUID: {0}", supblk.uuid).AppendLine(); sb.AppendFormat("Volume UUID: {0}", supblk.uuid).AppendLine();
xmlFsType.VolumeSerial = supblk.uuid.ToString(); XmlFsType.VolumeSerial = supblk.uuid.ToString();
} }
if(supblk.kbytes_written > 0) if(supblk.kbytes_written > 0)
sb.AppendFormat("{0} KiB has been written on volume", supblk.kbytes_written).AppendLine(); sb.AppendFormat("{0} KiB has been written on volume", supblk.kbytes_written).AppendLine();
sb.AppendFormat("{0} reserved and {1} free blocks", reserved, free).AppendLine(); sb.AppendFormat("{0} reserved and {1} free blocks", reserved, free).AppendLine();
xmlFsType.FreeClusters = (long)free; XmlFsType.FreeClusters = (long)free;
xmlFsType.FreeClustersSpecified = true; XmlFsType.FreeClustersSpecified = true;
sb.AppendFormat("{0} inodes with {1} free inodes ({2}%)", supblk.inodes, supblk.free_inodes, sb.AppendFormat("{0} inodes with {1} free inodes ({2}%)", supblk.inodes, supblk.free_inodes,
supblk.free_inodes * 100 / supblk.inodes).AppendLine(); supblk.free_inodes * 100 / supblk.inodes).AppendLine();
if(supblk.first_inode > 0) sb.AppendFormat("First inode is {0}", supblk.first_inode).AppendLine(); if(supblk.first_inode > 0) sb.AppendFormat("First inode is {0}", supblk.first_inode).AppendLine();

13
DiscImageChef.Filesystems/extFS.cs
View File

@@ -31,7 +31,6 @@
// ****************************************************************************/ // ****************************************************************************/
using System; using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis; using System.Diagnostics.CodeAnalysis;
using System.Text; using System.Text;
using DiscImageChef.CommonTypes; using DiscImageChef.CommonTypes;
@@ -49,13 +48,11 @@ namespace DiscImageChef.Filesystems
/// ext superblock magic /// ext superblock magic
/// </summary> /// </summary>
const ushort EXT_MAGIC = 0x137D; const ushort EXT_MAGIC = 0x137D;
Encoding currentEncoding;
FileSystemType xmlFsType;
public FileSystemType XmlFsType => xmlFsType;
public FileSystemType XmlFsType { get; private set; }
public string Name => "Linux extended Filesystem"; public string Name => "Linux extended Filesystem";
public Guid Id => new Guid("076CB3A2-08C2-4D69-BC8A-FCAA2E502BE2"); public Guid Id => new Guid("076CB3A2-08C2-4D69-BC8A-FCAA2E502BE2");
public Encoding Encoding => currentEncoding; public Encoding Encoding { get; private set; }
public bool Identify(IMediaImage imagePlugin, Partition partition) public bool Identify(IMediaImage imagePlugin, Partition partition)
{ {
@@ -76,9 +73,9 @@ namespace DiscImageChef.Filesystems
} }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding) Encoding encoding)
{ {
currentEncoding = encoding ?? Encoding.GetEncoding("iso-8859-15"); Encoding = encoding ?? Encoding.GetEncoding("iso-8859-15");
information = ""; information = "";
StringBuilder sb = new StringBuilder(); StringBuilder sb = new StringBuilder();
@@ -118,7 +115,7 @@ namespace DiscImageChef.Filesystems
sb.AppendFormat("Log zone size: {0}", extSb.logzonesize); sb.AppendFormat("Log zone size: {0}", extSb.logzonesize);
sb.AppendFormat("Max zone size: {0}", extSb.maxsize); sb.AppendFormat("Max zone size: {0}", extSb.maxsize);
xmlFsType = new FileSystemType XmlFsType = new FileSystemType
{ {
Type = "ext", Type = "ext",
FreeClusters = extSb.freecountblk, FreeClusters = extSb.freecountblk,