Beispiel #1
0
        public override int ReadFrom(byte[] buffer, int offset)
        {
            DescriptorTag           = Utilities.ToStruct <DescriptorTag>(buffer, offset);
            InformationControlBlock = Utilities.ToStruct <InformationControlBlock>(buffer, offset + 16);
            Uid                         = Utilities.ToUInt32LittleEndian(buffer, offset + 36);
            Gid                         = Utilities.ToUInt32LittleEndian(buffer, offset + 40);
            Permissions                 = (FilePermissions)Utilities.ToUInt32LittleEndian(buffer, offset + 44);
            FileLinkCount               = Utilities.ToUInt16LittleEndian(buffer, offset + 48);
            RecordFormat                = buffer[offset + 50];
            RecordDisplayAttributes     = buffer[offset + 51];
            RecordLength                = Utilities.ToUInt16LittleEndian(buffer, offset + 52);
            InformationLength           = Utilities.ToUInt64LittleEndian(buffer, offset + 56);
            ObjectSize                  = Utilities.ToUInt64LittleEndian(buffer, offset + 64);
            LogicalBlocksRecorded       = Utilities.ToUInt64LittleEndian(buffer, offset + 72);
            AccessTime                  = UdfUtilities.ParseTimestamp(buffer, offset + 80);
            ModificationTime            = UdfUtilities.ParseTimestamp(buffer, offset + 92);
            CreationTime                = UdfUtilities.ParseTimestamp(buffer, offset + 104);
            AttributeTime               = UdfUtilities.ParseTimestamp(buffer, offset + 116);
            Checkpoint                  = Utilities.ToUInt32LittleEndian(buffer, offset + 128);
            ExtendedAttributeIcb        = Utilities.ToStruct <LongAllocationDescriptor>(buffer, offset + 136);
            StreamDirectoryIcb          = Utilities.ToStruct <LongAllocationDescriptor>(buffer, offset + 152);
            ImplementationIdentifier    = Utilities.ToStruct <ImplementationEntityIdentifier>(buffer, offset + 168);
            UniqueId                    = Utilities.ToUInt64LittleEndian(buffer, offset + 200);
            ExtendedAttributesLength    = Utilities.ToInt32LittleEndian(buffer, offset + 208);
            AllocationDescriptorsLength = Utilities.ToInt32LittleEndian(buffer, offset + 212);
            AllocationDescriptors       = Utilities.ToByteArray(buffer, offset + 216 + ExtendedAttributesLength, AllocationDescriptorsLength);

            byte[] eaData = Utilities.ToByteArray(buffer, offset + 216, ExtendedAttributesLength);
            ExtendedAttributes = ReadExtendedAttributes(eaData);

            return((int)(216 + ExtendedAttributesLength + AllocationDescriptorsLength));
        }
        public override int Parse(byte[] buffer, int offset)
        {
            VolumeDescriptorSequenceNumber = Utilities.ToUInt32LittleEndian(buffer, offset + 16);
            PrimaryVolumeDescriptorNumber  = Utilities.ToUInt32LittleEndian(buffer, offset + 20);
            VolumeIdentifier       = UdfUtilities.ReadDString(buffer, offset + 24, 32);
            VolumeSequenceNumber   = Utilities.ToUInt16LittleEndian(buffer, offset + 56);
            MaxVolumeSquenceNumber = Utilities.ToUInt16LittleEndian(buffer, offset + 58);
            InterchangeLevel       = Utilities.ToUInt16LittleEndian(buffer, offset + 60);
            MaxInterchangeLevel    = Utilities.ToUInt16LittleEndian(buffer, offset + 62);
            CharacterSetList       = Utilities.ToUInt32LittleEndian(buffer, offset + 64);
            MaxCharacterSetList    = Utilities.ToUInt32LittleEndian(buffer, offset + 68);
            VolumeSetIdentifier    = UdfUtilities.ReadDString(buffer, offset + 72, 128);
            DescriptorCharSet      = Utilities.ToStruct <CharacterSetSpecification>(buffer, offset + 200);
            ExplanatoryCharSet     = Utilities.ToStruct <CharacterSetSpecification>(buffer, offset + 264);
            VolumeAbstractExtent   = new ExtentDescriptor();
            VolumeAbstractExtent.ReadFrom(buffer, offset + 328);
            VolumeCopyrightNoticeExtent = new ExtentDescriptor();
            VolumeCopyrightNoticeExtent.ReadFrom(buffer, offset + 336);
            ApplicationIdentifier    = Utilities.ToStruct <ApplicationEntityIdentifier>(buffer, offset + 344);
            RecordingTime            = UdfUtilities.ParseTimestamp(buffer, offset + 376);
            ImplementationIdentifier = Utilities.ToStruct <ImplementationEntityIdentifier>(buffer, offset + 388);
            ImplementationUse        = Utilities.ToByteArray(buffer, offset + 420, 64);
            PredecessorVolumeDescriptorSequenceLocation = Utilities.ToUInt32LittleEndian(buffer, offset + 484);
            Flags = Utilities.ToUInt16LittleEndian(buffer, offset + 488);

            return(512);
        }
        public override int Parse(byte[] buffer, int offset)
        {
            VolumeDescriptorSequenceNumber = Utilities.ToUInt32LittleEndian(buffer, offset + 16);
            DescriptorCharset        = Utilities.ToByteArray(buffer, offset + 20, 64);
            LogicalVolumeIdentifier  = UdfUtilities.ReadDString(buffer, offset + 84, 128);
            LogicalBlockSize         = Utilities.ToUInt32LittleEndian(buffer, offset + 212);
            DomainIdentifier         = Utilities.ToStruct <DomainEntityIdentifier>(buffer, offset + 216);
            LogicalVolumeContentsUse = Utilities.ToByteArray(buffer, offset + 248, 16);
            MapTableLength           = Utilities.ToUInt32LittleEndian(buffer, offset + 264);
            NumPartitionMaps         = Utilities.ToUInt32LittleEndian(buffer, offset + 268);
            ImplementationIdentifier = Utilities.ToStruct <ImplementationEntityIdentifier>(buffer, offset + 272);
            ImplementationUse        = Utilities.ToByteArray(buffer, offset + 304, 128);
            IntegritySequenceExtent  = new ExtentDescriptor();
            IntegritySequenceExtent.ReadFrom(buffer, offset + 432);

            int pmOffset = 0;

            PartitionMaps = new PartitionMap[NumPartitionMaps];
            for (int i = 0; i < NumPartitionMaps; ++i)
            {
                PartitionMaps[i] = PartitionMap.CreateFrom(buffer, offset + 440 + pmOffset);
                pmOffset        += PartitionMaps[i].Size;
            }

            return(440 + (int)MapTableLength);
        }
