// /*************************************************************************** // The Disc Image Chef // ---------------------------------------------------------------------------- // // Filename : BFS.cs // Author(s) : Natalia Portillo // // Component : BeOS filesystem plugin. // // --[ Description ] ---------------------------------------------------------- // // Identifies the BeOS filesystem and shows information. // // --[ License ] -------------------------------------------------------------- // // This library is free software; you can redistribute it and/or modify // it under the terms of the GNU Lesser General Public License as // published by the Free Software Foundation; either version 2.1 of the // License, or (at your option) any later version. // // This library is distributed in the hope that it will be useful, but // WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public // License along with this library; if not, see . // // ---------------------------------------------------------------------------- // Copyright © 2011-2018 Natalia Portillo // ****************************************************************************/ using System; using System.Runtime.InteropServices; using System.Text; using DiscImageChef.CommonTypes; using DiscImageChef.CommonTypes.Interfaces; using Schemas; namespace DiscImageChef.Filesystems { // Information from Practical Filesystem Design, ISBN 1-55860-497-9 public class BeFS : IFilesystem { // Little endian constants (that is, as read by .NET :p) const uint BEFS_MAGIC1 = 0x42465331; const uint BEFS_MAGIC2 = 0xDD121031; const uint BEFS_MAGIC3 = 0x15B6830E; const uint BEFS_ENDIAN = 0x42494745; // Big endian constants const uint BEFS_CIGAM1 = 0x31534642; const uint BEFS_NAIDNE = 0x45474942; // Common constants const uint BEFS_CLEAN = 0x434C454E; const uint BEFS_DIRTY = 0x44495254; public FileSystemType XmlFsType { get; private set; } public Encoding Encoding { get; private set; } public string Name => "Be Filesystem"; public Guid Id => new Guid("dc8572b3-b6ad-46e4-8de9-cbe123ff6672"); public string Author => "Natalia Portillo"; public bool Identify(IMediaImage imagePlugin, Partition partition) { if(2 + partition.Start >= partition.End) return false; byte[] sbSector = imagePlugin.ReadSector(0 + partition.Start); uint magic = BitConverter.ToUInt32(sbSector, 0x20); uint magicBe = BigEndianBitConverter.ToUInt32(sbSector, 0x20); if(magic == BEFS_MAGIC1 || magicBe == BEFS_MAGIC1) return true; if(sbSector.Length >= 0x400) { magic = BitConverter.ToUInt32(sbSector, 0x220); magicBe = BigEndianBitConverter.ToUInt32(sbSector, 0x220); } if(magic == BEFS_MAGIC1 || magicBe == BEFS_MAGIC1) return true; sbSector = imagePlugin.ReadSector(1 + partition.Start); magic = BitConverter.ToUInt32(sbSector, 0x20); magicBe = BigEndianBitConverter.ToUInt32(sbSector, 0x20); return magic == BEFS_MAGIC1 || magicBe == BEFS_MAGIC1; } public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, Encoding encoding) { Encoding = encoding ?? Encoding.GetEncoding("iso-8859-15"); information = ""; StringBuilder sb = new StringBuilder(); BeSuperBlock besb = new BeSuperBlock(); byte[] sbSector = imagePlugin.ReadSector(0 + partition.Start); bool littleEndian; besb.magic1 = BigEndianBitConverter.ToUInt32(sbSector, 0x20); if(besb.magic1 == BEFS_MAGIC1 || besb.magic1 == BEFS_CIGAM1) // Magic is at offset littleEndian = besb.magic1 == BEFS_CIGAM1; else { sbSector = imagePlugin.ReadSector(1 + partition.Start); besb.magic1 = BigEndianBitConverter.ToUInt32(sbSector, 0x20); if(besb.magic1 == BEFS_MAGIC1 || besb.magic1 == BEFS_CIGAM1) // There is a boot sector littleEndian = besb.magic1 == BEFS_CIGAM1; else if(sbSector.Length >= 0x400) { byte[] temp = imagePlugin.ReadSector(0 + partition.Start); besb.magic1 = BigEndianBitConverter.ToUInt32(temp, 0x220); if(besb.magic1 == BEFS_MAGIC1 || besb.magic1 == BEFS_CIGAM1) // There is a boot sector { littleEndian = besb.magic1 == BEFS_CIGAM1; sbSector = new byte[0x200]; Array.Copy(temp, 0x200, sbSector, 0, 0x200); } else return; } else return; } if(littleEndian) { GCHandle handle = GCHandle.Alloc(sbSector, GCHandleType.Pinned); besb = (BeSuperBlock)Marshal.PtrToStructure(handle.AddrOfPinnedObject(), typeof(BeSuperBlock)); handle.Free(); } else besb = BigEndianMarshal.ByteArrayToStructureBigEndian(sbSector); sb.AppendLine(littleEndian ? "Little-endian BeFS" : "Big-endian BeFS"); if(besb.magic1 != BEFS_MAGIC1 || besb.fs_byte_order != BEFS_ENDIAN || besb.magic2 != BEFS_MAGIC2 || besb.magic3 != BEFS_MAGIC3 || besb.root_dir_len != 1 || besb.indices_len != 1 || 1 << (int)besb.block_shift != besb.block_size) { sb.AppendLine("Superblock seems corrupt, following information may be incorrect"); sb.AppendFormat("Magic 1: 0x{0:X8} (Should be 0x42465331)", besb.magic1).AppendLine(); sb.AppendFormat("Magic 2: 0x{0:X8} (Should be 0xDD121031)", besb.magic2).AppendLine(); sb.AppendFormat("Magic 3: 0x{0:X8} (Should be 0x15B6830E)", besb.magic3).AppendLine(); sb.AppendFormat("Filesystem endianness: 0x{0:X8} (Should be 0x42494745)", besb.fs_byte_order) .AppendLine(); sb.AppendFormat("Root folder's i-node size: {0} blocks (Should be 1)", besb.root_dir_len).AppendLine(); sb.AppendFormat("Indices' i-node size: {0} blocks (Should be 1)", besb.indices_len).AppendLine(); sb.AppendFormat("1 << block_shift == block_size => 1 << {0} == {1} (Should be {2})", besb.block_shift, 1 << (int)besb.block_shift, besb.block_size).AppendLine(); } switch(besb.flags) { case BEFS_CLEAN: sb.AppendLine(besb.log_start == besb.log_end ? "Filesystem is clean" : "Filesystem is dirty"); break; case BEFS_DIRTY: sb.AppendLine("Filesystem is dirty"); break; default: sb.AppendFormat("Unknown flags: {0:X8}", besb.flags).AppendLine(); break; } sb.AppendFormat("Volume name: {0}", StringHandlers.CToString(besb.name, Encoding)).AppendLine(); sb.AppendFormat("{0} bytes per block", besb.block_size).AppendLine(); sb.AppendFormat("{0} blocks in volume ({1} bytes)", besb.num_blocks, besb.num_blocks * besb.block_size) .AppendLine(); sb.AppendFormat("{0} used blocks ({1} bytes)", besb.used_blocks, besb.used_blocks * besb.block_size) .AppendLine(); sb.AppendFormat("{0} bytes per i-node", besb.inode_size).AppendLine(); sb.AppendFormat("{0} blocks per allocation group ({1} bytes)", besb.blocks_per_ag, besb.blocks_per_ag * besb.block_size).AppendLine(); sb.AppendFormat("{0} allocation groups in volume", besb.num_ags).AppendLine(); sb.AppendFormat("Journal resides in block {0} of allocation group {1} and runs for {2} blocks ({3} bytes)", besb.log_blocks_start, besb.log_blocks_ag, besb.log_blocks_len, besb.log_blocks_len * besb.block_size).AppendLine(); sb.AppendFormat("Journal starts in byte {0} and ends in byte {1}", besb.log_start, besb.log_end) .AppendLine(); sb .AppendFormat("Root folder's i-node resides in block {0} of allocation group {1} and runs for {2} blocks ({3} bytes)", besb.root_dir_start, besb.root_dir_ag, besb.root_dir_len, besb.root_dir_len * besb.block_size).AppendLine(); sb .AppendFormat("Indices' i-node resides in block {0} of allocation group {1} and runs for {2} blocks ({3} bytes)", besb.indices_start, besb.indices_ag, besb.indices_len, besb.indices_len * besb.block_size) .AppendLine(); information = sb.ToString(); XmlFsType = new FileSystemType { Clusters = besb.num_blocks, ClusterSize = (int)besb.block_size, Dirty = besb.flags == BEFS_DIRTY, FreeClusters = besb.num_blocks - besb.used_blocks, FreeClustersSpecified = true, Type = "BeFS", VolumeName = StringHandlers.CToString(besb.name, Encoding) }; } /// /// Be superblock /// [StructLayout(LayoutKind.Sequential, Pack = 1)] struct BeSuperBlock { /// 0x000, Volume name, 32 bytes [MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)] public byte[] name; /// 0x020, "BFS1", 0x42465331 public uint magic1; /// 0x024, "BIGE", 0x42494745 public uint fs_byte_order; /// 0x028, Bytes per block public uint block_size; /// 0x02C, 1 << block_shift == block_size public uint block_shift; /// 0x030, Blocks in volume public long num_blocks; /// 0x038, Used blocks in volume public long used_blocks; /// 0x040, Bytes per inode public int inode_size; /// 0x044, 0xDD121031 public uint magic2; /// 0x048, Blocks per allocation group public int blocks_per_ag; /// 0x04C, 1 << ag_shift == blocks_per_ag public int ag_shift; /// 0x050, Allocation groups in volume public int num_ags; /// 0x054, 0x434c454e if clean, 0x44495254 if dirty public uint flags; /// 0x058, Allocation group of journal public int log_blocks_ag; /// 0x05C, Start block of journal, inside ag public ushort log_blocks_start; /// 0x05E, Length in blocks of journal, inside ag public ushort log_blocks_len; /// 0x060, Start of journal public long log_start; /// 0x068, End of journal public long log_end; /// 0x070, 0x15B6830E public uint magic3; /// 0x074, Allocation group where root folder's i-node resides public int root_dir_ag; /// 0x078, Start in ag of root folder's i-node public ushort root_dir_start; /// 0x07A, As this is part of inode_addr, this is 1 public ushort root_dir_len; /// 0x07C, Allocation group where indices' i-node resides public int indices_ag; /// 0x080, Start in ag of indices' i-node public ushort indices_start; /// 0x082, As this is part of inode_addr, this is 1 public ushort indices_len; } } }