protected bool SetClusterEntryValue(uint cluster, uint nextcluster)
{
uint fatOffset = 0;
fatOffset = cluster * 4;
uint sector = ReservedSector + (fatOffset / BytePerSector);
uint sectorOffset = fatOffset % BytePerSector;
uint nbrSectors = 1;
if ((FatType == FatType.FAT12) && (sectorOffset == BytePerSector - 1))
{
nbrSectors = 2;
}
var xData = new byte[512 * nbrSectors];
this.IDevice.Read(sector, nbrSectors, xData);
BinaryFormat fat = new BinaryFormat(xData);
fat.SetUInt(sectorOffset, nextcluster);
this.IDevice.Write(sector, nbrSectors, fat.Data);
return(true);
}
public override void MakeDirectory(string DirName)
{
//TODO: Same Entry Exist exception.
FatFileLocation location = FindEntry(new FileSystem.Find.Empty(), FatCurrentDirectoryEntry);
uint FirstCluster = AllocateFirstCluster();
var xdata = new byte[512 * SectorsPerCluster];
this.IDevice.Read(location.DirectorySector, SectorsPerCluster, xdata);
BinaryFormat directory = new BinaryFormat(xdata);
directory.SetString(Entry.DOSName + location.DirectorySectorIndex * 32, " ", 11);
directory.SetString(Entry.DOSName + location.DirectorySectorIndex * 32, DirName);
directory.SetByte(Entry.FileAttributes + location.DirectorySectorIndex * 32, (byte)0x10);
directory.SetByte(Entry.Reserved + location.DirectorySectorIndex * 32, 0);
directory.SetByte(Entry.CreationTimeFine + location.DirectorySectorIndex * 32, 0);
directory.SetUShort(Entry.CreationTime + location.DirectorySectorIndex * 32, 0);
directory.SetUShort(Entry.CreationDate + location.DirectorySectorIndex * 32, 0);
directory.SetUShort(Entry.LastAccessDate + location.DirectorySectorIndex * 32, 0);
directory.SetUShort(Entry.LastModifiedTime + location.DirectorySectorIndex * 32, 0);
directory.SetUShort(Entry.LastModifiedDate + location.DirectorySectorIndex * 32, 0);
directory.SetUShort(Entry.FirstCluster + location.DirectorySectorIndex * 32, (ushort)FirstCluster);
directory.SetUInt(Entry.FileSize + location.DirectorySectorIndex * 32, 0);
this.IDevice.Write(location.DirectorySector, SectorsPerCluster, xdata);
FatFileLocation loc = FindEntry(new FileSystem.Find.Empty(), FirstCluster);
xdata = new byte[512 * SectorsPerCluster];
this.IDevice.Read(loc.DirectorySector, SectorsPerCluster, xdata);
directory = new BinaryFormat(xdata);
for (int i = 0; i < 2; i++)
{
directory.SetString(Entry.DOSName + loc.DirectorySectorIndex * 32, " ", 11);
if (i == 0)
{
directory.SetString(Entry.DOSName + loc.DirectorySectorIndex * 32, ".");
directory.SetUShort(Entry.FirstCluster + loc.DirectorySectorIndex * 32, (ushort)FirstCluster);
}
else
{
directory.SetString(Entry.DOSName + loc.DirectorySectorIndex * 32, "..");
directory.SetUShort(Entry.FirstCluster + loc.DirectorySectorIndex * 32, (ushort)FatCurrentDirectoryEntry);
}
directory.SetByte(Entry.FileAttributes + loc.DirectorySectorIndex * 32, (byte)0x10);
directory.SetByte(Entry.Reserved + loc.DirectorySectorIndex * 32, 0);
directory.SetByte(Entry.CreationTimeFine + loc.DirectorySectorIndex * 32, 0);
directory.SetUShort(Entry.CreationTime + loc.DirectorySectorIndex * 32, 0);
directory.SetUShort(Entry.CreationDate + loc.DirectorySectorIndex * 32, 0);
directory.SetUShort(Entry.LastAccessDate + loc.DirectorySectorIndex * 32, 0);
directory.SetUShort(Entry.LastModifiedTime + loc.DirectorySectorIndex * 32, 0);
directory.SetUShort(Entry.LastModifiedDate + loc.DirectorySectorIndex * 32, 0);
directory.SetUInt(Entry.FileSize + loc.DirectorySectorIndex * 32, 0);
loc.DirectorySectorIndex += 1;
}
this.IDevice.Write(loc.DirectorySector, SectorsPerCluster, xdata);
}
protected bool SetClusterEntryValue(uint cluster, uint nextcluster)
{
uint fatOffset = 0;
if (fatType == FATType.FAT12)
{
fatOffset = (cluster + (cluster / 2));
}
else if (fatType == FATType.FAT16)
{
fatOffset = cluster * 2;
}
else //if (type == FatType.FAT32)
{
fatOffset = cluster * 4;
}
uint sector = fatStart + (fatOffset / bytesPerSector);
uint sectorOffset = fatOffset % bytesPerSector;
uint nbrSectors = 1;
if ((fatType == FATType.FAT12) && (sectorOffset == bytesPerSector - 1))
{
nbrSectors = 2;
}
BinaryFormat fat = new BinaryFormat(partition.ReadBlock(sector, nbrSectors));
if (fatType == FATType.FAT12)
{
uint clustervalue = fat.GetUShort(sectorOffset);
if (cluster % 2 == 1)
{
clustervalue = ((clustervalue & 0xF) | (nextcluster << 4));
}
else
{
clustervalue = ((clustervalue & 0xf000) | (nextcluster));
}
fat.SetUShort(sectorOffset, (ushort)clustervalue);
}
else if (fatType == FATType.FAT16)
{
fat.SetUShort(sectorOffset, (ushort)nextcluster);
}
else //if (type == FatType.FAT32)
{
fat.SetUInt(sectorOffset, nextcluster);
}
partition.WriteBlock(sector, nbrSectors, fat.Data);
return(true);
}
public bool Format(FATSettings fatSettings)
{
if (!partition.CanWrite)
{
return(false);
}
this.fatType = fatSettings.FatType;
bytesPerSector = 512;
totalSectors = partition.BlockCount;
sectorsPerCluster = GetSectorsPerClusterByTotalSectors(fatType, totalSectors);
nbrFats = 2;
if (fatType == FATType.FAT32)
{
reservedSectors = 32;
rootEntries = 0;
}
else
{
reservedSectors = 1;
rootEntries = 512;
}
rootDirSectors = (((rootEntries * 32) + (bytesPerSector - 1)) / bytesPerSector);
fatStart = reservedSectors;
uint val1 = totalSectors - (reservedSectors + rootDirSectors);
uint val2 = (uint)((256 * sectorsPerCluster) + nbrFats);
if (fatType == FATType.FAT32)
{
val2 = val2 / 2;
}
uint sectorsperfat = (val1 + (val2 - 1)) / val2;
BinaryFormat bootSector = new BinaryFormat(512);
bootSector.SetUInt(BootSector.JumpInstruction, 0);
bootSector.SetString(BootSector.EOMName, "MSWIN4.1");
bootSector.SetUShort(BootSector.BytesPerSector, (ushort)bytesPerSector);
bootSector.SetByte(BootSector.SectorsPerCluster, (byte)sectorsPerCluster);
bootSector.SetUShort(BootSector.ReservedSectors, (ushort)reservedSectors);
bootSector.SetByte(BootSector.FatAllocationTables, nbrFats);
bootSector.SetUShort(BootSector.MaxRootDirEntries, (ushort)rootEntries);
if (totalSectors > 0xFFFF)
{
bootSector.SetUShort(BootSector.TotalSectors, 0);
bootSector.SetUInt(BootSector.FAT32_TotalSectors, totalClusters);
}
else
{
bootSector.SetUShort(BootSector.TotalSectors, (ushort)totalSectors);
bootSector.SetUInt(BootSector.FAT32_TotalSectors, 0);
}
bootSector.SetByte(BootSector.MediaDescriptor, 0xF8);
if (fatType == FATType.FAT32)
{
bootSector.SetUShort(BootSector.SectorsPerFAT, 0);
}
else
{
bootSector.SetUShort(BootSector.SectorsPerFAT, (ushort)sectorsperfat);
}
bootSector.SetUShort(BootSector.SectorsPerTrack, 0); ////FIXME
bootSector.SetUInt(BootSector.HiddenSectors, 0);
if (fatType != FATType.FAT32)
{
bootSector.SetByte(BootSector.PhysicalDriveNbr, 0x80);
bootSector.SetByte(BootSector.ReservedCurrentHead, 0);
bootSector.SetByte(BootSector.ExtendedBootSignature, 0x29);
bootSector.SetBytes(BootSector.IDSerialNumber, fatSettings.SerialID, 0, (uint)(fatSettings.SerialID.Length <= 4 ? fatSettings.SerialID.Length : 4));
bootSector.SetString(BootSector.VolumeLabel, " "); // 12 blank spaces
bootSector.SetString(BootSector.VolumeLabel, fatSettings.VolumeLabel, (uint)(fatSettings.VolumeLabel.Length <= 12 ? fatSettings.VolumeLabel.Length : 12));
bootSector.SetUShort(BootSector.BootSectorSignature, 0x55AA);
//BootSector.OSBootCode // TODO
}
if (fatType == FATType.FAT12)
{
bootSector.SetString(BootSector.FATType, "FAT12 ");
}
else if (fatType == FATType.FAT16)
{
bootSector.SetString(BootSector.FATType, "FAT16 ");
}
else // if (type == FatType.FAT32)
{
bootSector.SetString(BootSector.FATType, "FAT32 ");
}
if (fatType == FATType.FAT32)
{
bootSector.SetUInt(BootSector.FAT32_SectorPerFAT, sectorsperfat);
bootSector.SetByte(BootSector.FAT32_Flags, 0);
bootSector.SetUShort(BootSector.FAT32_Version, 0);
bootSector.SetUInt(BootSector.FAT32_ClusterNumberOfRoot, 2);
bootSector.SetUShort(BootSector.FAT32_SectorFSInformation, 1);
bootSector.SetUShort(BootSector.FAT32_SecondBootSector, 6);
//FAT32_Reserved1
bootSector.SetByte(BootSector.FAT32_PhysicalDriveNbr, 0x80);
bootSector.SetByte(BootSector.FAT32_Reserved2, 0);
bootSector.SetByte(BootSector.FAT32_ExtendedBootSignature, 0x29);
bootSector.SetBytes(BootSector.FAT32_IDSerialNumber, fatSettings.SerialID, 0, (uint)(fatSettings.SerialID.Length <= 4 ? fatSettings.SerialID.Length : 4));
bootSector.SetString(BootSector.FAT32_VolumeLabel, " "); // 12 blank spaces
bootSector.SetString(BootSector.FAT32_VolumeLabel, fatSettings.VolumeLabel, (uint)(fatSettings.VolumeLabel.Length <= 12 ? fatSettings.VolumeLabel.Length : 12));
bootSector.SetString(BootSector.FAT32_FATType, "FAT32 ");
//BootSector.OSBootCode // TODO
}
// Write Boot Sector
partition.WriteBlock(0, 1, bootSector.Data);
// Write backup Boot Sector
if (fatType == FATType.FAT32)
{
partition.WriteBlock(0, 1, bootSector.Data); // FIXME: wrong block #
}
// create FSInfo Structure
if (fatType == FATType.FAT32)
{
BinaryFormat infoSector = new BinaryFormat(512);
infoSector.SetUInt(FSInfo.FSI_LeadSignature, 0x41615252);
//FSInfo.FSI_Reserved1
infoSector.SetUInt(FSInfo.FSI_StructureSigature, 0x61417272);
infoSector.SetUInt(FSInfo.FSI_FreeCount, 0xFFFFFFFF);
infoSector.SetUInt(FSInfo.FSI_NextFree, 0xFFFFFFFF);
//FSInfo.FSI_Reserved2
bootSector.SetUInt(FSInfo.FSI_TrailSignature, 0xAA550000);
partition.WriteBlock(1, 1, infoSector.Data);
partition.WriteBlock(7, 1, infoSector.Data);
// create 2nd sector
BinaryFormat secondSector = new BinaryFormat(512);
secondSector.SetUInt((ushort)FSInfo.FSI_TrailSignature2, 0xAA55);
partition.WriteBlock(2, 1, secondSector.Data);
partition.WriteBlock(8, 1, secondSector.Data);
}
// create fats
/// TODO: incomplete
BinaryFormat emptyFat = new BinaryFormat(512);
// clear primary & secondary fats entries
for (uint i = fatStart; i < fatStart + 1; i++) //FIXME
{
partition.WriteBlock(i, 1, emptyFat.Data);
}
// first block is special
BinaryFormat firstFat = new BinaryFormat(512);
// TODO: incomplete
partition.WriteBlock(reservedSectors, 1, emptyFat.Data);
return(ReadBootSector());
}
public static void PatchSyslinux_6_03(PartitionDevice partitionDevice, FatFileSystem fat)
{
// Locate ldlinux.sys file for patching
string filename = "ldlinux.sys";
string name = (Path.GetFileNameWithoutExtension(filename) + Path.GetExtension(filename).PadRight(4).Substring(0, 4)).ToUpper();
var location = fat.FindEntry(name);
if (!location.IsValid)
{
throw new InvalidProgramException("Unable to find syslinux.sys");
}
// Get the file size & number of sectors used
uint fileSize = fat.GetFileSize(location.DirectorySector, location.DirectorySectorIndex);
var sectors = new List <uint>();
// Create list of the sectors of the file
for (uint cluster = location.FirstCluster; (cluster != 0); cluster = fat.GetNextCluster(cluster))
{
uint sec = fat.GetSectorByCluster(cluster);
for (uint i = 0; i < fat.SectorsPerCluster; i++)
{
sectors.Add(sec + i);
}
}
// Get the ldlinux.sys file stream
var ldlinux = new FatFileStream(fat, location);
var ldlinuxReader = new EndianAwareBinaryReader(ldlinux, Endianness.Little);
// Search for 0x3EB202FE (magic)
while ((ldlinuxReader.ReadUInt32() != Syslinux.LDLINUX_MAGIC) && (ldlinux.Position < ldlinux.Length))
{
;
}
if (ldlinux.Position >= ldlinux.Length || ldlinux.Position <= 0)
{
throw new InvalidProgramException("Unable to find patch location for syslinux");
}
uint patchArea = (uint)ldlinux.Position - 4;
// Get Extended Patch Area offset
ldlinux.Position = patchArea + Syslinux.PatchAreaOffset.EPAOffset;
ushort epa = ldlinuxReader.ReadUInt16();
ldlinux.Position = epa + Syslinux.ExtendedPatchAreaOffset.Sect1Ptr0;
uint sect1Ptr0 = ldlinuxReader.ReadUInt16();
ldlinux.Position = epa + Syslinux.ExtendedPatchAreaOffset.Sect1Ptr1;
uint sect1Ptr1 = ldlinuxReader.ReadUInt16();
ldlinux.Position = epa + Syslinux.ExtendedPatchAreaOffset.SecPtrOffset;
uint ex = ldlinuxReader.ReadUInt16();
ldlinux.Position = epa + Syslinux.ExtendedPatchAreaOffset.SecPtrCnt;
uint nptrs = ldlinuxReader.ReadUInt16();
ldlinux.Position = epa + Syslinux.ExtendedPatchAreaOffset.AdvPtrOffset;
uint advptrs = ldlinuxReader.ReadUInt16();
if (sectors.Count > nptrs)
{
throw new InvalidProgramException("Insufficient space for patching syslinux");
}
var ldlinuxWriter = new EndianAwareBinaryWriter(ldlinux, Endianness.Little);
// Set up the totals
ldlinux.Position = patchArea + Syslinux.PatchAreaOffset.DataSectors;
ldlinuxWriter.Write((ushort)sectors.Count);
ldlinux.Position = patchArea + Syslinux.PatchAreaOffset.DataSectors;
ldlinuxWriter.Write((ushort)2);
ldlinux.Position = patchArea + Syslinux.PatchAreaOffset.DataSectors;
ldlinuxWriter.Write(fileSize >> 2);
// Generate Extents
var extents = GenerateExtents(sectors);
ldlinux.Position = ex;
// Write out extents
foreach (var extent in extents)
{
ldlinuxWriter.Write(extent.Start);
ldlinuxWriter.Write(extent.Length);
}
// Write out ADV
ldlinux.Position = advptrs;
ldlinuxWriter.Write((ulong)sectors[sectors.Count - 2]);
ldlinuxWriter.Write((ulong)sectors[sectors.Count - 1]);
// Clear out checksum
ldlinux.Position = patchArea + Syslinux.PatchAreaOffset.Checksum;
ldlinuxWriter.Write((uint)0);
// Write back the updated cluster
ldlinuxWriter.Flush();
// Re-Calculate checksum
ldlinux.Position = 0;
uint csum = Syslinux.LDLINUX_MAGIC;
for (uint index = 0; index < (ldlinux.Length >> 2); index++)
{
csum = csum + ldlinuxReader.ReadUInt32();
}
// Set the checksum
ldlinux.Position = patchArea + Syslinux.PatchAreaOffset.Checksum;
ldlinuxWriter.Write(csum);
// Write patched cluster back to disk
ldlinuxWriter.Flush();
// Read boot sector
var fatBootSector = new BinaryFormat(partitionDevice.ReadBlock(0, 1));
// Set the first sector location of the file
fatBootSector.SetUInt(sect1Ptr0, fat.GetSectorByCluster(location.FirstCluster));
fatBootSector.SetUInt(sect1Ptr1, 0); // since only 32-bit offsets are support, the high portion of 64-bit value is zero
// Write back patched boot sector
partitionDevice.WriteBlock(0, 1, fatBootSector.Data);
}
public static void PatchSyslinux_3_72(PartitionDevice partitionDevice, FatFileSystem fat)
{
// Locate ldlinux.sys file for patching
string filename = "ldlinux.sys";
string name = (Path.GetFileNameWithoutExtension(filename) + Path.GetExtension(filename).PadRight(4).Substring(0, 4)).ToUpper();
var location = fat.FindEntry(name);
if (location.IsValid)
{
// Read boot sector
var bootSector = new BinaryFormat(partitionDevice.ReadBlock(0, 1));
// Set the first sector location of the file
bootSector.SetUInt(0x1F8, fat.GetSectorByCluster(location.FirstCluster));
// Change jump address
bootSector.SetUInt(0x01, 0x58);
// Write back patched boot sector
partitionDevice.WriteBlock(0, 1, bootSector.Data);
// Get the file size & number of sectors used
uint fileSize = fat.GetFileSize(location.DirectorySector, location.DirectorySectorIndex);
uint sectorCount = (fileSize + 511) >> 9;
uint[] sectors = new uint[65];
uint nsec = 0;
// Create list of the first 65 sectors of the file
for (uint cluster = location.FirstCluster; ((cluster != 0) & (nsec <= 64)); cluster = fat.GetNextCluster(cluster))
{
uint sec = fat.GetSectorByCluster(cluster);
for (uint s = 0; s < fat.SectorsPerCluster; s++)
{
sectors[nsec++] = sec + s;
}
}
// Read the first cluster of the file
var firstCluster = new BinaryFormat(fat.ReadCluster(location.FirstCluster));
uint patchArea = 0;
// Search for 0x3EB202FE (magic)
for (patchArea = 0; (firstCluster.GetUInt(patchArea) != 0x3EB202FE) && (patchArea < fat.ClusterSizeInBytes); patchArea += 4)
{
;
}
patchArea = patchArea + 8;
if (patchArea < fat.ClusterSizeInBytes)
{
// Set up the totals
firstCluster.SetUShort(patchArea, (ushort)(fileSize >> 2));
firstCluster.SetUShort(patchArea + 2, (ushort)(sectorCount - 1));
// Clear sector entries
firstCluster.Fill(patchArea + 8, 0, 64 * 4);
// Set sector entries
for (nsec = 0; nsec < 64; nsec++)
{
firstCluster.SetUInt(patchArea + 8 + (nsec * 4), sectors[nsec + 1]);
}
// Clear out checksum
firstCluster.SetUInt(patchArea + 4, 0);
// Write back the updated cluster
fat.WriteCluster(location.FirstCluster, firstCluster.Data);
// Re-Calculate checksum by opening the file
var file = new FatFileStream(fat, location);
uint csum = 0x3EB202FE;
for (uint index = 0; index < (file.Length >> 2); index++)
{
uint value = (uint)file.ReadByte() | ((uint)file.ReadByte() << 8) | ((uint)file.ReadByte() << 16) | ((uint)file.ReadByte() << 24);
csum -= value;
}
// Set the checksum
firstCluster.SetUInt(patchArea + 4, csum);
// Write patched cluster back to disk
fat.WriteCluster(location.FirstCluster, firstCluster.Data);
}
}
}