Exemple #1
0
 public Xdbf(byte[] Data)
 {
     this.br         = new CBinaryReader(EndianType.BigEndian, new MemoryStream(Data));
     this.header     = new XdbfHeader(this.br);
     this.entries    = new XdbfTable(this.br, this.header);
     this.dataOffset = (uint)this.br.BaseStream.Position;
 }
        /// <summary>
        /// Fetch all directory entries to build the internal index
        /// </summary>
        public void BuildIndex()
        {
            if (_indexBuilt)
            {
                return;
            }

            if (!_descriptorsRead)
            {
                throw new FrameworkException("Error : You must read the descriptors first");
            }

            try
            {
                long rootLba   = _primaryVolumeDescriptor.RootDirectoryEntry.ExtentLba;
                var  stream    = new CBinaryReader(ReadSector(rootLba, _defaultSectorMode));
                var  rootEntry = ReadDirectoryEntry(stream);

                _index = new DataTrackIndex(rootEntry);
                AddDirectoryToIndex(_index.Root);
                _indexBuilt = true;
            }
            catch (FrameworkException ex)
            {
                throw ex;
            }
            catch (Exception)
            {
                throw new FrameworkException("Error while building the index : unable to read data to build the internal index cache");
            }
        }
        // Constructors

        /// <summary>
        /// DataTrackReader
        /// </summary>
        /// <param name="stream">The stream of iso</param>
        /// <param name="trackNumber">The track number</param>
        /// <param name="system">File system used for this data track</param>
        /// <param name="mode">The sector mode of the track</param>
        /// <param name="readDescriptors">Read descriptors immediately</param>
        /// <param name="buildIndex">Build the index cache immediately</param>
        internal DataTrackReader(CBinaryReader stream, int trackNumber, DiskFileSystem system, DataTrackMode mode, bool readDescriptors = true, bool buildIndex = true)
            : base((FileStream)stream.BaseStream, trackNumber, system, mode)
        {
            _stream          = stream;
            _descriptorsRead = false;
            _indexBuilt      = false;
            _entriesOrder    = DataTrackEntriesOrder.DEFAULT;

            try
            {
                if (readDescriptors)
                {
                    ReadVolumeDescriptors();
                }

                if (buildIndex)
                {
                    BuildIndex();
                }

                SeekSector(0);
            }
            catch (FrameworkException ex)
            {
                throw ex;
            }
            catch (Exception)
            {
                throw new FrameworkException("Error while reading data track : unable to read the data track");
            }
        }
        // Constructors

        /// <summary>
        /// AudioTrackReader
        /// </summary>
        /// <param name="trackNumber">The track number</param>
        internal AudioTrackReader(CBinaryReader stream, int trackNumber)
            : base((FileStream)stream.BaseStream, trackNumber)
        {
            _stream = stream;

            SeekSector(0);
        }
Exemple #5
0
 public Xdbf(byte[] Data)
 {
     br         = new CBinaryReader(EndianType.BigEndian, new MemoryStream(Data));
     header     = new XdbfHeader(br);
     entries    = new XdbfTable(br, header);
     dataOffset = (uint)br.BaseStream.Position;
 }
 public XdbfTableEntry(CBinaryReader b)
 {
     Identifier = b.ReadUInt32();
     Offset     = b.ReadUInt32();
     Size       = b.ReadUInt32();
     Type       = b.ReadUInt16();
     Padding    = b.ReadUInt32();
 }
Exemple #7
0
 public XdbfTableEntry(CBinaryReader b)
 {
     this.Identifier = b.ReadUInt32();
     this.Offset     = b.ReadUInt32();
     this.Size       = b.ReadUInt32();
     this.Type       = b.ReadUInt16();
     this.Padding    = b.ReadUInt32();
 }
Exemple #8
0
        private void readImageData(CBinaryReader br)
        {
            br.Seek((long)this.Header.HeaderSize, SeekOrigin.Begin);
            int count = (int)(this.Header.FileSize - this.Header.HeaderSize);

            this.Image = new byte[count];
            this.Image = br.ReadBytes(count);
        }
