public void Save(VirtualWriter wtr, Rva adr) { wtr.SetPosition(adr); wtr.Write(sig); wtr.Write(maVer); wtr.Write(miVer); wtr.Write(res); wtr.Write((ver.Length + 3) & ~3); wtr.Write(Encoding.ASCII.GetBytes(ver)); wtr.Write(new byte[((ver.Length + 1 + 3) & ~3) - ver.Length]); wtr.Write(f); wtr.Write((ushort)Items.Count); uint datOffset = (uint)(20 + ((ver.Length + 3) & ~3) + this.Count * 8); foreach (MetadataStream str in Items) { datOffset += (uint)((str.Name.Length + 1 + 3) & ~3); } foreach (MetadataStream str in Items) { wtr.Write(datOffset); datOffset += (uint)((str.Length + 3) & ~3); wtr.Write((uint)((str.Length + 3) & ~3)); wtr.Write(Encoding.ASCII.GetBytes(str.Name)); wtr.Write(new byte[((str.Name.Length + 1 + 3) & ~3) - str.Name.Length]); } foreach (MetadataStream str in Items) { wtr.Write(str.Data); wtr.Write(new byte[((str.Length + 3) & ~3) - str.Length]); } }
protected override void InsertItem(int index, CLRData item) { if (lding && (datloc == 0 || datloc > item.Address)) { datloc = item.Address; } base.InsertItem(index, item); }
public void UpdateRva(Rva old, Rva @new) { IEnumerator <CLRData> etr = base.GetEnumerator(); while (etr.MoveNext() && etr.Current.Address != old) { ; } etr.Current.Address = @new; }
public void Save(VirtualWriter wtr, Rva adr) { wtr.SetPosition(adr); foreach (FixupEntry i in Items) { wtr.Write(i.VTable); wtr.Write((ushort)i.Size); wtr.Write((ushort)i.Type); } }
public void Load(VirtualReader rdr, Rva adr) { rdr.SetPosition(adr); sig = rdr.ReadUInt32(); maVer = rdr.ReadUInt16(); miVer = rdr.ReadUInt16(); res = rdr.ReadUInt32(); uint len = rdr.ReadUInt32(); ver = new string(rdr.ReadChars((int)len)).Trim('\0'); f = rdr.ReadUInt16(); ushort s = rdr.ReadUInt16(); for (int i = 0; i < s; i++) { MetadataStream str = new MetadataStream(this); Rva datAdr = adr + rdr.ReadUInt32(); Rva datSze = rdr.ReadUInt32(); str.Name = ""; str.File = rdr.BaseStream.File; for (int ii = 0; ii < 32; ii++) { byte[] bs = rdr.ReadBytes(4); foreach (byte b in bs) { if (b != 0) { str.Name += (char)b; } else { break; } } if (bs[3] == '\0') { break; } } if (str.Type != MetadataStreamType.Unknown) { tStrs[str.Type] = str; } nStrs[str.Name] = str; rdr.SaveLocation(); rdr.SetPosition(datAdr); str.Data = rdr.ReadBytes((int)datSze.Value); rdr.LoadLocation(); Items.Add(str); } foreach (MetadataStream i in Items) { i.Load(); } }
protected override void LoadInternal(VirtualReader rdr) { c = rdr.ReadUInt32(); stamp = rdr.ReadStamp(); maVer = rdr.ReadUInt16(); miVer = rdr.ReadUInt16(); t = (DebugType)rdr.ReadUInt32(); s = rdr.ReadUInt32(); this.adr = rdr.ReadRva(); ptr = rdr.ReadUInt32(); }
internal void Load(VirtualReader rdr) { for (int i = 0; i < dd.NumberOfNamePointers; i++) { Rva name = rdr.ReadRva(); rdr.SaveLocation(); rdr.BaseStream.Position = name; this.Add(rdr.ReadString()); rdr.LoadLocation(); } }
public bool ContainsAddress(Rva rva) { foreach (CLRData i in Items) { if (i.Address == rva) { return(true); } } return(false); }
public DataDirectoryType Occupied(Rva rva) { foreach (DataDirectoryEntry e in file.OptionalHeader.DataDirectories) { if (rva > e.Address && rva < (e.Address + e.Size)) { return(e.Type); } } return(DataDirectoryType.Reserved); }
internal void Load(VirtualReader rdr) { Rva datAdr = rdr.ReadRva(); uint s = rdr.ReadUInt32(); cp = rdr.ReadUInt32(); rdr.ReadUInt32(); rdr.SaveLocation(); rdr.SetPosition(datAdr); dat = rdr.ReadBytes((int)s); rdr.LoadLocation(); }
protected override void SaveInternal(VirtualWriter wtr) { root = Location.Address; ComputeOffset(); wtr.Write(c); wtr.WriteStamp(stamp); wtr.Write(maVer); wtr.Write(miVer); wtr.Write(noName); wtr.Write(noID); foreach (ResourceEntry i in es) { if ((i.Type & EntryType.Name) == EntryType.Name) { uint strOffset = strO[i.Name]; wtr.Write(strOffset | 0x80000000); wtr.SaveLocation(); wtr.SetPosition(root + strOffset); wtr.WriteUnicodeString(i.Name); wtr.LoadLocation(); } else if ((i.Type & EntryType.ID) == EntryType.ID) { wtr.Write(i.ID); } if ((i.Type & EntryType.Subdirectory) == EntryType.Subdirectory) { uint dirOffset = dirO[i.Data as Subdirectory]; wtr.Write(dirOffset | 0x80000000); wtr.SaveLocation(); wtr.SetPosition(root + dirOffset); (i.Data as Subdirectory).Save(wtr, this); wtr.LoadLocation(); } else if ((i.Type & EntryType.DataEntry) == EntryType.DataEntry) { uint dateOffset = dateO[i.Data as DataEntry]; wtr.Write(dateOffset); wtr.SaveLocation(); wtr.SetPosition(root + dateOffset); (i.Data as DataEntry).Save(wtr, this); wtr.LoadLocation(); } } }
public CLRData this[Rva rva] { get { foreach (CLRData i in Items) { if (i.Address == rva) { return(i); } } return(null); } }
public bool Resolve(Rva rva, out Section sect, out int idx) { foreach (Section s in this) { if (rva >= s.VirtualAddress && rva < (s.VirtualAddress + s.VirtualSize)) { sect = s; idx = (int)(rva - s.VirtualAddress); return(true); } } sect = null; idx = 0; return(false); }
internal void Load(VirtualReader rdr) { pr = rdr.ReadRva(); s = rdr.ReadUInt32(); uint c = (s - 8) / 2; for (int i = 0; i < c; i++) { RelocationEntry e = new RelocationEntry(); ushort item = rdr.ReadUInt16(); e.Type = (RelocationType)((item & 0xf000U) >> 12); e.Offest = (item & 0x0fffU) + pr; this.Add(e); } }
public Rva GetNewRva(Rva key) { if (key == 0) { return(key); } Rva ret = DatasLocation; IEnumerator <CLRData> etr = base.GetEnumerator(); while (etr.MoveNext() && etr.Current.Address != key) { ret += (uint)((etr.Current.Data.Length + 3) & ~3); } return((uint)(ret)); }
public override long Seek(long offset, SeekOrigin origin) { switch (origin) { case SeekOrigin.Begin: rva = (Rva)offset; break; case SeekOrigin.Current: rva += (Rva)offset; break; case SeekOrigin.End: throw new InvalidOperationException(); } return(rva); }
public override void Read(PeReader rdr) { rdr.SetPosition(hdr.StandardFieldsOffset); rdr.ReadUInt16(); maL = rdr.ReadByte(); miL = rdr.ReadByte(); sC = rdr.ReadUInt32(); sI = rdr.ReadUInt32(); sU = rdr.ReadUInt32(); entry = rdr.ReadUInt32(); bc = rdr.ReadUInt32(); if (Magic != ExecutableType.PE32Plus) { bd = rdr.ReadUInt32(); } }
public void Load(VirtualReader rdr, Rva adr, uint size) { rdr.SetPosition(adr); while (rdr.BaseStream.Position - adr < size) { FixupEntry e = new FixupEntry(); e.VTable = rdr.ReadRva(); e.Size = rdr.ReadUInt16(); e.Type = (FixupType)rdr.ReadUInt16(); rdr.SaveLocation(); rdr.SetPosition(e.VTable); d.Datas.Add(new CLRData() { Address = e.VTable, Data = rdr.ReadBytes((int)e.Size * 4) }); rdr.LoadLocation(); this.Add(e); } }
internal void Save(VirtualWriter wtr) { Rva fdrAdr = (Rva)wtr.GetPosition() + GetPointersSize(); foreach (ExportAddressEntry i in Items) { if (i.Type == ExportAddressType.RealExport) { wtr.Write(i.Address); } else { wtr.Write(fdrAdr); fdrAdr += (uint)i.Forwarder.Length + 1; wtr.SaveLocation(); wtr.SetPosition(fdrAdr); wtr.Write(i.Forwarder); wtr.LoadLocation(); } } }
protected override void SaveInternal(VirtualWriter wtr) { Rva baseAdr = wtr.GetPosition(); wtr.Write(f); wtr.WriteStamp(stamp); wtr.Write((ushort)maVer); wtr.Write((ushort)miVer); wtr.Write(baseAdr + 40); wtr.Write((uint)bas); wtr.Write((uint)noAdr); wtr.Write((uint)noName); Rva adrsAdr = (Rva)(baseAdr + 40 + n.Length + 1); Rva nptAdr = adrsAdr + adr.GetPointersSize() + adr.GetForwardersSize(); Rva otAdr = nptAdr + nt.GetPointersSize() + nt.GetDataSize(); wtr.Write(adrsAdr); wtr.Write(nptAdr); wtr.Write(otAdr); wtr.SetPosition(baseAdr + 40); wtr.Write(n); wtr.SetPosition(adrsAdr); adr.Save(wtr); wtr.SetPosition(nptAdr); uint nameOffset = nt.GetPointersSize(); foreach (string str in nt) { wtr.Write(nptAdr + nameOffset); nameOffset += (uint)str.Length + 1; } nt.Save(wtr); wtr.SetPosition(otAdr); ot.Save(wtr); }
protected override void LoadInternal(VirtualReader rdr) { f = rdr.ReadUInt32(); stamp = rdr.ReadStamp(); maVer = rdr.ReadUInt16(); miVer = rdr.ReadUInt16(); Rva nr = rdr.ReadRva(); bas = rdr.ReadUInt32(); noAdr = rdr.ReadUInt32(); noName = rdr.ReadUInt32(); Rva adrPtr = rdr.ReadRva(); Rva ntPtr = rdr.ReadRva(); Rva otPtr = rdr.ReadRva(); rdr.SaveLocation(); rdr.SetPosition(nr); n = rdr.ReadString(); rdr.LoadLocation(); rdr.SaveLocation(); rdr.SetPosition(adrPtr); adr = new ExportAddressTable(this); adr.Load(rdr); rdr.LoadLocation(); rdr.SaveLocation(); rdr.SetPosition(ntPtr); nt = new ExportNameTable(this); nt.Load(rdr); rdr.LoadLocation(); rdr.SaveLocation(); rdr.SetPosition(otPtr); ot = new ExportOrdinalTable(this); ot.Load(rdr); rdr.LoadLocation(); }
protected override void LoadInternal(VirtualReader rdr) { ulong bas = rdr.BaseStream.File.OptionalHeader.WindowsSpecificFields.ImageBase; if (rdr.BaseStream.File.OptionalHeader.Type == OptionalHeader.ExecutableType.PE32Plus) { isPe32Plus = true; s = (uint)(rdr.ReadUInt64() - bas); e = (uint)(rdr.ReadUInt64() - bas); idx = (uint)(rdr.ReadUInt64() - bas); cb = (uint)(rdr.ReadUInt64() - bas); } else { isPe32Plus = false; s = (uint)(rdr.ReadUInt32() - bas); e = (uint)(rdr.ReadUInt32() - bas); idx = (uint)(rdr.ReadUInt32() - bas); cb = (uint)(rdr.ReadUInt32() - bas); } sz = rdr.ReadUInt32(); c = rdr.ReadUInt32(); }
internal void Load(VirtualReader rdr) { for (int i = 0; i < dd.AddressTableEntries; i++) { ExportAddressEntry d = new ExportAddressEntry(); Rva rva = rdr.ReadRva(); d.Address = rva; if (!(rva > dd.Location.Address && rva < dd.Location.Address + dd.Location.Size)) { d.Type = ExportAddressType.RealExport; d.Forwarder = ""; } else { d.Type = ExportAddressType.ForwarderExport; rdr.SaveLocation(); rdr.SetPosition(rva); d.Forwarder = rdr.ReadString(); rdr.LoadLocation(); } this.Items.Add(d); } }
protected override void LoadInternal(VirtualReader rdr) { ImportDirectoryEntry entry; while (true) { entry = new ImportDirectoryEntry(this); Rva ltAdr = rdr.ReadRva(); entry.DateTimeStamp = rdr.ReadStamp(); entry.ForwarderChain = rdr.ReadUInt32(); Rva nAdr = rdr.ReadRva(); Rva atAdr = rdr.ReadRva(); if (ltAdr == 0 && atAdr == 0 && nAdr == 0) { break; } rdr.SaveLocation(); rdr.SetPosition(ltAdr); entry.LookupTable = new ImportFunctionTable(entry); entry.LookupTable.Load(rdr, false); rdr.LoadLocation(); rdr.SaveLocation(); rdr.SetPosition(nAdr); entry.Name = rdr.ReadString(); rdr.LoadLocation(); rdr.SaveLocation(); rdr.SetPosition(atAdr); entry.AddressTable = new ImportFunctionTable(entry); entry.AddressTable.Load(rdr, StampsHelper.UIntFromStamp(entry.DateTimeStamp) == 0xffffffff); rdr.LoadLocation(); items.Add(entry); } }
public void SetPosition(Rva pos) { BaseStream.Position = pos; }
protected override void LoadInternal(VirtualReader rdr) { s = rdr.ReadUInt32(); maVer = rdr.ReadUInt16(); miVer = rdr.ReadUInt16(); dats = new CLRDatas(this); dats.IsLoading = true; Rva mdAdr = rdr.ReadRva(); uint mdSze = rdr.ReadUInt32(); f = (RuntimeFlags)rdr.ReadUInt32(); if ((f & RuntimeFlags.NativeEntryPoint) == RuntimeFlags.NativeEntryPoint) { Rva ep = rdr.ReadRva(); rdr.SaveLocation(); rdr.SetPosition(ep); byte[] ec = NativeHelper.GetNativeCodes(rdr); rdr.LoadLocation(); e = ep; dats.Add(new CLRData() { Address = ep, Data = ec }); } else { t = rdr.ReadUInt32(); } Rva resAdr = rdr.ReadRva(); uint resSze = rdr.ReadUInt32(); Rva snAdr = rdr.ReadRva(); uint snSze = rdr.ReadUInt32(); Rva cmAdr = rdr.ReadRva(); uint cmSze = rdr.ReadUInt32(); Rva vtAdr = rdr.ReadRva(); uint vtSze = rdr.ReadUInt32(); Rva eatAdr = rdr.ReadRva(); uint eatSze = rdr.ReadUInt32(); Rva mnAdr = rdr.ReadRva(); uint mnSze = rdr.ReadUInt32(); rdr.SetPosition(resAdr); res = rdr.ReadBytes((int)resSze); rdr.SetPosition(snAdr); sn = rdr.ReadBytes((int)snSze); rdr.SetPosition(cmAdr); cm = rdr.ReadBytes((int)cmSze); rdr.SetPosition(eatAdr); eat = rdr.ReadBytes((int)eatSze); rdr.SetPosition(mnAdr); mn = rdr.ReadBytes((int)mnSze); vt = new VTableFixups(this); vt.Load(rdr, vtAdr, vtSze); md = new MetadataRoot(this); md.Load(rdr, mdAdr); dats.IsLoading = false; // Save the read info MetadataDirEntry = new CLRDataDirectoryEntry("MetaData", mdAdr, mdSze); ResourceDirEntry = new CLRDataDirectoryEntry("Resources", resAdr, resSze); StrongNameDirEntry = new CLRDataDirectoryEntry("Strong Name Signature", snAdr, snSze); CodeManagerTableDirEntry = new CLRDataDirectoryEntry("Code Manager Table", cmAdr, cmSze); VTableFixupsDirEntry = new CLRDataDirectoryEntry("VTable Fixups", vtAdr, vtSze); ExportAddressTableJumpsDirEntry = new CLRDataDirectoryEntry("Export Address Table Jumps", eatAdr, eatSze); ManagedNativeHeaderDirEntry = new CLRDataDirectoryEntry("Managed Native Header", mnAdr, mnSze); }
public override string ToString() { return(base.ToString() + " " + Name + " points to {" + Rva.ToString("X8") + " - " + (Rva + Size).ToString("X8") + "}"); }
void ReadRvaData(MetadataTable tbl, MetadataReader mdRdr, List <Rva> rvas, MetadataRowCollection rows) { List <Rva> sorted = new List <Rva>(rvas); sorted.Sort(); for (int i = 0; i < rvas.Count; i++) { Rva rva = rvas[i]; MetadataRow r = rows[i + 1]; byte[] dat = null; VirtualReader rdr = new VirtualReader(mdRdr.BaseStream.File.SectionHeaders.GetVirtualStream()); if (tbl.Type == TableType.FieldRVA) { MetadataRoot root = tbl.Heap.Stream.Root; rdr.SetPosition(rva); MetadataRow fd = (r["Field"] as TableToken).ResolveRow(); FieldSig sig = new FieldSig(); SignatureReader sigRdr = new SignatureReader(new MetadataReader(root[MetadataStreamType.Blob])); sigRdr.BaseStream.Position = (fd["Signature"] as BlobToken).Token.Index; sig.Read(sigRdr); int c = 0; switch (sig.Type.Element) { case ElementType.Boolean: case ElementType.UInt8: case ElementType.Int8: c = 1; break; case ElementType.UInt16: case ElementType.Int16: case ElementType.Char: c = 2; break; case ElementType.UInt32: case ElementType.Int32: case ElementType.Single: c = 4; break; case ElementType.UInt64: case ElementType.Int64: case ElementType.Double: c = 8; break; case ElementType.ValueType: TableToken vt = (sig.Type as VALUETYPE).Type; foreach (MetadataRow cl in tbl.Heap[TableType.ClassLayout]) { if (cl["Parent"] == vt) { c = (int)cl["ClassSize"]; break; } } break; default: throw new InvalidOperationException("ReadRvaData"); } dat = rdr.ReadBytes(c); } else if (tbl.Type == TableType.MethodDef && rva != 0) { //MethodBody bdy; //if (((MethodImplAttributes)r["ImplFlags"] & MethodImplAttributes.Native) == MethodImplAttributes.Native) //{ // bdy = new NativeMethodBody(r); //} //else //{ // bdy = new ManagedMethodBody(r); //} //rdr.SetPosition(rva); //bdy.Load(rdr); //rdr.SetPosition(rva); //dat = rdr.ReadBytes((int)bdy.Size); int idx; Rva next; if ((idx = sorted.IndexOf(rva)) == sorted.Count - 1) { CLRDirectory root = tbl.Heap.Stream.Root.Directory; Rva now; next = uint.MaxValue; rdr.SetPosition(root.Location.Address); rdr.BaseStream.Seek(0x8, System.IO.SeekOrigin.Current); if ((now = rdr.ReadRva()) < next && now != 0 && now > rva) { next = now; } rdr.BaseStream.Seek(0xC, System.IO.SeekOrigin.Current); if ((now = rdr.ReadRva()) < next && now != 0 && now > rva) { next = now; } rdr.BaseStream.Seek(0x4, System.IO.SeekOrigin.Current); if ((now = rdr.ReadRva()) < next && now != 0 && now > rva) { next = now; } rdr.BaseStream.Seek(0x4, System.IO.SeekOrigin.Current); if ((now = rdr.ReadRva()) < next && now != 0 && now > rva) { next = now; } rdr.BaseStream.Seek(0x4, System.IO.SeekOrigin.Current); if ((now = rdr.ReadRva()) < next && now != 0 && now > rva) { next = now; } rdr.BaseStream.Seek(0x4, System.IO.SeekOrigin.Current); if ((now = rdr.ReadRva()) < next && now != 0 && now > rva) { next = now; } rdr.BaseStream.Seek(0x4, System.IO.SeekOrigin.Current); if ((now = rdr.ReadRva()) < next && now != 0 && now > rva) { next = now; } } else { next = sorted[idx + 1]; } rdr.SetPosition(rva); dat = rdr.ReadBytes((int)(next - rva)); } if (!tbl.Heap.Stream.Root.Directory.Datas.ContainsAddress(rva) && dat != null) { tbl.Heap.Stream.Root.Directory.Datas.Add(new CLRData() { Address = rva, Data = dat }); } } }
internal void Load(VirtualReader rdr, Rva root) { c = rdr.ReadUInt32(); stamp = rdr.ReadStamp(); maVer = rdr.ReadUInt16(); miVer = rdr.ReadUInt16(); noName = rdr.ReadUInt16(); noID = rdr.ReadUInt16(); for (int i = 0; i < noName; i++) { ResourceEntry e = new ResourceEntry(); e.Type = EntryType.Name; Rva nRva = rdr.ReadRva() & ~0x80000000; rdr.SaveLocation(); rdr.SetPosition(nRva + root); e.Name = rdr.ReadUnicodeString(); rdr.LoadLocation(); Rva datAdr = rdr.ReadUInt32(); if ((datAdr & 0x80000000) == 0x80000000) { datAdr &= ~0x80000000; e.Type |= EntryType.Subdirectory; e.Data = new Subdirectory(e); rdr.SaveLocation(); rdr.SetPosition(datAdr + root); (e.Data as Subdirectory).Load(rdr, root); rdr.LoadLocation(); } else { e.Type |= EntryType.DataEntry; e.Data = new DataEntry(e); rdr.SaveLocation(); rdr.SetPosition(datAdr + root); (e.Data as DataEntry).Load(rdr); rdr.LoadLocation(); } this.Add(e); } for (int i = 0; i < noID; i++) { ResourceEntry e = new ResourceEntry(); e.Type = EntryType.ID; e.ID = rdr.ReadUInt32() & ~0x80000000; Rva datAdr = rdr.ReadUInt32(); if ((datAdr & 0x80000000) == 0x80000000) { datAdr &= ~0x80000000; e.Type |= EntryType.Subdirectory; e.Data = new Subdirectory(e); rdr.SaveLocation(); rdr.SetPosition(datAdr + root); (e.Data as Subdirectory).Load(rdr, root); rdr.LoadLocation(); } else { e.Type |= EntryType.DataEntry; e.Data = new DataEntry(e); rdr.SaveLocation(); rdr.SetPosition(datAdr + root); (e.Data as DataEntry).Load(rdr); rdr.LoadLocation(); } this.Add(e); } }
public MetadataTable Load(TablesHeap h, MetadataReader rdr, uint[] lens, TableType type) { MetadataTable ret = new MetadataTable(h, type); Reader[] read = new Reader[ret.Columns.Length]; for (int i = 0; i < ret.Columns.Length; i++) { int k = i; var retColTypeObj = ret.Columns[i].Type; if (retColTypeObj is Type) { var retColType = retColTypeObj as Type; //if (retColType.IsSubclassOf(typeof(Enum))) if (retColType.IsEnum) { var underEnumType = Enum.GetUnderlyingType(retColType); //read[i] = DicEnumReader[underEnumType]; if (underEnumType == typeof(byte)) { read[i] = new Reader(ReadByteFlag); } else if (underEnumType == typeof(System.UInt16)) { read[i] = new Reader(ReadUInt16Flag); } else if (underEnumType == typeof(System.UInt32)) { read[i] = new Reader(ReadUInt32Flag); } //switch (Enum.GetUnderlyingType(retColType).FullName) //{ // case "System.Byte": // read[i] = new Reader(ReadByteFlag); // break; // case "System.UInt16": // read[i] = new Reader(ReadUInt16Flag); // break; // case "System.UInt32": // read[i] = new Reader(ReadUInt32Flag); // break; //} } else { //read[i] = DicReader[retColType]; if (retColType == typeof(byte)) { read[i] = new Reader(ReadByte); } else if (retColType == typeof(System.UInt16)) { read[i] = new Reader(ReadUInt16); } else if (retColType == typeof(System.UInt32)) { read[i] = new Reader(ReadUInt32); } else if (retColType == typeof(NetPE.Core.Rva)) { read[i] = new Reader(ReadRva); } else if (retColType == typeof(NetPE.Core.Metadata.BlobToken)) { read[i] = new Reader(ReadBlobToken); } else if (retColType == typeof(NetPE.Core.Metadata.GUIDToken)) { read[i] = new Reader(ReadGUIDToken); } else if (retColType == typeof(NetPE.Core.Metadata.StringToken)) { read[i] = new Reader(ReadStringToken); } //switch ((ret.Columns[i].Type as Type).FullName) //{ // case "System.Byte": // read[i] = new Reader(ReadByte); // break; // case "System.UInt16": // read[i] = new Reader(ReadUInt16); // break; // case "System.UInt32": // read[i] = new Reader(ReadUInt32); // break; // case "NetPE.Core.Rva": // read[i] = new Reader(ReadRva); // break; // case "NetPE.Core.Metadata.BlobToken": // read[i] = new Reader(ReadBlobToken); // break; // case "NetPE.Core.Metadata.GUIDToken": // read[i] = new Reader(ReadGUIDToken); // break; // case "NetPE.Core.Metadata.StringToken": // read[i] = new Reader(ReadStringToken); // break; //} } } else if (retColTypeObj is TableType) { read[i] = new Reader(ReadTableToken); } else if (retColTypeObj is CodedIndex) { read[i] = new Reader(ReadCodedToken); } } List <Rva> rvas = new List <Rva>(); for (int i = 1; i <= lens[(int)ret.Type]; i++) { MetadataRow r = new MetadataRow(ret, false); bool hasRva = ret.Type == TableType.MethodDef || ret.Type == TableType.FieldRVA; int rvaIdx = 0; Rva rva = 0; for (int ii = 0; ii < read.Length; ii++) { if (hasRva && (ret.Columns[ii].Type is Type) && ((ret.Columns[ii].Type as Type) == typeof(NetPE.Core.Rva))) { rvaIdx = ii; rva = (Rva)rdr.ReadUInt32(); } else { r[ii] = read[ii](ii, ret, rdr, lens); } } if (hasRva) { r[rvaIdx] = rva; rvas.Add(rva); } r.Token = new MetadataToken((MetadataTokenType)ret.Type, (uint)i); ret.Rows.Add(r); } ReadRvaData(ret, rdr, rvas, ret.Rows); return(ret); }