public bool Identify(IMediaImage imagePlugin, Partition partition) { if (2 + partition.Start >= partition.End) { return(false); } byte[] eigthBytes = new byte[8]; byte[] ntfsBpb = imagePlugin.ReadSector(0 + partition.Start); Array.Copy(ntfsBpb, 0x003, eigthBytes, 0, 8); string oemName = StringHandlers.CToString(eigthBytes); if (oemName != "NTFS ") { return(false); } byte fatsNo = ntfsBpb[0x010]; ushort spFat = BitConverter.ToUInt16(ntfsBpb, 0x016); ushort signature = BitConverter.ToUInt16(ntfsBpb, 0x1FE); if (fatsNo != 0) { return(false); } if (spFat != 0) { return(false); } return(signature == 0xAA55); }
static DecodedVolumeDescriptor DecodeVolumeDescriptor(PrimaryVolumeDescriptor pvd) { var decodedVd = new DecodedVolumeDescriptor { SystemIdentifier = StringHandlers.CToString(pvd.system_id).TrimEnd(), VolumeIdentifier = StringHandlers.CToString(pvd.volume_id).TrimEnd(), VolumeSetIdentifier = StringHandlers.CToString(pvd.volume_set_id).TrimEnd(), PublisherIdentifier = StringHandlers.CToString(pvd.publisher_id).TrimEnd(), DataPreparerIdentifier = StringHandlers.CToString(pvd.preparer_id).TrimEnd(), ApplicationIdentifier = StringHandlers.CToString(pvd.application_id).TrimEnd() }; if (pvd.creation_date[0] == '0' || pvd.creation_date[0] == 0x00) { decodedVd.CreationTime = DateTime.MinValue; } else { decodedVd.CreationTime = DateHandlers.Iso9660ToDateTime(pvd.creation_date); } if (pvd.modification_date[0] == '0' || pvd.modification_date[0] == 0x00) { decodedVd.HasModificationTime = false; } else { decodedVd.HasModificationTime = true; decodedVd.ModificationTime = DateHandlers.Iso9660ToDateTime(pvd.modification_date); } if (pvd.expiration_date[0] == '0' || pvd.expiration_date[0] == 0x00) { decodedVd.HasExpirationTime = false; } else { decodedVd.HasExpirationTime = true; decodedVd.ExpirationTime = DateHandlers.Iso9660ToDateTime(pvd.expiration_date); } if (pvd.effective_date[0] == '0' || pvd.effective_date[0] == 0x00) { decodedVd.HasEffectiveTime = false; } else { decodedVd.HasEffectiveTime = true; decodedVd.EffectiveTime = DateHandlers.Iso9660ToDateTime(pvd.effective_date); } decodedVd.Blocks = pvd.volume_space_size; decodedVd.BlockSize = pvd.logical_block_size; return(decodedVd); }
public static string PrettifyHPModePage_3B(HP_ModePage_3B?modePage) { if (!modePage.HasValue) { return(null); } HP_ModePage_3B page = modePage.Value; StringBuilder sb = new StringBuilder(); sb.AppendLine("HP Serial Number Override Mode Page:"); if (page.PS) { sb.AppendLine("\tParameters can be saved"); } switch (page.MSN) { case 1: sb.AppendLine("\tSerial number is the manufacturer's default value"); break; case 3: sb.AppendLine("\tSerial number is not the manufacturer's default value"); break; } sb.AppendFormat("\tSerial number: {0}", StringHandlers.CToString(page.SerialNumber)).AppendLine(); return(sb.ToString()); }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, Encoding encoding) { // Technically everything on Plan 9 from Bell Labs is in UTF-8 Encoding = Encoding.UTF8; information = ""; if (imagePlugin.Info.SectorSize < 512) { return; } ulong hdrSector = HEADER_POS / imagePlugin.Info.SectorSize; byte[] sector = imagePlugin.ReadSector(partition.Start + hdrSector); FossilHeader hdr = Marshal.ByteArrayToStructureBigEndian <FossilHeader>(sector); DicConsole.DebugWriteLine("Fossil plugin", "magic at 0x{0:X8} (expected 0x{1:X8})", hdr.magic, FOSSIL_HDR_MAGIC); StringBuilder sb = new StringBuilder(); sb.AppendLine("Fossil"); sb.AppendFormat("Filesystem version {0}", hdr.version).AppendLine(); sb.AppendFormat("{0} bytes per block", hdr.blockSize).AppendLine(); sb.AppendFormat("Superblock resides in block {0}", hdr.super).AppendLine(); sb.AppendFormat("Labels resides in block {0}", hdr.label).AppendLine(); sb.AppendFormat("Data starts at block {0}", hdr.data).AppendLine(); sb.AppendFormat("Volume has {0} blocks", hdr.end).AppendLine(); ulong sbLocation = hdr.super * (hdr.blockSize / imagePlugin.Info.SectorSize) + partition.Start; XmlFsType = new FileSystemType { Type = "Fossil filesystem", ClusterSize = hdr.blockSize, Clusters = hdr.end }; if (sbLocation <= partition.End) { sector = imagePlugin.ReadSector(sbLocation); FossilSuperBlock fsb = Marshal.ByteArrayToStructureBigEndian <FossilSuperBlock>(sector); DicConsole.DebugWriteLine("Fossil plugin", "magic 0x{0:X8} (expected 0x{1:X8})", fsb.magic, FOSSIL_SB_MAGIC); if (fsb.magic == FOSSIL_SB_MAGIC) { sb.AppendFormat("Epoch low {0}", fsb.epochLow).AppendLine(); sb.AppendFormat("Epoch high {0}", fsb.epochHigh).AppendLine(); sb.AppendFormat("Next QID {0}", fsb.qid).AppendLine(); sb.AppendFormat("Active root block {0}", fsb.active).AppendLine(); sb.AppendFormat("Next root block {0}", fsb.next).AppendLine(); sb.AppendFormat("Curren root block {0}", fsb.current).AppendLine(); sb.AppendFormat("Volume label: \"{0}\"", StringHandlers.CToString(fsb.name, Encoding)).AppendLine(); XmlFsType.VolumeName = StringHandlers.CToString(fsb.name, Encoding); } } information = sb.ToString(); }
public bool Identify(IFilter imageFilter) { Stream stream = imageFilter.GetDataForkStream(); if ((stream.Length - Marshal.SizeOf <DriFooter>()) % 512 != 0) { return(false); } byte[] buffer = new byte[Marshal.SizeOf <DriFooter>()]; stream.Seek(-buffer.Length, SeekOrigin.End); stream.Read(buffer, 0, buffer.Length); DriFooter tmpFooter = Marshal.ByteArrayToStructureLittleEndian <DriFooter>(buffer); string sig = StringHandlers.CToString(tmpFooter.signature); DicConsole.DebugWriteLine("DRI DiskCopy plugin", "tmp_footer.signature = \"{0}\"", sig); DicConsole.DebugWriteLine("DRI DiskCopy plugin", "tmp_footer.bpb.five = {0}", tmpFooter.bpb.five); DicConsole.DebugWriteLine("DRI DiskCopy plugin", "tmp_footer.bpb.driveCode = {0}", tmpFooter.bpb.driveCode); DicConsole.DebugWriteLine("DRI DiskCopy plugin", "tmp_footer.bpb.unknown = {0}", tmpFooter.bpb.unknown); DicConsole.DebugWriteLine("DRI DiskCopy plugin", "tmp_footer.bpb.cylinders = {0}", tmpFooter.bpb.cylinders); DicConsole.DebugWriteLine("DRI DiskCopy plugin", "tmp_footer.bpb.unknown2 = {0}", tmpFooter.bpb.unknown2); DicConsole.DebugWriteLine("DRI DiskCopy plugin", "tmp_footer.bpb.bps = {0}", tmpFooter.bpb.bps); DicConsole.DebugWriteLine("DRI DiskCopy plugin", "tmp_footer.bpb.spc = {0}", tmpFooter.bpb.spc); DicConsole.DebugWriteLine("DRI DiskCopy plugin", "tmp_footer.bpb.rsectors = {0}", tmpFooter.bpb.rsectors); DicConsole.DebugWriteLine("DRI DiskCopy plugin", "tmp_footer.bpb.fats_no = {0}", tmpFooter.bpb.fats_no); DicConsole.DebugWriteLine("DRI DiskCopy plugin", "tmp_footer.bpb.sectors = {0}", tmpFooter.bpb.sectors); DicConsole.DebugWriteLine("DRI DiskCopy plugin", "tmp_footer.bpb.media_descriptor = {0}", tmpFooter.bpb.media_descriptor); DicConsole.DebugWriteLine("DRI DiskCopy plugin", "tmp_footer.bpb.spfat = {0}", tmpFooter.bpb.spfat); DicConsole.DebugWriteLine("DRI DiskCopy plugin", "tmp_footer.bpb.sptrack = {0}", tmpFooter.bpb.sptrack); DicConsole.DebugWriteLine("DRI DiskCopy plugin", "tmp_footer.bpb.heads = {0}", tmpFooter.bpb.heads); DicConsole.DebugWriteLine("DRI DiskCopy plugin", "tmp_footer.bpb.hsectors = {0}", tmpFooter.bpb.hsectors); DicConsole.DebugWriteLine("DRI DiskCopy plugin", "tmp_footer.bpb.drive_no = {0}", tmpFooter.bpb.drive_no); DicConsole.DebugWriteLine("DRI DiskCopy plugin", "tmp_footer.bpb.unknown3 = {0}", tmpFooter.bpb.unknown3); DicConsole.DebugWriteLine("DRI DiskCopy plugin", "tmp_footer.bpb.unknown4 = {0}", tmpFooter.bpb.unknown4); DicConsole.DebugWriteLine("DRI DiskCopy plugin", "tmp_footer.bpb.sptrack2 = {0}", tmpFooter.bpb.sptrack2); DicConsole.DebugWriteLine("DRI DiskCopy plugin", "ArrayHelpers.ArrayIsNullOrEmpty(tmp_footer.bpb.unknown5) = {0}", ArrayHelpers.ArrayIsNullOrEmpty(tmpFooter.bpb.unknown5)); Regex regexSignature = new Regex(REGEX_DRI); Match matchSignature = regexSignature.Match(sig); DicConsole.DebugWriteLine("DRI DiskCopy plugin", "MatchSignature.Success? = {0}", matchSignature.Success); if (!matchSignature.Success) { return(false); } if (tmpFooter.bpb.sptrack * tmpFooter.bpb.cylinders * tmpFooter.bpb.heads != tmpFooter.bpb.sectors) { return(false); } return(tmpFooter.bpb.sectors * tmpFooter.bpb.bps + Marshal.SizeOf <DriFooter>() == stream.Length); }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, Encoding encoding) { // Always Shift-JIS Encoding = Encoding.GetEncoding("shift_jis"); information = ""; byte[] sector = imagePlugin.ReadSectors(partition.Start, 2); PcfxHeader header = Marshal.ByteArrayToStructureLittleEndian <PcfxHeader>(sector); string date; DateTime dateTime = DateTime.MinValue; try { date = Encoding.GetString(header.date); int year = int.Parse(date.Substring(0, 4)); int month = int.Parse(date.Substring(4, 2)); int day = int.Parse(date.Substring(6, 2)); dateTime = new DateTime(year, month, day); } catch { date = null; } var sb = new StringBuilder(); sb.AppendLine("PC-FX executable:"); sb.AppendFormat("Identifier: {0}", StringHandlers.CToString(header.signature, Encoding)).AppendLine(); sb.AppendFormat("Copyright: {0}", StringHandlers.CToString(header.copyright, Encoding)).AppendLine(); sb.AppendFormat("Title: {0}", StringHandlers.CToString(header.title, Encoding)).AppendLine(); sb.AppendFormat("Maker ID: {0}", StringHandlers.CToString(header.makerId, Encoding)).AppendLine(); sb.AppendFormat("Maker name: {0}", StringHandlers.CToString(header.makerName, Encoding)).AppendLine(); sb.AppendFormat("Volume number: {0}", header.volumeNumber).AppendLine(); sb.AppendFormat("Country code: {0}", header.country).AppendLine(); sb.AppendFormat("Version: {0}.{1}", header.minorVersion, header.majorVersion).AppendLine(); if (date != null) { sb.AppendFormat("Dated {0}", dateTime).AppendLine(); } sb.AppendFormat("Load {0} sectors from sector {1}", header.loadCount, header.loadOffset).AppendLine(); sb.AppendFormat("Load at 0x{0:X8} and jump to 0x{1:X8}", header.loadAddress, header.entryPoint). AppendLine(); information = sb.ToString(); XmlFsType = new FileSystemType { Type = "PC-FX", Clusters = partition.Length, ClusterSize = 2048, Bootable = true, CreationDate = dateTime, CreationDateSpecified = date != null, PublisherIdentifier = StringHandlers.CToString(header.makerName, Encoding), VolumeName = StringHandlers.CToString(header.title, Encoding), SystemIdentifier = "PC-FX" }; }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, Encoding encoding) { Encoding = encoding ?? Encoding.GetEncoding("iso-8859-15"); information = ""; if (imagePlugin.Info.SectorSize < 512) { return; } uint sbAddr = REISER4_SUPER_OFFSET / imagePlugin.Info.SectorSize; if (sbAddr == 0) { sbAddr = 1; } uint sbSize = (uint)(Marshal.SizeOf <Superblock>() / imagePlugin.Info.SectorSize); if (Marshal.SizeOf <Superblock>() % imagePlugin.Info.SectorSize != 0) { sbSize++; } byte[] sector = imagePlugin.ReadSectors(partition.Start + sbAddr, sbSize); if (sector.Length < Marshal.SizeOf <Superblock>()) { return; } Superblock reiserSb = Marshal.ByteArrayToStructureLittleEndian <Superblock>(sector); if (!_magic.SequenceEqual(reiserSb.magic)) { return; } var sb = new StringBuilder(); sb.AppendLine("Reiser 4 filesystem"); sb.AppendFormat("{0} bytes per block", reiserSb.blocksize).AppendLine(); sb.AppendFormat("Volume disk format: {0}", reiserSb.diskformat).AppendLine(); sb.AppendFormat("Volume UUID: {0}", reiserSb.uuid).AppendLine(); sb.AppendFormat("Volume name: {0}", StringHandlers.CToString(reiserSb.label, Encoding)).AppendLine(); information = sb.ToString(); XmlFsType = new FileSystemType { Type = "Reiser 4 filesystem", ClusterSize = reiserSb.blocksize, Clusters = ((partition.End - partition.Start) * imagePlugin.Info.SectorSize) / reiserSb.blocksize, VolumeName = StringHandlers.CToString(reiserSb.label, Encoding), VolumeSerial = reiserSb.uuid.ToString() }; }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, Encoding encoding) { Encoding = new PETSCII(); byte[] sector; StringBuilder sbInformation = new StringBuilder(); sbInformation.AppendLine("Commodore file system"); XmlFsType = new FileSystemType { Type = "Commodore file system", Clusters = imagePlugin.Info.Sectors, ClusterSize = 256 }; if (imagePlugin.Info.Sectors == 3200) { sector = imagePlugin.ReadSector(1560); CommodoreHeader cbmHdr = Marshal.ByteArrayToStructureLittleEndian <CommodoreHeader>(sector); sbInformation.AppendFormat("Directory starts at track {0} sector {1}", cbmHdr.directoryTrack, cbmHdr.directorySector).AppendLine(); sbInformation .AppendFormat("Disk DOS Version: {0}", Encoding.ASCII.GetString(new[] { cbmHdr.diskDosVersion })) .AppendLine(); sbInformation.AppendFormat("DOS Version: {0}", Encoding.ASCII.GetString(new[] { cbmHdr.dosVersion })) .AppendLine(); sbInformation.AppendFormat("Disk Version: {0}", Encoding.ASCII.GetString(new[] { cbmHdr.diskVersion })) .AppendLine(); sbInformation.AppendFormat("Disk ID: {0}", cbmHdr.diskId).AppendLine(); sbInformation.AppendFormat("Disk name: {0}", StringHandlers.CToString(cbmHdr.name, Encoding)) .AppendLine(); XmlFsType.VolumeName = StringHandlers.CToString(cbmHdr.name, Encoding); XmlFsType.VolumeSerial = $"{cbmHdr.diskId}"; } else { sector = imagePlugin.ReadSector(357); CommodoreBam cbmBam = Marshal.ByteArrayToStructureLittleEndian <CommodoreBam>(sector); sbInformation.AppendFormat("Directory starts at track {0} sector {1}", cbmBam.directoryTrack, cbmBam.directorySector).AppendLine(); sbInformation.AppendFormat("Disk DOS type: {0}", Encoding.ASCII.GetString(BitConverter.GetBytes(cbmBam.dosType))) .AppendLine(); sbInformation.AppendFormat("DOS Version: {0}", Encoding.ASCII.GetString(new[] { cbmBam.dosVersion })) .AppendLine(); sbInformation.AppendFormat("Disk ID: {0}", cbmBam.diskId).AppendLine(); sbInformation.AppendFormat("Disk name: {0}", StringHandlers.CToString(cbmBam.name, Encoding)) .AppendLine(); XmlFsType.VolumeName = StringHandlers.CToString(cbmBam.name, Encoding); XmlFsType.VolumeSerial = $"{cbmBam.diskId}"; } information = sbInformation.ToString(); }
Errno ReadDir(short dirId, out List <string> contents) { // Do same trick as Mac OS X, replace filesystem '/' with '-', // as '-' is the path separator in Lisa OS contents = (from entry in _catalogCache where entry.parentID == dirId select StringHandlers.CToString(entry.filename, Encoding).Replace('/', '-')).ToList(); return(Errno.NoError); }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, Encoding encoding) { Encoding = encoding ?? Encoding.GetEncoding("iso-8859-15"); information = ""; var sb = new StringBuilder(); byte[] bfsSbSector = imagePlugin.ReadSector(0 + partition.Start); byte[] sbStrings = new byte[6]; var bfsSb = new SuperBlock { s_magic = BitConverter.ToUInt32(bfsSbSector, 0x00), s_start = BitConverter.ToUInt32(bfsSbSector, 0x04), s_end = BitConverter.ToUInt32(bfsSbSector, 0x08), s_from = BitConverter.ToUInt32(bfsSbSector, 0x0C), s_to = BitConverter.ToUInt32(bfsSbSector, 0x10), s_bfrom = BitConverter.ToInt32(bfsSbSector, 0x14), s_bto = BitConverter.ToInt32(bfsSbSector, 0x18) }; Array.Copy(bfsSbSector, 0x1C, sbStrings, 0, 6); bfsSb.s_fsname = StringHandlers.CToString(sbStrings, Encoding); Array.Copy(bfsSbSector, 0x22, sbStrings, 0, 6); bfsSb.s_volume = StringHandlers.CToString(sbStrings, Encoding); AaruConsole.DebugWriteLine("BFS plugin", "bfs_sb.s_magic: 0x{0:X8}", bfsSb.s_magic); AaruConsole.DebugWriteLine("BFS plugin", "bfs_sb.s_start: 0x{0:X8}", bfsSb.s_start); AaruConsole.DebugWriteLine("BFS plugin", "bfs_sb.s_end: 0x{0:X8}", bfsSb.s_end); AaruConsole.DebugWriteLine("BFS plugin", "bfs_sb.s_from: 0x{0:X8}", bfsSb.s_from); AaruConsole.DebugWriteLine("BFS plugin", "bfs_sb.s_to: 0x{0:X8}", bfsSb.s_to); AaruConsole.DebugWriteLine("BFS plugin", "bfs_sb.s_bfrom: 0x{0:X8}", bfsSb.s_bfrom); AaruConsole.DebugWriteLine("BFS plugin", "bfs_sb.s_bto: 0x{0:X8}", bfsSb.s_bto); AaruConsole.DebugWriteLine("BFS plugin", "bfs_sb.s_fsname: 0x{0}", bfsSb.s_fsname); AaruConsole.DebugWriteLine("BFS plugin", "bfs_sb.s_volume: 0x{0}", bfsSb.s_volume); sb.AppendLine("UNIX Boot filesystem"); sb.AppendFormat("Volume goes from byte {0} to byte {1}, for {2} bytes", bfsSb.s_start, bfsSb.s_end, bfsSb.s_end - bfsSb.s_start).AppendLine(); sb.AppendFormat("Filesystem name: {0}", bfsSb.s_fsname).AppendLine(); sb.AppendFormat("Volume name: {0}", bfsSb.s_volume).AppendLine(); XmlFsType = new FileSystemType { Type = "BFS", VolumeName = bfsSb.s_volume, ClusterSize = imagePlugin.Info.SectorSize, Clusters = (partition.End - partition.Start) + 1 }; information = sb.ToString(); }
Dictionary <string, DirectoryEntryWithPointers> DecodeDirectory(int firstBlock) { Dictionary <string, DirectoryEntryWithPointers> entries = new Dictionary <string, DirectoryEntryWithPointers>(); int nextBlock = firstBlock; DirectoryHeader header; do { byte[] data = _image.ReadSectors((ulong)(nextBlock * _volumeBlockSizeRatio), _volumeBlockSizeRatio); header = Marshal.ByteArrayToStructureBigEndian <DirectoryHeader>(data); nextBlock = header.next_block + firstBlock; int off = (int)header.first_used; var entry = new DirectoryEntry(); while (off + _directoryEntrySize < data.Length) { entry = Marshal.ByteArrayToStructureBigEndian <DirectoryEntry>(data, off, _directoryEntrySize); string name = StringHandlers.CToString(entry.name, Encoding); var entryWithPointers = new DirectoryEntryWithPointers { entry = entry, pointers = new uint[entry.last_copy + 1] }; for (int i = 0; i <= entry.last_copy; i++) { entryWithPointers.pointers[i] = BigEndianBitConverter.ToUInt32(data, off + _directoryEntrySize + (i * 4)); } entries.Add(name, entryWithPointers); if ((entry.flags & (uint)FileFlags.LastEntry) != 0 || (entry.flags & (uint)FileFlags.LastEntryInBlock) != 0) { break; } off += (int)(_directoryEntrySize + ((entry.last_copy + 1) * 4)); } if ((entry.flags & (uint)FileFlags.LastEntry) != 0) { break; } } while(header.next_block != -1); return(entries); }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, Encoding encoding) { Encoding = encoding ?? Encoding.UTF8; ulong vmfsSuperOff = VXFS_BASE / imagePlugin.Info.SectorSize; byte[] sector = imagePlugin.ReadSector(partition.Start + vmfsSuperOff); SuperBlock vxSb = Marshal.ByteArrayToStructureLittleEndian <SuperBlock>(sector); var sbInformation = new StringBuilder(); sbInformation.AppendLine("Veritas file system"); sbInformation.AppendFormat("Volume version {0}", vxSb.vs_version).AppendLine(); sbInformation.AppendFormat("Volume name {0}", StringHandlers.CToString(vxSb.vs_fname, Encoding)). AppendLine(); sbInformation.AppendFormat("Volume has {0} blocks of {1} bytes each", vxSb.vs_bsize, vxSb.vs_size). AppendLine(); sbInformation.AppendFormat("Volume has {0} inodes per block", vxSb.vs_inopb).AppendLine(); sbInformation.AppendFormat("Volume has {0} free inodes", vxSb.vs_ifree).AppendLine(); sbInformation.AppendFormat("Volume has {0} free blocks", vxSb.vs_free).AppendLine(); sbInformation.AppendFormat("Volume created on {0}", DateHandlers.UnixUnsignedToDateTime(vxSb.vs_ctime, vxSb.vs_cutime)).AppendLine(); sbInformation.AppendFormat("Volume last modified on {0}", DateHandlers.UnixUnsignedToDateTime(vxSb.vs_wtime, vxSb.vs_wutime)).AppendLine(); if (vxSb.vs_clean != 0) { sbInformation.AppendLine("Volume is dirty"); } information = sbInformation.ToString(); XmlFsType = new FileSystemType { Type = "Veritas file system", CreationDate = DateHandlers.UnixUnsignedToDateTime(vxSb.vs_ctime, vxSb.vs_cutime), CreationDateSpecified = true, ModificationDate = DateHandlers.UnixUnsignedToDateTime(vxSb.vs_wtime, vxSb.vs_wutime), ModificationDateSpecified = true, Clusters = (ulong)vxSb.vs_size, ClusterSize = (uint)vxSb.vs_bsize, Dirty = vxSb.vs_clean != 0, FreeClusters = (ulong)vxSb.vs_free, FreeClustersSpecified = true }; }
public void Update(byte[] data, bool bigEndian) { VersionInfo versionInfo = bigEndian ? BigEndianMarshal.ByteArrayToStructureBigEndian <VersionInfo>(data) : BigEndianMarshal.ByteArrayToStructureLittleEndian <VersionInfo>(data); txtMajorVersion.Text = $"{versionInfo.major}"; txtMiddleVersion.Text = $"{versionInfo.middle}"; txtMinorVersion.Text = $"{versionInfo.minor}"; txtVariety.Text = $"{versionInfo.variety}"; txtInternal.Text = $"{versionInfo.interna1}"; txtShortInfo.Text = StringHandlers.CToString(versionInfo.short_info, Encoding.UTF8); txtLongInfo.Text = StringHandlers.CToString(versionInfo.long_info, Encoding.UTF8); }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, Encoding encoding) { Encoding = encoding ?? Encoding.UTF8; ulong vmfsSuperOff = VMFS_BASE / imagePlugin.Info.SectorSize; byte[] sector = imagePlugin.ReadSector(partition.Start + vmfsSuperOff); VolumeInfo volInfo = new VolumeInfo(); IntPtr volInfoPtr = Marshal.AllocHGlobal(Marshal.SizeOf(volInfo)); Marshal.Copy(sector, 0, volInfoPtr, Marshal.SizeOf(volInfo)); volInfo = (VolumeInfo)Marshal.PtrToStructure(volInfoPtr, typeof(VolumeInfo)); Marshal.FreeHGlobal(volInfoPtr); StringBuilder sbInformation = new StringBuilder(); sbInformation.AppendLine("VMware file system"); uint ctimeSecs = (uint)(volInfo.ctime / 1000000); uint ctimeNanoSecs = (uint)(volInfo.ctime % 1000000); uint mtimeSecs = (uint)(volInfo.mtime / 1000000); uint mtimeNanoSecs = (uint)(volInfo.mtime % 1000000); sbInformation.AppendFormat("Volume version {0}", volInfo.version).AppendLine(); sbInformation.AppendFormat("Volume name {0}", StringHandlers.CToString(volInfo.name, Encoding)) .AppendLine(); sbInformation.AppendFormat("Volume size {0} bytes", volInfo.size * 256).AppendLine(); sbInformation.AppendFormat("Volume UUID {0}", volInfo.uuid).AppendLine(); sbInformation .AppendFormat("Volume created on {0}", DateHandlers.UnixUnsignedToDateTime(ctimeSecs, ctimeNanoSecs)) .AppendLine(); sbInformation.AppendFormat("Volume last modified on {0}", DateHandlers.UnixUnsignedToDateTime(mtimeSecs, mtimeNanoSecs)).AppendLine(); information = sbInformation.ToString(); XmlFsType = new FileSystemType { Type = "VMware file system", CreationDate = DateHandlers.UnixUnsignedToDateTime(ctimeSecs, ctimeNanoSecs), CreationDateSpecified = true, ModificationDate = DateHandlers.UnixUnsignedToDateTime(mtimeSecs, mtimeNanoSecs), ModificationDateSpecified = true, Clusters = volInfo.size * 256 / imagePlugin.Info.SectorSize, ClusterSize = (int)imagePlugin.Info.SectorSize, VolumeSerial = volInfo.uuid.ToString() }; }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, Encoding encoding) { Encoding = encoding ?? Encoding.GetEncoding("iso-8859-15"); byte[] sector = imagePlugin.ReadSector(partition.Start); uint magic = BitConverter.ToUInt32(sector, 0x00); CramSuperBlock crSb = new CramSuperBlock(); bool littleEndian = true; switch (magic) { case CRAM_MAGIC: IntPtr crSbPtr = Marshal.AllocHGlobal(Marshal.SizeOf(crSb)); Marshal.Copy(sector, 0, crSbPtr, Marshal.SizeOf(crSb)); crSb = (CramSuperBlock)Marshal.PtrToStructure(crSbPtr, typeof(CramSuperBlock)); Marshal.FreeHGlobal(crSbPtr); break; case CRAM_CIGAM: crSb = BigEndianMarshal.ByteArrayToStructureBigEndian <CramSuperBlock>(sector); littleEndian = false; break; } StringBuilder sbInformation = new StringBuilder(); sbInformation.AppendLine("Cram file system"); sbInformation.AppendLine(littleEndian ? "Little-endian" : "Big-endian"); sbInformation.AppendFormat("Volume edition {0}", crSb.edition).AppendLine(); sbInformation.AppendFormat("Volume name: {0}", StringHandlers.CToString(crSb.name, Encoding)).AppendLine(); sbInformation.AppendFormat("Volume has {0} bytes", crSb.size).AppendLine(); sbInformation.AppendFormat("Volume has {0} blocks", crSb.blocks).AppendLine(); sbInformation.AppendFormat("Volume has {0} files", crSb.files).AppendLine(); information = sbInformation.ToString(); XmlFsType = new FileSystemType { VolumeName = StringHandlers.CToString(crSb.name, Encoding), Type = "Cram file system", Clusters = crSb.blocks, Files = crSb.files, FilesSpecified = true, FreeClusters = 0, FreeClustersSpecified = true }; }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, Encoding encoding) { Encoding = encoding ?? Encoding.GetEncoding("iso-8859-15"); information = ""; if (imagePlugin.Info.SectorSize < 256) { return; } byte[] sector = imagePlugin.ReadSector(partition.Start); SystemBlock lifSb = Marshal.ByteArrayToStructureBigEndian <SystemBlock>(sector); if (lifSb.magic != LIF_MAGIC) { return; } var sb = new StringBuilder(); sb.AppendLine("HP Logical Interchange Format"); sb.AppendFormat("Directory starts at cluster {0}", lifSb.directoryStart).AppendLine(); sb.AppendFormat("LIF identifier: {0}", lifSb.lifId).AppendLine(); sb.AppendFormat("Directory size: {0} clusters", lifSb.directorySize).AppendLine(); sb.AppendFormat("LIF version: {0}", lifSb.lifVersion).AppendLine(); // How is this related to volume size? I have only CDs to test and makes no sense there sb.AppendFormat("{0} tracks", lifSb.tracks).AppendLine(); sb.AppendFormat("{0} heads", lifSb.heads).AppendLine(); sb.AppendFormat("{0} sectors", lifSb.sectors).AppendLine(); sb.AppendFormat("Volume name: {0}", StringHandlers.CToString(lifSb.volumeLabel, Encoding)).AppendLine(); sb.AppendFormat("Volume created on {0}", DateHandlers.LifToDateTime(lifSb.creationDate)).AppendLine(); information = sb.ToString(); XmlFsType = new FileSystemType { Type = "HP Logical Interchange Format", ClusterSize = 256, Clusters = partition.Size / 256, CreationDate = DateHandlers.LifToDateTime(lifSb.creationDate), CreationDateSpecified = true, VolumeName = StringHandlers.CToString(lifSb.volumeLabel, Encoding) }; }
public bool Identify(IMediaImage imagePlugin, Partition partition) { if (2 + partition.Start >= partition.End) { return(false); } byte[] bpb = imagePlugin.ReadSector(0 + partition.Start); byte[] fsTypeB = new byte[8]; byte signature = bpb[0x25]; Array.Copy(bpb, 0x35, fsTypeB, 0, 8); string fsType = StringHandlers.CToString(fsTypeB); return(signature == 0x29 && fsType == "SOL_FS "); }
public bool Identify(IFilter imageFilter) { Stream stream = imageFilter.GetDataForkStream(); stream.Seek(0, SeekOrigin.Begin); // Even if comment is supposedly ASCII, I'm pretty sure most emulators allow Shift-JIS to be used :p Encoding shiftjis = Encoding.GetEncoding("shift_jis"); v98Hdr = new Virtual98Header(); if (stream.Length < Marshal.SizeOf(v98Hdr)) { return(false); } byte[] hdrB = new byte[Marshal.SizeOf(v98Hdr)]; stream.Read(hdrB, 0, hdrB.Length); GCHandle handle = GCHandle.Alloc(hdrB, GCHandleType.Pinned); v98Hdr = (Virtual98Header)Marshal.PtrToStructure(handle.AddrOfPinnedObject(), typeof(Virtual98Header)); handle.Free(); if (!v98Hdr.signature.SequenceEqual(signature)) { return(false); } DicConsole.DebugWriteLine("Virtual98 plugin", "v98hdr.signature = \"{0}\"", StringHandlers.CToString(v98Hdr.signature, shiftjis)); DicConsole.DebugWriteLine("Virtual98 plugin", "v98hdr.comment = \"{0}\"", StringHandlers.CToString(v98Hdr.comment, shiftjis)); DicConsole.DebugWriteLine("Virtual98 plugin", "v98hdr.padding = {0}", v98Hdr.padding); DicConsole.DebugWriteLine("Virtual98 plugin", "v98hdr.mbsize = {0}", v98Hdr.mbsize); DicConsole.DebugWriteLine("Virtual98 plugin", "v98hdr.sectorsize = {0}", v98Hdr.sectorsize); DicConsole.DebugWriteLine("Virtual98 plugin", "v98hdr.sectors = {0}", v98Hdr.sectors); DicConsole.DebugWriteLine("Virtual98 plugin", "v98hdr.surfaces = {0}", v98Hdr.surfaces); DicConsole.DebugWriteLine("Virtual98 plugin", "v98hdr.cylinders = {0}", v98Hdr.cylinders); DicConsole.DebugWriteLine("Virtual98 plugin", "v98hdr.totals = {0}", v98Hdr.totals); return(true); }
public bool Open(IFilter imageFilter) { Stream stream = imageFilter.GetDataForkStream(); stream.Seek(0, SeekOrigin.Begin); // Even if comment is supposedly ASCII, I'm pretty sure most emulators allow Shift-JIS to be used :p Encoding shiftjis = Encoding.GetEncoding("shift_jis"); v98Hdr = new Virtual98Header(); if (stream.Length < Marshal.SizeOf(v98Hdr)) { return(false); } byte[] hdrB = new byte[Marshal.SizeOf(v98Hdr)]; stream.Read(hdrB, 0, hdrB.Length); GCHandle handle = GCHandle.Alloc(hdrB, GCHandleType.Pinned); v98Hdr = (Virtual98Header)Marshal.PtrToStructure(handle.AddrOfPinnedObject(), typeof(Virtual98Header)); handle.Free(); imageInfo.MediaType = MediaType.GENERIC_HDD; imageInfo.ImageSize = (ulong)(stream.Length - 0xDC); imageInfo.CreationTime = imageFilter.GetCreationTime(); imageInfo.LastModificationTime = imageFilter.GetLastWriteTime(); imageInfo.MediaTitle = Path.GetFileNameWithoutExtension(imageFilter.GetFilename()); imageInfo.Sectors = v98Hdr.totals; imageInfo.XmlMediaType = XmlMediaType.BlockMedia; imageInfo.SectorSize = v98Hdr.sectorsize; imageInfo.Cylinders = v98Hdr.cylinders; imageInfo.Heads = v98Hdr.surfaces; imageInfo.SectorsPerTrack = v98Hdr.sectors; imageInfo.Comments = StringHandlers.CToString(v98Hdr.comment, shiftjis); nhdImageFilter = imageFilter; return(true); }
public bool Identify(IFilter imageFilter) { Stream stream = imageFilter.GetDataForkStream(); stream.Seek(0, SeekOrigin.Begin); // Even if comment is supposedly ASCII, I'm pretty sure most emulators allow Shift-JIS to be used :p Encoding shiftjis = Encoding.GetEncoding("shift_jis"); nhdhdr = new Nhdr0Header(); if (stream.Length < Marshal.SizeOf(nhdhdr)) { return(false); } byte[] hdrB = new byte[Marshal.SizeOf(nhdhdr)]; stream.Read(hdrB, 0, hdrB.Length); GCHandle handle = GCHandle.Alloc(hdrB, GCHandleType.Pinned); nhdhdr = (Nhdr0Header)Marshal.PtrToStructure(handle.AddrOfPinnedObject(), typeof(Nhdr0Header)); handle.Free(); if (!nhdhdr.szFileID.SequenceEqual(signature)) { return(false); } DicConsole.DebugWriteLine("NHDr0 plugin", "nhdhdr.szFileID = \"{0}\"", StringHandlers.CToString(nhdhdr.szFileID, shiftjis)); DicConsole.DebugWriteLine("NHDr0 plugin", "nhdhdr.reserved1 = {0}", nhdhdr.reserved1); DicConsole.DebugWriteLine("NHDr0 plugin", "nhdhdr.szComment = \"{0}\"", StringHandlers.CToString(nhdhdr.szComment, shiftjis)); DicConsole.DebugWriteLine("NHDr0 plugin", "nhdhdr.dwHeadSize = {0}", nhdhdr.dwHeadSize); DicConsole.DebugWriteLine("NHDr0 plugin", "nhdhdr.dwCylinder = {0}", nhdhdr.dwCylinder); DicConsole.DebugWriteLine("NHDr0 plugin", "nhdhdr.wHead = {0}", nhdhdr.wHead); DicConsole.DebugWriteLine("NHDr0 plugin", "nhdhdr.wSect = {0}", nhdhdr.wSect); DicConsole.DebugWriteLine("NHDr0 plugin", "nhdhdr.wSectLen = {0}", nhdhdr.wSectLen); return(true); }
public bool Identify(IFilter imageFilter) { Stream stream = imageFilter.GetDataForkStream(); stream.Seek(0, SeekOrigin.Begin); if (stream.Length < 512) { return(false); } byte[] headerB = new byte[256]; stream.Read(headerB, 0, 256); CpcDiskInfo header = Marshal.ByteArrayToStructureLittleEndian <CpcDiskInfo>(headerB); AaruConsole.DebugWriteLine("CPCDSK plugin", "header.magic = \"{0}\"", StringHandlers.CToString(header.magic)); return(cpcdskId.SequenceEqual(header.magic.Take(cpcdskId.Length)) || edskId.SequenceEqual(header.magic) || du54Id.SequenceEqual(header.magic)); }
public bool Identify(IFilter imageFilter) { Stream stream = imageFilter.GetDataForkStream(); stream.Seek(0, SeekOrigin.Begin); // Even if comment is supposedly ASCII, I'm pretty sure most emulators allow Shift-JIS to be used :p var shiftjis = Encoding.GetEncoding("shift_jis"); if (stream.Length < Marshal.SizeOf <Nhdr0Header>()) { return(false); } byte[] hdrB = new byte[Marshal.SizeOf <Nhdr0Header>()]; stream.Read(hdrB, 0, hdrB.Length); _nhdhdr = Marshal.ByteArrayToStructureLittleEndian <Nhdr0Header>(hdrB); if (!_nhdhdr.szFileID.SequenceEqual(_signature)) { return(false); } AaruConsole.DebugWriteLine("NHDr0 plugin", "nhdhdr.szFileID = \"{0}\"", StringHandlers.CToString(_nhdhdr.szFileID, shiftjis)); AaruConsole.DebugWriteLine("NHDr0 plugin", "nhdhdr.reserved1 = {0}", _nhdhdr.reserved1); AaruConsole.DebugWriteLine("NHDr0 plugin", "nhdhdr.szComment = \"{0}\"", StringHandlers.CToString(_nhdhdr.szComment, shiftjis)); AaruConsole.DebugWriteLine("NHDr0 plugin", "nhdhdr.dwHeadSize = {0}", _nhdhdr.dwHeadSize); AaruConsole.DebugWriteLine("NHDr0 plugin", "nhdhdr.dwCylinder = {0}", _nhdhdr.dwCylinder); AaruConsole.DebugWriteLine("NHDr0 plugin", "nhdhdr.wHead = {0}", _nhdhdr.wHead); AaruConsole.DebugWriteLine("NHDr0 plugin", "nhdhdr.wSect = {0}", _nhdhdr.wSect); AaruConsole.DebugWriteLine("NHDr0 plugin", "nhdhdr.wSectLen = {0}", _nhdhdr.wSectLen); return(true); }
public bool Identify(IFilter imageFilter) { Stream stream = imageFilter.GetDataForkStream(); stream.Seek(0, SeekOrigin.Begin); // Even if comment is supposedly ASCII, I'm pretty sure most emulators allow Shift-JIS to be used :p var shiftjis = Encoding.GetEncoding("shift_jis"); if (stream.Length < Marshal.SizeOf <Virtual98Header>()) { return(false); } byte[] hdrB = new byte[Marshal.SizeOf <Virtual98Header>()]; stream.Read(hdrB, 0, hdrB.Length); v98Hdr = Marshal.ByteArrayToStructureLittleEndian <Virtual98Header>(hdrB); if (!v98Hdr.signature.SequenceEqual(signature)) { return(false); } AaruConsole.DebugWriteLine("Virtual98 plugin", "v98hdr.signature = \"{0}\"", StringHandlers.CToString(v98Hdr.signature, shiftjis)); AaruConsole.DebugWriteLine("Virtual98 plugin", "v98hdr.comment = \"{0}\"", StringHandlers.CToString(v98Hdr.comment, shiftjis)); AaruConsole.DebugWriteLine("Virtual98 plugin", "v98hdr.padding = {0}", v98Hdr.padding); AaruConsole.DebugWriteLine("Virtual98 plugin", "v98hdr.mbsize = {0}", v98Hdr.mbsize); AaruConsole.DebugWriteLine("Virtual98 plugin", "v98hdr.sectorsize = {0}", v98Hdr.sectorsize); AaruConsole.DebugWriteLine("Virtual98 plugin", "v98hdr.sectors = {0}", v98Hdr.sectors); AaruConsole.DebugWriteLine("Virtual98 plugin", "v98hdr.surfaces = {0}", v98Hdr.surfaces); AaruConsole.DebugWriteLine("Virtual98 plugin", "v98hdr.cylinders = {0}", v98Hdr.cylinders); AaruConsole.DebugWriteLine("Virtual98 plugin", "v98hdr.totals = {0}", v98Hdr.totals); return(true); }
public bool GetInformation(IMediaImage imagePlugin, out List <Partition> partitions, ulong sectorOffset) { partitions = new List <Partition>(); if (sectorOffset + 2 >= imagePlugin.Info.Sectors) { return(false); } byte[] sector = imagePlugin.ReadSector(sectorOffset + 1); // While all of Plan9 is supposedly UTF-8, it uses ASCII strcmp for reading its partition table string[] really = StringHandlers.CToString(sector).Split('\n'); foreach (string[] tokens in really.TakeWhile(part => part.Length >= 5 && part.Substring(0, 5) == "part "). Select(part => part.Split(' ')).TakeWhile(tokens => tokens.Length == 4)) { if (!ulong.TryParse(tokens[2], out ulong start) || !ulong.TryParse(tokens[3], out ulong end)) { break; } var part = new Partition { Length = (end - start) + 1, Offset = (start + sectorOffset) * imagePlugin.Info.SectorSize, Scheme = Name, Sequence = (ulong)partitions.Count, Size = ((end - start) + 1) * imagePlugin.Info.SectorSize, Start = start + sectorOffset, Type = tokens[1] }; partitions.Add(part); } return(partitions.Count > 0); }
public static byte[] ClearInquiry(byte[] inquiry) { Inquiry?decodedNullable = Inquiry.Decode(inquiry); if (!decodedNullable.HasValue) { return(inquiry); } Inquiry decoded = decodedNullable.Value; // Clear Seagate serial number if (decoded.SeagatePresent && StringHandlers.CToString(decoded.VendorIdentification)?.Trim().ToLowerInvariant() == "seagate") { for (int i = 36; i <= 43; i++) { inquiry[i] = 0; } } return(inquiry); }
public static CID DecodeCID(byte[] response) { if (response?.Length != 16) { return(null); } CID cid = new CID { Manufacturer = response[0], DeviceType = (byte)(response[1] & 0x03), ProductRevision = response[9], ProductSerialNumber = BitConverter.ToUInt32(response, 10), ManufacturingDate = response[14], CRC = (byte)((response[15] & 0xFE) >> 1) }; byte[] tmp = new byte[6]; Array.Copy(response, 3, tmp, 0, 6); cid.ProductName = StringHandlers.CToString(tmp); return(cid); }
public bool Identify(IFilter imageFilter) { Stream stream = imageFilter.GetDataForkStream(); if (stream.Length < Marshal.SizeOf(typeof(RayHdr))) { return(false); } byte[] buffer = new byte[Marshal.SizeOf(typeof(RayHdr))]; stream.Seek(0, SeekOrigin.Begin); stream.Read(buffer, 0, buffer.Length); IntPtr ftrPtr = Marshal.AllocHGlobal(buffer.Length); Marshal.Copy(buffer, 0, ftrPtr, buffer.Length); RayHdr header = (RayHdr)Marshal.PtrToStructure(ftrPtr, typeof(RayHdr)); Marshal.FreeHGlobal(ftrPtr); string signature = StringHandlers.CToString(header.signature); DicConsole.DebugWriteLine("Ray Arachelian's Disk IMage plugin", "header.signature = {0}", signature); DicConsole.DebugWriteLine("Ray Arachelian's Disk IMage plugin", "header.diskType = {0}", header.diskType); DicConsole.DebugWriteLine("Ray Arachelian's Disk IMage plugin", "header.heads = {0}", header.heads); DicConsole.DebugWriteLine("Ray Arachelian's Disk IMage plugin", "header.cylinders = {0}", header.cylinders); DicConsole.DebugWriteLine("Ray Arachelian's Disk IMage plugin", "header.sectorsPerTrack = {0}", header.sectorsPerTrack); Regex sx = new Regex(REGEX_SIGNATURE); Match sm = sx.Match(signature); DicConsole.DebugWriteLine("Ray Arachelian's Disk IMage plugin", "header.signature matches? = {0}", sm.Success); return(sm.Success); }
public bool Open(IFilter imageFilter) { Stream stream = imageFilter.GetDataForkStream(); stream.Seek(0, SeekOrigin.Begin); // Even if comment is supposedly ASCII, I'm pretty sure most emulators allow Shift-JIS to be used :p var shiftjis = Encoding.GetEncoding("shift_jis"); if (stream.Length < Marshal.SizeOf <Virtual98Header>()) { return(false); } byte[] hdrB = new byte[Marshal.SizeOf <Virtual98Header>()]; stream.Read(hdrB, 0, hdrB.Length); _v98Hdr = Marshal.ByteArrayToStructureLittleEndian <Virtual98Header>(hdrB); _imageInfo.MediaType = MediaType.GENERIC_HDD; _imageInfo.ImageSize = (ulong)(stream.Length - 0xDC); _imageInfo.CreationTime = imageFilter.GetCreationTime(); _imageInfo.LastModificationTime = imageFilter.GetLastWriteTime(); _imageInfo.MediaTitle = Path.GetFileNameWithoutExtension(imageFilter.GetFilename()); _imageInfo.Sectors = _v98Hdr.totals; _imageInfo.XmlMediaType = XmlMediaType.BlockMedia; _imageInfo.SectorSize = _v98Hdr.sectorsize; _imageInfo.Cylinders = _v98Hdr.cylinders; _imageInfo.Heads = _v98Hdr.surfaces; _imageInfo.SectorsPerTrack = _v98Hdr.sectors; _imageInfo.Comments = StringHandlers.CToString(_v98Hdr.comment, shiftjis); _nhdImageFilter = imageFilter; return(true); }
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information, Encoding encoding) { Encoding = Encoding.GetEncoding("koi8-r"); byte[] sector = imagePlugin.ReadSector(0); AODOS_BootBlock bb = new AODOS_BootBlock(); IntPtr bbPtr = Marshal.AllocHGlobal(Marshal.SizeOf(bb)); Marshal.Copy(sector, 0, bbPtr, Marshal.SizeOf(bb)); bb = (AODOS_BootBlock)Marshal.PtrToStructure(bbPtr, typeof(AODOS_BootBlock)); Marshal.FreeHGlobal(bbPtr); StringBuilder sbInformation = new StringBuilder(); sbInformation.AppendLine("Alexander Osipov DOS file system"); XmlFsType = new FileSystemType { Type = "Alexander Osipov DOS file system", Clusters = (long)imagePlugin.Info.Sectors, ClusterSize = (int)imagePlugin.Info.SectorSize, Files = bb.files, FilesSpecified = true, FreeClusters = (long)(imagePlugin.Info.Sectors - bb.usedSectors), FreeClustersSpecified = true, VolumeName = StringHandlers.SpacePaddedToString(bb.volumeLabel, Encoding), Bootable = true }; sbInformation.AppendFormat("{0} files on volume", bb.files).AppendLine(); sbInformation.AppendFormat("{0} used sectors on volume", bb.usedSectors).AppendLine(); sbInformation.AppendFormat("Disk name: {0}", StringHandlers.CToString(bb.volumeLabel, Encoding)) .AppendLine(); information = sbInformation.ToString(); }
public static XboxDMI?DecodeXbox(byte[] response) { bool isXbox = IsXbox(response); if (!isXbox) { return(null); } XboxDMI dmi = new XboxDMI { DataLength = (ushort)((response[0] << 8) + response[1]), Reserved1 = response[2], Reserved2 = response[3], Version = BitConverter.ToUInt32(response, 4), Timestamp = BitConverter.ToInt64(response, 20) }; byte[] tmp = new byte[8]; Array.Copy(response, 12, tmp, 0, 8); dmi.CatalogNumber = StringHandlers.CToString(tmp); return(dmi); }