public Engine(Configuration configuration, RuntimeBase runtime) { if (runtime == null) { throw new ArgumentNullException("runtime"); } this._CachedNames = new Dictionary <int, string>(); this._CachedClasses = new Dictionary <IntPtr, UnrealClass>(); this._CachedFields = new Dictionary <IntPtr, UnrealField>(); this._CachedPaths = new Dictionary <IntPtr, string>(); this.Configuration = (Configuration)configuration.Clone(); this.Runtime = runtime; this._NameAddresses = this.ReadPointerArray(configuration.GlobalNameArrayAddress); this._ObjectAddresses = this.ReadPointerArray(configuration.GlobalObjectArrayAddress); this._ObjectShims = new Dictionary <IntPtr, UnrealObjectShim>(); foreach (var objectAddress in this._ObjectAddresses.Where(oa => oa != IntPtr.Zero)) { var objectClassPointer = this.ReadPointer(objectAddress + this.Offsets.CoreObjectClass); var objectClass = this.ReadClass(objectClassPointer); var objectName = this.ReadName(objectAddress + this.Offsets.CoreObjectName); var objectPath = this.ReadPath(objectAddress); var objectShim = new UnrealObjectShim(this, objectAddress, objectClass, objectName, objectPath); this._ObjectShims.Add(objectAddress, objectShim); } }
public override ISimulatable NewSimulator(string name, RuntimeBase runtime) { switch (name) { case Models.Network.Name: return(new PeerToPeerNetworkSimulator(runtime)); case Models.Scene.Name: return(new SceneSimulator(runtime)); case Models.Channel.AdaptedFriis.Name: return(new AdaptedFriisSimulator(runtime)); case Models.Antenna.Spheric.Name: return(new SphericAntennaSimulator(runtime)); case Models.Antenna.Simple.Name: return(new SimpleAntennaSimulator(runtime)); case Models.Antenna.Flat.Name: return(new SimpleAntennaSimulator(runtime)); case Models.Communication.LrWpan.Name: return(new LrwpanSimulator(runtime)); case Models.Energy.Battery.Name: return(new BatteryPackSimulator(runtime)); default: return(null); } }
// -- constructor public ImportPipeline(OptionsBase options, FactoryBase factory, RuntimeBase runtime) { Arguments = new Dictionary <SimulationTypes, ArgumentsBase>(); Options = options; Factory = factory; Runtime = runtime; }
public HeapBase(RuntimeBase runtime) { _canWalkHeap = runtime.CanWalkHeap; if (runtime.DataReader.CanReadAsync) MemoryReader = new AsyncMemoryReader(runtime.DataReader, 0x10000); else MemoryReader = new MemoryReader(runtime.DataReader, 0x10000); _pointerSize = runtime.PointerSize; }
private static StashTableEntry <T>[] ReadStashTable <T>( this RuntimeBase runtime, IntPtr pointer, Func <IntPtr, T> callback) { if (pointer == IntPtr.Zero) { return(new StashTableEntry <T> [0]); } StashTableHeader header; if (runtime.Is32Bit == false) { header = runtime.ReadStructure <StashTableHeader>(pointer); } else { header = runtime.ReadStructure <x32.StashTableHeader>(pointer).Upgrade(); } if (header.AllocatedCount == 0) { return(new StashTableEntry <T> [0]); } StashTableEntry[] entries; if (runtime.Is32Bit == false) { entries = runtime.ReadStructureArray <StashTableEntry>(header.EntriesPointer, header.AllocatedCount); } else { var entries32 = runtime.ReadStructureArray <x32.StashTableEntry>(header.EntriesPointer, header.AllocatedCount); entries = new StashTableEntry[header.AllocatedCount]; for (int i = 0; i < header.AllocatedCount; i++) { entries[i] = entries32[i].Upgrade(); } } var items = new StashTableEntry <T> [header.AllocatedCount]; int o = 0; for (int i = 0; i < header.AllocatedCount; i++) { var entry = entries[i]; if (entry.NamePointer == default && entry.ValuePointer == default) { continue; } var name = runtime.ReadStringZ(entry.NamePointer, Encoding.ASCII); var value = callback(entry.ValuePointer); items[o] = new StashTableEntry <T>(name, value); o++; } Array.Resize(ref items, o); return(items); }
internal static int GetTlsSlotForThread(RuntimeBase runtime, ulong teb) { const int maxTlsSlot = 64; const int tlsSlotOffset = 0x1480; // Same on x86 and amd64 const int tlsExpansionSlotsOffset = 0x1780; uint ptrSize = (uint)runtime.PointerSize; ulong lowerTlsSlots = teb + tlsSlotOffset; uint clrTlsSlot = runtime.GetTlsSlot(); if (clrTlsSlot == uint.MaxValue) { return(0); } ulong tlsSlot = 0; if (clrTlsSlot < maxTlsSlot) { tlsSlot = lowerTlsSlots + ptrSize * clrTlsSlot; } else { if (!runtime.ReadPointer(teb + tlsExpansionSlotsOffset, out tlsSlot) || tlsSlot == 0) { return(0); } tlsSlot += ptrSize * (clrTlsSlot - maxTlsSlot); } ulong clrTls = 0; if (!runtime.ReadPointer(tlsSlot, out clrTls)) { return(0); } // Get thread data; uint tlsThreadTypeIndex = runtime.GetThreadTypeIndex(); if (tlsThreadTypeIndex == uint.MaxValue) { return(0); } ulong threadType = 0; if (!runtime.ReadPointer(clrTls + ptrSize * tlsThreadTypeIndex, out threadType)) { return(0); } return((int)threadType); }
public override void Arrange() { base.Arrange(); _runtime = new RuntimeController(new D3vS1mValidator()); _runtime.IterationPassed += (o, e) => { var runtimeArgs = e.Arguments as RuntimeArgs; _log.Debug(runtimeArgs); }; }
// -- constructor protected SimulatorBase(RuntimeBase runtime) { _log = LoggingProvider.CreateLogger <SimulatorBase>(); Guid = global::System.Guid.NewGuid().ToString(); if (runtime != null) { _runtime = runtime; _runtime.Started += OnStarted; } }
public override RuntimeBase SetupRuntime(ArgumentsBase[] args, RuntimeBase runtime) { base.Simulators.Clear(); foreach (var arg in args) { RegisterSimulator( NewSimulator(arg.Name, runtime), arg); } runtime.BindSimulators(Simulators); return(runtime); }
private static uint HashKeyValueList(RuntimeBase runtime, IntPtr baseAddress, uint hash) { var entries = runtime.ReadStringStashTable(baseAddress); var sb = new StringBuilder(); foreach (var entry in entries.OrderBy(e => e.Name.ToLowerInvariant())) { sb.Append(entry.Name); sb.Append(entry.Value); } return(Adler32.Hash(sb.ToString(), hash)); }
internal DesktopThread(RuntimeBase clr, IThreadData thread, ulong address, bool finalizer) { m_runtime = clr; m_address = address; m_finalizer = finalizer; Debug.Assert(thread != null); if (thread != null) { m_osThreadId = thread.OSThreadID; m_managedThreadId = thread.ManagedThreadID; m_appDomain = thread.AppDomain; m_lockCount = thread.LockCount; m_teb = thread.Teb; m_threadState = thread.State; m_exception = thread.ExceptionPtr; m_preemptive = thread.Preemptive; } }
public Engine(Configuration configuration, RuntimeBase runtime) { if (runtime == null) { throw new ArgumentNullException("runtime"); } this.Configuration = (Configuration)configuration.Clone(); this.Runtime = runtime; this._NameAddresses = this.ReadPointerArray(configuration.GlobalNameArrayAddress); this._ObjectAddresses = this.ReadPointerArray(configuration.GlobalObjectArrayAddress); foreach (var objectAddress in this._ObjectAddresses.Where(oa => oa != IntPtr.Zero)) { var objectClassPointer = this.ReadPointer(objectAddress + this.Configuration.ObjectClassOffset); var objectClass = this.ReadClass(objectClassPointer); var objectName = this.ReadName(objectAddress + this.Configuration.ObjectNameOffset); var objectPath = this.ReadPath(objectAddress); this._ObjectShims.Add(objectAddress, new UnrealObjectShim(this, objectAddress, objectClass, objectName, objectPath)); } }
private void SetupDemoRepo(RuntimeBase runtime) { var sceneArgs = new InvariantSceneArgs(); var radioArgs = base.GetRadioArgs(); var comArgs = new WirelessCommArgs(); var netArgs = new NetworkArgs(); var antennaArgs = new SimpleAntennaArgs(); _repo = new SimulatorRepository(); _repo.AddRange(new ISimulatable[] { new SceneSimulator(runtime) .With(sceneArgs), new AdaptedFriisSimulator(runtime) .With(radioArgs) .With(comArgs), new SimpleAntennaSimulator(runtime) .With(antennaArgs), new PeerToPeerNetworkSimulator(runtime) .With(netArgs), new LrwpanSimulator(runtime) .With(comArgs) }); }
internal HeapSegment(RuntimeBase clr, ISegmentData segment, SubHeap subHeap, bool large, HeapBase heap) { _clr = clr; _large = large; _segment = segment; _heap = heap; _subHeap = subHeap; }
// -- constructor public LrwpanSimulator(RuntimeBase runtime) : base(runtime) { }
// -- constructors public SceneSimulator(RuntimeBase runtime) : base(runtime) { }
public abstract ISimulatable NewSimulator(string name, RuntimeBase runtime);
public AdaptedFriisSimulator(RuntimeBase runtime) : base(runtime) { _log = LoggingProvider.CreateLogger <SimulatorBase>(); }
public static StashTableEntry <IntPtr>[] ReadStashTable(this RuntimeBase runtime, IntPtr pointer) { return(runtime.ReadStashTable(pointer, p => p)); }
// -- constructor public SimpleAntennaSimulator(RuntimeBase runtime) : base(runtime) { }
// -- constructor public PeerToPeerNetworkSimulator(RuntimeBase runtime) : base(runtime) { }
public HeapBase(RuntimeBase runtime) { _canWalkHeap = runtime.CanWalkHeap; MemoryReader = new MemoryReader(runtime.DataReader, 0x10000); _pointerSize = runtime.PointerSize; }
internal static int GetTlsSlotForThread(RuntimeBase runtime, ulong teb) { const int maxTlsSlot = 64; const int tlsSlotOffset = 0x1480; // Same on x86 and amd64 const int tlsExpansionSlotsOffset = 0x1780; uint ptrSize = (uint)runtime.PointerSize; ulong lowerTlsSlots = teb + tlsSlotOffset; uint clrTlsSlot = runtime.GetTlsSlot(); if (clrTlsSlot == uint.MaxValue) return 0; ulong tlsSlot = 0; if (clrTlsSlot < maxTlsSlot) { tlsSlot = lowerTlsSlots + ptrSize * clrTlsSlot; } else { if (!runtime.ReadPointer(teb + tlsExpansionSlotsOffset, out tlsSlot) || tlsSlot == 0) return 0; tlsSlot += ptrSize * (clrTlsSlot - maxTlsSlot); } ulong clrTls = 0; if (!runtime.ReadPointer(tlsSlot, out clrTls)) return 0; // Get thread data; uint tlsThreadTypeIndex = runtime.GetThreadTypeIndex(); if (tlsThreadTypeIndex == uint.MaxValue) return 0; ulong threadType = 0; if (!runtime.ReadPointer(clrTls + ptrSize * tlsThreadTypeIndex, out threadType)) return 0; return (int)threadType; }
internal DesktopThread(RuntimeBase clr, IThreadData thread, ulong address, bool finalizer) { _runtime = clr; _address = address; _finalizer = finalizer; Debug.Assert(thread != null); if (thread != null) { _osThreadId = thread.OSThreadID; _managedThreadId = thread.ManagedThreadID; _appDomain = thread.AppDomain; _lockCount = thread.LockCount; _teb = thread.Teb; _threadState = thread.State; _exception = thread.ExceptionPtr; _preemptive = thread.Preemptive; } }
private static uint HashTable(RuntimeBase runtime, IntPtr address, uint hash) { throw new NotImplementedException(); var columns = new List <KeyValuePair <ParseColumn, string> >(); var currentAddress = address; while (true) { var column = runtime.ReadStructure <ParseColumn>(currentAddress); currentAddress += 40; var name = runtime.ReadStringZ(column.NamePointer, Encoding.ASCII); if (column.Type == 0) { if (string.IsNullOrEmpty(name) == true) { break; } } columns.Add(new KeyValuePair <ParseColumn, string>(column, name)); } foreach (var kv in columns) { var column = kv.Key; if (column.Flags.HasAny(Parse.ColumnFlags.REDUNDANTNAME | Parse.ColumnFlags.UNOWNED) == true) { continue; } var name = kv.Value; if (string.IsNullOrEmpty(name) == false) { hash = Adler32.Hash(name, hash); } hash = Adler32.Hash(column.Type, hash); var token = Parse.GlobalTokens.GetToken(column.Token); switch (token.GetParameter(column.Flags, 0)) { case Parse.ColumnParameter.NumberOfElements: case Parse.ColumnParameter.Default: case Parse.ColumnParameter.StringLength: case Parse.ColumnParameter.Size: { hash = Adler32.Hash(column.Parameter0.Int32, hash); break; } case Parse.ColumnParameter.BitOffset: { hash = Adler32.Hash(column.Parameter0.Int32 >> 16, hash); break; } case Parse.ColumnParameter.DefaultString: case Parse.ColumnParameter.CommandString: { if (column.Parameter0.Pointer != default) { hash = Adler32.Hash(runtime.ReadStringZ(column.Parameter0.Pointer, Encoding.ASCII), hash); } break; } } var param1 = token.GetParameter(column.Flags, 1); if (column.Parameter1.Pointer != default && (column.Token == 20 || column.Token == 21) && address != column.Parameter1.Pointer && column.Flags.HasAny(Parse.ColumnFlags.STRUCT_NORECURSE) == false) { hash = HashTable(runtime, column.Parameter1.Pointer, hash); } if (column.Parameter1.Pointer != default && param1 == Parse.ColumnParameter.StaticDefineList) { hash = HashStaticDefineList(runtime, column.Parameter1.Pointer, hash); } if (column.Token == 23) { var formatString = runtime.ReadStringZ(column.FormatStringPointer, Encoding.ASCII); if (string.IsNullOrEmpty(formatString) == false) { hash = Adler32.Hash(formatString, hash); } } } return(hash); }
public abstract RuntimeBase SetupRuntime(ArgumentsBase[] args, RuntimeBase runtime);
public BatteryPackSimulator(RuntimeBase runtime) : base(runtime) { _log = LoggingProvider.CreateLogger <BatteryPackSimulator>(); }
protected void InitSegments(RuntimeBase runtime) { // Populate segments SubHeap[] heaps; if (runtime.GetHeaps(out heaps)) { var segments = new List<HeapSegment>(); foreach (var heap in heaps) { if (heap != null) { ISegmentData seg = runtime.GetSegmentData(heap.FirstLargeSegment); while (seg != null) { var segment = new HeapSegment(runtime, seg, heap, true, this); segments.Add(segment); UpdateSegmentData(segment); seg = runtime.GetSegmentData(seg.Next); } seg = runtime.GetSegmentData(heap.FirstSegment); while (seg != null) { var segment = new HeapSegment(runtime, seg, heap, false, this); segments.Add(segment); UpdateSegmentData(segment); seg = runtime.GetSegmentData(seg.Next); } } } UpdateSegments(segments.ToArray()); } else { _segments = new ClrSegment[0]; } }
public SphericAntennaSimulator(RuntimeBase runtime) : base(runtime) { _log = LoggingProvider.CreateLogger <SphericAntennaSimulator>(); }
public static StashTableEntry <string>[] ReadStringStashTable(this RuntimeBase runtime, IntPtr pointer) { return(runtime.ReadStashTable(pointer, p => runtime.ReadStringZ(p, Encoding.ASCII))); }
private static uint HashStaticDefineList(RuntimeBase runtime, IntPtr baseAddress, uint hash) { var valueType = 4; while (true) { var type = runtime.ReadValueU32(baseAddress); if (type == 0) { break; } switch (type) { case 1: { valueType = 1; baseAddress += 8; break; } case 2: { valueType = 2; baseAddress += 8; break; } case 3: { var listAddress = runtime.ReadPointer(baseAddress + 4); baseAddress += 8; if (listAddress != IntPtr.Zero) { hash = HashKeyValueList(runtime, listAddress, hash); } break; } case 5: { var parent = runtime.ReadPointer(baseAddress + 4); return(HashStaticDefineList(runtime, parent, hash)); } default: { // TODO(gibbed): FIXME var name = runtime.ReadStringZ(new IntPtr(type), Encoding.ASCII); hash = Adler32.Hash(name, hash); switch (valueType) { case 1: { var value = runtime.ReadValueU32(baseAddress + 4); hash = Adler32.Hash(value, hash); baseAddress += 8; break; } case 2: { var value = runtime.ReadStringZ(baseAddress + 4, Encoding.ASCII); hash = Adler32.Hash(value, hash); baseAddress += 8; break; } default: { throw new NotImplementedException(); } } break; } } } return(hash); }