/// <summary> /// Sets the name of the volume. /// </summary> /// <param name="volumeName">Name of the volume.</param> public void SetVolumeName(string volumeName) { if (volumeLabel.Length > 8) volumeLabel = volumeLabel.Substring(0, 8); FatFileLocation location = FindEntry(new Find.Volume(), 0); if (!location.Valid) { location = FindEntry(new Find.Empty(), 0); if (!location.Valid) return; // TODO: something went wrong } BinaryFormat directory = new BinaryFormat(partition.ReadBlock(location.DirectorySector, 1)); if (volumeName.Length > 8) volumeName = volumeName.Substring(0, 8); // Create Entry directory.SetString(Entry.DOSName + (location.DirectorySectorIndex * Entry.EntrySize), " ", 11); directory.SetString(Entry.DOSName + (location.DirectorySectorIndex * Entry.EntrySize), volumeName); directory.SetByte(Entry.FileAttributes + (location.DirectorySectorIndex * Entry.EntrySize), (byte)FatFileAttributes.VolumeLabel); directory.SetByte(Entry.Reserved + (location.DirectorySectorIndex * Entry.EntrySize), 0); directory.SetByte(Entry.CreationTimeFine + (location.DirectorySectorIndex * Entry.EntrySize), 0); directory.SetUShort(Entry.CreationTime + (location.DirectorySectorIndex * Entry.EntrySize), 0); directory.SetUShort(Entry.CreationDate + (location.DirectorySectorIndex * Entry.EntrySize), 0); directory.SetUShort(Entry.LastAccessDate + (location.DirectorySectorIndex * Entry.EntrySize), 0); directory.SetUShort(Entry.LastModifiedTime + (location.DirectorySectorIndex * Entry.EntrySize), 0); directory.SetUShort(Entry.LastModifiedDate + (location.DirectorySectorIndex * Entry.EntrySize), 0); directory.SetUShort(Entry.FirstCluster + (location.DirectorySectorIndex * Entry.EntrySize), 0); directory.SetUInt(Entry.FileSize + (location.DirectorySectorIndex * Entry.EntrySize), 0); partition.WriteBlock(location.DirectorySector, 1, directory.Data); }
/// <summary> /// Creates the file. /// </summary> /// <param name="filename">The filename.</param> /// <param name="fileAttributes">The file attributes.</param> /// <param name="directoryCluster">The directory cluster.</param> /// <returns></returns> public FatFileLocation CreateFile(string filename, FatFileAttributes fileAttributes, uint directoryCluster) { FatFileLocation location = FindEntry(new Find.WithName(filename), directoryCluster); if (location.Valid) { // Truncate the file BinaryFormat entry = new BinaryFormat(partition.ReadBlock(location.DirectorySector, 1)); // Truncate the file length and reset the start cluster entry.SetUInt(Entry.FileSize + (location.DirectorySectorIndex * Entry.EntrySize), 0); entry.SetUInt(Entry.FirstCluster + (location.DirectorySectorIndex * Entry.EntrySize), 0); partition.WriteBlock(location.DirectorySector, 1, entry.Data); FreeClusterChain(location.FirstCluster); location.FirstCluster = 0; return location; } // Find an empty location in the directory location = FindEntry(new Find.Empty(), directoryCluster); if (!location.Valid) { // Extend Directory // TODO return location; } BinaryFormat directory = new BinaryFormat(partition.ReadBlock(location.DirectorySector, 1)); if (filename.Length > 11) filename = filename.Substring(0, 11); // Create Entry directory.SetString(Entry.DOSName + (location.DirectorySectorIndex * Entry.EntrySize), " ", 11); directory.SetString(Entry.DOSName + (location.DirectorySectorIndex * Entry.EntrySize), filename); directory.SetByte(Entry.FileAttributes + (location.DirectorySectorIndex * Entry.EntrySize), (byte)fileAttributes); directory.SetByte(Entry.Reserved + (location.DirectorySectorIndex * Entry.EntrySize), 0); directory.SetByte(Entry.CreationTimeFine + (location.DirectorySectorIndex * Entry.EntrySize), 0); directory.SetUShort(Entry.CreationTime + (location.DirectorySectorIndex * Entry.EntrySize), 0); directory.SetUShort(Entry.CreationDate + (location.DirectorySectorIndex * Entry.EntrySize), 0); directory.SetUShort(Entry.LastAccessDate + (location.DirectorySectorIndex * Entry.EntrySize), 0); directory.SetUShort(Entry.LastModifiedTime + (location.DirectorySectorIndex * Entry.EntrySize), 0); directory.SetUShort(Entry.LastModifiedDate + (location.DirectorySectorIndex * Entry.EntrySize), 0); directory.SetUShort(Entry.FirstCluster + (location.DirectorySectorIndex * Entry.EntrySize), 0); directory.SetUInt(Entry.FileSize + (location.DirectorySectorIndex * Entry.EntrySize), 0); partition.WriteBlock(location.DirectorySector, 1, directory.Data); return location; }
/// <summary> /// Formats the partition with specified fat settings. /// </summary> /// <param name="fatSettings">The fat settings.</param> /// <returns></returns> public bool Format(FatSettings fatSettings) { if (!partition.CanWrite) return false; this.fatType = fatSettings.FATType; bytesPerSector = 512; nbrFats = 2; totalSectors = partition.BlockCount; sectorsPerCluster = GetSectorsPerClusterByTotalSectors(fatType, totalSectors); if (sectorsPerCluster == 0) return false; if (fatType == FatType.FAT32) { reservedSectors = 32; rootEntries = 0; } else { reservedSectors = 1; rootEntries = 512; } rootDirSectors = (((rootEntries * 32) + (bytesPerSector - 1)) / bytesPerSector); uint val1 = totalSectors - (reservedSectors + rootDirSectors); uint val2 = (uint)((sectorsPerCluster * 256) + nbrFats); if (fatType == FatType.FAT32) val2 = val2 / 2; uint sectorsPerFat = (val1 + (val2 - 1)) / val2; firstRootDirectorySector = reservedSectors + sectorsPerFat; BinaryFormat bootSector = new BinaryFormat(512); bootSector.SetUInt(BootSector.JumpInstruction, 0); bootSector.SetString(BootSector.EOMName, "MOSA "); 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); bootSector.SetUShort(BootSector.BootSectorSignature, 0xAA55); if (totalSectors > 0xFFFF) { bootSector.SetUShort(BootSector.TotalSectors16, 0); bootSector.SetUInt(BootSector.TotalSectors32, totalSectors); } else { bootSector.SetUShort(BootSector.TotalSectors16, (ushort)totalSectors); bootSector.SetUInt(BootSector.TotalSectors32, 0); } if (fatSettings.FloppyMedia) { // Default is 1.44 bootSector.SetByte(BootSector.MediaDescriptor, 0xF0); // 0xF0 = 3.5" Double Sided, 80 tracks per side, 18 sectors per track (1.44MB). } else bootSector.SetByte(BootSector.MediaDescriptor, 0xF8); // 0xF8 = Hard disk bootSector.SetUShort(BootSector.SectorsPerTrack, fatSettings.SectorsPerTrack); bootSector.SetUShort(BootSector.NumberOfHeads, fatSettings.NumberOfHeads); bootSector.SetUInt(BootSector.HiddenSectors, fatSettings.HiddenSectors); if (fatType != FatType.FAT32) { bootSector.SetUShort(BootSector.SectorsPerFAT, (ushort)sectorsPerFat); if (fatSettings.FloppyMedia) bootSector.SetByte(BootSector.PhysicalDriveNbr, 0x00); else bootSector.SetByte(BootSector.PhysicalDriveNbr, 0x80); bootSector.SetByte(BootSector.ReservedCurrentHead, 0); bootSector.SetByte(BootSector.ExtendedBootSignature, 0x29); bootSector.SetBytes(BootSector.IDSerialNumber, fatSettings.SerialID, 0, (uint)Math.Min(4, fatSettings.SerialID.Length)); if (string.IsNullOrEmpty(fatSettings.VolumeLabel)) bootSector.SetString(BootSector.VolumeLabel, "NO NAME "); else { bootSector.SetString(BootSector.VolumeLabel, " "); // 11 blank spaces bootSector.SetString(BootSector.VolumeLabel, fatSettings.VolumeLabel, (uint)Math.Min(11, fatSettings.VolumeLabel.Length)); } if (fatSettings.OSBootCode != null) { if (fatSettings.OSBootCode.Length == 512) { bootSector.SetBytes(BootSector.JumpInstruction, fatSettings.OSBootCode, BootSector.JumpInstruction, 3); bootSector.SetBytes(BootSector.OSBootCode, fatSettings.OSBootCode, BootSector.OSBootCode, 448); } else { bootSector.SetByte(BootSector.JumpInstruction, 0xEB); // 0xEB = JMP Instruction bootSector.SetByte(BootSector.JumpInstruction + 1, 0x3C); bootSector.SetByte(BootSector.JumpInstruction + 2, 0x90); bootSector.SetBytes(BootSector.OSBootCode, fatSettings.OSBootCode, 0, (uint)Math.Min(448, fatSettings.OSBootCode.Length)); } } if (fatType == FatType.FAT12) bootSector.SetString(BootSector.FATType, "FAT12 "); else bootSector.SetString(BootSector.FATType, "FAT16 "); } if (fatType == FatType.FAT32) { bootSector.SetUShort(BootSector.SectorsPerFAT, 0); 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); 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)Math.Min(4, fatSettings.SerialID.Length)); bootSector.SetString(BootSector.FAT32_VolumeLabel, " "); // 11 blank spaces bootSector.SetString(BootSector.FAT32_VolumeLabel, fatSettings.VolumeLabel, (uint)(fatSettings.VolumeLabel.Length <= 11 ? fatSettings.VolumeLabel.Length : 11)); bootSector.SetString(BootSector.FAT32_FATType, "FAT32 "); if (fatSettings.OSBootCode.Length == 512) { bootSector.SetBytes(BootSector.JumpInstruction, fatSettings.OSBootCode, BootSector.JumpInstruction, 3); bootSector.SetBytes(BootSector.FAT32_OSBootCode, fatSettings.OSBootCode, BootSector.FAT32_OSBootCode, 420); } else { bootSector.SetByte(BootSector.JumpInstruction, 0xEB); // 0xEB = JMP Instruction bootSector.SetByte(BootSector.JumpInstruction + 1, 0x58); bootSector.SetByte(BootSector.JumpInstruction + 2, 0x90); bootSector.SetBytes(BootSector.FAT32_OSBootCode, fatSettings.OSBootCode, 0, (uint)Math.Min(420, fatSettings.OSBootCode.Length)); } } // Write Boot Sector partition.WriteBlock(0, 1, bootSector.Data); if (fatType == FatType.FAT32) { // Write backup Boot Sector if (fatType == FatType.FAT32) partition.WriteBlock(6, 1, bootSector.Data); // Create FSInfo Structure 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); // Write FSInfo Structure partition.WriteBlock(1, 1, infoSector.Data); partition.WriteBlock(7, 1, infoSector.Data); // Create 2nd sector BinaryFormat secondSector = new BinaryFormat(512); secondSector.SetUShort(FSInfo.FSI_TrailSignature2, 0xAA55); partition.WriteBlock(2, 1, secondSector.Data); partition.WriteBlock(8, 1, secondSector.Data); } // Create FAT table(s) // Clear primary & secondary FATs BinaryFormat emptyFat = new BinaryFormat(512); for (uint i = 1; i < sectorsPerFat; i++) partition.WriteBlock(reservedSectors + i, 1, emptyFat.Data); if (nbrFats == 2) for (uint i = 1; i < sectorsPerFat; i++) partition.WriteBlock(reservedSectors + sectorsPerFat + i, 1, emptyFat.Data); // First FAT block is special BinaryFormat firstFat = new BinaryFormat(512); if (fatType == FatType.FAT12) { firstFat.SetByte(1, 0xFF); firstFat.SetByte(2, 0xFF); // 0xF8 } else if (fatType == FatType.FAT16) { firstFat.SetUShort(0, 0xFFFF); firstFat.SetUShort(2, 0xFFFF); // 0xFFF8 } else // if (type == FatType.FAT32) { firstFat.SetUInt(0, 0x0FFFFFFF); firstFat.SetUInt(4, 0x0FFFFFFF); // 0x0FFFFFF8 firstFat.SetUInt(8, 0x0FFFFFFF); // Also reserve the 2nd cluster for root directory } if (fatSettings.FloppyMedia) firstFat.SetByte(0, 0xF0); else firstFat.SetByte(0, 0xF8); partition.WriteBlock(reservedSectors, 1, firstFat.Data); if (nbrFats == 2) partition.WriteBlock(reservedSectors + sectorsPerFat, 1, firstFat.Data); // Create Empty Root Directory if (fatType == FatType.FAT32) { } else { for (uint i = 0; i < rootDirSectors; i++) partition.WriteBlock(firstRootDirectorySector + i, 1, emptyFat.Data); } return ReadBootSector(); }
/// <summary> /// Sets the cluster entry value. /// </summary> /// <param name="cluster">The cluster.</param> /// <param name="nextcluster">The nextcluster.</param> /// <returns></returns> 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 = reservedSectors + (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 & 0x000F) | (nextcluster << 4)); else clustervalue = ((clustervalue & 0xF000) | (nextcluster & 0x0FFF)); fat.SetUShort(sectorOffset, (ushort)clustervalue); } else if (fatType == FatType.FAT16) fat.SetUShort(sectorOffset, (ushort)(nextcluster & 0xFFFF)); else //if (type == FatType.FAT32) fat.SetUInt(sectorOffset, nextcluster); partition.WriteBlock(sector, nbrSectors, fat.Data); return true; }
/// <summary> /// Allocates the first cluster. /// </summary> /// <param name="directorySector">The directory sector.</param> /// <param name="directorySectorIndex">Index of the directory sector.</param> /// <returns></returns> public uint AllocateFirstCluster(uint directorySector, uint directorySectorIndex) { uint newCluster = AllocateCluster(); if (newCluster == 0) return 0; // Truncate set first cluster BinaryFormat entry = new BinaryFormat(partition.ReadBlock(directorySector, 1)); entry.SetUInt(Entry.FirstCluster + (directorySectorIndex * Entry.EntrySize), newCluster); partition.WriteBlock(directorySector, 1, entry.Data); return newCluster; }
/// <summary> /// Updates the length. /// </summary> /// <param name="size">The size.</param> /// <param name="firstCluster">The first cluster.</param> /// <param name="directorySector">The directory sector.</param> /// <param name="directorySectorIndex">Index of the directory sector.</param> public void UpdateLength(uint size, uint firstCluster, uint directorySector, uint directorySectorIndex) { // Truncate the file BinaryFormat entry = new BinaryFormat(partition.ReadBlock(directorySector, 1)); // Truncate the file length and set entry.SetUInt(Entry.FileSize + (directorySectorIndex * Entry.EntrySize), size); if (size == 0) entry.SetUInt(Entry.FirstCluster + (directorySectorIndex * Entry.EntrySize), 0); partition.WriteBlock(directorySector, 1, entry.Data); if (size == 0) FreeClusterChain(firstCluster); }
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(new Mosa.FileSystem.FAT.Find.WithName(name), 0); 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); } } }
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(new Mosa.FileSystem.FAT.Find.WithName(name), 0); 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 = (uint)ldlinuxReader.ReadUInt16(); ldlinux.Position = epa + Syslinux.ExtendedPatchAreaOffset.Sect1Ptr1; uint sect1Ptr1 = (uint)ldlinuxReader.ReadUInt16(); ldlinux.Position = epa + Syslinux.ExtendedPatchAreaOffset.SecPtrOffset; uint ex = (uint)ldlinuxReader.ReadUInt16(); ldlinux.Position = epa + Syslinux.ExtendedPatchAreaOffset.SecPtrCnt; uint nptrs = (uint)ldlinuxReader.ReadUInt16(); ldlinux.Position = epa + Syslinux.ExtendedPatchAreaOffset.AdvPtrOffset; uint advptrs = (uint)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((uint)fileSize >> 2); // Generate Extents var extents = GenerateExtents(sectors); ldlinux.Position = ex; // Write out extents foreach (var extent in extents) { ldlinuxWriter.Write((ulong)extent.Start); ldlinuxWriter.Write((ushort)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); }
/// <summary> /// Identifies the drive. /// </summary> protected void IdentifyDrive() { byte drive = (byte)(((deviceHead & 0x10) != 0x10) ? 0 : 1); byte d = (byte)('0' + drive + 1); BinaryFormat data = new BinaryFormat(bufferData); data.Fill(0, 0, 512); // fixed drive and over 5Mb/sec data.SetUShort(0x00, 0x140); // Serial Number data.Fill(0x0A * 2, d, 20); data.SetByte(0x0A * 2, d); // Firmware version data.Fill(0x17 * 2, d, 8); data.SetChar(0x17 * 2 + 0, '1'); data.SetChar(0x17 * 2 + 1, '.'); data.SetChar(0x17 * 2 + 2, '0'); // Model Number data.Fill(0x1B * 2, d, 40); data.SetChar(0x17 * 2 + 0, 'D'); data.SetChar(0x17 * 2 + 1, 'R'); data.SetChar(0x17 * 2 + 2, 'I'); data.SetChar(0x17 * 2 + 3, 'V'); data.SetChar(0x17 * 2 + 4, 'E'); data.SetByte(0x1B * 2 + 5, d); // lba28 data.SetUInt(0x3C * 2, (uint)(driveFiles[drive].Length / 512)); commandStatus = (byte)((commandStatus | 0x08) & ~0x80); // Set DRQ (bit 3), clear BUSY (bit 7) status = DeviceStatus.IdentifyDrive; }
/// <summary> /// Writes the master boot block. /// </summary> /// <returns></returns> public bool Write() { if (!diskDevice.CanWrite) { return false; } BinaryFormat masterboot = new BinaryFormat(new byte[512]); masterboot.SetUInt(MBR.DiskSignature, diskSignature); masterboot.SetUShort(MBR.MBRSignature, MBRConstant.MBRSignature); if (code != null) for (uint index = 0; ((index < MBRConstant.CodeAreaSize) && (index < code.Length)); index++) masterboot.SetByte(index, code[index]); for (uint index = 0; index < MaxMBRPartitions; index++) if (Partitions[index].TotalBlocks != 0) { uint offset = MBR.FirstPartition + (index * 16); masterboot.SetByte(offset + PartitionRecord.Status, (byte)(Partitions[index].Bootable ? 0x80 : 0x00)); masterboot.SetByte(offset + PartitionRecord.PartitionType, Partitions[index].PartitionType); masterboot.SetUInt(offset + PartitionRecord.LBA, Partitions[index].StartLBA); masterboot.SetUInt(offset + PartitionRecord.Sectors, Partitions[index].TotalBlocks); DiskGeometry diskGeometry = new DiskGeometry(); diskGeometry.GuessGeometry(diskDevice.TotalBlocks); CHS chsStart = new CHS(); CHS chsEnd = new CHS(); chsStart.SetCHS(diskGeometry, Partitions[index].StartLBA); chsEnd.SetCHS(diskGeometry, Partitions[index].StartLBA + Partitions[index].TotalBlocks - 1); masterboot.SetByte(offset + PartitionRecord.FirstCRS, chsStart.Head); masterboot.SetByte(offset + PartitionRecord.FirstCRS + 1, (byte)((chsStart.Sector & 0x3F) | ((chsStart.Cylinder >> 8) & 0x03))); masterboot.SetByte(offset + PartitionRecord.FirstCRS + 2, (byte)(chsStart.Cylinder & 0xFF)); masterboot.SetByte(offset + PartitionRecord.LastCRS, chsEnd.Head); masterboot.SetByte(offset + PartitionRecord.LastCRS + 1, (byte)((chsEnd.Sector & 0x3F) | ((chsEnd.Cylinder >> 8) & 0x03))); masterboot.SetByte(offset + PartitionRecord.LastCRS + 2, (byte)(chsEnd.Cylinder & 0xFF)); } diskDevice.WriteBlock(0, 1, masterboot.Data); return true; }