Beispiel #4
0
        public int ReadFrom(byte[] buffer, int offset)
        {
            DescriptorTag           = Utilities.ToStruct <DescriptorTag>(buffer, offset);
            FileVersionNumber       = Utilities.ToUInt16LittleEndian(buffer, offset + 16);
            FileCharacteristics     = (FileCharacteristic)buffer[offset + 18];
            NameLength              = buffer[offset + 19];
            FileLocation            = Utilities.ToStruct <LongAllocationDescriptor>(buffer, offset + 20);
            ImplementationUseLength = Utilities.ToUInt16LittleEndian(buffer, offset + 36);
            ImplementationUse       = Utilities.ToByteArray(buffer, offset + 38, ImplementationUseLength);
            Name = UdfUtilities.ReadDCharacters(buffer, offset + 38 + ImplementationUseLength, NameLength);

            return(Utilities.RoundUp(38 + ImplementationUseLength + NameLength, 4));
        }
        public int ReadFrom(byte[] buffer, int offset)
        {
            if (!DescriptorTag.IsValid(buffer, offset))
            {
                throw new InvalidDataException("Invalid Anchor Volume Descriptor Pointer (invalid tag)");
            }

            Tag = new DescriptorTag();
            Tag.ReadFrom(buffer, offset);

            if (UdfUtilities.ComputeCrc(buffer, offset + Tag.Size, Tag.DescriptorCrcLength) != Tag.DescriptorCrc)
            {
                throw new InvalidDataException("Invalid Anchor Volume Descriptor Pointer (invalid CRC)");
            }

            return(Parse(buffer, offset));
        }
        public int ReadFrom(byte[] buffer, int offset)
        {
            DescriptorTag                  = Utilities.ToStruct <DescriptorTag>(buffer, offset);
            RecordingTime                  = UdfUtilities.ParseTimestamp(buffer, offset + 16);
            InterchangeLevel               = Utilities.ToUInt16LittleEndian(buffer, offset + 28);
            MaximumInterchangeLevel        = Utilities.ToUInt16LittleEndian(buffer, offset + 30);
            CharacterSetList               = Utilities.ToUInt32LittleEndian(buffer, offset + 32);
            MaximumCharacterSetList        = Utilities.ToUInt32LittleEndian(buffer, offset + 36);
            FileSetNumber                  = Utilities.ToUInt32LittleEndian(buffer, offset + 40);
            FileSetDescriptorNumber        = Utilities.ToUInt32LittleEndian(buffer, offset + 44);
            LogicalVolumeIdentifierCharset = Utilities.ToStruct <CharacterSetSpecification>(buffer, offset + 48);
            LogicalVolumeIdentifier        = UdfUtilities.ReadDString(buffer, offset + 112, 128);
            FileSetCharset                 = Utilities.ToStruct <CharacterSetSpecification>(buffer, offset + 240);
            FileSetIdentifier              = UdfUtilities.ReadDString(buffer, offset + 304, 32);
            CopyrightFileIdentifier        = UdfUtilities.ReadDString(buffer, offset + 336, 32);
            AbstractFileIdentifier         = UdfUtilities.ReadDString(buffer, offset + 368, 32);
            RootDirectoryIcb               = Utilities.ToStruct <LongAllocationDescriptor>(buffer, offset + 400);
            DomainIdentifier               = Utilities.ToStruct <DomainEntityIdentifier>(buffer, offset + 416);
            NextExtent = Utilities.ToStruct <LongAllocationDescriptor>(buffer, offset + 448);
            SystemStreamDirectoryIcb = Utilities.ToStruct <LongAllocationDescriptor>(buffer, offset + 464);

            return(512);
        }
