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

* DiscImageChef.DiscImages/CPCDSK.cs:

Browse Source 
* DiscImageChef.DiscImages/DiscImageChef.DiscImages.csproj:
	  Added CPCEMU Disk File and Extended Disk File.

	* TODO:
	* README.md:
	* DiscImageChef.Filesystems/CPM/CPM.cs:
	* DiscImageChef.Filesystems/CPM/Dir.cs:
	* DiscImageChef.Filesystems/CPM/Info.cs:
	* DiscImageChef.Filesystems/CPM/File.cs:
	* DiscImageChef.Filesystems/CPM/Xattr.cs:
	* DiscImageChef.Filesystems/CPM/Super.cs:
	* DiscImageChef.Filesystems/CPM/Consts.cs:
	* DiscImageChef.Filesystems/CPM/Structs.cs:
	* DiscImageChef.Filesystems/CPM/cpmdefs.xml:
	* DiscImageChef.Filesystems/CPM/Definitions.cs:
	* DiscImageChef.Filesystems/DiscImageChef.Filesystems.csproj:
	  Added CP/M filesystem, closes #29.
This commit is contained in:
Natalia Portillo
2016-08-26 01:45:58 +01:00
parent f9bb6f25c8
commit 458853bef5
17 changed files with 3700 additions and 486 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -5,11 +5,11 @@
// Filename : CPM.cs
// Author(s) : Natalia Portillo <claunia@claunia.com>
//
// Component : Component
// Component : CP/M filesystem plugin.
//
// --[ Description ] ----------------------------------------------------------
//
// Description
// Constructors and common variables for the CP/M filesystem plugin.
//
// --[ License ] --------------------------------------------------------------
//
@@ -29,13 +29,99 @@
// ----------------------------------------------------------------------------
// Copyright © 2011-2016 Natalia Portillo
// ****************************************************************************/
using System;
using System.Collections.Generic;
using DiscImageChef.ImagePlugins;
namespace DiscImageChef.Filesystems.CPM
{
public class CPM
partial class CPM : Filesystem
{
bool mounted;
readonly ImagePlugin device;
ulong partStart;
ulong partEnd;
/// <summary>
/// Stores all known CP/M disk definitions
/// </summary>
CpmDefinitions definitions;
/// <summary>
/// True if <see cref="Identify"/> thinks this is a CP/M filesystem
/// </summary>
bool cpmFound;
/// <summary>
/// If <see cref="Identify"/> thinks this is a CP/M filesystem, this is the definition for it
/// </summary>
CpmDefinition workingDefinition;
/// <summary>
/// CP/M disc parameter block (on-memory)
/// </summary>
DiscParameterBlock dpb;
/// <summary>
/// Sector deinterleaving mask
/// </summary>
int[] sectorMask;
/// <summary>
/// The volume label, if the CP/M filesystem contains one
/// </summary>
string label;
/// <summary>
/// True if there are timestamps in Z80DOS or DOS+ format
/// </summary>
bool thirdPartyTimestamps;
/// <summary>
/// True if there are CP/M 3 timestamps
/// </summary>
bool standardTimestamps;
/// <summary>
/// Timestamp in volume label for creation
/// </summary>
byte[] labelCreationDate;
/// <summary>
/// Timestamp in volume label for update
/// </summary>
byte[] labelUpdateDate;
/// <summary>
/// Cached <see cref="FileSystemInfo"/>
/// </summary>
FileSystemInfo cpmStat;
/// <summary>
/// Cached directory listing
/// </summary>
List<string> dirList;
/// <summary>
/// Cached file data
/// </summary>
Dictionary<string, byte[]> fileCache;
/// <summary>
/// Cached file <see cref="FileEntryInfo"/>
/// </summary>
Dictionary<string, FileEntryInfo> statCache;
/// <summary>
/// Cached file passwords
/// </summary>
Dictionary<string, byte[]> passwordCache;
/// <summary>
/// Cached file passwords, decoded
/// </summary>
Dictionary<string, byte[]> decodedPasswordCache;
public CPM()
{
Name = "CP/M File System";
PluginUUID = new Guid("AA2B8585-41DF-4E3B-8A35-D1A935E2F8A1");
}
public CPM(ImagePlugin imagePlugin, ulong partitionStart, ulong partitionEnd)
{
device = imagePlugin;
partStart = partitionStart;
partEnd = partitionEnd;
Name = "CP/M File System";
PluginUUID = new Guid("AA2B8585-41DF-4E3B-8A35-D1A935E2F8A1");
}
}
}

53
DiscImageChef.Filesystems/CPM/Consts.cs
View File

@@ -5,11 +5,11 @@
// Filename : Consts.cs
// Author(s) : Natalia Portillo <claunia@claunia.com>
//
// Component : Component
// Component : CP/M filesystem plugin.
//
// --[ Description ] ----------------------------------------------------------
//
// Description
// CP/M filesystem constants.
//
// --[ License ] --------------------------------------------------------------
//
@@ -29,13 +29,56 @@
// ----------------------------------------------------------------------------
// Copyright © 2011-2016 Natalia Portillo
// ****************************************************************************/
using System;
namespace DiscImageChef.Filesystems.CPM
{
public class Consts
partial class CPM : Filesystem
{
public Consts()
/// <summary>
/// Enumerates the format identification byte used by CP/M-86
/// </summary>
enum FormatByte : byte
{
/// <summary>
/// 5.25" double-density single-side 8 sectors/track
/// </summary>
k160 = 0,
/// <summary>
/// 5.25" double-density double-side 8 sectors/track
/// </summary>
k320 = 1,
/// <summary>
/// 5.25" double-density double-side 9 sectors/track
/// </summary>
k360 = 0x10,
/// <summary>
/// 5.25" double-density double-side 9 sectors/track
/// </summary>
k360Alt = 0x40,
/// <summary>
/// 3.5" double-density double-side 9 sectors/track
/// </summary>
k720 = 0x11,
/// <summary>
/// 3.5" double-density double-side 9 sectors/track using FEAT144
/// </summary>
f720 = 0x48,
/// <summary>
/// 5.25" high-density double-side 15 sectors/track using FEAT144
/// </summary>
f1200 = 0x0C,
/// <summary>
/// 3.5" high-density double-side 18 sectors/track using FEAT144
/// </summary>
f1440 = 0x90,
/// <summary>
/// 5.25" double-density double-side 9 sectors/track
/// </summary>
k360Alt2 = 0x26,
/// <summary>
/// 3.5" double-density double-side 9 sectors/track
/// </summary>
k720Alt = 0x94
}
}
}

181
DiscImageChef.Filesystems/CPM/Definitions.cs
View File

@@ -5,11 +5,11 @@
// Filename : Definitions.cs
// Author(s) : Natalia Portillo <claunia@claunia.com>
//
// Component : Component
// Component : CP/M filesystem plugin.
//
// --[ Description ] ----------------------------------------------------------
//
// Description
// Handles definitions of known CP/M disks.
//
// --[ License ] --------------------------------------------------------------
//
@@ -29,14 +29,187 @@
// ----------------------------------------------------------------------------
// Copyright © 2011-2016 Natalia Portillo
// ****************************************************************************/
using System;
using System.Collections.Generic;
using System.Reflection;
using System.Xml;
using System.Xml.Serialization;
namespace DiscImageChef.Filesystems.CPM
{
public class Definitions
partial class CPM : Filesystem
{
public Definitions()
/// <summary>
/// Loads all the known CP/M disk definitions from an XML stored as an embedded resource.
/// </summary>
/// <returns>The definitions.</returns>
public bool LoadDefinitions()
{
try
{
XmlReader defsReader = XmlReader.Create(Assembly.GetExecutingAssembly().GetManifestResourceStream("DiscImageChef.Filesystems.CPM.cpmdefs.xml"));
XmlSerializer defsSerializer = new XmlSerializer(typeof(CpmDefinitions));
definitions = (CpmDefinitions)defsSerializer.Deserialize(defsReader);
// Patch definitions
foreach(CpmDefinition def in definitions.definitions)
{
if(def.side1 == null)
{
def.side1 = new Side();
def.side1.sideId = 0;
def.side1.sectorIds = new int[def.sectorsPerTrack];
for(int i = 0; i < def.sectorsPerTrack; i++)
def.side1.sectorIds[i] = i + 1;
}
if(def.sides == 2 && def.side2 == null)
{
def.side2 = new Side();
def.side2.sideId = 1;
def.side2.sectorIds = new int[def.sectorsPerTrack];
for(int i = 0; i < def.sectorsPerTrack; i++)
def.side2.sectorIds[i] = i + 1;
}
}
return true;
}
catch
{
return false;
}
}
}
/// <summary>
/// CP/M disk definitions
/// </summary>
public class CpmDefinitions
{
/// <summary>
/// List of all CP/M disk definitions
/// </summary>
public List<CpmDefinition> definitions;
/// <summary>
/// Timestamp of creation of the CP/M disk definitions list
/// </summary>
public DateTime creation;
}
/// <summary>
/// CP/M disk definition
/// </summary>
public class CpmDefinition
{
/// <summary>
/// Comment and description
/// </summary>
public string comment;
/// <summary>
/// Encoding, "FM", "MFM", "GCR"
/// </summary>
public string encoding;
/// <summary>
/// Controller bitrate
/// </summary>
public string bitrate;
/// <summary>
/// Total cylinders
/// </summary>
public int cylinders;
/// <summary>
/// Total sides
/// </summary>
public int sides;
/// <summary>
/// Physical sectors per side
/// </summary>
public int sectorsPerTrack;
/// <summary>
/// Physical bytes per sector
/// </summary>
public int bytesPerSector;
/// <summary>
/// Physical sector interleaving
/// </summary>
public int skew;
/// <summary>
/// Description of controller's side 0 (usually, upper side)
/// </summary>
public Side side1;
/// <summary>
/// Description of controller's side 1 (usually, lower side)
/// </summary>
public Side side2;
/// <summary>
/// Cylinder/side ordering. SIDES = change side after each track, CYLINDERS = change side after whole side, EAGLE and COLUMBIA unknown
/// </summary>
public string order;
/// <summary>
/// Disk definition label
/// </summary>
public string label;
/// <summary>
/// Left shifts needed to translate allocation block number to lba
/// </summary>
public int bsh;
/// <summary>
/// Block mask for <see cref="bsh"/>
/// </summary>
public int blm;
/// <summary>
/// Extent mask
/// </summary>
public int exm;
/// <summary>
/// Total number of 128 byte records on disk
/// </summary>
public int dsm;
/// <summary>
/// Total number of available directory entries
/// </summary>
public int drm;
/// <summary>
/// Maps the first 16 allocation blocks for reservation, high byte
/// </summary>
public int al0;
/// <summary>
/// Maps the first 16 allocation blocks for reservation, low byte
/// </summary>
public int al1;
/// <summary>
/// Tracks at the beginning of disk reserved for BIOS/BDOS
/// </summary>
public int ofs;
/// <summary>
/// Sectors at the beginning of disk reserved for BIOS/BDOS
/// </summary>
public int sofs;
/// <summary>
/// If true, all bytes written on disk are negated
/// </summary>
public bool complement;
/// <summary>
/// Absolutely unknown?
/// </summary>
public bool evenOdd;
}
/// <summary>
/// Side descriptions
/// </summary>
public class Side
{
/// <summary>
/// Side ID as found in each sector address mark
/// </summary>
public int sideId;
/// <summary>
/// Software interleaving mask, [1,3,0,2] means CP/M LBA 0 is physical sector 1, LBA 1 = 3, so on
/// </summary>
public int[] sectorIds;
}
}

102
DiscImageChef.Filesystems/CPM/Dir.cs
View File

@@ -5,11 +5,11 @@
// Filename : Dir.cs
// Author(s) : Natalia Portillo <claunia@claunia.com>
//
// Component : Component
// Component : CP/M filesystem plugin.
//
// --[ Description ] ----------------------------------------------------------
//
// Description
// Methods to show the CP/M filesystem directory.
//
// --[ License ] --------------------------------------------------------------
//
@@ -29,13 +29,107 @@
// ----------------------------------------------------------------------------
// Copyright © 2011-2016 Natalia Portillo
// ****************************************************************************/
using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using System.Text;
namespace DiscImageChef.Filesystems.CPM
{
public class Dir
partial class CPM : Filesystem
{
public Dir()
public override Errno ReadDir(string path, ref List<string> contents)
{
if(!mounted)
return Errno.AccessDenied;
if(!string.IsNullOrEmpty(path) && string.Compare(path, "/", StringComparison.OrdinalIgnoreCase) != 0)
return Errno.NotSupported;
contents = dirList;
return Errno.NoError;
}
/// <summary>
/// Checks that the given directory blocks follow the CP/M filesystem directory specification
/// Corrupted directories will fail.
/// FAT firectories will false positive if all files start with 0x05, and do not use full extentions, for example:
/// "σAFILE.GZ" (using code page 437)
/// </summary>
/// <returns>False if the directory does not follow the directory specification</returns>
/// <param name="directory">Directory blocks.</param>
bool CheckDir(byte[] directory)
{
try
{
if(directory == null)
return false;
int fileCount = 0;
for(int off = 0; off < directory.Length; off += 32)
{
DirectoryEntry entry = new DirectoryEntry();
IntPtr dirPtr = Marshal.AllocHGlobal(32);
Marshal.Copy(directory, off, dirPtr, 32);
entry = (DirectoryEntry)Marshal.PtrToStructure(dirPtr, typeof(DirectoryEntry));
Marshal.FreeHGlobal(dirPtr);
if((entry.statusUser & 0x7F) < 0x20)
{
for(int f = 0; f < 8; f++)
{
if(entry.filename[f] < 0x20 && entry.filename[f] != 0x00)
return false;
}
for(int e = 0; e < 3; e++)
{
if(entry.extension[e] < 0x20 && entry.extension[e] != 0x00)
return false;
}
if(!ArrayHelpers.ArrayIsNullOrWhiteSpace(entry.filename))
fileCount++;
}
else if(entry.statusUser == 0x20)
{
for(int f = 0; f < 8; f++)
{
if(entry.filename[f] < 0x20 && entry.filename[f] != 0x00)
return false;
}
for(int e = 0; e < 3; e++)
{
if(entry.extension[e] < 0x20 && entry.extension[e] != 0x00)
return false;
}
label = Encoding.ASCII.GetString(directory, off + 1, 11).Trim();
labelCreationDate = new byte[4];
labelUpdateDate = new byte[4];
Array.Copy(directory, off + 24, labelCreationDate, 0, 4);
Array.Copy(directory, off + 28, labelUpdateDate, 0, 4);
}
else if(entry.statusUser == 0x21)
{
if(directory[off + 1] == 0x00)
{
thirdPartyTimestamps = true;
}
else standardTimestamps |= (directory[off + 21] == 0x00 && directory[off + 31] == 0x00);
}
}
return fileCount > 0;
}
catch
{
return false;
}
}
}
}

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