Exemple #9
0
 private void init(CBinaryReader br)
 {
     br.Seek(0L, SeekOrigin.Begin);
     this.Header = new XPRHeader(br);
     if (this.IsValid)
     {
         this.readImageData(br);
     }
 }
Exemple #10
0
 public void Read(CBinaryReader br, uint BaseAddress)
 {
     br.Seek((long)(this.Header.SectionNameAddress - BaseAddress), SeekOrigin.Begin);
     while (br.PeekChar() != 0)
     {
         this.Name = this.Name + br.ReadChar();
     }
     br.Seek((long)this.Header.RawAddress, SeekOrigin.Begin);
     this.Data = br.ReadBytes((int)this.Header.RawSize);
 }
Exemple #11
0
 public void Read(CBinaryReader br, uint BaseAddress)
 {
     br.Seek(Header.SectionNameAddress - BaseAddress, SeekOrigin.Begin);
     while (br.PeekChar() != 0)
     {
         Name = Name + br.ReadChar();
     }
     br.Seek(Header.RawAddress, SeekOrigin.Begin);
     Data = br.ReadBytes((int)Header.RawSize);
 }
Exemple #12
0
 public XdbfHeader(CBinaryReader b)
 {
     b.Seek(0L, SeekOrigin.Begin);
     MagicBytes     = b.ReadBytes(4);
     Version        = b.ReadUInt16();
     Reserved       = b.ReadUInt16();
     NumEntries     = b.ReadUInt32();
     NumEntriesCopy = b.ReadUInt32();
     UnknownA       = b.ReadUInt32();
     UnknownB       = b.ReadUInt32();
 }
Exemple #13
0
        // Methods

        /// <summary>
        /// Read GZip meta data from stream
        /// </summary>
        /// <param name="stream">The stream to read</param>
        /// <param name="size">The size of the GZip file</param>
        internal void Read(Stream stream, uint size)
        {
            try
            {
                var reader = new CBinaryReader(stream);

                if (reader.ReadUInt16() != SIGNATURE)
                {
                    throw new FrameworkException("Error while parsing gzip : gzip signature not found");
                }

                _method = (GZipCompressionMethod)reader.ReadByte();
                _flags  = reader.ReadByte();
                _date   = new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc).AddSeconds(reader.ReadUInt32());
                _xfl    = reader.ReadByte();
                _os     = reader.ReadByte();

                if (HasExtra)
                {
                    int extraSize = reader.ReadUInt16();
                    _extra = reader.ReadAsciiString(extraSize);
                    reader.Position++;
                }

                if (HasName)
                {
                    _name = reader.ReadAsciiString();
                }

                if (HasComment)
                {
                    _comment = reader.ReadAsciiString();
                }

                if (HasCrc)
                {
                    _crc = reader.ReadUInt16();
                }

                _dataOffset     = (uint)reader.Position;
                _dataSize       = size - _dataOffset - FOOTER_SIZE;
                reader.Position = size - FOOTER_SIZE;
                _crc32          = reader.ReadUInt32();
                _dataRealSize   = reader.ReadUInt32();
            }
            catch (FrameworkException ex)
            {
                throw ex;
            }
            catch (Exception)
            {
                throw new FrameworkException("Error while parsing gzip data : unable to read meta data");
            }
        }
Exemple #14
0
 public XdbfTable(CBinaryReader b, XdbfHeader header)
 {
     b.Seek(30L, SeekOrigin.Begin);
     for (int i = 0; i < header.NumEntries; i++)
     {
         base.Add(new XdbfTableEntry(b));
     }
     while (b.PeekChar() == 0)
     {
         b.ReadByte();
     }
 }
