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

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

Parent Directory Parent Directory | Revision Log Revision Log


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