mirror of
https://github.com/aaru-dps/Aaru.git
synced 2025-12-16 19:24:25 +00:00
761 lines
35 KiB
C#
761 lines
35 KiB
C#
// /***************************************************************************
|
|
// The Disc Image Chef
|
|
// ----------------------------------------------------------------------------
|
|
//
|
|
// Filename : Super.cs
|
|
// Author(s) : Natalia Portillo <claunia@claunia.com>
|
|
//
|
|
// Component : Microsoft FAT filesystem plugin.
|
|
//
|
|
// --[ Description ] ----------------------------------------------------------
|
|
//
|
|
// Handles mounting and umounting the Microsoft FAT filesystem.
|
|
//
|
|
// --[ License ] --------------------------------------------------------------
|
|
//
|
|
// This library is free software; you can redistribute it and/or modify
|
|
// it under the terms of the GNU Lesser General Public License as
|
|
// published by the Free Software Foundation; either version 2.1 of the
|
|
// License, or (at your option) any later version.
|
|
//
|
|
// This library is distributed in the hope that it will be useful, but
|
|
// WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
// Lesser General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Lesser General Public
|
|
// License along with this library; if not, see <http://www.gnu.org/licenses/>.
|
|
//
|
|
// ----------------------------------------------------------------------------
|
|
// Copyright © 2011-2019 Natalia Portillo
|
|
// ****************************************************************************/
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Runtime.InteropServices;
|
|
using System.Text;
|
|
using DiscImageChef.CommonTypes;
|
|
using DiscImageChef.CommonTypes.Enums;
|
|
using DiscImageChef.CommonTypes.Interfaces;
|
|
using DiscImageChef.CommonTypes.Structs;
|
|
using DiscImageChef.Console;
|
|
using Schemas;
|
|
using FileSystemInfo = DiscImageChef.CommonTypes.Structs.FileSystemInfo;
|
|
using Marshal = DiscImageChef.Helpers.Marshal;
|
|
|
|
namespace DiscImageChef.Filesystems.FAT
|
|
{
|
|
public partial class FAT
|
|
{
|
|
uint fatEntriesPerSector;
|
|
|
|
IMediaImage image;
|
|
|
|
/// <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)) continue;
|
|
|
|
if(BitConverter.ToUInt16(longnameEa, 0) != EAT_ASCII) continue;
|
|
|
|
ushort longnameSize = BitConverter.ToUInt16(longnameEa, 2);
|
|
|
|
if(longnameSize + 4 > longnameEa.Length) continue;
|
|
|
|
byte[] longnameBytes = new byte[longnameSize];
|
|
|
|
Array.Copy(longnameEa, 4, longnameBytes, 0, longnameSize);
|
|
|
|
string longname = StringHandlers.CToString(longnameBytes, Encoding);
|
|
|
|
if(string.IsNullOrWhiteSpace(longname)) continue;
|
|
|
|
// Forward slash is allowed in .LONGNAME, so change it to visually similar division slash
|
|
longname = longname.Replace('/', '\u2215');
|
|
|
|
fileWithEa.Value.Longname = longname;
|
|
rootDirectoryCache.Remove(fileWithEa.Key);
|
|
rootDirectoryCache[fileWithEa.Value.ToString()] = fileWithEa.Value;
|
|
}
|
|
}
|
|
|
|
// Check FAT32.IFS EAs
|
|
if(fat32 || debug)
|
|
{
|
|
List<KeyValuePair<string, CompleteDirectoryEntry>> fat32EaSidecars = rootDirectoryCache
|
|
.Where(t =>
|
|
t.Key
|
|
.EndsWith(FAT32_EA_TAIL,
|
|
true,
|
|
cultureInfo))
|
|
.ToList();
|
|
|
|
foreach(KeyValuePair<string, CompleteDirectoryEntry> sidecar in fat32EaSidecars)
|
|
{
|
|
// No real file this sidecar accompanies
|
|
if(!rootDirectoryCache
|
|
.TryGetValue(sidecar.Key.Substring(0, sidecar.Key.Length - FAT32_EA_TAIL.Length),
|
|
out CompleteDirectoryEntry fileWithEa)) continue;
|
|
|
|
// If not in debug mode we will consider the lack of EA bitflags to mean the EAs are corrupted or not real
|
|
if(!debug)
|
|
if(!fileWithEa.Dirent.caseinfo.HasFlag(CaseInfo.NormalEaOld) &&
|
|
!fileWithEa.Dirent.caseinfo.HasFlag(CaseInfo.CriticalEa) &&
|
|
!fileWithEa.Dirent.caseinfo.HasFlag(CaseInfo.NormalEa) &&
|
|
!fileWithEa.Dirent.caseinfo.HasFlag(CaseInfo.CriticalEa))
|
|
continue;
|
|
|
|
fileWithEa.Fat32Ea = sidecar.Value.Dirent;
|
|
|
|
if(!debug) rootDirectoryCache.Remove(sidecar.Key);
|
|
}
|
|
}
|
|
|
|
mounted = true;
|
|
return Errno.NoError;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Umounts this Lisa filesystem
|
|
/// </summary>
|
|
public Errno Unmount()
|
|
{
|
|
if(!mounted) return Errno.AccessDenied;
|
|
|
|
mounted = false;
|
|
fatEntries = null;
|
|
return Errno.NoError;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets information about the mounted volume.
|
|
/// </summary>
|
|
/// <param name="stat">Information about the mounted volume.</param>
|
|
public Errno StatFs(out FileSystemInfo stat)
|
|
{
|
|
stat = null;
|
|
if(!mounted) return Errno.AccessDenied;
|
|
|
|
stat = statfs.ShallowCopy();
|
|
return Errno.NoError;
|
|
}
|
|
}
|
|
} |