Exemple #15
0
 public override void Parse(CBinaryReader br)
 {
     br.Seek((long)base.Address, SeekOrigin.Begin);
     br.Endian           = EndianType.BigEndian;
     this.MediaID        = br.ReadBytes(4);
     this.Version        = br.ReadUInt32();
     this.BaseVersion    = br.ReadUInt32();
     this.TitleID        = br.ReadBytes(4);
     this.Platform       = br.ReadByte();
     this.ExecutableType = br.ReadByte();
     this.DiscNumber     = br.ReadByte();
     this.DiscCount      = br.ReadByte();
 }
Exemple #16
0
 public override void Parse(CBinaryReader br)
 {
     br.Seek(Address, SeekOrigin.Begin);
     br.Endian      = EndianType.BigEndian;
     MediaID        = br.ReadBytes(4);
     Version        = br.ReadUInt32();
     BaseVersion    = br.ReadUInt32();
     TitleID        = br.ReadBytes(4);
     Platform       = br.ReadByte();
     ExecutableType = br.ReadByte();
     DiscNumber     = br.ReadByte();
     DiscCount      = br.ReadByte();
 }
Exemple #17
0
 public XexInfo(byte[] Xex)
 {
     ms     = new MemoryStream(Xex);
     br     = new CBinaryReader(EndianType.BigEndian, ms);
     Header = new XexHeader(br);
     foreach (XexInfoField field in Header.Values)
     {
         if (!field.Flags)
         {
             field.Parse(br);
         }
     }
 }
Exemple #18
0
 public GDF(FileStream File)
 {
     this.file = File;
     this.fr   = new CBinaryReader(EndianType.LittleEndian, this.file);
     this.readVolume();
     try
     {
         this.rootDir = new GDFDirTable(this.fr, this.volDesc, this.volDesc.RootDirSector, this.volDesc.RootDirSize);
     }
     catch (Exception exception)
     {
         this.Exceptions.Add(exception);
     }
 }
        /// <summary>
        /// Read the disk descriptors
        /// </summary>
        public void ReadVolumeDescriptors()
        {
            if (_descriptorsRead)
            {
                return;
            }

            try
            {
                VolumeDescriptor descriptor;
                bool             endOfList            = false;
                bool             hasPrimaryDescriptor = false;
                SeekSector(16);

                do
                {
                    using (var stream = new CBinaryReader(ReadSector(_defaultSectorMode)))
                    {
                        descriptor = ReadVolumeDescriptor(stream);
                    }

                    switch (descriptor.Type)
                    {
                    case VolumeDescriptorType.PRIMARY:
                        _primaryVolumeDescriptor = (PrimaryVolumeDescriptor)descriptor;
                        hasPrimaryDescriptor     = true;
                        break;

                    case VolumeDescriptorType.SET_TERMINATOR:
                        endOfList = true;
                        break;
                    }
                } while (!endOfList);

                _descriptorsRead = true;

                if (!hasPrimaryDescriptor)
                {
                    throw new FrameworkException("Error while reading volume descriptors : no primary descriptor found");
                }
            }
            catch (FrameworkException ex)
            {
                throw ex;
            }
            catch (Exception)
            {
                throw new FrameworkException("Error while reading volume descriptors : Invalid list of descriptors");
            }
        }
Exemple #20
0
 public GDF(FileStream File)
 {
     file = File;
     fr   = new CBinaryReader(EndianType.LittleEndian, file);
     readVolume();
     try
     {
         rootDir = new GDFDirTable(fr, volDesc, volDesc.RootDirSector, volDesc.RootDirSize);
     }
     catch (Exception exception)
     {
         Exceptions.Add(exception);
     }
 }