Beispiel #7
0
        public static File FromDescriptor(UdfContext context, LongAllocationDescriptor icb)
        {
            LogicalPartition partition = context.LogicalPartitions[icb.ExtentLocation.Partition];

            byte[]        rootDirData = UdfUtilities.ReadExtent(context, icb);
            DescriptorTag rootDirTag  = Utilities.ToStruct <DescriptorTag>(rootDirData, 0);

            if (rootDirTag.TagIdentifier == TagIdentifier.ExtendedFileEntry)
            {
                ExtendedFileEntry fileEntry = Utilities.ToStruct <ExtendedFileEntry>(rootDirData, 0);
                if (fileEntry.InformationControlBlock.FileType == FileType.Directory)
                {
                    return(new Directory(context, partition, fileEntry));
                }
                else
                {
                    return(new File(context, partition, fileEntry, (uint)partition.LogicalBlockSize));
                }
            }
            else if (rootDirTag.TagIdentifier == TagIdentifier.FileEntry)
            {
                FileEntry fileEntry = Utilities.ToStruct <FileEntry>(rootDirData, 0);
                if (fileEntry.InformationControlBlock.FileType == FileType.Directory)
                {
                    return(new Directory(context, partition, fileEntry));
                }
                else
                {
                    return(new File(context, partition, fileEntry, (uint)partition.LogicalBlockSize));
                }
            }
            else
            {
                throw new NotImplementedException("Only ExtendedFileEntries implemented");
            }
        }
Beispiel #8
0
            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);
                }
            }