/// <inheritdoc /> /// <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 = _cpmStat; return(Errno.NoError); }
public Errno Mount(IMediaImage imagePlugin, Partition partition, Encoding encoding, Dictionary <string, string> options, string @namespace) { _device = imagePlugin; Encoding = encoding ?? Encoding.GetEncoding("IBM437"); options ??= GetDefaultOptions(); if (options.TryGetValue("debug", out string debugString)) { bool.TryParse(debugString, out _debug); } // As the identification is so complex, just call Identify() and relay on its findings if (!Identify(_device, partition) || !_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 AaruConsole.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) { AaruConsole.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) { AaruConsole.DebugWriteLine("CP/M Plugin", "Don't know how to handle EAGLE ordering, not proceeding with this definition."); return(Errno.NotImplemented); } else { AaruConsole.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) { AaruConsole.DebugWriteLine("CP/M Plugin", "Deinterleaving whole volume."); for (int p = 0; p <= (int)(partition.End - partition.Start); p++) { byte[] readSector = _device.ReadSector((ulong)((int)partition.Start + ((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; var blockMs = new MemoryStream(); ulong blockNo = 0; int sectorsPerBlock = 0; Dictionary <ulong, byte[]> allocationBlocks = new Dictionary <ulong, byte[]>(); AaruConsole.DebugWriteLine("CP/M Plugin", "Creating allocation blocks."); // For each volume sector for (ulong a = 0; a < (ulong)deinterleavedSectors.Count; a++) { deinterleavedSectors.TryGetValue(a, out byte[] 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) { continue; } allocationBlocks.Add(blockNo++, blockMs.ToArray()); sectorsPerBlock = 0; blockMs = new MemoryStream(); } // CP/M blocks are same size than physical sectors else { allocationBlocks.Add(blockNo++, sector); } } AaruConsole.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 var dirMs = new MemoryStream(); for (int d = 0; d < dirSectors; d++) { deinterleavedSectors.TryGetValue((ulong)(d + dirOff), out byte[] 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[]>(); AaruConsole.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 (allocationBlocks.Count > 256) { DirectoryEntry16 entry = Marshal.ByteArrayToStructureLittleEndian <DirectoryEntry16>(directory, dOff, 32); 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 = $"{user:X1}:{filename}"; } if (!string.IsNullOrEmpty(extension)) { filename = filename + "." + extension; } int entryNo = ((32 * entry.extentCounter) + entry.extentCounterHigh) / (_dpb.exm + 1); // Do we have a stat for the file already? if (_statCache.TryGetValue(filename, out FileEntryInfo fInfo)) { _statCache.Remove(filename); } else { fInfo = new FileEntryInfo { Attributes = new FileAttributes() } }; // And any extent? if (fileExtents.TryGetValue(filename, out Dictionary <int, List <ushort> > 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 List <ushort> 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.Where(blk => !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 = Marshal.ByteArrayToStructureLittleEndian <DirectoryEntry>(directory, dOff, 32); 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 = $"{user:X1}:{filename}"; } if (!string.IsNullOrEmpty(extension)) { filename = filename + "." + extension; } int entryNo = ((32 * entry.extentCounterHigh) + entry.extentCounter) / (_dpb.exm + 1); // Do we have a stat for the file already? if (_statCache.TryGetValue(filename, out FileEntryInfo fInfo)) { _statCache.Remove(filename); } else { fInfo = new FileEntryInfo { Attributes = new FileAttributes() } }; // And any extent? if (fileExtents.TryGetValue(filename, out Dictionary <int, List <ushort> > 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 List <ushort> 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.Where(blk => !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 = Marshal.ByteArrayToStructureLittleEndian <PasswordEntry>(directory, dOff, 32); 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 = $"{user:X1}:{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 { switch (directory[dOff] & 0x7F) { case 0x20: LabelEntry labelEntry = Marshal.ByteArrayToStructureLittleEndian <LabelEntry>(directory, dOff, 32); // The volume label defines if one of the fields in CP/M 3 timestamp is a creation or an // access time atime |= (labelEntry.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++; break; case 0x21: if (directory[dOff + 10] == 0x00 && directory[dOff + 20] == 0x00 && directory[dOff + 30] == 0x00 && directory[dOff + 31] == 0x00) { DateEntry dateEntry = Marshal.ByteArrayToStructureLittleEndian <DateEntry>(directory, dOff, 32); 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(dateEntry.date1); } else { fInfo.CreationTime = DateHandlers.CpmToDateTime(dateEntry.date1); } fInfo.LastWriteTime = DateHandlers.CpmToDateTime(dateEntry.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(dateEntry.date3); } else { fInfo.CreationTime = DateHandlers.CpmToDateTime(dateEntry.date3); } fInfo.LastWriteTime = DateHandlers.CpmToDateTime(dateEntry.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(dateEntry.date5); } else { fInfo.CreationTime = DateHandlers.CpmToDateTime(dateEntry.date5); } fInfo.LastWriteTime = DateHandlers.CpmToDateTime(dateEntry.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 trdPartyDateEntry = Marshal.ByteArrayToStructureLittleEndian <TrdPartyDateEntry>(directory, dOff, 32); 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] = trdPartyDateEntry.create1[0]; ctime[1] = trdPartyDateEntry.create1[1]; fInfo.AccessTime = DateHandlers.CpmToDateTime(trdPartyDateEntry.access1); fInfo.CreationTime = DateHandlers.CpmToDateTime(ctime); fInfo.LastWriteTime = DateHandlers.CpmToDateTime(trdPartyDateEntry.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] = trdPartyDateEntry.create2[0]; ctime[1] = trdPartyDateEntry.create2[1]; fInfo.AccessTime = DateHandlers.CpmToDateTime(trdPartyDateEntry.access2); fInfo.CreationTime = DateHandlers.CpmToDateTime(ctime); fInfo.LastWriteTime = DateHandlers.CpmToDateTime(trdPartyDateEntry.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] = trdPartyDateEntry.create3[0]; ctime[1] = trdPartyDateEntry.create3[1]; fInfo.AccessTime = DateHandlers.CpmToDateTime(trdPartyDateEntry.access3); fInfo.CreationTime = DateHandlers.CpmToDateTime(ctime); fInfo.LastWriteTime = DateHandlers.CpmToDateTime(trdPartyDateEntry.modify3); _statCache.Add(file3, fInfo); } file1 = null; file2 = null; file3 = null; dirCnt = 0; } break; } } } // Cache all files. As CP/M maximum volume size is 8 Mib // this should not be a problem AaruConsole.DebugWriteLine("CP/M Plugin", "Reading files."); long usedBlocks = 0; _fileCache = new Dictionary <string, byte[]>(); foreach (string filename in _dirList) { var fileMs = new MemoryStream(); if (_statCache.TryGetValue(filename, out FileEntryInfo fInfo)) { _statCache.Remove(filename); } fInfo.Blocks = 0; if (fileExtents.TryGetValue(filename, out Dictionary <int, List <ushort> > extents)) { for (int ex = 0; ex < extents.Count; ex++) { if (!extents.TryGetValue(ex, out List <ushort> alBlks)) { continue; } foreach (ushort alBlk in alBlks) { allocationBlocks.TryGetValue(alBlk, out byte[] 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 = (ulong)(_dpb.dsm + 1); _cpmStat.FilenameLength = 11; _cpmStat.Files = (ulong)_fileCache.Count; _cpmStat.FreeBlocks = _cpmStat.Blocks - (ulong)usedBlocks; _cpmStat.PluginId = Id; _cpmStat.Type = "CP/M filesystem"; // Generate XML info XmlFsType = new FileSystemType { Clusters = _cpmStat.Blocks, ClusterSize = (uint)blockSize, Files = (ulong)_fileCache.Count, FilesSpecified = true, FreeClusters = _cpmStat.FreeBlocks, FreeClustersSpecified = true, Type = "CP/M filesystem" }; if (_labelCreationDate != null) { XmlFsType.CreationDate = DateHandlers.CpmToDateTime(_labelCreationDate); XmlFsType.CreationDateSpecified = true; } if (_labelUpdateDate != null) { XmlFsType.ModificationDate = DateHandlers.CpmToDateTime(_labelUpdateDate); XmlFsType.ModificationDateSpecified = true; } if (!string.IsNullOrEmpty(_label)) { XmlFsType.VolumeName = _label; } _mounted = true; return(Errno.NoError); }
/// <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))