Exemple #21
0
 public XexInfo(byte[] Xex)
 {
     this.data   = Xex;
     this.ms     = new MemoryStream(this.data);
     this.br     = new CBinaryReader(EndianType.BigEndian, this.ms);
     this.Header = new XexHeader(this.br);
     foreach (XexInfoField field in this.Header.Values)
     {
         if (!field.Flags)
         {
             field.Parse(this.br);
         }
     }
 }
        /// <summary>
        /// Fetch a directory to build the internal index (recursive)
        /// </summary>
        private void AddDirectoryToIndex(DataTrackIndexEntry indexDirectoryEntry)
        {
            DirectoryEntry      entry;
            DataTrackIndexEntry indexEntry;
            long lba          = indexDirectoryEntry.DirectoryEntry.ExtentLba;
            long size         = indexDirectoryEntry.DirectoryEntry.ExtentSize;
            int  sectorsCount = (int)(size / GetSectorDataSize(_defaultSectorMode));

            var stream = new CBinaryReader(ReadSectors(lba, sectorsCount, _defaultSectorMode));

            // First directory entry of a directory entry is the directory itself, so let's skip it
            ReadDirectoryEntry(stream);

            // Second directory entry is the parent directory entry.
            // As we parse the data from root to children, it has already been handled, so let's skip it too
            ReadDirectoryEntry(stream);

            while (stream.Position < size)
            {
                short b = stream.TestByte();

                if (b == 0)
                {
                    // DirectoryEntry cannot be "splitted" on two sectors
                    int dataSize = GetSectorDataSize(_defaultSectorMode);
                    stream.Position = (((stream.Position / dataSize) + 1) * dataSize);
                    b = stream.TestByte();
                }

                if (b <= 0)
                {
                    break;
                }
                else
                {
                    entry = ReadDirectoryEntry(stream);

                    indexEntry = new DataTrackIndexEntry(indexDirectoryEntry, entry);
                    _index.AddToIndex(indexEntry);

                    if (indexEntry.IsDirectory)
                    {
                        AddDirectoryToIndex(indexEntry);
                    }
                }
            }

            stream.CloseAndDispose();
        }
Exemple #23
0
 public XbeSectionHeader(CBinaryReader bw)
 {
     this.SectionDigest                 = new byte[20];
     bw.Endian                          = EndianType.LittleEndian;
     this.Flags                         = (XbeSectionFlags)bw.ReadUInt32();
     this.VirtualAddress                = bw.ReadUInt32();
     this.VirtualSize                   = bw.ReadUInt32();
     this.RawAddress                    = bw.ReadUInt32();
     this.RawSize                       = bw.ReadUInt32();
     this.SectionNameAddress            = bw.ReadUInt32();
     this.SectionNameRefCount           = bw.ReadUInt32();
     this.HeadSharedPageRefCountAddress = bw.ReadUInt32();
     this.TailSharedPageRefCountAddress = bw.ReadUInt32();
     this.SectionDigest                 = bw.ReadBytes(20);
 }
Exemple #24
0
 public XbeCertifcate(CBinaryReader br)
 {
     this.Size             = br.ReadUInt32();
     this.TimeData         = br.ReadBytes(4);
     this.titleID          = br.ReadUInt32();
     this.titleName        = br.ReadBytes(80);
     this.AltTitleIDs      = br.ReadBytes(0x40);
     this.AllowedMedia     = (XbeAllowedMedia)br.ReadUInt32();
     this.GameRegion       = (XbeGameRegion)br.ReadUInt32();
     this.GameRatings      = br.ReadUInt32();
     this.DiskNumber       = br.ReadUInt32();
     this.Version          = br.ReadUInt32();
     this.LanKey           = br.ReadBytes(0x10);
     this.SignatureKey     = br.ReadBytes(0x10);
     this.AltSignatureKeys = br.ReadBytes(0x100);
 }
Exemple #25
0
 public XPRHeader(CBinaryReader br)
 {
     br.Endian  = EndianType.LittleEndian;
     MagicBytes = br.ReadUInt32();
     if (MagicBytes == 0x30525058)
     {
         FileSize      = br.ReadUInt32();
         HeaderSize    = br.ReadUInt32();
         TextureCommon = br.ReadUInt32();
         TextureData   = br.ReadUInt32();
         TextureLock   = br.ReadUInt32();
         TextureMisc1  = br.ReadByte();
         TextureFormat = br.ReadByte();
         TextureRes1   = br.ReadByte();
         TextureRes2   = br.ReadByte();
         IsValid       = true;
     }
 }
