public MetadataPartition(UdfContext context, LogicalVolumeDescriptor volumeDescriptor, MetadataPartitionMap partitionMap)
: base(context, volumeDescriptor)
{
_partitionMap = partitionMap;
PhysicalPartition physical = context.PhysicalPartitions[partitionMap.PartitionNumber];
long fileEntryPos = partitionMap.MetadataFileLocation * (long)volumeDescriptor.LogicalBlockSize;
byte[] entryData = Utilities.ReadFully(physical.Content, fileEntryPos, _context.PhysicalSectorSize);
if (!DescriptorTag.IsValid(entryData, 0))
{
throw new IOException("Invalid descriptor tag looking for Metadata file entry");
}
DescriptorTag dt = Utilities.ToStruct <DescriptorTag>(entryData, 0);
if (dt.TagIdentifier == TagIdentifier.ExtendedFileEntry)
{
ExtendedFileEntry efe = Utilities.ToStruct <ExtendedFileEntry>(entryData, 0);
_metadataFile = new File(context, physical, efe, _volumeDescriptor.LogicalBlockSize);
}
else
{
throw new NotImplementedException("Only EFE implemented for Metadata file entry");
}
}
public static LogicalPartition FromDescriptor(UdfContext context, LogicalVolumeDescriptor volumeDescriptor, int index)
{
PartitionMap map = volumeDescriptor.PartitionMaps[index];
Type1PartitionMap asType1 = map as Type1PartitionMap;
if (asType1 != null)
{
return(new Type1Partition(context, volumeDescriptor, asType1));
}
MetadataPartitionMap asMetadata = map as MetadataPartitionMap;
if (asMetadata != null)
{
return(new MetadataPartition(context, volumeDescriptor, asMetadata));
}
throw new NotImplementedException("Unrecognized partition map type");
}
private void Initialize()
{
Context = new UdfContext()
{
PhysicalPartitions = new Dictionary <ushort, PhysicalPartition>(),
PhysicalSectorSize = (int)_sectorSize,
LogicalPartitions = new List <LogicalPartition>(),
};
IBuffer dataBuffer = new StreamBuffer(_data, Ownership.None);
AnchorVolumeDescriptorPointer avdp = AnchorVolumeDescriptorPointer.FromStream(_data, 256, _sectorSize);
uint sector = avdp.MainDescriptorSequence.Location;
bool terminatorFound = false;
while (!terminatorFound)
{
_data.Position = sector * (long)_sectorSize;
DescriptorTag dt;
if (!DescriptorTag.TryFromStream(_data, out dt))
{
break;
}
switch (dt.TagIdentifier)
{
case TagIdentifier.PrimaryVolumeDescriptor:
_pvd = PrimaryVolumeDescriptor.FromStream(_data, sector, _sectorSize);
break;
case TagIdentifier.ImplementationUseVolumeDescriptor:
// Not used
break;
case TagIdentifier.PartitionDescriptor:
PartitionDescriptor pd = PartitionDescriptor.FromStream(_data, sector, _sectorSize);
if (Context.PhysicalPartitions.ContainsKey(pd.PartitionNumber))
{
throw new IOException("Duplicate partition number reading UDF Partition Descriptor");
}
Context.PhysicalPartitions[pd.PartitionNumber] = new PhysicalPartition(pd, dataBuffer, _sectorSize);
break;
case TagIdentifier.LogicalVolumeDescriptor:
_lvd = LogicalVolumeDescriptor.FromStream(_data, sector, _sectorSize);
break;
case TagIdentifier.UnallocatedSpaceDescriptor:
// Not used for reading
break;
case TagIdentifier.TerminatingDescriptor:
terminatorFound = true;
break;
default:
break;
}
sector++;
}
// Convert logical partition descriptors into actual partition objects
for (int i = 0; i < _lvd.PartitionMaps.Length; ++i)
{
Context.LogicalPartitions.Add(LogicalPartition.FromDescriptor(Context, _lvd, i));
}
byte[] fsdBuffer = UdfUtilities.ReadExtent(Context, _lvd.FileSetDescriptorLocation);
if (DescriptorTag.IsValid(fsdBuffer, 0))
{
FileSetDescriptor fsd = Utilities.ToStruct <FileSetDescriptor>(fsdBuffer, 0);
RootDirectory = (Directory)File.FromDescriptor(Context, fsd.RootDirectoryIcb);
}
}
protected LogicalPartition(UdfContext context, LogicalVolumeDescriptor volumeDescriptor)
{
_context = context;
_volumeDescriptor = volumeDescriptor;
}