@@ -5,11 +5,11 @@
// Filename : File.cs
// Author(s) : Natalia Portillo <claunia@claunia.com>
//
// Component : Component
// Component : CP/M filesystem plugin.
//
// --[ Description ] ----------------------------------------------------------
//
// Description
// Methods to handle files.
//
// --[ License ] --------------------------------------------------------------
//
@@ -29,14 +29,117 @@
// ----------------------------------------------------------------------------
// Copyright © 2011-2016 Natalia Portillo
// ****************************************************************************/
using System;
namespace DiscImageChef.Filesystems.CPM
{
public class File
partial class CPM : Filesystem
{
public File()
public override Errno GetAttributes(string path, ref FileAttributes attributes)
{
if(!mounted)
return Errno.AccessDenied;
string[] pathElements = path.Split(new char[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
if(pathElements.Length != 1)
return Errno.NotSupported;
FileEntryInfo fInfo;
if(string.IsNullOrEmpty(pathElements[0]) || string.Compare(pathElements[0], "/", StringComparison.OrdinalIgnoreCase) == 0)
{
attributes = new FileAttributes();
attributes = FileAttributes.Directory;
return Errno.NoError;
}
if(statCache.TryGetValue(pathElements[0].ToUpperInvariant(), out fInfo))
{
attributes = fInfo.Attributes;
return Errno.NoError;
}
return Errno.NoSuchFile;
}
public override Errno MapBlock(string path, long fileBlock, ref long deviceBlock)
{
if(!mounted)
return Errno.AccessDenied;
// TODO: Implementing this would require storing the interleaving
return Errno.NotImplemented;
}
public override Errno Read(string path, long offset, long size, ref byte[] buf)
{
if(!mounted)
return Errno.AccessDenied;
if(size == 0)
{
buf = new byte[0];
return Errno.NoError;
}
if(offset < 0)
return Errno.InvalidArgument;
string[] pathElements = path.Split(new char[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
if(pathElements.Length != 1)
return Errno.NotSupported;
byte[] file;
if(!fileCache.TryGetValue(pathElements[0].ToUpperInvariant(), out file))
return Errno.NoSuchFile;
if(offset >= file.Length)
return Errno.EINVAL;
if(size + offset >= file.Length)
size = file.Length - offset;
buf = new byte[size];
Array.Copy(file, offset, buf, 0, size);
return Errno.NoError;
}
public override Errno ReadLink(string path, ref string dest)
{
if(!mounted)
return Errno.AccessDenied;
return Errno.NotSupported;
}
public override Errno Stat(string path, ref FileEntryInfo stat)
{
if(!mounted)
return Errno.AccessDenied;
string[] pathElements = path.Split(new char[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
if(pathElements.Length != 1)
return Errno.NotSupported;
if(string.IsNullOrEmpty(path) || string.Compare(path, "/", StringComparison.OrdinalIgnoreCase) == 0)
{
if(labelCreationDate != null)
stat.CreationTime = DateHandlers.CPMToDateTime(labelCreationDate);
if(labelUpdateDate != null)
stat.StatusChangeTime = DateHandlers.CPMToDateTime(labelUpdateDate);
stat.Attributes = FileAttributes.Directory;
stat.BlockSize = xmlFSType.ClusterSize;
return Errno.NoError;
}
if(statCache.TryGetValue(pathElements[0].ToUpperInvariant(), out stat))
return Errno.NoError;
return Errno.NoSuchFile;
}
}
}

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

@@ -5,11 +5,11 @@
// Filename : Info.cs
// Author(s) : Natalia Portillo <claunia@claunia.com>
//
// Component : Component
// Component : CP/M filesystem plugin.
//
// --[ Description ] ----------------------------------------------------------
//
// Description
// Identifies the CP/M filesystem and shows information.
//
// --[ License ] --------------------------------------------------------------
//
@@ -30,12 +30,907 @@
// Copyright © 2011-2016 Natalia Portillo
// ****************************************************************************/
using System;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using DiscImageChef.Console;
using DiscImageChef.ImagePlugins;
namespace DiscImageChef.Filesystems.CPM
{
public class Info
partial class CPM : Filesystem
{
public Info()
public override bool Identify(ImagePlugin imagePlugin, ulong partitionStart, ulong partitionEnd)
{
// This will try to identify a CP/M filesystem
// However as it contains no identification marks whatsoever it's more something of trial-and-error
// As anything can happen, better try{}catch{} than sorry ;)
try
{
byte[] sector;
ulong sectorCount;
ulong sectorSize;
ulong sides;
ulong firstDirectorySector;
byte[] directory = null;
workingDefinition = null;
label = null;
// Try Amstrad superblock
if(!cpmFound)
{
// Read CHS = {0,0,1}
sector = imagePlugin.ReadSector(0 + partitionStart);
int amsSbOffset = 0;
uint sig1, sig2, sig3;
sig1 = BitConverter.ToUInt32(sector, 0x2B);
sig2 = BitConverter.ToUInt32(sector, 0x33) & 0x00FFFFFF;
sig3 = BitConverter.ToUInt32(sector, 0x7C);
// PCW16 extended boot record
if(sig1 == 0x4D2F5043 && sig2 == 0x004B5344 && sig3 == sig1)
amsSbOffset = 0x80;
// Read the superblock
AmstradSuperBlock amsSb = new AmstradSuperBlock();
IntPtr amsPtr = Marshal.AllocHGlobal(16);
Marshal.Copy(sector, amsSbOffset, amsPtr, 16);
amsSb = (AmstradSuperBlock)Marshal.PtrToStructure(amsPtr, typeof(AmstradSuperBlock));
Marshal.FreeHGlobal(amsPtr);
// Check that format byte and sidedness indicate the same number of sizes
if((amsSb.format == 0 && (amsSb.sidedness & 0x02) == 0) ||
(amsSb.format == 2 && (amsSb.sidedness & 0x02) == 1) ||
(amsSb.format == 2 && (amsSb.sidedness & 0x02) == 2))
{
// Calculate device limits
sides = (ulong)(amsSb.format == 0 ? 1 : 2);
sectorCount = (ulong)(amsSb.tps * amsSb.spt * (byte)sides);
sectorSize = (ulong)(128 << amsSb.psh);
// Compare device limits from superblock to real limits
if(sectorSize == imagePlugin.GetSectorSize() &&
sectorCount == imagePlugin.GetSectors())
{
cpmFound = true;
firstDirectorySector = (ulong)((amsSb.off * amsSb.spt));
// Build a DiscParameterBlock
dpb = new DiscParameterBlock();
dpb.al0 = sectorCount == 1440 ? (byte)0xF0 : (byte)0xC0;
dpb.spt = amsSb.spt;
dpb.bsh = amsSb.bsh;
for(int i = 0; i < dpb.bsh; i++)
dpb.blm += (byte)Math.Pow(2, i);
if(sectorCount >= 1440)
{
dpb.cks = 0x40;
dpb.drm = 0xFF;
}
else
{
dpb.cks = 0x10;
dpb.drm = 0x3F;
}
dpb.dsm = 0; // I don't care
dpb.exm = sectorCount == 2880 ? (byte)1 : (byte)0;
dpb.off = amsSb.off;
dpb.psh = amsSb.psh;
for(int i = 0; i < dpb.psh; i++)
dpb.phm += (byte)Math.Pow(2, i);
dpb.spt = (ushort)(amsSb.spt * (sectorSize / 128));
uint directoryLength = (uint)((((ulong)dpb.drm + 1) * 32) / sectorSize);
directory = imagePlugin.ReadSector(firstDirectorySector + partitionStart, directoryLength);
// Build a CP/M disk definition
workingDefinition = new CpmDefinition();
workingDefinition.al0 = dpb.al0;
workingDefinition.al1 = dpb.al1;
workingDefinition.bitrate = "LOW";
workingDefinition.blm = dpb.blm;
workingDefinition.bsh = dpb.bsh;
workingDefinition.bytesPerSector = 512;
workingDefinition.cylinders = amsSb.tps;
workingDefinition.drm = dpb.drm;
workingDefinition.dsm = dpb.dsm;
workingDefinition.encoding = "MFM";
workingDefinition.evenOdd = false;
workingDefinition.exm = dpb.exm;
workingDefinition.label = null;
workingDefinition.comment = "Amstrad PCW superblock";
workingDefinition.ofs = dpb.off;
workingDefinition.sectorsPerTrack = amsSb.spt;
workingDefinition.side1 = new Side();
workingDefinition.side1.sideId = 0;
workingDefinition.side1.sectorIds = new int[amsSb.spt];
for(int si = 0; si < amsSb.spt; si++)
workingDefinition.side1.sectorIds[si] = si + 1;
if(amsSb.format == 2)
{
if((amsSb.sidedness & 0x02) == 1)
workingDefinition.order = "SIDES";
else if((amsSb.sidedness & 0x02) == 2)
workingDefinition.order = "CYLINDERS";
else
workingDefinition.order = null;
workingDefinition.side2 = new Side();
workingDefinition.side2.sideId = 1;
workingDefinition.side2.sectorIds = new int[amsSb.spt];
for(int si = 0; si < amsSb.spt; si++)
workingDefinition.side2.sectorIds[si] = si + 1;
}
else
workingDefinition.order = null;
workingDefinition.skew = 2;
workingDefinition.sofs = 0;
DicConsole.DebugWriteLine("CP/M Plugin", "Found Amstrad superblock.");
}
}
}
// Try CP/M-86 superblock for hard disks
if(!cpmFound)
{
// Read CHS = {0,0,4}
sector = imagePlugin.ReadSector(3 + partitionStart);
ushort sum = 0;
// Sum of all 16-bit words that make this sector must be 0
for(int i = 0; i < sector.Length; i += 2)
sum += BitConverter.ToUInt16(sector, i);
// It may happen that there is a corrupted superblock
// Better to ignore corrupted than to false positive the rest
if(sum == 0)
{
// Read the superblock
HardDiskSuperBlock hddSb = new HardDiskSuperBlock();
IntPtr hddPtr = Marshal.AllocHGlobal(16);
Marshal.Copy(sector, 0, hddPtr, Marshal.SizeOf(hddSb));
hddSb = (HardDiskSuperBlock)Marshal.PtrToStructure(hddPtr, typeof(HardDiskSuperBlock));
Marshal.FreeHGlobal(hddPtr);
// Calculate volume size
sectorSize = (ulong)(hddSb.recordsPerSector * 128);
ulong sectorsInPartition = (ulong)(hddSb.cylinders * hddSb.heads * hddSb.sectorsPerTrack);
ulong startingSector = (ulong)((hddSb.firstCylinder * hddSb.heads + hddSb.heads) * hddSb.sectorsPerTrack);
// If volume size corresponds with working partition (this variant will be inside MBR partitioning)
if(sectorSize == imagePlugin.GetSectorSize() &&
startingSector == partitionStart &&
sectorsInPartition + partitionStart <= partitionEnd)
{
cpmFound = true;
firstDirectorySector = (ulong)((hddSb.off * hddSb.sectorsPerTrack));
// Build a DiscParameterBlock
dpb = new DiscParameterBlock();
dpb.al0 = (byte)hddSb.al0;
dpb.al1 = (byte)hddSb.al1;
dpb.blm = hddSb.blm;
dpb.bsh = hddSb.bsh;
dpb.cks = hddSb.cks;
dpb.drm = hddSb.drm;
dpb.dsm = hddSb.dsm;
dpb.exm = hddSb.exm;
dpb.off = hddSb.off;
dpb.phm = 0; // Needed?
dpb.psh = 0; // Needed?
dpb.spt = hddSb.spt;
uint directoryLength = (uint)((((ulong)dpb.drm + 1) * 32) / sectorSize);
directory = imagePlugin.ReadSector(firstDirectorySector + partitionStart, directoryLength);
DicConsole.DebugWriteLine("CP/M Plugin", "Found CP/M-86 hard disk superblock.");
// Build a CP/M disk definition
workingDefinition = new CpmDefinition();
workingDefinition.al0 = dpb.al0;
workingDefinition.al1 = dpb.al1;
workingDefinition.bitrate = "HIGH";
workingDefinition.blm = dpb.blm;
workingDefinition.bsh = dpb.bsh;
workingDefinition.bytesPerSector = 512;
workingDefinition.cylinders = hddSb.cylinders;
workingDefinition.drm = dpb.drm;
workingDefinition.dsm = dpb.dsm;
workingDefinition.encoding = "MFM";
workingDefinition.evenOdd = false;
workingDefinition.exm = dpb.exm;
workingDefinition.label = null;
workingDefinition.comment = "CP/M-86 hard disk superblock";
workingDefinition.ofs = dpb.off;
workingDefinition.sectorsPerTrack = hddSb.sectorsPerTrack;
workingDefinition.side1 = new Side();
workingDefinition.side1.sideId = 0;
workingDefinition.side1.sectorIds = new int[hddSb.sectorsPerTrack];
for(int si = 0; si < hddSb.sectorsPerTrack; si++)
workingDefinition.side1.sectorIds[si] = si + 1;
workingDefinition.order = "SIDES";
workingDefinition.side2 = new Side();
workingDefinition.side2.sideId = 1;
workingDefinition.side2.sectorIds = new int[hddSb.sectorsPerTrack];
for(int si = 0; si < hddSb.spt; si++)
workingDefinition.side2.sectorIds[si] = si + 1;
workingDefinition.skew = 0;
workingDefinition.sofs = 0;
}
}
}
// Try CP/M-86 format ID for floppies
if(!cpmFound)
{
// Read CHS = {0,0,1}
sector = imagePlugin.ReadSector(0 + partitionStart);
byte formatByte;
// Check for alternate location of format ID
if(sector.Last() == 0x00 || sector.Last() == 0xFF)
{
if(sector[0x40] == 0x94 || sector[0x40] == 0x26)
formatByte = sector[0x40];
else
formatByte = sector.Last();
}
else
formatByte = sector.Last();
uint firstDirectorySector86 = 0;
// Check format ID
// If it is one of the known IDs, check disk size corresponds to the one we expect
// If so, build a DiscParameterBlock and a CP/M disk definition
// Will not work on over-formatted disks (40 cylinder volume on an 80 cylinder disk,
// something that happens a lot in IBM PC 5.25" disks)
switch((FormatByte)formatByte)
{
case FormatByte.k160:
if(imagePlugin.GetSectorSize() == 512 && imagePlugin.GetSectors() == 320)
{
cpmFound = true;
firstDirectorySector86 = 8;
dpb = new DiscParameterBlock();
dpb.al0 = 0xC0;
dpb.al1 = 0;
dpb.blm = 7;
dpb.bsh = 3;
dpb.cks = 0x10;
dpb.drm = 0x3F;
dpb.dsm = 0x9B;
dpb.exm = 0;
dpb.off = 1;
dpb.phm = 3;
dpb.psh = 2;
dpb.spt = 8 * 4;
workingDefinition = new CpmDefinition();
workingDefinition.al0 = dpb.al0;
workingDefinition.al1 = dpb.al1;
workingDefinition.bitrate = "LOW";
workingDefinition.blm = dpb.blm;
workingDefinition.bsh = dpb.bsh;
workingDefinition.bytesPerSector = 512;
workingDefinition.cylinders = 40;
workingDefinition.drm = dpb.drm;
workingDefinition.dsm = dpb.dsm;
workingDefinition.encoding = "MFM";
workingDefinition.evenOdd = false;
workingDefinition.exm = dpb.exm;
workingDefinition.label = null;
workingDefinition.comment = "CP/M-86 floppy identifier";
workingDefinition.ofs = dpb.off;
workingDefinition.sectorsPerTrack = 8;
workingDefinition.side1 = new Side();
workingDefinition.side1.sideId = 0;
workingDefinition.side1.sectorIds = new int[8];
for(int si = 0; si < 8; si++)
workingDefinition.side1.sectorIds[si] = si + 1;
workingDefinition.skew = 0;
workingDefinition.sofs = 0;
}
break;
case FormatByte.k320:
if(imagePlugin.GetSectorSize() == 512 && imagePlugin.GetSectors() == 640)
{
cpmFound = true;
firstDirectorySector86 = 8;
dpb = new DiscParameterBlock();
dpb.al0 = 0x80;
dpb.al1 = 0;
dpb.blm = 0x0F;
dpb.bsh = 4;
dpb.cks = 0x10;
dpb.drm = 0x3F;
dpb.dsm = 0x9D;
dpb.exm = 1;
dpb.off = 1;
dpb.phm = 3;
dpb.psh = 2;
dpb.spt = 8 * 4;
workingDefinition = new CpmDefinition();
workingDefinition.al0 = dpb.al0;
workingDefinition.al1 = dpb.al1;
workingDefinition.bitrate = "LOW";
workingDefinition.blm = dpb.blm;
workingDefinition.bsh = dpb.bsh;
workingDefinition.bytesPerSector = 512;
workingDefinition.cylinders = 40;
workingDefinition.drm = dpb.drm;
workingDefinition.dsm = dpb.dsm;
workingDefinition.encoding = "MFM";
workingDefinition.evenOdd = false;
workingDefinition.exm = dpb.exm;
workingDefinition.label = null;
workingDefinition.comment = "CP/M-86 floppy identifier";
workingDefinition.ofs = dpb.off;
workingDefinition.sectorsPerTrack = 8;
workingDefinition.side1 = new Side();
workingDefinition.side1.sideId = 0;
workingDefinition.side1.sectorIds = new int[8];
for(int si = 0; si < 8; si++)
workingDefinition.side1.sectorIds[si] = si + 1;
workingDefinition.order = "SIDES";
workingDefinition.side2 = new Side();
workingDefinition.side2.sideId = 1;
workingDefinition.side2.sectorIds = new int[8];
for(int si = 0; si < 8; si++)
workingDefinition.side2.sectorIds[si] = si + 1;
workingDefinition.skew = 0;
workingDefinition.sofs = 0;
}
break;
case FormatByte.k360:
case FormatByte.k360Alt:
case FormatByte.k360Alt2:
if(imagePlugin.GetSectorSize() == 512 && imagePlugin.GetSectors() == 720)
{
cpmFound = true;
firstDirectorySector86 = 36;
dpb = new DiscParameterBlock();
dpb.al0 = 0x80;
dpb.al1 = 0;
dpb.blm = 0x0F;
dpb.bsh = 4;
dpb.cks = 0x10;
dpb.drm = 0x3F;
dpb.dsm = 0; // Unknown. Needed?
dpb.exm = 1;
dpb.off = 4;
dpb.phm = 3;
dpb.psh = 2;
dpb.spt = 9 * 4;
workingDefinition = new CpmDefinition();
workingDefinition.al0 = dpb.al0;
workingDefinition.al1 = dpb.al1;
workingDefinition.bitrate = "LOW";
workingDefinition.blm = dpb.blm;
workingDefinition.bsh = dpb.bsh;
workingDefinition.bytesPerSector = 512;
workingDefinition.cylinders = 40;
workingDefinition.drm = dpb.drm;
workingDefinition.dsm = dpb.dsm;
workingDefinition.encoding = "MFM";
workingDefinition.evenOdd = false;
workingDefinition.exm = dpb.exm;
workingDefinition.label = null;
workingDefinition.comment = "CP/M-86 floppy identifier";
workingDefinition.ofs = dpb.off;
workingDefinition.sectorsPerTrack = 9;
workingDefinition.side1 = new Side();
workingDefinition.side1.sideId = 0;
workingDefinition.side1.sectorIds = new int[9];
for(int si = 0; si < 9; si++)
workingDefinition.side1.sectorIds[si] = si + 1;
workingDefinition.order = "SIDES";
workingDefinition.side2 = new Side();
workingDefinition.side2.sideId = 1;
workingDefinition.side2.sectorIds = new int[9];
for(int si = 0; si < 9; si++)
workingDefinition.side2.sectorIds[si] = si + 1;
workingDefinition.skew = 0;
workingDefinition.sofs = 0;
}
break;
case FormatByte.k720:
case FormatByte.k720Alt:
if(imagePlugin.GetSectorSize() == 512 && imagePlugin.GetSectors() == 1440)
{
cpmFound = true;
firstDirectorySector86 = 36;
dpb = new DiscParameterBlock();
dpb.al0 = 0xF0;
dpb.al1 = 0;
dpb.blm = 0x0F;
dpb.bsh = 4;
dpb.cks = 0x40;
dpb.drm = 0xFF;
dpb.dsm = 0x15E;
dpb.exm = 0;
dpb.off = 4;
dpb.phm = 3;
dpb.psh = 2;
dpb.spt = 9 * 4;
workingDefinition = new CpmDefinition();
workingDefinition.al0 = dpb.al0;
workingDefinition.al1 = dpb.al1;
workingDefinition.bitrate = "LOW";
workingDefinition.blm = dpb.blm;
workingDefinition.bsh = dpb.bsh;
workingDefinition.bytesPerSector = 512;
workingDefinition.cylinders = 80;
workingDefinition.drm = dpb.drm;
workingDefinition.dsm = dpb.dsm;
workingDefinition.encoding = "MFM";
workingDefinition.evenOdd = false;
workingDefinition.exm = dpb.exm;
workingDefinition.label = null;
workingDefinition.comment = "CP/M-86 floppy identifier";
workingDefinition.ofs = dpb.off;
workingDefinition.sectorsPerTrack = 9;
workingDefinition.side1 = new Side();
workingDefinition.side1.sideId = 0;
workingDefinition.side1.sectorIds = new int[9];
for(int si = 0; si < 9; si++)
workingDefinition.side1.sectorIds[si] = si + 1;
workingDefinition.order = "SIDES";
workingDefinition.side2 = new Side();
workingDefinition.side2.sideId = 1;
workingDefinition.side2.sectorIds = new int[9];
for(int si = 0; si < 9; si++)
workingDefinition.side2.sectorIds[si] = si + 1;
workingDefinition.skew = 0;
workingDefinition.sofs = 0;
}
break;
case FormatByte.f720:
if(imagePlugin.GetSectorSize() == 512 && imagePlugin.GetSectors() == 1440)
{
cpmFound = true;
firstDirectorySector86 = 18;
dpb = new DiscParameterBlock();
dpb.al0 = 0xF0;
dpb.al1 = 0;
dpb.blm = 0x0F;
dpb.bsh = 4;
dpb.cks = 0x40;
dpb.drm = 0xFF;
dpb.dsm = 0x162;
dpb.exm = 0;
dpb.off = 2;
dpb.phm = 3;
dpb.psh = 2;
dpb.spt = 9 * 4;
workingDefinition = new CpmDefinition();
workingDefinition.al0 = dpb.al0;
workingDefinition.al1 = dpb.al1;
workingDefinition.bitrate = "LOW";
workingDefinition.blm = dpb.blm;
workingDefinition.bsh = dpb.bsh;
workingDefinition.bytesPerSector = 512;
workingDefinition.cylinders = 80;
workingDefinition.drm = dpb.drm;
workingDefinition.dsm = dpb.dsm;
workingDefinition.encoding = "MFM";
workingDefinition.evenOdd = false;
workingDefinition.exm = dpb.exm;
workingDefinition.label = null;
workingDefinition.comment = "CP/M-86 floppy identifier";
workingDefinition.ofs = dpb.off;
workingDefinition.sectorsPerTrack = 9;
workingDefinition.side1 = new Side();
workingDefinition.side1.sideId = 0;
workingDefinition.side1.sectorIds = new int[9];
for(int si = 0; si < 9; si++)
workingDefinition.side1.sectorIds[si] = si + 1;
workingDefinition.order = "CYLINDERS";
workingDefinition.side2 = new Side();
workingDefinition.side2.sideId = 1;
workingDefinition.side2.sectorIds = new int[9];
for(int si = 0; si < 9; si++)
workingDefinition.side2.sectorIds[si] = si + 1;
workingDefinition.skew = 0;
workingDefinition.sofs = 0;
}
break;
case FormatByte.f1200:
if(imagePlugin.GetSectorSize() == 512 && imagePlugin.GetSectors() == 2400)
{
cpmFound = true;
firstDirectorySector86 = 30;
dpb = new DiscParameterBlock();
dpb.al0 = 0xC0;
dpb.al1 = 0;
dpb.blm = 0x1F;
dpb.bsh = 5;
dpb.cks = 0x40;
dpb.drm = 0xFF;
dpb.dsm = 0x127;
dpb.exm = 1;
dpb.off = 2;
dpb.phm = 3;
dpb.psh = 2;
dpb.spt = 15 * 4;
workingDefinition = new CpmDefinition();
workingDefinition.al0 = dpb.al0;
workingDefinition.al1 = dpb.al1;
workingDefinition.bitrate = "HIGH";
workingDefinition.blm = dpb.blm;
workingDefinition.bsh = dpb.bsh;
workingDefinition.bytesPerSector = 512;
workingDefinition.cylinders = 80;
workingDefinition.drm = dpb.drm;
workingDefinition.dsm = dpb.dsm;
workingDefinition.encoding = "MFM";
workingDefinition.evenOdd = false;
workingDefinition.exm = dpb.exm;
workingDefinition.label = null;
workingDefinition.comment = "CP/M-86 floppy identifier";
workingDefinition.ofs = dpb.off;
workingDefinition.sectorsPerTrack = 15;
workingDefinition.side1 = new Side();
workingDefinition.side1.sideId = 0;
workingDefinition.side1.sectorIds = new int[15];
for(int si = 0; si < 15; si++)
workingDefinition.side1.sectorIds[si] = si + 1;
workingDefinition.order = "CYLINDERS";
workingDefinition.side2 = new Side();
workingDefinition.side2.sideId = 1;
workingDefinition.side2.sectorIds = new int[15];
for(int si = 0; si < 15; si++)
workingDefinition.side2.sectorIds[si] = si + 1;
workingDefinition.skew = 0;
workingDefinition.sofs = 0;
}
break;
case FormatByte.f1440:
if(imagePlugin.GetSectorSize() == 512 && imagePlugin.GetSectors() == 2880)
{
cpmFound = true;
firstDirectorySector86 = 36;
dpb = new DiscParameterBlock();
dpb.al0 = 0xC0;
dpb.al1 = 0;
dpb.blm = 0x1F;
dpb.bsh = 5;
dpb.cks = 0x40;
dpb.drm = 0xFF;
dpb.dsm = 0x162;
dpb.exm = 1;
dpb.off = 2;
dpb.phm = 3;
dpb.psh = 2;
dpb.spt = 18 * 4;
workingDefinition = new CpmDefinition();
workingDefinition.al0 = dpb.al0;
workingDefinition.al1 = dpb.al1;
workingDefinition.bitrate = "LOW";
workingDefinition.blm = dpb.blm;
workingDefinition.bsh = dpb.bsh;
workingDefinition.bytesPerSector = 512;
workingDefinition.cylinders = 80;
workingDefinition.drm = dpb.drm;
workingDefinition.dsm = dpb.dsm;
workingDefinition.encoding = "MFM";
workingDefinition.evenOdd = false;
workingDefinition.exm = dpb.exm;
workingDefinition.label = null;
workingDefinition.comment = "CP/M-86 floppy identifier";
workingDefinition.ofs = dpb.off;
workingDefinition.sectorsPerTrack = 18;
workingDefinition.side1 = new Side();
workingDefinition.side1.sideId = 0;
workingDefinition.side1.sectorIds = new int[18];
for(int si = 0; si < 18; si++)
workingDefinition.side1.sectorIds[si] = si + 1;
workingDefinition.order = "CYLINDERS";
workingDefinition.side2 = new Side();
workingDefinition.side2.sideId = 1;
workingDefinition.side2.sectorIds = new int[18];
for(int si = 0; si < 18; si++)
workingDefinition.side2.sectorIds[si] = si + 1;
workingDefinition.skew = 0;
workingDefinition.sofs = 0;
}
break;
}
if(cpmFound)
{
uint directoryLength = (uint)((((ulong)dpb.drm + 1) * 32) / imagePlugin.GetSectorSize());
directory = imagePlugin.ReadSector(firstDirectorySector86 + partitionStart, directoryLength);
DicConsole.DebugWriteLine("CP/M Plugin", "Found CP/M-86 floppy identifier.");
}
}
// One of the few CP/M filesystem marks has been found, try for correcteness checking the whole directory
if(cpmFound)
{
if(CheckDir(directory))
{
DicConsole.DebugWriteLine("CP/M Plugin", "First directory block seems correct.");
return true;
}
cpmFound = false;
}
// Try all definitions
if(!cpmFound)
{
// Load all definitions
DicConsole.DebugWriteLine("CP/M Plugin", "Trying to load definitions.");
if(LoadDefinitions() && definitions != null && definitions.definitions != null && definitions.definitions.Count > 0)
{
DicConsole.DebugWriteLine("CP/M Plugin", "Trying all known definitions.");
foreach(CpmDefinition def in definitions.definitions)
{
ulong sectors = (ulong)(def.cylinders * def.sides * def.sectorsPerTrack);
// Definition seems to describe current disk, at least, same number of volume sectors and bytes per sector
if(sectors == imagePlugin.GetSectors() && def.bytesPerSector == imagePlugin.GetSectorSize())
{
DicConsole.DebugWriteLine("CP/M Plugin", "Trying definition \"{0}\"", def.comment);
ulong offset;
if(def.sofs != 0)
offset = (ulong)def.sofs;
else
offset = (ulong)(def.ofs * def.sectorsPerTrack);
int dirLen = ((def.drm + 1) * 32) / def.bytesPerSector;
if(def.sides == 1)
{
sectorMask = new int[def.side1.sectorIds.Length];
for(int m = 0; m < sectorMask.Length; m++)
sectorMask[m] = def.side1.sectorIds[m] - def.side1.sectorIds[0];
}
else
{
// Head changes after every track
if(string.Compare(def.order, "SIDES", StringComparison.InvariantCultureIgnoreCase) == 0)
{
sectorMask = new int[def.side1.sectorIds.Length + def.side2.sectorIds.Length];
for(int m = 0; m < def.side1.sectorIds.Length; m++)
sectorMask[m] = def.side1.sectorIds[m] - def.side1.sectorIds[0];
// Skip first track (first side)
for(int m = 0; m < def.side2.sectorIds.Length; m++)
sectorMask[m + def.side1.sectorIds.Length] = (def.side2.sectorIds[m] - def.side2.sectorIds[0]) + def.side1.sectorIds.Length;
}
// Head changes after whole side
else if(string.Compare(def.order, "CYLINDERS", StringComparison.InvariantCultureIgnoreCase) == 0)
{
for(int m = 0; m < def.side1.sectorIds.Length; m++)
sectorMask[m] = def.side1.sectorIds[m] - def.side1.sectorIds[0];
// Skip first track (first side) and first track (second side)
for(int m = 0; m < def.side1.sectorIds.Length; m++)
sectorMask[m + def.side1.sectorIds.Length] = (def.side1.sectorIds[m] - def.side1.sectorIds[0]) + def.side1.sectorIds.Length + def.side2.sectorIds.Length;
}
// TODO: Implement COLUMBIA ordering
else if(string.Compare(def.order, "COLUMBIA", StringComparison.InvariantCultureIgnoreCase) == 0)
{
DicConsole.DebugWriteLine("CP/M Plugin", "Don't know how to handle COLUMBIA ordering, not proceeding with this definition.");
continue;
}
// TODO: Implement EAGLE ordering
else if(string.Compare(def.order, "EAGLE", StringComparison.InvariantCultureIgnoreCase) == 0)
{
DicConsole.DebugWriteLine("CP/M Plugin", "Don't know how to handle EAGLE ordering, not proceeding with this definition.");
continue;
}
else
{
DicConsole.DebugWriteLine("CP/M Plugin", "Unknown order type \"{0}\", not proceeding with this definition.", def.order);
continue;
}
}
// Read the directory marked by this definition
MemoryStream ms = new MemoryStream();
for(int p = 0; p < dirLen; p++)
{
byte[] dirSector = imagePlugin.ReadSector((ulong)((int)offset + (int)partitionStart + (p / sectorMask.Length) * sectorMask.Length + sectorMask[p % sectorMask.Length]));
ms.Write(dirSector, 0, dirSector.Length);
}
directory = ms.ToArray();
if(def.evenOdd)
DicConsole.DebugWriteLine("CP/M Plugin", "Definition contains EVEN-ODD field, with unknown meaning, detection may be wrong.");
// Complement of the directory bytes if needed
if(def.complement)
{
for(int b = 0; b < directory.Length; b++)
directory[b] = (byte)(~directory[b] & 0xFF);
}
// Check the directory
if(CheckDir(directory))
{
DicConsole.DebugWriteLine("CP/M Plugin", "Definition \"{0}\" has a correct directory", def.comment);
// Build a Disc Parameter Block
workingDefinition = def;
dpb = new DiscParameterBlock();
dpb.al0 = (byte)def.al0;
dpb.al1 = (byte)def.al1;
dpb.blm = (byte)def.blm;
dpb.bsh = (byte)def.bsh;
dpb.cks = 0; // Needed?
dpb.drm = (ushort)def.drm;
dpb.dsm = (ushort)def.dsm;
dpb.exm = (byte)def.exm;
dpb.off = (ushort)def.ofs;
switch(def.bytesPerSector)
{
case 128:
dpb.psh = 0;
dpb.phm = 0;
break;
case 256:
dpb.psh = 1;
dpb.phm = 1;
break;
case 512:
dpb.psh = 2;
dpb.phm = 3;
break;
case 1024:
dpb.psh = 3;
dpb.phm = 7;
break;
case 2048:
dpb.psh = 4;
dpb.phm = 15;
break;
case 4096:
dpb.psh = 5;
dpb.phm = 31;
break;
case 8192:
dpb.psh = 6;
dpb.phm = 63;
break;
case 16384:
dpb.psh = 7;
dpb.phm = 127;
break;
case 32768:
dpb.psh = 8;
dpb.phm = 255;
break;
}
dpb.spt = (ushort)((def.sectorsPerTrack * def.bytesPerSector) / 128);
cpmFound = true;
workingDefinition = def;
return true;
}
label = null;
labelCreationDate = null;
labelUpdateDate = null;
}
}
}
}
// Clear class variables
cpmFound = false;
workingDefinition = null;
dpb = null;
label = null;
standardTimestamps = false;
thirdPartyTimestamps = false;
return false;
}
catch(Exception ex)
{
throw ex;
// return false;
}
}
public override void GetInformation(ImagePlugin imagePlugin, ulong partitionStart, ulong partitionEnd, out string information)
{
information = "";
// As the identification is so complex, just call Identify() and relay on its findings
if(!Identify(imagePlugin, partitionStart, partitionEnd) || !cpmFound || workingDefinition == null || dpb == null)
return;
StringBuilder sb = new StringBuilder();
sb.AppendLine("CP/M filesystem");
if(!string.IsNullOrEmpty(workingDefinition.comment))
sb.AppendFormat("Identified as {0}", workingDefinition.comment).AppendLine();
sb.AppendFormat("Volume block is {0} bytes", 128 << dpb.bsh).AppendLine();
if(dpb.dsm > 0)
sb.AppendFormat("Volume contains {0} blocks ({1} bytes)", dpb.dsm, (dpb.dsm) * (128 << dpb.bsh)).AppendLine();
sb.AppendFormat("Volume contains {0} directory entries", dpb.drm + 1).AppendLine();
if(workingDefinition.sofs > 0)
sb.AppendFormat("Volume reserves {0} sectors for system", workingDefinition.sofs).AppendLine();
else
sb.AppendFormat("Volume reserves {1} tracks ({0} sectors) for system", workingDefinition.ofs * workingDefinition.sectorsPerTrack, workingDefinition.ofs).AppendLine();
int interleaveSide1;
int interleaveSide2 = 1;
interleaveSide1 = workingDefinition.side1.sectorIds[1] - workingDefinition.side1.sectorIds[0];
if(interleaveSide1 > 1)
sb.AppendFormat("Side 0 uses {0}:1 software interleaving", interleaveSide1).AppendLine();
if(workingDefinition.sides == 2)
{
interleaveSide2 = workingDefinition.side2.sectorIds[1] - workingDefinition.side2.sectorIds[0];
if(interleaveSide2 > 1)
sb.AppendFormat("Side 1 uses {0}:1 software interleaving", interleaveSide2).AppendLine();
switch(workingDefinition.order)
{
case "SIDES":
sb.AppendLine("Head changes after each whole track");
break;
case "CYLINDERS":
sb.AppendLine("Head changes after whole side");
break;
default:
sb.AppendFormat("Unknown how {0} side ordering works", workingDefinition.order).AppendLine();
break;
}
}
if(workingDefinition.skew > 0)
sb.AppendFormat("Device uses {0}:1 hardware interleaving", workingDefinition.skew).AppendLine();
if(workingDefinition.sofs > 0)
sb.AppendFormat("BSH {0} BLM {1} EXM {2} DSM {3} DRM {4} AL0 {5:X2}H AL1 {6:X2}H SOFS {7}", dpb.bsh, dpb.blm, dpb.exm, dpb.dsm, dpb.drm, dpb.al0, dpb.al1, workingDefinition.sofs).AppendLine();
else
sb.AppendFormat("BSH {0} BLM {1} EXM {2} DSM {3} DRM {4} AL0 {5:X2}H AL1 {6:X2}H OFS {7}", dpb.bsh, dpb.blm, dpb.exm, dpb.dsm, dpb.drm, dpb.al0, dpb.al1, workingDefinition.ofs).AppendLine();
if(label != null)
sb.AppendFormat("Volume label {0}", label).AppendLine();
if(standardTimestamps)
sb.AppendLine("Volume uses standard CP/M timestamps");
if(thirdPartyTimestamps)
sb.AppendLine("Volume uses third party timestamps");
if(labelCreationDate != null)
sb.AppendFormat("Volume created on {0}", DateHandlers.CPMToDateTime(labelCreationDate)).AppendLine();
if(labelUpdateDate != null)
sb.AppendFormat("Volume updated on {0}", DateHandlers.CPMToDateTime(labelUpdateDate)).AppendLine();
xmlFSType = new Schemas.FileSystemType();
xmlFSType.Bootable |= (workingDefinition.sofs > 0 || workingDefinition.ofs > 0);
xmlFSType.ClusterSize = 128 << dpb.bsh;
if(dpb.dsm > 0)
xmlFSType.Clusters = ((dpb.dsm + 1) * 128) / (128 << dpb.bsh);
else
xmlFSType.Clusters = (long)(partitionEnd - partitionStart);
if(labelCreationDate != null)
{
xmlFSType.CreationDate = DateHandlers.CPMToDateTime(labelCreationDate);
xmlFSType.CreationDateSpecified = true;
}
if(labelUpdateDate != null)
{
xmlFSType.ModificationDate = DateHandlers.CPMToDateTime(labelUpdateDate);
xmlFSType.ModificationDateSpecified = true;
}
xmlFSType.Type = "CP/M";
xmlFSType.VolumeName = label;
information = sb.ToString();
}
}
}

534
DiscImageChef.Filesystems/CPM/Structs.cs
View File

@@ -5,11 +5,11 @@
// Filename : Structs.cs
// Author(s) : Natalia Portillo <claunia@claunia.com>
//
// Component : Component
// Component : CP/M filesystem plugin.
//
// --[ Description ] ----------------------------------------------------------
//
// Description
// CP/M filesystem structures.
//
// --[ License ] --------------------------------------------------------------
//
@@ -29,13 +29,537 @@
// ----------------------------------------------------------------------------
// Copyright © 2011-2016 Natalia Portillo
// ****************************************************************************/
using System;
using System.Runtime.InteropServices;
namespace DiscImageChef.Filesystems.CPM
{
public class Structs
partial class CPM : Filesystem
{
public Structs()
/// <summary>
/// Most of the times this structure is hard wired or generated by CP/M, not stored on disk
/// </summary>
class DiscParameterBlock
{
/// <summary>
/// Sectors per track
/// </summary>
public ushort spt;
/// <summary>
/// Block shift
/// </summary>
public byte bsh;
/// <summary>
/// Block mask
/// </summary>
public byte blm;
/// <summary>
/// Extent mask
/// </summary>
public byte exm;
/// <summary>
/// Blocks on disk - 1
/// </summary>
public ushort dsm;
/// <summary>
/// Directory entries - 1
/// </summary>
public ushort drm;
/// <summary>
/// First byte of allocation bitmap
/// </summary>
public byte al0;
/// <summary>
/// Second byte of allocation bitmap
/// </summary>
public byte al1;
/// <summary>
/// Checksum vector size
/// </summary>
public ushort cks;
/// <summary>
/// Reserved tracks
/// </summary>
public ushort off;
/// <summary>
/// Physical sector shift
/// </summary>
public byte psh;
/// <summary>
/// Physical sector mask
/// </summary>
public byte phm;
}
/// <summary>
/// Amstrad superblock, for PCW
/// </summary>
[StructLayout(LayoutKind.Sequential, Pack = 1)]
struct AmstradSuperBlock
{
/// <summary>
/// Format ID. 0 single-side, 3 double-side. 1 and 2 are for CPC but they don't use the superblock
/// </summary>
public byte format;
/// <summary>
/// Gives information about side ordering
/// </summary>
public byte sidedness;
/// <summary>
/// Tracks per side, aka, cylinders
/// </summary>
public byte tps;
/// <summary>
/// Sectors per track
/// </summary>
public byte spt;
/// <summary>
/// Physical sector shift
/// </summary>
public byte psh;
/// <summary>
/// Reserved tracks
/// </summary>
public byte off;
/// <summary>
/// Block size shift
/// </summary>
public byte bsh;
/// <summary>
/// How many blocks does the directory take
/// </summary>
public byte dirBlocks;
/// <summary>
/// GAP#3 length (intersector)
/// </summary>
public byte gapLen;
/// <summary>
/// GAP#4 length (end-of-track)
/// </summary>
public byte formatGap;
/// <summary>
/// Must be 0
/// </summary>
public byte zero1;
/// <summary>
/// Must be 0
/// </summary>
public byte zero2;
/// <summary>
/// Must be 0
/// </summary>
public byte zero3;
/// <summary>
/// Must be 0
/// </summary>
public byte zero4;
/// <summary>
/// Must be 0
/// </summary>
public byte zero5;
/// <summary>
/// Indicates machine the boot code following the superblock is designed to boot
/// </summary>
public byte fiddle;
}
/// <summary>
/// Superblock found on CP/M-86 hard disk volumes
/// </summary>
[StructLayout(LayoutKind.Sequential, Pack = 1)]
struct HardDiskSuperBlock
{
/// <summary>
/// Value so the sum of all the superblock's sector bytes taken as 16-bit values gives 0
/// </summary>
public ushort checksum;
/// <summary>
/// Copyright string
/// </summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 0x1F)]
public byte[] copyright;
/// <summary>
/// First cylinder of disk where this volume resides
/// </summary>
public ushort firstCylinder;
/// <summary>
/// How many cylinders does this volume span
/// </summary>
public ushort cylinders;
/// <summary>
/// Heads on hard disk
/// </summary>
public byte heads;
/// <summary>
/// Sectors per track
/// </summary>
public byte sectorsPerTrack;
/// <summary>
/// Flags, only use by CCP/M where bit 0 equals verify on write
/// </summary>
public byte flags;
/// <summary>
/// Sector size / 128
/// </summary>
public byte recordsPerSector;
/// <summary>
/// <see cref="DiscParameterBlock.spt"/>
/// </summary>
public ushort spt;
/// <summary>
/// <see cref="DiscParameterBlock.bsh"/>
/// </summary>
public byte bsh;
/// <summary>
/// <see cref="DiscParameterBlock.blm"/>
/// </summary>
public byte blm;
/// <summary>
/// <see cref="DiscParameterBlock.exm"/>
/// </summary>
public byte exm;
/// <summary>
/// <see cref="DiscParameterBlock.dsm"/>
/// </summary>
public ushort dsm;
/// <summary>
/// <see cref="DiscParameterBlock.drm"/>
/// </summary>
public ushort drm;
/// <summary>
/// <see cref="DiscParameterBlock.al0"/>
/// </summary>
public ushort al0;
/// <summary>
/// <see cref="DiscParameterBlock.al1"/>
/// </summary>
public ushort al1;
/// <summary>
/// <see cref="DiscParameterBlock.cks"/>
/// </summary>
public ushort cks;
/// <summary>
/// <see cref="DiscParameterBlock.off"/>
/// </summary>
public ushort off;
/// <summary>
/// Must be zero
/// </summary>
public ushort zero1;
/// <summary>
/// Must be zero
/// </summary>
public ushort zero2;
/// <summary>
/// Must be zero
/// </summary>
public ushort zero3;
/// <summary>
/// Must be zero
/// </summary>
public ushort zero4;
/// <summary>
/// How many 128 bytes are in a block
/// </summary>
public ushort recordsPerBlock;
/// <summary>
/// Maximum number of bad blocks in the bad block list
/// </summary>
public ushort badBlockWordsMax;
/// <summary>
/// Used number of bad blocks in the bad block list
/// </summary>
public ushort badBlockWords;
/// <summary>
/// First block after the blocks reserved for bad block substitution
/// </summary>
public ushort firstSub;
}
/// <summary>
/// Volume label entry
/// </summary>
[StructLayout(LayoutKind.Sequential, Pack = 1)]
struct LabelEntry
{
/// <summary>
/// Must be 0x20
/// </summary>
public byte signature;
/// <summary>
/// Label in ASCII
/// </summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 11)]
public byte[] label;
/// <summary>
/// Label flags. Bit 0 = label exists, bit 4 = creation timestamp, bit 5 = modification timestamp, bit 6 = access timestamp, bit 7 = password enabled
/// </summary>
public byte flags;
/// <summary>
/// Password decoder byte
/// </summary>
public byte passwordDecoder;
/// <summary>
/// Must be 0
/// </summary>
public ushort reserved;
/// <summary>
/// Password XOR'ed with <see cref="passwordDecoder"/>
/// </summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)]
public byte[] password;
/// <summary>
/// Label creation time
/// </summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
public byte[] ctime;
/// <summary>
/// Label modification time
/// </summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
public byte[] mtime;
}
/// <summary>
/// CP/M 3 timestamp entry
/// </summary>
[StructLayout(LayoutKind.Sequential, Pack = 1)]
struct DateEntry
{
/// <summary>
/// Must be 0x21
/// </summary>
public byte signature;
/// <summary>
/// File 1 create/access timestamp
/// </summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
public byte[] date1;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
/// <summary>
/// File 1 modification timestamp
/// </summary>
public byte[] date2;
/// <summary>
/// File 1 password mode
/// </summary>
public byte mode1;
public byte zero1;
/// <summary>
/// File 2 create/access timestamp
/// </summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
public byte[] date3;
/// <summary>
/// File 2 modification timestamp
/// </summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
public byte[] date4;
/// <summary>
/// File 2 password mode
/// </summary>
public byte mode2;
public byte zero2;
/// <summary>
/// File 3 create/access timestamp
/// </summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
public byte[] date5;
/// <summary>
/// File 3 modification timestamp
/// </summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
public byte[] date6;
/// <summary>
/// File 3 password mode
/// </summary>
public byte mode3;
public ushort zero3;
}
/// <summary>
/// Password entry
/// </summary>
[StructLayout(LayoutKind.Sequential, Pack = 1)]
struct PasswordEntry
{
/// <summary>
/// 16 + user number
/// </summary>
public byte userNumber;
/// <summary>
/// Filename
/// </summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)]
public byte[] filename;
/// <summary>
/// Extension
/// </summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
public byte[] extension;
/// <summary>
/// Password mode. Bit 7 = required for read, bit 6 = required for write, bit 5 = required for delete
/// </summary>
public byte mode;
/// <summary>
/// Password decoder byte
/// </summary>
public byte passwordDecoder;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)]
public byte[] reserved;
/// <summary>
/// Password XOR'ed with <see cref="passwordDecoder"/>
/// </summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)]
public byte[] password;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)]
public byte[] reserved2;
}
/// <summary>
/// Timestamp for Z80DOS or DOS+
/// </summary>
[StructLayout(LayoutKind.Sequential, Pack = 1)]
struct TrdPartyDateEntry
{
/// <summary>
/// Must be 0x21
/// </summary>
public byte signature;
public byte zero;
/// <summary>
/// Creation year for file 1
/// </summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)]
public byte[] create1;
/// <summary>
/// Modification time for file 1
/// </summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
public byte[] modify1;
/// <summary>
/// Access time for file 1
/// </summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
public byte[] access1;
/// <summary>
/// Creation year for file 2
/// </summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)]
public byte[] create2;
/// <summary>
/// Modification time for file 2
/// </summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
public byte[] modify2;
/// <summary>
/// Access time for file 2
/// </summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
public byte[] access2;
/// <summary>
/// Creation year for file 3
/// </summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)]
public byte[] create3;
/// <summary>
/// Modification time for file 3
/// </summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
public byte[] modify3;
/// <summary>
/// Access time for file 3
/// </summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
public byte[] access3;
}
/// <summary>
/// Directory entry for &lt;256 allocation blocks
/// </summary>
[StructLayout(LayoutKind.Sequential, Pack = 1)]
struct DirectoryEntry
{
/// <summary>
/// User number. Bit 7 set in CP/M 1 means hidden
/// </summary>
public byte statusUser;
/// <summary>
/// Filename and bit 7 as flags
/// </summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)]
public byte[] filename;
/// <summary>
/// Extension and bit 7 as flags
/// </summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
public byte[] extension;
/// <summary>
/// Low byte of extent number
/// </summary>
public byte extentCounter;
/// <summary>
/// Last record bytes. In some implementations it means how many bytes are used in the last record, in others how many bytes are free.
/// It always refer to 128 byte records even if blocks are way bigger, so it's mostly useless.
/// </summary>
public byte lastRecordBytes;
/// <summary>
/// High byte of extent number
/// </summary>
public byte extentCounterHigh;
/// <summary>
/// How many records are used in this entry. 0x80 if all are used.
/// </summary>
public byte records;
/// <summary>
/// Allocation blocks
/// </summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)]
public byte[] allocations;
}
/// <summary>
/// Directory entry for &bt;256 allocation blocks
/// </summary>
[StructLayout(LayoutKind.Sequential, Pack = 1)]
struct DirectoryEntry16
{
/// <summary>
/// User number. Bit 7 set in CP/M 1 means hidden
/// </summary>
public byte statusUser;
/// <summary>
/// Filename and bit 7 as flags
/// </summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)]
public byte[] filename;
/// <summary>
/// Extension and bit 7 as flags
/// </summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
public byte[] extension;
/// <summary>
/// Low byte of extent number
/// </summary>
public byte extentCounter;
/// <summary>
/// Last record bytes. In some implementations it means how many bytes are used in the last record, in others how many bytes are free.
/// It always refer to 128 byte records even if blocks are way bigger, so it's mostly useless.
/// </summary>
public byte lastRecordBytes;
/// <summary>
/// High byte of extent number
/// </summary>
public byte extentCounterHigh;
/// <summary>
/// How many records are used in this entry. 0x80 if all are used.
/// </summary>
public byte records;
/// <summary>
/// Allocation blocks
/// </summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)]
public ushort[] allocations;
}
}
}

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

@@ -5,11 +5,13 @@
// Filename : Super.cs
// Author(s) : Natalia Portillo <claunia@claunia.com>
//
// Component : Component
// Component : CP/M filesystem plugin.
//
// --[ Description ] ----------------------------------------------------------
//
// Description
// Handles mounting and umounting the CP/M filesystem.
// Caches the whole volume on mounting (shouldn't be a problem, maximum
// volume size for CP/M is 8 MiB).
//
// --[ License ] --------------------------------------------------------------
//
@@ -29,13 +31,756 @@
// ----------------------------------------------------------------------------
// Copyright © 2011-2016 Natalia Portillo
// ****************************************************************************/
using System;
using System.Collections.Generic;
using System.IO;
using System.Runtime.InteropServices;
using System.Text;
using DiscImageChef.Console;
namespace DiscImageChef.Filesystems.CPM
{
public class Super
partial class CPM : Filesystem
{
public Super()
public override Errno Mount()
{
return Mount(false);
}
public override Errno Mount(bool debug)
{
// As the identification is so complex, just call Identify() and relay on its findings
if(!Identify(device, partStart, partEnd) || !cpmFound || workingDefinition == null || dpb == null)
return Errno.InvalidArgument;
// Build the software interleaving sector mask
if(workingDefinition.sides == 1)
{
sectorMask = new int[workingDefinition.side1.sectorIds.Length];
for(int m = 0; m < sectorMask.Length; m++)
sectorMask[m] = workingDefinition.side1.sectorIds[m] - workingDefinition.side1.sectorIds[0];
}
else
{
// Head changes after every track
if(string.Compare(workingDefinition.order, "SIDES", StringComparison.InvariantCultureIgnoreCase) == 0)
{
sectorMask = new int[workingDefinition.side1.sectorIds.Length + workingDefinition.side2.sectorIds.Length];
for(int m = 0; m < workingDefinition.side1.sectorIds.Length; m++)
sectorMask[m] = workingDefinition.side1.sectorIds[m] - workingDefinition.side1.sectorIds[0];
// Skip first track (first side)
for(int m = 0; m < workingDefinition.side2.sectorIds.Length; m++)
sectorMask[m + workingDefinition.side1.sectorIds.Length] = (workingDefinition.side2.sectorIds[m] - workingDefinition.side2.sectorIds[0]) + workingDefinition.side1.sectorIds.Length;
}
// Head changes after whole side
else if(string.Compare(workingDefinition.order, "CYLINDERS", StringComparison.InvariantCultureIgnoreCase) == 0)
{
for(int m = 0; m < workingDefinition.side1.sectorIds.Length; m++)
sectorMask[m] = workingDefinition.side1.sectorIds[m] - workingDefinition.side1.sectorIds[0];
// Skip first track (first side) and first track (second side)
for(int m = 0; m < workingDefinition.side1.sectorIds.Length; m++)
sectorMask[m + workingDefinition.side1.sectorIds.Length] = (workingDefinition.side1.sectorIds[m] - workingDefinition.side1.sectorIds[0]) + workingDefinition.side1.sectorIds.Length + workingDefinition.side2.sectorIds.Length;
// TODO: Implement CYLINDERS ordering
DicConsole.DebugWriteLine("CP/M Plugin", "CYLINDERS ordering not yet implemented.");
return Errno.NotImplemented;
}
// TODO: Implement COLUMBIA ordering
else if(string.Compare(workingDefinition.order, "COLUMBIA", StringComparison.InvariantCultureIgnoreCase) == 0)
{
DicConsole.DebugWriteLine("CP/M Plugin", "Don't know how to handle COLUMBIA ordering, not proceeding with this definition.");
return Errno.NotImplemented;
}
// TODO: Implement EAGLE ordering
else if(string.Compare(workingDefinition.order, "EAGLE", StringComparison.InvariantCultureIgnoreCase) == 0)
{
DicConsole.DebugWriteLine("CP/M Plugin", "Don't know how to handle EAGLE ordering, not proceeding with this definition.");
return Errno.NotImplemented;
}
else
{
DicConsole.DebugWriteLine("CP/M Plugin", "Unknown order type \"{0}\", not proceeding with this definition.", workingDefinition.order);
return Errno.NotSupported;
}
}
// Deinterleave whole volume
Dictionary<ulong, byte[]> deinterleavedSectors = new Dictionary<ulong, byte[]>();
if(workingDefinition.sides == 1 || string.Compare(workingDefinition.order, "SIDES", StringComparison.InvariantCultureIgnoreCase) == 0)
{
DicConsole.DebugWriteLine("CP/M Plugin", "Deinterleaving whole volume.");
for(int p = 0; p <= (int)(partEnd - partStart); p++)
{
byte[] readSector = device.ReadSector((ulong)((int)partStart + (p / sectorMask.Length) * sectorMask.Length + sectorMask[p % sectorMask.Length]));
if(workingDefinition.complement)
{
for(int b = 0; b < readSector.Length; b++)
readSector[b] = (byte)(~readSector[b] & 0xFF);
}
deinterleavedSectors.Add((ulong)p, readSector);
}
}
int blockSize = 128 << dpb.bsh;
MemoryStream blockMs = new MemoryStream();
ulong blockNo = 0;
int sectorsPerBlock = 0;
Dictionary<ulong, byte[]> allocationBlocks = new Dictionary<ulong, byte[]>();
DicConsole.DebugWriteLine("CP/M Plugin", "Creating allocation blocks.");
// For each volume sector
for(ulong a = 0; a < (ulong)deinterleavedSectors.Count; a++)
{
byte[] sector;
deinterleavedSectors.TryGetValue(a, out sector);
// May it happen? Just in case, CP/M blocks are smaller than physical sectors
if(sector.Length > blockSize)
{
for(int i = 0; i < (sector.Length / blockSize); i++)
{
byte[] tmp = new byte[blockSize];
Array.Copy(sector, blockSize * i, tmp, 0, blockSize);
allocationBlocks.Add(blockNo++, tmp);
}
}
// CP/M blocks are larger than physical sectors
else if(sector.Length < blockSize)
{
blockMs.Write(sector, 0, sector.Length);
sectorsPerBlock++;
if(sectorsPerBlock == blockSize / sector.Length)
{
allocationBlocks.Add(blockNo++, blockMs.ToArray());
sectorsPerBlock = 0;
blockMs = new MemoryStream();
}
}
// CP/M blocks are same size than physical sectors
else
allocationBlocks.Add(blockNo++, sector);
}
DicConsole.DebugWriteLine("CP/M Plugin", "Reading directory.");
int dirOff;
int dirSectors = ((dpb.drm + 1) * 32) / workingDefinition.bytesPerSector;
if(workingDefinition.sofs > 0)
dirOff = workingDefinition.sofs;
else
dirOff = workingDefinition.ofs * workingDefinition.sectorsPerTrack;
// Read the whole directory blocks
MemoryStream dirMs = new MemoryStream();
for(int d = 0; d < dirSectors; d++)
{
byte[] sector;
deinterleavedSectors.TryGetValue((ulong)(d + dirOff), out sector);
dirMs.Write(sector, 0, sector.Length);
}
byte[] directory = dirMs.ToArray();
if(directory == null)
return Errno.InvalidArgument;
int dirCnt = 0;
string file1 = null;
string file2 = null;
string file3 = null;
Dictionary<string, Dictionary<int, List<ushort>>> fileExtents = new Dictionary<string, Dictionary<int, List<ushort>>>();
statCache = new Dictionary<string, FileEntryInfo>();
cpmStat = new FileSystemInfo();
bool atime = false;
dirList = new List<string>();
labelCreationDate = null;
labelUpdateDate = null;
passwordCache = new Dictionary<string, byte[]>();
DicConsole.DebugWriteLine("CP/M Plugin", "Traversing directory.");
// For each directory entry
for(int dOff = 0; dOff < directory.Length; dOff += 32)
{
// Describes a file (does not support PDOS entries with user >= 16, because they're identical to password entries
if((directory[dOff] & 0x7F) < 0x10)
{
// If there are more than 256 allocation blocks, the allocation block becomes a 16-bit value
if(allocationBlocks.Count > 256)
{
DirectoryEntry16 entry = new DirectoryEntry16();
IntPtr dirPtr = Marshal.AllocHGlobal(32);
Marshal.Copy(directory, dOff, dirPtr, 32);
entry = (DirectoryEntry16)Marshal.PtrToStructure(dirPtr, typeof(DirectoryEntry16));
Marshal.FreeHGlobal(dirPtr);
bool hidden = (entry.statusUser & 0x80) == 0x80;
bool rdOnly = (entry.filename[0] & 0x80) == 0x80 || (entry.extension[0] & 0x80) == 0x80;
bool system = (entry.filename[1] & 0x80) == 0x80 || (entry.extension[2] & 0x80) == 0x80;
//bool backed = (entry.filename[3] & 0x80) == 0x80 || (entry.extension[3] & 0x80) == 0x80;
int user = (entry.statusUser & 0x0F);
bool validEntry = true;
for(int i = 0; i < 8; i++)
{
entry.filename[i] &= 0x7F;
validEntry &= entry.filename[i] >= 0x20;
}
for(int i = 0; i < 3; i++)
{
entry.extension[i] &= 0x7F;
validEntry &= entry.extension[i] >= 0x20;
}
if(!validEntry)
continue;
string filename = Encoding.ASCII.GetString(entry.filename).Trim();
string extension = Encoding.ASCII.GetString(entry.extension).Trim();
// If user is != 0, append user to name to have identical filenames
if(user > 0)
filename = string.Format("{0:X1}:{1}", user, filename);
if(!string.IsNullOrEmpty(extension))
filename = filename + "." + extension;
int entryNo = ((32 * entry.extentCounter) + entry.extentCounterHigh) / (dpb.exm + 1);
List<ushort> blocks;
Dictionary<int, List<ushort>> extentBlocks;
FileEntryInfo fInfo;
// Do we have a stat for the file already?
if(statCache.TryGetValue(filename, out fInfo))
statCache.Remove(filename);
else
{
fInfo = new FileEntryInfo();
fInfo.Attributes = new FileAttributes();
}
// And any extent?
if(fileExtents.TryGetValue(filename, out extentBlocks))
fileExtents.Remove(filename);
else
extentBlocks = new Dictionary<int, List<ushort>>();
// Do we already have this extent? Should never happen
if(extentBlocks.TryGetValue(entryNo, out blocks))
extentBlocks.Remove(entryNo);
else
blocks = new List<ushort>();
// Attributes
if(hidden)
fInfo.Attributes |= FileAttributes.Hidden;
if(rdOnly)
fInfo.Attributes |= FileAttributes.ReadOnly;
if(system)
fInfo.Attributes |= FileAttributes.System;
// Supposedly there is a value in the directory entry telling how many blocks are designated in this entry
// However some implementations tend to do whatever they wish, but none will ever allocate block 0 for a file
// because that's where the directory resides.
// There is also a field telling how many bytes are used in the last block, but its meaning is non-standard so
// we must ignore it.
foreach(ushort blk in entry.allocations)
{
if(!blocks.Contains(blk) && blk != 0)
blocks.Add(blk);
}
// Save the file
fInfo.UID = (ulong)user;
extentBlocks.Add(entryNo, blocks);
fileExtents.Add(filename, extentBlocks);
statCache.Add(filename, fInfo);
// Add the file to the directory listing
if(!dirList.Contains(filename))
dirList.Add(filename);
// Count entries 3 by 3 for timestamps
switch(dirCnt % 3)
{
case 0:
file1 = filename;
break;
case 1:
file2 = filename;
break;
case 2:
file3 = filename;
break;
}
dirCnt++;
}
else
{
DirectoryEntry entry = new DirectoryEntry();
IntPtr dirPtr = Marshal.AllocHGlobal(32);
Marshal.Copy(directory, dOff, dirPtr, 32);
entry = (DirectoryEntry)Marshal.PtrToStructure(dirPtr, typeof(DirectoryEntry));
Marshal.FreeHGlobal(dirPtr);
bool hidden = (entry.statusUser & 0x80) == 0x80;
bool rdOnly = (entry.filename[0] & 0x80) == 0x80 || (entry.extension[0] & 0x80) == 0x80;
bool system = (entry.filename[1] & 0x80) == 0x80 || (entry.extension[2] & 0x80) == 0x80;
//bool backed = (entry.filename[3] & 0x80) == 0x80 || (entry.extension[3] & 0x80) == 0x80;
int user = (entry.statusUser & 0x0F);
bool validEntry = true;
for(int i = 0; i < 8; i++)
{
entry.filename[i] &= 0x7F;
validEntry &= entry.filename[i] >= 0x20;
}
for(int i = 0; i < 3; i++)
{
entry.extension[i] &= 0x7F;
validEntry &= entry.extension[i] >= 0x20;
}
if(!validEntry)
continue;
string filename = Encoding.ASCII.GetString(entry.filename).Trim();
string extension = Encoding.ASCII.GetString(entry.extension).Trim();
// If user is != 0, append user to name to have identical filenames
if(user > 0)
filename = string.Format("{0:X1}:{1}", user, filename);
if(!string.IsNullOrEmpty(extension))
filename = filename + "." + extension;
int entryNo = ((32 * entry.extentCounterHigh) + entry.extentCounter) / (dpb.exm + 1);
List<ushort> blocks;
Dictionary<int, List<ushort>> extentBlocks;
FileEntryInfo fInfo;
// Do we have a stat for the file already?
if(statCache.TryGetValue(filename, out fInfo))
statCache.Remove(filename);
else
{
fInfo = new FileEntryInfo();
fInfo.Attributes = new FileAttributes();
}
// And any extent?
if(fileExtents.TryGetValue(filename, out extentBlocks))
fileExtents.Remove(filename);
else
extentBlocks = new Dictionary<int, List<ushort>>();
// Do we already have this extent? Should never happen
if(extentBlocks.TryGetValue(entryNo, out blocks))
extentBlocks.Remove(entryNo);
else
blocks = new List<ushort>();
// Attributes
if(hidden)
fInfo.Attributes |= FileAttributes.Hidden;
if(rdOnly)
fInfo.Attributes |= FileAttributes.ReadOnly;
if(system)
fInfo.Attributes |= FileAttributes.System;
// Supposedly there is a value in the directory entry telling how many blocks are designated in this entry
// However some implementations tend to do whatever they wish, but none will ever allocate block 0 for a file
// because that's where the directory resides.
// There is also a field telling how many bytes are used in the last block, but its meaning is non-standard so
// we must ignore it.
foreach(ushort blk in entry.allocations)
{
if(!blocks.Contains(blk) && blk != 0)
blocks.Add(blk);
}
// Save the file
fInfo.UID = (ulong)user;
extentBlocks.Add(entryNo, blocks);
fileExtents.Add(filename, extentBlocks);
statCache.Add(filename, fInfo);
// Add the file to the directory listing
if(!dirList.Contains(filename))
dirList.Add(filename);
// Count entries 3 by 3 for timestamps
switch(dirCnt % 3)
{
case 0:
file1 = filename;
break;
case 1:
file2 = filename;
break;
case 2:
file3 = filename;
break;
}
dirCnt++;
}
}
// A password entry (or a file entry in PDOS, but this does not handle that case)
else if((directory[dOff] & 0x7F) >= 0x10 && (directory[dOff] & 0x7F) < 0x20)
{
PasswordEntry entry = new PasswordEntry();
IntPtr dirPtr = Marshal.AllocHGlobal(32);
Marshal.Copy(directory, dOff, dirPtr, 32);
entry = (PasswordEntry)Marshal.PtrToStructure(dirPtr, typeof(PasswordEntry));
Marshal.FreeHGlobal(dirPtr);
int user = (entry.userNumber & 0x0F);
for(int i = 0; i < 8; i++)
entry.filename[i] &= 0x7F;
for(int i = 0; i < 3; i++)
entry.extension[i] &= 0x7F;
string filename = Encoding.ASCII.GetString(entry.filename).Trim();
string extension = Encoding.ASCII.GetString(entry.extension).Trim();
// If user is != 0, append user to name to have identical filenames
if(user > 0)
filename = string.Format("{0:X1}:{1}", user, filename);
if(!string.IsNullOrEmpty(extension))
filename = filename + "." + extension;
// Do not repeat passwords
if(passwordCache.ContainsKey(filename))
passwordCache.Remove(filename);
// Copy whole password entry
byte[] tmp = new byte[32];
Array.Copy(directory, dOff, tmp, 0, 32);
passwordCache.Add(filename, tmp);
// Count entries 3 by 3 for timestamps
switch(dirCnt % 3)
{
case 0:
file1 = filename;
break;
case 1:
file2 = filename;
break;
case 2:
file3 = filename;
break;
}
dirCnt++;
}
// Volume label and password entry. Volume password is ignored.
else if((directory[dOff] & 0x7F) == 0x20)
{
LabelEntry entry = new LabelEntry();
IntPtr dirPtr = Marshal.AllocHGlobal(32);
Marshal.Copy(directory, dOff, dirPtr, 32);
entry = (LabelEntry)Marshal.PtrToStructure(dirPtr, typeof(LabelEntry));
Marshal.FreeHGlobal(dirPtr);
// The volume label defines if one of the fields in CP/M 3 timestamp is a creation or an access time
atime |= (entry.flags & 0x40) == 0x40;
label = Encoding.ASCII.GetString(directory, dOff + 1, 11).Trim();
labelCreationDate = new byte[4];
labelUpdateDate = new byte[4];
Array.Copy(directory, dOff + 24, labelCreationDate, 0, 4);
Array.Copy(directory, dOff + 28, labelUpdateDate, 0, 4);
// Count entries 3 by 3 for timestamps
switch(dirCnt % 3)
{
case 0:
file1 = null;
break;
case 1:
file2 = null;
break;
case 2:
file3 = null;
break;
}
dirCnt++;
}
// Timestamp entry
else if((directory[dOff] & 0x7F) == 0x21)
{
// These places must be zero on CP/M 3 timestamp
if(directory[dOff + 10] == 0x00 &&
directory[dOff + 20] == 0x00 &&
directory[dOff + 30] == 0x00 &&
directory[dOff + 31] == 0x00)
{
DateEntry entry = new DateEntry();
IntPtr dirPtr = Marshal.AllocHGlobal(32);
Marshal.Copy(directory, dOff, dirPtr, 32);
entry = (DateEntry)Marshal.PtrToStructure(dirPtr, typeof(DateEntry));
Marshal.FreeHGlobal(dirPtr);
FileEntryInfo fInfo;
// Entry contains timestamps for last 3 entries, whatever the kind they are.
if(!string.IsNullOrEmpty(file1))
{
if(statCache.TryGetValue(file1, out fInfo))
statCache.Remove(file1);
else
fInfo = new FileEntryInfo();
if(atime)
fInfo.AccessTime = DateHandlers.CPMToDateTime(entry.date1);
else
fInfo.CreationTime = DateHandlers.CPMToDateTime(entry.date1);
fInfo.LastWriteTime = DateHandlers.CPMToDateTime(entry.date2);
statCache.Add(file1, fInfo);
}
if(!string.IsNullOrEmpty(file2))
{
if(statCache.TryGetValue(file2, out fInfo))
statCache.Remove(file2);
else
fInfo = new FileEntryInfo();
if(atime)
fInfo.AccessTime = DateHandlers.CPMToDateTime(entry.date3);
else
fInfo.CreationTime = DateHandlers.CPMToDateTime(entry.date3);
fInfo.LastWriteTime = DateHandlers.CPMToDateTime(entry.date4);
statCache.Add(file2, fInfo);
}
if(!string.IsNullOrEmpty(file3))
{
if(statCache.TryGetValue(file3, out fInfo))
statCache.Remove(file3);
else
fInfo = new FileEntryInfo();
if(atime)
fInfo.AccessTime = DateHandlers.CPMToDateTime(entry.date5);
else
fInfo.CreationTime = DateHandlers.CPMToDateTime(entry.date5);
fInfo.LastWriteTime = DateHandlers.CPMToDateTime(entry.date6);
statCache.Add(file3, fInfo);
}
file1 = null;
file2 = null;
file3 = null;
dirCnt = 0;
}
// However, if this byte is 0, timestamp is in Z80DOS or DOS+ format
else if(directory[dOff + 1] == 0x00)
{
TrdPartyDateEntry entry = new TrdPartyDateEntry();
IntPtr dirPtr = Marshal.AllocHGlobal(32);
Marshal.Copy(directory, dOff, dirPtr, 32);
entry = (TrdPartyDateEntry)Marshal.PtrToStructure(dirPtr, typeof(TrdPartyDateEntry));
Marshal.FreeHGlobal(dirPtr);
FileEntryInfo fInfo;
// Entry contains timestamps for last 3 entries, whatever the kind they are.
if(!string.IsNullOrEmpty(file1))
{
if(statCache.TryGetValue(file1, out fInfo))
statCache.Remove(file1);
else
fInfo = new FileEntryInfo();
byte[] ctime = new byte[4];
ctime[0] = entry.create1[0];
ctime[1] = entry.create1[1];
fInfo.AccessTime = DateHandlers.CPMToDateTime(entry.access1);
fInfo.CreationTime = DateHandlers.CPMToDateTime(ctime);
fInfo.LastWriteTime = DateHandlers.CPMToDateTime(entry.modify1);
statCache.Add(file1, fInfo);
}
if(!string.IsNullOrEmpty(file2))
{
if(statCache.TryGetValue(file2, out fInfo))
statCache.Remove(file2);
else
fInfo = new FileEntryInfo();
byte[] ctime = new byte[4];
ctime[0] = entry.create2[0];
ctime[1] = entry.create2[1];
fInfo.AccessTime = DateHandlers.CPMToDateTime(entry.access2);
fInfo.CreationTime = DateHandlers.CPMToDateTime(ctime);
fInfo.LastWriteTime = DateHandlers.CPMToDateTime(entry.modify2);
statCache.Add(file2, fInfo);
}
if(!string.IsNullOrEmpty(file3))
{
if(statCache.TryGetValue(file1, out fInfo))
statCache.Remove(file3);
else
fInfo = new FileEntryInfo();
byte[] ctime = new byte[4];
ctime[0] = entry.create3[0];
ctime[1] = entry.create3[1];
fInfo.AccessTime = DateHandlers.CPMToDateTime(entry.access3);
fInfo.CreationTime = DateHandlers.CPMToDateTime(ctime);
fInfo.LastWriteTime = DateHandlers.CPMToDateTime(entry.modify3);
statCache.Add(file3, fInfo);
}
file1 = null;
file2 = null;
file3 = null;
dirCnt = 0;
}
}
}
// Cache all files. As CP/M maximum volume size is 8 Mib
// this should not be a problem
DicConsole.DebugWriteLine("CP/M Plugin", "Reading files.");
long usedBlocks = 0;
fileCache = new Dictionary<string, byte[]>();
foreach(string filename in dirList)
{
MemoryStream fileMs = new MemoryStream();
FileEntryInfo fInfo = new FileEntryInfo();
if(statCache.TryGetValue(filename, out fInfo))
statCache.Remove(filename);
fInfo.Blocks = 0;
Dictionary<int, List<ushort>> extents;
if(fileExtents.TryGetValue(filename, out extents))
{
for(int ex = 0; ex < extents.Count; ex++)
{
List<ushort> alBlks;
if(extents.TryGetValue(ex, out alBlks))
{
foreach(ushort alBlk in alBlks)
{
byte[] blk = new byte[blockSize];
allocationBlocks.TryGetValue(alBlk, out blk);
fileMs.Write(blk, 0, blk.Length);
fInfo.Blocks++;
}
}
}
}
// If you insist to call CP/M "extent based"
fInfo.Attributes |= FileAttributes.Extents;
fInfo.BlockSize = blockSize;
fInfo.Length = fileMs.Length;
cpmStat.Files++;
usedBlocks += fInfo.Blocks;
statCache.Add(filename, fInfo);
fileCache.Add(filename, fileMs.ToArray());
}
decodedPasswordCache = new Dictionary<string, byte[]>();
// For each stored password, store a decoded version of it
if(passwordCache.Count > 0)
{
foreach(KeyValuePair<string, byte[]> kvp in passwordCache)
{
byte[] tmp = new byte[8];
Array.Copy(kvp.Value, 16, tmp, 0, 8);
for(int t = 0; t < 8; t++)
tmp[t] ^= kvp.Value[13];
decodedPasswordCache.Add(kvp.Key, tmp);
}
}
// Generate statfs.
cpmStat.Blocks = dpb.dsm + 1;
cpmStat.FilenameLength = 11;
cpmStat.Files = (ulong)fileCache.Count;
cpmStat.FreeBlocks = cpmStat.Blocks - usedBlocks;
cpmStat.PluginId = PluginUUID;
cpmStat.Type = "CP/M filesystem";
// Generate XML info
xmlFSType = new Schemas.FileSystemType();
xmlFSType.Clusters = cpmStat.Blocks;
xmlFSType.ClusterSize = blockSize;
if(labelCreationDate != null)
{
xmlFSType.CreationDate = DateHandlers.CPMToDateTime(labelCreationDate);
xmlFSType.CreationDateSpecified = true;
}
if(labelUpdateDate != null)
{
xmlFSType.ModificationDate = DateHandlers.CPMToDateTime(labelUpdateDate);
xmlFSType.ModificationDateSpecified = true;
}
xmlFSType.Files = fileCache.Count;
xmlFSType.FilesSpecified = true;
xmlFSType.FreeClusters = cpmStat.FreeBlocks;
xmlFSType.FreeClustersSpecified = true;
xmlFSType.Type = "CP/M filesystem";
if(!string.IsNullOrEmpty(label))
xmlFSType.VolumeName = label;
mounted = true;
return Errno.NoError;
}
/// <summary>
/// Gets information about the mounted volume.
/// </summary>
/// <param name="stat">Information about the mounted volume.</param>
public override Errno StatFs(ref FileSystemInfo stat)
{
if(!mounted)
return Errno.AccessDenied;
stat = cpmStat;
return Errno.NoError;
}
public override Errno Unmount()
{
mounted = false;
definitions = null;
cpmFound = false;
workingDefinition = null;
dpb = null;
sectorMask = null;
label = null;
thirdPartyTimestamps = false;
standardTimestamps = false;
labelCreationDate = null;
labelUpdateDate = null;
return Errno.NoError;
}
}
}

69
DiscImageChef.Filesystems/CPM/Xattr.cs
View File

@@ -5,11 +5,11 @@
// Filename : Xattr.cs
// Author(s) : Natalia Portillo <claunia@claunia.com>
//
// Component : Component
// Component : CP/M filesystem plugin.
//
// --[ Description ] ----------------------------------------------------------
//
// Description
// Methods to handle CP/M extended attributes (password).
//
// --[ License ] --------------------------------------------------------------
//
@@ -29,13 +29,74 @@
// ----------------------------------------------------------------------------
// Copyright © 2011-2016 Natalia Portillo
// ****************************************************************************/
using System;
using System.Collections.Generic;
namespace DiscImageChef.Filesystems.CPM
{
public class Xattr
partial class CPM : Filesystem
{
public Xattr()
/// <summary>
/// Reads an extended attribute, alternate data stream or fork from the given file.
/// </summary>
/// <returns>Error number.</returns>
/// <param name="path">File path.</param>
/// <param name="xattr">Extendad attribute, alternate data stream or fork name.</param>
/// <param name="buf">Buffer.</param>
public override Errno GetXattr(string path, string xattr, ref byte[] buf)
{
if(!mounted)
return Errno.AccessDenied;
string[] pathElements = path.Split(new char[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
if(pathElements.Length != 1)
return Errno.NotSupported;
if(!fileCache.ContainsKey(pathElements[0].ToUpperInvariant()))
return Errno.NoSuchFile;
if(string.Compare(xattr, "com.caldera.cpm.password", StringComparison.InvariantCulture) == 0)
{
if(!passwordCache.TryGetValue(pathElements[0].ToUpperInvariant(), out buf))
return Errno.NoError;
}
if(string.Compare(xattr, "com.caldera.cpm.password.text", StringComparison.InvariantCulture) == 0)
{
if(!passwordCache.TryGetValue(pathElements[0].ToUpperInvariant(), out buf))
return Errno.NoError;
}
return Errno.NoSuchExtendedAttribute;
}
/// <summary>
/// Lists all extended attributes, alternate data streams and forks of the given file.
/// </summary>
/// <returns>Error number.</returns>
/// <param name="path">Path.</param>
/// <param name="xattrs">List of extended attributes, alternate data streams and forks.</param>
public override Errno ListXAttr(string path, ref List<string> xattrs)
{
if(!mounted)
return Errno.AccessDenied;
string[] pathElements = path.Split(new char[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
if(pathElements.Length != 1)
return Errno.NotSupported;
if(!fileCache.ContainsKey(pathElements[0].ToUpperInvariant()))
return Errno.NoSuchFile;
xattrs = new List<string>();
if(passwordCache.ContainsKey(pathElements[0].ToUpperInvariant()))
xattrs.Add("com.caldera.cpm.password");
if(decodedPasswordCache.ContainsKey(pathElements[0].ToUpperInvariant()))
xattrs.Add("com.caldera.cpm.password.text");
return Errno.NoError;
}
}
}

628
DiscImageChef.Filesystems/CPM/cpmdefs.xml
View File

@@ -4255,10 +4255,10 @@
<comment>Columbia Commander 964 - DSDD 48 tpi 5.25" - 512 x 10</comment>
<encoding>MFM</encoding>
<bitrate>LOW</bitrate>
<cylinders>0</cylinders>
<sides>0</sides>
<sectorsPerTrack>0</sectorsPerTrack>
<bytesPerSector>0</bytesPerSector>
<cylinders>40</cylinders>
<sides>2</sides>
<sectorsPerTrack>10</sectorsPerTrack>
<bytesPerSector>512</bytesPerSector>
<skew>0</skew>
<side1>
<sideId>0</sideId>
@@ -4308,10 +4308,10 @@
<comment>Columbia 1600 - DSDD 96 tpi 5.25" - 512 x 10</comment>
<encoding>MFM</encoding>
<bitrate>LOW</bitrate>
<cylinders>0</cylinders>
<sides>0</sides>
<sectorsPerTrack>0</sectorsPerTrack>
<bytesPerSector>0</bytesPerSector>
<cylinders>80</cylinders>
<sides>2</sides>
<sectorsPerTrack>10</sectorsPerTrack>
<bytesPerSector>512</bytesPerSector>
<skew>0</skew>
<side1>
<sideId>0</sideId>
@@ -4539,59 +4539,6 @@
<complement>true</complement>
<evenOdd>false</evenOdd>
</CpmDefinition>
<CpmDefinition>
<comment>Compustar 30, Super IOS - DSDD 48 tpi 5.25" - 512 x 10</comment>
<encoding>MFM</encoding>
<bitrate>LOW</bitrate>
<cylinders>35</cylinders>
<sides>2</sides>
<sectorsPerTrack>10</sectorsPerTrack>
<bytesPerSector>512</bytesPerSector>
<skew>0</skew>
<side1>
<sideId>0</sideId>
<sectorIds>
<int>1</int>
<int>3</int>
<int>5</int>
<int>7</int>
<int>9</int>
<int>2</int>
<int>4</int>
<int>6</int>
<int>8</int>
<int>10</int>
</sectorIds>
</side1>
<side2>
<sideId>1</sideId>
<sectorIds>
<int>1</int>
<int>3</int>
<int>5</int>
<int>7</int>
<int>9</int>
<int>2</int>
<int>4</int>
<int>6</int>
<int>8</int>
<int>10</int>
</sectorIds>
</side2>
<order>CYLINDERS</order>
<label>COM4</label>
<bsh>0</bsh>
<blm>0</blm>
<exm>0</exm>
<dsm>0</dsm>
<drm>0</drm>
<al0>0</al0>
<al1>0</al1>
<ofs>0</ofs>
<sofs>0</sofs>
<complement>true</complement>
<evenOdd>false</evenOdd>
</CpmDefinition>
<CpmDefinition>
<comment>Compupro (Viasyn) - DSDD 96 tpi 5.25" - 1024 x 5</comment>
<encoding>MFM</encoding>
@@ -4923,10 +4870,10 @@
<comment>Cromemco CDOS - SSSD 48 tpi 5.25" - 128 x 18</comment>
<encoding>FM</encoding>
<bitrate>LOW</bitrate>
<cylinders>0</cylinders>
<sides>0</sides>
<sectorsPerTrack>0</sectorsPerTrack>
<bytesPerSector>0</bytesPerSector>
<cylinders>40</cylinders>
<sides>1</sides>
<sectorsPerTrack>18</sectorsPerTrack>
<bytesPerSector>128</bytesPerSector>
<skew>0</skew>
<side1>
<sideId>0</sideId>
@@ -4968,10 +4915,10 @@
<comment>Cromemco CDOS - DSSD 48 tpi 5.25" - 128 x 18</comment>
<encoding>FM</encoding>
<bitrate>LOW</bitrate>
<cylinders>0</cylinders>
<sides>0</sides>
<sectorsPerTrack>0</sectorsPerTrack>
<bytesPerSector>0</bytesPerSector>
<cylinders>40</cylinders>
<sides>2</sides>
<sectorsPerTrack>128</sectorsPerTrack>
<bytesPerSector>18</bytesPerSector>
<skew>0</skew>
<side1>
<sideId>0</sideId>
@@ -5037,10 +4984,10 @@
<comment>Cromemco CDOS - SSDD 48 tpi 5.25" - 512 x 10</comment>
<encoding>MFM</encoding>
<bitrate>LOW</bitrate>
<cylinders>0</cylinders>
<sides>0</sides>
<sectorsPerTrack>0</sectorsPerTrack>
<bytesPerSector>0</bytesPerSector>
<cylinders>40</cylinders>
<sides>1</sides>
<sectorsPerTrack>10</sectorsPerTrack>
<bytesPerSector>512</bytesPerSector>
<skew>0</skew>
<side1>
<sideId>0</sideId>
@@ -5074,10 +5021,10 @@
<comment>Cromemco CDOS - DSDD 48 tpi 5.25" - 512 x 10</comment>
<encoding>MFM</encoding>
<bitrate>LOW</bitrate>
<cylinders>0</cylinders>
<sides>0</sides>
<sectorsPerTrack>0</sectorsPerTrack>
<bytesPerSector>0</bytesPerSector>
<cylinders>40</cylinders>
<sides>2</sides>
<sectorsPerTrack>10</sectorsPerTrack>
<bytesPerSector>512</bytesPerSector>
<skew>0</skew>
<side1>
<sideId>0</sideId>
@@ -5127,10 +5074,10 @@
<comment>Cromemco CDOS - DSDD 8" - 512 x 16</comment>
<encoding>MFM</encoding>
<bitrate>HIGH</bitrate>
<cylinders>0</cylinders>
<sides>0</sides>
<sectorsPerTrack>0</sectorsPerTrack>
<bytesPerSector>0</bytesPerSector>
<cylinders>77</cylinders>
<sides>2</sides>
<sectorsPerTrack>16</sectorsPerTrack>
<bytesPerSector>512</bytesPerSector>
<skew>0</skew>
<side1>
<sideId>0</sideId>
@@ -5192,10 +5139,10 @@
<comment>Cromemco CP/M - SSDD 48 tpi 5.25" - 512 x 10</comment>
<encoding>MFM</encoding>
<bitrate>LOW</bitrate>
<cylinders>0</cylinders>
<sides>0</sides>
<sectorsPerTrack>0</sectorsPerTrack>
<bytesPerSector>0</bytesPerSector>
<cylinders>40</cylinders>
<sides>1</sides>
<sectorsPerTrack>10</sectorsPerTrack>
<bytesPerSector>512</bytesPerSector>
<skew>0</skew>
<side1>
<sideId>0</sideId>
@@ -5229,10 +5176,10 @@
<comment>Cromemco CP/M - DSDD 48 tpi 5.25" - 512 x 10</comment>
<encoding>MFM</encoding>
<bitrate>LOW</bitrate>
<cylinders>0</cylinders>
<sides>0</sides>
<sectorsPerTrack>0</sectorsPerTrack>
<bytesPerSector>0</bytesPerSector>
<cylinders>40</cylinders>
<sides>2</sides>
<sectorsPerTrack>10</sectorsPerTrack>
<bytesPerSector>512</bytesPerSector>
<skew>0</skew>
<side1>
<sideId>0</sideId>
@@ -13617,13 +13564,13 @@
<evenOdd>false</evenOdd>
</CpmDefinition>
<CpmDefinition>
<comment>People's World Computer - SSDD 48 tpi 5.25" - 1024 x 5</comment>
<comment>People's World Computer - DSDD 48 tpi 5.25" - 1024 x 5</comment>
<encoding>MFM</encoding>
<bitrate>LOW</bitrate>
<cylinders>0</cylinders>
<sides>0</sides>
<sectorsPerTrack>0</sectorsPerTrack>
<bytesPerSector>0</bytesPerSector>
<cylinders>40</cylinders>
<sides>2</sides>
<sectorsPerTrack>5</sectorsPerTrack>
<bytesPerSector>1024</bytesPerSector>
<skew>0</skew>
<side1>
<sideId>0</sideId>
@@ -14115,98 +14062,6 @@
<complement>false</complement>
<evenOdd>false</evenOdd>
</CpmDefinition>
<CpmDefinition>
<comment>QDP-500 - DSHD 96 tpi 5.25" - 1024 x 8</comment>
<encoding>MFM</encoding>
<bitrate>HIGH</bitrate>
<cylinders>77</cylinders>
<sides>2</sides>
<sectorsPerTrack>8</sectorsPerTrack>
<bytesPerSector>1024</bytesPerSector>
<skew>0</skew>
<side1>
<sideId>0</sideId>
<sectorIds>
<int>1</int>
<int>3</int>
<int>5</int>
<int>7</int>
<int>2</int>
<int>4</int>
<int>6</int>
<int>8</int>
</sectorIds>
</side1>
<side2>
<sideId>1</sideId>
<sectorIds>
<int>1</int>
<int>3</int>
<int>5</int>
<int>7</int>
<int>2</int>
<int>4</int>
<int>6</int>
<int>8</int>
</sectorIds>
</side2>
<order>CYLINDERS</order>
<label>QDP1</label>
<bsh>0</bsh>
<blm>0</blm>
<exm>0</exm>
<dsm>0</dsm>
<drm>0</drm>
<al0>0</al0>
<al1>0</al1>
<ofs>0</ofs>
<sofs>0</sofs>
<complement>false</complement>
<evenOdd>false</evenOdd>
</CpmDefinition>
<CpmDefinition>
<comment>Quay - DSDD 48 tpi 5.25" - 1024 x 5</comment>
<encoding>MFM</encoding>
<bitrate>LOW</bitrate>
<cylinders>40</cylinders>
<sides>2</sides>
<sectorsPerTrack>5</sectorsPerTrack>
<bytesPerSector>1024</bytesPerSector>
<skew>0</skew>
<side1>
<sideId>0</sideId>
<sectorIds>
<int>1</int>
<int>3</int>
<int>5</int>
<int>2</int>
<int>4</int>
</sectorIds>
</side1>
<side2>
<sideId>1</sideId>
<sectorIds>
<int>1</int>
<int>3</int>
<int>5</int>
<int>2</int>
<int>4</int>
</sectorIds>
</side2>
<order>CYLINDERS</order>
<label>QUA1</label>
<bsh>0</bsh>
<blm>0</blm>
<exm>0</exm>
<dsm>0</dsm>
<drm>0</drm>
<al0>0</al0>
<al1>0</al1>
<ofs>0</ofs>
<sofs>0</sofs>
<complement>false</complement>
<evenOdd>false</evenOdd>
</CpmDefinition>
<CpmDefinition>
<comment>Research Machines Limited 380Z - 128 x 16</comment>
<encoding>FM</encoding>
@@ -14636,7 +14491,7 @@
<sides>1</sides>
<sectorsPerTrack>9</sectorsPerTrack>
<bytesPerSector>512</bytesPerSector>
<skew>0</skew>
<skew>2</skew>
<side1>
<sideId>0</sideId>
<sectorIds>
@@ -16875,10 +16730,10 @@
<comment>TeleVideo 806 TurboDOS - DSDD 48 tpi 5.25" - 1024 x 5</comment>
<encoding>MFM</encoding>
<bitrate>LOW</bitrate>
<cylinders>0</cylinders>
<sides>0</sides>
<sectorsPerTrack>0</sectorsPerTrack>
<bytesPerSector>0</bytesPerSector>
<cylinders>40</cylinders>
<sides>2</sides>
<sectorsPerTrack>5</sectorsPerTrack>
<bytesPerSector>1024</bytesPerSector>
<skew>0</skew>
<side1>
<sideId>0</sideId>
@@ -18624,10 +18479,10 @@
<comment>Xerox 820, S/W Publishers DD - SSDD 48 tpi 5.25" - 256 x 18</comment>
<encoding>MFM</encoding>
<bitrate>LOW</bitrate>
<cylinders>0</cylinders>
<sides>0</sides>
<sectorsPerTrack>0</sectorsPerTrack>
<bytesPerSector>0</bytesPerSector>
<cylinders>40</cylinders>
<sides>1</sides>
<sectorsPerTrack>18</sectorsPerTrack>
<bytesPerSector>256</bytesPerSector>
<skew>0</skew>
<side1>
<sideId>0</sideId>
@@ -19849,12 +19704,30 @@
<sideId>0</sideId>
<sectorIds>
<int>0</int>
<int>1</int>
<int>2</int>
<int>3</int>
<int>4</int>
<int>5</int>
<int>6</int>
<int>7</int>
<int>8</int>
<int>9</int>
</sectorIds>
</side1>
<side2>
<sideId>0</sideId>
<sideId>1</sideId>
<sectorIds>
<int>0</int>
<int>1</int>
<int>2</int>
<int>3</int>
<int>4</int>
<int>5</int>
<int>6</int>
<int>7</int>
<int>8</int>
<int>9</int>
</sectorIds>
</side2>
<order>CYLINDERS</order>
@@ -19871,34 +19744,6 @@
<complement>false</complement>
<evenOdd>false</evenOdd>
</CpmDefinition>
<CpmDefinition>
<comment>CPC-STD 178K Data 40trk 9sct 64dir 1Kpb Side 1</comment>
<encoding>MFM</encoding>
<bitrate>LOW</bitrate>
<cylinders>40</cylinders>
<sides>1</sides>
<sectorsPerTrack>9</sectorsPerTrack>
<bytesPerSector>512</bytesPerSector>
<skew>5</skew>
<side1>
<sideId>0</sideId>
<sectorIds>
<int>0</int>
</sectorIds>
</side1>
<label>DA1A</label>
<bsh>0</bsh>
<blm>0</blm>
<exm>0</exm>
<dsm>0</dsm>
<drm>0</drm>
<al0>0</al0>
<al1>0</al1>
<ofs>0</ofs>
<sofs>0</sofs>
<complement>false</complement>
<evenOdd>false</evenOdd>
</CpmDefinition>
<CpmDefinition>
<comment>CPC 178K Data 40trk 9sct 64dir 1Kpb Side 2</comment>
<encoding>MFM</encoding>
@@ -19934,34 +19779,6 @@
<complement>false</complement>
<evenOdd>false</evenOdd>
</CpmDefinition>
<CpmDefinition>
<comment>CPC 187K Data 42trk 9sct 64dir 1Kpb Side 1</comment>
<encoding>MFM</encoding>
<bitrate>LOW</bitrate>
<cylinders>42</cylinders>
<sides>1</sides>
<sectorsPerTrack>9</sectorsPerTrack>
<bytesPerSector>512</bytesPerSector>
<skew>5</skew>
<side1>
<sideId>0</sideId>
<sectorIds>
<int>0</int>
</sectorIds>
</side1>
<label>DA2A</label>
<bsh>0</bsh>
<blm>0</blm>
<exm>0</exm>
<dsm>0</dsm>
<drm>0</drm>
<al0>0</al0>
<al1>0</al1>
<ofs>0</ofs>
<sofs>0</sofs>
<complement>false</complement>
<evenOdd>false</evenOdd>
</CpmDefinition>
<CpmDefinition>
<comment>CPC 187K Data 42trk 9sct 64dir 1Kpb Side 2</comment>
<encoding>MFM</encoding>
@@ -19997,69 +19814,6 @@
<complement>false</complement>
<evenOdd>false</evenOdd>
</CpmDefinition>
<CpmDefinition>
<comment>CPC 253K Data 60trk 9sct 64dir 1Kpb Side 1</comment>
<encoding>MFM</encoding>
<bitrate>LOW</bitrate>
<cylinders>60</cylinders>
<sides>1</sides>
<sectorsPerTrack>9</sectorsPerTrack>
<bytesPerSector>512</bytesPerSector>
<skew>5</skew>
<side1>
<sideId>0</sideId>
<sectorIds>
<int>0</int>
</sectorIds>
</side1>
<label>DA3A</label>
<bsh>0</bsh>
<blm>0</blm>
<exm>0</exm>
<dsm>0</dsm>
<drm>0</drm>
<al0>0</al0>
<al1>0</al1>
<ofs>0</ofs>
<sofs>0</sofs>
<complement>false</complement>
<evenOdd>false</evenOdd>
</CpmDefinition>
<CpmDefinition>
<comment>CPC 253K Data 60trk 9sct 64dir 1Kpb Side 2</comment>
<encoding>MFM</encoding>
<bitrate>LOW</bitrate>
<cylinders>60</cylinders>
<sides>2</sides>
<sectorsPerTrack>9</sectorsPerTrack>
<bytesPerSector>512</bytesPerSector>
<skew>5</skew>
<side1>
<sideId>0</sideId>
<sectorIds>
<int>0</int>
</sectorIds>
</side1>
<side2>
<sideId>0</sideId>
<sectorIds>
<int>0</int>
</sectorIds>
</side2>
<order>EAGLE</order>
<label>DA3B</label>
<bsh>0</bsh>
<blm>0</blm>
<exm>0</exm>
<dsm>0</dsm>
<drm>0</drm>
<al0>0</al0>
<al1>0</al1>
<ofs>0</ofs>
<sofs>0</sofs>
<complement>false</complement>
<evenOdd>false</evenOdd>
</CpmDefinition>
<CpmDefinition>
<comment>CPC-B360 358K Data 80trk 9sct 64dir 2Kpb Side 1</comment>
<encoding>MFM</encoding>
@@ -20689,6 +20443,14 @@
<sideId>0</sideId>
<sectorIds>
<int>1</int>
<int>2</int>
<int>3</int>
<int>4</int>
<int>5</int>
<int>6</int>
<int>7</int>
<int>8</int>
<int>9</int>
</sectorIds>
</side1>
<label>PC1A</label>
@@ -20717,12 +20479,28 @@
<sideId>0</sideId>
<sectorIds>
<int>1</int>
<int>2</int>
<int>3</int>
<int>4</int>
<int>5</int>
<int>6</int>
<int>7</int>
<int>8</int>
<int>9</int>
</sectorIds>
</side1>
<side2>
<sideId>0</sideId>
<sectorIds>
<int>1</int>
<int>2</int>
<int>3</int>
<int>4</int>
<int>5</int>
<int>6</int>
<int>7</int>
<int>8</int>
<int>9</int>
</sectorIds>
</side2>
<order>EAGLE</order>
@@ -20752,12 +20530,28 @@
<sideId>0</sideId>
<sectorIds>
<int>1</int>
<int>2</int>
<int>3</int>
<int>4</int>
<int>5</int>
<int>6</int>
<int>7</int>
<int>8</int>
<int>9</int>
</sectorIds>
</side1>
<side2>
<sideId>1</sideId>
<sectorIds>
<int>1</int>
<int>2</int>
<int>3</int>
<int>4</int>
<int>5</int>
<int>6</int>
<int>7</int>
<int>8</int>
<int>9</int>
</sectorIds>
</side2>
<order>SIDES</order>
@@ -20776,21 +20570,37 @@
</CpmDefinition>
<CpmDefinition>
<comment>PCW 706K Format 80trk 9sct 256dir 2Kpb Two Sides</comment>
<cylinders>0</cylinders>
<sides>0</sides>
<sectorsPerTrack>0</sectorsPerTrack>
<bytesPerSector>0</bytesPerSector>
<cylinders>80</cylinders>
<sides>2</sides>
<sectorsPerTrack>9</sectorsPerTrack>
<bytesPerSector>512</bytesPerSector>
<skew>0</skew>
<side1>
<sideId>0</sideId>
<sectorIds>
<int>1</int>
<int>2</int>
<int>3</int>
<int>4</int>
<int>5</int>
<int>6</int>
<int>7</int>
<int>8</int>
<int>9</int>
</sectorIds>
</side1>
<side2>
<sideId>1</sideId>
<sectorIds>
<int>1</int>
<int>2</int>
<int>3</int>
<int>4</int>
<int>5</int>
<int>6</int>
<int>7</int>
<int>8</int>
<int>9</int>
</sectorIds>
</side2>
<label>PCW3</label>
@@ -20806,132 +20616,6 @@
<complement>false</complement>
<evenOdd>false</evenOdd>
</CpmDefinition>
<CpmDefinition>
<comment>CPC 398K Data 80trk 10sct 64dir 2Kpb Side 1</comment>
<encoding>MFM</encoding>
<bitrate>LOW</bitrate>
<cylinders>80</cylinders>
<sides>1</sides>
<sectorsPerTrack>10</sectorsPerTrack>
<bytesPerSector>512</bytesPerSector>
<skew>2</skew>
<side1>
<sideId>0</sideId>
<sectorIds>
<int>0</int>
</sectorIds>
</side1>
<label>DX1A</label>
<bsh>0</bsh>
<blm>0</blm>
<exm>0</exm>
<dsm>0</dsm>
<drm>0</drm>
<al0>0</al0>
<al1>0</al1>
<ofs>0</ofs>
<sofs>0</sofs>
<complement>false</complement>
<evenOdd>false</evenOdd>
</CpmDefinition>
<CpmDefinition>
<comment>CPC 398K Data 80trk 10sct 64dir 2Kpb Side 2</comment>
<encoding>MFM</encoding>
<bitrate>LOW</bitrate>
<cylinders>80</cylinders>
<sides>2</sides>
<sectorsPerTrack>10</sectorsPerTrack>
<bytesPerSector>512</bytesPerSector>
<skew>2</skew>
<side1>
<sideId>0</sideId>
<sectorIds>
<int>0</int>
</sectorIds>
</side1>
<side2>
<sideId>0</sideId>
<sectorIds>
<int>0</int>
</sectorIds>
</side2>
<order>EAGLE</order>
<label>DX1B</label>
<bsh>0</bsh>
<blm>0</blm>
<exm>0</exm>
<dsm>0</dsm>
<drm>0</drm>
<al0>0</al0>
<al1>0</al1>
<ofs>0</ofs>
<sofs>0</sofs>
<complement>false</complement>
<evenOdd>false</evenOdd>
</CpmDefinition>
<CpmDefinition>
<comment>MAGIC-DOS 408K Data 82trk 10sct 64dir 2Kpb Side 1</comment>
<encoding>MFM</encoding>
<bitrate>LOW</bitrate>
<cylinders>82</cylinders>
<sides>1</sides>
<sectorsPerTrack>10</sectorsPerTrack>
<bytesPerSector>512</bytesPerSector>
<skew>2</skew>
<side1>
<sideId>0</sideId>
<sectorIds>
<int>0</int>
</sectorIds>
</side1>
<label>DX2A</label>
<bsh>0</bsh>
<blm>0</blm>
<exm>0</exm>
<dsm>0</dsm>
<drm>0</drm>
<al0>0</al0>
<al1>0</al1>
<ofs>0</ofs>
<sofs>0</sofs>
<complement>false</complement>
<evenOdd>false</evenOdd>
</CpmDefinition>
<CpmDefinition>
<comment>MAGIC-DOS 408K Data 82trk 10sct 64dir 2Kpb Side 2</comment>
<encoding>MFM</encoding>
<bitrate>LOW</bitrate>
<cylinders>82</cylinders>
<sides>2</sides>
<sectorsPerTrack>10</sectorsPerTrack>
<bytesPerSector>512</bytesPerSector>
<skew>2</skew>
<side1>
<sideId>0</sideId>
<sectorIds>
<int>0</int>
</sectorIds>
</side1>
<side2>
<sideId>0</sideId>
<sectorIds>
<int>0</int>
</sectorIds>
</side2>
<order>EAGLE</order>
<label>DX2B</label>
<bsh>0</bsh>
<blm>0</blm>
<exm>0</exm>
<dsm>0</dsm>
<drm>0</drm>
<al0>0</al0>
<al1>0</al1>
<ofs>0</ofs>
<sofs>0</sofs>
<complement>false</complement>
<evenOdd>false</evenOdd>
</CpmDefinition>
<CpmDefinition>
<comment>PCW 784K Format 80trk 10sct 256dir 4Kpb Two Sides</comment>
<encoding>MFM</encoding>
@@ -20945,12 +20629,30 @@
<sideId>0</sideId>
<sectorIds>
<int>1</int>
<int>2</int>
<int>3</int>
<int>4</int>
<int>5</int>
<int>6</int>
<int>7</int>
<int>8</int>
<int>9</int>
<int>10</int>
</sectorIds>
</side1>
<side2>
<sideId>1</sideId>
<sectorIds>
<int>1</int>
<int>2</int>
<int>3</int>
<int>4</int>
<int>5</int>
<int>6</int>
<int>7</int>
<int>8</int>
<int>9</int>
<int>10</int>
</sectorIds>
</side2>
<order>SIDES</order>
@@ -21958,6 +21660,42 @@
<complement>false</complement>
<evenOdd>false</evenOdd>
</CpmDefinition>
<CpmDefinition>
<comment>Extended CPC 3" 43-track</comment>
<encoding>MFM</encoding>
<bitrate>LOW</bitrate>
<cylinders>43</cylinders>
<sides>1</sides>
<sectorsPerTrack>9</sectorsPerTrack>
<bytesPerSector>512</bytesPerSector>
<skew>2</skew>
<side1>
<sideId>0</sideId>
<sectorIds>
<int>193</int>
<int>194</int>
<int>195</int>
<int>196</int>
<int>197</int>
<int>198</int>
<int>199</int>
<int>200</int>
<int>201</int>
</sectorIds>
</side1>
<label>AMS7</label>
<bsh>3</bsh>
<blm>7</blm>
<exm>0</exm>
<dsm>193</dsm>
<drm>63</drm>
<al0>192</al0>
<al1>0</al1>
<ofs>0</ofs>
<sofs>0</sofs>
<complement>false</complement>
<evenOdd>false</evenOdd>
</CpmDefinition>
<CpmDefinition>
<comment>Apple // CPM card 13-sector</comment>
<encoding>GCR</encoding>

15
DiscImageChef.Filesystems/ChangeLog
View File

@@ -1,3 +1,18 @@
2016-08-26 Natalia Portillo <claunia@claunia.com>
* CPM.cs:
* Dir.cs:
* File.cs:
* Info.cs:
* Xattr.cs:
* Super.cs:
* Consts.cs:
* Structs.cs:
* cpmdefs.xml:
* Definitions.cs:
* DiscImageChef.Filesystems.csproj: Added CP/M filesystem,
closes #29.
2016-08-26 Natalia Portillo <claunia@claunia.com>
* Dir.cs: Typo.

12
DiscImageChef.Filesystems/DiscImageChef.Filesystems.csproj
View File

@@ -31,6 +31,7 @@
</PropertyGroup>
<ItemGroup>
<Reference Include="System" />
<Reference Include="System.Xml" />
</ItemGroup>
<ItemGroup>
<Compile Include="Properties\AssemblyInfo.cs" />
@@ -87,6 +88,15 @@
<Compile Include="AppleMFS\Super.cs" />
<Compile Include="AppleMFS\Xattr.cs" />
<Compile Include="exFAT.cs" />
<Compile Include="CPM\Info.cs" />
<Compile Include="CPM\CPM.cs" />
<Compile Include="CPM\Structs.cs" />
<Compile Include="CPM\Definitions.cs" />
<Compile Include="CPM\Dir.cs" />
<Compile Include="CPM\Super.cs" />
<Compile Include="CPM\Consts.cs" />
<Compile Include="CPM\File.cs" />
<Compile Include="CPM\Xattr.cs" />
</ItemGroup>
<Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
<ItemGroup>
@@ -127,11 +137,13 @@
<Folder Include="LisaFS\" />
<Folder Include="UCSDPascal\" />
<Folder Include="AppleMFS\" />
<Folder Include="CPM\" />
</ItemGroup>
<ItemGroup>
<EmbeddedResource Include="..\LICENSE.LGPL">
<Link>LICENSE.LGPL</Link>
</EmbeddedResource>
<EmbeddedResource Include="CPM\cpmdefs.xml" />
</ItemGroup>
<ProjectExtensions>
<MonoDevelop>