コード例 #1
0
        public LazyModuleProvider(IServiceContainer ctx, ModuleInfo mod)
        {
            this.ctx         = ctx;
            this.StreamTable = ctx.GetService <StreamTableReader>();

            this.Info       = mod;
            this.lazyModule = LazyFactory.CreateLazy(ReadModule);
        }
コード例 #2
0
ファイル: DebugReader.cs プロジェクト: smx-smx/PDBSharp
        public DebugReader(IServiceContainer ctx, SpanStream stream) : base(stream)
        {
            this.StreamTable = ctx.GetService <StreamTableReader>();

            for (int i = 0; i < (int)DebugType.DebugTypeMax; i++)
            {
                DebugStreams[i] = ReadInt16();
            }

            lazyFPO = LazyFactory.CreateLazy(CreateFPOReader);
        }
コード例 #3
0
ファイル: PDBFile.cs プロジェクト: gitter-badger/PDBSharp
        public PDBFile(FileStream stream)
        {
            this.fs          = stream;
            this.StreamTable = Services.GetService <StreamTableReader>();

            this.mf       = MemoryMappedFile.CreateFromFile(stream, null, 0, MemoryMappedFileAccess.Read, HandleInheritability.Inheritable, true);
            this.FileType = DetectPdbType();

            Services.AddService <PDBFile>(this);

            //$TODO
            if (this.FileType == PDBType.Small)
            {
                throw new NotImplementedException($"Small/Old/JG PDBs not supported/tested yet");
            }


            MSFReader msf = new MSFReader(mf, stream.Length);

            Services.AddService <MSFReader>(msf);

            StreamTableReader streamTable;

            // init stream table
            {
                byte[] streamTableData = msf.StreamTable();
                streamTable = new StreamTableReader(Services, streamTableData);
            }
            Services.AddService <StreamTableReader>(streamTable);

            DBIReader dbi;

            // init DBI
            {
                byte[] dbiData = streamTable.GetStream(DefaultStreams.DBI);
                dbi = new DBIReader(Services, dbiData);
                OnDbiInit?.Invoke(dbi);
            }
            Services.AddService <DBIReader>(dbi);

            TPIReader tpi;

            // init TPI
            {
                byte[] tpiData = streamTable.GetStream(DefaultStreams.TPI);
                tpi = new TPIReader(Services, new SpanStream(tpiData));
                OnTpiInit?.Invoke(tpi);
            }
            Services.AddService <TPIReader>(tpi);

            TPIHashReader tpiHash = null;

            // init TPIHash
            if (tpi.Header.Hash.StreamNumber != -1)
            {
                byte[] tpiHashData = streamTable.GetStream(tpi.Header.Hash.StreamNumber);
                tpiHash = new TPIHashReader(Services, tpiHashData);
                Services.AddService <TPIHashReader>(tpiHash);
            }

            // init resolver
            TypeResolver resolver = new TypeResolver(Services);

            Services.AddService <TypeResolver>(resolver);


            // init Hasher
            HasherV2 hasher = new HasherV2(Services);

            Services.AddService <HasherV2>(hasher);

            PdbStreamReader nameMap;

            // init NameMap
            {
                byte[] nameMapData = streamTable.GetStream(DefaultStreams.PDB);
                nameMap = new PdbStreamReader(nameMapData);
            }
            Services.AddService <PdbStreamReader>(nameMap);

            NamedStreamTableReader namedStreamTable = new NamedStreamTableReader(Services);

            Services.AddService <NamedStreamTableReader>(namedStreamTable);

            UdtNameTableReader udtNameTable = null;
            // init UdtNameMap
            {
                byte[] namesData = namedStreamTable.GetStreamByName("/names");
                if (namesData != null)
                {
                    udtNameTable = new UdtNameTableReader(Services, namesData);
                    Services.AddService <UdtNameTableReader>(udtNameTable);
                }
            }
        }
コード例 #4
0
        /**
         * Layout of the DBI stream
         * -> Header
         * -> ModuleList
         * -> SectionContributions
         * -> SectionMap
         * -> FileInfo
         * -> TypeServerMap
         * -> EcSubstream
         * -> DebugHeader
         **/
        public DBIReader(IServiceContainer ctx, byte[] data) : base(data)
        {
            this.ctx = ctx;
            if (Length == 0)
            {
                return;
            }

            if (Length < Marshal.SizeOf <DBIHeader>())
            {
                throw new InvalidDataException();
            }

            Header = Read <DBIHeader>();

            if (Header.Signature != unchecked ((uint)-1) || !Enum.IsDefined(typeof(DBIVersion), (uint)Header.Version))
            {
                throw new InvalidDataException();
            }

            this.StreamTable = ctx.GetService <StreamTableReader>();

            uint nStreams = StreamTable.NumStreams;

            if (
                Header.GsSymbolsStreamNumber >= nStreams ||
                Header.PsSymbolsStreamNumber >= nStreams ||
                Header.SymbolRecordsStreamNumber >= nStreams
                )
            {
                throw new InvalidDataException();
            }

            lazyModuleContainers = LazyFactory.CreateLazy(ReadModules);
            Position            += Header.ModuleListSize;

            if (Header.SectionContributionSize > 0)
            {
                SectionContribs = new SectionContribsReader(Header.SectionContributionSize, this);
            }
            Position += Header.SectionContributionSize;

            Position += Header.SectionMapSize;
            Position += Header.FileInfoSize;

            if (Header.TypeServerMapSize > 0)
            {
                TypeServerMap = new TypeServerMapReader(this);
            }
            Position += Header.TypeServerMapSize;

            if (Header.EcSubstreamSize > 0)
            {
                EC = new ECReader(this);
            }
            Position += Header.EcSubstreamSize;

            if (Header.DebugHeaderSize > 0)
            {
                DebugInfo = new DebugReader(ctx, this);
            }
        }
