343 lines
16 KiB
C#
343 lines
16 KiB
C#
// Fat12ImageLib.cs
|
|
// Minimal C# library for creating a FAT12 disk image and adding files (root directory only)
|
|
// Target: .NET 6+
|
|
// Limitations: 8.3 filenames, root directory only (no subdirectories), no long file names, no deletions/compaction.
|
|
|
|
using System;
|
|
using System.Buffers.Binary;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Text;
|
|
|
|
namespace Fat12Lib
|
|
{
|
|
public class Fat12ImageOptions
|
|
{
|
|
// Total size of the image in bytes. Common sizes: 360 KiB, 720 KiB, 1.2 MiB, 1.44 MiB, 2.88 MiB, etc.
|
|
public long TotalSizeBytes { get; set; } = 1440L * 1024; // 1.44 MiB default
|
|
public ushort BytesPerSector { get; set; } = 512;
|
|
public byte SectorsPerCluster { get; set; } = 0; // 0 = auto-select based on size
|
|
public byte NumFats { get; set; } = 2;
|
|
public ushort ReservedSectors { get; set; } = 1; // boot sector
|
|
public ushort MaxRootDirEntries { get; set; } = 224; // typical for 1.44MB floppy
|
|
public byte MediaDescriptor { get; set; } = 0xF0; // floppy
|
|
public ushort SectorsPerTrack { get; set; } = 18; // 1.44MB geometry (not critical)
|
|
public ushort NumberOfHeads { get; set; } = 2; // geometry (not critical)
|
|
public uint HiddenSectors { get; set; } = 0;
|
|
public string OemId { get; set; } = "MSDOS5.0";
|
|
public string VolumeLabel { get; set; } = "NO NAME "; // exactly 11 chars; will be padded/trimmed
|
|
public string FsTypeLabel { get; set; } = "FAT12 "; // 8 chars in boot sector label
|
|
public ushort? VolumeId { get; set; } = null; // null => random
|
|
}
|
|
|
|
public class Fat12Image
|
|
{
|
|
private readonly Fat12ImageOptions _opt;
|
|
|
|
// Computed layout
|
|
private uint _totalSectors; // 16-bit or 32-bit depending on size
|
|
private ushort _rootDirSectors;
|
|
private ushort _fatSectors; // sectors per FAT
|
|
private uint _firstFatSectorLba;
|
|
private uint _firstRootDirSectorLba;
|
|
private uint _firstDataSectorLba;
|
|
private uint _clusterCount; // data clusters (not counting 0 and 1)
|
|
private byte _sectorsPerCluster;
|
|
|
|
// Runtime buffers
|
|
private byte[] _bootSector = Array.Empty<byte>();
|
|
private byte[] _fat; // a single FAT table; will be duplicated NumFats times
|
|
private byte[] _rootDir; // root directory area (fixed size)
|
|
private byte[] _data; // data region sized to contain all clusters (clusterCount * spc * bps)
|
|
|
|
// Allocation state
|
|
private uint _nextFreeCluster = 2; // FAT clusters start at 2
|
|
private int _nextFreeRootDirEntry = 0;
|
|
|
|
public Fat12Image(Fat12ImageOptions options)
|
|
{
|
|
_opt = options;
|
|
if (_opt.BytesPerSector != 512)
|
|
throw new NotSupportedException("Only 512-byte sectors supported in this minimal implementation.");
|
|
if (_opt.TotalSizeBytes % _opt.BytesPerSector != 0)
|
|
throw new ArgumentException("TotalSizeBytes must be a multiple of BytesPerSector.");
|
|
|
|
InitializeLayout();
|
|
BuildBootSector();
|
|
InitializeFatAndRoot();
|
|
}
|
|
|
|
// Adds a file into the root directory. Uses 8.3 name rules.
|
|
public void AddFile(string fileName, byte[] content, DateTime? timestamp = null)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(fileName)) throw new ArgumentException("fileName");
|
|
if (content == null) throw new ArgumentNullException(nameof(content));
|
|
|
|
var (name83, ext83) = ToShortName(fileName);
|
|
if (_nextFreeRootDirEntry >= _opt.MaxRootDirEntries)
|
|
throw new IOException("Root directory is full.");
|
|
|
|
// Compute how many clusters needed
|
|
uint bytesPerCluster = (uint)(_opt.BytesPerSector * _sectorsPerCluster);
|
|
uint clustersNeeded = (uint)((content.Length + bytesPerCluster - 1) / bytesPerCluster);
|
|
if (clustersNeeded == 0) clustersNeeded = 1; // allocate 1 cluster to store 0-byte file metadata/simple handling
|
|
|
|
if ((_nextFreeCluster - 2) + clustersNeeded > _clusterCount)
|
|
throw new IOException("Not enough free space for file.");
|
|
|
|
// Allocate cluster chain
|
|
List<uint> chain = new();
|
|
for (int i = 0; i < clustersNeeded; i++)
|
|
{
|
|
uint c = _nextFreeCluster++;
|
|
chain.Add(c);
|
|
}
|
|
|
|
// Write data to clusters
|
|
int srcOffset = 0;
|
|
foreach (var c in chain)
|
|
{
|
|
uint lba = ClusterToLba(c);
|
|
uint offset = (lba - _firstDataSectorLba) * _opt.BytesPerSector;
|
|
int toCopy = (int)Math.Min(bytesPerCluster, (uint)(content.Length - srcOffset));
|
|
if (toCopy > 0)
|
|
Buffer.BlockCopy(content, srcOffset, _data, (int)offset, toCopy);
|
|
srcOffset += toCopy;
|
|
}
|
|
|
|
// Link FAT entries (12-bit values)
|
|
for (int i = 0; i < chain.Count - 1; i++)
|
|
SetFat12Entry(chain[i], (ushort)chain[i + 1]);
|
|
SetFat12Entry(chain[^1], 0xFFF); // EOF for FAT12
|
|
|
|
// Build directory entry
|
|
var dt = timestamp ?? DateTime.Now;
|
|
ushort time = ToFatTime(dt);
|
|
ushort date = ToFatDate(dt);
|
|
|
|
Span<byte> entry = stackalloc byte[32];
|
|
entry.Clear();
|
|
Encoding.ASCII.GetBytes(name83, entry);
|
|
Encoding.ASCII.GetBytes(ext83, entry.Slice(8));
|
|
entry[11] = 0x20; // Archive
|
|
BinaryPrimitives.WriteUInt16LittleEndian(entry.Slice(14), time); // Create time
|
|
BinaryPrimitives.WriteUInt16LittleEndian(entry.Slice(16), date); // Create date
|
|
BinaryPrimitives.WriteUInt16LittleEndian(entry.Slice(18), date); // Last access date (approx)
|
|
BinaryPrimitives.WriteUInt16LittleEndian(entry.Slice(22), time); // Write time
|
|
BinaryPrimitives.WriteUInt16LittleEndian(entry.Slice(24), date); // Write date
|
|
BinaryPrimitives.WriteUInt16LittleEndian(entry.Slice(26), (ushort)chain[0]); // First cluster
|
|
BinaryPrimitives.WriteUInt32LittleEndian(entry.Slice(28), (uint)content.Length); // File size
|
|
|
|
// Write entry into root dir
|
|
int rootOffset = _nextFreeRootDirEntry * 32;
|
|
_rootDir.AsSpan(rootOffset, 32).Clear();
|
|
entry.CopyTo(_rootDir.AsSpan(rootOffset));
|
|
_nextFreeRootDirEntry++;
|
|
}
|
|
|
|
public byte[] GetImage()
|
|
{
|
|
using var ms = new MemoryStream((int)(_opt.TotalSizeBytes));
|
|
|
|
// Boot sector
|
|
ms.Write(_bootSector, 0, _bootSector.Length);
|
|
|
|
// FATs
|
|
for (int f = 0; f < _opt.NumFats; f++)
|
|
ms.Write(_fat, 0, _fat.Length);
|
|
|
|
// Root directory
|
|
ms.Write(_rootDir, 0, _rootDir.Length);
|
|
|
|
// Data region
|
|
ms.Write(_data, 0, _data.Length);
|
|
|
|
// Pad to exact size if necessary (should be exact)
|
|
if (ms.Length < _opt.TotalSizeBytes)
|
|
ms.Write(new byte[_opt.TotalSizeBytes - ms.Length], 0, (int)(_opt.TotalSizeBytes - ms.Length));
|
|
|
|
return ms.ToArray();
|
|
}
|
|
|
|
public void SaveToFile(string path)
|
|
{
|
|
File.WriteAllBytes(path, GetImage());
|
|
}
|
|
|
|
private void InitializeLayout()
|
|
{
|
|
_totalSectors = (uint)(_opt.TotalSizeBytes / _opt.BytesPerSector);
|
|
|
|
// Decide sectors per cluster if not specified
|
|
_sectorsPerCluster = _opt.SectorsPerCluster != 0 ? _opt.SectorsPerCluster : SelectSectorsPerCluster(_totalSectors, _opt.BytesPerSector);
|
|
|
|
_rootDirSectors = (ushort)(((uint)_opt.MaxRootDirEntries * 32 + (_opt.BytesPerSector - 1)) / _opt.BytesPerSector);
|
|
|
|
// Iteratively solve for FAT size and cluster count (FAT12 uses 12-bit entries => 1.5 bytes per entry)
|
|
ushort fatSectors = 1;
|
|
while (true)
|
|
{
|
|
uint dataSectors = _totalSectors - _opt.ReservedSectors - (uint)(_opt.NumFats * fatSectors) - _rootDirSectors;
|
|
uint clusterCount = dataSectors / _sectorsPerCluster;
|
|
if (clusterCount < 1 || clusterCount > 4084)
|
|
throw new NotSupportedException($"Cluster count {clusterCount} out of FAT12 bounds (needs 1..4,084). Adjust size or sectors/cluster.");
|
|
|
|
// FAT12 entries: (clusterCount + 2) entries, each 12 bits => total bytes = ceil(3 * entries / 2)
|
|
uint entries = clusterCount + 2;
|
|
uint fatBytes = (entries * 3 + 1) / 2; // ceil(1.5 * entries)
|
|
ushort requiredFatSectors = (ushort)((fatBytes + (_opt.BytesPerSector - 1)) / _opt.BytesPerSector);
|
|
if (requiredFatSectors == fatSectors)
|
|
{
|
|
_fatSectors = fatSectors;
|
|
_clusterCount = clusterCount;
|
|
break;
|
|
}
|
|
fatSectors = requiredFatSectors;
|
|
}
|
|
|
|
_firstFatSectorLba = _opt.ReservedSectors;
|
|
_firstRootDirSectorLba = _firstFatSectorLba + (uint)(_opt.NumFats * _fatSectors);
|
|
_firstDataSectorLba = _firstRootDirSectorLba + _rootDirSectors;
|
|
|
|
// Buffers
|
|
_bootSector = new byte[_opt.BytesPerSector];
|
|
_fat = new byte[_fatSectors * _opt.BytesPerSector];
|
|
_rootDir = new byte[_rootDirSectors * _opt.BytesPerSector];
|
|
uint dataSectorsFinal = _totalSectors - _opt.ReservedSectors - (uint)(_opt.NumFats * _fatSectors) - _rootDirSectors;
|
|
_data = new byte[dataSectorsFinal * _opt.BytesPerSector];
|
|
}
|
|
|
|
private void BuildBootSector()
|
|
{
|
|
Span<byte> bs = _bootSector;
|
|
bs.Clear();
|
|
|
|
// Jump + OEM
|
|
bs[0] = 0xEB; bs[1] = 0x3C; bs[2] = 0x90; // JMP short
|
|
Encoding.ASCII.GetBytes((_opt.OemId ?? "MSDOS5.0").PadRight(8).Substring(0,8), bs.Slice(3, 8));
|
|
|
|
// BIOS Parameter Block (BPB)
|
|
BinaryPrimitives.WriteUInt16LittleEndian(bs.Slice(11), _opt.BytesPerSector);
|
|
bs[13] = _sectorsPerCluster;
|
|
BinaryPrimitives.WriteUInt16LittleEndian(bs.Slice(14), _opt.ReservedSectors);
|
|
bs[16] = _opt.NumFats;
|
|
BinaryPrimitives.WriteUInt16LittleEndian(bs.Slice(17), _opt.MaxRootDirEntries);
|
|
ushort totalSectors16 = _totalSectors <= 0xFFFF ? (ushort)_totalSectors : (ushort)0;
|
|
BinaryPrimitives.WriteUInt16LittleEndian(bs.Slice(19), totalSectors16);
|
|
bs[21] = _opt.MediaDescriptor;
|
|
BinaryPrimitives.WriteUInt16LittleEndian(bs.Slice(22), _fatSectors);
|
|
BinaryPrimitives.WriteUInt16LittleEndian(bs.Slice(24), _opt.SectorsPerTrack);
|
|
BinaryPrimitives.WriteUInt16LittleEndian(bs.Slice(26), _opt.NumberOfHeads);
|
|
BinaryPrimitives.WriteUInt32LittleEndian(bs.Slice(28), _opt.HiddenSectors);
|
|
BinaryPrimitives.WriteUInt32LittleEndian(bs.Slice(32), _totalSectors);
|
|
|
|
// Extended BPB for FAT12/FAT16
|
|
ushort volId = _opt.VolumeId ?? (ushort)Random.Shared.Next(1, 0xFFFF);
|
|
BinaryPrimitives.WriteUInt32LittleEndian(bs.Slice(39), volId);
|
|
string label = (_opt.VolumeLabel ?? "NO NAME").ToUpperInvariant();
|
|
label = new string(label.Where(ch => ch >= 0x20 && ch <= 0x7E).ToArray());
|
|
label = label.PadRight(11).Substring(0, 11);
|
|
Encoding.ASCII.GetBytes(label, bs.Slice(43, 11));
|
|
string fstype = (_opt.FsTypeLabel ?? "FAT12").PadRight(8).Substring(0, 8);
|
|
Encoding.ASCII.GetBytes(fstype, bs.Slice(54, 8));
|
|
|
|
// Minimal bootstrap code area (ignored for data disks)
|
|
bs[_opt.BytesPerSector - 2] = 0x55; // signature
|
|
bs[_opt.BytesPerSector - 1] = 0xAA;
|
|
}
|
|
|
|
private void InitializeFatAndRoot()
|
|
{
|
|
// FAT initial entries for FAT12
|
|
// First three bytes: media descriptor and end markers -> usually F0 FF FF for 0xF0 media
|
|
Array.Clear(_fat, 0, _fat.Length);
|
|
_fat[0] = _opt.MediaDescriptor; // e.g., 0xF0
|
|
_fat[1] = 0xFF;
|
|
_fat[2] = 0xFF; // cluster 1 reserved/end
|
|
}
|
|
|
|
private uint ClusterToLba(uint cluster)
|
|
{
|
|
if (cluster < 2) throw new ArgumentOutOfRangeException(nameof(cluster));
|
|
return _firstDataSectorLba + (cluster - 2) * _sectorsPerCluster;
|
|
}
|
|
|
|
private void SetFat12Entry(uint cluster, ushort value)
|
|
{
|
|
if (cluster >= _clusterCount + 2) throw new ArgumentOutOfRangeException(nameof(cluster));
|
|
// value is 12-bit
|
|
value &= 0x0FFF;
|
|
int index = (int)(cluster + (cluster / 2)); // floor(1.5 * cluster)
|
|
if ((cluster & 1) == 0)
|
|
{
|
|
// even cluster: low 12 bits starting at index
|
|
_fat[index] = (byte)((_fat[index] & 0x00) | (value & 0xFF));
|
|
_fat[index + 1] = (byte)((_fat[index + 1] & 0xF0) | ((value >> 8) & 0x0F));
|
|
}
|
|
else
|
|
{
|
|
// odd cluster: high 12 bits overlapping starting at index
|
|
_fat[index] = (byte)((_fat[index] & 0x0F) | ((value << 4) & 0xF0));
|
|
_fat[index + 1] = (byte)((_fat[index + 1] & 0x00) | ((value >> 4) & 0xFF));
|
|
}
|
|
}
|
|
|
|
private static (string name, string ext) ToShortName(string fileName)
|
|
{
|
|
// Extract base and extension, sanitize to 8.3 uppercase ASCII
|
|
string name = Path.GetFileNameWithoutExtension(fileName) ?? "FILE";
|
|
string ext = Path.GetExtension(fileName);
|
|
if (ext.StartsWith('.')) ext = ext.Substring(1);
|
|
|
|
string Sanitize(string s) => new string(s.ToUpperInvariant()
|
|
.Select(c => (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || "!#$%&'()-@^_`{}~".Contains(c) ? c : '_')
|
|
.ToArray());
|
|
|
|
string n = Sanitize(name);
|
|
string e = Sanitize(ext);
|
|
if (n.Length > 8) n = n.Substring(0, 8);
|
|
if (e.Length > 3) e = e.Substring(0, 3);
|
|
n = n.PadRight(8);
|
|
e = e.PadRight(3);
|
|
return (n, e);
|
|
}
|
|
|
|
private static ushort ToFatDate(DateTime dt)
|
|
{
|
|
int year = Math.Clamp(dt.Year - 1980, 0, 127);
|
|
int month = Math.Clamp(dt.Month, 1, 12);
|
|
int day = Math.Clamp(dt.Day, 1, 31);
|
|
return (ushort)((year << 9) | (month << 5) | day);
|
|
}
|
|
|
|
private static ushort ToFatTime(DateTime dt)
|
|
{
|
|
int hour = Math.Clamp(dt.Hour, 0, 23);
|
|
int minute = Math.Clamp(dt.Minute, 0, 59);
|
|
int second = Math.Clamp(dt.Second / 2, 0, 29); // 2-second resolution
|
|
return (ushort)((hour << 11) | (minute << 5) | second);
|
|
}
|
|
|
|
private static byte SelectSectorsPerCluster(uint totalSectors, ushort bytesPerSector)
|
|
{
|
|
// Simple mapping aimed at floppy-like sizes with 512B sectors
|
|
long sizeKiB = (long)totalSectors * bytesPerSector / 1024;
|
|
if (sizeKiB <= 720) return 1; // 360K/720K
|
|
if (sizeKiB <= 1440) return 1; // 1.44MB
|
|
if (sizeKiB <= 2400) return 1; // 2.4MB
|
|
if (sizeKiB <= 2880) return 1; // 2.88MB
|
|
if (sizeKiB <= 4096) return 2; // up to 4MB
|
|
if (sizeKiB <= 8192) return 4; // up to 8MB
|
|
return 8; // larger volumes still FAT12 but uncommon
|
|
}
|
|
}
|
|
}
|
|
|
|
// --------- Example usage (not part of the library) ---------
|
|
// using System.Text;
|
|
// var img = new Fat12Lib.Fat12Image(new Fat12Lib.Fat12ImageOptions { TotalSizeBytes = 1440L * 1024, VolumeLabel = "MY12DISK" });
|
|
// img.AddFile("HELLO.TXT", Encoding.ASCII.GetBytes("Hello FAT12!
|
|
"));
|
|
// img.SaveToFile("fat12.img");
|