2017-05-19 20:28:49 +01:00
|
|
|
// /***************************************************************************
|
2020-02-27 12:31:25 +00:00
|
|
|
// Aaru Data Preservation Suite
|
2016-02-05 05:39:15 +00:00
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
|
//
|
|
|
|
|
// Filename : Sun.cs
|
2016-07-28 18:13:49 +01:00
|
|
|
// Author(s) : Natalia Portillo <claunia@claunia.com>
|
2016-02-05 05:39:15 +00:00
|
|
|
//
|
2016-07-28 18:13:49 +01:00
|
|
|
// Component : Partitioning scheme plugins.
|
2016-02-05 05:39:15 +00:00
|
|
|
//
|
|
|
|
|
// --[ Description ] ----------------------------------------------------------
|
|
|
|
|
//
|
2016-07-28 18:13:49 +01:00
|
|
|
// Manages Sun disklabels.
|
2016-02-05 05:39:15 +00:00
|
|
|
//
|
|
|
|
|
// --[ License ] --------------------------------------------------------------
|
|
|
|
|
//
|
2016-07-28 18:13:49 +01:00
|
|
|
// 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
|
2016-02-05 05:39:15 +00:00
|
|
|
// License, or (at your option) any later version.
|
|
|
|
|
//
|
2016-07-28 18:13:49 +01:00
|
|
|
// 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.
|
2016-02-05 05:39:15 +00:00
|
|
|
//
|
2016-07-28 18:13:49 +01:00
|
|
|
// You should have received a copy of the GNU Lesser General Public
|
|
|
|
|
// License along with this library; if not, see <http://www.gnu.org/licenses/>.
|
2016-02-05 05:39:15 +00:00
|
|
|
//
|
|
|
|
|
// ----------------------------------------------------------------------------
|
2022-12-03 16:07:10 +00:00
|
|
|
// Copyright © 2011-2023 Natalia Portillo
|
2016-02-05 05:39:15 +00:00
|
|
|
// ****************************************************************************/
|
2016-07-28 18:13:49 +01:00
|
|
|
|
2016-02-05 05:39:15 +00:00
|
|
|
using System;
|
|
|
|
|
using System.Collections.Generic;
|
2017-12-22 16:53:11 +00:00
|
|
|
using System.Diagnostics.CodeAnalysis;
|
* DiscImageChef.Helpers/BigEndianStructure.cs:
* DiscImageChef.Helpers/DiscImageChef.Helpers.csproj:
Added code that directly marshals from a big-endian byte
array. But untested with nested structures.
* DiscImageChef.Partitions/Acorn.cs:
Added support for Acorn FileCore partition, closes #4.
* DiscImageChef.Partitions/BSD.cs:
Moved BSD partitions from inside MBR code to separate code,
as they can (and do) appear on other architectures as the
only scheme.
* DiscImageChef.Partitions/DEC.cs:
Added support for DEC disklabels, closes #11.
* DiscImageChef.Partitions/DragonFlyBSD.cs:
Added support for DragonFly BSD 64-bit disklabels.
* DiscImageChef.Partitions/PC98.cs:
Added support for NEC PC-9800 partitions.
* DiscImageChef.Partitions/RioKarma.cs:
Added support for Rio Karma partitions.
* DiscImageChef.Partitions/SGI.cs:
Added support for SGI DVHs, closes #9.
* DiscImageChef.Partitions/UNIX.cs:
Moved UNIX partitions from inside MBR code to separate code,
as they can (and do) appear on other architectures as the
only scheme.
* TODO:
* README.md:
* DiscImageChef.Partitions/DiscImageChef.Partitions.csproj:
Added support for Acorn FileCore partition, closes #4.
Added support for DEC disklabels, closes #11.
Added support for SGI DVHs, closes #9.
Moved BSD partitions from inside MBR code to separate code, as
they can (and do) appear on other architectures as the only
scheme.
Added support for DragonFly BSD 64-bit disklabels.
Added support for NEC PC-9800 partitions.
Added support for Rio Karma partitions.
Moved UNIX partitions from inside MBR code to separate code,
as they can (and do) appear on other architectures as the
only scheme.
* DiscImageChef.Partitions/GPT.cs:
Added new partition type UUIDs.
* DiscImageChef.Partitions/MBR.cs:
Moved BSD partitions from inside MBR code to separate code,
as they can (and do) appear on other architectures as the
only scheme.
Moved UNIX partitions from inside MBR code to separate code,
as they can (and do) appear on other architectures as the
only scheme.
* DiscImageChef.Partitions/Sun.cs:
Added new partition types.
Prepare structures for marshaling.
2016-08-21 08:27:43 +01:00
|
|
|
using System.Runtime.InteropServices;
|
2017-12-21 14:30:38 +00:00
|
|
|
using System.Text;
|
2020-02-27 00:33:26 +00:00
|
|
|
using Aaru.CommonTypes;
|
2021-09-19 21:16:47 +01:00
|
|
|
using Aaru.CommonTypes.Enums;
|
2020-02-27 00:33:26 +00:00
|
|
|
using Aaru.CommonTypes.Interfaces;
|
|
|
|
|
using Aaru.Console;
|
2020-07-20 15:43:52 +01:00
|
|
|
using Aaru.Helpers;
|
2020-02-27 00:33:26 +00:00
|
|
|
using Marshal = Aaru.Helpers.Marshal;
|
2016-02-05 05:39:15 +00:00
|
|
|
|
2022-11-15 15:58:43 +00:00
|
|
|
namespace Aaru.Partitions;
|
|
|
|
|
|
2022-03-06 13:29:38 +00:00
|
|
|
/// <inheritdoc />
|
|
|
|
|
/// <summary>Implements decoding of Sun disklabels</summary>
|
|
|
|
|
[SuppressMessage("ReSharper", "InconsistentNaming")]
|
|
|
|
|
public sealed class SunDisklabel : IPartition
|
2016-02-05 05:39:15 +00:00
|
|
|
{
|
2022-03-06 13:29:38 +00:00
|
|
|
/// <summary>Sun disklabel magic number</summary>
|
|
|
|
|
const ushort DKL_MAGIC = 0xDABE;
|
|
|
|
|
/// <summary>Sun VTOC magic number</summary>
|
|
|
|
|
const uint VTOC_SANE = 0x600DDEEE;
|
|
|
|
|
/// <summary>Sun disklabel magic number, byte-swapped</summary>
|
|
|
|
|
const ushort DKL_CIGAM = 0xBEDA;
|
|
|
|
|
/// <summary>Sun VTOC magic number, byte-swapped</summary>
|
|
|
|
|
const uint VTOC_ENAS = 0xEEDE0D60;
|
|
|
|
|
/// <summary># of logical partitions</summary>
|
|
|
|
|
const int NDKMAP = 8;
|
|
|
|
|
/// <summary># of logical partitions</summary>
|
|
|
|
|
const int NDKMAP16 = 16;
|
|
|
|
|
/// <summary>Disk label size</summary>
|
|
|
|
|
const int DK_LABEL_SIZE = 512;
|
|
|
|
|
/// <summary>Volume label size</summary>
|
|
|
|
|
const int LEN_DKL_ASCII = 128;
|
|
|
|
|
/// <summary>Length of v_volume</summary>
|
|
|
|
|
const int LEN_DKL_VVOL = 8;
|
|
|
|
|
/// <summary>Size of padding in SunOS disk label</summary>
|
2023-10-03 23:36:49 +01:00
|
|
|
const int LEN_DKL_PAD = DK_LABEL_SIZE - (LEN_DKL_ASCII + NDKMAP * 8 + 14 * 2);
|
2022-03-06 13:29:38 +00:00
|
|
|
/// <summary>Size of padding in Solaris disk label with 8 partitions</summary>
|
2023-10-04 17:34:40 +01:00
|
|
|
const int LEN_DKL_PAD8 = DK_LABEL_SIZE -
|
|
|
|
|
(LEN_DKL_ASCII +
|
|
|
|
|
136 + // sizeof(dk_vtoc8)
|
|
|
|
|
NDKMAP * 8 +
|
|
|
|
|
14 * 2 +
|
|
|
|
|
2 * 2);
|
|
|
|
|
const int LEN_DKL_PAD16 = DK_LABEL_SIZE -
|
|
|
|
|
(456 + // sizeof(dk_vtoc16)
|
|
|
|
|
4 * 4 +
|
|
|
|
|
12 * 2 +
|
|
|
|
|
2 * 2);
|
2023-10-03 18:46:31 +01:00
|
|
|
const string MODULE_NAME = "Sun partitions plugin";
|
2022-03-06 13:29:38 +00:00
|
|
|
|
2023-10-03 23:36:49 +01:00
|
|
|
#region IPartition Members
|
|
|
|
|
|
2022-03-06 13:29:38 +00:00
|
|
|
/// <inheritdoc />
|
2022-11-29 03:13:21 +00:00
|
|
|
public string Name => Localization.SunDisklabel_Name;
|
2023-10-03 23:36:49 +01:00
|
|
|
|
2022-03-06 13:29:38 +00:00
|
|
|
/// <inheritdoc />
|
|
|
|
|
public Guid Id => new("50F35CC4-8375-4445-8DCB-1BA550C931A3");
|
2023-10-03 23:36:49 +01:00
|
|
|
|
2021-08-17 14:25:12 +01:00
|
|
|
/// <inheritdoc />
|
2023-10-05 01:52:48 +01:00
|
|
|
public string Author => Authors.NATALIA_PORTILLO;
|
2022-03-06 13:29:38 +00:00
|
|
|
|
|
|
|
|
/// <inheritdoc />
|
|
|
|
|
public bool GetInformation(IMediaImage imagePlugin, out List<Partition> partitions, ulong sectorOffset)
|
2016-02-05 05:39:15 +00:00
|
|
|
{
|
2022-03-06 13:29:38 +00:00
|
|
|
partitions = new List<Partition>();
|
2016-02-05 05:39:15 +00:00
|
|
|
|
2022-03-06 13:29:38 +00:00
|
|
|
if(imagePlugin.Info.SectorSize < 512)
|
|
|
|
|
return false;
|
2017-12-19 20:33:03 +00:00
|
|
|
|
2022-03-06 13:29:38 +00:00
|
|
|
if(sectorOffset + 2 >= imagePlugin.Info.Sectors)
|
|
|
|
|
return false;
|
2016-08-22 00:49:48 +01:00
|
|
|
|
2022-03-06 13:29:38 +00:00
|
|
|
bool useDkl = false, useDkl8 = false, useDkl16 = false;
|
2017-07-30 15:53:42 +01:00
|
|
|
|
2022-03-06 13:29:38 +00:00
|
|
|
ErrorNumber errno = imagePlugin.ReadSector(sectorOffset, out byte[] sunSector);
|
2021-09-19 21:16:47 +01:00
|
|
|
|
2022-03-06 13:29:38 +00:00
|
|
|
if(errno != ErrorNumber.NoError)
|
|
|
|
|
return false;
|
2017-07-30 15:53:42 +01:00
|
|
|
|
2022-03-06 13:29:38 +00:00
|
|
|
dk_label dkl = Marshal.ByteArrayToStructureLittleEndian<dk_label>(sunSector);
|
|
|
|
|
dk_label8 dkl8 = Marshal.ByteArrayToStructureLittleEndian<dk_label8>(sunSector);
|
|
|
|
|
dk_label16 dkl16 = Marshal.ByteArrayToStructureLittleEndian<dk_label16>(sunSector);
|
2017-07-30 15:53:42 +01:00
|
|
|
|
2023-10-03 23:36:49 +01:00
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl.dkl_magic = 0x{0:X4}", dkl.dkl_magic);
|
|
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl8.dkl_vtoc.v_sanity = 0x{0:X8}", dkl8.dkl_vtoc.v_sanity);
|
2023-10-03 18:46:31 +01:00
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl16.dkl_vtoc.v_sanity = 0x{0:X8}", dkl16.dkl_vtoc.v_sanity);
|
2017-07-30 15:53:42 +01:00
|
|
|
|
2022-03-16 11:47:00 +00:00
|
|
|
if(dkl.dkl_magic is DKL_MAGIC or DKL_CIGAM)
|
2023-10-03 23:36:49 +01:00
|
|
|
{
|
2022-03-16 11:47:00 +00:00
|
|
|
if(dkl16.dkl_vtoc.v_sanity is VTOC_SANE or VTOC_ENAS)
|
2022-03-06 13:29:38 +00:00
|
|
|
useDkl16 = true;
|
2022-03-16 11:47:00 +00:00
|
|
|
else if(dkl8.dkl_vtoc.v_sanity is VTOC_SANE or VTOC_ENAS)
|
2022-03-06 13:29:38 +00:00
|
|
|
useDkl8 = true;
|
|
|
|
|
else
|
|
|
|
|
useDkl = true;
|
2023-10-03 23:36:49 +01:00
|
|
|
}
|
2021-09-19 21:16:47 +01:00
|
|
|
|
2023-10-04 17:34:40 +01:00
|
|
|
if(!useDkl && !useDkl8 && !useDkl16)
|
2022-03-06 13:29:38 +00:00
|
|
|
{
|
|
|
|
|
errno = imagePlugin.ReadSector(sectorOffset + 1, out sunSector);
|
|
|
|
|
|
|
|
|
|
if(errno == ErrorNumber.NoError)
|
|
|
|
|
{
|
|
|
|
|
dkl = Marshal.ByteArrayToStructureLittleEndian<dk_label>(sunSector);
|
|
|
|
|
dkl8 = Marshal.ByteArrayToStructureLittleEndian<dk_label8>(sunSector);
|
|
|
|
|
dkl16 = Marshal.ByteArrayToStructureLittleEndian<dk_label16>(sunSector);
|
|
|
|
|
|
2022-03-16 11:47:00 +00:00
|
|
|
if(dkl.dkl_magic is DKL_MAGIC or DKL_CIGAM)
|
2023-10-03 23:36:49 +01:00
|
|
|
{
|
2022-03-16 11:47:00 +00:00
|
|
|
if(dkl16.dkl_vtoc.v_sanity is VTOC_SANE or VTOC_ENAS)
|
2022-03-06 13:29:38 +00:00
|
|
|
useDkl16 = true;
|
2022-03-16 11:47:00 +00:00
|
|
|
else if(dkl8.dkl_vtoc.v_sanity is VTOC_SANE or VTOC_ENAS)
|
2022-03-06 13:29:38 +00:00
|
|
|
useDkl8 = true;
|
|
|
|
|
else
|
|
|
|
|
useDkl = true;
|
2023-10-03 23:36:49 +01:00
|
|
|
}
|
2016-02-05 05:39:15 +00:00
|
|
|
}
|
2022-03-06 13:29:38 +00:00
|
|
|
}
|
2016-02-05 05:39:15 +00:00
|
|
|
|
2023-10-04 17:34:40 +01:00
|
|
|
if(!useDkl && !useDkl8 && !useDkl16)
|
2022-03-06 13:29:38 +00:00
|
|
|
return false;
|
2016-02-05 05:39:15 +00:00
|
|
|
|
2022-03-06 13:29:38 +00:00
|
|
|
if(useDkl16 && dkl16.dkl_magic == DKL_CIGAM)
|
|
|
|
|
dkl16 = SwapDiskLabel(dkl16);
|
|
|
|
|
else if(useDkl8 && dkl8.dkl_magic == DKL_CIGAM)
|
|
|
|
|
dkl8 = SwapDiskLabel(dkl8);
|
|
|
|
|
else if(useDkl && dkl.dkl_magic == DKL_CIGAM)
|
|
|
|
|
dkl = SwapDiskLabel(dkl);
|
2016-02-05 05:39:15 +00:00
|
|
|
|
2022-03-06 13:29:38 +00:00
|
|
|
if(useDkl)
|
|
|
|
|
{
|
2023-10-03 23:36:49 +01:00
|
|
|
var sectorsPerCylinder = (ulong)(dkl.dkl_nsect * dkl.dkl_nhead);
|
2022-03-06 13:29:38 +00:00
|
|
|
|
2023-10-03 18:46:31 +01:00
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl.dkl_asciilabel = \"{0}\"",
|
2022-03-06 13:29:38 +00:00
|
|
|
StringHandlers.CToString(dkl.dkl_asciilabel));
|
|
|
|
|
|
2023-10-03 23:36:49 +01:00
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl.dkl_rpm = {0}", dkl.dkl_rpm);
|
|
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl.dkl_pcyl = {0}", dkl.dkl_pcyl);
|
|
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl.dkl_apc = {0}", dkl.dkl_apc);
|
|
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl.dkl_gap1 = {0}", dkl.dkl_gap1);
|
|
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl.dkl_gap2 = {0}", dkl.dkl_gap2);
|
2023-10-03 18:46:31 +01:00
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl.dkl_intrlv = {0}", dkl.dkl_intrlv);
|
2023-10-03 23:36:49 +01:00
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl.dkl_ncyl = {0}", dkl.dkl_ncyl);
|
|
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl.dkl_acyl = {0}", dkl.dkl_acyl);
|
|
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl.dkl_nhead = {0}", dkl.dkl_nhead);
|
|
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl.dkl_nsect = {0}", dkl.dkl_nsect);
|
|
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl.dkl_bhead = {0}", dkl.dkl_bhead);
|
|
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl.dkl_ppart = {0}", dkl.dkl_ppart);
|
|
|
|
|
|
|
|
|
|
for(var i = 0; i < NDKMAP; i++)
|
2016-02-05 05:39:15 +00:00
|
|
|
{
|
2023-10-03 18:46:31 +01:00
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl.dkl_map[{0}].dkl_cylno = {1}", i,
|
2022-03-06 13:29:38 +00:00
|
|
|
dkl.dkl_map[i].dkl_cylno);
|
2020-02-29 18:03:35 +00:00
|
|
|
|
2023-10-03 18:46:31 +01:00
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl.dkl_map[{0}].dkl_nblk = {1}", i, dkl.dkl_map[i].dkl_nblk);
|
2022-03-06 13:29:38 +00:00
|
|
|
}
|
2017-12-19 20:33:03 +00:00
|
|
|
|
2023-10-03 18:46:31 +01:00
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl.dkl_magic = 0x{0:X4}", dkl.dkl_magic);
|
|
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl.dkl_cksum = 0x{0:X4}", dkl.dkl_cksum);
|
|
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "sectorsPerCylinder = {0}", sectorsPerCylinder);
|
2017-07-30 15:53:42 +01:00
|
|
|
|
2023-10-03 23:36:49 +01:00
|
|
|
for(var i = 0; i < NDKMAP; i++)
|
|
|
|
|
{
|
2023-10-04 17:34:40 +01:00
|
|
|
if(dkl.dkl_map[i].dkl_cylno <= 0 || dkl.dkl_map[i].dkl_nblk <= 0)
|
2023-10-04 07:39:22 +01:00
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
var part = new Partition
|
2017-07-30 15:53:42 +01:00
|
|
|
{
|
2023-10-04 07:39:22 +01:00
|
|
|
Size = (ulong)dkl.dkl_map[i].dkl_nblk * DK_LABEL_SIZE,
|
|
|
|
|
Length = (ulong)(dkl.dkl_map[i].dkl_nblk * DK_LABEL_SIZE / imagePlugin.Info.SectorSize),
|
|
|
|
|
Sequence = (ulong)i,
|
2023-10-04 17:34:40 +01:00
|
|
|
Offset = ((ulong)dkl.dkl_map[i].dkl_cylno * sectorsPerCylinder + sectorOffset) * DK_LABEL_SIZE,
|
2023-10-04 07:39:22 +01:00
|
|
|
Start = ((ulong)dkl.dkl_map[i].dkl_cylno * sectorsPerCylinder + sectorOffset) *
|
2023-10-04 17:34:40 +01:00
|
|
|
DK_LABEL_SIZE /
|
|
|
|
|
imagePlugin.Info.SectorSize,
|
2023-10-04 07:39:22 +01:00
|
|
|
Type = Localization.SunOS_partition,
|
|
|
|
|
Scheme = Name
|
|
|
|
|
};
|
|
|
|
|
|
2023-10-04 17:34:40 +01:00
|
|
|
if(part.Start < imagePlugin.Info.Sectors && part.End <= imagePlugin.Info.Sectors)
|
2023-10-04 07:39:22 +01:00
|
|
|
partitions.Add(part);
|
2023-10-03 23:36:49 +01:00
|
|
|
}
|
2022-03-06 13:29:38 +00:00
|
|
|
}
|
|
|
|
|
else if(useDkl8)
|
|
|
|
|
{
|
2023-10-03 23:36:49 +01:00
|
|
|
var sectorsPerCylinder = (ulong)(dkl8.dkl_nsect * dkl8.dkl_nhead);
|
2020-02-29 18:03:35 +00:00
|
|
|
|
2023-10-03 18:46:31 +01:00
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl8.dkl_asciilabel = \"{0}\"",
|
2022-03-06 13:29:38 +00:00
|
|
|
StringHandlers.CToString(dkl8.dkl_asciilabel));
|
2020-02-29 18:03:35 +00:00
|
|
|
|
2023-10-03 18:46:31 +01:00
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl8.dkl_vtoc.v_version = {0}", dkl8.dkl_vtoc.v_version);
|
2020-02-29 18:03:35 +00:00
|
|
|
|
2023-10-03 18:46:31 +01:00
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl8.dkl_vtoc.v_volume = \"{0}\"",
|
2022-03-06 13:29:38 +00:00
|
|
|
StringHandlers.CToString(dkl8.dkl_vtoc.v_volume));
|
2020-02-29 18:03:35 +00:00
|
|
|
|
2023-10-03 23:36:49 +01:00
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl8.dkl_vtoc.v_nparts = {0}", dkl8.dkl_vtoc.v_nparts);
|
2023-10-03 18:46:31 +01:00
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl8.dkl_vtoc.v_sanity = 0x{0:X8}", dkl8.dkl_vtoc.v_sanity);
|
2023-10-03 23:36:49 +01:00
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl8.dkl_write_reinstruct = {0}", dkl8.dkl_write_reinstruct);
|
|
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl8.dkl_read_reinstruct = {0}", dkl8.dkl_read_reinstruct);
|
|
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl8.dkl_rpm = {0}", dkl8.dkl_rpm);
|
|
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl8.dkl_pcyl = {0}", dkl8.dkl_pcyl);
|
|
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl8.dkl_apc = {0}", dkl8.dkl_apc);
|
|
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl8.dkl_obs1 = {0}", dkl8.dkl_obs1);
|
|
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl8.dkl_obs2 = {0}", dkl8.dkl_obs2);
|
|
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl8.dkl_intrlv = {0}", dkl8.dkl_intrlv);
|
|
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl8.dkl_ncyl = {0}", dkl8.dkl_ncyl);
|
|
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl8.dkl_acyl = {0}", dkl8.dkl_acyl);
|
|
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl8.dkl_nhead = {0}", dkl8.dkl_nhead);
|
|
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl8.dkl_nsect = {0}", dkl8.dkl_nsect);
|
|
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl8.dkl_obs3 = {0}", dkl8.dkl_obs3);
|
|
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl8.dkl_obs4 = {0}", dkl8.dkl_obs4);
|
|
|
|
|
|
|
|
|
|
for(var i = 0; i < NDKMAP; i++)
|
2022-03-06 13:29:38 +00:00
|
|
|
{
|
2023-10-03 18:46:31 +01:00
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl8.dkl_map[{0}].dkl_cylno = {1}", i,
|
2022-03-06 13:29:38 +00:00
|
|
|
dkl8.dkl_map[i].dkl_cylno);
|
2017-12-19 20:33:03 +00:00
|
|
|
|
2023-10-03 18:46:31 +01:00
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl8.dkl_map[{0}].dkl_nblk = {1}", i,
|
2022-03-06 13:29:38 +00:00
|
|
|
dkl8.dkl_map[i].dkl_nblk);
|
2016-02-05 05:39:15 +00:00
|
|
|
|
2023-10-03 18:46:31 +01:00
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl8.dkl_vtoc.v_part[{0}].p_tag = {1} ({2})", i,
|
2022-03-06 13:29:38 +00:00
|
|
|
dkl8.dkl_vtoc.v_part[i].p_tag, (ushort)dkl8.dkl_vtoc.v_part[i].p_tag);
|
2017-07-30 15:53:42 +01:00
|
|
|
|
2023-10-03 18:46:31 +01:00
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl8.dkl_vtoc.v_part[{0}].p_flag = {1} ({2})", i,
|
2022-03-06 13:29:38 +00:00
|
|
|
dkl8.dkl_vtoc.v_part[i].p_flag, (ushort)dkl8.dkl_vtoc.v_part[i].p_flag);
|
|
|
|
|
|
2023-10-03 18:46:31 +01:00
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl8.dkl_vtoc.v_timestamp[{0}] = {1}", i,
|
2022-03-06 13:29:38 +00:00
|
|
|
DateHandlers.UnixToDateTime(dkl8.dkl_vtoc.v_timestamp[i]));
|
2017-07-30 15:53:42 +01:00
|
|
|
}
|
2020-02-29 18:03:35 +00:00
|
|
|
|
2023-10-03 18:46:31 +01:00
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl8.dkl_magic = 0x{0:X4}", dkl8.dkl_magic);
|
|
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl8.dkl_cksum = 0x{0:X4}", dkl8.dkl_cksum);
|
2023-10-03 23:36:49 +01:00
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "sectorsPerCylinder = {0}", sectorsPerCylinder);
|
2020-02-29 18:03:35 +00:00
|
|
|
|
2022-03-06 13:29:38 +00:00
|
|
|
if(dkl8.dkl_vtoc.v_nparts > NDKMAP)
|
|
|
|
|
return false;
|
2020-02-29 18:03:35 +00:00
|
|
|
|
2023-10-03 23:36:49 +01:00
|
|
|
for(var i = 0; i < dkl8.dkl_vtoc.v_nparts; i++)
|
|
|
|
|
{
|
2023-10-04 07:39:22 +01:00
|
|
|
if(dkl8.dkl_map[i].dkl_nblk <= 0 ||
|
|
|
|
|
dkl8.dkl_vtoc.v_part[i].p_tag == SunTag.SunEmpty ||
|
|
|
|
|
dkl8.dkl_vtoc.v_part[i].p_tag == SunTag.SunWholeDisk)
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
var part = new Partition
|
|
|
|
|
{
|
|
|
|
|
Description = SunFlagsToString(dkl8.dkl_vtoc.v_part[i].p_flag),
|
2023-10-04 17:34:40 +01:00
|
|
|
Size = (ulong)dkl8.dkl_map[i].dkl_nblk * DK_LABEL_SIZE,
|
|
|
|
|
Length = (ulong)(dkl8.dkl_map[i].dkl_nblk * DK_LABEL_SIZE / imagePlugin.Info.SectorSize),
|
|
|
|
|
Sequence = (ulong)i,
|
|
|
|
|
Offset = ((ulong)dkl8.dkl_map[i].dkl_cylno * sectorsPerCylinder + sectorOffset) * DK_LABEL_SIZE,
|
2023-10-04 07:39:22 +01:00
|
|
|
Start = ((ulong)dkl8.dkl_map[i].dkl_cylno * sectorsPerCylinder + sectorOffset) *
|
2023-10-04 17:34:40 +01:00
|
|
|
DK_LABEL_SIZE /
|
|
|
|
|
imagePlugin.Info.SectorSize,
|
2023-10-04 07:39:22 +01:00
|
|
|
Type = SunIdToString(dkl8.dkl_vtoc.v_part[i].p_tag),
|
|
|
|
|
Scheme = Name
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
if(dkl8.dkl_vtoc.v_timestamp[i] != 0)
|
2022-03-06 13:29:38 +00:00
|
|
|
{
|
2023-10-04 17:34:40 +01:00
|
|
|
part.Description +=
|
|
|
|
|
"\n" +
|
|
|
|
|
string.Format(Localization.Partition_timestamped_on_0,
|
|
|
|
|
DateHandlers.UnixToDateTime(dkl8.dkl_vtoc.v_timestamp[i]));
|
2022-03-06 13:29:38 +00:00
|
|
|
}
|
2023-10-04 07:39:22 +01:00
|
|
|
|
2023-10-04 17:34:40 +01:00
|
|
|
if(part.Start < imagePlugin.Info.Sectors && part.End <= imagePlugin.Info.Sectors)
|
2023-10-04 07:39:22 +01:00
|
|
|
partitions.Add(part);
|
2023-10-03 23:36:49 +01:00
|
|
|
}
|
2022-03-06 13:29:38 +00:00
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2023-10-03 18:46:31 +01:00
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl16.dkl_vtoc.v_sanity = 0x{0:X8}", dkl16.dkl_vtoc.v_sanity);
|
2023-10-03 23:36:49 +01:00
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl16.dkl_vtoc.v_version = {0}", dkl16.dkl_vtoc.v_version);
|
2020-02-29 18:03:35 +00:00
|
|
|
|
2023-10-03 18:46:31 +01:00
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl16.dkl_vtoc.v_volume = \"{0}\"",
|
2022-03-06 13:29:38 +00:00
|
|
|
StringHandlers.CToString(dkl16.dkl_vtoc.v_volume));
|
2020-02-29 18:03:35 +00:00
|
|
|
|
2023-10-03 18:46:31 +01:00
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl16.dkl_vtoc.v_sectorsz = {0}", dkl16.dkl_vtoc.v_sectorsz);
|
2023-10-03 23:36:49 +01:00
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl16.dkl_vtoc.v_nparts = {0}", dkl16.dkl_vtoc.v_nparts);
|
2020-02-29 18:03:35 +00:00
|
|
|
|
2023-10-03 18:46:31 +01:00
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl16.dkl_vtoc.v_asciilabel = \"{0}\"",
|
2022-03-06 13:29:38 +00:00
|
|
|
StringHandlers.CToString(dkl16.dkl_vtoc.v_asciilabel));
|
2020-02-29 18:03:35 +00:00
|
|
|
|
2023-10-03 23:36:49 +01:00
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl16.dkl_pcyl = {0}", dkl16.dkl_pcyl);
|
|
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl16.dkl_ncyl = {0}", dkl16.dkl_ncyl);
|
|
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl16.dkl_acyl = {0}", dkl16.dkl_acyl);
|
|
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl16.dkl_bcyl = {0}", dkl16.dkl_bcyl);
|
|
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl16.dkl_nhead = {0}", dkl16.dkl_nhead);
|
|
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl16.dkl_nsect = {0}", dkl16.dkl_nsect);
|
2023-10-03 18:46:31 +01:00
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl16.dkl_intrlv = {0}", dkl16.dkl_intrlv);
|
2023-10-03 23:36:49 +01:00
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl16.dkl_skew = {0}", dkl16.dkl_skew);
|
|
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl16.dkl_apc = {0}", dkl16.dkl_apc);
|
|
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl16.dkl_rpm = {0}", dkl16.dkl_rpm);
|
2020-02-29 18:03:35 +00:00
|
|
|
|
2023-10-03 18:46:31 +01:00
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl16.dkl_write_reinstruct = {0}", dkl16.dkl_write_reinstruct);
|
2020-02-29 18:03:35 +00:00
|
|
|
|
2023-10-03 18:46:31 +01:00
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl16.dkl_read_reinstruct = {0}", dkl16.dkl_read_reinstruct);
|
2020-02-29 18:03:35 +00:00
|
|
|
|
2023-10-03 23:36:49 +01:00
|
|
|
for(var i = 0; i < NDKMAP16; i++)
|
2022-03-06 13:29:38 +00:00
|
|
|
{
|
2023-10-03 18:46:31 +01:00
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl16.dkl_vtoc.v_part[{0}].p_start = {1}", i,
|
2022-03-06 13:29:38 +00:00
|
|
|
dkl16.dkl_vtoc.v_part[i].p_start);
|
2020-02-29 18:03:35 +00:00
|
|
|
|
2023-10-03 18:46:31 +01:00
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl16.dkl_vtoc.v_part[{0}].p_size = {1}", i,
|
2022-03-06 13:29:38 +00:00
|
|
|
dkl16.dkl_vtoc.v_part[i].p_size);
|
2017-12-19 20:33:03 +00:00
|
|
|
|
2023-10-03 18:46:31 +01:00
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl16.dkl_vtoc.v_part[{0}].p_tag = {1} ({2})", i,
|
2022-03-06 13:29:38 +00:00
|
|
|
dkl16.dkl_vtoc.v_part[i].p_tag, (ushort)dkl16.dkl_vtoc.v_part[i].p_tag);
|
2017-07-30 15:53:42 +01:00
|
|
|
|
2023-10-03 18:46:31 +01:00
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl16.dkl_vtoc.v_part[{0}].p_flag = {1} ({2})", i,
|
2022-03-07 07:36:44 +00:00
|
|
|
dkl16.dkl_vtoc.v_part[i].p_flag, (ushort)dkl16.dkl_vtoc.v_part[i].p_flag);
|
2017-07-30 15:53:42 +01:00
|
|
|
|
2023-10-03 18:46:31 +01:00
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl16.dkl_vtoc.v_timestamp[{0}] = {1}", i,
|
2022-03-06 13:29:38 +00:00
|
|
|
DateHandlers.UnixToDateTime(dkl16.dkl_vtoc.v_timestamp[i]));
|
2016-02-05 05:39:15 +00:00
|
|
|
}
|
|
|
|
|
|
2023-10-03 18:46:31 +01:00
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl16.dkl_magic = 0x{0:X4}", dkl16.dkl_magic);
|
|
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, "dkl16.dkl_cksum = 0x{0:X4}", dkl16.dkl_cksum);
|
2020-02-29 18:03:35 +00:00
|
|
|
|
2022-03-06 13:29:38 +00:00
|
|
|
if(dkl16.dkl_vtoc.v_nparts > NDKMAP16)
|
|
|
|
|
return false;
|
2017-07-30 15:53:42 +01:00
|
|
|
|
2023-10-03 23:36:49 +01:00
|
|
|
for(var i = 0; i < dkl16.dkl_vtoc.v_nparts; i++)
|
|
|
|
|
{
|
2023-10-04 07:39:22 +01:00
|
|
|
if(dkl16.dkl_vtoc.v_part[i].p_size <= 0 ||
|
|
|
|
|
dkl16.dkl_vtoc.v_part[i].p_tag == SunTag.SunEmpty ||
|
|
|
|
|
dkl16.dkl_vtoc.v_part[i].p_tag == SunTag.SunWholeDisk)
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
var part = new Partition
|
2022-03-06 13:29:38 +00:00
|
|
|
{
|
2023-10-04 07:39:22 +01:00
|
|
|
Description = SunFlagsToString(dkl16.dkl_vtoc.v_part[i].p_flag),
|
|
|
|
|
Size = (ulong)dkl16.dkl_vtoc.v_part[i].p_size * dkl16.dkl_vtoc.v_sectorsz,
|
2023-10-04 17:34:40 +01:00
|
|
|
Length = (ulong)(dkl16.dkl_vtoc.v_part[i].p_size *
|
|
|
|
|
dkl16.dkl_vtoc.v_sectorsz /
|
2023-10-04 07:39:22 +01:00
|
|
|
imagePlugin.Info.SectorSize),
|
|
|
|
|
Sequence = (ulong)i,
|
|
|
|
|
Offset = ((ulong)dkl16.dkl_vtoc.v_part[i].p_start + sectorOffset) * dkl16.dkl_vtoc.v_sectorsz,
|
2023-10-04 17:34:40 +01:00
|
|
|
Start = ((ulong)dkl16.dkl_vtoc.v_part[i].p_start + sectorOffset) *
|
|
|
|
|
dkl16.dkl_vtoc.v_sectorsz /
|
2023-10-04 07:39:22 +01:00
|
|
|
imagePlugin.Info.SectorSize,
|
|
|
|
|
Type = SunIdToString(dkl16.dkl_vtoc.v_part[i].p_tag),
|
|
|
|
|
Scheme = Name
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
if(dkl16.dkl_vtoc.v_timestamp[i] != 0)
|
|
|
|
|
{
|
2023-10-04 17:34:40 +01:00
|
|
|
part.Description +=
|
|
|
|
|
"\n" +
|
|
|
|
|
string.Format(Localization.Partition_timestamped_on_0,
|
|
|
|
|
DateHandlers.UnixToDateTime(dkl16.dkl_vtoc.v_timestamp[i]));
|
2022-03-06 13:29:38 +00:00
|
|
|
}
|
2023-10-04 07:39:22 +01:00
|
|
|
|
2023-10-04 17:34:40 +01:00
|
|
|
if(part.Start < imagePlugin.Info.Sectors && part.End <= imagePlugin.Info.Sectors)
|
2023-10-04 07:39:22 +01:00
|
|
|
partitions.Add(part);
|
2023-10-03 23:36:49 +01:00
|
|
|
}
|
2017-07-30 15:53:42 +01:00
|
|
|
}
|
|
|
|
|
|
2022-03-06 13:29:38 +00:00
|
|
|
return partitions.Count > 0;
|
|
|
|
|
}
|
2020-02-29 18:03:35 +00:00
|
|
|
|
2023-10-03 23:36:49 +01:00
|
|
|
#endregion
|
|
|
|
|
|
2022-03-06 13:29:38 +00:00
|
|
|
static dk_label SwapDiskLabel(dk_label label)
|
|
|
|
|
{
|
2023-10-03 18:46:31 +01:00
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Swapping_dk_label);
|
2022-03-06 13:29:38 +00:00
|
|
|
label = (dk_label)Marshal.SwapStructureMembersEndian(label);
|
2019-02-27 08:49:42 +00:00
|
|
|
|
2023-10-03 23:36:49 +01:00
|
|
|
for(var i = 0; i < label.dkl_map.Length; i++)
|
2022-03-06 13:29:38 +00:00
|
|
|
label.dkl_map[i] = (dk_map)Marshal.SwapStructureMembersEndian(label.dkl_map[i]);
|
2020-02-29 18:03:35 +00:00
|
|
|
|
2022-03-06 13:29:38 +00:00
|
|
|
return label;
|
|
|
|
|
}
|
2018-03-08 20:00:01 +00:00
|
|
|
|
2022-03-06 13:29:38 +00:00
|
|
|
static dk_label8 SwapDiskLabel(dk_label8 label)
|
|
|
|
|
{
|
2023-10-03 18:46:31 +01:00
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Swapping_dk_label8);
|
2022-03-06 13:29:38 +00:00
|
|
|
label = (dk_label8)Marshal.SwapStructureMembersEndian(label);
|
2020-02-29 18:03:35 +00:00
|
|
|
|
2023-10-03 23:36:49 +01:00
|
|
|
for(var i = 0; i < label.dkl_map.Length; i++)
|
2022-03-06 13:29:38 +00:00
|
|
|
label.dkl_map[i] = (dk_map)Marshal.SwapStructureMembersEndian(label.dkl_map[i]);
|
2017-07-30 15:53:42 +01:00
|
|
|
|
2023-10-03 23:36:49 +01:00
|
|
|
for(var i = 0; i < label.dkl_vtoc.v_bootinfo.Length; i++)
|
2022-03-06 13:29:38 +00:00
|
|
|
label.dkl_vtoc.v_bootinfo[i] = Swapping.Swap(label.dkl_vtoc.v_bootinfo[i]);
|
2017-07-30 15:53:42 +01:00
|
|
|
|
2023-10-03 23:36:49 +01:00
|
|
|
for(var i = 0; i < label.dkl_vtoc.v_part.Length; i++)
|
2017-07-30 15:53:42 +01:00
|
|
|
{
|
2022-03-06 13:29:38 +00:00
|
|
|
label.dkl_vtoc.v_part[i].p_flag = (SunFlags)Swapping.Swap((ushort)label.dkl_vtoc.v_part[i].p_flag);
|
|
|
|
|
label.dkl_vtoc.v_part[i].p_tag = (SunTag)Swapping.Swap((ushort)label.dkl_vtoc.v_part[i].p_tag);
|
|
|
|
|
}
|
2020-02-29 18:03:35 +00:00
|
|
|
|
2023-10-03 23:36:49 +01:00
|
|
|
for(var i = 0; i < label.dkl_vtoc.v_timestamp.Length; i++)
|
2022-03-06 13:29:38 +00:00
|
|
|
label.dkl_vtoc.v_timestamp[i] = Swapping.Swap(label.dkl_vtoc.v_timestamp[i]);
|
2020-02-29 18:03:35 +00:00
|
|
|
|
2023-10-03 23:36:49 +01:00
|
|
|
for(var i = 0; i < label.dkl_vtoc.v_reserved.Length; i++)
|
2022-03-06 13:29:38 +00:00
|
|
|
label.dkl_vtoc.v_reserved[i] = Swapping.Swap(label.dkl_vtoc.v_reserved[i]);
|
2018-03-08 20:00:01 +00:00
|
|
|
|
2022-03-06 13:29:38 +00:00
|
|
|
return label;
|
|
|
|
|
}
|
2020-02-29 18:03:35 +00:00
|
|
|
|
2022-03-06 13:29:38 +00:00
|
|
|
static dk_label16 SwapDiskLabel(dk_label16 label)
|
|
|
|
|
{
|
2023-10-03 18:46:31 +01:00
|
|
|
AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Swapping_dk_label16);
|
2022-03-06 13:29:38 +00:00
|
|
|
label = (dk_label16)Marshal.SwapStructureMembersEndian(label);
|
2017-07-30 15:53:42 +01:00
|
|
|
|
2023-10-03 23:36:49 +01:00
|
|
|
for(var i = 0; i < label.dkl_vtoc.v_bootinfo.Length; i++)
|
2022-03-06 13:29:38 +00:00
|
|
|
label.dkl_vtoc.v_bootinfo[i] = Swapping.Swap(label.dkl_vtoc.v_bootinfo[i]);
|
2016-02-05 05:39:15 +00:00
|
|
|
|
2023-10-03 23:36:49 +01:00
|
|
|
for(var i = 0; i < label.dkl_vtoc.v_part.Length; i++)
|
2016-02-05 05:39:15 +00:00
|
|
|
{
|
2022-03-06 13:29:38 +00:00
|
|
|
label.dkl_vtoc.v_part[i].p_flag = (SunFlags)Swapping.Swap((ushort)label.dkl_vtoc.v_part[i].p_flag);
|
|
|
|
|
label.dkl_vtoc.v_part[i].p_tag = (SunTag)Swapping.Swap((ushort)label.dkl_vtoc.v_part[i].p_tag);
|
|
|
|
|
label.dkl_vtoc.v_part[i].p_size = Swapping.Swap(label.dkl_vtoc.v_part[i].p_size);
|
|
|
|
|
label.dkl_vtoc.v_part[i].p_start = Swapping.Swap(label.dkl_vtoc.v_part[i].p_start);
|
|
|
|
|
}
|
2020-02-29 18:03:35 +00:00
|
|
|
|
2023-10-03 23:36:49 +01:00
|
|
|
for(var i = 0; i < label.dkl_vtoc.v_timestamp.Length; i++)
|
2022-03-06 13:29:38 +00:00
|
|
|
label.dkl_vtoc.v_timestamp[i] = Swapping.Swap(label.dkl_vtoc.v_timestamp[i]);
|
2020-02-29 18:03:35 +00:00
|
|
|
|
2023-10-03 23:36:49 +01:00
|
|
|
for(var i = 0; i < label.dkl_vtoc.v_reserved.Length; i++)
|
2022-03-06 13:29:38 +00:00
|
|
|
label.dkl_vtoc.v_reserved[i] = Swapping.Swap(label.dkl_vtoc.v_reserved[i]);
|
2020-02-29 18:03:35 +00:00
|
|
|
|
2022-03-06 13:29:38 +00:00
|
|
|
return label;
|
|
|
|
|
}
|
2016-02-05 05:39:15 +00:00
|
|
|
|
2022-03-06 13:29:38 +00:00
|
|
|
static string SunFlagsToString(SunFlags flags)
|
|
|
|
|
{
|
|
|
|
|
var sb = new StringBuilder();
|
2016-02-05 05:39:15 +00:00
|
|
|
|
2022-03-06 13:29:38 +00:00
|
|
|
if(flags.HasFlag(SunFlags.NoMount))
|
2022-11-29 03:13:21 +00:00
|
|
|
sb.AppendLine(Localization.Unmountable);
|
2017-12-24 03:11:33 +00:00
|
|
|
|
2022-03-06 13:29:38 +00:00
|
|
|
if(flags.HasFlag(SunFlags.ReadOnly))
|
2022-11-29 03:13:21 +00:00
|
|
|
sb.AppendLine(Localization.Read_only);
|
2017-12-24 03:11:33 +00:00
|
|
|
|
2022-03-06 13:29:38 +00:00
|
|
|
return sb.ToString();
|
|
|
|
|
}
|
2016-02-05 05:39:15 +00:00
|
|
|
|
2022-11-13 19:59:24 +00:00
|
|
|
static string SunIdToString(SunTag id) => id switch
|
2023-10-03 23:36:49 +01:00
|
|
|
{
|
|
|
|
|
SunTag.Linux => Localization.Linux,
|
|
|
|
|
SunTag.LinuxRaid => Localization.Linux_RAID,
|
|
|
|
|
SunTag.LinuxSwap => Localization.Linux_swap,
|
|
|
|
|
SunTag.LVM => Localization.LVM,
|
|
|
|
|
SunTag.SunBoot => Localization.Sun_boot,
|
|
|
|
|
SunTag.SunEmpty => Localization.Empty,
|
|
|
|
|
SunTag.SunHome => Localization.Sun_home,
|
|
|
|
|
SunTag.SunRoot => Localization.Sun_root,
|
|
|
|
|
SunTag.SunStand => Localization.Sun_stand,
|
|
|
|
|
SunTag.SunSwap => Localization.Sun_swap,
|
|
|
|
|
SunTag.SunUsr => Localization.Sun_usr,
|
|
|
|
|
SunTag.SunVar => Localization.Sun_var,
|
|
|
|
|
SunTag.SunWholeDisk => Localization.Whole_disk,
|
|
|
|
|
SunTag.SunAlt => Localization.Replacement_sectors,
|
|
|
|
|
SunTag.SunCache => Localization.Sun_cachefs,
|
|
|
|
|
SunTag.SunReserved => Localization.Reserved_for_SMI,
|
|
|
|
|
SunTag.VxVmPublic => Localization.Veritas_public,
|
|
|
|
|
SunTag.VxVmPrivate => Localization.Veritas_private,
|
|
|
|
|
SunTag.NetBSD => Localization.NetBSD,
|
|
|
|
|
SunTag.FreeBSD_Swap => Localization.FreeBSD_swap,
|
|
|
|
|
SunTag.FreeBSD_UFS => Localization.FreeBSD,
|
|
|
|
|
SunTag.FreeBSD_Vinum => Localization.Vinum,
|
|
|
|
|
SunTag.FreeBSD_ZFS => Localization.FreeBSD_ZFS,
|
|
|
|
|
SunTag.FreeBSD_NANDFS => Localization.FreeBSD_nandfs,
|
|
|
|
|
_ => Localization.Unknown_partition_type
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
#region Nested type: dk_label
|
2017-07-30 15:53:42 +01:00
|
|
|
|
2022-03-06 13:29:38 +00:00
|
|
|
/// <summary>SunOS disk label</summary>
|
|
|
|
|
[StructLayout(LayoutKind.Sequential, Pack = 1)]
|
|
|
|
|
struct dk_label
|
|
|
|
|
{
|
|
|
|
|
/// <summary>Informative string</summary>
|
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = LEN_DKL_ASCII)]
|
|
|
|
|
public readonly byte[] dkl_asciilabel;
|
|
|
|
|
/// <summary>Padding</summary>
|
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = LEN_DKL_PAD)]
|
|
|
|
|
public readonly byte[] dkl_pad;
|
|
|
|
|
/// <summary>rotations per minute</summary>
|
|
|
|
|
public readonly ushort dkl_rpm;
|
|
|
|
|
/// <summary># physical cylinders</summary>
|
|
|
|
|
public readonly ushort dkl_pcyl;
|
|
|
|
|
/// <summary>alternates per cylinder</summary>
|
|
|
|
|
public readonly ushort dkl_apc;
|
|
|
|
|
/// <summary>size of gap 1</summary>
|
|
|
|
|
public readonly ushort dkl_gap1;
|
|
|
|
|
/// <summary>size of gap 2</summary>
|
|
|
|
|
public readonly ushort dkl_gap2;
|
|
|
|
|
/// <summary>interleave factor</summary>
|
|
|
|
|
public readonly ushort dkl_intrlv;
|
|
|
|
|
/// <summary># of data cylinders</summary>
|
|
|
|
|
public readonly ushort dkl_ncyl;
|
|
|
|
|
/// <summary># of alternate cylinders</summary>
|
|
|
|
|
public readonly ushort dkl_acyl;
|
|
|
|
|
/// <summary># of heads in this partition</summary>
|
|
|
|
|
public readonly ushort dkl_nhead;
|
|
|
|
|
/// <summary># of 512 byte sectors per track</summary>
|
|
|
|
|
public readonly ushort dkl_nsect;
|
|
|
|
|
/// <summary>identifies proper label location</summary>
|
|
|
|
|
public readonly ushort dkl_bhead;
|
|
|
|
|
/// <summary>physical partition #</summary>
|
|
|
|
|
public readonly ushort dkl_ppart;
|
|
|
|
|
/// <summary>Logical partitions</summary>
|
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = NDKMAP)]
|
|
|
|
|
public readonly dk_map[] dkl_map;
|
|
|
|
|
/// <summary>identifies this label format</summary>
|
|
|
|
|
public readonly ushort dkl_magic;
|
|
|
|
|
/// <summary>xor checksum of sector</summary>
|
|
|
|
|
public readonly ushort dkl_cksum;
|
|
|
|
|
}
|
2016-02-05 05:39:15 +00:00
|
|
|
|
2023-10-03 23:36:49 +01:00
|
|
|
#endregion
|
2016-02-05 05:39:15 +00:00
|
|
|
|
2023-10-03 23:36:49 +01:00
|
|
|
#region Nested type: dk_label16
|
2022-03-06 13:29:38 +00:00
|
|
|
|
|
|
|
|
[StructLayout(LayoutKind.Sequential, Pack = 1)]
|
2023-10-03 23:36:49 +01:00
|
|
|
struct dk_label16
|
2022-03-06 13:29:38 +00:00
|
|
|
{
|
2023-10-03 23:36:49 +01:00
|
|
|
/// <summary>vtoc inclusions from AT&T SVr4</summary>
|
|
|
|
|
public readonly dk_vtoc16 dkl_vtoc;
|
|
|
|
|
/// <summary># of physical cylinders</summary>
|
|
|
|
|
public readonly uint dkl_pcyl;
|
|
|
|
|
/// <summary># of data cylinders</summary>
|
|
|
|
|
public readonly uint dkl_ncyl;
|
|
|
|
|
/// <summary># of alternate cylinders</summary>
|
|
|
|
|
public readonly ushort dkl_acyl;
|
|
|
|
|
/// <summary>cyl offset (for fixed head area)</summary>
|
|
|
|
|
public readonly ushort dkl_bcyl;
|
|
|
|
|
/// <summary># of heads</summary>
|
|
|
|
|
public readonly uint dkl_nhead;
|
|
|
|
|
/// <summary># of data sectors per track</summary>
|
|
|
|
|
public readonly uint dkl_nsect;
|
|
|
|
|
/// <summary>interleave factor</summary>
|
|
|
|
|
public readonly ushort dkl_intrlv;
|
|
|
|
|
/// <summary>skew factor</summary>
|
|
|
|
|
public readonly ushort dkl_skew;
|
|
|
|
|
/// <summary>alternates per cyl (SCSI only) </summary>
|
|
|
|
|
public readonly ushort dkl_apc;
|
|
|
|
|
/// <summary>revolutions per minute</summary>
|
|
|
|
|
public readonly ushort dkl_rpm;
|
|
|
|
|
/// <summary># sectors to skip, writes</summary>
|
|
|
|
|
public readonly ushort dkl_write_reinstruct;
|
|
|
|
|
/// <summary># sectors to skip, reads </summary>
|
|
|
|
|
public readonly ushort dkl_read_reinstruct;
|
|
|
|
|
/// <summary>for compatible expansion</summary>
|
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
|
|
|
|
|
public readonly ushort[] dkl_extra;
|
|
|
|
|
/// <summary>unused part of 512 bytes</summary>
|
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = LEN_DKL_PAD16)]
|
|
|
|
|
public readonly byte[] dkl_pad;
|
|
|
|
|
/// <summary>identifies this label format</summary>
|
|
|
|
|
public readonly ushort dkl_magic;
|
|
|
|
|
/// <summary>xor checksum of sector</summary>
|
|
|
|
|
public readonly ushort dkl_cksum;
|
2022-03-06 13:29:38 +00:00
|
|
|
}
|
|
|
|
|
|
2023-10-03 23:36:49 +01:00
|
|
|
#endregion
|
|
|
|
|
|
|
|
|
|
#region Nested type: dk_label8
|
2022-03-06 13:29:38 +00:00
|
|
|
|
|
|
|
|
[StructLayout(LayoutKind.Sequential, Pack = 1)]
|
|
|
|
|
struct dk_label8
|
|
|
|
|
{
|
|
|
|
|
/// <summary>for compatibility</summary>
|
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = LEN_DKL_ASCII)]
|
|
|
|
|
public readonly byte[] dkl_asciilabel;
|
|
|
|
|
/// <summary>vtoc inclusions from AT&T SVr4</summary>
|
|
|
|
|
public readonly dk_vtoc8 dkl_vtoc;
|
|
|
|
|
/// <summary># sectors to skip, writes</summary>
|
|
|
|
|
public readonly ushort dkl_write_reinstruct;
|
|
|
|
|
/// <summary># sectors to skip, reads</summary>
|
|
|
|
|
public readonly ushort dkl_read_reinstruct;
|
|
|
|
|
/// <summary>unused part of 512 bytes</summary>
|
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = LEN_DKL_PAD8)]
|
|
|
|
|
public readonly byte[] dkl_pad;
|
|
|
|
|
/// <summary>rotations per minute</summary>
|
|
|
|
|
public readonly ushort dkl_rpm;
|
|
|
|
|
/// <summary># physical cylinders</summary>
|
|
|
|
|
public readonly ushort dkl_pcyl;
|
|
|
|
|
/// <summary>alternates per cylinder</summary>
|
|
|
|
|
public readonly ushort dkl_apc;
|
|
|
|
|
/// <summary>obsolete</summary>
|
|
|
|
|
public readonly ushort dkl_obs1;
|
|
|
|
|
/// <summary>obsolete</summary>
|
|
|
|
|
public readonly ushort dkl_obs2;
|
|
|
|
|
/// <summary>interleave factor</summary>
|
|
|
|
|
public readonly ushort dkl_intrlv;
|
|
|
|
|
/// <summary># of data cylinders</summary>
|
|
|
|
|
public readonly ushort dkl_ncyl;
|
|
|
|
|
/// <summary># of alternate cylinders</summary>
|
|
|
|
|
public readonly ushort dkl_acyl;
|
|
|
|
|
/// <summary># of heads in this partition</summary>
|
|
|
|
|
public readonly ushort dkl_nhead;
|
|
|
|
|
/// <summary># of 512 byte sectors per track</summary>
|
|
|
|
|
public readonly ushort dkl_nsect;
|
|
|
|
|
/// <summary>obsolete</summary>
|
|
|
|
|
public readonly ushort dkl_obs3;
|
|
|
|
|
/// <summary>obsolete</summary>
|
|
|
|
|
public readonly ushort dkl_obs4;
|
|
|
|
|
/// <summary>logical partition headers</summary>
|
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = NDKMAP)]
|
|
|
|
|
public readonly dk_map[] dkl_map;
|
|
|
|
|
/// <summary>identifies this label format</summary>
|
|
|
|
|
public readonly ushort dkl_magic;
|
|
|
|
|
/// <summary>xor checksum of sector</summary>
|
|
|
|
|
public readonly ushort dkl_cksum;
|
|
|
|
|
}
|
|
|
|
|
|
2023-10-03 23:36:49 +01:00
|
|
|
#endregion
|
|
|
|
|
|
|
|
|
|
#region Nested type: dk_map
|
|
|
|
|
|
|
|
|
|
/// <summary>SunOS logical partitions</summary>
|
2022-03-06 13:29:38 +00:00
|
|
|
[StructLayout(LayoutKind.Sequential, Pack = 1)]
|
2023-10-03 23:36:49 +01:00
|
|
|
struct dk_map
|
2022-03-06 13:29:38 +00:00
|
|
|
{
|
2023-10-03 23:36:49 +01:00
|
|
|
/// <summary>starting cylinder</summary>
|
|
|
|
|
public readonly int dkl_cylno;
|
|
|
|
|
/// <summary>number of blocks</summary>
|
|
|
|
|
public readonly int dkl_nblk;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
|
|
|
|
#region Nested type: dk_map2
|
|
|
|
|
|
|
|
|
|
/// <summary>Solaris logical partition for small disk label</summary>
|
|
|
|
|
[StructLayout(LayoutKind.Sequential, Pack = 1)]
|
|
|
|
|
struct dk_map2
|
|
|
|
|
{
|
|
|
|
|
/// <summary> ID tag of partition</summary>
|
|
|
|
|
public SunTag p_tag;
|
|
|
|
|
/// <summary> permission flag</summary>
|
|
|
|
|
public SunFlags p_flag;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
|
|
|
|
#region Nested type: dk_vtoc16
|
|
|
|
|
|
|
|
|
|
[StructLayout(LayoutKind.Sequential, Pack = 1)]
|
|
|
|
|
struct dk_vtoc16
|
|
|
|
|
{
|
|
|
|
|
/// <summary>info needed by mboot</summary>
|
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
|
|
|
|
|
public readonly uint[] v_bootinfo;
|
|
|
|
|
/// <summary>to verify vtoc sanity</summary>
|
|
|
|
|
public readonly uint v_sanity;
|
|
|
|
|
/// <summary>layout version</summary>
|
|
|
|
|
public readonly uint v_version;
|
|
|
|
|
/// <summary>volume name</summary>
|
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = LEN_DKL_VVOL)]
|
|
|
|
|
public readonly byte[] v_volume;
|
|
|
|
|
/// <summary>sector size in bytes</summary>
|
|
|
|
|
public readonly ushort v_sectorsz;
|
|
|
|
|
/// <summary>number of partitions</summary>
|
|
|
|
|
public readonly ushort v_nparts;
|
|
|
|
|
/// <summary>free space</summary>
|
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 10)]
|
|
|
|
|
public readonly uint[] v_reserved;
|
|
|
|
|
/// <summary>partition headers</summary>
|
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = NDKMAP16)]
|
|
|
|
|
public readonly dkl_partition[] v_part;
|
|
|
|
|
/// <summary>partition timestamp</summary>
|
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = NDKMAP16)]
|
|
|
|
|
public readonly int[] v_timestamp;
|
|
|
|
|
/// <summary>for compatibility</summary>
|
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = LEN_DKL_ASCII)]
|
|
|
|
|
public readonly byte[] v_asciilabel;
|
2016-02-05 05:39:15 +00:00
|
|
|
}
|
2023-10-03 23:36:49 +01:00
|
|
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
|
|
|
|
#region Nested type: dk_vtoc8
|
|
|
|
|
|
|
|
|
|
[StructLayout(LayoutKind.Sequential, Pack = 1)]
|
|
|
|
|
struct dk_vtoc8
|
|
|
|
|
{
|
|
|
|
|
/// <summary> layout version</summary>
|
|
|
|
|
public readonly uint v_version;
|
|
|
|
|
/// <summary> volume name</summary>
|
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = LEN_DKL_VVOL)]
|
|
|
|
|
public readonly byte[] v_volume;
|
|
|
|
|
/// <summary> number of partitions </summary>
|
|
|
|
|
public readonly ushort v_nparts;
|
|
|
|
|
/// <summary> partition hdrs, sec 2</summary>
|
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = NDKMAP)]
|
|
|
|
|
public readonly dk_map2[] v_part;
|
|
|
|
|
/// <summary>Alignment</summary>
|
|
|
|
|
public readonly ushort padding;
|
|
|
|
|
/// <summary> info needed by mboot</summary>
|
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
|
|
|
|
|
public readonly uint[] v_bootinfo;
|
|
|
|
|
/// <summary> to verify vtoc sanity</summary>
|
|
|
|
|
public readonly uint v_sanity;
|
|
|
|
|
/// <summary> free space</summary>
|
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 10)]
|
|
|
|
|
public readonly uint[] v_reserved;
|
|
|
|
|
/// <summary> partition timestamp</summary>
|
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = NDKMAP)]
|
|
|
|
|
public readonly int[] v_timestamp;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
|
|
|
|
#region Nested type: dkl_partition
|
|
|
|
|
|
|
|
|
|
/// <summary>Solaris logical partition</summary>
|
|
|
|
|
[StructLayout(LayoutKind.Sequential, Pack = 1)]
|
|
|
|
|
struct dkl_partition
|
|
|
|
|
{
|
|
|
|
|
/// <summary>ID tag of partition</summary>
|
|
|
|
|
public SunTag p_tag;
|
|
|
|
|
/// <summary>permision flags</summary>
|
|
|
|
|
public SunFlags p_flag;
|
|
|
|
|
/// <summary>start sector no of partition</summary>
|
|
|
|
|
public int p_start;
|
|
|
|
|
/// <summary># of blocks in partition</summary>
|
|
|
|
|
public int p_size;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
|
|
|
|
#region Nested type: SunFlags
|
|
|
|
|
|
|
|
|
|
[Flags]
|
|
|
|
|
enum SunFlags : ushort
|
|
|
|
|
{
|
|
|
|
|
NoMount = 0x0001,
|
|
|
|
|
ReadOnly = 0x0010
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
|
|
|
|
#region Nested type: SunTag
|
|
|
|
|
|
|
|
|
|
enum SunTag : ushort
|
|
|
|
|
{
|
|
|
|
|
SunEmpty = 0x0000,
|
|
|
|
|
SunBoot = 0x0001,
|
|
|
|
|
SunRoot = 0x0002,
|
|
|
|
|
SunSwap = 0x0003,
|
|
|
|
|
SunUsr = 0x0004,
|
|
|
|
|
SunWholeDisk = 0x0005,
|
|
|
|
|
SunStand = 0x0006,
|
|
|
|
|
SunVar = 0x0007,
|
|
|
|
|
SunHome = 0x0008,
|
|
|
|
|
SunAlt = 0x0009,
|
|
|
|
|
SunCache = 0x000A,
|
|
|
|
|
SunReserved = 0x000B,
|
|
|
|
|
VxVmPublic = 0x000E,
|
|
|
|
|
VxVmPrivate = 0x000F,
|
|
|
|
|
LinuxSwap = 0x0082,
|
|
|
|
|
Linux = 0x0083,
|
|
|
|
|
LVM = 0x008E,
|
|
|
|
|
LinuxRaid = 0x00FD,
|
|
|
|
|
NetBSD = 0x00FF,
|
|
|
|
|
FreeBSD_Swap = 0x0901,
|
|
|
|
|
FreeBSD_UFS = 0x0902,
|
|
|
|
|
FreeBSD_Vinum = 0x0903,
|
|
|
|
|
FreeBSD_ZFS = 0x0904,
|
|
|
|
|
FreeBSD_NANDFS = 0x0905
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#endregion
|
2016-02-05 05:39:15 +00:00
|
|
|
}
|