コード例 #5
0
 public NamedStreamTableReader(IServiceContainer ctx)
 {
     streamReader = ctx.GetService <PdbStreamReader>();
     streamTable  = ctx.GetService <StreamTableReader>();
 }
コード例 #6
0
ファイル: PDBFile.cs プロジェクト: smx-smx/PDBSharp
        public PDBFile(FileStream stream)
        {
            this.fs      = stream;
            this.mf      = MemoryMappedFile.CreateFromFile(stream, null, 0, MemoryMappedFileAccess.Read, HandleInheritability.Inheritable, true);
            this.memSpan = new MemoryMappedSpan <byte>(mf, (int)fs.Length);

            this.StreamTable = Services.GetService <StreamTableReader>();
            Services.AddService <PDBFile>(this);

            this.Type = MSFReader.DetectPdbType(memSpan.GetSpan());

            MSFReader         msf         = null;
            StreamTableReader streamTable = null;

            if (Type != PDBType.Old)
            {
                switch (Type)
                {
                case PDBType.Big:
                    msf = new MSFReaderDS(memSpan.Memory);
                    break;

                case PDBType.Small:
                    msf = new MSFReaderJG(memSpan.Memory);
                    break;

                default:
                    throw new InvalidOperationException();
                }
                Services.AddService <MSFReader>(msf);

                // init stream table
                {
                    byte[] streamTableData = msf.StreamTable();
                    streamTable = new StreamTableReader(Services, streamTableData);
                }
                Services.AddService <StreamTableReader>(streamTable);

                DBIReader dbi;
                // init DBI
                {
                    byte[] dbiData = streamTable.GetStream(DefaultStreams.DBI);
                    dbi = new DBIReader(Services, dbiData);
                    OnDbiInit?.Invoke(dbi);
                }
                Services.AddService <DBIReader>(dbi);
            }

            TPIReader tpi;

            // init TPI
            {
                SpanStream tpiStream;
                if (Type != PDBType.Old)
                {
                    byte[] tpiData = streamTable.GetStream(DefaultStreams.TPI);
                    tpiStream = new SpanStream(tpiData);
                }
                else
                {
                    Span <byte> span   = memSpan.GetSpan();
                    JGHeaderOld header = span.Read <JGHeaderOld>(0);
                    // $TODO: the MSFReader interface should be abstracted into a more generic PDBHeader
                    Services.AddService <JGHeaderOld>(header);

                    tpiStream = new SpanStream(span.Slice(header.SIZE).ToArray());
                }
                tpi = new TPIReader(Services, tpiStream);
                OnTpiInit?.Invoke(tpi);
            }
            Services.AddService <TPIReader>(tpi);

            TPIHashReader tpiHash = null;

            // init TPIHash
            if (Type != PDBType.Old && tpi.Header.Hash.StreamNumber != -1)
            {
                byte[] tpiHashData = streamTable.GetStream(tpi.Header.Hash.StreamNumber);
                tpiHash = new TPIHashReader(Services, tpiHashData);
                Services.AddService <TPIHashReader>(tpiHash);
            }

            // init resolver
            TypeResolver resolver = new TypeResolver(Services);

            Services.AddService <TypeResolver>(resolver);


            // init Hasher
            HasherV2 hasher = new HasherV2(Services);

            Services.AddService <HasherV2>(hasher);

            if (Type != PDBType.Old)
            {
                {                 // init NameMap
                    byte[] nameMapData = streamTable.GetStream(DefaultStreams.PDB);

                    PdbStreamReader nameMap = new PdbStreamReader(nameMapData);
                    Services.AddService <PdbStreamReader>(nameMap);
                }

                NamedStreamTableReader namedStreamTable = new NamedStreamTableReader(Services);
                Services.AddService <NamedStreamTableReader>(namedStreamTable);

                {                 // init UdtNameMap
                    byte[] namesData = namedStreamTable.GetStreamByName("/names");
                    if (namesData != null)
                    {
                        UdtNameTableReader udtNameTable = new UdtNameTableReader(Services, namesData);
                        Services.AddService <UdtNameTableReader>(udtNameTable);
                    }
                }
            }
        }