/[RomCheater]/trunk/RomCheater/Docking/FloatingMemorySearcher.cs
ViewVC logotype

Annotation of /trunk/RomCheater/Docking/FloatingMemorySearcher.cs

Parent Directory Parent Directory | Revision Log Revision Log


Revision 459 - (hide annotations) (download)
Mon Jun 3 02:23:04 2013 UTC (7 years, 4 months ago) by william
File size: 139755 byte(s)

1 william 414 #region Logging Defines
2     // include this any class or method that required logging, and comment-out what is not needed
3 william 415
4 william 414 #region Enabled logging levels
5     #define LOGGING_ENABLE_INFO
6     #define LOGGING_ENABLE_WARN
7     #define LOGGING_ENABLE_DEBUG
8     #define LOGGING_ENABLE_VERBOSEDEBUG
9     #define LOGGING_ENABLE_ERROR
10     #define LOGGING_ENABLE_VERBOSEERROR
11     #define LOGGING_ENABLE_PROFILER
12     #endregion
13     #endregion
14     //#define USE_AUTOMATIC_MEMORY_SEARCH_RANGE // when defined will automatically choose the best starting address and size for memory search otherwise it will use the constants defined in MemorySizeConstants
15 william 289 #if !USE_AUTOMATIC_MEMORY_SEARCH_RANGE
16 william 287 #define FORCE_USE_OF_MEMORYSIZECONSTANTS // when defined wil force the use of the constants defined in MemorySizeConstants for memory search range
17 william 289 #endif
18 william 452 #define DONOT_HAVE_RANGED_SEARCH_SUPPORT // when defined, indicates that ranged searches have not been implemented
19 william 280 #define INCREASE_NUMBER_OF_RESULTS_BEFORE_DISPLAY // when defined will set MIN RESULTS to 0x2701 otherwise 0x03e8
20     //#define DO_NOT_SUSPEND_RESUME_THREAD_ON_FREEZE // when defined will not freeze/resume thread on freeze
21 william 229 using System;
22 william 227 using System.Collections.Generic;
23     using System.ComponentModel;
24     using System.Data;
25     using System.Drawing;
26     using System.Linq;
27     using System.Text;
28     using System.Windows.Forms;
29     using WeifenLuo.WinFormsUI.Docking;
30     using RomCheater.PluginFramework.Interfaces;
31     using System.Diagnostics;
32 william 229 using RomCheater.Docking.MemorySearch;
33     using libWin32.Win32.Threading;
34 william 230 using System.Threading;
35     using RomCheater.Logging;
36     using System.IO;
37 william 242 using Sojaner.MemoryScanner.MemoryProviers;
38 william 275 using RomCheater.PluginFramework.Events;
39 william 287 using System.Reflection;
40 william 292 using Sojaner.MemoryScanner;
41 william 399 using System.Collections;
42 william 401 using RomCheater.Serialization;
43 william 227
44     namespace RomCheater.Docking
45     {
46 william 228 public partial class FloatingMemorySearcher : DockContent,
47 william 243 IAcceptsPlugin<IConfigPlugin>,
48     IAcceptsProcess<Process>,
49     IAcceptsProcessAndConfig,
50 william 275 ISearchInProgress,
51 william 287 IAcceptsBrowseMemoryRegion,
52     IAcceptsMemoryRange
53 william 227 {
54 william 280 #if INCREASE_NUMBER_OF_RESULTS_BEFORE_DISPLAY
55     const int MIN_NUMBER_OF_RESULTS_BEFORE_DISPLAY = 0x2701; // 10,000 results
56     #else
57     const int MIN_NUMBER_OF_RESULTS_BEFORE_DISPLAY = 0x03e8; // 1,000 results
58     #endif
59    
60 william 452 const bool USE_OLD_SEARCH_RESULTS_COMPRATOR_CODE = false;
61 william 457 const bool USE_NONRANGE_SEARCH_RESULT_READER = false;
62 william 229 private bool DefaultUnsignedState = true; // set unsigned to true
63 william 287 public FloatingMemorySearcher() { InitializeComponent(); this.AcceptedPlugin = null; OnBrowseMemoryRegion = null; this.AcceptedProcess = null; SearchInProgess = false; Reload(); }
64 william 227 public FloatingMemorySearcher(IConfigPlugin config) : this() { this.AcceptedPlugin = config; }
65     public FloatingMemorySearcher(IConfigPlugin config, Process process) : this() { this.AcceptedPlugin = config; this.AcceptedProcess = process; }
66    
67 william 237 #region IAcceptsProcess<Process> Members
68 william 243 private Process _AcceptedProcess;
69 william 305 public Process AcceptedProcess { get { return _AcceptedProcess; } set { _AcceptedProcess = value; UpdateAcceptedProcess(value); } }
70 william 227 #endregion
71     #region IAcceptsPlugin<IConfigPlugin> Members
72 william 243 private IConfigPlugin _AcceptedPlugin;
73 william 305 public IConfigPlugin AcceptedPlugin { get { return _AcceptedPlugin; } set { _AcceptedPlugin = value; UpdateAcceptedPlugin(value); } }
74 william 227 #endregion
75 william 275 #region IAcceptsBrowseMemoryRegion members
76 william 287 public event BaseEventHandler<BrowseMemoryRegionEvent> OnBrowseMemoryRegion;
77 william 275 #endregion
78    
79 william 305 private void UpdateAcceptedPlugin(IConfigPlugin config)
80 william 243 {
81     this.lstResults.AcceptedPlugin = config;
82     this.lstPatchList.AcceptedPlugin = config;
83 william 389 if (config != null)
84     {
85     MemoryRangeStart = AcceptedPlugin.MemoryRangeStart;
86     MemoryRangeSize = AcceptedPlugin.MemoryRangeStart + AcceptedPlugin.MemoryRangeSize;
87     }
88 william 305 }
89     private void UpdateAcceptedProcess(Process process)
90     {
91     this.lstResults.AcceptedProcess = process;
92 william 243 this.lstPatchList.AcceptedProcess = process;
93 william 287 #if USE_AUTOMATIC_MEMORY_SEARCH_RANGE && FORCE_USE_OF_MEMORYSIZECONSTANTS
94     logger.Warn.WriteLine("FloatingMemorySearcher.UpdateAcceptedProcessAndConfig(IConfigPlugin config, Process process):");
95     logger.Warn.WriteLine("Both USE_AUTOMATIC_MEMORY_SEARCH_RANGE and FORCE_USE_OF_MEMORYSIZECONSTANTS are defined");
96     logger.Warn.WriteLine("FORCE_USE_OF_MEMORYSIZECONSTANTS will take precedence and will ignore the values supplied in the memeory search range");
97 william 289 #endif
98     #if FORCE_USE_OF_MEMORYSIZECONSTANTS
99     // force use of MemorySizeConstants
100 william 349 txtMemoryRangeStart.Value = MemorySizeConstants.MinimumSearchAddress;
101 william 401 txtMemoryRangeSize.Value = MemorySizeConstants.MinimumSearchAddress + MemorySizeConstants.MaximumSearchSize;
102 william 287 #endif
103     #if USE_AUTOMATIC_MEMORY_SEARCH_RANGE && !FORCE_USE_OF_MEMORYSIZECONSTANTS
104 william 318 ////// code to automatically choose the best starting memory address and size
105     //if (process != null)
106     //{
107     // string filename = process.MainModule.FileName;
108     // //string filename = @"c:\Windows\notepad.exe";
109     // PEReader peReader = new PEReader(filename);
110     //}
111     //else
112     //{
113 william 389 //txtMemoryRangeStart.Value = MemorySizeConstants.MinimumSearchAddress;
114     //txtMemoryRangeSize.Value = MemorySizeConstants.MinimumSearchAddress + MemorySizeConstants.MaximumSearchSize;
115 william 318 //}
116 william 389 if (AcceptedPlugin != null)
117     {
118     MemoryRangeStart = AcceptedPlugin.MemoryRangeStart;
119     MemoryRangeSize = AcceptedPlugin.MemoryRangeStart + AcceptedPlugin.MemoryRangeSize;
120     }
121    
122 william 287 #endif
123    
124 william 243 }
125 william 228 #region ISearchInProgress members
126 william 399 private bool _SearchInProgess;
127     public bool SearchInProgess
128     {
129     get { return _SearchInProgess; }
130     private set
131     {
132     _SearchInProgess = value;
133     if (this.AcceptedPlugin != null)
134     this.AcceptedPlugin.SetMemorySearchReference(this);
135     }
136     }
137 william 444 private Guid _SearchGuid;
138     public Guid SearchGuid
139     {
140     get { return _SearchGuid; }
141     private set { _SearchGuid = value; }
142     }
143 william 228 #endregion
144 william 229
145 william 287 #region IAcceptsMemoryRange
146     #if !FORCE_USE_OF_MEMORYSIZECONSTANTS
147 william 389 private uint _MemoryRangeStart;
148 william 287 private uint _MemoryRangeSize;
149     #endif
150 william 378 public uint MemoryRangeStart
151 william 287 {
152     get
153     {
154     #if FORCE_USE_OF_MEMORYSIZECONSTANTS
155 william 349 return MemorySizeConstants.MinimumSearchAddress;
156 william 287 #else
157     return _MemoryRangeStart;
158     #endif
159     }
160     set
161     {
162     #if !FORCE_USE_OF_MEMORYSIZECONSTANTS
163     _MemoryRangeStart = value;
164 william 389 txtMemoryRangeStart.Value = value;
165 william 287 #endif
166     }
167     }
168     public uint MemoryRangeSize
169     {
170     get
171     {
172     #if FORCE_USE_OF_MEMORYSIZECONSTANTS
173 william 401 return MemorySizeConstants.MinimumSearchAddress + MemorySizeConstants.MaximumSearchSize;
174 william 287 #else
175     return _MemoryRangeSize;
176     #endif
177     }
178     set
179     {
180     #if !FORCE_USE_OF_MEMORYSIZECONSTANTS
181     _MemoryRangeSize = value;
182 william 389 txtMemoryRangeSize.Value = value;
183 william 287 #endif
184     }
185     }
186     #endregion
187 william 229
188     public void Reload()
189     {
190     chkUnsigned.Checked = DefaultUnsignedState;
191     radio_8bits.Checked = true;
192     radiocompare_equal.Checked = true;
193     radio_oldvalue.Checked = true;
194 william 230 chkRefreshResults.Checked = true;
195 william 229 }
196 william 230 public enum eListViewResults
197     {
198     SEARCH_RESULTS_LIST = 0x3000,
199     PATCH_RESULTS_LIST = 0x3001,
200     UKNOWN_RESULTS_LIST = 0x3001
201     }
202 william 280 bool IsFirstSearch = true;
203 william 277 SearchType SearchArgs;
204 william 272 static int col_Found_Address = 1;
205     static int col_Found_Value = 2;
206 william 419 //static int col_Found_Frozen = 3; /* unused */
207 william 272 static int col_Added_Address = 1;
208     static int col_Added_Value = 2;
209 william 419 //static int col_Added_Frozen = 3; /* unused */
210 william 230 List<ListViewItem> ResultItems = new List<ListViewItem>();
211     List<ListViewItem> AddedItems = new List<ListViewItem>();
212     private bool _PatchedValue_NeedsUpdate;
213     bool PatchedValue_NeedsUpdate
214     {
215     get { if (_PatchedValue_NeedsUpdate) this.ThawResultsUpdate(); return _PatchedValue_NeedsUpdate; }
216     set { _PatchedValue_NeedsUpdate = value; if (value) this.ThawResultsUpdate(); }
217     }
218     private delegate ListViewItem ThreadSafe_GetResultItem(int index, int lv_type);
219     private ListViewItem GetResultItem(int index, int lv_type)
220     {
221     try
222     {
223     AddressValuePairList lv = null;
224     switch (lv_type)
225     {
226     case (int)eListViewResults.SEARCH_RESULTS_LIST: lv = lstResults; break;
227     case (int)eListViewResults.PATCH_RESULTS_LIST: lv = lstPatchList; break;
228     default: throw new IndexOutOfRangeException("Detected: " + Enum.GetName(typeof(eListViewResults), eListViewResults.UKNOWN_RESULTS_LIST) + " with value: " + lv_type.ToString("x4"));
229     }
230     ListViewItem item = new ListViewItem();
231     item = (ListViewItem)lv.Items[index].Clone();
232     return item;
233     }
234     catch (Exception)
235     {
236     return null;
237     }
238     }
239 william 229 private void radiocompare_equal_CheckedChanged(object sender, EventArgs e)
240     {
241     //if (!radiocompare_between.Checked && !radiocompare_notbetween.Checked)
242     //{
243     if (radio_oldvalue.Checked)
244     {
245     txtStartAddr.ReadOnly = true;
246     txtEndAddr.ReadOnly = true;
247     }
248     if (radio_specificvalue.Checked)
249     {
250     txtStartAddr.ReadOnly = false;
251     txtEndAddr.ReadOnly = true;
252     }
253     //}
254     }
255    
256     private void radiocompare_between_CheckedChanged(object sender, EventArgs e)
257     {
258     if (!radiocompare_equal.Checked &&
259     !radiocompare_greaterthan.Checked &&
260     !radiocompare_greaterthan.Checked &&
261     !radiocompare_lessthan.Checked &&
262     !radiocompare_greaterthan_orequal.Checked &&
263     !radiocompare_lessthan_orequal.Checked &&
264     !radiocompare_notequal.Checked)
265     if (radiocompare_between.Checked)
266     {
267     txtStartAddr.ReadOnly = false;
268     txtEndAddr.ReadOnly = false;
269     return;
270     }
271     if (!radiocompare_between.Checked && !radiocompare_notbetween.Checked)
272     {
273     if (radio_oldvalue.Checked)
274     {
275     txtStartAddr.ReadOnly = true;
276     txtEndAddr.ReadOnly = true;
277     }
278     if (radio_specificvalue.Checked)
279     {
280     txtStartAddr.ReadOnly = false;
281     txtEndAddr.ReadOnly = true;
282     }
283     }
284     }
285    
286     private void radiocompare_notbetween_CheckedChanged(object sender, EventArgs e)
287     {
288     if (!radiocompare_equal.Checked &&
289     !radiocompare_greaterthan.Checked &&
290     !radiocompare_greaterthan.Checked &&
291     !radiocompare_lessthan.Checked &&
292     !radiocompare_greaterthan_orequal.Checked &&
293     !radiocompare_lessthan_orequal.Checked &&
294     !radiocompare_notequal.Checked)
295     if (radiocompare_notbetween.Checked)
296     {
297     txtStartAddr.ReadOnly = false;
298     txtEndAddr.ReadOnly = false;
299     return;
300     }
301     if (!radiocompare_between.Checked && !radiocompare_notbetween.Checked)
302     {
303     if (radio_oldvalue.Checked)
304     {
305     txtStartAddr.ReadOnly = true;
306     txtEndAddr.ReadOnly = true;
307     }
308     if (radio_specificvalue.Checked)
309     {
310     txtStartAddr.ReadOnly = false;
311     txtEndAddr.ReadOnly = true;
312     }
313     }
314     }
315    
316     private void radio_8bits_CheckedChanged(object sender, EventArgs e)
317     {
318     if (chkUnsigned.Checked)
319     {
320     txtStartAddr.CreateTypeSize<byte>();
321     txtEndAddr.CreateTypeSize<byte>();
322     }
323     else
324     {
325     txtStartAddr.CreateTypeSize<sbyte>();
326     txtEndAddr.CreateTypeSize<sbyte>();
327     }
328     }
329    
330     private void radio_16bits_CheckedChanged(object sender, EventArgs e)
331     {
332     if (chkUnsigned.Checked)
333     {
334     txtStartAddr.CreateTypeSize<ushort>();
335     txtEndAddr.CreateTypeSize<ushort>();
336     }
337     else
338     {
339     txtStartAddr.CreateTypeSize<short>();
340     txtEndAddr.CreateTypeSize<short>();
341     }
342     }
343    
344     private void radio_32bits_CheckedChanged(object sender, EventArgs e)
345     {
346    
347     if (chkUnsigned.Checked)
348     {
349     txtStartAddr.CreateTypeSize<uint>();
350     txtEndAddr.CreateTypeSize<uint>();
351     }
352     else
353     {
354     txtStartAddr.CreateTypeSize<int>();
355     txtEndAddr.CreateTypeSize<int>();
356     }
357     }
358    
359     private void radio_64bits_CheckedChanged(object sender, EventArgs e)
360     {
361    
362     if (chkUnsigned.Checked)
363     {
364     txtStartAddr.CreateTypeSize<ulong>();
365     txtEndAddr.CreateTypeSize<ulong>();
366     }
367     else
368     {
369     txtStartAddr.CreateTypeSize<long>();
370     txtEndAddr.CreateTypeSize<long>();
371     }
372     }
373    
374     private void radio_oldvalue_CheckedChanged(object sender, EventArgs e)
375     {
376     if (!radiocompare_between.Checked && !radiocompare_notbetween.Checked)
377     {
378     txtStartAddr.ReadOnly = true;
379     txtEndAddr.ReadOnly = true;
380     }
381     }
382    
383     private void radio_specificvalue_CheckedChanged(object sender, EventArgs e)
384     {
385     if (!radiocompare_between.Checked && !radiocompare_notbetween.Checked)
386     {
387     txtStartAddr.ReadOnly = false;
388     txtEndAddr.ReadOnly = true;
389     }
390     }
391    
392     private void chkRefreshResults_CheckedChanged(object sender, EventArgs e)
393     {
394     if (chkRefreshResults.Checked)
395     {
396     timer_update_results.Enabled = true;
397     }
398     else
399     {
400     timer_update_results.Enabled = false;
401     ResultsUpdateWorkerThread.CancelAsync();
402     }
403     }
404    
405     private void timer_update_results_Tick(object sender, EventArgs e)
406     {
407     if (chkRefreshResults.Checked && !ResultsUpdateWorkerThread.IsBusy)
408     {
409     ResultsUpdateWorkerThread.RunWorkerAsync();
410     }
411     }
412 william 230 private bool ShouldUpdateResults()
413     {
414     if (this.AcceptedProcess == null) return false;
415     if (SearchWorkerThread.IsBusy) return false;
416     //if (JokerSearchWorker.IsBusy) return false;
417     if (this.IsResultsUpdateFrozen) return false;
418     if (mnuAddedResults.Visible) return false;
419     if (mnuResults.Visible) return false;
420     if (Process.GetProcessById(this.AcceptedProcess.Id) == null) return false;
421     if (lstResults.Items.Count > 0) return true;
422     if (lstPatchList.Items.Count > 0) return true;
423     return false;
424     }
425 william 229 private void ResultsUpdateWorkerThread_DoWork(object sender, DoWorkEventArgs e)
426     {
427 william 230 Thread.Sleep(250); // keep thread from blocking
428     if (!this.ShouldUpdateResults()) return;
429     ////if (SearchArgs == null) return;
430     ////if (this.IsResultsUpdateFrozen) return;
431     ////// put thread to sleep for 500ms
432     ////System.Threading.Thread.Sleep(500);
433     //PCSX2MemoryProvider provider = new PCSX2MemoryProvider(this.SearchPCSX2ProcessPID, resultslog);
434     //byte[] buffered_mem = provider.GetMemory();
435     //MemoryStream ms = new MemoryStream(buffered_mem);
436     //BinaryReader r_ms = new BinaryReader(ms);
437 william 229
438 william 230 #region Update Results List
439     ResultItems = new List<ListViewItem>();
440     //r_ms.BaseStream.Seek(0, SeekOrigin.Begin);
441     for (int i = 0; i < lstResults.Items.Count; i++)
442     {
443     if (this.lstResults.InvokeRequired)
444     {
445     ThreadSafe_GetResultItem _get_item = new ThreadSafe_GetResultItem(GetResultItem);
446     object item = this.lstResults.Invoke(_get_item, new object[] { i, (int)eListViewResults.SEARCH_RESULTS_LIST });
447     if (item != null)
448     ResultItems.Add((ListViewItem)item);
449     }
450     else
451     {
452     ResultItems.Add(lstResults.Items[i]);
453     }
454    
455     }
456     for (int i = 0; i < ResultItems.Count; i++)
457     {
458     if (ResultsUpdateWorkerThread.CancellationPending == true)
459     {
460     e.Cancel = true;
461     return;
462     }
463 william 249 int Address = 0;
464 william 230 ResultDataType _result = (ResultDataType)ResultItems[i].Tag;
465    
466 william 249 Address = Convert.ToInt32(ResultItems[i].SubItems[col_Found_Address].Text, 16);
467 william 242 //r_ms.BaseStream.Seek(Address, SeekOrigin.Begin);
468 william 398 using (GenericMemoryProvider provider = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
469 william 230 {
470 william 398 provider.OpenProvider();
471     int bytesReadSize;
472     byte[] data;
473     uint bytesToRead = 0;
474     switch (_result.ValueType)
475     {
476     case SearchDataTypes._8bits:
477     bytesToRead = 1;
478     break;
479     case SearchDataTypes._16bits:
480     bytesToRead = 2;
481     break;
482     case SearchDataTypes._32bits:
483     bytesToRead = 4;
484     break;
485     case SearchDataTypes._64bits:
486     bytesToRead = 8;
487     break;
488     }
489     provider.ReadProcessMemory(Address, bytesToRead, out bytesReadSize, out data);
490     using (MemoryStream ms = new MemoryStream(data))
491     {
492     using (BinaryReader r_ms = new BinaryReader(ms))
493     {
494     switch (_result.ValueType)
495     {
496     case SearchDataTypes._8bits:
497     if (_result.IsUnsigned) { ResultItems[i].SubItems[col_Found_Value].Text = string.Format("0x{0:x2}", r_ms.ReadByte()); }
498     else { ResultItems[i].SubItems[col_Found_Value].Text = string.Format("0x{0:x2}", r_ms.ReadSByte()); }
499     break;
500     case SearchDataTypes._16bits:
501     if (_result.IsUnsigned) { ResultItems[i].SubItems[col_Found_Value].Text = string.Format("0x{0:x4}", r_ms.ReadUInt16()); }
502     else { ResultItems[i].SubItems[col_Found_Value].Text = string.Format("0x{0:x4}", r_ms.ReadInt16()); }
503     break;
504     case SearchDataTypes._32bits:
505     if (_result.IsUnsigned) { ResultItems[i].SubItems[col_Found_Value].Text = string.Format("0x{0:x8}", r_ms.ReadUInt32()); }
506     else { ResultItems[i].SubItems[col_Found_Value].Text = string.Format("0x{0:x8}", r_ms.ReadInt32()); }
507     break;
508     case SearchDataTypes._64bits:
509     if (_result.IsUnsigned) { ResultItems[i].SubItems[col_Found_Value].Text = string.Format("0x{0:x16}", r_ms.ReadUInt64()); }
510     else { ResultItems[i].SubItems[col_Found_Value].Text = string.Format("0x{0:x16}", r_ms.ReadInt64()); }
511     break;
512     }
513     r_ms.Close();
514     }
515     }
516 william 424 provider.CloseProvider();
517 william 230 }
518 william 398 //Application.DoEvents();
519 william 230 }
520     #endregion
521    
522     #region Update Added Results List
523     AddedItems = new List<ListViewItem>();
524     //r_ms.BaseStream.Seek(0, SeekOrigin.Begin);
525     for (int i = 0; i < lstPatchList.Items.Count; i++)
526     {
527     if (this.lstResults.InvokeRequired)
528     {
529     ThreadSafe_GetResultItem _get_item = new ThreadSafe_GetResultItem(GetResultItem);
530     object item = this.lstResults.Invoke(_get_item, new object[] { i, (int)eListViewResults.PATCH_RESULTS_LIST });
531     if (item != null)
532     AddedItems.Add((ListViewItem)item);
533     }
534     else
535     {
536     AddedItems.Add(lstPatchList.Items[i]);
537     }
538    
539     }
540     for (int i = 0; i < AddedItems.Count; i++)
541     {
542     if (ResultsUpdateWorkerThread.CancellationPending == true)
543     {
544     e.Cancel = true;
545     return;
546     }
547 william 249 int Address = 0;
548 william 230 ResultDataType _result = (ResultDataType)AddedItems[i].Tag;
549 william 249 Address = Convert.ToInt32(AddedItems[i].SubItems[col_Added_Address].Text, 16);
550 william 398 using (GenericMemoryProvider provider = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
551 william 230 {
552 william 398 provider.OpenProvider();
553     int bytesReadSize;
554     byte[] data;
555     uint bytesToRead = 0;
556     switch (_result.ValueType)
557     {
558     case SearchDataTypes._8bits:
559     bytesToRead = 1;
560     break;
561     case SearchDataTypes._16bits:
562     bytesToRead = 2;
563     break;
564     case SearchDataTypes._32bits:
565     bytesToRead = 4;
566     break;
567     case SearchDataTypes._64bits:
568     bytesToRead = 8;
569     break;
570     }
571     provider.ReadProcessMemory(Address, bytesToRead, out bytesReadSize, out data);
572 william 424 provider.CloseProvider();
573 william 398 using (MemoryStream ms = new MemoryStream(data))
574     {
575     using (BinaryReader r_ms = new BinaryReader(ms))
576     {
577     switch (_result.ValueType)
578     {
579     case SearchDataTypes._8bits:
580     if (_result.IsUnsigned) { AddedItems[i].SubItems[col_Added_Value].Text = string.Format("0x{0:x2}", r_ms.ReadByte()); }
581     else { AddedItems[i].SubItems[col_Added_Value].Text = string.Format("0x{0:x2}", r_ms.ReadSByte()); }
582     break;
583     case SearchDataTypes._16bits:
584     if (_result.IsUnsigned) { AddedItems[i].SubItems[col_Added_Value].Text = string.Format("0x{0:x4}", r_ms.ReadUInt16()); }
585     else { AddedItems[i].SubItems[col_Added_Value].Text = string.Format("0x{0:x4}", r_ms.ReadInt16()); }
586     break;
587     case SearchDataTypes._32bits:
588     if (_result.IsUnsigned) { AddedItems[i].SubItems[col_Added_Value].Text = string.Format("0x{0:x8}", r_ms.ReadUInt32()); }
589     else { AddedItems[i].SubItems[col_Added_Value].Text = string.Format("0x{0:x8}", r_ms.ReadInt32()); }
590     break;
591     case SearchDataTypes._64bits:
592     if (_result.IsUnsigned) { AddedItems[i].SubItems[col_Added_Value].Text = string.Format("0x{0:x16}", r_ms.ReadUInt64()); }
593     else { AddedItems[i].SubItems[col_Added_Value].Text = string.Format("0x{0:x16}", r_ms.ReadInt64()); }
594     break;
595     }
596     r_ms.Close();
597     }
598     }
599 william 230 }
600 william 398 //Application.DoEvents();
601 william 230 }
602     #endregion
603    
604    
605 william 229 }
606    
607     private void ResultsUpdateWorkerThread_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
608     {
609 william 230 try
610     {
611     //if ((lstResults.SelectedItems.Count > 0) && !PatchedValue_NeedsUpdate ) return;
612     //if ((lstPatchList.SelectedItems.Count > 0) && !PatchedValue_NeedsUpdate) return;
613     if (!this.ShouldUpdateResults()) return;
614     if (ResultItems.Count > 0)
615     {
616     //lstResults.Items.Clear();
617     //lstResults.Items.AddRange(ResultItems.ToArray());
618 william 229
619 william 230 for (int i = 0; i < ResultItems.Count; i++)
620     {
621     lstResults.Items[i].SubItems[new AVPColumnText(AVPColumnType.VALUE).ColumnIndex].Text =
622     ResultItems[i].SubItems[new AVPColumnText(AVPColumnType.VALUE).ColumnIndex].Text;
623     }
624    
625     }
626     if (AddedItems.Count > 0)
627     {
628     //lstPatchList.Items.Clear();
629     //lstPatchList.Items.AddRange(AddedItems.ToArray());
630    
631     for (int i = 0; i < AddedItems.Count; i++)
632     {
633     lstPatchList.Items[i].SubItems[new AVPColumnText(AVPColumnType.VALUE).ColumnIndex].Text =
634     AddedItems[i].SubItems[new AVPColumnText(AVPColumnType.VALUE).ColumnIndex].Text;
635     }
636    
637     }
638     PatchedValue_NeedsUpdate = false;
639     }
640     catch { }
641 william 229 }
642    
643     private void btnImportFile_Click(object sender, EventArgs e)
644     {
645     this.FreezeResultsUpdate();
646     if (!lstPatchList.ImportFromFile())
647     {
648     MessageBox.Show("Failed to Import Patch List from File.", "Import Failure", MessageBoxButtons.OK, MessageBoxIcon.Error);
649     this.ThawResultsUpdate();
650     return;
651     }
652     else
653     {
654     MessageBox.Show("Succesfully Imported Patch List from File.", "Import Success", MessageBoxButtons.OK, MessageBoxIcon.Information);
655     this.ThawResultsUpdate();
656     return;
657     }
658     }
659     bool g_isFrozen = false;
660     private bool IsResultsUpdateFrozen
661     {
662     get { return g_isFrozen; }
663     set { g_isFrozen = value; }
664     }
665     private void ThawResultsUpdate()
666     {
667     this.IsResultsUpdateFrozen = false;
668     if (this.AcceptedProcess != null)
669     {
670     #if !DO_NOT_SUSPEND_RESUME_THREAD_ON_FREEZE
671     ThreadControl.ResumeProcess(this.AcceptedProcess.Id);
672     #endif
673     }
674     }
675    
676     private void FreezeResultsUpdate()
677     {
678     this.IsResultsUpdateFrozen = true;
679 william 285 //this.IsResultsUpdateFrozen = false;
680 william 229 if (this.AcceptedProcess != null)
681     {
682     #if !DO_NOT_SUSPEND_RESUME_THREAD_ON_FREEZE
683     ThreadControl.SuspendProcess(this.AcceptedProcess.Id);
684     #endif
685     }
686     }
687    
688     private void btnExportFile_Click(object sender, EventArgs e)
689     {
690     this.FreezeResultsUpdate();
691     if (!lstPatchList.ExportToFile())
692     {
693     MessageBox.Show("Failed to Export Patch List to File.", "Export Failure", MessageBoxButtons.OK, MessageBoxIcon.Error);
694     this.ThawResultsUpdate();
695     return;
696     }
697     else
698     {
699     MessageBox.Show("Succesfully Exported Patch List to File.", "Export Success", MessageBoxButtons.OK, MessageBoxIcon.Information);
700     this.ThawResultsUpdate();
701     return;
702     }
703     }
704    
705     private void btnImportClipboard_Click(object sender, EventArgs e)
706     {
707     this.FreezeResultsUpdate();
708     if (!lstPatchList.ImportFromClipboard())
709     {
710     MessageBox.Show("Failed to Import Patch List from Clipboard.", "Import Failure", MessageBoxButtons.OK, MessageBoxIcon.Error);
711     this.ThawResultsUpdate();
712     return;
713     }
714     else
715     {
716     MessageBox.Show("Succesfully Import Patch List from Clipboard.", "Import Success", MessageBoxButtons.OK, MessageBoxIcon.Information);
717     this.ThawResultsUpdate();
718     }
719     }
720    
721     private void btnExportClipboard_Click(object sender, EventArgs e)
722     {
723     this.FreezeResultsUpdate();
724     if (!lstPatchList.ExportToClipboard())
725     {
726     MessageBox.Show("Failed to Export Patch List to Clipboard.", "Export Failure", MessageBoxButtons.OK, MessageBoxIcon.Error);
727     this.ThawResultsUpdate();
728     return;
729     }
730     else
731     {
732     MessageBox.Show("Succesfully Exported Patch List to Clipboard.", "Export Success", MessageBoxButtons.OK, MessageBoxIcon.Information);
733     this.ThawResultsUpdate();
734     return;
735     }
736     }
737    
738     private void btnAddPatchAddress_Click(object sender, EventArgs e)
739     {
740 william 245 PatchAdder adder = new PatchAdder((IAcceptsProcessAndConfig)this);
741 william 229 adder.ShowDialog();
742     if (adder.WasAPatchAdded) AddToPatchList(adder.AddedPatchValue);
743     }
744    
745     private void btnAddAddressRange_Click(object sender, EventArgs e)
746     {
747 william 245 PatchRangeAdder adder = new PatchRangeAdder((IAcceptsProcessAndConfig)this);
748 william 229 adder.ShowDialog();
749     if (adder.WasAPatchAdded) AddToPatchList(adder.AddedPatchValue);
750     }
751     private void AddToPatchList(List<ResultDataType> item) { foreach (ResultDataType data in item) { AddToPatchList(data); } }
752     private void AddToPatchList(ResultDataType item)
753     {
754     ResultItem item2 = null;
755     switch (item.ValueType)
756     {
757     case SearchDataTypes._8bits:
758     if (item.IsUnsigned) { item2 = new ResultItem(item.Address, item.IsFrozen, Convert.ToByte(item.Value)); }
759     else { item2 = new ResultItem(item.Address, item.IsFrozen, Convert.ToSByte(item.Value)); }
760     break;
761     case SearchDataTypes._16bits:
762     if (item.IsUnsigned) { item2 = new ResultItem(item.Address, item.IsFrozen, Convert.ToUInt16(item.Value)); }
763     else { item2 = new ResultItem(item.Address, item.IsFrozen, Convert.ToInt16(item.Value)); }
764     break;
765     case SearchDataTypes._32bits:
766     if (item.IsUnsigned) { item2 = new ResultItem(item.Address, item.IsFrozen, Convert.ToUInt32(item.Value)); }
767     else { item2 = new ResultItem(item.Address, item.IsFrozen, Convert.ToInt32(item.Value)); }
768     break;
769     case SearchDataTypes._64bits:
770     if (item.IsUnsigned) { item2 = new ResultItem(item.Address, item.IsFrozen, Convert.ToUInt64(item.Value)); }
771     else { item2 = new ResultItem(item.Address, item.IsFrozen, Convert.ToInt64(item.Value)); }
772     break;
773     }
774     this.AddToPatchList(item2);
775     }
776     private void AddToPatchList(ListViewItem item)
777     {
778     try
779     {
780     ResultDataType _result = (ResultDataType)item.Tag;
781     this.AddToPatchList(_result);
782     }
783     catch (InvalidCastException ex)
784     {
785     // unable to cast
786     MessageBox.Show(ex.Message, "Invalid Cast Exception", MessageBoxButtons.OK, MessageBoxIcon.Error);
787     }
788     catch (Exception ex)
789     {
790     // other exception
791     MessageBox.Show(ex.Message, "Unhandled Exception", MessageBoxButtons.OK, MessageBoxIcon.Error);
792     }
793     }
794     private void AddToPatchList(ResultItem item)
795     {
796     if (!lstPatchList.Items.Contains(item)) lstPatchList.Items.Add(item);
797     }
798     private void AddToPatchList(string address, SearchDataTypes bitsize, bool IsUnsigned)
799     {
800 william 245 ResultItemState state = new ResultItemState(address, bitsize, IsUnsigned, (IAcceptsProcessAndConfig)this);
801 william 229 ResultItem item = new ResultItem(state.Address, state.Value, state.Frozen, state.ValueType, state.IsUnsigned);
802     this.AddToPatchList(item);
803     }
804 william 230
805     private void mnuItemAddToPatchList_Click(object sender, EventArgs e)
806     {
807     if (!(lstResults.SelectedItems.Count > 0)) return;
808     //if (SearchArgs == null) return;
809    
810     try
811     {
812     for (int i = 0; i < lstResults.SelectedIndices.Count; i++)
813     {
814     //ResultDataType result = (ResultDataType)lstResults.Items[selected_index].Tag;
815     ListViewItem item = lstResults.Items[lstResults.SelectedIndices[i]];
816     this.AddToPatchList(item);
817     }
818     }
819     catch (Exception ex)
820     {
821     logger.Error.WriteLine(ex.ToString());
822     }
823     }
824    
825     private void mnuItemRemoveResult_Click(object sender, EventArgs e)
826     {
827     if (!(lstPatchList.SelectedItems.Count > 0)) return;
828     //if (SearchArgs == null) return;
829     try
830     {
831     this.FreezeResultsUpdate();
832     for (int i = 0; i < lstPatchList.SelectedIndices.Count; i++)
833     {
834     //lstPatchList.ThawItem(lstPatchList.SelectedIndices[i]);
835     lstPatchList.Items[lstPatchList.SelectedIndices[i]].Remove();
836     }
837     this.ThawResultsUpdate();
838     }
839     catch (Exception ex)
840     {
841     Debug.WriteLine(ex.ToString());
842     }
843     }
844     private void PatchRange(bool SingleEntry)
845     {
846     //if (SearchArgs == null) return;
847     #region Patch Selected Address
848     // stop ResultsUpdate Thread
849     ResultsUpdateWorkerThread.CancelAsync();
850    
851     List<ResultDataType> patch_list = new List<ResultDataType>();
852     List<int> SelectedIndexes = new List<int>();
853    
854     if (SingleEntry)
855     {
856     SelectedIndexes.Add(lstPatchList.SelectedIndices[0]);
857     }
858     else
859     {
860     foreach (int index in lstPatchList.SelectedIndices)
861     {
862     SelectedIndexes.Add(index);
863     }
864     }
865     //PCSX2MemoryProvider provider = new PCSX2MemoryProvider(this.SearchPCSX2ProcessPID, resultslog);
866     foreach (int index in SelectedIndexes)
867     {
868     if (SingleEntry)
869     {
870     SearchPatcher patcher = null;
871     uint Address = 0;
872     ListViewItem item = lstPatchList.Items[index];
873     ResultDataType _result = (ResultDataType)item.Tag;
874     Address = Convert.ToUInt32(item.SubItems[col_Found_Address].Text, 16);
875     switch (_result.ValueType)
876     {
877     case SearchDataTypes._8bits:
878     if (_result.IsUnsigned)
879     {
880     byte value = Convert.ToByte(item.SubItems[col_Found_Value].Text, 16);
881 william 243 patcher = new SearchPatcher((IAcceptsProcessAndConfig)this, Address, value);
882 william 230 timer_update_results.Enabled = false;
883     patcher.ShowDialog();
884     timer_update_results.Enabled = true;
885     PatchedValue_NeedsUpdate = true;
886     if (!chkRefreshResults.Checked && !ResultsUpdateWorkerThread.IsBusy)
887     ResultsUpdateWorkerThread.RunWorkerAsync();
888     }
889     else
890     {
891     sbyte value = Convert.ToSByte(item.SubItems[col_Found_Value].Text, 16);
892 william 243 patcher = new SearchPatcher((IAcceptsProcessAndConfig)this, Address, value);
893 william 230 timer_update_results.Enabled = false;
894     patcher.ShowDialog();
895     timer_update_results.Enabled = true;
896     PatchedValue_NeedsUpdate = true;
897     if (!chkRefreshResults.Checked && !ResultsUpdateWorkerThread.IsBusy)
898     ResultsUpdateWorkerThread.RunWorkerAsync();
899     }
900     break;
901     case SearchDataTypes._16bits:
902     if (_result.IsUnsigned)
903     {
904     ushort value = Convert.ToUInt16(item.SubItems[col_Found_Value].Text, 16);
905 william 243 patcher = new SearchPatcher((IAcceptsProcessAndConfig)this, Address, value);
906 william 230 timer_update_results.Enabled = false;
907     patcher.ShowDialog();
908     timer_update_results.Enabled = true;
909     PatchedValue_NeedsUpdate = true;
910     if (!chkRefreshResults.Checked && !ResultsUpdateWorkerThread.IsBusy)
911     ResultsUpdateWorkerThread.RunWorkerAsync();
912     }
913     else
914     {
915     short value = Convert.ToInt16(item.SubItems[col_Found_Value].Text, 16);
916 william 243 patcher = new SearchPatcher((IAcceptsProcessAndConfig)this, Address, value);
917 william 230 timer_update_results.Enabled = false;
918     patcher.ShowDialog();
919     timer_update_results.Enabled = true;
920     PatchedValue_NeedsUpdate = true;
921     if (!chkRefreshResults.Checked && !ResultsUpdateWorkerThread.IsBusy)
922     ResultsUpdateWorkerThread.RunWorkerAsync();
923     }
924     break;
925     case SearchDataTypes._32bits:
926     if (_result.IsUnsigned)
927     {
928     uint value = Convert.ToUInt32(item.SubItems[col_Found_Value].Text, 16);
929 william 243 patcher = new SearchPatcher((IAcceptsProcessAndConfig)this, Address, value);
930 william 230 timer_update_results.Enabled = false;
931     patcher.ShowDialog();
932     timer_update_results.Enabled = true;
933     PatchedValue_NeedsUpdate = true;
934     if (!chkRefreshResults.Checked && !ResultsUpdateWorkerThread.IsBusy)
935     ResultsUpdateWorkerThread.RunWorkerAsync();
936     }
937     else
938     {
939     int value = Convert.ToInt32(item.SubItems[col_Found_Value].Text, 16);
940 william 243 patcher = new SearchPatcher((IAcceptsProcessAndConfig)this, Address, value);
941 william 230 timer_update_results.Enabled = false;
942     patcher.ShowDialog();
943     timer_update_results.Enabled = true;
944     PatchedValue_NeedsUpdate = true;
945     if (!chkRefreshResults.Checked && !ResultsUpdateWorkerThread.IsBusy)
946     ResultsUpdateWorkerThread.RunWorkerAsync();
947     }
948     break;
949     case SearchDataTypes._64bits:
950     if (_result.IsUnsigned)
951     {
952     ulong value = Convert.ToUInt32(item.SubItems[col_Found_Value].Text, 16);
953 william 243 patcher = new SearchPatcher((IAcceptsProcessAndConfig)this, Address, value);
954 william 230 timer_update_results.Enabled = false;
955     patcher.ShowDialog();
956     timer_update_results.Enabled = true;
957     PatchedValue_NeedsUpdate = true;
958     if (!chkRefreshResults.Checked && !ResultsUpdateWorkerThread.IsBusy)
959     ResultsUpdateWorkerThread.RunWorkerAsync();
960     }
961     else
962     {
963     long value = Convert.ToInt32(item.SubItems[col_Found_Value].Text, 16);
964 william 243 patcher = new SearchPatcher((IAcceptsProcessAndConfig)this, Address, value);
965 william 230 timer_update_results.Enabled = false;
966     patcher.ShowDialog();
967     timer_update_results.Enabled = true;
968     PatchedValue_NeedsUpdate = true;
969     if (!chkRefreshResults.Checked && !ResultsUpdateWorkerThread.IsBusy)
970     ResultsUpdateWorkerThread.RunWorkerAsync();
971     }
972     break;
973     }
974     }
975     else
976     {
977    
978     ListViewItem item = lstPatchList.Items[index];
979     ResultDataType _result = (ResultDataType)item.Tag;
980     patch_list.Add(_result);
981     }
982     }
983    
984     if (patch_list.Count > 0)
985     {
986 william 243 SearchRangePatcher rangePatcher = new SearchRangePatcher((IAcceptsProcessAndConfig)this, patch_list);
987 william 230 rangePatcher.ShowDialog();
988     }
989    
990     #endregion
991     }
992     private void mnuItemPatchSelectedEntry_Click(object sender, EventArgs e)
993     {
994     if (!(lstPatchList.SelectedItems.Count == 1)) return;
995     PatchRange(true);
996     }
997    
998     private void mnuItemPatchSelectedRange_Click(object sender, EventArgs e)
999     {
1000     if (!(lstPatchList.SelectedItems.Count >= 1)) return;
1001     PatchRange(false);
1002     }
1003    
1004     private void mnuItemFreezeSelectedPatches_Click(object sender, EventArgs e)
1005     {
1006     if (!(lstPatchList.SelectedItems.Count > 0)) return;
1007     //if (SearchArgs == null) return;
1008     try
1009     {
1010     lstPatchList.ProcessID = this.AcceptedProcess.Id;
1011     this.FreezeResultsUpdate();
1012     for (int i = 0; i < lstPatchList.SelectedIndices.Count; i++)
1013     {
1014     lstPatchList.FreezeItem(lstPatchList.SelectedIndices[i]);
1015     }
1016     // force thaw and update
1017     this.ThawResultsUpdate();
1018     this.Update();
1019     }
1020     catch (Exception ex)
1021     {
1022     Debug.WriteLine(ex.ToString());
1023     }
1024     }
1025    
1026     private void mnuItemThawSelectedPatches_Click(object sender, EventArgs e)
1027     {
1028     if (!(lstPatchList.SelectedItems.Count > 0)) return;
1029     //if (SearchArgs == null) return;
1030     try
1031     {
1032     lstPatchList.ProcessID = this.AcceptedProcess.Id;
1033     this.FreezeResultsUpdate();
1034     for (int i = 0; i < lstPatchList.SelectedIndices.Count; i++)
1035     {
1036     lstPatchList.ThawItem(lstPatchList.SelectedIndices[i]);
1037     }
1038     // force thaw and update
1039     this.ThawResultsUpdate();
1040     this.Update();
1041     }
1042     catch (Exception ex)
1043     {
1044     Debug.WriteLine(ex.ToString());
1045     }
1046     }
1047 william 408 private void search_provider_OnBytesRead(OnBytesReadEventArgs e)
1048     {
1049 william 446 if (SearchWorkerThread.CancellationPending) { e.Canceled = true; return; }
1050 william 408 SearchDataTypes sdt = SearchArgs.DataType;
1051     bool unsigned = SearchArgs.IsUnsignedDataType;
1052     int Last_Whole_Percent_Done = 0;
1053     uint CurrentIndex = e.CurrentIndex;
1054     if (e.UserState != null)
1055     {
1056     SearchResultWriter writer = (e.UserState as SearchResultWriter);
1057     if (writer == null)
1058     throw new InvalidOperationException("writer cannot be null");
1059     using (MemoryStream ms = new MemoryStream(e.Data))
1060     {
1061     using (BinaryReader br = new BinaryReader(ms))
1062     {
1063     while (br.BaseStream.Position < br.BaseStream.Length)
1064     {
1065     try
1066     {
1067     switch (sdt)
1068     {
1069     case SearchDataTypes._8bits:
1070 william 454 if (unsigned)
1071     {
1072     #region 8bits - unsigned
1073     var Value = br.ReadByte();
1074     using (_8bit_unsigned_comparer_ comparer = new _8bit_unsigned_comparer_(SearchArgs, CurrentIndex))
1075     {
1076     byte value = 0;
1077     if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1078     {
1079     using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1080     {
1081     try
1082     {
1083     gmp.OpenProvider();
1084     gmp.ReadMemory(CurrentIndex, out value);
1085     gmp.CloseProvider();
1086     }
1087     catch (Exception ex)
1088     {
1089     logger.VerboseError.WriteLine(ex.ToString());
1090     }
1091     }
1092     comparer.Value = value;
1093     }
1094     else
1095     {
1096     value = Convert.ToByte(SearchArgs.CompareStartValue);
1097     comparer.Value = value;
1098     }
1099     if (comparer.Compare(Convert.ToByte(Value), value))
1100     {
1101     writer.WriteResult<byte>(comparer.Address, comparer.Value);
1102     }
1103     }
1104     #endregion
1105     }
1106     else
1107     {
1108     #region 8bits - signed
1109     var Value = br.ReadSByte();
1110     using (_8bit_signed_comparer_ comparer = new _8bit_signed_comparer_(SearchArgs, CurrentIndex))
1111     {
1112     sbyte value = 0;
1113     if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1114     {
1115     using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1116     {
1117     try
1118     {
1119     gmp.OpenProvider();
1120     gmp.ReadMemory(CurrentIndex, out value);
1121     gmp.CloseProvider();
1122     }
1123     catch (Exception ex)
1124     {
1125     logger.VerboseError.WriteLine(ex.ToString());
1126     }
1127     }
1128     comparer.Value = value;
1129     }
1130     else
1131     {
1132     value = Convert.ToSByte(SearchArgs.CompareStartValue);
1133     comparer.Value = value;
1134     }
1135     if (comparer.Compare(Convert.ToSByte(Value), value))
1136     {
1137     writer.WriteResult<sbyte>(comparer.Address, comparer.Value);
1138     }
1139     }
1140     #endregion
1141     } break;
1142 william 408 case SearchDataTypes._16bits:
1143 william 454 if (unsigned)
1144     {
1145     #region 16bits - unsigned
1146     var Value = br.ReadUInt16();
1147     using (_16bit_unsigned_comparer_ comparer = new _16bit_unsigned_comparer_(SearchArgs, CurrentIndex))
1148     {
1149     ushort value = 0;
1150     if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1151     {
1152     using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1153     {
1154     try
1155     {
1156     gmp.OpenProvider();
1157     gmp.ReadMemory(CurrentIndex, out value);
1158     gmp.CloseProvider();
1159     }
1160     catch (Exception ex)
1161     {
1162     logger.VerboseError.WriteLine(ex.ToString());
1163     }
1164     }
1165     comparer.Value = value;
1166     }
1167     else
1168     {
1169     value = Convert.ToUInt16(SearchArgs.CompareStartValue);
1170     comparer.Value = value;
1171     }
1172     if (comparer.Compare(Convert.ToUInt16(Value), value))
1173     {
1174     writer.WriteResult<ushort>(comparer.Address, comparer.Value);
1175     }
1176     }
1177     #endregion
1178     writer.WriteResult<ushort>(CurrentIndex, br.ReadUInt16());
1179     }
1180     else
1181     {
1182     #region 16bits - signed
1183     var Value = br.ReadInt16();
1184     using (_16bit_signed_comparer_ comparer = new _16bit_signed_comparer_(SearchArgs, CurrentIndex))
1185     {
1186     short value = 0;
1187     if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1188     {
1189     using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1190     {
1191     try
1192     {
1193     gmp.OpenProvider();
1194     gmp.ReadMemory(CurrentIndex, out value);
1195     gmp.CloseProvider();
1196     }
1197     catch (Exception ex)
1198     {
1199     logger.VerboseError.WriteLine(ex.ToString());
1200     }
1201     }
1202     comparer.Value = value;
1203     }
1204     else
1205     {
1206     value = Convert.ToInt16(SearchArgs.CompareStartValue);
1207     comparer.Value = value;
1208     }
1209     if (comparer.Compare(Convert.ToSByte(Value), value))
1210     {
1211     writer.WriteResult<short>(comparer.Address, comparer.Value);
1212     }
1213     }
1214     #endregion
1215     } break;
1216 william 408 case SearchDataTypes._32bits:
1217 william 454 if (unsigned)
1218     {
1219     #region 32bits - unsigned
1220     var Value = br.ReadUInt32();
1221     using (_32bit_unsigned_comparer_ comparer = new _32bit_unsigned_comparer_(SearchArgs, CurrentIndex))
1222     {
1223     uint value = 0;
1224     if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1225     {
1226     using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1227     {
1228     try
1229     {
1230     gmp.OpenProvider();
1231     gmp.ReadMemory(CurrentIndex, out value);
1232     gmp.CloseProvider();
1233     }
1234     catch (Exception ex)
1235     {
1236     logger.VerboseError.WriteLine(ex.ToString());
1237     }
1238     }
1239     comparer.Value = value;
1240     }
1241     else
1242     {
1243     value = Convert.ToUInt32(SearchArgs.CompareStartValue);
1244     comparer.Value = value;
1245     }
1246     if (comparer.Compare(Convert.ToUInt32(Value), value))
1247     {
1248     writer.WriteResult<uint>(comparer.Address, comparer.Value);
1249     }
1250     }
1251     #endregion
1252     }
1253     else
1254     {
1255     #region 32bits - signed
1256     var Value = br.ReadInt32();
1257     using (_32bit_signed_comparer_ comparer = new _32bit_signed_comparer_(SearchArgs, CurrentIndex))
1258     {
1259     int value = 0;
1260     if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1261     {
1262     using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1263     {
1264     try
1265     {
1266     gmp.OpenProvider();
1267     gmp.ReadMemory(CurrentIndex, out value);
1268     gmp.CloseProvider();
1269     }
1270     catch (Exception ex)
1271     {
1272     logger.VerboseError.WriteLine(ex.ToString());
1273     }
1274     }
1275     comparer.Value = value;
1276     }
1277     else
1278     {
1279     value = Convert.ToInt32(SearchArgs.CompareStartValue);
1280     comparer.Value = value;
1281     }
1282     if (comparer.Compare(Convert.ToInt32(Value), value))
1283     {
1284     writer.WriteResult<int>(comparer.Address, comparer.Value);
1285     }
1286     }
1287     #endregion
1288     } break;
1289 william 408 case SearchDataTypes._64bits:
1290 william 454 if (unsigned)
1291     {
1292     #region 64bits - unsigned
1293     var Value = br.ReadUInt64();
1294     using (_64bit_unsigned_comparer_ comparer = new _64bit_unsigned_comparer_(SearchArgs, CurrentIndex))
1295     {
1296     ulong value = 0;
1297     if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1298     {
1299     using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1300     {
1301     try
1302     {
1303     gmp.OpenProvider();
1304     gmp.ReadMemory(CurrentIndex, out value);
1305     gmp.CloseProvider();
1306     }
1307     catch (Exception ex)
1308     {
1309     logger.VerboseError.WriteLine(ex.ToString());
1310     }
1311     }
1312     comparer.Value = value;
1313     }
1314     else
1315     {
1316     value = Convert.ToUInt64(SearchArgs.CompareStartValue);
1317     comparer.Value = value;
1318     }
1319     if (comparer.Compare(Convert.ToUInt64(Value), value))
1320     {
1321     writer.WriteResult<ulong>(comparer.Address, comparer.Value);
1322     }
1323     }
1324     #endregion
1325     }
1326     else
1327     {
1328     #region 64bits - signed
1329     var Value = br.ReadInt64();
1330     using (_64bit_signed_comparer_ comparer = new _64bit_signed_comparer_(SearchArgs, CurrentIndex))
1331     {
1332     long value = 0;
1333     if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1334     {
1335     using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1336     {
1337     try
1338     {
1339     gmp.OpenProvider();
1340     gmp.ReadMemory(CurrentIndex, out value);
1341     gmp.CloseProvider();
1342     }
1343     catch (Exception ex)
1344     {
1345     logger.VerboseError.WriteLine(ex.ToString());
1346     }
1347     }
1348     comparer.Value = value;
1349     }
1350     else
1351     {
1352     value = Convert.ToInt64(SearchArgs.CompareStartValue);
1353     comparer.Value = value;
1354     }
1355     if (comparer.Compare(Convert.ToInt64(Value), value))
1356     {
1357     writer.WriteResult<long>(comparer.Address, comparer.Value);
1358     }
1359     }
1360     #endregion
1361     } break;
1362 william 408 }
1363 william 446 if (SearchWorkerThread.CancellationPending) { e.Canceled = true; return; }
1364 william 408 }
1365     catch (EndOfStreamException) { }
1366     double double_percent_done = 100.0 * (double)((double)CurrentIndex / (double)e.TotalCount);
1367     int int_percent_done = (int)double_percent_done;
1368 william 456 if (int_percent_done != Last_Whole_Percent_Done && CurrentIndex % 100000 == 0)
1369 william 408 {
1370     if (int_percent_done <= 100)
1371     {
1372     resultsprogress.Value = int_percent_done;
1373     resultsprogress.Message = string.Format(" -> Reading Address: 0x{0:x8}", (CurrentIndex + MemoryRangeStart));
1374     Last_Whole_Percent_Done = int_percent_done;
1375     }
1376 william 446 if (SearchWorkerThread.CancellationPending) { e.Canceled = true; return; }
1377 william 408 }
1378 william 413 switch (sdt)
1379     {
1380     case SearchDataTypes._8bits:
1381     CurrentIndex += sizeof(byte);
1382     break;
1383     case SearchDataTypes._16bits:
1384     CurrentIndex += sizeof(ushort);
1385     break;
1386     case SearchDataTypes._32bits:
1387     CurrentIndex += sizeof(uint);
1388     break;
1389     case SearchDataTypes._64bits:
1390     CurrentIndex += sizeof(ulong);
1391     break;
1392     }
1393 william 408 }
1394    
1395     }
1396     }
1397     }
1398 william 446 if (SearchWorkerThread.CancellationPending) { e.Canceled = true; return; }
1399 william 408 }
1400 william 230 private void SearchWorkerThread_DoWork(object sender, DoWorkEventArgs e)
1401     {
1402 william 410 try
1403 william 445 {
1404 william 410 Stopwatch st = new Stopwatch();
1405     st.Start();
1406 william 392
1407 william 410 Stopwatch st_first_search = new Stopwatch();
1408     Stopwatch st_nonrange_search = new Stopwatch();
1409     Stopwatch st_ranged_search = new Stopwatch();
1410 william 392
1411 william 410 e.Result = st;
1412     //List<ResultType<object>> tmp_Results = new List<ResultType<object>>();
1413     List<ResultType<object>> second_tmp_Results = new List<ResultType<object>>();
1414     //const int ElementsBeforeDisplay = 100;
1415     SearchArgs.LogSearchOptions();
1416     uint STEP_SIZE = (uint)SearchArgs.DataType / 8;
1417 william 399
1418 william 410 bool unsigned = SearchArgs.IsUnsignedDataType;
1419     SearchDataTypes sdt = SearchArgs.DataType;
1420     //byte[] buffered_mem = new byte[(MemoryRangeSize - MemoryRangeStart)]; // throws OutOfMemoryException if size is over 2G
1421     logger.Debug.WriteLine(string.Format("Buffered Memory Size -> 0x{0:x8}", MemoryRangeSize - MemoryRangeStart));
1422     resultsprogress.Value = 0;
1423     resultsprogress.Message = string.Format("Search is Warming Up...Please Wait...");
1424 william 408
1425 william 410 Stopwatch provider_st = new Stopwatch();
1426     provider_st.Start();
1427     using (GenericMemoryProvider provider = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1428     {
1429     provider.OpenProvider();
1430 william 429 int count = (int)((MemoryRangeSize - MemoryRangeStart) / STEP_SIZE);
1431 william 444 SearchResultWriter writer = new SearchResultWriter((int)(count), SearchGuid);
1432 william 410 provider.OnBytesRead += new BaseEventHandler<OnBytesReadEventArgs>(search_provider_OnBytesRead);
1433 william 459 if (SearchArgs.IsFirstSearch)
1434     {
1435     provider.ReadProcessMemoryAtOnce(MemoryRangeStart, (MemoryRangeSize - MemoryRangeStart), writer);
1436     }
1437     else
1438     {
1439     // need to get the address list
1440     using (SearchResultReader reader = new SearchResultReader(SearchGuid))
1441     {
1442     var addresses = reader.GetResultAddresses(SearchArgs, (IAcceptsProcessAndConfig)this, resultsprogress);
1443     foreach (var address in addresses)
1444     {
1445     provider.ReadProcessMemoryAtOnce(address, STEP_SIZE, writer);
1446     }
1447     }
1448     }
1449 william 424 provider.CloseProvider();
1450 william 457 if (SearchWorkerThread.CancellationPending)
1451     {
1452 william 459 provider_st.Stop();
1453 william 457 st.Stop();
1454     writer.CancelRequest();
1455     writer.Dispose();
1456     writer = null;
1457     e.Result = true;
1458     return;
1459     }
1460 william 410 writer.Dispose();
1461 william 457 writer = null;
1462 william 410 }
1463     provider_st.Stop();
1464     logger.Profiler.WriteLine("It took a total of {0} seconds for the memory provider to complete it's operation(s).", provider_st.Elapsed.TotalSeconds);
1465     //if (buffered_mem.Length == 0) { logger.Warn.WriteLine("Buffered Memory is Zero Length."); return; }
1466 william 456 //int Last_Whole_Percent_Done = 0;
1467 william 408
1468    
1469 william 410 #region Subsequent Searches
1470     //r_ms.BaseStream.Seek(0, SeekOrigin.Begin);
1471 william 408
1472    
1473 william 410 // hack to help with OutOfMemory Exceptions (OldValue and Equal compare will always add all found search results)
1474     bool NeedToCompare = true;
1475     if (SearchArgs.CompareValueType == CompareValueTypes.OldValue &&
1476     SearchArgs.CompareType == SearchCompareTypes.Equal &&
1477     SearchArgs.IsFirstSearch)
1478     {
1479     NeedToCompare = false;
1480     //second_tmp_Results = null; // Free Memory
1481     }
1482 william 408
1483 william 410 if (NeedToCompare)
1484 william 280 {
1485 william 410 if (SearchArgs.CompareType != SearchCompareTypes.Between && SearchArgs.CompareType != SearchCompareTypes.NotBetween)
1486 william 280 {
1487 william 410 #region Non-Range Searches
1488 william 457 if (USE_NONRANGE_SEARCH_RESULT_READER)
1489 william 398 {
1490 william 457 st_nonrange_search.Start();
1491     //second_tmp_Results = new List<ResultType<object>>(SearchArgs.Results.Count * 1024);
1492     ////second_tmp_Results.c
1493     try
1494 william 398 {
1495 william 457 using (SearchResultReader reader = new SearchResultReader(SearchGuid))
1496 william 398 {
1497 william 457 try
1498     {
1499 william 453
1500 william 457 #region new comparator-support
1501     second_tmp_Results = new List<ResultType<object>>(reader.GetResults(SearchArgs, (IAcceptsProcessAndConfig)this, resultsprogress));
1502     #endregion
1503 william 452
1504 william 457 #region USE_OLD_SEARCH_RESULTS_COMPRATOR_CODE
1505     if (USE_OLD_SEARCH_RESULTS_COMPRATOR_CODE)
1506 william 452 {
1507 william 457 for (int i = 0; i < reader.ResultCount; i += 1)
1508 william 452 {
1509 william 457 object result_value = 0;
1510     uint address = 0;
1511     #region switch (SearchArgs.DataType)
1512     switch (SearchArgs.DataType)
1513     {
1514     case SearchDataTypes._8bits: if (unsigned)
1515 william 452 {
1516 william 457 using (ResultType<byte> result = reader.GetNextResult<byte>())
1517     {
1518     address = result.Address;
1519     result_value = result.Value;
1520     }
1521 william 452 }
1522 william 457 else
1523 william 452 {
1524 william 457 using (ResultType<sbyte> result = reader.GetNextResult<sbyte>())
1525     {
1526     address = result.Address;
1527     result_value = result.Value;
1528     }
1529     } break;
1530     case SearchDataTypes._16bits: if (unsigned)
1531 william 452 {
1532 william 457 using (ResultType<ushort> result = reader.GetNextResult<ushort>())
1533     {
1534     address = result.Address;
1535     result_value = result.Value;
1536     }
1537 william 452 }
1538 william 457 else
1539 william 452 {
1540 william 457 using (ResultType<short> result = reader.GetNextResult<short>())
1541     {
1542     address = result.Address;
1543     result_value = result.Value;
1544     }
1545     } break;
1546     case SearchDataTypes._32bits: if (unsigned)
1547 william 452 {
1548 william 457 using (ResultType<uint> result = reader.GetNextResult<uint>())
1549     {
1550     address = result.Address;
1551     result_value = result.Value;
1552     }
1553 william 452 }
1554 william 457 else
1555 william 452 {
1556 william 457 using (ResultType<int> result = reader.GetNextResult<int>())
1557     {
1558     address = result.Address;
1559     result_value = result.Value;
1560     }
1561     } break;
1562     case SearchDataTypes._64bits: if (unsigned)
1563 william 452 {
1564 william 457 using (ResultType<ulong> result = reader.GetNextResult<ulong>())
1565     {
1566     address = result.Address;
1567     result_value = result.Value;
1568     }
1569 william 452 }
1570 william 457 else
1571 william 452 {
1572 william 457 using (ResultType<long> result = reader.GetNextResult<long>())
1573     {
1574     address = result.Address;
1575     result_value = result.Value;
1576     }
1577     } break;
1578     }
1579     #endregion
1580     if (MemoryRangeStart > 0 && !SearchArgs.IsFirstSearch) { address = address - MemoryRangeStart; }
1581     try
1582     {
1583     //r_ms.BaseStream.Seek(address, SeekOrigin.Begin);
1584     }
1585     catch (Exception)
1586     {
1587     throw;
1588     }
1589     switch (SearchArgs.DataType)
1590     {
1591     #region Comparer Support
1592     #region case SearchDataTypes._8bits:
1593     case SearchDataTypes._8bits:
1594     if (SearchArgs.IsUnsignedDataType)
1595 william 452 {
1596 william 457 byte lookup_value = 0;
1597     //using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this)) { gmp.OpenProvider(); gmp.ReadMemory(address, out lookup_value); gmp.CloseProvider(); }
1598     lookup_value = Convert.ToByte(result_value);
1599     using (_8bit_unsigned_comparer_ comparer = new _8bit_unsigned_comparer_(SearchArgs, address))
1600 william 452 {
1601 william 457 byte value = 0;
1602     if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1603 william 452 {
1604 william 457 using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1605 william 452 {
1606 william 457 try
1607     {
1608     gmp.OpenProvider();
1609     gmp.ReadMemory(address, out value);
1610     gmp.CloseProvider();
1611     }
1612     catch (Exception ex)
1613     {
1614     logger.VerboseError.WriteLine(ex.ToString());
1615     }
1616 william 452 }
1617 william 457 comparer.Value = value;
1618 william 452 }
1619 william 457 else
1620     {
1621     value = Convert.ToByte(SearchArgs.CompareStartValue);
1622     comparer.Value = value;
1623     }
1624     if (comparer.Compare(lookup_value, value))
1625     {
1626     second_tmp_Results.Add(new ResultType<object>(comparer.Address, comparer.Value));
1627     }
1628 william 452 }
1629     }
1630 william 457 else
1631 william 452 {
1632 william 457 sbyte lookup_value = 0;
1633     //using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this)) { gmp.OpenProvider(); gmp.ReadMemory(address, out lookup_value); gmp.CloseProvider(); }
1634     lookup_value = Convert.ToSByte(result_value);
1635     using (_8bit_signed_comparer_ comparer = new _8bit_signed_comparer_(SearchArgs, address))
1636 william 452 {
1637 william 457 sbyte value = 0;
1638     if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1639 william 452 {
1640 william 457 using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1641 william 452 {
1642 william 457 try
1643     {
1644     gmp.OpenProvider();
1645     gmp.ReadMemory(address, out value);
1646     gmp.CloseProvider();
1647     }
1648     catch (Exception ex)
1649     {
1650     logger.VerboseError.WriteLine(ex.ToString());
1651     }
1652 william 452 }
1653 william 457 comparer.Value = value;
1654 william 452 }
1655 william 457 else
1656     {
1657     value = Convert.ToSByte(SearchArgs.CompareStartValue);
1658     }
1659     if (comparer.Compare(lookup_value, value))
1660     {
1661     second_tmp_Results.Add(new ResultType<object>(comparer.Address, comparer.Value));
1662     }
1663 william 452 }
1664     }
1665 william 457 break;
1666     #endregion
1667     #region case SearchDataTypes._16bits:
1668     case SearchDataTypes._16bits:
1669     if (SearchArgs.IsUnsignedDataType)
1670 william 452 {
1671 william 457 ushort lookup_value = 0;
1672     //using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this)) { gmp.OpenProvider(); gmp.ReadMemory(address, out lookup_value); gmp.CloseProvider(); }
1673     lookup_value = Convert.ToUInt16(result_value);
1674     using (_16bit_unsigned_comparer_ comparer = new _16bit_unsigned_comparer_(SearchArgs, address))
1675 william 452 {
1676 william 457 ushort value = 0;
1677     if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1678 william 452 {
1679 william 457 using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1680 william 452 {
1681 william 457 try
1682     {
1683     gmp.OpenProvider();
1684     gmp.ReadMemory(address, out value);
1685     gmp.CloseProvider();
1686     }
1687     catch (Exception ex)
1688     {
1689     logger.VerboseError.WriteLine(ex.ToString());
1690     }
1691 william 452 }
1692 william 457 comparer.Value = value;
1693 william 452 }
1694 william 457 else
1695     {
1696     value = Convert.ToUInt16(SearchArgs.CompareStartValue);
1697     comparer.Value = value;
1698     }
1699     if (comparer.Compare(lookup_value, value))
1700     {
1701     second_tmp_Results.Add(new ResultType<object>(comparer.Address, comparer.Value));
1702     }
1703 william 452 }
1704     }
1705 william 457 else
1706 william 452 {
1707 william 457 short lookup_value = 0;
1708     //using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this)) { gmp.OpenProvider(); gmp.ReadMemory(address, out lookup_value); gmp.CloseProvider(); }
1709     lookup_value = Convert.ToInt16(result_value);
1710     using (_16bit_signed_comparer_ comparer = new _16bit_signed_comparer_(SearchArgs, address))
1711 william 452 {
1712 william 457 short value = 0;
1713     if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1714 william 452 {
1715 william 457 using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1716 william 452 {
1717 william 457 try
1718     {
1719     gmp.OpenProvider();
1720     gmp.ReadMemory(address, out value);
1721     gmp.CloseProvider();
1722     }
1723     catch (Exception ex)
1724     {
1725     logger.VerboseError.WriteLine(ex.ToString());
1726     }
1727 william 452 }
1728 william 457 comparer.Value = value;
1729 william 452 }
1730 william 457 else
1731     {
1732     value = Convert.ToInt16(SearchArgs.CompareStartValue);
1733     }
1734     if (comparer.Compare(lookup_value, value))
1735     {
1736     second_tmp_Results.Add(new ResultType<object>(comparer.Address, comparer.Value));
1737     }
1738 william 452 }
1739     }
1740 william 457 break;
1741     #endregion
1742     #region case SearchDataTypes._32bits:
1743     case SearchDataTypes._32bits:
1744     if (SearchArgs.IsUnsignedDataType)
1745 william 452 {
1746 william 457 uint lookup_value = 0;
1747     //using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this)) { gmp.OpenProvider(); gmp.ReadMemory(address, out lookup_value); gmp.CloseProvider(); }
1748     lookup_value = Convert.ToUInt32(result_value);
1749     using (_32bit_unsigned_comparer_ comparer = new _32bit_unsigned_comparer_(SearchArgs, address))
1750 william 452 {
1751 william 457 uint value = 0;
1752     if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1753 william 452 {
1754 william 457 using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1755 william 452 {
1756 william 457 try
1757     {
1758     gmp.OpenProvider();
1759     gmp.ReadMemory(address, out value);
1760     gmp.CloseProvider();
1761     }
1762     catch (Exception ex)
1763     {
1764     logger.VerboseError.WriteLine(ex.ToString());
1765     }
1766 william 452 }
1767 william 457 comparer.Value = value;
1768 william 452 }
1769 william 457 else
1770     {
1771     value = Convert.ToUInt32(SearchArgs.CompareStartValue);
1772     comparer.Value = value;
1773     }
1774     if (comparer.Compare(lookup_value, value))
1775     {
1776     second_tmp_Results.Add(new ResultType<object>(comparer.Address, comparer.Value));
1777     }
1778 william 452 }
1779     }
1780 william 457 else
1781 william 452 {
1782 william 457 int lookup_value = 0;
1783     //using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this)) { gmp.OpenProvider(); gmp.ReadMemory(address, out lookup_value); gmp.CloseProvider(); }
1784     lookup_value = Convert.ToInt32(result_value);
1785     using (_32bit_signed_comparer_ comparer = new _32bit_signed_comparer_(SearchArgs, address))
1786 william 452 {
1787 william 457 int value = 0;
1788     if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1789 william 452 {
1790 william 457 using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1791 william 452 {
1792 william 457 try
1793     {
1794     gmp.OpenProvider();
1795     gmp.ReadMemory(address, out value);
1796     gmp.CloseProvider();
1797     }
1798     catch (Exception ex)
1799     {
1800     logger.VerboseError.WriteLine(ex.ToString());
1801     }
1802 william 452 }
1803 william 457 comparer.Value = value;
1804 william 452 }
1805 william 457 else
1806     {
1807     value = Convert.ToInt32(SearchArgs.CompareStartValue);
1808     }
1809     if (comparer.Compare(lookup_value, value))
1810     {
1811     second_tmp_Results.Add(new ResultType<object>(comparer.Address, comparer.Value));
1812     }
1813 william 452 }
1814     }
1815 william 457 break;
1816     #endregion
1817     #region case SearchDataTypes._64bits:
1818     case SearchDataTypes._64bits:
1819     if (SearchArgs.IsUnsignedDataType)
1820 william 452 {
1821 william 457 ulong lookup_value = 0;
1822     //using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this)) { gmp.OpenProvider(); gmp.ReadMemory(address, out lookup_value); gmp.CloseProvider(); }
1823     lookup_value = Convert.ToUInt64(result_value);
1824     using (_64bit_unsigned_comparer_ comparer = new _64bit_unsigned_comparer_(SearchArgs, address))
1825 william 452 {
1826 william 457 ulong value = 0;
1827     if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1828 william 452 {
1829 william 457 using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1830 william 452 {
1831 william 457 try
1832     {
1833     gmp.OpenProvider();
1834     gmp.ReadMemory(address, out value);
1835     gmp.CloseProvider();
1836     }
1837     catch (Exception ex)
1838     {
1839     logger.VerboseError.WriteLine(ex.ToString());
1840     }
1841 william 452 }
1842 william 457 comparer.Value = value;
1843 william 452 }
1844 william 457 else
1845     {
1846     value = Convert.ToUInt64(SearchArgs.CompareStartValue);
1847     comparer.Value = value;
1848     }
1849     if (comparer.Compare(lookup_value, value))
1850     {
1851     second_tmp_Results.Add(new ResultType<object>(comparer.Address, comparer.Value));
1852     }
1853 william 452 }
1854     }
1855 william 457 else
1856 william 452 {
1857 william 457 long lookup_value = 0;
1858     //using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this)) { gmp.OpenProvider(); gmp.ReadMemory(address, out lookup_value); gmp.CloseProvider(); }
1859     lookup_value = Convert.ToInt64(result_value);
1860     using (_64bit_signed_comparer_ comparer = new _64bit_signed_comparer_(SearchArgs, address))
1861 william 452 {
1862 william 457 long value = 0;
1863     if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1864 william 452 {
1865 william 457 using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1866 william 452 {
1867 william 457 try
1868     {
1869     gmp.OpenProvider();
1870     gmp.ReadMemory(address, out value);
1871     gmp.CloseProvider();
1872     }
1873     catch (Exception ex)
1874     {
1875     logger.VerboseError.WriteLine(ex.ToString());
1876     }
1877 william 452 }
1878 william 457 comparer.Value = value;
1879 william 452 }
1880 william 457 else
1881     {
1882     value = Convert.ToInt64(SearchArgs.CompareStartValue);
1883     }
1884     if (comparer.Compare(lookup_value, value))
1885     {
1886     second_tmp_Results.Add(new ResultType<object>(comparer.Address, comparer.Value));
1887     }
1888 william 452 }
1889     }
1890 william 457 break;
1891     #endregion
1892     #endregion
1893     }
1894     double double_percent_done = 100.0 * (double)((double)i / (double)reader.ResultCount);
1895     int int_percent_done = (int)double_percent_done;
1896     //if (int_percent_done != Last_Whole_Percent_Done && i % 100000 == 0)
1897     //{
1898     if (int_percent_done <= 100)
1899     {
1900     resultsprogress.Value = int_percent_done;
1901     resultsprogress.Message = string.Format(" -> Reading Address: 0x{0:x8}", i + MemoryRangeStart);
1902     //Last_Whole_Percent_Done = int_percent_done;
1903     }
1904     //}
1905     //this.Refresh();
1906 william 452 }
1907 william 402 }
1908 william 457 #endregion
1909 william 410 }
1910 william 457 catch (Exception ex)
1911     {
1912     throw ex;
1913     }
1914 william 409 }
1915 william 398 }
1916 william 457 catch (Exception ex)
1917     {
1918     throw ex;
1919     }
1920     st_nonrange_search.Stop();
1921     logger.Profiler.WriteLine("Non-Ranged search took a total of {0} seconds to complete.", st_nonrange_search.Elapsed.TotalSeconds);
1922     //Last_Whole_Percent_Done = 0;
1923 william 280 }
1924 william 410 #endregion
1925 william 280 }
1926 william 410 #region Ranged Searches
1927     #if !DONOT_HAVE_RANGED_SEARCH_SUPPORT
1928     if (SearchArgs.CompareType == SearchCompareTypes.Between || SearchArgs.CompareType == SearchCompareTypes.NotBetween)
1929 william 409 {
1930 william 410 st_ranged_search.Start();
1931     object start, end;
1932 william 408
1933 william 410 start = SearchArgs.CompareStartValue;
1934     end = SearchArgs.CompareEndValue;
1935 william 444 using (SearchResultReader reader = new SearchResultReader(SearchGuid))
1936 william 402 {
1937 william 410 for (int i = 0; i < reader.ResultCount; i += 1)
1938 william 409 {
1939 william 410 uint address = 0;
1940     #region switch (SearchArgs.DataType)
1941     switch (SearchArgs.DataType)
1942 william 402 {
1943 william 410 case SearchDataTypes._8bits: if (unsigned) { using (ResultType<byte> result = reader.GetNextResult<byte>()) { address = result.Address; } }
1944     else { using (ResultType<sbyte> result = reader.GetNextResult<sbyte>()) { address = result.Address; } } break;
1945     case SearchDataTypes._16bits: if (unsigned) { using (ResultType<ushort> result = reader.GetNextResult<ushort>()) { address = result.Address; } }
1946     else { using (ResultType<short> result = reader.GetNextResult<short>()) { address = result.Address; } } break;
1947     case SearchDataTypes._32bits: if (unsigned) { using (ResultType<uint> result = reader.GetNextResult<uint>()) { address = result.Address; } }
1948     else { using (ResultType<int> result = reader.GetNextResult<int>()) { address = result.Address; } } break;
1949     case SearchDataTypes._64bits: if (unsigned) { using (ResultType<ulong> result = reader.GetNextResult<ulong>()) { address = result.Address; } }
1950     else { using (ResultType<long> result = reader.GetNextResult<long>()) { address = result.Address; } } break;
1951     }
1952     #endregion
1953    
1954     if (MemoryRangeStart > 0 && !SearchArgs.IsFirstSearch) { address = address - MemoryRangeStart; }
1955     //r_ms.BaseStream.Seek(address, SeekOrigin.Begin);
1956     if (SearchArgs.CompareType == SearchCompareTypes.Between)
1957     {
1958     using (InRangeComparer comparer = new InRangeComparer(address, 0))
1959 william 409 {
1960 william 410 if (comparer.Compare(start, end, SearchArgs.DataType, SearchArgs.IsUnsignedDataType, (IAcceptsProcessAndConfig)this))
1961     {
1962     using (ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value))
1963     {
1964     second_tmp_Results.Add(_tmp_result);
1965     }
1966     }
1967 william 409 }
1968 william 402 }
1969 william 410 else if (SearchArgs.CompareType == SearchCompareTypes.NotBetween)
1970 william 408 {
1971 william 410 using (NotInRangeComparer comparer = new NotInRangeComparer(address, 0))
1972 william 409 {
1973 william 410 if (comparer.Compare(start, end, SearchArgs.DataType, SearchArgs.IsUnsignedDataType, (IAcceptsProcessAndConfig)this))
1974     {
1975     using (ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value))
1976     {
1977     second_tmp_Results.Add(_tmp_result);
1978     }
1979     }
1980 william 409 }
1981 william 408 }
1982 william 410 else
1983 william 408 {
1984 william 410 throw new InvalidOperationException("Encounted unkown range search type: " + SearchArgs.CompareType);
1985 william 408 }
1986 william 410 double double_percent_done = 100.0 * (double)((double)i / (double)reader.ResultCount);
1987     int int_percent_done = (int)double_percent_done;
1988     if (int_percent_done != Last_Whole_Percent_Done)
1989 william 409 {
1990 william 410 if (int_percent_done <= 100)
1991     {
1992     resultsprogress.Value = int_percent_done;
1993     resultsprogress.Message = string.Format(" -> Reading Address: 0x{0:x8}", i + MemoryRangeStart);
1994     Last_Whole_Percent_Done = int_percent_done;
1995     }
1996 william 409 }
1997 william 408 }
1998     }
1999 william 410 st_ranged_search.Stop();
2000     logger.Profiler.WriteLine("Ranged search took a total of {0} seconds to complete.", st_ranged_search.Elapsed.TotalSeconds);
2001 william 280 }
2002 william 410 #endif
2003     #endregion
2004    
2005 william 408 }
2006     #endregion
2007 william 457 //// leave SearchArgs.Results alone, if false
2008     //if (NeedToCompare)
2009     //{
2010     // // fix addresses when memory start is not zero
2011     // if (MemoryRangeStart > 0 && SearchArgs.IsFirstSearch) { for (int i = 0; i < second_tmp_Results.Count; i++) { second_tmp_Results[i].Address = second_tmp_Results[i].Address + MemoryRangeStart; } }
2012     // using (SearchResultWriter writer = new SearchResultWriter(second_tmp_Results.Count, SearchGuid))
2013     // {
2014     // for (int i = 0; i < second_tmp_Results.Count; i++)
2015     // {
2016     // switch (sdt)
2017     // {
2018     // case SearchDataTypes._8bits:
2019     // if (unsigned) { writer.WriteResult<Byte>(second_tmp_Results[i].Address, Convert.ToByte(second_tmp_Results[i].Value)); }
2020     // else { writer.WriteResult<SByte>(second_tmp_Results[i].Address, Convert.ToSByte(second_tmp_Results[i].Value)); } break;
2021     // case SearchDataTypes._16bits:
2022     // if (unsigned) { writer.WriteResult<UInt16>(second_tmp_Results[i].Address, Convert.ToUInt16(second_tmp_Results[i].Value)); }
2023     // else { writer.WriteResult<Int16>(second_tmp_Results[i].Address, Convert.ToInt16(second_tmp_Results[i].Value)); } break;
2024     // case SearchDataTypes._32bits:
2025     // if (unsigned) { writer.WriteResult<UInt32>(second_tmp_Results[i].Address, Convert.ToUInt32(second_tmp_Results[i].Value)); }
2026     // else { writer.WriteResult<Int32>(second_tmp_Results[i].Address, Convert.ToInt32(second_tmp_Results[i].Value)); } break;
2027     // case SearchDataTypes._64bits:
2028     // if (unsigned) { writer.WriteResult<UInt64>(second_tmp_Results[i].Address, Convert.ToUInt64(second_tmp_Results[i].Value)); }
2029     // else { writer.WriteResult<Int64>(second_tmp_Results[i].Address, Convert.ToInt64(second_tmp_Results[i].Value)); } break;
2030     // }
2031     // }
2032     // }
2033     // second_tmp_Results = null; // free memory
2034     //}
2035 william 280 }
2036 william 410 catch (Exception ex)
2037     {
2038 william 419 throw ex;
2039 william 410 }
2040 william 230 }
2041    
2042 william 408
2043    
2044 william 230 private void SearchWorkerThread_ProgressChanged(object sender, ProgressChangedEventArgs e)
2045     {
2046 william 280 //if (SearchArgs.ProgressLogger != null)
2047     //{
2048     // resultsprogress.Value = e.ProgressPercentage;
2049     // //Application.DoEvents();
2050     //}
2051 william 230 }
2052    
2053     private void SearchWorkerThread_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
2054     {
2055 william 446 try { if ((bool)e.Result) { logger.Warn.WriteLine("Search operation was cancelled."); resultsprogress.Value = 0; resultsprogress.Message = ""; return; } }
2056     catch (InvalidCastException) { }
2057     try
2058 william 286 {
2059 william 446 Stopwatch st = (Stopwatch)e.Result;
2060 william 286 st.Stop();
2061 william 392 logger.Profiler.WriteLine("Search took {0} seconds, overall, to complete.", st.Elapsed.TotalSeconds);
2062 william 286 }
2063 william 446 catch (InvalidCastException) { }
2064     catch (Exception ex) { throw ex; }
2065    
2066 william 280 resultsprogress.Value = 100;
2067 william 409 bool unsigned = SearchArgs.IsUnsignedDataType;
2068 william 444 using (SearchResultReader reader = new SearchResultReader(SearchGuid))
2069 william 402 {
2070     logger.Info.WriteLine(string.Format("Found 0x{0:x8} results", reader.ResultCount));
2071    
2072     if (reader.ResultCount <= MIN_NUMBER_OF_RESULTS_BEFORE_DISPLAY)
2073 william 280 {
2074 william 402 lstResults.Items.Clear();
2075 william 457 //List<ResultItem> items = new List<ResultItem>();
2076     //for (int i = 0; i < reader.ResultCount; i++)
2077     //{
2078     // ResultItem item = new ResultItem(0, false);
2079     // //item.Text = string.Format("0x{0:x8}", SearchArgs.Results[i].Address);
2080     // //item.SubItems.Add(string.Format("0x{0:x8}", SearchArgs.Results[i].Address));
2081     // switch (SearchArgs.DataType)
2082     // {
2083     // case SearchDataTypes._8bits:
2084     // if (SearchArgs.IsUnsignedDataType) { ResultType<byte> result = new ResultType<byte>(); item = new ResultItem(result.Address, false, result.Value); }
2085     // else { ResultType<sbyte> result = reader.GetNextResult<sbyte>(); item = new ResultItem(result.Address, false, result.Value); }
2086     // break;
2087     // case SearchDataTypes._16bits:
2088     // if (SearchArgs.IsUnsignedDataType) { ResultType<ushort> result = reader.GetNextResult<ushort>(); item = new ResultItem(result.Address, false, result.Value); }
2089     // else { ResultType<short> result = reader.GetNextResult<short>(); item = new ResultItem(result.Address, false, result.Value); }
2090     // break;
2091     // case SearchDataTypes._32bits:
2092     // if (SearchArgs.IsUnsignedDataType) { ResultType<uint> result = reader.GetNextResult<uint>(); item = new ResultItem(result.Address, false, result.Value); }
2093     // else { ResultType<int> result = reader.GetNextResult<int>(); item = new ResultItem(result.Address, false, result.Value); }
2094     // break;
2095     // case SearchDataTypes._64bits:
2096     // if (SearchArgs.IsUnsignedDataType) { ResultType<ulong> result = reader.GetNextResult<ulong>(); item = new ResultItem(result.Address, false, result.Value); }
2097     // else { ResultType<long> result = reader.GetNextResult<long>(); item = new ResultItem(result.Address, false, result.Value); }
2098     // break;
2099     // }
2100     // if (!items.Contains(item))
2101     // items.Add(item);
2102     //}
2103     lstResults.Items.AddRange(reader.GetResultItems(SearchArgs, (IAcceptsProcessAndConfig)this, resultsprogress));
2104 william 280 }
2105     }
2106    
2107     this.DoSearchDoneSpecific();
2108     //System.Threading.Thread.Sleep(100);
2109     //if (_SEARCH_MODE != SearchMode.SEARCH_MODE_NORMAL_WITH_JOKER)
2110     this.ThawResultsUpdate();
2111     Application.DoEvents();
2112 william 230 }
2113 william 280 private void DoSearchDoneSpecific()
2114     {
2115     SearchWorkerThread.CancelAsync();
2116     if (lstResults.Items.Count > 0) { timer_update_results.Enabled = true; }
2117     else { timer_update_results.Enabled = false; }
2118 william 230
2119 william 280 search_progress_updater.Enabled = false;
2120    
2121     btnCancel.Enabled = false;
2122     btnReset.Enabled = true;
2123     btnSearch.Enabled = true;
2124     grpCompareType.Enabled = true;
2125     grpCompareValue.Enabled = true;
2126     resultsprogress.Value = 0;
2127     resultsprogress.Message = "";
2128     grpDataType.Enabled = false;
2129     // resume process on reset, incase it was suspended
2130     ThreadControl.ResumeProcess(this.AcceptedProcess.Id);
2131     //Application.DoEvents();
2132     this.Refresh();
2133     }
2134    
2135     private void DoCancelSpecific()
2136     {
2137     this.DoSearchDoneSpecific();
2138     }
2139     private void DoResetSpecific()
2140     {
2141     this.DoCancelSpecific();
2142     IsFirstSearch = true;
2143     grpDataType.Enabled = true;
2144 william 447 btnReset.Enabled = false;
2145 william 448
2146     // delete any temporary search result files
2147     SearchResultWriter.CleanupTemporarySearchResultFiles();
2148    
2149 william 280 }
2150 william 230 private void search_progress_updater_Tick(object sender, EventArgs e)
2151     {
2152     if ((this.AcceptedProcess ==null) || Process.GetProcessById(this.AcceptedProcess.Id) == null)
2153     {
2154     SearchWorkerThread.CancelAsync();
2155     //JokerSearchWorker.CancelAsync();
2156     ResultsUpdateWorkerThread.CancelAsync();
2157     }
2158     }
2159    
2160 william 280 #region Search Button
2161 william 230 private void btnSearch_Click(object sender, EventArgs e)
2162     {
2163 william 444 if (this.SearchGuid == Guid.Empty)
2164     this.SearchGuid = Guid.NewGuid();
2165 william 271 this.SearchInProgess = true;
2166 william 447 btnCancel.Enabled = true;
2167     btnReset.Enabled = true;
2168     btnSearch.Enabled = false;
2169 william 280 this.FreezeResultsUpdate();
2170     this.handle_btnSearch_Click();
2171     }
2172     private void handle_btnSearch_Click()
2173     {
2174     //this.FreezeResultsUpdate();
2175     lstResults.Items.Clear();
2176    
2177     if (lstResults.Items.Count > 0) { timer_update_results.Enabled = true; }
2178     else { timer_update_results.Enabled = false; }
2179    
2180    
2181     resultsprogress.Value = 0;
2182     bool _is_unsigned = chkUnsigned.Checked;
2183     SearchType search_type = new SearchType();
2184     SearchDataTypes _data_type = new SearchDataTypes();
2185     SearchCompareTypes _compare_type = new SearchCompareTypes();
2186     CompareValueTypes _compare_value_type = new CompareValueTypes();
2187     object start_value = 0;
2188     object end_value = 0;
2189     // get datatype
2190     if (radio_8bits.Checked) { _data_type = SearchDataTypes._8bits; }
2191     else if (radio_16bits.Checked) { _data_type = SearchDataTypes._16bits; }
2192     else if (radio_32bits.Checked) { _data_type = SearchDataTypes._32bits; }
2193     else if (radio_64bits.Checked) { _data_type = SearchDataTypes._64bits; }
2194     else { logger.Error.WriteLine("Could not determine search data type bit size. (was not 8/16/32/or 64bits)"); }
2195     // get compare type
2196     if (radiocompare_equal.Checked) { _compare_type = SearchCompareTypes.Equal; }
2197     else if (radiocompare_greaterthan.Checked) { _compare_type = SearchCompareTypes.GreaterThan; }
2198     else if (radiocompare_lessthan.Checked) { _compare_type = SearchCompareTypes.LessThan; }
2199     else if (radiocompare_greaterthan_orequal.Checked) { _compare_type = SearchCompareTypes.GreaterThanOrEqual; }
2200     else if (radiocompare_lessthan_orequal.Checked) { _compare_type = SearchCompareTypes.LessThanOrEqual; }
2201     else if (radiocompare_notequal.Checked) { _compare_type = SearchCompareTypes.NotEqual; }
2202     else if (radiocompare_between.Checked) { _compare_type = SearchCompareTypes.Between; }
2203     else if (radiocompare_notbetween.Checked) { _compare_type = SearchCompareTypes.NotBetween; }
2204     else { logger.Error.WriteLine("Could not determine search comparison type. (was not == > < >= <= != <> or !<>)"); }
2205     // get compare valure type
2206     if (radio_oldvalue.Checked) { _compare_value_type = CompareValueTypes.OldValue; }
2207     else if (radio_specificvalue.Checked) { _compare_value_type = CompareValueTypes.SpecificValue; }
2208     else { logger.Error.WriteLine("Could not determine search comparison type. (was not old or specific value"); }
2209    
2210     if (_compare_value_type == CompareValueTypes.SpecificValue || (_compare_type == SearchCompareTypes.Between || _compare_type == SearchCompareTypes.NotBetween))
2211     {
2212    
2213     switch (_data_type)
2214     {
2215     case SearchDataTypes._8bits:
2216     if (_is_unsigned) { start_value = txtStartAddr.ToByte(); }
2217     else { start_value = txtStartAddr.ToSByte(); }
2218     break;
2219     case SearchDataTypes._16bits:
2220     if (_is_unsigned) { start_value = txtStartAddr.ToUInt16(); }
2221     else { start_value = txtStartAddr.ToInt16(); }
2222     break;
2223     case SearchDataTypes._32bits:
2224     if (_is_unsigned) { start_value = txtStartAddr.ToUInt32(); }
2225     else { start_value = txtStartAddr.ToInt32(); }
2226     break;
2227     case SearchDataTypes._64bits:
2228     if (_is_unsigned) { start_value = txtStartAddr.ToUInt64(); }
2229     else { start_value = txtStartAddr.ToInt64(); }
2230     break;
2231     default: throw new InvalidOperationException("In SearchType(): Encounterd an Unkown Search Data Type.");
2232     }
2233     }
2234     if (_compare_type == SearchCompareTypes.Between || _compare_type == SearchCompareTypes.NotBetween)
2235     {
2236     switch (_data_type)
2237     {
2238     case SearchDataTypes._8bits:
2239     if (_is_unsigned) { end_value = txtEndAddr.ToByte(); }
2240     else { end_value = txtEndAddr.ToSByte(); }
2241     break;
2242     case SearchDataTypes._16bits:
2243     if (_is_unsigned) { end_value = txtEndAddr.ToUInt16(); }
2244     else { end_value = txtEndAddr.ToInt16(); }
2245     break;
2246     case SearchDataTypes._32bits:
2247     if (_is_unsigned) { end_value = txtEndAddr.ToUInt32(); }
2248     else { end_value = txtEndAddr.ToInt32(); }
2249     break;
2250     case SearchDataTypes._64bits:
2251     if (_is_unsigned) { end_value = txtEndAddr.ToUInt64(); }
2252