Пример #1
0
        static DiskLabel GetDiskLabel(byte[] disklabel)
        {
            GCHandle  handle = GCHandle.Alloc(disklabel, GCHandleType.Pinned);
            DiskLabel dl     = (DiskLabel)Marshal.PtrToStructure(handle.AddrOfPinnedObject(), typeof(DiskLabel));

            handle.Free();
            return(dl);
        }
Пример #2
0
        static DiskLabel SwapDiskLabel(DiskLabel dl)
        {
            dl = (DiskLabel)Marshal.SwapStructureMembersEndian(dl);
            for (int i = 0; i < dl.d_drivedata.Length; i++)
            {
                dl.d_drivedata[i] = Swapping.Swap(dl.d_drivedata[i]);
            }
            for (int i = 0; i < dl.d_spare.Length; i++)
            {
                dl.d_spare[i] = Swapping.Swap(dl.d_spare[i]);
            }
            for (int i = 0; i < dl.d_partitions.Length; i++)
            {
                dl.d_partitions[i] = (BSDPartition)Marshal.SwapStructureMembersEndian(dl.d_partitions[i]);
            }

            return(dl);
        }
Пример #3
0
        public bool GetInformation(IMediaImage imagePlugin, out List <Partition> partitions, ulong sectorOffset)
        {
            partitions = new List <Partition>();
            uint run = (MAX_LABEL_SIZE + labelOffsets.Last()) / imagePlugin.Info.SectorSize;

            if ((MAX_LABEL_SIZE + labelOffsets.Last()) % imagePlugin.Info.SectorSize > 0)
            {
                run++;
            }

            DiskLabel dl    = new DiskLabel();
            bool      found = false;

            foreach (ulong location in labelLocations)
            {
                if (location + run + sectorOffset >= imagePlugin.Info.Sectors)
                {
                    return(false);
                }

                byte[] tmp = imagePlugin.ReadSectors(location + sectorOffset, run);
                foreach (uint offset in labelOffsets)
                {
                    byte[] sector = new byte[MAX_LABEL_SIZE];
                    Array.Copy(tmp, offset, sector, 0, MAX_LABEL_SIZE);
                    dl = GetDiskLabel(sector);
                    DicConsole.DebugWriteLine("BSD plugin",
                                              "dl.magic on sector {0} at offset {1} = 0x{2:X8} (expected 0x{3:X8})",
                                              location + sectorOffset, offset, dl.d_magic, DISKMAGIC);
                    if ((dl.d_magic != DISKMAGIC || dl.d_magic2 != DISKMAGIC) &&
                        (dl.d_magic != DISKCIGAM || dl.d_magic2 != DISKCIGAM))
                    {
                        continue;
                    }

                    found = true;
                    break;
                }

                if (found)
                {
                    break;
                }
            }

            if (!found)
            {
                return(false);
            }

            if (dl.d_magic == DISKCIGAM && dl.d_magic2 == DISKCIGAM)
            {
                dl = SwapDiskLabel(dl);
            }

            DicConsole.DebugWriteLine("BSD plugin", "dl.d_type = {0}", dl.d_type);
            DicConsole.DebugWriteLine("BSD plugin", "dl.d_subtype = {0}", dl.d_subtype);
            DicConsole.DebugWriteLine("BSD plugin", "dl.d_typename = {0}",
                                      StringHandlers.CToString(dl.d_typename));
            DicConsole.DebugWriteLine("BSD plugin", "dl.d_packname = {0}",
                                      StringHandlers.CToString(dl.d_packname));
            DicConsole.DebugWriteLine("BSD plugin", "dl.d_secsize = {0}", dl.d_secsize);
            DicConsole.DebugWriteLine("BSD plugin", "dl.d_nsectors = {0}", dl.d_nsectors);
            DicConsole.DebugWriteLine("BSD plugin", "dl.d_ntracks = {0}", dl.d_ntracks);
            DicConsole.DebugWriteLine("BSD plugin", "dl.d_ncylinders = {0}", dl.d_ncylinders);
            DicConsole.DebugWriteLine("BSD plugin", "dl.d_secpercyl = {0}", dl.d_secpercyl);
            DicConsole.DebugWriteLine("BSD plugin", "dl.d_secperunit = {0}", dl.d_secperunit);
            DicConsole.DebugWriteLine("BSD plugin", "dl.d_sparespertrack = {0}", dl.d_sparespertrack);
            DicConsole.DebugWriteLine("BSD plugin", "dl.d_sparespercyl = {0}", dl.d_sparespercyl);
            DicConsole.DebugWriteLine("BSD plugin", "dl.d_acylinders = {0}", dl.d_acylinders);
            DicConsole.DebugWriteLine("BSD plugin", "dl.d_rpm = {0}", dl.d_rpm);
            DicConsole.DebugWriteLine("BSD plugin", "dl.d_interleave = {0}", dl.d_interleave);
            DicConsole.DebugWriteLine("BSD plugin", "dl.d_trackskew = {0}", dl.d_trackskew);
            DicConsole.DebugWriteLine("BSD plugin", "dl.d_cylskeew = {0}", dl.d_cylskeew);
            DicConsole.DebugWriteLine("BSD plugin", "dl.d_headswitch = {0}", dl.d_headswitch);
            DicConsole.DebugWriteLine("BSD plugin", "dl.d_trkseek = {0}", dl.d_trkseek);
            DicConsole.DebugWriteLine("BSD plugin", "dl.d_flags = {0}", dl.d_flags);
            DicConsole.DebugWriteLine("BSD plugin", "dl.d_drivedata[0] = {0}", dl.d_drivedata[0]);
            DicConsole.DebugWriteLine("BSD plugin", "dl.d_drivedata[1] = {0}", dl.d_drivedata[1]);
            DicConsole.DebugWriteLine("BSD plugin", "dl.d_drivedata[2] = {0}", dl.d_drivedata[2]);
            DicConsole.DebugWriteLine("BSD plugin", "dl.d_drivedata[3] = {0}", dl.d_drivedata[3]);
            DicConsole.DebugWriteLine("BSD plugin", "dl.d_drivedata[4] = {0}", dl.d_drivedata[4]);
            DicConsole.DebugWriteLine("BSD plugin", "dl.d_spare[0] = {0}", dl.d_spare[0]);
            DicConsole.DebugWriteLine("BSD plugin", "dl.d_spare[1] = {0}", dl.d_spare[1]);
            DicConsole.DebugWriteLine("BSD plugin", "dl.d_spare[2] = {0}", dl.d_spare[2]);
            DicConsole.DebugWriteLine("BSD plugin", "dl.d_spare[3] = {0}", dl.d_spare[3]);
            DicConsole.DebugWriteLine("BSD plugin", "dl.d_spare[4] = {0}", dl.d_spare[4]);
            DicConsole.DebugWriteLine("BSD plugin", "dl.d_magic2 = 0x{0:X8}", dl.d_magic2);
            DicConsole.DebugWriteLine("BSD plugin", "dl.d_checksum = 0x{0:X8}", dl.d_checksum);
            DicConsole.DebugWriteLine("BSD plugin", "dl.d_npartitions = {0}", dl.d_npartitions);
            DicConsole.DebugWriteLine("BSD plugin", "dl.d_bbsize = {0}", dl.d_bbsize);
            DicConsole.DebugWriteLine("BSD plugin", "dl.d_sbsize = {0}", dl.d_sbsize);

            ulong counter         = 0;
            bool  addSectorOffset = false;

            for (int i = 0; i < dl.d_npartitions && i < 22; i++)
            {
                DicConsole.DebugWriteLine("BSD plugin", "dl.d_partitions[i].p_offset = {0}",
                                          dl.d_partitions[i].p_offset);
                DicConsole.DebugWriteLine("BSD plugin", "dl.d_partitions[i].p_size = {0}", dl.d_partitions[i].p_size);
                DicConsole.DebugWriteLine("BSD plugin", "dl.d_partitions[i].p_fstype = {0} ({1})",
                                          dl.d_partitions[i].p_fstype, fsTypeToString(dl.d_partitions[i].p_fstype));
                Partition part = new Partition
                {
                    Start    = dl.d_partitions[i].p_offset * dl.d_secsize / imagePlugin.Info.SectorSize,
                    Offset   = dl.d_partitions[i].p_offset * dl.d_secsize,
                    Length   = dl.d_partitions[i].p_size * dl.d_secsize / imagePlugin.Info.SectorSize,
                    Size     = dl.d_partitions[i].p_size * dl.d_secsize,
                    Type     = fsTypeToString(dl.d_partitions[i].p_fstype),
                    Sequence = counter,
                    Scheme   = Name
                };
                if (dl.d_partitions[i].p_fstype == fsType.Unused)
                {
                    continue;
                }

                // Crude and dirty way to know if the disklabel is relative to its parent partition...
                if (dl.d_partitions[i].p_offset < sectorOffset && !addSectorOffset)
                {
                    addSectorOffset = true;
                }

                if (addSectorOffset)
                {
                    part.Start  += sectorOffset;
                    part.Offset += sectorOffset * imagePlugin.Info.SectorSize;
                }

                DicConsole.DebugWriteLine("BSD plugin", "part.start = {0}", part.Start);
                DicConsole.DebugWriteLine("BSD plugin", "Adding it...");
                partitions.Add(part);
                counter++;
            }

            return(partitions.Count > 0);
        }