Errno GetFileEntry(string path, out CompleteDirectoryEntry entry)
{
entry = null;
string cutPath = path.StartsWith('/') ? path.Substring(1).ToLower(_cultureInfo)
: path.ToLower(_cultureInfo);
string[] pieces = cutPath.Split(new[]
{
'/'
}, StringSplitOptions.RemoveEmptyEntries);
if (pieces.Length == 0)
{
return(Errno.InvalidArgument);
}
string parentPath = string.Join("/", pieces, 0, pieces.Length - 1);
if (!_directoryCache.TryGetValue(parentPath, out _))
{
Errno err = ReadDir(parentPath, out _);
if (err != Errno.NoError)
{
return(err);
}
}
Dictionary <string, CompleteDirectoryEntry> parent;
if (pieces.Length == 1)
{
parent = _rootDirectoryCache;
}
else if (!_directoryCache.TryGetValue(parentPath, out parent))
{
return(Errno.InvalidArgument);
}
KeyValuePair <string, CompleteDirectoryEntry> dirent =
parent.FirstOrDefault(t => t.Key.ToLower(_cultureInfo) == pieces[^ 1]);
if (string.IsNullOrEmpty(dirent.Key))
{
return(Errno.NoSuchFile);
}
entry = dirent.Value;
return(Errno.NoError);
}
/// <inheritdoc />
/// <summary>Lists contents from a directory.</summary>
/// <param name="path">Directory path.</param>
/// <param name="contents">Directory contents.</param>
public Errno ReadDir(string path, out List <string> contents)
{
contents = null;
if (!_mounted)
{
return(Errno.AccessDenied);
}
if (string.IsNullOrWhiteSpace(path) ||
path == "/")
{
contents = _rootDirectoryCache.Keys.ToList();
return(Errno.NoError);
}
string cutPath = path.StartsWith("/", StringComparison.Ordinal) ? path.Substring(1).ToLower(_cultureInfo)
: path.ToLower(_cultureInfo);
if (_directoryCache.TryGetValue(cutPath, out Dictionary <string, CompleteDirectoryEntry> currentDirectory))
{
contents = currentDirectory.Keys.ToList();
return(Errno.NoError);
}
string[] pieces = cutPath.Split(new[]
{
'/'
}, StringSplitOptions.RemoveEmptyEntries);
KeyValuePair <string, CompleteDirectoryEntry> entry =
_rootDirectoryCache.FirstOrDefault(t => t.Key.ToLower(_cultureInfo) == pieces[0]);
if (string.IsNullOrEmpty(entry.Key))
{
return(Errno.NoSuchFile);
}
if (!entry.Value.Dirent.attributes.HasFlag(FatAttributes.Subdirectory))
{
return(Errno.NotDirectory);
}
string currentPath = pieces[0];
currentDirectory = _rootDirectoryCache;
for (int p = 0; p < pieces.Length; p++)
{
entry = currentDirectory.FirstOrDefault(t => t.Key.ToLower(_cultureInfo) == pieces[p]);
if (string.IsNullOrEmpty(entry.Key))
{
return(Errno.NoSuchFile);
}
if (!entry.Value.Dirent.attributes.HasFlag(FatAttributes.Subdirectory))
{
return(Errno.NotDirectory);
}
currentPath = p == 0 ? pieces[0] : $"{currentPath}/{pieces[p]}";
uint currentCluster = entry.Value.Dirent.start_cluster;
if (_fat32)
{
currentCluster += (uint)(entry.Value.Dirent.ea_handle << 16);
}
if (_directoryCache.TryGetValue(currentPath, out currentDirectory))
{
continue;
}
uint[] clusters = GetClusters(currentCluster);
if (clusters is null)
{
return(Errno.InvalidArgument);
}
byte[] directoryBuffer = new byte[_bytesPerCluster * clusters.Length];
for (int i = 0; i < clusters.Length; i++)
{
byte[] buffer = _image.ReadSectors(_firstClusterSector + (clusters[i] * _sectorsPerCluster),
_sectorsPerCluster);
Array.Copy(buffer, 0, directoryBuffer, i * _bytesPerCluster, _bytesPerCluster);
}
currentDirectory = new Dictionary <string, CompleteDirectoryEntry>();
byte[] lastLfnName = null;
byte lastLfnChecksum = 0;
for (int pos = 0; pos < directoryBuffer.Length; pos += Marshal.SizeOf <DirectoryEntry>())
{
DirectoryEntry dirent =
Marshal.ByteArrayToStructureLittleEndian <DirectoryEntry>(directoryBuffer, pos,
Marshal.SizeOf <DirectoryEntry>());
if (dirent.filename[0] == DIRENT_FINISHED)
{
break;
}
if (dirent.attributes.HasFlag(FatAttributes.LFN))
{
if (_namespace != Namespace.Lfn &&
_namespace != Namespace.Ecs)
{
continue;
}
LfnEntry lfnEntry =
Marshal.ByteArrayToStructureLittleEndian <LfnEntry>(directoryBuffer, pos,
Marshal.SizeOf <LfnEntry>());
int lfnSequence = lfnEntry.sequence & LFN_MASK;
if ((lfnEntry.sequence & LFN_ERASED) > 0)
{
continue;
}
if ((lfnEntry.sequence & LFN_LAST) > 0)
{
lastLfnName = new byte[lfnSequence * 26];
lastLfnChecksum = lfnEntry.checksum;
}
if (lastLfnName is null)
{
continue;
}
if (lfnEntry.checksum != lastLfnChecksum)
{
continue;
}
lfnSequence--;
Array.Copy(lfnEntry.name1, 0, lastLfnName, lfnSequence * 26, 10);
Array.Copy(lfnEntry.name2, 0, lastLfnName, (lfnSequence * 26) + 10, 12);
Array.Copy(lfnEntry.name3, 0, lastLfnName, (lfnSequence * 26) + 22, 4);
continue;
}
// Not a correct entry
if (dirent.filename[0] < DIRENT_MIN &&
dirent.filename[0] != DIRENT_E5)
{
continue;
}
// Self
if (Encoding.GetString(dirent.filename).TrimEnd() == ".")
{
continue;
}
// Parent
if (Encoding.GetString(dirent.filename).TrimEnd() == "..")
{
continue;
}
// Deleted
if (dirent.filename[0] == DIRENT_DELETED)
{
continue;
}
string filename;
if (dirent.attributes.HasFlag(FatAttributes.VolumeLabel))
{
continue;
}
var completeEntry = new CompleteDirectoryEntry
{
Dirent = dirent
};
if ((_namespace == Namespace.Lfn || _namespace == Namespace.Ecs) &&
lastLfnName != null)
{
byte calculatedLfnChecksum = LfnChecksum(dirent.filename, dirent.extension);
if (calculatedLfnChecksum == lastLfnChecksum)
{
filename = StringHandlers.CToString(lastLfnName, Encoding.Unicode, true);
completeEntry.Lfn = filename;
lastLfnName = null;
lastLfnChecksum = 0;
}
}
if (dirent.filename[0] == DIRENT_E5)
{
dirent.filename[0] = DIRENT_DELETED;
}
string name = Encoding.GetString(dirent.filename).TrimEnd();
string extension = Encoding.GetString(dirent.extension).TrimEnd();
if (_namespace == Namespace.Nt)
{
if (dirent.caseinfo.HasFlag(CaseInfo.LowerCaseExtension))
{
extension = extension.ToLower(CultureInfo.CurrentCulture);
}
if (dirent.caseinfo.HasFlag(CaseInfo.LowerCaseBasename))
{
name = name.ToLower(CultureInfo.CurrentCulture);
}
}
if (extension != "")
{
filename = name + "." + extension;
}
else
{
filename = name;
}
if (_namespace == Namespace.Human)
{
HumanDirectoryEntry humanEntry =
Marshal.ByteArrayToStructureLittleEndian <HumanDirectoryEntry>(directoryBuffer, pos,
Marshal.
SizeOf <HumanDirectoryEntry
>());
completeEntry.HumanDirent = humanEntry;
name = StringHandlers.CToString(humanEntry.name1, Encoding).TrimEnd();
extension = StringHandlers.CToString(humanEntry.extension, Encoding).TrimEnd();
string name2 = StringHandlers.CToString(humanEntry.name2, Encoding).TrimEnd();
if (extension != "")
{
filename = name + name2 + "." + extension;
}
else
{
filename = name + name2;
}
completeEntry.HumanName = filename;
}
// Using array accessor ensures that repeated entries just get substituted.
// Repeated entries are not allowed but some bad implementations (e.g. FAT32.IFS)allow to create them
// when using spaces
completeEntry.Shortname = filename;
currentDirectory[completeEntry.ToString()] = completeEntry;
}
// Check OS/2 .LONGNAME
if (_eaCache != null &&
(_namespace == Namespace.Os2 || _namespace == Namespace.Ecs) &&
!_fat32)
{
List <KeyValuePair <string, CompleteDirectoryEntry> > filesWithEas =
currentDirectory.Where(t => t.Value.Dirent.ea_handle != 0).ToList();
foreach (KeyValuePair <string, CompleteDirectoryEntry> fileWithEa in filesWithEas)
{
Dictionary <string, byte[]> eas = GetEas(fileWithEa.Value.Dirent.ea_handle);
if (eas is null)
{
continue;
}
if (!eas.TryGetValue("com.microsoft.os2.longname", out byte[] longnameEa))
/// <inheritdoc />
public Errno Mount(IMediaImage imagePlugin, Partition partition, Encoding encoding,
Dictionary <string, string> options, string @namespace)
{
XmlFsType = new FileSystemType();
options ??= GetDefaultOptions();
if (options.TryGetValue("debug", out string debugString))
{
bool.TryParse(debugString, out _debug);
}
// Default namespace
@namespace ??= "ecs";
switch (@namespace.ToLowerInvariant())
{
case "dos":
_namespace = Namespace.Dos;
break;
case "nt":
_namespace = Namespace.Nt;
break;
case "os2":
_namespace = Namespace.Os2;
break;
case "ecs":
_namespace = Namespace.Ecs;
break;
case "lfn":
_namespace = Namespace.Lfn;
break;
case "human":
_namespace = Namespace.Human;
break;
default: return(Errno.InvalidArgument);
}
AaruConsole.DebugWriteLine("FAT plugin", "Reading BPB");
uint sectorsPerBpb = imagePlugin.Info.SectorSize < 512 ? 512 / imagePlugin.Info.SectorSize : 1;
byte[] bpbSector = imagePlugin.ReadSectors(0 + partition.Start, sectorsPerBpb);
BpbKind bpbKind = DetectBpbKind(bpbSector, imagePlugin, partition, out BiosParameterBlockEbpb fakeBpb,
out HumanParameterBlock humanBpb, out AtariParameterBlock atariBpb,
out byte minBootNearJump, out bool andosOemCorrect, out bool bootable);
_fat12 = false;
_fat16 = false;
_fat32 = false;
_useFirstFat = true;
XmlFsType.Bootable = bootable;
_statfs = new FileSystemInfo
{
FilenameLength = 11,
Files = 0, // Requires traversing all directories
FreeFiles = 0,
PluginId = Id,
FreeBlocks = 0 // Requires traversing the FAT
};
// This is needed because for FAT16, GEMDOS increases bytes per sector count instead of using big_sectors field.
uint sectorsPerRealSector = 1;
// This is needed because some OSes don't put volume label as first entry in the root directory
uint sectorsForRootDirectory = 0;
uint rootDirectoryCluster = 0;
Encoding = encoding ?? (bpbKind == BpbKind.Human ? Encoding.GetEncoding("shift_jis")
: Encoding.GetEncoding("IBM437"));
switch (bpbKind)
{
case BpbKind.DecRainbow:
case BpbKind.Hardcoded:
case BpbKind.Msx:
case BpbKind.Apricot:
_fat12 = true;
break;
case BpbKind.ShortFat32:
case BpbKind.LongFat32:
{
_fat32 = true;
Fat32ParameterBlock fat32Bpb =
Marshal.ByteArrayToStructureLittleEndian <Fat32ParameterBlock>(bpbSector);
Fat32ParameterBlockShort shortFat32Bpb =
Marshal.ByteArrayToStructureLittleEndian <Fat32ParameterBlockShort>(bpbSector);
rootDirectoryCluster = fat32Bpb.root_cluster;
// This is to support FAT partitions on hybrid ISO/USB images
if (imagePlugin.Info.XmlMediaType == XmlMediaType.OpticalDisc)
{
fat32Bpb.bps *= 4;
fat32Bpb.spc /= 4;
fat32Bpb.big_spfat /= 4;
fat32Bpb.hsectors /= 4;
fat32Bpb.sptrk /= 4;
}
XmlFsType.Type = fat32Bpb.version != 0 ? "FAT+" : "FAT32";
if (fat32Bpb.oem_name != null &&
(fat32Bpb.oem_name[5] != 0x49 || fat32Bpb.oem_name[6] != 0x48 || fat32Bpb.oem_name[7] != 0x43))
{
XmlFsType.SystemIdentifier = StringHandlers.CToString(fat32Bpb.oem_name);
}
_sectorsPerCluster = fat32Bpb.spc;
XmlFsType.ClusterSize = (uint)(fat32Bpb.bps * fat32Bpb.spc);
_reservedSectors = fat32Bpb.rsectors;
if (fat32Bpb.big_sectors == 0 &&
fat32Bpb.signature == 0x28)
{
XmlFsType.Clusters = shortFat32Bpb.huge_sectors / shortFat32Bpb.spc;
}
else if (fat32Bpb.sectors == 0)
{
XmlFsType.Clusters = fat32Bpb.big_sectors / fat32Bpb.spc;
}
else
{
XmlFsType.Clusters = (ulong)(fat32Bpb.sectors / fat32Bpb.spc);
}
_sectorsPerFat = fat32Bpb.big_spfat;
XmlFsType.VolumeSerial = $"{fat32Bpb.serial_no:X8}";
_statfs.Id = new FileSystemId
{
IsInt = true,
Serial32 = fat32Bpb.serial_no
};
if ((fat32Bpb.flags & 0xF8) == 0x00)
{
if ((fat32Bpb.flags & 0x01) == 0x01)
{
XmlFsType.Dirty = true;
}
}
if ((fat32Bpb.mirror_flags & 0x80) == 0x80)
{
_useFirstFat = (fat32Bpb.mirror_flags & 0xF) != 1;
}
if (fat32Bpb.signature == 0x29)
{
XmlFsType.VolumeName = StringHandlers.SpacePaddedToString(fat32Bpb.volume_label, Encoding);
XmlFsType.VolumeName = XmlFsType.VolumeName?.Replace("\0", "");
}
// Check that jumps to a correct boot code position and has boot signature set.
// This will mean that the volume will boot, even if just to say "this is not bootable change disk"......
XmlFsType.Bootable =
(fat32Bpb.jump[0] == 0xEB && fat32Bpb.jump[1] >= minBootNearJump && fat32Bpb.jump[1] < 0x80) ||
(fat32Bpb.jump[0] == 0xE9 && fat32Bpb.jump.Length >= 3 &&
BitConverter.ToUInt16(fat32Bpb.jump, 1) >= minBootNearJump &&
BitConverter.ToUInt16(fat32Bpb.jump, 1) <= 0x1FC);
sectorsPerRealSector = fat32Bpb.bps / imagePlugin.Info.SectorSize;
_sectorsPerCluster *= sectorsPerRealSector;
// First root directory sector
_firstClusterSector =
((ulong)((fat32Bpb.big_spfat * fat32Bpb.fats_no) + fat32Bpb.rsectors) * sectorsPerRealSector) -
(2 * _sectorsPerCluster);
if (fat32Bpb.fsinfo_sector + partition.Start <= partition.End)
{
byte[] fsinfoSector = imagePlugin.ReadSector(fat32Bpb.fsinfo_sector + partition.Start);
FsInfoSector fsInfo = Marshal.ByteArrayToStructureLittleEndian <FsInfoSector>(fsinfoSector);
if (fsInfo.signature1 == FSINFO_SIGNATURE1 &&
fsInfo.signature2 == FSINFO_SIGNATURE2 &&
fsInfo.signature3 == FSINFO_SIGNATURE3)
{
if (fsInfo.free_clusters < 0xFFFFFFFF)
{
XmlFsType.FreeClusters = fsInfo.free_clusters;
XmlFsType.FreeClustersSpecified = true;
}
}
}
break;
}
// Some fields could overflow fake BPB, those will be handled below
case BpbKind.Atari:
{
ushort sum = 0;
for (int i = 0; i < bpbSector.Length; i += 2)
{
sum += BigEndianBitConverter.ToUInt16(bpbSector, i);
}
// TODO: Check this
if (sum == 0x1234)
{
XmlFsType.Bootable = true;
}
// BGM changes the bytes per sector instead of changing the sectors per cluster. Why?! WHY!?
uint ratio = fakeBpb.bps / imagePlugin.Info.SectorSize;
fakeBpb.bps = (ushort)imagePlugin.Info.SectorSize;
fakeBpb.spc = (byte)(fakeBpb.spc * ratio);
fakeBpb.rsectors = (ushort)(fakeBpb.rsectors * ratio);
fakeBpb.big_sectors = fakeBpb.sectors * ratio;
fakeBpb.sectors = 0;
fakeBpb.spfat = (ushort)(fakeBpb.spfat * ratio);
fakeBpb.sptrk = (ushort)(fakeBpb.sptrk * ratio);
break;
}
case BpbKind.Human:
// If not debug set Human68k namespace and ShiftJIS codepage as defaults
if (!_debug)
{
_namespace = Namespace.Human;
}
XmlFsType.Bootable = true;
break;
}
ulong firstRootSector = 0;
if (!_fat32)
{
// This is to support FAT partitions on hybrid ISO/USB images
if (imagePlugin.Info.XmlMediaType == XmlMediaType.OpticalDisc)
{
fakeBpb.bps *= 4;
fakeBpb.spc /= 4;
fakeBpb.spfat /= 4;
fakeBpb.hsectors /= 4;
fakeBpb.sptrk /= 4;
fakeBpb.rsectors /= 4;
if (fakeBpb.spc == 0)
{
fakeBpb.spc = 1;
}
}
ulong clusters;
if (bpbKind != BpbKind.Human)
{
int reservedSectors = fakeBpb.rsectors + (fakeBpb.fats_no * fakeBpb.spfat) +
(fakeBpb.root_ent * 32 / fakeBpb.bps);
if (fakeBpb.sectors == 0)
{
clusters = (ulong)(fakeBpb.spc == 0 ? fakeBpb.big_sectors - reservedSectors
: (fakeBpb.big_sectors - reservedSectors) / fakeBpb.spc);
}
else
{
clusters = (ulong)(fakeBpb.spc == 0 ? fakeBpb.sectors - reservedSectors
: (fakeBpb.sectors - reservedSectors) / fakeBpb.spc);
}
}
else
{
clusters = humanBpb.clusters == 0 ? humanBpb.big_clusters : humanBpb.clusters;
}
// This will walk all the FAT entries and check if they're valid FAT12 or FAT16 entries.
// If the whole table is valid in both senses, it considers the type entry in the BPB.
// BeOS is known to set the type as FAT16 but treat it as FAT12.
if (!_fat12 &&
!_fat16)
{
if (clusters < 4089)
{
ushort[] fat12 = new ushort[clusters];
_reservedSectors = fakeBpb.rsectors;
sectorsPerRealSector = fakeBpb.bps / imagePlugin.Info.SectorSize;
_fatFirstSector = partition.Start + (_reservedSectors * sectorsPerRealSector);
byte[] fatBytes = imagePlugin.ReadSectors(_fatFirstSector, fakeBpb.spfat);
int pos = 0;
for (int i = 0; i + 3 < fatBytes.Length && pos < fat12.Length; i += 3)
{
fat12[pos++] = (ushort)(((fatBytes[i + 1] & 0xF) << 8) + fatBytes[i + 0]);
if (pos >= fat12.Length)
{
break;
}
fat12[pos++] = (ushort)(((fatBytes[i + 1] & 0xF0) >> 4) + (fatBytes[i + 2] << 4));
}
bool fat12Valid = fat12[0] >= FAT12_RESERVED && fat12[1] >= FAT12_RESERVED;
foreach (ushort entry in fat12)
{
if (entry >= FAT12_RESERVED ||
entry <= clusters)
{
continue;
}
fat12Valid = false;
break;
}
ushort[] fat16 = MemoryMarshal.Cast <byte, ushort>(fatBytes).ToArray();
bool fat16Valid = fat16[0] >= FAT16_RESERVED && fat16[1] >= 0x3FF0;
foreach (ushort entry in fat16)
{
if (entry >= FAT16_RESERVED ||
entry <= clusters)
{
continue;
}
fat16Valid = false;
break;
}
_fat12 = fat12Valid;
_fat16 = fat16Valid;
// Check BPB type
if (_fat12 == _fat16)
{
_fat12 = Encoding.ASCII.GetString(fakeBpb.fs_type) == "FAT12 ";
_fat16 = Encoding.ASCII.GetString(fakeBpb.fs_type) == "FAT16 ";
}
}
else
{
_fat16 = true;
}
}
if (_fat12)
{
XmlFsType.Type = "FAT12";
}
else if (_fat16)
{
XmlFsType.Type = "FAT16";
}
if (bpbKind == BpbKind.Atari)
{
if (atariBpb.serial_no[0] != 0x49 ||
atariBpb.serial_no[1] != 0x48 ||
atariBpb.serial_no[2] != 0x43)
{
XmlFsType.VolumeSerial =
$"{atariBpb.serial_no[0]:X2}{atariBpb.serial_no[1]:X2}{atariBpb.serial_no[2]:X2}";
_statfs.Id = new FileSystemId
{
IsInt = true,
Serial32 = (uint)((atariBpb.serial_no[0] << 16) + (atariBpb.serial_no[1] << 8) +
atariBpb.serial_no[2])
};
}
XmlFsType.SystemIdentifier = StringHandlers.CToString(atariBpb.oem_name);
if (string.IsNullOrEmpty(XmlFsType.SystemIdentifier))
{
XmlFsType.SystemIdentifier = null;
}
}
else if (fakeBpb.oem_name != null)
{
if (fakeBpb.oem_name[5] != 0x49 ||
fakeBpb.oem_name[6] != 0x48 ||
fakeBpb.oem_name[7] != 0x43)
{
// Later versions of Windows create a DOS 3 BPB without OEM name on 8 sectors/track floppies
// OEM ID should be ASCII, otherwise ignore it
if (fakeBpb.oem_name[0] >= 0x20 &&
fakeBpb.oem_name[0] <= 0x7F &&
fakeBpb.oem_name[1] >= 0x20 &&
fakeBpb.oem_name[1] <= 0x7F &&
fakeBpb.oem_name[2] >= 0x20 &&
fakeBpb.oem_name[2] <= 0x7F &&
fakeBpb.oem_name[3] >= 0x20 &&
fakeBpb.oem_name[3] <= 0x7F &&
fakeBpb.oem_name[4] >= 0x20 &&
fakeBpb.oem_name[4] <= 0x7F &&
fakeBpb.oem_name[5] >= 0x20 &&
fakeBpb.oem_name[5] <= 0x7F &&
fakeBpb.oem_name[6] >= 0x20 &&
fakeBpb.oem_name[6] <= 0x7F &&
fakeBpb.oem_name[7] >= 0x20 &&
fakeBpb.oem_name[7] <= 0x7F)
{
XmlFsType.SystemIdentifier = StringHandlers.CToString(fakeBpb.oem_name);
}
else if (fakeBpb.oem_name[0] < 0x20 &&
fakeBpb.oem_name[1] >= 0x20 &&
fakeBpb.oem_name[1] <= 0x7F &&
fakeBpb.oem_name[2] >= 0x20 &&
fakeBpb.oem_name[2] <= 0x7F &&
fakeBpb.oem_name[3] >= 0x20 &&
fakeBpb.oem_name[3] <= 0x7F &&
fakeBpb.oem_name[4] >= 0x20 &&
fakeBpb.oem_name[4] <= 0x7F &&
fakeBpb.oem_name[5] >= 0x20 &&
fakeBpb.oem_name[5] <= 0x7F &&
fakeBpb.oem_name[6] >= 0x20 &&
fakeBpb.oem_name[6] <= 0x7F &&
fakeBpb.oem_name[7] >= 0x20 &&
fakeBpb.oem_name[7] <= 0x7F)
{
XmlFsType.SystemIdentifier = StringHandlers.CToString(fakeBpb.oem_name, Encoding, start: 1);
}
}
if (fakeBpb.signature == 0x28 ||
fakeBpb.signature == 0x29)
{
XmlFsType.VolumeSerial = $"{fakeBpb.serial_no:X8}";
_statfs.Id = new FileSystemId
{
IsInt = true,
Serial32 = fakeBpb.serial_no
};
}
}
XmlFsType.Clusters = clusters;
_sectorsPerCluster = fakeBpb.spc;
XmlFsType.ClusterSize = (uint)(fakeBpb.bps * fakeBpb.spc);
_reservedSectors = fakeBpb.rsectors;
_sectorsPerFat = fakeBpb.spfat;
if (fakeBpb.signature == 0x28 ||
fakeBpb.signature == 0x29 ||
andosOemCorrect)
{
if ((fakeBpb.flags & 0xF8) == 0x00)
{
if ((fakeBpb.flags & 0x01) == 0x01)
{
XmlFsType.Dirty = true;
}
}
if (fakeBpb.signature == 0x29 || andosOemCorrect)
{
XmlFsType.VolumeName = StringHandlers.SpacePaddedToString(fakeBpb.volume_label, Encoding);
XmlFsType.VolumeName = XmlFsType.VolumeName?.Replace("\0", "");
}
}
// Workaround that PCExchange jumps into "FAT16 "...
if (XmlFsType.SystemIdentifier == "PCX 2.0 ")
{
fakeBpb.jump[1] += 8;
}
// Check that jumps to a correct boot code position and has boot signature set.
// This will mean that the volume will boot, even if just to say "this is not bootable change disk"......
if (XmlFsType.Bootable == false &&
fakeBpb.jump != null)
{
XmlFsType.Bootable |=
(fakeBpb.jump[0] == 0xEB && fakeBpb.jump[1] >= minBootNearJump && fakeBpb.jump[1] < 0x80) ||
(fakeBpb.jump[0] == 0xE9 && fakeBpb.jump.Length >= 3 &&
BitConverter.ToUInt16(fakeBpb.jump, 1) >= minBootNearJump &&
BitConverter.ToUInt16(fakeBpb.jump, 1) <= 0x1FC);
}
// First root directory sector
firstRootSector =
((ulong)((fakeBpb.spfat * fakeBpb.fats_no) + fakeBpb.rsectors) * sectorsPerRealSector) +
partition.Start;
sectorsForRootDirectory = (uint)(fakeBpb.root_ent * 32 / imagePlugin.Info.SectorSize);
sectorsPerRealSector = fakeBpb.bps / imagePlugin.Info.SectorSize;
_sectorsPerCluster *= sectorsPerRealSector;
}
_firstClusterSector += partition.Start;
_image = imagePlugin;
if (_fat32)
{
_fatEntriesPerSector = imagePlugin.Info.SectorSize / 4;
}
else if (_fat16)
{
_fatEntriesPerSector = imagePlugin.Info.SectorSize / 2;
}
else
{
_fatEntriesPerSector = imagePlugin.Info.SectorSize * 2 / 3;
}
_fatFirstSector = partition.Start + (_reservedSectors * sectorsPerRealSector);
_rootDirectoryCache = new Dictionary <string, CompleteDirectoryEntry>();
byte[] rootDirectory;
if (!_fat32)
{
_firstClusterSector = firstRootSector + sectorsForRootDirectory - (_sectorsPerCluster * 2);
rootDirectory = imagePlugin.ReadSectors(firstRootSector, sectorsForRootDirectory);
if (bpbKind == BpbKind.DecRainbow)
{
var rootMs = new MemoryStream();
foreach (byte[] tmp in from ulong rootSector in new[]
{
0x17, 0x19, 0x1B, 0x1D, 0x1E, 0x20
} select imagePlugin.ReadSector(rootSector))
{
rootMs.Write(tmp, 0, tmp.Length);
}
rootDirectory = rootMs.ToArray();
}
}
else
{
if (rootDirectoryCluster == 0)
{
return(Errno.InvalidArgument);
}
var rootMs = new MemoryStream();
uint[] rootDirectoryClusters = GetClusters(rootDirectoryCluster);
foreach (byte[] buffer in rootDirectoryClusters.Select(cluster =>
imagePlugin.
ReadSectors(_firstClusterSector + (cluster * _sectorsPerCluster),
_sectorsPerCluster)))
{
rootMs.Write(buffer, 0, buffer.Length);
}
rootDirectory = rootMs.ToArray();
// OS/2 FAT32.IFS uses LFN instead of .LONGNAME
if (_namespace == Namespace.Os2)
{
_namespace = Namespace.Lfn;
}
}
if (rootDirectory is null)
{
return(Errno.InvalidArgument);
}
byte[] lastLfnName = null;
byte lastLfnChecksum = 0;
for (int i = 0; i < rootDirectory.Length; i += Marshal.SizeOf <DirectoryEntry>())
{
DirectoryEntry entry =
Marshal.ByteArrayToStructureLittleEndian <DirectoryEntry>(rootDirectory, i,
Marshal.SizeOf <DirectoryEntry>());
if (entry.filename[0] == DIRENT_FINISHED)
{
break;
}
if (entry.attributes.HasFlag(FatAttributes.LFN))
{
if (_namespace != Namespace.Lfn &&
_namespace != Namespace.Ecs)
{
continue;
}
LfnEntry lfnEntry =
Marshal.ByteArrayToStructureLittleEndian <LfnEntry>(rootDirectory, i,
Marshal.SizeOf <LfnEntry>());
int lfnSequence = lfnEntry.sequence & LFN_MASK;
if ((lfnEntry.sequence & LFN_ERASED) > 0)
{
continue;
}
if ((lfnEntry.sequence & LFN_LAST) > 0)
{
lastLfnName = new byte[lfnSequence * 26];
lastLfnChecksum = lfnEntry.checksum;
}
if (lastLfnName is null)
{
continue;
}
if (lfnEntry.checksum != lastLfnChecksum)
{
continue;
}
lfnSequence--;
Array.Copy(lfnEntry.name1, 0, lastLfnName, lfnSequence * 26, 10);
Array.Copy(lfnEntry.name2, 0, lastLfnName, (lfnSequence * 26) + 10, 12);
Array.Copy(lfnEntry.name3, 0, lastLfnName, (lfnSequence * 26) + 22, 4);
continue;
}
// Not a correct entry
if (entry.filename[0] < DIRENT_MIN &&
entry.filename[0] != DIRENT_E5)
{
continue;
}
// Self
if (Encoding.GetString(entry.filename).TrimEnd() == ".")
{
continue;
}
// Parent
if (Encoding.GetString(entry.filename).TrimEnd() == "..")
{
continue;
}
// Deleted
if (entry.filename[0] == DIRENT_DELETED)
{
continue;
}
string filename;
if (entry.attributes.HasFlag(FatAttributes.VolumeLabel))
{
byte[] fullname = new byte[11];
Array.Copy(entry.filename, 0, fullname, 0, 8);
Array.Copy(entry.extension, 0, fullname, 8, 3);
string volname = Encoding.GetString(fullname).Trim();
if (!string.IsNullOrEmpty(volname))
{
XmlFsType.VolumeName =
entry.caseinfo.HasFlag(CaseInfo.AllLowerCase) && _namespace == Namespace.Nt
? volname.ToLower() : volname;
}
XmlFsType.VolumeName = XmlFsType.VolumeName?.Replace("\0", "");
if (entry.ctime > 0 &&
entry.cdate > 0)
{
XmlFsType.CreationDate = DateHandlers.DosToDateTime(entry.cdate, entry.ctime);
if (entry.ctime_ms > 0)
{
XmlFsType.CreationDate = XmlFsType.CreationDate.AddMilliseconds(entry.ctime_ms * 10);
}
XmlFsType.CreationDateSpecified = true;
}
if (entry.mtime > 0 &&
entry.mdate > 0)
{
XmlFsType.ModificationDate = DateHandlers.DosToDateTime(entry.mdate, entry.mtime);
XmlFsType.ModificationDateSpecified = true;
}
continue;
}
var completeEntry = new CompleteDirectoryEntry
{
Dirent = entry
};
if ((_namespace == Namespace.Lfn || _namespace == Namespace.Ecs) &&
lastLfnName != null)
{
byte calculatedLfnChecksum = LfnChecksum(entry.filename, entry.extension);
if (calculatedLfnChecksum == lastLfnChecksum)
{
filename = StringHandlers.CToString(lastLfnName, Encoding.Unicode, true);
completeEntry.Lfn = filename;
lastLfnName = null;
lastLfnChecksum = 0;
}
}
if (entry.filename[0] == DIRENT_E5)
{
entry.filename[0] = DIRENT_DELETED;
}
string name = Encoding.GetString(entry.filename).TrimEnd();
string extension = Encoding.GetString(entry.extension).TrimEnd();
if (_namespace == Namespace.Nt)
{
if (entry.caseinfo.HasFlag(CaseInfo.LowerCaseExtension))
{
extension = extension.ToLower(CultureInfo.CurrentCulture);
}
if (entry.caseinfo.HasFlag(CaseInfo.LowerCaseBasename))
{
name = name.ToLower(CultureInfo.CurrentCulture);
}
}
if (extension != "")
{
filename = name + "." + extension;
}
else
{
filename = name;
}
if (name == "" &&
extension == "")
{
AaruConsole.DebugWriteLine("FAT filesystem", "Found empty filename in root directory");
if (!_debug ||
(entry.size > 0 && entry.start_cluster == 0))
{
continue; // Skip invalid name
}
// If debug, add it
name = ":{EMPTYNAME}:";
// Try to create a unique filename with an extension from 000 to 999
for (int uniq = 0; uniq < 1000; uniq++)
{
extension = $"{uniq:D03}";
if (!_rootDirectoryCache.ContainsKey($"{name}.{extension}"))
{
break;
}
}
// If we couldn't find it, just skip over
if (_rootDirectoryCache.ContainsKey($"{name}.{extension}"))
{
continue;
}
}
// Atari ST allows slash AND colon so cannot simply substitute one for the other like in Mac filesystems
filename = filename.Replace('/', '\u2215');
completeEntry.Shortname = filename;
if (_namespace == Namespace.Human)
{
HumanDirectoryEntry humanEntry =
Marshal.ByteArrayToStructureLittleEndian <HumanDirectoryEntry>(rootDirectory, i,
Marshal.SizeOf <HumanDirectoryEntry>());
completeEntry.HumanDirent = humanEntry;
name = StringHandlers.CToString(humanEntry.name1, Encoding).TrimEnd();
extension = StringHandlers.CToString(humanEntry.extension, Encoding).TrimEnd();
string name2 = StringHandlers.CToString(humanEntry.name2, Encoding).TrimEnd();
if (extension != "")
{
filename = name + name2 + "." + extension;
}
else
{
filename = name + name2;
}
completeEntry.HumanName = filename;
}
if (!_fat32 &&
filename == "EA DATA. SF")
{
_eaDirEntry = entry;
lastLfnName = null;
lastLfnChecksum = 0;
if (_debug)
{
_rootDirectoryCache[completeEntry.ToString()] = completeEntry;
}
continue;
}
_rootDirectoryCache[completeEntry.ToString()] = completeEntry;
lastLfnName = null;
lastLfnChecksum = 0;
}
XmlFsType.VolumeName = XmlFsType.VolumeName?.Trim();
_statfs.Blocks = XmlFsType.Clusters;
switch (bpbKind)
{
case BpbKind.Hardcoded:
_statfs.Type = $"Microsoft FAT{(_fat16 ? "16" : "12")}";
break;
case BpbKind.Atari:
_statfs.Type = $"Atari FAT{(_fat16 ? "16" : "12")}";
break;
case BpbKind.Msx:
_statfs.Type = $"MSX FAT{(_fat16 ? "16" : "12")}";
break;
case BpbKind.Dos2:
case BpbKind.Dos3:
case BpbKind.Dos32:
case BpbKind.Dos33:
case BpbKind.ShortExtended:
case BpbKind.Extended:
_statfs.Type = $"Microsoft FAT{(_fat16 ? "16" : "12")}";
break;
case BpbKind.ShortFat32:
case BpbKind.LongFat32:
_statfs.Type = XmlFsType.Type == "FAT+" ? "FAT+" : "Microsoft FAT32";
break;
case BpbKind.Andos:
_statfs.Type = $"ANDOS FAT{(_fat16 ? "16" : "12")}";
break;
case BpbKind.Apricot:
_statfs.Type = $"Apricot FAT{(_fat16 ? "16" : "12")}";
break;
case BpbKind.DecRainbow:
_statfs.Type = $"DEC FAT{(_fat16 ? "16" : "12")}";
break;
case BpbKind.Human:
_statfs.Type = $"Human68k FAT{(_fat16 ? "16" : "12")}";
break;
default: throw new ArgumentOutOfRangeException();
}
_bytesPerCluster = _sectorsPerCluster * imagePlugin.Info.SectorSize;
ushort[] _firstFatEntries = new ushort[_statfs.Blocks];
ushort[] _secondFatEntries = new ushort[_statfs.Blocks];
bool _firstFatValid = true;
bool _secondFatValid = true;
if (_fat12)
{
AaruConsole.DebugWriteLine("FAT plugin", "Reading FAT12");
byte[] fatBytes = imagePlugin.ReadSectors(_fatFirstSector, _sectorsPerFat);
int pos = 0;
for (int i = 0; i + 3 < fatBytes.Length && pos < _firstFatEntries.Length; i += 3)
{
_firstFatEntries[pos++] = (ushort)(((fatBytes[i + 1] & 0xF) << 8) + fatBytes[i + 0]);
if (pos >= _firstFatEntries.Length)
{
break;
}
_firstFatEntries[pos++] = (ushort)(((fatBytes[i + 1] & 0xF0) >> 4) + (fatBytes[i + 2] << 4));
}
fatBytes = imagePlugin.ReadSectors(_fatFirstSector + _sectorsPerFat, _sectorsPerFat);
_fatEntries = new ushort[_statfs.Blocks];
pos = 0;
for (int i = 0; i + 3 < fatBytes.Length && pos < _secondFatEntries.Length; i += 3)
{
_secondFatEntries[pos++] = (ushort)(((fatBytes[i + 1] & 0xF) << 8) + fatBytes[i + 0]);
if (pos >= _secondFatEntries.Length)
{
break;
}
_secondFatEntries[pos++] = (ushort)(((fatBytes[i + 1] & 0xF0) >> 4) + (fatBytes[i + 2] << 4));
}
foreach (ushort entry in _firstFatEntries)
{
if (entry >= FAT12_RESERVED ||
entry <= _statfs.Blocks)
{
continue;
}
_firstFatValid = false;
break;
}
foreach (ushort entry in _secondFatEntries)
{
if (entry >= FAT12_RESERVED ||
entry <= _statfs.Blocks)
{
continue;
}
_secondFatValid = false;
break;
}
if (_firstFatValid == _secondFatValid)
{
_fatEntries = _useFirstFat ? _firstFatEntries : _secondFatEntries;
}
else if (_firstFatValid)
{
_fatEntries = _firstFatEntries;
}
else
{
_fatEntries = _secondFatEntries;
}
}
else if (_fat16)
{
AaruConsole.DebugWriteLine("FAT plugin", "Reading FAT16");
byte[] fatBytes = imagePlugin.ReadSectors(_fatFirstSector, _sectorsPerFat);
AaruConsole.DebugWriteLine("FAT plugin", "Casting FAT");
_firstFatEntries = MemoryMarshal.Cast <byte, ushort>(fatBytes).ToArray();
fatBytes = imagePlugin.ReadSectors(_fatFirstSector + _sectorsPerFat, _sectorsPerFat);
AaruConsole.DebugWriteLine("FAT plugin", "Casting FAT");
_secondFatEntries = MemoryMarshal.Cast <byte, ushort>(fatBytes).ToArray();
foreach (ushort entry in _firstFatEntries)
{
if (entry >= FAT16_RESERVED ||
entry <= _statfs.Blocks)
{
continue;
}
_firstFatValid = false;
break;
}
foreach (ushort entry in _secondFatEntries)
{
if (entry >= FAT16_RESERVED ||
entry <= _statfs.Blocks)
{
continue;
}
_secondFatValid = false;
break;
}
if (_firstFatValid == _secondFatValid)
{
_fatEntries = _useFirstFat ? _firstFatEntries : _secondFatEntries;
}
else if (_firstFatValid)
{
_fatEntries = _firstFatEntries;
}
else
{
_fatEntries = _secondFatEntries;
}
}
// TODO: Check how this affects international filenames
_cultureInfo = new CultureInfo("en-US", false);
_directoryCache = new Dictionary <string, Dictionary <string, CompleteDirectoryEntry> >();
// Check it is really an OS/2 EA file
if (_eaDirEntry.start_cluster != 0)
{
CacheEaData();
ushort eamagic = BitConverter.ToUInt16(_cachedEaData, 0);
if (eamagic != EADATA_MAGIC)
{
_eaDirEntry = new DirectoryEntry();
_cachedEaData = null;
}
else
{
_eaCache = new Dictionary <string, Dictionary <string, byte[]> >();
}
}
else if (_fat32)
{
_eaCache = new Dictionary <string, Dictionary <string, byte[]> >();
}
// Check OS/2 .LONGNAME
if (_eaCache != null &&
(_namespace == Namespace.Os2 || _namespace == Namespace.Ecs) &&
!_fat32)
{
List <KeyValuePair <string, CompleteDirectoryEntry> > rootFilesWithEas =
_rootDirectoryCache.Where(t => t.Value.Dirent.ea_handle != 0).ToList();
foreach (KeyValuePair <string, CompleteDirectoryEntry> fileWithEa in rootFilesWithEas)
{
Dictionary <string, byte[]> eas = GetEas(fileWithEa.Value.Dirent.ea_handle);
if (eas is null)
{
continue;
}
if (!eas.TryGetValue("com.microsoft.os2.longname", out byte[] longnameEa))
/// <summary>
/// Mounts an Apple Lisa filesystem
/// </summary>
public Errno Mount(IMediaImage imagePlugin, Partition partition, Encoding encoding,
Dictionary <string, string> options, string @namespace)
{
XmlFsType = new FileSystemType();
if (options == null)
{
options = GetDefaultOptions();
}
if (options.TryGetValue("debug", out string debugString))
{
bool.TryParse(debugString, out debug);
}
// Default namespace
if (@namespace is null)
{
@namespace = "ecs";
}
switch (@namespace.ToLowerInvariant())
{
case "dos":
this.@namespace = Namespace.Dos;
break;
case "nt":
this.@namespace = Namespace.Nt;
break;
case "os2":
this.@namespace = Namespace.Os2;
break;
case "ecs":
this.@namespace = Namespace.Ecs;
break;
case "lfn":
this.@namespace = Namespace.Lfn;
break;
case "human":
this.@namespace = Namespace.Human;
break;
default: return(Errno.InvalidArgument);
}
DicConsole.DebugWriteLine("FAT plugin", "Reading BPB");
uint sectorsPerBpb = imagePlugin.Info.SectorSize < 512 ? 512 / imagePlugin.Info.SectorSize : 1;
byte[] bpbSector = imagePlugin.ReadSectors(0 + partition.Start, sectorsPerBpb);
BpbKind bpbKind = DetectBpbKind(bpbSector, imagePlugin, partition,
out BiosParameterBlockEbpb fakeBpb,
out HumanParameterBlock humanBpb, out AtariParameterBlock atariBpb,
out byte minBootNearJump, out bool andosOemCorrect,
out bool bootable);
fat12 = false;
fat16 = false;
fat32 = false;
useFirstFat = true;
XmlFsType.Bootable = bootable;
statfs = new FileSystemInfo
{
Blocks = XmlFsType.Clusters,
FilenameLength = 11,
Files = 0, // Requires traversing all directories
FreeFiles = 0,
PluginId = Id,
FreeBlocks = 0 // Requires traversing the FAT
};
// This is needed because for FAT16, GEMDOS increases bytes per sector count instead of using big_sectors field.
uint sectorsPerRealSector = 1;
// This is needed because some OSes don't put volume label as first entry in the root directory
uint sectorsForRootDirectory = 0;
uint rootDirectoryCluster = 0;
switch (bpbKind)
{
case BpbKind.DecRainbow:
case BpbKind.Hardcoded:
case BpbKind.Msx:
case BpbKind.Apricot:
fat12 = true;
break;
case BpbKind.ShortFat32:
case BpbKind.LongFat32:
{
fat32 = true;
Fat32ParameterBlock fat32Bpb =
Marshal.ByteArrayToStructureLittleEndian <Fat32ParameterBlock>(bpbSector);
Fat32ParameterBlockShort shortFat32Bpb =
Marshal.ByteArrayToStructureLittleEndian <Fat32ParameterBlockShort>(bpbSector);
rootDirectoryCluster = fat32Bpb.root_cluster;
// This is to support FAT partitions on hybrid ISO/USB images
if (imagePlugin.Info.XmlMediaType == XmlMediaType.OpticalDisc)
{
fat32Bpb.bps *= 4;
fat32Bpb.spc /= 4;
fat32Bpb.big_spfat /= 4;
fat32Bpb.hsectors /= 4;
fat32Bpb.sptrk /= 4;
}
XmlFsType.Type = fat32Bpb.version != 0 ? "FAT+" : "FAT32";
if (fat32Bpb.oem_name != null && (fat32Bpb.oem_name[5] != 0x49 || fat32Bpb.oem_name[6] != 0x48 ||
fat32Bpb.oem_name[7] != 0x43))
{
XmlFsType.SystemIdentifier = StringHandlers.CToString(fat32Bpb.oem_name);
}
sectorsPerCluster = fat32Bpb.spc;
XmlFsType.ClusterSize = (uint)(fat32Bpb.bps * fat32Bpb.spc);
reservedSectors = fat32Bpb.rsectors;
if (fat32Bpb.big_sectors == 0 && fat32Bpb.signature == 0x28)
{
XmlFsType.Clusters = shortFat32Bpb.huge_sectors / shortFat32Bpb.spc;
}
else
{
XmlFsType.Clusters = fat32Bpb.big_sectors / fat32Bpb.spc;
}
sectorsPerFat = fat32Bpb.big_spfat;
XmlFsType.VolumeSerial = $"{fat32Bpb.serial_no:X8}";
statfs.Id = new FileSystemId {
IsInt = true, Serial32 = fat32Bpb.serial_no
};
if ((fat32Bpb.flags & 0xF8) == 0x00)
{
if ((fat32Bpb.flags & 0x01) == 0x01)
{
XmlFsType.Dirty = true;
}
}
if ((fat32Bpb.mirror_flags & 0x80) == 0x80)
{
useFirstFat = (fat32Bpb.mirror_flags & 0xF) != 1;
}
if (fat32Bpb.signature == 0x29)
{
XmlFsType.VolumeName = Encoding.ASCII.GetString(fat32Bpb.volume_label);
}
// Check that jumps to a correct boot code position and has boot signature set.
// This will mean that the volume will boot, even if just to say "this is not bootable change disk"......
XmlFsType.Bootable =
fat32Bpb.jump[0] == 0xEB && fat32Bpb.jump[1] >= minBootNearJump && fat32Bpb.jump[1] < 0x80 ||
fat32Bpb.jump[0] == 0xE9 && fat32Bpb.jump.Length >= 3 &&
BitConverter.ToUInt16(fat32Bpb.jump, 1) >= minBootNearJump &&
BitConverter.ToUInt16(fat32Bpb.jump, 1) <= 0x1FC;
sectorsPerRealSector = fat32Bpb.bps / imagePlugin.Info.SectorSize;
sectorsPerCluster *= sectorsPerRealSector;
// First root directory sector
firstClusterSector =
(ulong)(fat32Bpb.big_spfat * fat32Bpb.fats_no + fat32Bpb.rsectors) * sectorsPerRealSector -
2 * sectorsPerCluster;
if (fat32Bpb.fsinfo_sector + partition.Start <= partition.End)
{
byte[] fsinfoSector = imagePlugin.ReadSector(fat32Bpb.fsinfo_sector + partition.Start);
FsInfoSector fsInfo =
Marshal.ByteArrayToStructureLittleEndian <FsInfoSector>(fsinfoSector);
if (fsInfo.signature1 == FSINFO_SIGNATURE1 && fsInfo.signature2 == FSINFO_SIGNATURE2 &&
fsInfo.signature3 == FSINFO_SIGNATURE3)
{
if (fsInfo.free_clusters < 0xFFFFFFFF)
{
XmlFsType.FreeClusters = fsInfo.free_clusters;
XmlFsType.FreeClustersSpecified = true;
}
}
}
break;
}
// Some fields could overflow fake BPB, those will be handled below
case BpbKind.Atari:
{
ushort sum = 0;
for (int i = 0; i < bpbSector.Length; i += 2)
{
sum += BigEndianBitConverter.ToUInt16(bpbSector, i);
}
// TODO: Check this
if (sum == 0x1234)
{
XmlFsType.Bootable = true;
}
break;
}
case BpbKind.Human:
// If not debug set Human68k namespace and ShiftJIS codepage as defaults
if (!debug)
{
this.@namespace = Namespace.Human;
encoding = Encoding.GetEncoding("shift_jis");
}
XmlFsType.Bootable = true;
break;
}
Encoding = encoding ?? (bpbKind == BpbKind.Human
? Encoding.GetEncoding("shift_jis")
: Encoding.GetEncoding("IBM437"));
ulong firstRootSector = 0;
if (!fat32)
{
// This is to support FAT partitions on hybrid ISO/USB images
if (imagePlugin.Info.XmlMediaType == XmlMediaType.OpticalDisc)
{
fakeBpb.bps *= 4;
fakeBpb.spc /= 4;
fakeBpb.spfat /= 4;
fakeBpb.hsectors /= 4;
fakeBpb.sptrk /= 4;
fakeBpb.rsectors /= 4;
if (fakeBpb.spc == 0)
{
fakeBpb.spc = 1;
}
}
// This assumes no sane implementation will violate cluster size rules
// However nothing prevents this to happen
// If first file on disk uses only one cluster there is absolutely no way to differentiate between FAT12 and FAT16,
// so let's hope implementations use common sense?
if (!fat12 && !fat16)
{
ulong clusters;
if (fakeBpb.sectors == 0)
{
clusters = fakeBpb.spc == 0 ? fakeBpb.big_sectors : fakeBpb.big_sectors / fakeBpb.spc;
}
else
{
clusters = fakeBpb.spc == 0 ? fakeBpb.sectors : (ulong)fakeBpb.sectors / fakeBpb.spc;
}
if (clusters < 4089)
{
fat12 = true;
}
else
{
fat16 = true;
}
}
if (fat12)
{
XmlFsType.Type = "FAT12";
}
else if (fat16)
{
XmlFsType.Type = "FAT16";
}
if (bpbKind == BpbKind.Atari)
{
if (atariBpb.serial_no[0] != 0x49 || atariBpb.serial_no[1] != 0x48 || atariBpb.serial_no[2] != 0x43)
{
XmlFsType.VolumeSerial =
$"{atariBpb.serial_no[0]:X2}{atariBpb.serial_no[1]:X2}{atariBpb.serial_no[2]:X2}";
statfs.Id = new FileSystemId
{
IsInt = true,
Serial32 = (uint)((atariBpb.serial_no[0] << 16) + (atariBpb.serial_no[1] << 8) +
atariBpb.serial_no[2])
};
}
XmlFsType.SystemIdentifier = StringHandlers.CToString(atariBpb.oem_name);
if (string.IsNullOrEmpty(XmlFsType.SystemIdentifier))
{
XmlFsType.SystemIdentifier = null;
}
}
else if (fakeBpb.oem_name != null)
{
if (fakeBpb.oem_name[5] != 0x49 || fakeBpb.oem_name[6] != 0x48 || fakeBpb.oem_name[7] != 0x43)
{
// Later versions of Windows create a DOS 3 BPB without OEM name on 8 sectors/track floppies
// OEM ID should be ASCII, otherwise ignore it
if (fakeBpb.oem_name[0] >= 0x20 && fakeBpb.oem_name[0] <= 0x7F && fakeBpb.oem_name[1] >= 0x20 &&
fakeBpb.oem_name[1] <= 0x7F && fakeBpb.oem_name[2] >= 0x20 && fakeBpb.oem_name[2] <= 0x7F &&
fakeBpb.oem_name[3] >= 0x20 && fakeBpb.oem_name[3] <= 0x7F && fakeBpb.oem_name[4] >= 0x20 &&
fakeBpb.oem_name[4] <= 0x7F && fakeBpb.oem_name[5] >= 0x20 && fakeBpb.oem_name[5] <= 0x7F &&
fakeBpb.oem_name[6] >= 0x20 && fakeBpb.oem_name[6] <= 0x7F && fakeBpb.oem_name[7] >= 0x20 &&
fakeBpb.oem_name[7] <= 0x7F)
{
XmlFsType.SystemIdentifier = StringHandlers.CToString(fakeBpb.oem_name);
}
else if (fakeBpb.oem_name[0] < 0x20 && fakeBpb.oem_name[1] >= 0x20 &&
fakeBpb.oem_name[1] <= 0x7F && fakeBpb.oem_name[2] >= 0x20 &&
fakeBpb.oem_name[2] <= 0x7F && fakeBpb.oem_name[3] >= 0x20 &&
fakeBpb.oem_name[3] <= 0x7F && fakeBpb.oem_name[4] >= 0x20 &&
fakeBpb.oem_name[4] <= 0x7F && fakeBpb.oem_name[5] >= 0x20 &&
fakeBpb.oem_name[5] <= 0x7F && fakeBpb.oem_name[6] >= 0x20 &&
fakeBpb.oem_name[6] <= 0x7F && fakeBpb.oem_name[7] >= 0x20 &&
fakeBpb.oem_name[7] <= 0x7F)
{
XmlFsType.SystemIdentifier = StringHandlers.CToString(fakeBpb.oem_name, Encoding, start: 1);
}
}
if (fakeBpb.signature == 0x28 || fakeBpb.signature == 0x29)
{
XmlFsType.VolumeSerial = $"{fakeBpb.serial_no:X8}";
statfs.Id = new FileSystemId {
IsInt = true, Serial32 = fakeBpb.serial_no
};
}
}
if (bpbKind != BpbKind.Human)
{
if (fakeBpb.sectors == 0)
{
XmlFsType.Clusters = fakeBpb.spc == 0 ? fakeBpb.big_sectors : fakeBpb.big_sectors / fakeBpb.spc;
}
else
{
XmlFsType.Clusters =
(ulong)(fakeBpb.spc == 0 ? fakeBpb.sectors : fakeBpb.sectors / fakeBpb.spc);
}
}
else
{
XmlFsType.Clusters = humanBpb.clusters == 0 ? humanBpb.big_clusters : humanBpb.clusters;
}
sectorsPerCluster = fakeBpb.spc;
XmlFsType.ClusterSize = (uint)(fakeBpb.bps * fakeBpb.spc);
reservedSectors = fakeBpb.rsectors;
sectorsPerFat = fakeBpb.spfat;
if (fakeBpb.signature == 0x28 || fakeBpb.signature == 0x29 || andosOemCorrect)
{
if ((fakeBpb.flags & 0xF8) == 0x00)
{
if ((fakeBpb.flags & 0x01) == 0x01)
{
XmlFsType.Dirty = true;
}
}
if (fakeBpb.signature == 0x29 || andosOemCorrect)
{
XmlFsType.VolumeName = Encoding.ASCII.GetString(fakeBpb.volume_label);
}
}
// Workaround that PCExchange jumps into "FAT16 "...
if (XmlFsType.SystemIdentifier == "PCX 2.0 ")
{
fakeBpb.jump[1] += 8;
}
// Check that jumps to a correct boot code position and has boot signature set.
// This will mean that the volume will boot, even if just to say "this is not bootable change disk"......
if (XmlFsType.Bootable == false && fakeBpb.jump != null)
{
XmlFsType.Bootable |=
fakeBpb.jump[0] == 0xEB && fakeBpb.jump[1] >= minBootNearJump && fakeBpb.jump[1] < 0x80 ||
fakeBpb.jump[0] == 0xE9 && fakeBpb.jump.Length >= 3 &&
BitConverter.ToUInt16(fakeBpb.jump, 1) >= minBootNearJump &&
BitConverter.ToUInt16(fakeBpb.jump, 1) <= 0x1FC;
}
// First root directory sector
firstRootSector = (ulong)(fakeBpb.spfat * fakeBpb.fats_no + fakeBpb.rsectors) * sectorsPerRealSector +
partition.Start;
sectorsForRootDirectory = (uint)(fakeBpb.root_ent * 32 / imagePlugin.Info.SectorSize);
sectorsPerRealSector = fakeBpb.bps / imagePlugin.Info.SectorSize;
sectorsPerCluster *= sectorsPerRealSector;
}
firstClusterSector += partition.Start;
image = imagePlugin;
if (fat32)
{
fatEntriesPerSector = imagePlugin.Info.SectorSize / 4;
}
else if (fat16)
{
fatEntriesPerSector = imagePlugin.Info.SectorSize / 2;
}
else
{
fatEntriesPerSector = imagePlugin.Info.SectorSize * 2 / 3;
}
fatFirstSector = partition.Start + reservedSectors * sectorsPerRealSector;
rootDirectoryCache = new Dictionary <string, CompleteDirectoryEntry>();
byte[] rootDirectory = null;
if (!fat32)
{
firstClusterSector = firstRootSector + sectorsForRootDirectory - sectorsPerCluster * 2;
rootDirectory = imagePlugin.ReadSectors(firstRootSector, sectorsForRootDirectory);
if (bpbKind == BpbKind.DecRainbow)
{
MemoryStream rootMs = new MemoryStream();
foreach (byte[] tmp in from ulong rootSector in new[] { 0x17, 0x19, 0x1B, 0x1D, 0x1E, 0x20 }
select imagePlugin.ReadSector(rootSector))
{
rootMs.Write(tmp, 0, tmp.Length);
}
rootDirectory = rootMs.ToArray();
}
}
else
{
if (rootDirectoryCluster == 0)
{
return(Errno.InvalidArgument);
}
MemoryStream rootMs = new MemoryStream();
uint[] rootDirectoryClusters = GetClusters(rootDirectoryCluster);
foreach (uint cluster in rootDirectoryClusters)
{
byte[] buffer =
imagePlugin.ReadSectors(firstClusterSector + cluster * sectorsPerCluster, sectorsPerCluster);
rootMs.Write(buffer, 0, buffer.Length);
}
rootDirectory = rootMs.ToArray();
// OS/2 FAT32.IFS uses LFN instead of .LONGNAME
if (this.@namespace == Namespace.Os2)
{
this.@namespace = Namespace.Os2;
}
}
if (rootDirectory is null)
{
return(Errno.InvalidArgument);
}
byte[] lastLfnName = null;
byte lastLfnChecksum = 0;
for (int i = 0; i < rootDirectory.Length; i += Marshal.SizeOf <DirectoryEntry>())
{
DirectoryEntry entry =
Marshal.ByteArrayToStructureLittleEndian <DirectoryEntry>(rootDirectory, i,
Marshal.SizeOf <DirectoryEntry>());
if (entry.filename[0] == DIRENT_FINISHED)
{
break;
}
if (entry.attributes.HasFlag(FatAttributes.LFN))
{
if (this.@namespace != Namespace.Lfn && this.@namespace != Namespace.Ecs)
{
continue;
}
LfnEntry lfnEntry =
Marshal.ByteArrayToStructureLittleEndian <LfnEntry>(rootDirectory, i,
Marshal.SizeOf <LfnEntry>());
int lfnSequence = lfnEntry.sequence & LFN_MASK;
if ((lfnEntry.sequence & LFN_ERASED) > 0)
{
continue;
}
if ((lfnEntry.sequence & LFN_LAST) > 0)
{
lastLfnName = new byte[lfnSequence * 26];
lastLfnChecksum = lfnEntry.checksum;
}
if (lastLfnName is null)
{
continue;
}
if (lfnEntry.checksum != lastLfnChecksum)
{
continue;
}
lfnSequence--;
Array.Copy(lfnEntry.name1, 0, lastLfnName, lfnSequence * 26, 10);
Array.Copy(lfnEntry.name2, 0, lastLfnName, lfnSequence * 26 + 10, 12);
Array.Copy(lfnEntry.name3, 0, lastLfnName, lfnSequence * 26 + 22, 4);
continue;
}
// Not a correct entry
if (entry.filename[0] < DIRENT_MIN && entry.filename[0] != DIRENT_E5)
{
continue;
}
// Self
if (Encoding.GetString(entry.filename).TrimEnd() == ".")
{
continue;
}
// Parent
if (Encoding.GetString(entry.filename).TrimEnd() == "..")
{
continue;
}
// Deleted
if (entry.filename[0] == DIRENT_DELETED)
{
continue;
}
string filename;
if (entry.attributes.HasFlag(FatAttributes.VolumeLabel))
{
byte[] fullname = new byte[11];
Array.Copy(entry.filename, 0, fullname, 0, 8);
Array.Copy(entry.extension, 0, fullname, 8, 3);
string volname = Encoding.GetString(fullname).Trim();
if (!string.IsNullOrEmpty(volname))
{
XmlFsType.VolumeName =
entry.caseinfo.HasFlag(CaseInfo.AllLowerCase) && this.@namespace == Namespace.Nt
? volname.ToLower()
: volname;
}
if (entry.ctime > 0 && entry.cdate > 0)
{
XmlFsType.CreationDate = DateHandlers.DosToDateTime(entry.cdate, entry.ctime);
if (entry.ctime_ms > 0)
{
XmlFsType.CreationDate = XmlFsType.CreationDate.AddMilliseconds(entry.ctime_ms * 10);
}
XmlFsType.CreationDateSpecified = true;
}
if (entry.mtime > 0 && entry.mdate > 0)
{
XmlFsType.ModificationDate = DateHandlers.DosToDateTime(entry.mdate, entry.mtime);
XmlFsType.ModificationDateSpecified = true;
}
continue;
}
CompleteDirectoryEntry completeEntry = new CompleteDirectoryEntry {
Dirent = entry
};
if ((this.@namespace == Namespace.Lfn || this.@namespace == Namespace.Ecs) && lastLfnName != null)
{
byte calculatedLfnChecksum = LfnChecksum(entry.filename, entry.extension);
if (calculatedLfnChecksum == lastLfnChecksum)
{
filename = StringHandlers.CToString(lastLfnName, Encoding.Unicode, true);
completeEntry.Lfn = filename;
lastLfnName = null;
lastLfnChecksum = 0;
}
}
if (entry.filename[0] == DIRENT_E5)
{
entry.filename[0] = DIRENT_DELETED;
}
string name = Encoding.GetString(entry.filename).TrimEnd();
string extension = Encoding.GetString(entry.extension).TrimEnd();
if (this.@namespace == Namespace.Nt)
{
if (entry.caseinfo.HasFlag(CaseInfo.LowerCaseExtension))
{
extension = extension.ToLower(CultureInfo.CurrentCulture);
}
if (entry.caseinfo.HasFlag(CaseInfo.LowerCaseBasename))
{
name = name.ToLower(CultureInfo.CurrentCulture);
}
}
if (extension != "")
{
filename = name + "." + extension;
}
else
{
filename = name;
}
completeEntry.Shortname = filename;
if (this.@namespace == Namespace.Human)
{
HumanDirectoryEntry humanEntry =
Marshal.ByteArrayToStructureLittleEndian <HumanDirectoryEntry>(rootDirectory, i,
Marshal
.SizeOf <HumanDirectoryEntry
>());
completeEntry.HumanDirent = humanEntry;
name = StringHandlers.CToString(humanEntry.name1, Encoding).TrimEnd();
extension = StringHandlers.CToString(humanEntry.extension, Encoding).TrimEnd();
string name2 = StringHandlers.CToString(humanEntry.name2, Encoding).TrimEnd();
if (extension != "")
{
filename = name + name2 + "." + extension;
}
else
{
filename = name + name2;
}
completeEntry.HumanName = filename;
}
if (!fat32 && filename == "EA DATA. SF")
{
eaDirEntry = entry;
lastLfnName = null;
lastLfnChecksum = 0;
if (debug)
{
rootDirectoryCache[completeEntry.ToString()] = completeEntry;
}
continue;
}
rootDirectoryCache[completeEntry.ToString()] = completeEntry;
lastLfnName = null;
lastLfnChecksum = 0;
}
XmlFsType.VolumeName = XmlFsType.VolumeName?.Trim();
statfs.Blocks = XmlFsType.Clusters;
switch (bpbKind)
{
case BpbKind.Hardcoded:
statfs.Type = $"Microsoft FAT{(fat16 ? "16" : "12")}";
break;
case BpbKind.Atari:
statfs.Type = $"Atari FAT{(fat16 ? "16" : "12")}";
break;
case BpbKind.Msx:
statfs.Type = $"MSX FAT{(fat16 ? "16" : "12")}";
break;
case BpbKind.Dos2:
case BpbKind.Dos3:
case BpbKind.Dos32:
case BpbKind.Dos33:
case BpbKind.ShortExtended:
case BpbKind.Extended:
statfs.Type = $"Microsoft FAT{(fat16 ? "16" : "12")}";
break;
case BpbKind.ShortFat32:
case BpbKind.LongFat32:
statfs.Type = XmlFsType.Type == "FAT+" ? "FAT+" : "Microsoft FAT32";
break;
case BpbKind.Andos:
statfs.Type = $"ANDOS FAT{(fat16 ? "16" : "12")}";
break;
case BpbKind.Apricot:
statfs.Type = $"Apricot FAT{(fat16 ? "16" : "12")}";
break;
case BpbKind.DecRainbow:
statfs.Type = $"DEC FAT{(fat16 ? "16" : "12")}";
break;
case BpbKind.Human:
statfs.Type = $"Human68k FAT{(fat16 ? "16" : "12")}";
break;
default: throw new ArgumentOutOfRangeException();
}
bytesPerCluster = sectorsPerCluster * imagePlugin.Info.SectorSize;
if (fat12)
{
byte[] fatBytes =
imagePlugin.ReadSectors(fatFirstSector + (useFirstFat ? 0 : sectorsPerFat), sectorsPerFat);
fatEntries = new ushort[statfs.Blocks];
int pos = 0;
for (int i = 0; i + 3 < fatBytes.Length && pos < fatEntries.Length; i += 3)
{
fatEntries[pos++] = (ushort)(((fatBytes[i + 1] & 0xF) << 8) + fatBytes[i + 0]);
fatEntries[pos++] = (ushort)(((fatBytes[i + 1] & 0xF0) >> 4) + (fatBytes[i + 2] << 4));
}
}
else if (fat16)
{
DicConsole.DebugWriteLine("FAT plugin", "Reading FAT16");
byte[] fatBytes =
imagePlugin.ReadSectors(fatFirstSector + (useFirstFat ? 0 : sectorsPerFat), sectorsPerFat);
DicConsole.DebugWriteLine("FAT plugin", "Casting FAT");
fatEntries = MemoryMarshal.Cast <byte, ushort>(fatBytes).ToArray();
}
// TODO: Check how this affects international filenames
cultureInfo = new CultureInfo("en-US", false);
directoryCache = new Dictionary <string, Dictionary <string, CompleteDirectoryEntry> >();
// Check it is really an OS/2 EA file
if (eaDirEntry.start_cluster != 0)
{
CacheEaData();
ushort eamagic = BitConverter.ToUInt16(cachedEaData, 0);
if (eamagic != EADATA_MAGIC)
{
eaDirEntry = new DirectoryEntry();
cachedEaData = null;
}
else
{
eaCache = new Dictionary <string, Dictionary <string, byte[]> >();
}
}
else if (fat32)
{
eaCache = new Dictionary <string, Dictionary <string, byte[]> >();
}
// Check OS/2 .LONGNAME
if (eaCache != null && (this.@namespace == Namespace.Os2 || this.@namespace == Namespace.Ecs))
{
List <KeyValuePair <string, CompleteDirectoryEntry> > rootFilesWithEas =
rootDirectoryCache.Where(t => t.Value.Dirent.ea_handle != 0).ToList();
foreach (KeyValuePair <string, CompleteDirectoryEntry> fileWithEa in rootFilesWithEas)
{
Dictionary <string, byte[]> eas = GetEas(fileWithEa.Value.Dirent.ea_handle);
if (eas is null)
{
continue;
}
if (!eas.TryGetValue("com.microsoft.os2.longname", out byte[] longnameEa))