Exemple #26
0
 public XbeHeader(CBinaryReader br)
 {
     try
     {
         if (br.ReadUInt32() == 0x48454258)
         {
             DigitalSignature                = br.ReadBytes(0x100);
             BaseAddress                     = br.ReadUInt32();
             SizeOfHeaders                   = br.ReadUInt32();
             SizeOfImage                     = br.ReadUInt32();
             SizeOfImageHeader               = br.ReadUInt32();
             TimeDate                        = br.ReadBytes(4);
             CertificateAddress              = br.ReadUInt32();
             NumberOfSections                = br.ReadUInt32();
             SectionHeadersAddress           = br.ReadUInt32();
             InitialisationFlags             = (XbeInitFlags)br.ReadUInt32();
             EntryPoint                      = br.ReadUInt32();
             TLSAddress                      = br.ReadUInt32();
             PEStackCommit                   = br.ReadUInt32();
             PEHeapReserve                   = br.ReadUInt32();
             PEHeapCommit                    = br.ReadUInt32();
             PEBaseAddress                   = br.ReadUInt32();
             PESizeOfImage                   = br.ReadUInt32();
             PEChecksum                      = br.ReadUInt32();
             PETimeDate                      = br.ReadBytes(4);
             DebugPathnameAddress            = br.ReadUInt32();
             DebugFilenameAddress            = br.ReadUInt32();
             DebugUnicodeFilenameAddress     = br.ReadUInt32();
             KernelImageThunkAddress         = br.ReadUInt32();
             NonKernelImportDirectoryAddress = br.ReadUInt32();
             NumberOfLibraryVersions         = br.ReadUInt32();
             LibraryVersionsAddress          = br.ReadUInt32();
             KernelLibraryVersionAddress     = br.ReadUInt32();
             XAPILibraryVersionAddress       = br.ReadUInt32();
             LogoBitmapAddress               = br.ReadUInt32();
             LogoBitmapSize                  = br.ReadUInt32();
             IsValid = true;
         }
     }
     catch (Exception ex)
     {
         Console.WriteLine(ex);
     }
 }
Exemple #27
0
        public GDFDirTable(CBinaryReader File, GDFVolumeDescriptor Vol, uint Sector, uint Size)
        {
            this.Sector = Sector;
            this.Size   = Size;
            File.Seek((long)((Sector * Vol.SectorSize) + Vol.RootOffset), SeekOrigin.Begin);
            byte[]        buffer = File.ReadBytes((int)Size);
            MemoryStream  s      = new MemoryStream(buffer);
            CBinaryReader reader = new CBinaryReader(EndianType.LittleEndian, s);

            try
            {
                while (s.Position < Size)
                {
                    GDFDirEntry item = new GDFDirEntry {
                        SubTreeL = reader.ReadUInt16(),
                        SubTreeR = reader.ReadUInt16()
                    };
                    if ((item.SubTreeL != 0xffff) && (item.SubTreeR != 0xffff))
                    {
                        item.Sector     = reader.ReadUInt32();
                        item.Size       = reader.ReadUInt32();
                        item.Attributes = (GDFDirEntryAttrib)reader.ReadByte();
                        item.NameLength = reader.ReadByte();
                        item.Name       = Encoding.ASCII.GetString(buffer, (int)s.Position, item.NameLength);
                        s.Seek((long)item.NameLength, SeekOrigin.Current);
                        long num1 = s.Position % 4L;
                        if ((s.Position % 4L) != 0L)
                        {
                            s.Seek(4L - (s.Position % 4L), SeekOrigin.Current);
                        }
                        base.Add(item);
                    }
                }
            }
            catch (EndOfStreamException)
            {
                Console.WriteLine("EndOfStreamException while trying to read directory at sector {0} ({1} bytes)", Sector.ToString(), Size.ToString());
            }
            catch (Exception exception)
            {
                Console.WriteLine("Unhandled Exception {0} for directory at sector {1} -> {2}", exception.InnerException, Sector.ToString(), exception.Message);
            }
        }
