public static async Task <IEnumerable <LoadSegBlock> > Read(
RigidDiskBlock rigidDiskBlock, FileSystemHeaderBlock fileSystemHeaderBlock, Stream stream)
{
var loadSegBlocks = new List <LoadSegBlock>();
var segListBlock = fileSystemHeaderBlock.SegListBlocks;
do
{
// calculate seg list block offset
var segListBlockOffset = rigidDiskBlock.BlockSize * segListBlock;
// seek partition block offset
stream.Seek(segListBlockOffset, SeekOrigin.Begin);
// read block
var block = await BlockHelper.ReadBlock(stream);
// parse file system header block
var loadSegBlock = await Parse(block);
loadSegBlocks.Add(loadSegBlock);
// get next partition list block and increase partition number
segListBlock = loadSegBlock.NextLoadSegBlock;
} while (segListBlock > 0);
return(loadSegBlocks);
}
public static async Task <IEnumerable <PartitionBlock> > Read(RigidDiskBlock rigidDiskBlock, Stream stream)
{
if (rigidDiskBlock.PartitionList == BlockIdentifiers.EndOfBlock)
{
return(Enumerable.Empty <PartitionBlock>());
}
// get partition list block and set partition number to 1
var partitionList = rigidDiskBlock.PartitionList;
var partitionBlocks = new List <PartitionBlock>();
do
{
// calculate partition block offset
var partitionBlockOffset = rigidDiskBlock.BlockSize * partitionList;
// seek partition block offset
stream.Seek(partitionBlockOffset, SeekOrigin.Begin);
// read block
var blockBytes = await BlockHelper.ReadBlock(stream);
// read partition block
var partitionBlock = await Parse(rigidDiskBlock, blockBytes);
// fail, if partition block is null
if (partitionBlock == null)
{
throw new IOException("Invalid partition block");
}
partitionBlocks.Add(partitionBlock);
// get next partition list block and increase partition number
partitionList = partitionBlock.NextPartitionBlock;
} while (partitionList > 0 && partitionList != BlockIdentifiers.EndOfBlock);
rigidDiskBlock.PartitionBlocks = partitionBlocks;
rigidDiskBlock.FileSystemHeaderBlocks =
await FileSystemHeaderBlockReader.Read(rigidDiskBlock, stream);
return(partitionBlocks);
}
public static async Task <IEnumerable <BadBlock> > Read(RigidDiskBlock rigidDiskBlock, Stream stream)
{
if (rigidDiskBlock == null)
{
throw new ArgumentNullException(nameof(rigidDiskBlock));
}
if (stream == null)
{
throw new ArgumentNullException(nameof(stream));
}
if (rigidDiskBlock.BadBlockList == BlockIdentifiers.EndOfBlock)
{
return(Enumerable.Empty <BadBlock>());
}
var badBlocks = new List <BadBlock>();
var badBlockList = rigidDiskBlock.BadBlockList;
do
{
// calculate block offset
var blockOffset = rigidDiskBlock.BlockSize * badBlockList;
// seek block offset
stream.Seek(blockOffset, SeekOrigin.Begin);
// read block
var block = await BlockHelper.ReadBlock(stream);
// read rigid disk block
var badBlock = await Parse(block);
badBlocks.Add(badBlock);
// get next partition list block and increase partition number
badBlockList = badBlock.NextBadBlock;
} while (badBlockList > 0 && badBlockList != BlockIdentifiers.EndOfBlock);
return(badBlocks);
}
public static async Task <IEnumerable <FileSystemHeaderBlock> > Read(
RigidDiskBlock rigidDiskBlock, Stream stream)
{
if (rigidDiskBlock.FileSysHdrList == BlockIdentifiers.EndOfBlock)
{
return(Enumerable.Empty <FileSystemHeaderBlock>());
}
var fileSystemHeaderBlocks = new List <FileSystemHeaderBlock>();
var fileSysHdrList = rigidDiskBlock.FileSysHdrList;
do
{
// calculate file system header block offset
var fileSystemHeaderBlockOffset = rigidDiskBlock.BlockSize * fileSysHdrList;
// seek partition block offset
stream.Seek(fileSystemHeaderBlockOffset, SeekOrigin.Begin);
// read block
var block = await BlockHelper.ReadBlock(stream);
// parse file system header block
var fileSystemHeaderBlock = await Parse(block);
fileSystemHeaderBlocks.Add(fileSystemHeaderBlock);
// get next partition list block and increase partition number
fileSysHdrList = fileSystemHeaderBlock.NextFileSysHeaderBlock;
} while (fileSysHdrList > 0 && fileSysHdrList != BlockIdentifiers.EndOfBlock);
foreach (var fileSystemHeaderBlock in fileSystemHeaderBlocks)
{
fileSystemHeaderBlock.LoadSegBlocks =
await LoadSegBlockReader.Read(rigidDiskBlock, fileSystemHeaderBlock, stream);
}
return(fileSystemHeaderBlocks);
}
public static async Task <RigidDiskBlock> Read(Stream stream)
{
var rdbIndex = 0;
var blockSize = 512;
var rdbLocationLimit = 16;
RigidDiskBlock rigidDiskBlock;
// read rigid disk block from one of the first 15 blocks
do
{
// calculate block offset
var blockOffset = blockSize * rdbIndex;
// seek block offset
stream.Seek(blockOffset, SeekOrigin.Begin);
// read block
var block = await BlockHelper.ReadBlock(stream);
// read rigid disk block
rigidDiskBlock = await Parse(block);
rdbIndex++;
} while (rdbIndex < rdbLocationLimit && rigidDiskBlock == null);
// fail, if rigid disk block is null
if (rigidDiskBlock == null)
{
return(null);
}
rigidDiskBlock.PartitionBlocks = await PartitionBlockReader.Read(rigidDiskBlock, stream);
rigidDiskBlock.BadBlocks = await BadBlockReader.Read(rigidDiskBlock, stream);
return(rigidDiskBlock);
}