Exemple #28
0
 public XbeHeader(CBinaryReader br)
 {
     try
     {
         if (br.ReadUInt32() == 0x48454258)
         {
             this.DigitalSignature                = br.ReadBytes(0x100);
             this.BaseAddress                     = br.ReadUInt32();
             this.SizeOfHeaders                   = br.ReadUInt32();
             this.SizeOfImage                     = br.ReadUInt32();
             this.SizeOfImageHeader               = br.ReadUInt32();
             this.TimeDate                        = br.ReadBytes(4);
             this.CertificateAddress              = br.ReadUInt32();
             this.NumberOfSections                = br.ReadUInt32();
             this.SectionHeadersAddress           = br.ReadUInt32();
             this.InitialisationFlags             = (XbeInitFlags)br.ReadUInt32();
             this.EntryPoint                      = br.ReadUInt32();
             this.TLSAddress                      = br.ReadUInt32();
             this.PEStackCommit                   = br.ReadUInt32();
             this.PEHeapReserve                   = br.ReadUInt32();
             this.PEHeapCommit                    = br.ReadUInt32();
             this.PEBaseAddress                   = br.ReadUInt32();
             this.PESizeOfImage                   = br.ReadUInt32();
             this.PEChecksum                      = br.ReadUInt32();
             this.PETimeDate                      = br.ReadBytes(4);
             this.DebugPathnameAddress            = br.ReadUInt32();
             this.DebugFilenameAddress            = br.ReadUInt32();
             this.DebugUnicodeFilenameAddress     = br.ReadUInt32();
             this.KernelImageThunkAddress         = br.ReadUInt32();
             this.NonKernelImportDirectoryAddress = br.ReadUInt32();
             this.NumberOfLibraryVersions         = br.ReadUInt32();
             this.LibraryVersionsAddress          = br.ReadUInt32();
             this.KernelLibraryVersionAddress     = br.ReadUInt32();
             this.XAPILibraryVersionAddress       = br.ReadUInt32();
             this.LogoBitmapAddress               = br.ReadUInt32();
             this.LogoBitmapSize                  = br.ReadUInt32();
             this.IsValid = true;
         }
     }
     catch (Exception)
     {
     }
 }
Exemple #29
0
 public XbeInfo(byte[] Xbe)
 {
     br     = new CBinaryReader(EndianType.LittleEndian, new MemoryStream(Xbe));
     Header = new XbeHeader(br);
     if (Header.IsValid)
     {
         br.Seek(Header.CertificateAddress - Header.BaseAddress, SeekOrigin.Begin);
         Certifcate = new XbeCertifcate(br);
         br.Seek(Header.SectionHeadersAddress - Header.BaseAddress, SeekOrigin.Begin);
         for (uint i = 0; i < Header.NumberOfSections; i++)
         {
             Sections.Add(new XbeSection(br));
         }
         foreach (XbeSection section in Sections)
         {
             section.Read(br, Header.BaseAddress);
         }
     }
 }
Exemple #30
0
 public XbeInfo(byte[] Xbe)
 {
     this.data   = Xbe;
     this.br     = new CBinaryReader(EndianType.LittleEndian, new MemoryStream(this.data));
     this.Header = new XbeHeader(this.br);
     if (this.Header.IsValid)
     {
         this.br.Seek((long)(this.Header.CertificateAddress - this.Header.BaseAddress), SeekOrigin.Begin);
         this.Certifcate = new XbeCertifcate(this.br);
         this.br.Seek((long)(this.Header.SectionHeadersAddress - this.Header.BaseAddress), SeekOrigin.Begin);
         for (uint i = 0; i < this.Header.NumberOfSections; i++)
         {
             this.Sections.Add(new XbeSection(this.br));
         }
         foreach (XbeSection section in this.Sections)
         {
             section.Read(this.br, this.Header.BaseAddress);
         }
     }
 }