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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 525 - (show annotations) (download)
Wed Jun 5 07:37:37 2013 UTC (7 years, 4 months ago) by william
File size: 205938 byte(s)

1 #region Logging Defines
2 // include this any class or method that required logging, and comment-out what is not needed
3
4 #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 #if !USE_AUTOMATIC_MEMORY_SEARCH_RANGE
16 #define FORCE_USE_OF_MEMORYSIZECONSTANTS // when defined wil force the use of the constants defined in MemorySizeConstants for memory search range
17 #endif
18 #define DONOT_HAVE_RANGED_SEARCH_SUPPORT // when defined, indicates that ranged searches have not been implemented
19 #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 using System;
22 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 using RomCheater.Docking.MemorySearch;
33 using libWin32.Win32.Threading;
34 using System.Threading;
35 using RomCheater.Logging;
36 using System.IO;
37 using Sojaner.MemoryScanner.MemoryProviers;
38 using RomCheater.PluginFramework.Events;
39 using System.Reflection;
40 using Sojaner.MemoryScanner;
41 using System.Collections;
42 using RomCheater.Serialization;
43 using RomCheater.Core;
44
45 namespace RomCheater.Docking
46 {
47 public partial class FloatingMemorySearcher : DockContent,
48 IAcceptsPlugin<IConfigPlugin>,
49 IAcceptsProcess<Process>,
50 IAcceptsProcessAndConfig,
51 ISearchInProgress,
52 IAcceptsBrowseMemoryRegion,
53 IAcceptsMemoryRange
54 {
55 #if INCREASE_NUMBER_OF_RESULTS_BEFORE_DISPLAY
56 const int MIN_NUMBER_OF_RESULTS_BEFORE_DISPLAY = 0x2701; // 10,000 results
57 #else
58 const int MIN_NUMBER_OF_RESULTS_BEFORE_DISPLAY = 0x03e8; // 1,000 results
59 #endif
60
61 const bool USE_OLD_SEARCH_RESULTS_COMPRATOR_CODE = false;
62 const bool USE_NONRANGE_SEARCH_RESULT_READER = false;
63 private bool DefaultUnsignedState = true; // set unsigned to true
64 public FloatingMemorySearcher() { InitializeComponent(); this.AcceptedPlugin = null; OnBrowseMemoryRegion = null; this.AcceptedProcess = null; SearchInProgess = false; Reload(); }
65 public FloatingMemorySearcher(IConfigPlugin config) : this() { this.AcceptedPlugin = config; }
66 public FloatingMemorySearcher(IConfigPlugin config, Process process) : this() { this.AcceptedPlugin = config; this.AcceptedProcess = process; }
67
68 //new Action<int, string>(UpdateProgress) to use this as a delegate
69
70 private void thread_UpdateProgress(object o)
71 {
72 IProgressMessage pm = (o as IProgressMessage);
73 if (pm == null) { return; }
74 resultsprogress.Value = pm.Progress;
75 resultsprogress.Message = pm.Message;
76 }
77
78 private void UpdateProgress(int progress, string message)
79 {
80 // detach the progress update from execution within the current thread (so it does not block a cpu-intensive or long running sequence)
81 Thread t = new Thread(new ParameterizedThreadStart(thread_UpdateProgress));
82 t.SetApartmentState(ApartmentState.STA);
83 t.Start(new ProgressMessage(progress, message));
84 //resultsprogress.Value = progress;
85 //resultsprogress.Message = message;
86 }
87
88 #region IAcceptsProcess<Process> Members
89 private Process _AcceptedProcess;
90 public Process AcceptedProcess { get { return _AcceptedProcess; } set { _AcceptedProcess = value; UpdateAcceptedProcess(value); } }
91 #endregion
92 #region IAcceptsPlugin<IConfigPlugin> Members
93 private IConfigPlugin _AcceptedPlugin;
94 public IConfigPlugin AcceptedPlugin { get { return _AcceptedPlugin; } set { _AcceptedPlugin = value; UpdateAcceptedPlugin(value); } }
95 #endregion
96 #region IAcceptsBrowseMemoryRegion members
97 public event BaseEventHandler<BrowseMemoryRegionEvent> OnBrowseMemoryRegion;
98 #endregion
99
100 private void UpdateAcceptedPlugin(IConfigPlugin config)
101 {
102 this.lstResults.AcceptedPlugin = config;
103 this.lstPatchList.AcceptedPlugin = config;
104 if (config != null)
105 {
106 MemoryRangeStart = AcceptedPlugin.MemoryRangeStart;
107 MemoryRangeSize = AcceptedPlugin.MemoryRangeStart + AcceptedPlugin.MemoryRangeSize;
108 }
109 }
110 private void UpdateAcceptedProcess(Process process)
111 {
112 this.lstResults.AcceptedProcess = process;
113 this.lstPatchList.AcceptedProcess = process;
114 #if USE_AUTOMATIC_MEMORY_SEARCH_RANGE && FORCE_USE_OF_MEMORYSIZECONSTANTS
115 logger.Warn.WriteLine("FloatingMemorySearcher.UpdateAcceptedProcessAndConfig(IConfigPlugin config, Process process):");
116 logger.Warn.WriteLine("Both USE_AUTOMATIC_MEMORY_SEARCH_RANGE and FORCE_USE_OF_MEMORYSIZECONSTANTS are defined");
117 logger.Warn.WriteLine("FORCE_USE_OF_MEMORYSIZECONSTANTS will take precedence and will ignore the values supplied in the memeory search range");
118 #endif
119 #if FORCE_USE_OF_MEMORYSIZECONSTANTS
120 // force use of MemorySizeConstants
121 txtMemoryRangeStart.Value = MemorySizeConstants.MinimumSearchAddress;
122 txtMemoryRangeSize.Value = MemorySizeConstants.MinimumSearchAddress + MemorySizeConstants.MaximumSearchSize;
123 #endif
124 #if USE_AUTOMATIC_MEMORY_SEARCH_RANGE && !FORCE_USE_OF_MEMORYSIZECONSTANTS
125 ////// code to automatically choose the best starting memory address and size
126 //if (process != null)
127 //{
128 // string filename = process.MainModule.FileName;
129 // //string filename = @"c:\Windows\notepad.exe";
130 // PEReader peReader = new PEReader(filename);
131 //}
132 //else
133 //{
134 //txtMemoryRangeStart.Value = MemorySizeConstants.MinimumSearchAddress;
135 //txtMemoryRangeSize.Value = MemorySizeConstants.MinimumSearchAddress + MemorySizeConstants.MaximumSearchSize;
136 //}
137 if (AcceptedPlugin != null)
138 {
139 MemoryRangeStart = AcceptedPlugin.MemoryRangeStart;
140 MemoryRangeSize = AcceptedPlugin.MemoryRangeStart + AcceptedPlugin.MemoryRangeSize;
141 }
142
143 #endif
144
145 }
146 #region ISearchInProgress members
147 private bool _SearchInProgess;
148 public bool SearchInProgess
149 {
150 get { return _SearchInProgess; }
151 private set
152 {
153 _SearchInProgess = value;
154 if (this.AcceptedPlugin != null)
155 this.AcceptedPlugin.SetMemorySearchReference(this);
156 }
157 }
158 private Guid _SearchGuid;
159 public Guid SearchGuid
160 {
161 get { return _SearchGuid; }
162 private set { _SearchGuid = value; }
163 }
164 #endregion
165
166 #region IAcceptsMemoryRange
167 #if !FORCE_USE_OF_MEMORYSIZECONSTANTS
168 private uint _MemoryRangeStart;
169 private uint _MemoryRangeSize;
170 #endif
171 public uint MemoryRangeStart
172 {
173 get
174 {
175 #if FORCE_USE_OF_MEMORYSIZECONSTANTS
176 return MemorySizeConstants.MinimumSearchAddress;
177 #else
178 return _MemoryRangeStart;
179 #endif
180 }
181 set
182 {
183 #if !FORCE_USE_OF_MEMORYSIZECONSTANTS
184 _MemoryRangeStart = value;
185 txtMemoryRangeStart.Value = value;
186 #endif
187 }
188 }
189 public uint MemoryRangeSize
190 {
191 get
192 {
193 #if FORCE_USE_OF_MEMORYSIZECONSTANTS
194 return MemorySizeConstants.MinimumSearchAddress + MemorySizeConstants.MaximumSearchSize;
195 #else
196 return _MemoryRangeSize;
197 #endif
198 }
199 set
200 {
201 #if !FORCE_USE_OF_MEMORYSIZECONSTANTS
202 _MemoryRangeSize = value;
203 txtMemoryRangeSize.Value = value;
204 #endif
205 }
206 }
207 #endregion
208
209 public void Reload()
210 {
211 chkUnsigned.Checked = DefaultUnsignedState;
212 radio_8bits.Checked = true;
213 radiocompare_equal.Checked = true;
214 radio_oldvalue.Checked = true;
215 chkRefreshResults.Checked = true;
216 }
217 public enum eListViewResults
218 {
219 SEARCH_RESULTS_LIST = 0x3000,
220 PATCH_RESULTS_LIST = 0x3001,
221 UKNOWN_RESULTS_LIST = 0x3001
222 }
223 bool IsFirstSearch = true;
224 SearchType SearchArgs;
225 static int col_Found_Address = 1;
226 static int col_Found_Value = 2;
227 //static int col_Found_Frozen = 3; /* unused */
228 static int col_Added_Address = 1;
229 static int col_Added_Value = 2;
230 //static int col_Added_Frozen = 3; /* unused */
231 List<ListViewItem> ResultItems = new List<ListViewItem>();
232 List<ListViewItem> AddedItems = new List<ListViewItem>();
233 private bool _PatchedValue_NeedsUpdate;
234 bool PatchedValue_NeedsUpdate
235 {
236 get { if (_PatchedValue_NeedsUpdate) this.ThawResultsUpdate(); return _PatchedValue_NeedsUpdate; }
237 set { _PatchedValue_NeedsUpdate = value; if (value) this.ThawResultsUpdate(); }
238 }
239 private delegate ListViewItem ThreadSafe_GetResultItem(int index, int lv_type);
240 private ListViewItem GetResultItem(int index, int lv_type)
241 {
242 try
243 {
244 AddressValuePairList lv = null;
245 switch (lv_type)
246 {
247 case (int)eListViewResults.SEARCH_RESULTS_LIST: lv = lstResults; break;
248 case (int)eListViewResults.PATCH_RESULTS_LIST: lv = lstPatchList; break;
249 default: throw new IndexOutOfRangeException("Detected: " + Enum.GetName(typeof(eListViewResults), eListViewResults.UKNOWN_RESULTS_LIST) + " with value: " + lv_type.ToString("x4"));
250 }
251 ListViewItem item = new ListViewItem();
252 item = (ListViewItem)lv.Items[index].Clone();
253 return item;
254 }
255 catch (Exception)
256 {
257 return null;
258 }
259 }
260 private void radiocompare_equal_CheckedChanged(object sender, EventArgs e)
261 {
262 //if (!radiocompare_between.Checked && !radiocompare_notbetween.Checked)
263 //{
264 if (radio_oldvalue.Checked)
265 {
266 txtStartAddr.ReadOnly = true;
267 txtEndAddr.ReadOnly = true;
268 }
269 if (radio_specificvalue.Checked)
270 {
271 txtStartAddr.ReadOnly = false;
272 txtEndAddr.ReadOnly = true;
273 }
274 //}
275 }
276
277 private void radiocompare_between_CheckedChanged(object sender, EventArgs e)
278 {
279 if (!radiocompare_equal.Checked &&
280 !radiocompare_greaterthan.Checked &&
281 !radiocompare_greaterthan.Checked &&
282 !radiocompare_lessthan.Checked &&
283 !radiocompare_greaterthan_orequal.Checked &&
284 !radiocompare_lessthan_orequal.Checked &&
285 !radiocompare_notequal.Checked)
286 if (radiocompare_between.Checked)
287 {
288 txtStartAddr.ReadOnly = false;
289 txtEndAddr.ReadOnly = false;
290 return;
291 }
292 if (!radiocompare_between.Checked && !radiocompare_notbetween.Checked)
293 {
294 if (radio_oldvalue.Checked)
295 {
296 txtStartAddr.ReadOnly = true;
297 txtEndAddr.ReadOnly = true;
298 }
299 if (radio_specificvalue.Checked)
300 {
301 txtStartAddr.ReadOnly = false;
302 txtEndAddr.ReadOnly = true;
303 }
304 }
305 }
306
307 private void radiocompare_notbetween_CheckedChanged(object sender, EventArgs e)
308 {
309 if (!radiocompare_equal.Checked &&
310 !radiocompare_greaterthan.Checked &&
311 !radiocompare_greaterthan.Checked &&
312 !radiocompare_lessthan.Checked &&
313 !radiocompare_greaterthan_orequal.Checked &&
314 !radiocompare_lessthan_orequal.Checked &&
315 !radiocompare_notequal.Checked)
316 if (radiocompare_notbetween.Checked)
317 {
318 txtStartAddr.ReadOnly = false;
319 txtEndAddr.ReadOnly = false;
320 return;
321 }
322 if (!radiocompare_between.Checked && !radiocompare_notbetween.Checked)
323 {
324 if (radio_oldvalue.Checked)
325 {
326 txtStartAddr.ReadOnly = true;
327 txtEndAddr.ReadOnly = true;
328 }
329 if (radio_specificvalue.Checked)
330 {
331 txtStartAddr.ReadOnly = false;
332 txtEndAddr.ReadOnly = true;
333 }
334 }
335 }
336
337 private void radio_8bits_CheckedChanged(object sender, EventArgs e)
338 {
339 if (chkUnsigned.Checked)
340 {
341 txtStartAddr.CreateTypeSize<byte>();
342 txtEndAddr.CreateTypeSize<byte>();
343 }
344 else
345 {
346 txtStartAddr.CreateTypeSize<sbyte>();
347 txtEndAddr.CreateTypeSize<sbyte>();
348 }
349 }
350
351 private void radio_16bits_CheckedChanged(object sender, EventArgs e)
352 {
353 if (chkUnsigned.Checked)
354 {
355 txtStartAddr.CreateTypeSize<ushort>();
356 txtEndAddr.CreateTypeSize<ushort>();
357 }
358 else
359 {
360 txtStartAddr.CreateTypeSize<short>();
361 txtEndAddr.CreateTypeSize<short>();
362 }
363 }
364
365 private void radio_32bits_CheckedChanged(object sender, EventArgs e)
366 {
367
368 if (chkUnsigned.Checked)
369 {
370 txtStartAddr.CreateTypeSize<uint>();
371 txtEndAddr.CreateTypeSize<uint>();
372 }
373 else
374 {
375 txtStartAddr.CreateTypeSize<int>();
376 txtEndAddr.CreateTypeSize<int>();
377 }
378 }
379
380 private void radio_64bits_CheckedChanged(object sender, EventArgs e)
381 {
382
383 if (chkUnsigned.Checked)
384 {
385 txtStartAddr.CreateTypeSize<ulong>();
386 txtEndAddr.CreateTypeSize<ulong>();
387 }
388 else
389 {
390 txtStartAddr.CreateTypeSize<long>();
391 txtEndAddr.CreateTypeSize<long>();
392 }
393 }
394
395 private void radio_oldvalue_CheckedChanged(object sender, EventArgs e)
396 {
397 if (!radiocompare_between.Checked && !radiocompare_notbetween.Checked)
398 {
399 txtStartAddr.ReadOnly = true;
400 txtEndAddr.ReadOnly = true;
401 }
402 }
403
404 private void radio_specificvalue_CheckedChanged(object sender, EventArgs e)
405 {
406 if (!radiocompare_between.Checked && !radiocompare_notbetween.Checked)
407 {
408 txtStartAddr.ReadOnly = false;
409 txtEndAddr.ReadOnly = true;
410 }
411 }
412
413 private void chkRefreshResults_CheckedChanged(object sender, EventArgs e)
414 {
415 if (chkRefreshResults.Checked)
416 {
417 timer_update_results.Enabled = true;
418 }
419 else
420 {
421 timer_update_results.Enabled = false;
422 ResultsUpdateWorkerThread.CancelAsync();
423 }
424 }
425
426 private void timer_update_results_Tick(object sender, EventArgs e)
427 {
428 if (chkRefreshResults.Checked && !ResultsUpdateWorkerThread.IsBusy)
429 {
430 ResultsUpdateWorkerThread.RunWorkerAsync();
431 }
432 }
433 private bool ShouldUpdateResults()
434 {
435 if (this.AcceptedProcess == null) return false;
436 if (SearchWorkerThread.IsBusy) return false;
437 //if (JokerSearchWorker.IsBusy) return false;
438 if (this.IsResultsUpdateFrozen) return false;
439 if (mnuAddedResults.Visible) return false;
440 if (mnuResults.Visible) return false;
441 if (Process.GetProcessById(this.AcceptedProcess.Id) == null) return false;
442 if (lstResults.Items.Count > 0) return true;
443 if (lstPatchList.Items.Count > 0) return true;
444 return false;
445 }
446 private void ResultsUpdateWorkerThread_DoWork(object sender, DoWorkEventArgs e)
447 {
448 Thread.Sleep(250); // keep thread from blocking
449 if (!this.ShouldUpdateResults()) return;
450 ////if (SearchArgs == null) return;
451 ////if (this.IsResultsUpdateFrozen) return;
452 ////// put thread to sleep for 500ms
453 ////System.Threading.Thread.Sleep(500);
454 //PCSX2MemoryProvider provider = new PCSX2MemoryProvider(this.SearchPCSX2ProcessPID, resultslog);
455 //byte[] buffered_mem = provider.GetMemory();
456 //MemoryStream ms = new MemoryStream(buffered_mem);
457 //BinaryReader r_ms = new BinaryReader(ms);
458
459 #region Update Results List
460 ResultItems = new List<ListViewItem>();
461 //r_ms.BaseStream.Seek(0, SeekOrigin.Begin);
462 for (int i = 0; i < lstResults.Items.Count; i++)
463 {
464 if (this.lstResults.InvokeRequired)
465 {
466 ThreadSafe_GetResultItem _get_item = new ThreadSafe_GetResultItem(GetResultItem);
467 object item = this.lstResults.Invoke(_get_item, new object[] { i, (int)eListViewResults.SEARCH_RESULTS_LIST });
468 if (item != null)
469 ResultItems.Add((ListViewItem)item);
470 }
471 else
472 {
473 ResultItems.Add(lstResults.Items[i]);
474 }
475
476 }
477 for (int i = 0; i < ResultItems.Count; i++)
478 {
479 if (ResultsUpdateWorkerThread.CancellationPending == true)
480 {
481 e.Cancel = true;
482 return;
483 }
484 int Address = 0;
485 ResultDataType _result = (ResultDataType)ResultItems[i].Tag;
486
487 Address = Convert.ToInt32(ResultItems[i].SubItems[col_Found_Address].Text, 16);
488 //r_ms.BaseStream.Seek(Address, SeekOrigin.Begin);
489 using (GenericMemoryProvider provider = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
490 {
491 provider.OpenProvider();
492 int bytesReadSize;
493 byte[] data;
494 uint bytesToRead = 0;
495 switch (_result.ValueType)
496 {
497 case SearchDataTypes._8bits:
498 bytesToRead = 1;
499 break;
500 case SearchDataTypes._16bits:
501 bytesToRead = 2;
502 break;
503 case SearchDataTypes._32bits:
504 bytesToRead = 4;
505 break;
506 case SearchDataTypes._64bits:
507 bytesToRead = 8;
508 break;
509 }
510 provider.ReadProcessMemory(Address, bytesToRead, out bytesReadSize, out data);
511 using (MemoryStream ms = new MemoryStream(data))
512 {
513 using (BinaryReader r_ms = new BinaryReader(ms))
514 {
515 switch (_result.ValueType)
516 {
517 case SearchDataTypes._8bits:
518 if (_result.IsUnsigned) { ResultItems[i].SubItems[col_Found_Value].Text = string.Format("0x{0:x2}", r_ms.ReadByte()); }
519 else { ResultItems[i].SubItems[col_Found_Value].Text = string.Format("0x{0:x2}", r_ms.ReadSByte()); }
520 break;
521 case SearchDataTypes._16bits:
522 if (_result.IsUnsigned) { ResultItems[i].SubItems[col_Found_Value].Text = string.Format("0x{0:x4}", r_ms.ReadUInt16()); }
523 else { ResultItems[i].SubItems[col_Found_Value].Text = string.Format("0x{0:x4}", r_ms.ReadInt16()); }
524 break;
525 case SearchDataTypes._32bits:
526 if (_result.IsUnsigned) { ResultItems[i].SubItems[col_Found_Value].Text = string.Format("0x{0:x8}", r_ms.ReadUInt32()); }
527 else { ResultItems[i].SubItems[col_Found_Value].Text = string.Format("0x{0:x8}", r_ms.ReadInt32()); }
528 break;
529 case SearchDataTypes._64bits:
530 if (_result.IsUnsigned) { ResultItems[i].SubItems[col_Found_Value].Text = string.Format("0x{0:x16}", r_ms.ReadUInt64()); }
531 else { ResultItems[i].SubItems[col_Found_Value].Text = string.Format("0x{0:x16}", r_ms.ReadInt64()); }
532 break;
533 }
534 r_ms.Close();
535 }
536 }
537 provider.CloseProvider();
538 }
539 //Application.DoEvents();
540 }
541 #endregion
542
543 #region Update Added Results List
544 AddedItems = new List<ListViewItem>();
545 //r_ms.BaseStream.Seek(0, SeekOrigin.Begin);
546 for (int i = 0; i < lstPatchList.Items.Count; i++)
547 {
548 if (this.lstResults.InvokeRequired)
549 {
550 ThreadSafe_GetResultItem _get_item = new ThreadSafe_GetResultItem(GetResultItem);
551 object item = this.lstResults.Invoke(_get_item, new object[] { i, (int)eListViewResults.PATCH_RESULTS_LIST });
552 if (item != null)
553 AddedItems.Add((ListViewItem)item);
554 }
555 else
556 {
557 AddedItems.Add(lstPatchList.Items[i]);
558 }
559
560 }
561 for (int i = 0; i < AddedItems.Count; i++)
562 {
563 if (ResultsUpdateWorkerThread.CancellationPending == true)
564 {
565 e.Cancel = true;
566 return;
567 }
568 int Address = 0;
569 ResultDataType _result = (ResultDataType)AddedItems[i].Tag;
570 Address = Convert.ToInt32(AddedItems[i].SubItems[col_Added_Address].Text, 16);
571 using (GenericMemoryProvider provider = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
572 {
573 provider.OpenProvider();
574 int bytesReadSize;
575 byte[] data;
576 uint bytesToRead = 0;
577 switch (_result.ValueType)
578 {
579 case SearchDataTypes._8bits:
580 bytesToRead = 1;
581 break;
582 case SearchDataTypes._16bits:
583 bytesToRead = 2;
584 break;
585 case SearchDataTypes._32bits:
586 bytesToRead = 4;
587 break;
588 case SearchDataTypes._64bits:
589 bytesToRead = 8;
590 break;
591 }
592 provider.ReadProcessMemory(Address, bytesToRead, out bytesReadSize, out data);
593 provider.CloseProvider();
594 using (MemoryStream ms = new MemoryStream(data))
595 {
596 using (BinaryReader r_ms = new BinaryReader(ms))
597 {
598 switch (_result.ValueType)
599 {
600 case SearchDataTypes._8bits:
601 if (_result.IsUnsigned) { AddedItems[i].SubItems[col_Added_Value].Text = string.Format("0x{0:x2}", r_ms.ReadByte()); }
602 else { AddedItems[i].SubItems[col_Added_Value].Text = string.Format("0x{0:x2}", r_ms.ReadSByte()); }
603 break;
604 case SearchDataTypes._16bits:
605 if (_result.IsUnsigned) { AddedItems[i].SubItems[col_Added_Value].Text = string.Format("0x{0:x4}", r_ms.ReadUInt16()); }
606 else { AddedItems[i].SubItems[col_Added_Value].Text = string.Format("0x{0:x4}", r_ms.ReadInt16()); }
607 break;
608 case SearchDataTypes._32bits:
609 if (_result.IsUnsigned) { AddedItems[i].SubItems[col_Added_Value].Text = string.Format("0x{0:x8}", r_ms.ReadUInt32()); }
610 else { AddedItems[i].SubItems[col_Added_Value].Text = string.Format("0x{0:x8}", r_ms.ReadInt32()); }
611 break;
612 case SearchDataTypes._64bits:
613 if (_result.IsUnsigned) { AddedItems[i].SubItems[col_Added_Value].Text = string.Format("0x{0:x16}", r_ms.ReadUInt64()); }
614 else { AddedItems[i].SubItems[col_Added_Value].Text = string.Format("0x{0:x16}", r_ms.ReadInt64()); }
615 break;
616 }
617 r_ms.Close();
618 }
619 }
620 }
621 //Application.DoEvents();
622 }
623 #endregion
624
625
626 }
627
628 private void ResultsUpdateWorkerThread_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
629 {
630 try
631 {
632 //if ((lstResults.SelectedItems.Count > 0) && !PatchedValue_NeedsUpdate ) return;
633 //if ((lstPatchList.SelectedItems.Count > 0) && !PatchedValue_NeedsUpdate) return;
634 if (!this.ShouldUpdateResults()) return;
635 if (ResultItems.Count > 0)
636 {
637 //lstResults.Items.Clear();
638 //lstResults.Items.AddRange(ResultItems.ToArray());
639
640 for (int i = 0; i < ResultItems.Count; i++)
641 {
642 lstResults.Items[i].SubItems[new AVPColumnText(AVPColumnType.VALUE).ColumnIndex].Text =
643 ResultItems[i].SubItems[new AVPColumnText(AVPColumnType.VALUE).ColumnIndex].Text;
644 }
645
646 }
647 if (AddedItems.Count > 0)
648 {
649 //lstPatchList.Items.Clear();
650 //lstPatchList.Items.AddRange(AddedItems.ToArray());
651
652 for (int i = 0; i < AddedItems.Count; i++)
653 {
654 lstPatchList.Items[i].SubItems[new AVPColumnText(AVPColumnType.VALUE).ColumnIndex].Text =
655 AddedItems[i].SubItems[new AVPColumnText(AVPColumnType.VALUE).ColumnIndex].Text;
656 }
657
658 }
659 PatchedValue_NeedsUpdate = false;
660 }
661 catch { }
662 }
663
664 private void btnImportFile_Click(object sender, EventArgs e)
665 {
666 this.FreezeResultsUpdate();
667 if (!lstPatchList.ImportFromFile())
668 {
669 MessageBox.Show("Failed to Import Patch List from File.", "Import Failure", MessageBoxButtons.OK, MessageBoxIcon.Error);
670 this.ThawResultsUpdate();
671 return;
672 }
673 else
674 {
675 MessageBox.Show("Succesfully Imported Patch List from File.", "Import Success", MessageBoxButtons.OK, MessageBoxIcon.Information);
676 this.ThawResultsUpdate();
677 return;
678 }
679 }
680 bool g_isFrozen = false;
681 private bool IsResultsUpdateFrozen
682 {
683 get { return g_isFrozen; }
684 set { g_isFrozen = value; }
685 }
686 private void ThawResultsUpdate()
687 {
688 this.IsResultsUpdateFrozen = false;
689 if (this.AcceptedProcess != null)
690 {
691 #if !DO_NOT_SUSPEND_RESUME_THREAD_ON_FREEZE
692 ThreadControl.ResumeProcess(this.AcceptedProcess.Id);
693 #endif
694 }
695 }
696
697 private void FreezeResultsUpdate()
698 {
699 this.IsResultsUpdateFrozen = true;
700 //this.IsResultsUpdateFrozen = false;
701 if (this.AcceptedProcess != null)
702 {
703 #if !DO_NOT_SUSPEND_RESUME_THREAD_ON_FREEZE
704 ThreadControl.SuspendProcess(this.AcceptedProcess.Id);
705 #endif
706 }
707 }
708
709 private void btnExportFile_Click(object sender, EventArgs e)
710 {
711 this.FreezeResultsUpdate();
712 if (!lstPatchList.ExportToFile())
713 {
714 MessageBox.Show("Failed to Export Patch List to File.", "Export Failure", MessageBoxButtons.OK, MessageBoxIcon.Error);
715 this.ThawResultsUpdate();
716 return;
717 }
718 else
719 {
720 MessageBox.Show("Succesfully Exported Patch List to File.", "Export Success", MessageBoxButtons.OK, MessageBoxIcon.Information);
721 this.ThawResultsUpdate();
722 return;
723 }
724 }
725
726 private void btnImportClipboard_Click(object sender, EventArgs e)
727 {
728 this.FreezeResultsUpdate();
729 if (!lstPatchList.ImportFromClipboard())
730 {
731 MessageBox.Show("Failed to Import Patch List from Clipboard.", "Import Failure", MessageBoxButtons.OK, MessageBoxIcon.Error);
732 this.ThawResultsUpdate();
733 return;
734 }
735 else
736 {
737 MessageBox.Show("Succesfully Import Patch List from Clipboard.", "Import Success", MessageBoxButtons.OK, MessageBoxIcon.Information);
738 this.ThawResultsUpdate();
739 }
740 }
741
742 private void btnExportClipboard_Click(object sender, EventArgs e)
743 {
744 this.FreezeResultsUpdate();
745 if (!lstPatchList.ExportToClipboard())
746 {
747 MessageBox.Show("Failed to Export Patch List to Clipboard.", "Export Failure", MessageBoxButtons.OK, MessageBoxIcon.Error);
748 this.ThawResultsUpdate();
749 return;
750 }
751 else
752 {
753 MessageBox.Show("Succesfully Exported Patch List to Clipboard.", "Export Success", MessageBoxButtons.OK, MessageBoxIcon.Information);
754 this.ThawResultsUpdate();
755 return;
756 }
757 }
758
759 private void btnAddPatchAddress_Click(object sender, EventArgs e)
760 {
761 PatchAdder adder = new PatchAdder((IAcceptsProcessAndConfig)this);
762 adder.ShowDialog();
763 if (adder.WasAPatchAdded) AddToPatchList(adder.AddedPatchValue);
764 }
765
766 private void btnAddAddressRange_Click(object sender, EventArgs e)
767 {
768 PatchRangeAdder adder = new PatchRangeAdder((IAcceptsProcessAndConfig)this);
769 adder.ShowDialog();
770 if (adder.WasAPatchAdded) AddToPatchList(adder.AddedPatchValue);
771 }
772 private void AddToPatchList(List<ResultDataType> item) { foreach (ResultDataType data in item) { AddToPatchList(data); } }
773 private void AddToPatchList(ResultDataType item)
774 {
775 ResultItem item2 = null;
776 switch (item.ValueType)
777 {
778 case SearchDataTypes._8bits:
779 if (item.IsUnsigned) { item2 = new ResultItem(item.Address, item.IsFrozen, Convert.ToByte(item.Value)); }
780 else { item2 = new ResultItem(item.Address, item.IsFrozen, Convert.ToSByte(item.Value)); }
781 break;
782 case SearchDataTypes._16bits:
783 if (item.IsUnsigned) { item2 = new ResultItem(item.Address, item.IsFrozen, Convert.ToUInt16(item.Value)); }
784 else { item2 = new ResultItem(item.Address, item.IsFrozen, Convert.ToInt16(item.Value)); }
785 break;
786 case SearchDataTypes._32bits:
787 if (item.IsUnsigned) { item2 = new ResultItem(item.Address, item.IsFrozen, Convert.ToUInt32(item.Value)); }
788 else { item2 = new ResultItem(item.Address, item.IsFrozen, Convert.ToInt32(item.Value)); }
789 break;
790 case SearchDataTypes._64bits:
791 if (item.IsUnsigned) { item2 = new ResultItem(item.Address, item.IsFrozen, Convert.ToUInt64(item.Value)); }
792 else { item2 = new ResultItem(item.Address, item.IsFrozen, Convert.ToInt64(item.Value)); }
793 break;
794 }
795 this.AddToPatchList(item2);
796 }
797 private void AddToPatchList(ListViewItem item)
798 {
799 try
800 {
801 ResultDataType _result = (ResultDataType)item.Tag;
802 this.AddToPatchList(_result);
803 }
804 catch (InvalidCastException ex)
805 {
806 // unable to cast
807 MessageBox.Show(ex.Message, "Invalid Cast Exception", MessageBoxButtons.OK, MessageBoxIcon.Error);
808 }
809 catch (Exception ex)
810 {
811 // other exception
812 MessageBox.Show(ex.Message, "Unhandled Exception", MessageBoxButtons.OK, MessageBoxIcon.Error);
813 }
814 }
815 private void AddToPatchList(ResultItem item)
816 {
817 if (!lstPatchList.Items.Contains(item)) lstPatchList.Items.Add(item);
818 }
819 private void AddToPatchList(string address, SearchDataTypes bitsize, bool IsUnsigned)
820 {
821 ResultItemState state = new ResultItemState(address, bitsize, IsUnsigned, (IAcceptsProcessAndConfig)this);
822 ResultItem item = new ResultItem(state.Address, state.Value, state.Frozen, state.ValueType, state.IsUnsigned);
823 this.AddToPatchList(item);
824 }
825
826 private void mnuItemAddToPatchList_Click(object sender, EventArgs e)
827 {
828 if (!(lstResults.SelectedItems.Count > 0)) return;
829 //if (SearchArgs == null) return;
830
831 try
832 {
833 for (int i = 0; i < lstResults.SelectedIndices.Count; i++)
834 {
835 //ResultDataType result = (ResultDataType)lstResults.Items[selected_index].Tag;
836 ListViewItem item = lstResults.Items[lstResults.SelectedIndices[i]];
837 this.AddToPatchList(item);
838 }
839 }
840 catch (Exception ex)
841 {
842 logger.Error.WriteLine(ex.ToString());
843 }
844 }
845
846 private void mnuItemRemoveResult_Click(object sender, EventArgs e)
847 {
848 if (!(lstPatchList.SelectedItems.Count > 0)) return;
849 //if (SearchArgs == null) return;
850 try
851 {
852 this.FreezeResultsUpdate();
853 for (int i = 0; i < lstPatchList.SelectedIndices.Count; i++)
854 {
855 //lstPatchList.ThawItem(lstPatchList.SelectedIndices[i]);
856 lstPatchList.Items[lstPatchList.SelectedIndices[i]].Remove();
857 }
858 this.ThawResultsUpdate();
859 }
860 catch (Exception ex)
861 {
862 Debug.WriteLine(ex.ToString());
863 }
864 }
865 private void PatchRange(bool SingleEntry)
866 {
867 //if (SearchArgs == null) return;
868 #region Patch Selected Address
869 // stop ResultsUpdate Thread
870 ResultsUpdateWorkerThread.CancelAsync();
871
872 List<ResultDataType> patch_list = new List<ResultDataType>();
873 List<int> SelectedIndexes = new List<int>();
874
875 if (SingleEntry)
876 {
877 SelectedIndexes.Add(lstPatchList.SelectedIndices[0]);
878 }
879 else
880 {
881 foreach (int index in lstPatchList.SelectedIndices)
882 {
883 SelectedIndexes.Add(index);
884 }
885 }
886 //PCSX2MemoryProvider provider = new PCSX2MemoryProvider(this.SearchPCSX2ProcessPID, resultslog);
887 foreach (int index in SelectedIndexes)
888 {
889 if (SingleEntry)
890 {
891 SearchPatcher patcher = null;
892 uint Address = 0;
893 ListViewItem item = lstPatchList.Items[index];
894 ResultDataType _result = (ResultDataType)item.Tag;
895 Address = Convert.ToUInt32(item.SubItems[col_Found_Address].Text, 16);
896 switch (_result.ValueType)
897 {
898 case SearchDataTypes._8bits:
899 if (_result.IsUnsigned)
900 {
901 byte value = Convert.ToByte(item.SubItems[col_Found_Value].Text, 16);
902 patcher = new SearchPatcher((IAcceptsProcessAndConfig)this, Address, value);
903 timer_update_results.Enabled = false;
904 patcher.ShowDialog();
905 timer_update_results.Enabled = true;
906 PatchedValue_NeedsUpdate = true;
907 if (!chkRefreshResults.Checked && !ResultsUpdateWorkerThread.IsBusy)
908 ResultsUpdateWorkerThread.RunWorkerAsync();
909 }
910 else
911 {
912 sbyte value = Convert.ToSByte(item.SubItems[col_Found_Value].Text, 16);
913 patcher = new SearchPatcher((IAcceptsProcessAndConfig)this, Address, value);
914 timer_update_results.Enabled = false;
915 patcher.ShowDialog();
916 timer_update_results.Enabled = true;
917 PatchedValue_NeedsUpdate = true;
918 if (!chkRefreshResults.Checked && !ResultsUpdateWorkerThread.IsBusy)
919 ResultsUpdateWorkerThread.RunWorkerAsync();
920 }
921 break;
922 case SearchDataTypes._16bits:
923 if (_result.IsUnsigned)
924 {
925 ushort value = Convert.ToUInt16(item.SubItems[col_Found_Value].Text, 16);
926 patcher = new SearchPatcher((IAcceptsProcessAndConfig)this, Address, value);
927 timer_update_results.Enabled = false;
928 patcher.ShowDialog();
929 timer_update_results.Enabled = true;
930 PatchedValue_NeedsUpdate = true;
931 if (!chkRefreshResults.Checked && !ResultsUpdateWorkerThread.IsBusy)
932 ResultsUpdateWorkerThread.RunWorkerAsync();
933 }
934 else
935 {
936 short value = Convert.ToInt16(item.SubItems[col_Found_Value].Text, 16);
937 patcher = new SearchPatcher((IAcceptsProcessAndConfig)this, Address, value);
938 timer_update_results.Enabled = false;
939 patcher.ShowDialog();
940 timer_update_results.Enabled = true;
941 PatchedValue_NeedsUpdate = true;
942 if (!chkRefreshResults.Checked && !ResultsUpdateWorkerThread.IsBusy)
943 ResultsUpdateWorkerThread.RunWorkerAsync();
944 }
945 break;
946 case SearchDataTypes._32bits:
947 if (_result.IsUnsigned)
948 {
949 uint value = Convert.ToUInt32(item.SubItems[col_Found_Value].Text, 16);
950 patcher = new SearchPatcher((IAcceptsProcessAndConfig)this, Address, value);
951 timer_update_results.Enabled = false;
952 patcher.ShowDialog();
953 timer_update_results.Enabled = true;
954 PatchedValue_NeedsUpdate = true;
955 if (!chkRefreshResults.Checked && !ResultsUpdateWorkerThread.IsBusy)
956 ResultsUpdateWorkerThread.RunWorkerAsync();
957 }
958 else
959 {
960 int value = Convert.ToInt32(item.SubItems[col_Found_Value].Text, 16);
961 patcher = new SearchPatcher((IAcceptsProcessAndConfig)this, Address, value);
962 timer_update_results.Enabled = false;
963 patcher.ShowDialog();
964 timer_update_results.Enabled = true;
965 PatchedValue_NeedsUpdate = true;
966 if (!chkRefreshResults.Checked && !ResultsUpdateWorkerThread.IsBusy)
967 ResultsUpdateWorkerThread.RunWorkerAsync();
968 }
969 break;
970 case SearchDataTypes._64bits:
971 if (_result.IsUnsigned)
972 {
973 ulong value = Convert.ToUInt32(item.SubItems[col_Found_Value].Text, 16);
974 patcher = new SearchPatcher((IAcceptsProcessAndConfig)this, Address, value);
975 timer_update_results.Enabled = false;
976 patcher.ShowDialog();
977 timer_update_results.Enabled = true;
978 PatchedValue_NeedsUpdate = true;
979 if (!chkRefreshResults.Checked && !ResultsUpdateWorkerThread.IsBusy)
980 ResultsUpdateWorkerThread.RunWorkerAsync();
981 }
982 else
983 {
984 long value = Convert.ToInt32(item.SubItems[col_Found_Value].Text, 16);
985 patcher = new SearchPatcher((IAcceptsProcessAndConfig)this, Address, value);
986 timer_update_results.Enabled = false;
987 patcher.ShowDialog();
988 timer_update_results.Enabled = true;
989 PatchedValue_NeedsUpdate = true;
990 if (!chkRefreshResults.Checked && !ResultsUpdateWorkerThread.IsBusy)
991 ResultsUpdateWorkerThread.RunWorkerAsync();
992 }
993 break;
994 }
995 }
996 else
997 {
998
999 ListViewItem item = lstPatchList.Items[index];
1000 ResultDataType _result = (ResultDataType)item.Tag;
1001 patch_list.Add(_result);
1002 }
1003 }
1004
1005 if (patch_list.Count > 0)
1006 {
1007 SearchRangePatcher rangePatcher = new SearchRangePatcher((IAcceptsProcessAndConfig)this, patch_list);
1008 rangePatcher.ShowDialog();
1009 }
1010
1011 #endregion
1012 }
1013 private void mnuItemPatchSelectedEntry_Click(object sender, EventArgs e)
1014 {
1015 if (!(lstPatchList.SelectedItems.Count == 1)) return;
1016 PatchRange(true);
1017 }
1018
1019 private void mnuItemPatchSelectedRange_Click(object sender, EventArgs e)
1020 {
1021 if (!(lstPatchList.SelectedItems.Count >= 1)) return;
1022 PatchRange(false);
1023 }
1024
1025 private void mnuItemFreezeSelectedPatches_Click(object sender, EventArgs e)
1026 {
1027 if (!(lstPatchList.SelectedItems.Count > 0)) return;
1028 //if (SearchArgs == null) return;
1029 try
1030 {
1031 lstPatchList.ProcessID = this.AcceptedProcess.Id;
1032 this.FreezeResultsUpdate();
1033 for (int i = 0; i < lstPatchList.SelectedIndices.Count; i++)
1034 {
1035 lstPatchList.FreezeItem(lstPatchList.SelectedIndices[i]);
1036 }
1037 // force thaw and update
1038 this.ThawResultsUpdate();
1039 this.Update();
1040 }
1041 catch (Exception ex)
1042 {
1043 Debug.WriteLine(ex.ToString());
1044 }
1045 }
1046
1047 private void mnuItemThawSelectedPatches_Click(object sender, EventArgs e)
1048 {
1049 if (!(lstPatchList.SelectedItems.Count > 0)) return;
1050 //if (SearchArgs == null) return;
1051 try
1052 {
1053 lstPatchList.ProcessID = this.AcceptedProcess.Id;
1054 this.FreezeResultsUpdate();
1055 for (int i = 0; i < lstPatchList.SelectedIndices.Count; i++)
1056 {
1057 lstPatchList.ThawItem(lstPatchList.SelectedIndices[i]);
1058 }
1059 // force thaw and update
1060 this.ThawResultsUpdate();
1061 this.Update();
1062 }
1063 catch (Exception ex)
1064 {
1065 Debug.WriteLine(ex.ToString());
1066 }
1067 }
1068
1069 #region old-code: private void search_provider_OnBytesRead_compare_only(OnBytesReadEventArgs e)
1070 //private void search_provider_OnBytesRead_compare_only(OnBytesReadEventArgs e)
1071 //{
1072 // if (SearchWorkerThread.CancellationPending) { e.Canceled = true; return; }
1073 // SearchDataTypes sdt = SearchArgs.DataType;
1074 // bool unsigned = SearchArgs.IsUnsignedDataType;
1075 // //int Last_Whole_Percent_Done = 0;
1076 // uint CurrentIndex = e.CurrentIndex;
1077 // if (e.UserState != null)
1078 // {
1079 // SearchResultWriter writer = (e.UserState as SearchResultWriter);
1080 // if (writer == null)
1081 // throw new InvalidOperationException("writer cannot be null");
1082 // using (MemoryStream ms = new MemoryStream(e.Data))
1083 // {
1084 // using (BinaryReader br = new BinaryReader(ms))
1085 // {
1086 // while (br.BaseStream.Position < br.BaseStream.Length)
1087 // {
1088 // try
1089 // {
1090 // switch (sdt)
1091 // {
1092 // case SearchDataTypes._8bits:
1093 // if (unsigned)
1094 // {
1095 // #region 8bits - unsigned
1096 // var Value = br.ReadByte();
1097 // using (_8bit_unsigned_comparer_ comparer = new _8bit_unsigned_comparer_(SearchArgs, CurrentIndex))
1098 // {
1099 // byte value = 0;
1100 // if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1101 // {
1102 // using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1103 // {
1104 // try
1105 // {
1106 // gmp.OpenProvider();
1107 // gmp.ReadMemory(CurrentIndex, out value);
1108 // gmp.CloseProvider();
1109 // }
1110 // catch (Exception ex)
1111 // {
1112 // logger.VerboseError.WriteLine(ex.ToString());
1113 // }
1114 // }
1115 // comparer.Value = value;
1116 // }
1117 // else
1118 // {
1119 // value = Convert.ToByte(SearchArgs.CompareStartValue);
1120 // comparer.Value = value;
1121 // }
1122 // if (comparer.Compare(Convert.ToByte(Value), value))
1123 // {
1124 // writer.WriteResult<byte>(comparer.Address, comparer.Value);
1125 // }
1126 // }
1127 // #endregion
1128 // }
1129 // else
1130 // {
1131 // #region 8bits - signed
1132 // var Value = br.ReadSByte();
1133 // using (_8bit_signed_comparer_ comparer = new _8bit_signed_comparer_(SearchArgs, CurrentIndex))
1134 // {
1135 // sbyte value = 0;
1136 // if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1137 // {
1138 // using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1139 // {
1140 // try
1141 // {
1142 // gmp.OpenProvider();
1143 // gmp.ReadMemory(CurrentIndex, out value);
1144 // gmp.CloseProvider();
1145 // }
1146 // catch (Exception ex)
1147 // {
1148 // logger.VerboseError.WriteLine(ex.ToString());
1149 // }
1150 // }
1151 // comparer.Value = value;
1152 // }
1153 // else
1154 // {
1155 // value = Convert.ToSByte(SearchArgs.CompareStartValue);
1156 // comparer.Value = value;
1157 // }
1158 // if (comparer.Compare(Convert.ToSByte(Value), value))
1159 // {
1160 // writer.WriteResult<sbyte>(comparer.Address, comparer.Value);
1161 // }
1162 // }
1163 // #endregion
1164 // } break;
1165 // case SearchDataTypes._16bits:
1166 // if (unsigned)
1167 // {
1168 // #region 16bits - unsigned
1169 // var Value = br.ReadUInt16();
1170 // using (_16bit_unsigned_comparer_ comparer = new _16bit_unsigned_comparer_(SearchArgs, CurrentIndex))
1171 // {
1172 // ushort value = 0;
1173 // if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1174 // {
1175 // using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1176 // {
1177 // try
1178 // {
1179 // gmp.OpenProvider();
1180 // gmp.ReadMemory(CurrentIndex, out value);
1181 // gmp.CloseProvider();
1182 // }
1183 // catch (Exception ex)
1184 // {
1185 // logger.VerboseError.WriteLine(ex.ToString());
1186 // }
1187 // }
1188 // comparer.Value = value;
1189 // }
1190 // else
1191 // {
1192 // value = Convert.ToUInt16(SearchArgs.CompareStartValue);
1193 // comparer.Value = value;
1194 // }
1195 // if (comparer.Compare(Convert.ToUInt16(Value), value))
1196 // {
1197 // writer.WriteResult<ushort>(comparer.Address, comparer.Value);
1198 // }
1199 // }
1200 // #endregion
1201 // }
1202 // else
1203 // {
1204 // #region 16bits - signed
1205 // var Value = br.ReadInt16();
1206 // using (_16bit_signed_comparer_ comparer = new _16bit_signed_comparer_(SearchArgs, CurrentIndex))
1207 // {
1208 // short value = 0;
1209 // if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1210 // {
1211 // using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1212 // {
1213 // try
1214 // {
1215 // gmp.OpenProvider();
1216 // gmp.ReadMemory(CurrentIndex, out value);
1217 // gmp.CloseProvider();
1218 // }
1219 // catch (Exception ex)
1220 // {
1221 // logger.VerboseError.WriteLine(ex.ToString());
1222 // }
1223 // }
1224 // comparer.Value = value;
1225 // }
1226 // else
1227 // {
1228 // value = Convert.ToInt16(SearchArgs.CompareStartValue);
1229 // comparer.Value = value;
1230 // }
1231 // if (comparer.Compare(Convert.ToSByte(Value), value))
1232 // {
1233 // writer.WriteResult<short>(comparer.Address, comparer.Value);
1234 // }
1235 // }
1236 // #endregion
1237 // } break;
1238 // case SearchDataTypes._32bits:
1239 // if (unsigned)
1240 // {
1241 // #region 32bits - unsigned
1242 // var Value = br.ReadUInt32();
1243 // using (_32bit_unsigned_comparer_ comparer = new _32bit_unsigned_comparer_(SearchArgs, CurrentIndex))
1244 // {
1245 // uint value = 0;
1246 // if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1247 // {
1248 // using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1249 // {
1250 // try
1251 // {
1252 // gmp.OpenProvider();
1253 // gmp.ReadMemory(CurrentIndex, out value);
1254 // gmp.CloseProvider();
1255 // }
1256 // catch (Exception ex)
1257 // {
1258 // logger.VerboseError.WriteLine(ex.ToString());
1259 // }
1260 // }
1261 // comparer.Value = value;
1262 // }
1263 // else
1264 // {
1265 // value = Convert.ToUInt32(SearchArgs.CompareStartValue);
1266 // comparer.Value = value;
1267 // }
1268 // if (comparer.Compare(Convert.ToUInt32(Value), value))
1269 // {
1270 // writer.WriteResult<uint>(comparer.Address, comparer.Value);
1271 // }
1272 // }
1273 // #endregion
1274 // }
1275 // else
1276 // {
1277 // #region 32bits - signed
1278 // var Value = br.ReadInt32();
1279 // using (_32bit_signed_comparer_ comparer = new _32bit_signed_comparer_(SearchArgs, CurrentIndex))
1280 // {
1281 // int value = 0;
1282 // if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1283 // {
1284 // using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1285 // {
1286 // try
1287 // {
1288 // gmp.OpenProvider();
1289 // gmp.ReadMemory(CurrentIndex, out value);
1290 // gmp.CloseProvider();
1291 // }
1292 // catch (Exception ex)
1293 // {
1294 // logger.VerboseError.WriteLine(ex.ToString());
1295 // }
1296 // }
1297 // comparer.Value = value;
1298 // }
1299 // else
1300 // {
1301 // value = Convert.ToInt32(SearchArgs.CompareStartValue);
1302 // comparer.Value = value;
1303 // }
1304 // if (comparer.Compare(Convert.ToInt32(Value), value))
1305 // {
1306 // writer.WriteResult<int>(comparer.Address, comparer.Value);
1307 // }
1308 // }
1309 // #endregion
1310 // } break;
1311 // case SearchDataTypes._64bits:
1312 // if (unsigned)
1313 // {
1314 // #region 64bits - unsigned
1315 // var Value = br.ReadUInt64();
1316 // using (_64bit_unsigned_comparer_ comparer = new _64bit_unsigned_comparer_(SearchArgs, CurrentIndex))
1317 // {
1318 // ulong value = 0;
1319 // if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1320 // {
1321 // using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1322 // {
1323 // try
1324 // {
1325 // gmp.OpenProvider();
1326 // gmp.ReadMemory(CurrentIndex, out value);
1327 // gmp.CloseProvider();
1328 // }
1329 // catch (Exception ex)
1330 // {
1331 // logger.VerboseError.WriteLine(ex.ToString());
1332 // }
1333 // }
1334 // comparer.Value = value;
1335 // }
1336 // else
1337 // {
1338 // value = Convert.ToUInt64(SearchArgs.CompareStartValue);
1339 // comparer.Value = value;
1340 // }
1341 // if (comparer.Compare(Convert.ToUInt64(Value), value))
1342 // {
1343 // writer.WriteResult<ulong>(comparer.Address, comparer.Value);
1344 // }
1345 // }
1346 // #endregion
1347 // }
1348 // else
1349 // {
1350 // #region 64bits - signed
1351 // var Value = br.ReadInt64();
1352 // using (_64bit_signed_comparer_ comparer = new _64bit_signed_comparer_(SearchArgs, CurrentIndex))
1353 // {
1354 // long value = 0;
1355 // if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1356 // {
1357 // using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1358 // {
1359 // try
1360 // {
1361 // gmp.OpenProvider();
1362 // gmp.ReadMemory(CurrentIndex, out value);
1363 // gmp.CloseProvider();
1364 // }
1365 // catch (Exception ex)
1366 // {
1367 // logger.VerboseError.WriteLine(ex.ToString());
1368 // }
1369 // }
1370 // comparer.Value = value;
1371 // }
1372 // else
1373 // {
1374 // value = Convert.ToInt64(SearchArgs.CompareStartValue);
1375 // comparer.Value = value;
1376 // }
1377 // if (comparer.Compare(Convert.ToInt64(Value), value))
1378 // {
1379 // writer.WriteResult<long>(comparer.Address, comparer.Value);
1380 // }
1381 // }
1382 // #endregion
1383 // } break;
1384 // }
1385 // if (SearchWorkerThread.CancellationPending) { e.Canceled = true; return; }
1386 // }
1387 // catch (EndOfStreamException) { }
1388 // if (e.ReportProgress)
1389 // {
1390 // double double_percent_done = 100.0 * (double)((double)CurrentIndex / (double)e.TotalCount);
1391 // int int_percent_done = (int)double_percent_done;
1392 // //if (CurrentIndex % 10 == 0)
1393 // //{
1394 // // if (int_percent_done <= 100)
1395 // // {
1396 // new Action<int, string>(UpdateProgress).Invoke(int_percent_done, string.Format(" -> Reading Index: 0x{0:x8} of 0x{1:x8}", CurrentIndex, e.TotalCount));
1397 // // }
1398 // // if (SearchWorkerThread.CancellationPending) { e.Canceled = true; return; }
1399 // //}
1400 // }
1401 // //switch (sdt)
1402 // //{
1403 // // case SearchDataTypes._8bits:
1404 // // CurrentIndex += sizeof(byte);
1405 // // break;
1406 // // case SearchDataTypes._16bits:
1407 // // CurrentIndex += sizeof(ushort);
1408 // // break;
1409 // // case SearchDataTypes._32bits:
1410 // // CurrentIndex += sizeof(uint);
1411 // // break;
1412 // // case SearchDataTypes._64bits:
1413 // // CurrentIndex += sizeof(ulong);
1414 // // break;
1415 // //}
1416 // }
1417 // }
1418 // }
1419 // }
1420 // if (SearchWorkerThread.CancellationPending) { e.Canceled = true; return; }
1421 //}
1422 #endregion
1423
1424 #region old-code: private void search_provider_OnBytesRead(OnBytesReadEventArgs e)
1425 //private void search_provider_OnBytesRead(OnBytesReadEventArgs e)
1426 //{
1427 // if (SearchWorkerThread.CancellationPending) { e.Canceled = true; return; }
1428 // SearchDataTypes sdt = SearchArgs.DataType;
1429 // bool unsigned = SearchArgs.IsUnsignedDataType;
1430 // int Last_Whole_Percent_Done = 0;
1431 // uint CurrentIndex = e.CurrentIndex;
1432 // if (e.UserState != null)
1433 // {
1434 // SearchResultWriter writer = (e.UserState as SearchResultWriter);
1435 // if (writer == null)
1436 // throw new InvalidOperationException("writer cannot be null");
1437 // using (MemoryStream ms = new MemoryStream(e.Data))
1438 // {
1439 // using (BinaryReader br = new BinaryReader(ms))
1440 // {
1441 // while (br.BaseStream.Position < br.BaseStream.Length)
1442 // {
1443 // try
1444 // {
1445 // //if (e.ReportProgress)
1446 // //{
1447 // // double double_percent_done = 100.0 * (double)((double)CurrentIndex / (double)e.TotalCount);
1448 // // int int_percent_done = (int)double_percent_done;
1449 // // int align_base = 100;
1450 // // int align_power = 1;
1451 // // int align = align_base * align_power;
1452 // // if (int_percent_done != Last_Whole_Percent_Done && (CurrentIndex % align) == 0)
1453 // // {
1454 // // string message = string.Format(" -> Reading Address: 0x{0:x8}", (CurrentIndex + MemoryRangeStart));
1455 // // UpdateProgress((int)double_percent_done, message);
1456 // // //new Action<int, string>(UpdateProgress).Invoke(int_percent_done, message);
1457 // // Last_Whole_Percent_Done = int_percent_done;
1458 // // if (SearchWorkerThread.CancellationPending) { e.Canceled = true; return; }
1459 // // }
1460 // //}
1461
1462 // switch (sdt)
1463 // {
1464 // case SearchDataTypes._8bits:
1465 // if (unsigned)
1466 // {
1467 // #region 8bits - unsigned
1468 // var Value = br.ReadByte();
1469 // using (_8bit_unsigned_comparer_ comparer = new _8bit_unsigned_comparer_(SearchArgs, CurrentIndex))
1470 // {
1471 // byte value = 0;
1472 // if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1473 // {
1474 // using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1475 // {
1476 // try
1477 // {
1478 // gmp.OpenProvider();
1479 // gmp.ReadMemory(CurrentIndex, out value);
1480 // gmp.CloseProvider();
1481 // }
1482 // catch (Exception ex)
1483 // {
1484 // logger.VerboseError.WriteLine(ex.ToString());
1485 // }
1486 // }
1487 // comparer.Value = value;
1488 // }
1489 // else
1490 // {
1491 // value = Convert.ToByte(SearchArgs.CompareStartValue);
1492 // comparer.Value = value;
1493 // }
1494 // if (comparer.Compare(Convert.ToByte(Value), value))
1495 // {
1496 // writer.WriteResult<byte>(comparer.Address, comparer.Value);
1497 // }
1498 // }
1499 // #endregion
1500 // }
1501 // else
1502 // {
1503 // #region 8bits - signed
1504 // var Value = br.ReadSByte();
1505 // using (_8bit_signed_comparer_ comparer = new _8bit_signed_comparer_(SearchArgs, CurrentIndex))
1506 // {
1507 // sbyte value = 0;
1508 // if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1509 // {
1510 // using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1511 // {
1512 // try
1513 // {
1514 // gmp.OpenProvider();
1515 // gmp.ReadMemory(CurrentIndex, out value);
1516 // gmp.CloseProvider();
1517 // }
1518 // catch (Exception ex)
1519 // {
1520 // logger.VerboseError.WriteLine(ex.ToString());
1521 // }
1522 // }
1523 // comparer.Value = value;
1524 // }
1525 // else
1526 // {
1527 // value = Convert.ToSByte(SearchArgs.CompareStartValue);
1528 // comparer.Value = value;
1529 // }
1530 // if (comparer.Compare(Convert.ToSByte(Value), value))
1531 // {
1532 // writer.WriteResult<sbyte>(comparer.Address, comparer.Value);
1533 // }
1534 // }
1535 // #endregion
1536 // } break;
1537 // case SearchDataTypes._16bits:
1538 // if (unsigned)
1539 // {
1540 // #region 16bits - unsigned
1541 // var Value = br.ReadUInt16();
1542 // using (_16bit_unsigned_comparer_ comparer = new _16bit_unsigned_comparer_(SearchArgs, CurrentIndex))
1543 // {
1544 // ushort value = 0;
1545 // if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1546 // {
1547 // using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1548 // {
1549 // try
1550 // {
1551 // gmp.OpenProvider();
1552 // gmp.ReadMemory(CurrentIndex, out value);
1553 // gmp.CloseProvider();
1554 // }
1555 // catch (Exception ex)
1556 // {
1557 // logger.VerboseError.WriteLine(ex.ToString());
1558 // }
1559 // }
1560 // comparer.Value = value;
1561 // }
1562 // else
1563 // {
1564 // value = Convert.ToUInt16(SearchArgs.CompareStartValue);
1565 // comparer.Value = value;
1566 // }
1567 // if (comparer.Compare(Convert.ToUInt16(Value), value))
1568 // {
1569 // writer.WriteResult<ushort>(comparer.Address, comparer.Value);
1570 // }
1571 // }
1572 // #endregion
1573 // }
1574 // else
1575 // {
1576 // #region 16bits - signed
1577 // var Value = br.ReadInt16();
1578 // using (_16bit_signed_comparer_ comparer = new _16bit_signed_comparer_(SearchArgs, CurrentIndex))
1579 // {
1580 // short value = 0;
1581 // if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1582 // {
1583 // using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1584 // {
1585 // try
1586 // {
1587 // gmp.OpenProvider();
1588 // gmp.ReadMemory(CurrentIndex, out value);
1589 // gmp.CloseProvider();
1590 // }
1591 // catch (Exception ex)
1592 // {
1593 // logger.VerboseError.WriteLine(ex.ToString());
1594 // }
1595 // }
1596 // comparer.Value = value;
1597 // }
1598 // else
1599 // {
1600 // value = Convert.ToInt16(SearchArgs.CompareStartValue);
1601 // comparer.Value = value;
1602 // }
1603 // if (comparer.Compare(Convert.ToSByte(Value), value))
1604 // {
1605 // writer.WriteResult<short>(comparer.Address, comparer.Value);
1606 // }
1607 // }
1608 // #endregion
1609 // } break;
1610 // case SearchDataTypes._32bits:
1611 // if (unsigned)
1612 // {
1613 // #region 32bits - unsigned
1614 // var Value = br.ReadUInt32();
1615 // using (_32bit_unsigned_comparer_ comparer = new _32bit_unsigned_comparer_(SearchArgs, CurrentIndex))
1616 // {
1617 // uint value = 0;
1618 // if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1619 // {
1620 // using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1621 // {
1622 // try
1623 // {
1624 // gmp.OpenProvider();
1625 // gmp.ReadMemory(CurrentIndex, out value);
1626 // gmp.CloseProvider();
1627 // }
1628 // catch (Exception ex)
1629 // {
1630 // logger.VerboseError.WriteLine(ex.ToString());
1631 // }
1632 // }
1633 // comparer.Value = value;
1634 // }
1635 // else
1636 // {
1637 // value = Convert.ToUInt32(SearchArgs.CompareStartValue);
1638 // comparer.Value = value;
1639 // }
1640 // if (comparer.Compare(Convert.ToUInt32(Value), value))
1641 // {
1642 // writer.WriteResult<uint>(comparer.Address, comparer.Value);
1643 // }
1644 // }
1645 // #endregion
1646 // }
1647 // else
1648 // {
1649 // #region 32bits - signed
1650 // var Value = br.ReadInt32();
1651 // using (_32bit_signed_comparer_ comparer = new _32bit_signed_comparer_(SearchArgs, CurrentIndex))
1652 // {
1653 // int value = 0;
1654 // if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1655 // {
1656 // using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1657 // {
1658 // try
1659 // {
1660 // gmp.OpenProvider();
1661 // gmp.ReadMemory(CurrentIndex, out value);
1662 // gmp.CloseProvider();
1663 // }
1664 // catch (Exception ex)
1665 // {
1666 // logger.VerboseError.WriteLine(ex.ToString());
1667 // }
1668 // }
1669 // comparer.Value = value;
1670 // }
1671 // else
1672 // {
1673 // value = Convert.ToInt32(SearchArgs.CompareStartValue);
1674 // comparer.Value = value;
1675 // }
1676 // if (comparer.Compare(Convert.ToInt32(Value), value))
1677 // {
1678 // writer.WriteResult<int>(comparer.Address, comparer.Value);
1679 // }
1680 // }
1681 // #endregion
1682 // } break;
1683 // case SearchDataTypes._64bits:
1684 // if (unsigned)
1685 // {
1686 // #region 64bits - unsigned
1687 // var Value = br.ReadUInt64();
1688 // using (_64bit_unsigned_comparer_ comparer = new _64bit_unsigned_comparer_(SearchArgs, CurrentIndex))
1689 // {
1690 // ulong value = 0;
1691 // if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1692 // {
1693 // using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1694 // {
1695 // try
1696 // {
1697 // gmp.OpenProvider();
1698 // gmp.ReadMemory(CurrentIndex, out value);
1699 // gmp.CloseProvider();
1700 // }
1701 // catch (Exception ex)
1702 // {
1703 // logger.VerboseError.WriteLine(ex.ToString());
1704 // }
1705 // }
1706 // comparer.Value = value;
1707 // }
1708 // else
1709 // {
1710 // value = Convert.ToUInt64(SearchArgs.CompareStartValue);
1711 // comparer.Value = value;
1712 // }
1713 // if (comparer.Compare(Convert.ToUInt64(Value), value))
1714 // {
1715 // writer.WriteResult<ulong>(comparer.Address, comparer.Value);
1716 // }
1717 // }
1718 // #endregion
1719 // }
1720 // else
1721 // {
1722 // #region 64bits - signed
1723 // var Value = br.ReadInt64();
1724 // using (_64bit_signed_comparer_ comparer = new _64bit_signed_comparer_(SearchArgs, CurrentIndex))
1725 // {
1726 // long value = 0;
1727 // if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1728 // {
1729 // using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1730 // {
1731 // try
1732 // {
1733 // gmp.OpenProvider();
1734 // gmp.ReadMemory(CurrentIndex, out value);
1735 // gmp.CloseProvider();
1736 // }
1737 // catch (Exception ex)
1738 // {
1739 // logger.VerboseError.WriteLine(ex.ToString());
1740 // }
1741 // }
1742 // comparer.Value = value;
1743 // }
1744 // else
1745 // {
1746 // value = Convert.ToInt64(SearchArgs.CompareStartValue);
1747 // comparer.Value = value;
1748 // }
1749 // if (comparer.Compare(Convert.ToInt64(Value), value))
1750 // {
1751 // writer.WriteResult<long>(comparer.Address, comparer.Value);
1752 // }
1753 // }
1754 // #endregion
1755 // } break;
1756 // }
1757 // if (SearchWorkerThread.CancellationPending) { e.Canceled = true; return; }
1758 // }
1759 // catch (EndOfStreamException) { }
1760
1761 // uint size = 0;
1762 // BitTools.SizeOf(sdt, out size);
1763 // CurrentIndex += size;
1764 // }
1765 // }
1766 // }
1767 // }
1768 // if (SearchWorkerThread.CancellationPending) { e.Canceled = true; return; }
1769 //}
1770 #endregion
1771
1772 private void SearchWorkerThread_DoWork(object sender, DoWorkEventArgs e)
1773 {
1774 try
1775 {
1776 Stopwatch st = new Stopwatch();
1777 st.Start();
1778
1779 Stopwatch st_first_search = new Stopwatch();
1780 Stopwatch st_nonrange_search = new Stopwatch();
1781 Stopwatch st_ranged_search = new Stopwatch();
1782
1783 e.Result = st;
1784 //List<ResultType<object>> tmp_Results = new List<ResultType<object>>();
1785 List<ResultType<ulong>> second_tmp_Results = new List<ResultType<ulong>>();
1786 //const int ElementsBeforeDisplay = 100;
1787 SearchArgs.LogSearchOptions();
1788 uint STEP_SIZE = (uint)SearchArgs.DataType / 8;
1789
1790 bool unsigned = SearchArgs.IsUnsignedDataType;
1791 SearchDataTypes sdt = SearchArgs.DataType;
1792 //byte[] buffered_mem = new byte[(MemoryRangeSize - MemoryRangeStart)]; // throws OutOfMemoryException if size is over 2G
1793 logger.Debug.WriteLine(string.Format("Buffered Memory Size -> 0x{0:x8}", MemoryRangeSize - MemoryRangeStart));
1794 UpdateProgress(0, string.Format("Search is Warming Up...Please Wait..."));
1795 //new Action<int, string>(UpdateProgress).Invoke(0, string.Format("Search is Warming Up...Please Wait..."));
1796 Stopwatch provider_st = new Stopwatch();
1797 provider_st.Start();
1798 using (GenericMemoryProvider provider = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1799 {
1800
1801 if (SearchArgs.IsFirstSearch)
1802 {
1803 provider.OpenProvider();
1804 int count = (int)((MemoryRangeSize - MemoryRangeStart) / STEP_SIZE);
1805 SearchResultWriter writer = new SearchResultWriter((int)(count), SearchGuid);
1806 //provider.OnBytesRead += new BaseEventHandler<OnBytesReadEventArgs>(search_provider_OnBytesRead);
1807 //provider.ReadProcessMemoryAtOnce(MemoryRangeStart, (MemoryRangeSize - MemoryRangeStart), writer);
1808
1809
1810 Stopwatch st_profiler = new Stopwatch();
1811 st_profiler.Start();
1812 int Last_Whole_Percent_Done = 0;
1813 uint size = STEP_SIZE * 4096;
1814 for (uint i = MemoryRangeStart; i < MemoryRangeSize; i+=size)
1815 {
1816
1817 int bytesRead=0;
1818 byte[] data = new byte[size];
1819 //provider.ReadProcessMemory(i, size, out bytesRead, out data);
1820
1821 provider.ReadProcessMemoryAtOnce(i, size, out bytesRead, out data);
1822
1823 //OnBytesReadEventArgs t_args = new OnBytesReadEventArgs(this, writer, data, i, MemoryRangeSize, true);
1824 //search_provider_OnBytesRead(t_args);
1825 //t_args = null;
1826
1827 string message = string.Format(" -> Reading Address: 0x{0:x8}", (i + MemoryRangeStart));
1828 double double_percent_done = 100.0 * (double)((double)i / (double)MemoryRangeSize);
1829 int int_percent_done = (int)double_percent_done;
1830 if ( (int_percent_done != Last_Whole_Percent_Done) && (i % 10000) == 0)
1831 {
1832 UpdateProgress((int)double_percent_done, message);
1833 logger.Profiler.WriteLine("Memory Search Operation Profiler: search operation has taken {0} seconds", st_profiler.Elapsed.TotalSeconds.ToString());
1834 Last_Whole_Percent_Done = int_percent_done;
1835 }
1836
1837
1838 #region comparison and serialization
1839 switch (sdt)
1840 {
1841 case SearchDataTypes._8bits:
1842 if (unsigned)
1843 {
1844 #region 8bits - unsigned
1845 var t_data = BitTools.ConvertByteArray<byte>(data);
1846 foreach (var Value in t_data)
1847 {
1848 if (SearchWorkerThread.CancellationPending) { break; }
1849 using (_8bit_unsigned_comparer_ comparer = new _8bit_unsigned_comparer_(SearchArgs, i))
1850 {
1851 byte value = 0;
1852 if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1853 {
1854 using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1855 {
1856 try
1857 {
1858 gmp.OpenProvider();
1859 gmp.ReadMemory(i, out value);
1860 gmp.CloseProvider();
1861 }
1862 catch (Exception ex)
1863 {
1864 logger.VerboseError.WriteLine(ex.ToString());
1865 }
1866 }
1867 comparer.Value = value;
1868 }
1869 else
1870 {
1871 value = Convert.ToByte(SearchArgs.CompareStartValue);
1872 comparer.Value = value;
1873 }
1874 if (comparer.Compare(Convert.ToByte(Value), value))
1875 {
1876 writer.WriteResult<byte>(comparer.Address, comparer.Value);
1877 }
1878 }
1879 }
1880 #endregion
1881 }
1882 else
1883 {
1884 #region 8bits - signed
1885 var t_data = BitTools.ConvertByteArray<sbyte>(data);
1886 foreach (var Value in t_data)
1887 {
1888 if (SearchWorkerThread.CancellationPending) { break; }
1889 using (_8bit_signed_comparer_ comparer = new _8bit_signed_comparer_(SearchArgs, i))
1890 {
1891 sbyte value = 0;
1892 if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1893 {
1894 using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1895 {
1896 try
1897 {
1898 gmp.OpenProvider();
1899 gmp.ReadMemory(i, out value);
1900 gmp.CloseProvider();
1901 }
1902 catch (Exception ex)
1903 {
1904 logger.VerboseError.WriteLine(ex.ToString());
1905 }
1906 }
1907 comparer.Value = value;
1908 }
1909 else
1910 {
1911 value = Convert.ToSByte(SearchArgs.CompareStartValue);
1912 comparer.Value = value;
1913 }
1914 if (comparer.Compare(Convert.ToSByte(Value), value))
1915 {
1916 writer.WriteResult<sbyte>(comparer.Address, comparer.Value);
1917 }
1918 }
1919 }
1920 #endregion
1921 } break;
1922 case SearchDataTypes._16bits:
1923 if (unsigned)
1924 {
1925 #region 16bits - unsigned
1926 var t_data = BitTools.ConvertByteArray<ushort>(data);
1927 foreach (var Value in t_data)
1928 {
1929 if (SearchWorkerThread.CancellationPending) { break; }
1930 using (_16bit_unsigned_comparer_ comparer = new _16bit_unsigned_comparer_(SearchArgs, i))
1931 {
1932 ushort value = 0;
1933 if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1934 {
1935 using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1936 {
1937 try
1938 {
1939 gmp.OpenProvider();
1940 gmp.ReadMemory(i, out value);
1941 gmp.CloseProvider();
1942 }
1943 catch (Exception ex)
1944 {
1945 logger.VerboseError.WriteLine(ex.ToString());
1946 }
1947 }
1948 comparer.Value = value;
1949 }
1950 else
1951 {
1952 value = Convert.ToUInt16(SearchArgs.CompareStartValue);
1953 comparer.Value = value;
1954 }
1955 if (comparer.Compare(Convert.ToUInt16(Value), value))
1956 {
1957 writer.WriteResult<ushort>(comparer.Address, comparer.Value);
1958 }
1959 }
1960 }
1961 #endregion
1962 }
1963 else
1964 {
1965 #region 16bits - signed
1966 var t_data = BitTools.ConvertByteArray<short>(data);
1967 foreach (var Value in t_data)
1968 {
1969 if (SearchWorkerThread.CancellationPending) { break; }
1970 using (_16bit_signed_comparer_ comparer = new _16bit_signed_comparer_(SearchArgs, i))
1971 {
1972 short value = 0;
1973 if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1974 {
1975 using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1976 {
1977 try
1978 {
1979 gmp.OpenProvider();
1980 gmp.ReadMemory(i, out value);
1981 gmp.CloseProvider();
1982 }
1983 catch (Exception ex)
1984 {
1985 logger.VerboseError.WriteLine(ex.ToString());
1986 }
1987 }
1988 comparer.Value = value;
1989 }
1990 else
1991 {
1992 value = Convert.ToInt16(SearchArgs.CompareStartValue);
1993 comparer.Value = value;
1994 }
1995 if (comparer.Compare(Convert.ToSByte(Value), value))
1996 {
1997 writer.WriteResult<short>(comparer.Address, comparer.Value);
1998 }
1999 }
2000 }
2001 #endregion
2002 } break;
2003 case SearchDataTypes._32bits:
2004 if (unsigned)
2005 {
2006 #region 32bits - unsigned
2007 var t_data = BitTools.ConvertByteArray<uint>(data);
2008 foreach (var Value in t_data)
2009 {
2010 if (SearchWorkerThread.CancellationPending) { break; }
2011 using (_32bit_unsigned_comparer_ comparer = new _32bit_unsigned_comparer_(SearchArgs, i))
2012 {
2013 uint value = 0;
2014 if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
2015 {
2016 using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
2017 {
2018 try
2019 {
2020 gmp.OpenProvider();
2021 gmp.ReadMemory(i, out value);
2022 gmp.CloseProvider();
2023 }
2024 catch (Exception ex)
2025 {
2026 logger.VerboseError.WriteLine(ex.ToString());
2027 }
2028 }
2029 comparer.Value = value;
2030 }
2031 else
2032 {
2033 value = Convert.ToUInt32(SearchArgs.CompareStartValue);
2034 comparer.Value = value;
2035 }
2036 if (comparer.Compare(Convert.ToUInt32(Value), value))
2037 {
2038 writer.WriteResult<uint>(comparer.Address, comparer.Value);
2039 }
2040 }
2041 }
2042 #endregion
2043 }
2044 else
2045 {
2046 #region 32bits - signed
2047 var t_data = BitTools.ConvertByteArray<int>(data);
2048 foreach (var Value in t_data)
2049 {
2050 if (SearchWorkerThread.CancellationPending) { break; }
2051 using (_32bit_signed_comparer_ comparer = new _32bit_signed_comparer_(SearchArgs, i))
2052 {
2053 int value = 0;
2054 if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
2055 {
2056 using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
2057 {
2058 try
2059 {
2060 gmp.OpenProvider();
2061 gmp.ReadMemory(i, out value);
2062 gmp.CloseProvider();
2063 }
2064 catch (Exception ex)
2065 {
2066 logger.VerboseError.WriteLine(ex.ToString());
2067 }
2068 }
2069 comparer.Value = value;
2070 }
2071 else
2072 {
2073 value = Convert.ToInt32(SearchArgs.CompareStartValue);
2074 comparer.Value = value;
2075 }
2076 if (comparer.Compare(Convert.ToInt32(Value), value))
2077 {
2078 writer.WriteResult<int>(comparer.Address, comparer.Value);
2079 }
2080 }
2081 }
2082 #endregion
2083 } break;
2084 case SearchDataTypes._64bits:
2085 if (unsigned)
2086 {
2087 #region 64bits - unsigned
2088 var t_data = BitTools.ConvertByteArray<ulong>(data);
2089 foreach (var Value in t_data)
2090 {
2091 if (SearchWorkerThread.CancellationPending) { break; }
2092 using (_64bit_unsigned_comparer_ comparer = new _64bit_unsigned_comparer_(SearchArgs, i))
2093 {
2094 ulong value = 0;
2095 if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
2096 {
2097 using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
2098 {
2099 try
2100 {
2101 gmp.OpenProvider();
2102 gmp.ReadMemory(i, out value);
2103 gmp.CloseProvider();
2104 }
2105 catch (Exception ex)
2106 {
2107 logger.VerboseError.WriteLine(ex.ToString());
2108 }
2109 }
2110 comparer.Value = value;
2111 }
2112 else
2113 {
2114 value = Convert.ToUInt64(SearchArgs.CompareStartValue);
2115 comparer.Value = value;
2116 }
2117 if (comparer.Compare(Convert.ToUInt64(Value), value))
2118 {
2119 writer.WriteResult<ulong>(comparer.Address, comparer.Value);
2120 }
2121 }
2122 }
2123 #endregion
2124 }
2125 else
2126 {
2127 #region 64bits - signed
2128 var t_data = BitTools.ConvertByteArray<long>(data);
2129 foreach (var Value in t_data)
2130 {
2131 if (SearchWorkerThread.CancellationPending) { break; }
2132 using (_64bit_signed_comparer_ comparer = new _64bit_signed_comparer_(SearchArgs, i))
2133 {
2134 long value = 0;
2135 if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
2136 {
2137 using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
2138 {
2139 try
2140 {
2141 gmp.OpenProvider();
2142 gmp.ReadMemory(i, out value);
2143 gmp.CloseProvider();
2144 }
2145 catch (Exception ex)
2146 {
2147 logger.VerboseError.WriteLine(ex.ToString());
2148 }
2149 }
2150 comparer.Value = value;
2151 }
2152 else
2153 {
2154 value = Convert.ToInt64(SearchArgs.CompareStartValue);
2155 comparer.Value = value;
2156 }
2157 if (comparer.Compare(Convert.ToInt64(Value), value))
2158 {
2159 writer.WriteResult<long>(comparer.Address, comparer.Value);
2160 }
2161 }
2162 }
2163 #endregion
2164 } break;
2165 }
2166
2167 //using (MemoryStream ms = new MemoryStream(data))
2168 //{
2169 // using (BinaryReader br = new BinaryReader(ms))
2170 // {
2171 // while (br.BaseStream.Position < br.BaseStream.Length)
2172 // {
2173 // if (SearchWorkerThread.CancellationPending)
2174 // {
2175 // break;
2176 // }
2177 // }
2178 // }
2179 //}
2180 #endregion
2181
2182
2183 if (SearchWorkerThread.CancellationPending)
2184 {
2185 st_profiler.Stop();
2186 provider_st.Stop();
2187 st.Stop();
2188 writer.CancelRequest();
2189 writer.Dispose();
2190 writer = null;
2191 e.Result = true;
2192 provider.CloseProvider();
2193 logger.Profiler.WriteLine("Memory Search Operation Profiler: search operation took {0} seconds", st_profiler.Elapsed.TotalSeconds.ToString());
2194 return;
2195 }
2196 }
2197
2198 st_profiler.Stop();
2199
2200 logger.Profiler.WriteLine("Memory Search Operation Profiler: search operation took {0} seconds", st_profiler.Elapsed.TotalSeconds.ToString());
2201
2202 if (SearchWorkerThread.CancellationPending)
2203 {
2204 provider_st.Stop();
2205 st.Stop();
2206 writer.CancelRequest();
2207 writer.Dispose();
2208 writer = null;
2209 e.Result = true;
2210 provider.CloseProvider();
2211 return;
2212 }
2213 writer.Dispose();
2214 writer = null;
2215 provider.CloseProvider();
2216 }
2217 else
2218 {
2219
2220 #region action_onbytesread :: custom in-line delegate for processing read bytes
2221 // custom in-line delegate for processing read bytes
2222 Action<OnBytesReadEventArgs> action_onbytesread = delegate(OnBytesReadEventArgs obre)
2223 {
2224 SearchDataTypes obre_sdt = SearchArgs.DataType;
2225 bool obre_unsigned = SearchArgs.IsUnsignedDataType;
2226 uint obre_CurrentIndex = obre.CurrentIndex; // this should represent the address
2227 SearchResultReader reader = null;
2228 if (obre.UserState != null)
2229 {
2230 reader = (obre.UserState as SearchResultReader);
2231 if (reader == null)
2232 throw new InvalidOperationException("writer cannot be null");
2233 }
2234 else
2235 {
2236 throw new ArgumentNullException("UserState", "UserState cannot be null, it must be an instance of a SearchResultReader");
2237 }
2238 using (MemoryStream ms = new MemoryStream(obre.Data))
2239 {
2240 using (BinaryReader br = new BinaryReader(ms))
2241 {
2242 while (br.BaseStream.Position < br.BaseStream.Length)
2243 {
2244 ISerializedResult sr = (reader as ISerializedResult);
2245 if (sr == null)
2246 {
2247 throw new ArgumentNullException("sr", string.Format("Unable to cast: '{0}' to '{1}'", reader.GetType().Name, typeof(ISerializedResult).Name));
2248 }
2249 int sr_index = 0;
2250 try
2251 {
2252 if (sr.ContainsAddress(obre_CurrentIndex, obre_unsigned, obre_sdt, new Action<int, string>(this.UpdateProgress), out sr_index))
2253 {
2254 StructResultType<ulong> result = StructResultType<ulong>.Empty;
2255 sr.GetResultAtIndex(sr_index, obre_unsigned, obre_sdt, new Action<int, string>(this.UpdateProgress), out result);
2256 if (Debugger.IsAttached)
2257 {
2258 Debugger.Break();
2259 }
2260
2261 }
2262 }
2263 catch (Exception ex)
2264 {
2265 throw ex;
2266 }
2267 switch (obre_sdt)
2268 {
2269 case SearchDataTypes._8bits:
2270 if (obre_unsigned)
2271 {
2272 #region 8bit - unsigned
2273 var new_value = br.ReadByte(); // this should contain the updated value from memory
2274 using (_8bit_unsigned_comparer_ comparer = new _8bit_unsigned_comparer_(SearchArgs, obre_CurrentIndex))
2275 {
2276 byte value = 0; // this is the vaule we want to compare against
2277 value = Convert.ToByte(SearchArgs.CompareStartValue);
2278 comparer.Value = value;
2279 if (comparer.Compare(new_value, value))
2280 {
2281 //writer.WriteResult<byte>(comparer.Address, comparer.Value);
2282 }
2283 }
2284 #endregion
2285 }
2286 else
2287 {
2288 }
2289 break;
2290 case SearchDataTypes._16bits:
2291 if (obre_unsigned)
2292 {
2293 }
2294 else
2295 {
2296 }
2297 break;
2298 case SearchDataTypes._32bits:
2299 if (obre_unsigned)
2300 {
2301 }
2302 else
2303 {
2304 }
2305 break;
2306 case SearchDataTypes._64bits:
2307 if (obre_unsigned)
2308 {
2309 }
2310 else
2311 {
2312 }
2313 break;
2314 }
2315 uint size = 0;
2316 BitTools.SizeOf(obre_sdt, out size);
2317 obre_CurrentIndex += size;
2318 }
2319 }
2320 }
2321 };
2322 #endregion
2323 // need to get the address list
2324 using (SearchResultReader reader = new SearchResultReader(SearchGuid, false)) // delete the file on dispose
2325 {
2326
2327
2328 provider.OpenProvider();
2329 //int count = (int)((MemoryRangeSize - MemoryRangeStart) / STEP_SIZE);
2330 //SearchResultWriter writer = new SearchResultWriter((int)(count), SearchGuid);
2331 provider.OnBytesRead += new BaseEventHandler<OnBytesReadEventArgs>(action_onbytesread);
2332 provider.ReadProcessMemoryAtOnce(MemoryRangeStart, (MemoryRangeSize - MemoryRangeStart), reader);
2333 if (SearchWorkerThread.CancellationPending)
2334 {
2335 provider_st.Stop();
2336 st.Stop();
2337 e.Result = true;
2338 provider.CloseProvider();
2339 return;
2340 }
2341 provider.CloseProvider();
2342
2343 //byte[] guid = SearchGuid.ToByteArray();
2344 //guid[guid.Length - 1]++; // increment the search guid by 1
2345 //Guid new_SearchGuid = new Guid(guid);
2346 ////const int item_count = 0x100;
2347 //using (SearchResultWriter writer = new SearchResultWriter((int)(reader.ResultCount), new_SearchGuid))
2348 //{
2349 // var items = reader.GetSearchAddressValueMatches((IAcceptsProcessAndConfig)this, SearchArgs, new Action<int, string>(UpdateProgress));
2350 // reader.Dispose(); // delete the result file, if allowed
2351 // foreach (var item in items)
2352 // {
2353 // switch (SearchArgs.DataType)
2354 // {
2355 // case SearchDataTypes._8bits:
2356 // if (SearchArgs.IsUnsignedDataType)
2357 // {
2358 // writer.WriteResult<byte>(item.Address, Convert.ToByte(item.Value));
2359 // }
2360 // else
2361 // {
2362 // writer.WriteResult<sbyte>(item.Address, Convert.ToSByte(item.Value));
2363 // }
2364 // break;
2365 // case SearchDataTypes._16bits:
2366 // if (SearchArgs.IsUnsignedDataType)
2367 // {
2368 // writer.WriteResult<ushort>(item.Address, Convert.ToUInt16(item.Value));
2369 // }
2370 // else
2371 // {
2372 // writer.WriteResult<short>(item.Address, Convert.ToInt16(item.Value));
2373 // }
2374 // break;
2375 // case SearchDataTypes._32bits:
2376 // if (SearchArgs.IsUnsignedDataType)
2377 // {
2378 // writer.WriteResult<uint>(item.Address, Convert.ToUInt32(item.Value));
2379 // }
2380 // else
2381 // {
2382 // writer.WriteResult<int>(item.Address, Convert.ToInt32(item.Value));
2383 // }
2384 // break;
2385 // case SearchDataTypes._64bits:
2386 // if (SearchArgs.IsUnsignedDataType)
2387 // {
2388 // writer.WriteResult<ulong>(item.Address, Convert.ToUInt64(item.Value));
2389 // }
2390 // else
2391 // {
2392 // writer.WriteResult<long>(item.Address, Convert.ToInt64(item.Value));
2393 // }
2394 // break;
2395 // }
2396 // }
2397 //}
2398 //SearchGuid = new_SearchGuid;
2399 }
2400 }
2401 }
2402 provider_st.Stop();
2403 logger.Profiler.WriteLine("It took a total of {0} seconds for the memory provider to complete it's operation(s).", provider_st.Elapsed.TotalSeconds);
2404 //if (buffered_mem.Length == 0) { logger.Warn.WriteLine("Buffered Memory is Zero Length."); return; }
2405 //int Last_Whole_Percent_Done = 0;
2406
2407
2408 #region Subsequent Searches
2409 //r_ms.BaseStream.Seek(0, SeekOrigin.Begin);
2410
2411
2412 // hack to help with OutOfMemory Exceptions (OldValue and Equal compare will always add all found search results)
2413 bool NeedToCompare = true;
2414 if (SearchArgs.CompareValueType == CompareValueTypes.OldValue &&
2415 SearchArgs.CompareType == SearchCompareTypes.Equal &&
2416 SearchArgs.IsFirstSearch)
2417 {
2418 NeedToCompare = false;
2419 //second_tmp_Results = null; // Free Memory
2420 }
2421
2422 if (NeedToCompare)
2423 {
2424 if (SearchArgs.CompareType != SearchCompareTypes.Between && SearchArgs.CompareType != SearchCompareTypes.NotBetween)
2425 {
2426 #region Non-Range Searches
2427 if (USE_NONRANGE_SEARCH_RESULT_READER)
2428 {
2429 st_nonrange_search.Start();
2430 //second_tmp_Results = new List<ResultType<object>>(SearchArgs.Results.Count * 1024);
2431 ////second_tmp_Results.c
2432 try
2433 {
2434 using (SearchResultReader reader = new SearchResultReader(SearchGuid))
2435 {
2436 try
2437 {
2438
2439 #region new comparator-support
2440 //second_tmp_Results = new List<StructResultType<object>>(reader.GetResults(SearchArgs.IsUnsignedDataType, SearchArgs.DataType, new Action<int, string>(UpdateProgress)));
2441 #endregion
2442
2443 #region USE_OLD_SEARCH_RESULTS_COMPRATOR_CODE
2444 if (USE_OLD_SEARCH_RESULTS_COMPRATOR_CODE)
2445 {
2446 for (int i = 0; i < reader.ResultCount; i += 1)
2447 {
2448 object result_value = 0;
2449 uint address = 0;
2450 #region switch (SearchArgs.DataType)
2451 switch (SearchArgs.DataType)
2452 {
2453 case SearchDataTypes._8bits: if (unsigned)
2454 {
2455 using (ResultType<byte> result = reader.GetNextResult<byte>())
2456 {
2457 address = result.Address;
2458 result_value = result.Value;
2459 }
2460 }
2461 else
2462 {
2463 using (ResultType<sbyte> result = reader.GetNextResult<sbyte>())
2464 {
2465 address = result.Address;
2466 result_value = result.Value;
2467 }
2468 } break;
2469 case SearchDataTypes._16bits: if (unsigned)
2470 {
2471 using (ResultType<ushort> result = reader.GetNextResult<ushort>())
2472 {
2473 address = result.Address;
2474 result_value = result.Value;
2475 }
2476 }
2477 else
2478 {
2479 using (ResultType<short> result = reader.GetNextResult<short>())
2480 {
2481 address = result.Address;
2482 result_value = result.Value;
2483 }
2484 } break;
2485 case SearchDataTypes._32bits: if (unsigned)
2486 {
2487 using (ResultType<uint> result = reader.GetNextResult<uint>())
2488 {
2489 address = result.Address;
2490 result_value = result.Value;
2491 }
2492 }
2493 else
2494 {
2495 using (ResultType<int> result = reader.GetNextResult<int>())
2496 {
2497 address = result.Address;
2498 result_value = result.Value;
2499 }
2500 } break;
2501 case SearchDataTypes._64bits: if (unsigned)
2502 {
2503 using (ResultType<ulong> result = reader.GetNextResult<ulong>())
2504 {
2505 address = result.Address;
2506 result_value = result.Value;
2507 }
2508 }
2509 else
2510 {
2511 using (ResultType<long> result = reader.GetNextResult<long>())
2512 {
2513 address = result.Address;
2514 result_value = result.Value;
2515 }
2516 } break;
2517 }
2518 #endregion
2519 if (MemoryRangeStart > 0 && !SearchArgs.IsFirstSearch) { address = address - MemoryRangeStart; }
2520 try
2521 {
2522 //r_ms.BaseStream.Seek(address, SeekOrigin.Begin);
2523 }
2524 catch (Exception)
2525 {
2526 throw;
2527 }
2528 switch (SearchArgs.DataType)
2529 {
2530 #region Comparer Support
2531 #region case SearchDataTypes._8bits:
2532 case SearchDataTypes._8bits:
2533 if (SearchArgs.IsUnsignedDataType)
2534 {
2535 byte lookup_value = 0;
2536 //using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this)) { gmp.OpenProvider(); gmp.ReadMemory(address, out lookup_value); gmp.CloseProvider(); }
2537 lookup_value = Convert.ToByte(result_value);
2538 using (_8bit_unsigned_comparer_ comparer = new _8bit_unsigned_comparer_(SearchArgs, address))
2539 {
2540 byte value = 0;
2541 if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
2542 {
2543 using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
2544 {
2545 try
2546 {
2547 gmp.OpenProvider();
2548 gmp.ReadMemory(address, out value);
2549 gmp.CloseProvider();
2550 }
2551 catch (Exception ex)
2552 {
2553 logger.VerboseError.WriteLine(ex.ToString());
2554 }
2555 }
2556 comparer.Value = value;
2557 }
2558 else
2559 {
2560 value = Convert.ToByte(SearchArgs.CompareStartValue);
2561 comparer.Value = value;
2562 }
2563 if (comparer.Compare(lookup_value, value))
2564 {
2565 second_tmp_Results.Add(new ResultType<ulong>(comparer.Address, comparer.Value));
2566 }
2567 }
2568 }
2569 else
2570 {
2571 sbyte lookup_value = 0;
2572 //using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this)) { gmp.OpenProvider(); gmp.ReadMemory(address, out lookup_value); gmp.CloseProvider(); }
2573 lookup_value = Convert.ToSByte(result_value);
2574 using (_8bit_signed_comparer_ comparer = new _8bit_signed_comparer_(SearchArgs, address))
2575 {
2576 sbyte value = 0;
2577 if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
2578 {
2579 using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
2580 {
2581 try
2582 {
2583 gmp.OpenProvider();
2584 gmp.ReadMemory(address, out value);
2585 gmp.CloseProvider();
2586 }
2587 catch (Exception ex)
2588 {
2589 logger.VerboseError.WriteLine(ex.ToString());
2590 }
2591 }
2592 comparer.Value = value;
2593 }
2594 else
2595 {
2596 value = Convert.ToSByte(SearchArgs.CompareStartValue);
2597 }
2598 if (comparer.Compare(lookup_value, value))
2599 {
2600 second_tmp_Results.Add(new ResultType<ulong>(comparer.Address, (ulong)comparer.Value));
2601 }
2602 }
2603 }
2604 break;
2605 #endregion
2606 #region case SearchDataTypes._16bits:
2607 case SearchDataTypes._16bits:
2608 if (SearchArgs.IsUnsignedDataType)
2609 {
2610 ushort lookup_value = 0;
2611 //using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this)) { gmp.OpenProvider(); gmp.ReadMemory(address, out lookup_value); gmp.CloseProvider(); }
2612 lookup_value = Convert.ToUInt16(result_value);
2613 using (_16bit_unsigned_comparer_ comparer = new _16bit_unsigned_comparer_(SearchArgs, address))
2614 {
2615 ushort value = 0;
2616 if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
2617 {
2618 using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
2619 {
2620 try
2621 {
2622 gmp.OpenProvider();
2623 gmp.ReadMemory(address, out value);
2624 gmp.CloseProvider();
2625 }
2626 catch (Exception ex)
2627 {
2628 logger.VerboseError.WriteLine(ex.ToString());
2629 }
2630 }
2631 comparer.Value = value;
2632 }
2633 else
2634 {
2635 value = Convert.ToUInt16(SearchArgs.CompareStartValue);
2636 comparer.Value = value;
2637 }
2638 if (comparer.Compare(lookup_value, value))
2639 {
2640 second_tmp_Results.Add(new ResultType<ulong>(comparer.Address, comparer.Value));
2641 }
2642 }
2643 }
2644 else
2645 {
2646 short lookup_value = 0;
2647 //using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this)) { gmp.OpenProvider(); gmp.ReadMemory(address, out lookup_value); gmp.CloseProvider(); }
2648 lookup_value = Convert.ToInt16(result_value);
2649 using (_16bit_signed_comparer_ comparer = new _16bit_signed_comparer_(SearchArgs, address))
2650 {
2651 short value = 0;
2652 if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
2653 {
2654 using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
2655 {
2656 try
2657 {
2658 gmp.OpenProvider();
2659 gmp.ReadMemory(address, out value);
2660 gmp.CloseProvider();
2661 }
2662 catch (Exception ex)
2663 {
2664 logger.VerboseError.WriteLine(ex.ToString());
2665 }
2666 }
2667 comparer.Value = value;
2668 }
2669 else
2670 {
2671 value = Convert.ToInt16(SearchArgs.CompareStartValue);
2672 }
2673 if (comparer.Compare(lookup_value, value))
2674 {
2675 second_tmp_Results.Add(new ResultType<ulong>(comparer.Address, (ulong)comparer.Value));
2676 }
2677 }
2678 }
2679 break;
2680 #endregion
2681 #region case SearchDataTypes._32bits:
2682 case SearchDataTypes._32bits:
2683 if (SearchArgs.IsUnsignedDataType)
2684 {
2685 uint lookup_value = 0;
2686 //using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this)) { gmp.OpenProvider(); gmp.ReadMemory(address, out lookup_value); gmp.CloseProvider(); }
2687 lookup_value = Convert.ToUInt32(result_value);
2688 using (_32bit_unsigned_comparer_ comparer = new _32bit_unsigned_comparer_(SearchArgs, address))
2689 {
2690 uint value = 0;
2691 if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
2692 {
2693 using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
2694 {
2695 try
2696 {
2697 gmp.OpenProvider();
2698 gmp.ReadMemory(address, out value);
2699 gmp.CloseProvider();
2700 }
2701 catch (Exception ex)
2702 {
2703 logger.VerboseError.WriteLine(ex.ToString());
2704 }
2705 }
2706 comparer.Value = value;
2707 }
2708 else
2709 {
2710 value = Convert.ToUInt32(SearchArgs.CompareStartValue);
2711 comparer.Value = value;
2712 }
2713 if (comparer.Compare(lookup_value, value))
2714 {
2715 second_tmp_Results.Add(new ResultType<ulong>(comparer.Address, comparer.Value));
2716 }
2717 }
2718 }
2719 else
2720 {
2721 int lookup_value = 0;
2722 //using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this)) { gmp.OpenProvider(); gmp.ReadMemory(address, out lookup_value); gmp.CloseProvider(); }
2723 lookup_value = Convert.ToInt32(result_value);
2724 using (_32bit_signed_comparer_ comparer = new _32bit_signed_comparer_(SearchArgs, address))
2725 {
2726 int value = 0;
2727 if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
2728 {
2729 using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
2730 {
2731 try
2732 {
2733 gmp.OpenProvider();
2734 gmp.ReadMemory(address, out value);
2735 gmp.CloseProvider();
2736 }
2737 catch (Exception ex)
2738 {
2739 logger.VerboseError.WriteLine(ex.ToString());
2740 }
2741 }
2742 comparer.Value = value;
2743 }
2744 else
2745 {
2746 value = Convert.ToInt32(SearchArgs.CompareStartValue);
2747 }
2748 if (comparer.Compare(lookup_value, value))
2749 {
2750 second_tmp_Results.Add(new ResultType<ulong>(comparer.Address, (ulong)comparer.Value));
2751 }
2752 }
2753 }
2754 break;
2755 #endregion
2756 #region case SearchDataTypes._64bits:
2757 case SearchDataTypes._64bits:
2758 if (SearchArgs.IsUnsignedDataType)
2759 {
2760 ulong lookup_value = 0;
2761 //using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this)) { gmp.OpenProvider(); gmp.ReadMemory(address, out lookup_value); gmp.CloseProvider(); }
2762 lookup_value = Convert.ToUInt64(result_value);
2763 using (_64bit_unsigned_comparer_ comparer = new _64bit_unsigned_comparer_(SearchArgs, address))
2764 {
2765 ulong value = 0;
2766 if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
2767 {
2768 using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
2769 {
2770 try
2771 {
2772 gmp.OpenProvider();
2773 gmp.ReadMemory(address, out value);
2774 gmp.CloseProvider();
2775 }
2776 catch (Exception ex)
2777 {
2778 logger.VerboseError.WriteLine(ex.ToString());
2779 }
2780 }
2781 comparer.Value = value;
2782 }
2783 else
2784 {
2785 value = Convert.ToUInt64(SearchArgs.CompareStartValue);
2786 comparer.Value = value;
2787 }
2788 if (comparer.Compare(lookup_value, value))
2789 {
2790 second_tmp_Results.Add(new ResultType<ulong>(comparer.Address, comparer.Value));
2791 }
2792 }
2793 }
2794 else
2795 {
2796 long lookup_value = 0;
2797 //using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this)) { gmp.OpenProvider(); gmp.ReadMemory(address, out lookup_value); gmp.CloseProvider(); }
2798 lookup_value = Convert.ToInt64(result_value);
2799 using (_64bit_signed_comparer_ comparer = new _64bit_signed_comparer_(SearchArgs, address))
2800 {
2801 long value = 0;
2802 if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
2803 {
2804 using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
2805 {
2806 try
2807 {
2808 gmp.OpenProvider();
2809 gmp.ReadMemory(address, out value);
2810 gmp.CloseProvider();
2811 }
2812 catch (Exception ex)
2813 {
2814 logger.VerboseError.WriteLine(ex.ToString());
2815 }
2816 }
2817 comparer.Value = value;
2818 }
2819 else
2820 {
2821 value = Convert.ToInt64(SearchArgs.CompareStartValue);
2822 }
2823 if (comparer.Compare(lookup_value, value))
2824 {
2825 second_tmp_Results.Add(new ResultType<ulong>(comparer.Address, (ulong)comparer.Value));
2826 }
2827 }
2828 }
2829 break;
2830 #endregion
2831 #endregion
2832 }
2833 double double_percent_done = 100.0 * (double)((double)i / (double)reader.ResultCount);
2834 int int_percent_done = (int)double_percent_done;
2835 //if (int_percent_done != Last_Whole_Percent_Done && i % 100000 == 0)
2836 //{
2837 if (int_percent_done <= 100)
2838 {
2839 //Last_Whole_Percent_Done = int_percent_done;
2840 UpdateProgress(int_percent_done, string.Format(" -> Reading Address: 0x{0:x8}", i + MemoryRangeStart));
2841 //new Action<int, string>(UpdateProgress).Invoke(int_percent_done, string.Format(" -> Reading Address: 0x{0:x8}", i + MemoryRangeStart));
2842 }
2843 //}
2844 //this.Refresh();
2845 }
2846 }
2847 #endregion
2848 }
2849 catch (Exception ex)
2850 {
2851 throw ex;
2852 }
2853 }
2854 }
2855 catch (Exception ex)
2856 {
2857 throw ex;
2858 }
2859 st_nonrange_search.Stop();
2860 logger.Profiler.WriteLine("Non-Ranged search took a total of {0} seconds to complete.", st_nonrange_search.Elapsed.TotalSeconds);
2861 //Last_Whole_Percent_Done = 0;
2862 }
2863 #endregion
2864 }
2865 #region Ranged Searches
2866 #if !DONOT_HAVE_RANGED_SEARCH_SUPPORT
2867 if (SearchArgs.CompareType == SearchCompareTypes.Between || SearchArgs.CompareType == SearchCompareTypes.NotBetween)
2868 {
2869 st_ranged_search.Start();
2870 object start, end;
2871
2872 start = SearchArgs.CompareStartValue;
2873 end = SearchArgs.CompareEndValue;
2874 using (SearchResultReader reader = new SearchResultReader(SearchGuid))
2875 {
2876 for (int i = 0; i < reader.ResultCount; i += 1)
2877 {
2878 uint address = 0;
2879 #region switch (SearchArgs.DataType)
2880 switch (SearchArgs.DataType)
2881 {
2882 case SearchDataTypes._8bits: if (unsigned) { using (ResultType<byte> result = reader.GetNextResult<byte>()) { address = result.Address; } }
2883 else { using (ResultType<sbyte> result = reader.GetNextResult<sbyte>()) { address = result.Address; } } break;
2884 case SearchDataTypes._16bits: if (unsigned) { using (ResultType<ushort> result = reader.GetNextResult<ushort>()) { address = result.Address; } }
2885 else { using (ResultType<short> result = reader.GetNextResult<short>()) { address = result.Address; } } break;
2886 case SearchDataTypes._32bits: if (unsigned) { using (ResultType<uint> result = reader.GetNextResult<uint>()) { address = result.Address; } }
2887 else { using (ResultType<int> result = reader.GetNextResult<int>()) { address = result.Address; } } break;
2888 case SearchDataTypes._64bits: if (unsigned) { using (ResultType<ulong> result = reader.GetNextResult<ulong>()) { address = result.Address; } }
2889 else { using (ResultType<long> result = reader.GetNextResult<long>()) { address = result.Address; } } break;
2890 }
2891 #endregion
2892
2893 if (MemoryRangeStart > 0 && !SearchArgs.IsFirstSearch) { address = address - MemoryRangeStart; }
2894 //r_ms.BaseStream.Seek(address, SeekOrigin.Begin);
2895 if (SearchArgs.CompareType == SearchCompareTypes.Between)
2896 {
2897 using (InRangeComparer comparer = new InRangeComparer(address, 0))
2898 {
2899 if (comparer.Compare(start, end, SearchArgs.DataType, SearchArgs.IsUnsignedDataType, (IAcceptsProcessAndConfig)this))
2900 {
2901 using (ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value))
2902 {
2903 second_tmp_Results.Add(_tmp_result);
2904 }
2905 }
2906 }
2907 }
2908 else if (SearchArgs.CompareType == SearchCompareTypes.NotBetween)
2909 {
2910 using (NotInRangeComparer comparer = new NotInRangeComparer(address, 0))
2911 {
2912 if (comparer.Compare(start, end, SearchArgs.DataType, SearchArgs.IsUnsignedDataType, (IAcceptsProcessAndConfig)this))
2913 {
2914 using (ResultType<object> _tmp_result = new ResultType<object>(comparer.Address, comparer.Value))
2915 {
2916 second_tmp_Results.Add(_tmp_result);
2917 }
2918 }
2919 }
2920 }
2921 else
2922 {
2923 throw new InvalidOperationException("Encounted unkown range search type: " + SearchArgs.CompareType);
2924 }
2925 double double_percent_done = 100.0 * (double)((double)i / (double)reader.ResultCount);
2926 int int_percent_done = (int)double_percent_done;
2927 if (int_percent_done != Last_Whole_Percent_Done)
2928 {
2929 if (int_percent_done <= 100)
2930 {
2931 resultsprogress.Value = int_percent_done;
2932 resultsprogress.Message = string.Format(" -> Reading Address: 0x{0:x8}", i + MemoryRangeStart);
2933 Last_Whole_Percent_Done = int_percent_done;
2934 }
2935 }
2936 }
2937 }
2938 st_ranged_search.Stop();
2939 logger.Profiler.WriteLine("Ranged search took a total of {0} seconds to complete.", st_ranged_search.Elapsed.TotalSeconds);
2940 }
2941 #endif
2942 #endregion
2943
2944 }
2945 #endregion
2946 //// leave SearchArgs.Results alone, if false
2947 //if (NeedToCompare)
2948 //{
2949 // // fix addresses when memory start is not zero
2950 // 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; } }
2951 // using (SearchResultWriter writer = new SearchResultWriter(second_tmp_Results.Count, SearchGuid))
2952 // {
2953 // for (int i = 0; i < second_tmp_Results.Count; i++)
2954 // {
2955 // switch (sdt)
2956 // {
2957 // case SearchDataTypes._8bits:
2958 // if (unsigned) { writer.WriteResult<Byte>(second_tmp_Results[i].Address, Convert.ToByte(second_tmp_Results[i].Value)); }
2959 // else { writer.WriteResult<SByte>(second_tmp_Results[i].Address, Convert.ToSByte(second_tmp_Results[i].Value)); } break;
2960 // case SearchDataTypes._16bits:
2961 // if (unsigned) { writer.WriteResult<UInt16>(second_tmp_Results[i].Address, Convert.ToUInt16(second_tmp_Results[i].Value)); }
2962 // else { writer.WriteResult<Int16>(second_tmp_Results[i].Address, Convert.ToInt16(second_tmp_Results[i].Value)); } break;
2963 // case SearchDataTypes._32bits:
2964 // if (unsigned) { writer.WriteResult<UInt32>(second_tmp_Results[i].Address, Convert.ToUInt32(second_tmp_Results[i].Value)); }
2965 // else { writer.WriteResult<Int32>(second_tmp_Results[i].Address, Convert.ToInt32(second_tmp_Results[i].Value)); } break;
2966 // case SearchDataTypes._64bits:
2967 // if (unsigned) { writer.WriteResult<UInt64>(second_tmp_Results[i].Address, Convert.ToUInt64(second_tmp_Results[i].Value)); }
2968 // else { writer.WriteResult<Int64>(second_tmp_Results[i].Address, Convert.ToInt64(second_tmp_Results[i].Value)); } break;
2969 // }
2970 // }
2971 // }
2972 // second_tmp_Results = null; // free memory
2973 //}
2974 }
2975 catch (OutOfMemoryException ex)
2976 {
2977 e.Result = true;
2978 logger.Error.WriteLine("Encounted {0} for search: {0}", ex.GetType().Name, SearchGuid.ToString());
2979 logger.VerboseError.WriteLine(ex.ToString());
2980 MessageBox.Show(string.Format("Encounted {0} for search: {0} ... Please try again.", ex.GetType().Name, SearchGuid.ToString()), string.Format("{0} was thrown", ex.GetType().Name), MessageBoxButtons.OK, MessageBoxIcon.Error);
2981 return;
2982 }
2983 catch (Exception ex)
2984 {
2985 throw ex;
2986 }
2987 }
2988
2989
2990
2991 private void SearchWorkerThread_ProgressChanged(object sender, ProgressChangedEventArgs e)
2992 {
2993 //if (SearchArgs.ProgressLogger != null)
2994 //{
2995 // resultsprogress.Value = e.ProgressPercentage;
2996 // //Application.DoEvents();
2997 //}
2998 }
2999
3000 private void SearchWorkerThread_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
3001 {
3002 try { if ((bool)e.Result) { logger.Warn.WriteLine("Search operation was cancelled.");
3003 //new Action<int, string>(UpdateProgress).Invoke(0, string.Empty);
3004 UpdateProgress(0, string.Empty);
3005 return; }
3006 }
3007 catch (InvalidCastException) { }
3008 try
3009 {
3010 Stopwatch st = (Stopwatch)e.Result;
3011 st.Stop();
3012 logger.Profiler.WriteLine("Search took {0} seconds, overall, to complete.", st.Elapsed.TotalSeconds);
3013 }
3014 catch (InvalidCastException) { }
3015 catch (Exception ex) { throw ex; }
3016
3017 UpdateProgress(100, String.Empty);
3018 //new Action<int, string>(UpdateProgress).Invoke(100, string.Empty);
3019 bool unsigned = SearchArgs.IsUnsignedDataType;
3020 using (SearchResultReader reader = new SearchResultReader(SearchGuid))
3021 {
3022 logger.Info.WriteLine(string.Format("Found 0x{0:x8} results", reader.ResultCount));
3023
3024 if (reader.ResultCount <= MIN_NUMBER_OF_RESULTS_BEFORE_DISPLAY)
3025 {
3026 lstResults.Items.Clear();
3027 //List<ResultItem> items = new List<ResultItem>();
3028 //for (int i = 0; i < reader.ResultCount; i++)
3029 //{
3030 // ResultItem item = new ResultItem(0, false);
3031 // //item.Text = string.Format("0x{0:x8}", SearchArgs.Results[i].Address);
3032 // //item.SubItems.Add(string.Format("0x{0:x8}", SearchArgs.Results[i].Address));
3033 // switch (SearchArgs.DataType)
3034 // {
3035 // case SearchDataTypes._8bits:
3036 // if (SearchArgs.IsUnsignedDataType) { ResultType<byte> result = new ResultType<byte>(); item = new ResultItem(result.Address, false, result.Value); }
3037 // else { ResultType<sbyte> result = reader.GetNextResult<sbyte>(); item = new ResultItem(result.Address, false, result.Value); }
3038 // break;
3039 // case SearchDataTypes._16bits:
3040 // if (SearchArgs.IsUnsignedDataType) { ResultType<ushort> result = reader.GetNextResult<ushort>(); item = new ResultItem(result.Address, false, result.Value); }
3041 // else { ResultType<short> result = reader.GetNextResult<short>(); item = new ResultItem(result.Address, false, result.Value); }
3042 // break;
3043 // case SearchDataTypes._32bits:
3044 // if (SearchArgs.IsUnsignedDataType) { ResultType<uint> result = reader.GetNextResult<uint>(); item = new ResultItem(result.Address, false, result.Value); }
3045 // else { ResultType<int> result = reader.GetNextResult<int>(); item = new ResultItem(result.Address, false, result.Value); }
3046 // break;
3047 // case SearchDataTypes._64bits:
3048 // if (SearchArgs.IsUnsignedDataType) { ResultType<ulong> result = reader.GetNextResult<ulong>(); item = new ResultItem(result.Address, false, result.Value); }
3049 // else { ResultType<long> result = reader.GetNextResult<long>(); item = new ResultItem(result.Address, false, result.Value); }
3050 // break;
3051 // }
3052 // if (!items.Contains(item))
3053 // items.Add(item);
3054 //}
3055 //lstResults.Items.AddRange(reader.GetResultItems(SearchArgs.IsUnsignedDataType, SearchArgs.DataType, new Action<int, string>(UpdateProgress)));
3056 }
3057 }
3058
3059 this.DoSearchDoneSpecific();
3060 //System.Threading.Thread.Sleep(100);
3061 //if (_SEARCH_MODE != SearchMode.SEARCH_MODE_NORMAL_WITH_JOKER)
3062 this.ThawResultsUpdate();
3063 Application.DoEvents();
3064 }
3065 private void DoSearchDoneSpecific()
3066 {
3067 SearchWorkerThread.CancelAsync();
3068 if (lstResults.Items.Count > 0) { timer_update_results.Enabled = true; }
3069 else { timer_update_results.Enabled = false; }
3070
3071 search_progress_updater.Enabled = false;
3072
3073 btnCancel.Enabled = false;
3074 btnReset.Enabled = true;
3075 btnSearch.Enabled = true;
3076 grpCompareType.Enabled = true;
3077 grpCompareValue.Enabled = true;
3078 UpdateProgress(0, string.Empty);
3079 //new Action<int, string>(UpdateProgress).Invoke(0, string.Empty);
3080 grpDataType.Enabled = false;
3081 // resume process on reset, incase it was suspended
3082 ThreadControl.ResumeProcess(this.AcceptedProcess.Id);
3083 //Application.DoEvents();
3084 this.Refresh();
3085 }
3086
3087 private void DoCancelSpecific()
3088 {
3089 this.DoSearchDoneSpecific();
3090 }
3091 private void DoResetSpecific()
3092 {
3093 this.DoCancelSpecific();
3094 IsFirstSearch = true;
3095 grpDataType.Enabled = true;
3096 btnReset.Enabled = false;
3097
3098 // delete any temporary search result files
3099 SearchResultWriter.CleanupTemporarySearchResultFiles();
3100
3101 }
3102 private void search_progress_updater_Tick(object sender, EventArgs e)
3103 {
3104 if ((this.AcceptedProcess ==null) || Process.GetProcessById(this.AcceptedProcess.Id) == null)
3105 {
3106 SearchWorkerThread.CancelAsync();
3107 //JokerSearchWorker.CancelAsync();
3108 ResultsUpdateWorkerThread.CancelAsync();
3109 }
3110 }
3111
3112 #region Search Button
3113 private void btnSearch_Click(object sender, EventArgs e)
3114 {
3115 if (this.SearchGuid == Guid.Empty)
3116 this.SearchGuid = Guid.NewGuid();
3117 chkMemoryRangeExpertMode.Enabled = false;
3118 this.SearchInProgess = true;
3119 btnCancel.Enabled = true;
3120 btnReset.Enabled = false; // disable during search
3121 btnSearch.Enabled = false;
3122 this.FreezeResultsUpdate();
3123 this.handle_btnSearch_Click();
3124 }
3125 private void handle_btnSearch_Click()
3126 {
3127 //this.FreezeResultsUpdate();
3128 lstResults.Items.Clear();
3129
3130 if (lstResults.Items.Count > 0) { timer_update_results.Enabled = true; }
3131 else { timer_update_results.Enabled = false; }
3132 UpdateProgress(0, string.Empty);
3133 //new Action<int, string>(UpdateProgress).Invoke(0, string.Empty);
3134 bool _is_unsigned = chkUnsigned.Checked;
3135 SearchType search_type = new SearchType();
3136 SearchDataTypes _data_type = new SearchDataTypes();
3137 SearchCompareTypes _compare_type = new SearchCompareTypes();
3138 CompareValueTypes _compare_value_type = new CompareValueTypes();
3139 object start_value = 0;
3140 object end_value = 0;
3141 // get datatype
3142 if (radio_8bits.Checked) { _data_type = SearchDataTypes._8bits; }
3143 else if (radio_16bits.Checked) { _data_type = SearchDataTypes._16bits; }
3144 else if (radio_32bits.Checked) { _data_type = SearchDataTypes._32bits; }
3145 else if (radio_64bits.Checked) { _data_type = SearchDataTypes._64bits; }
3146 else { logger.Error.WriteLine("Could not determine search data type bit size. (was not 8/16/32/or 64bits)"); }
3147 // get compare type
3148 if (radiocompare_equal.Checked) { _compare_type = SearchCompareTypes.Equal; }
3149 else if (radiocompare_greaterthan.Checked) { _compare_type = SearchCompareTypes.GreaterThan; }
3150 else if (radiocompare_lessthan.Checked) { _compare_type = SearchCompareTypes.LessThan; }
3151 else if (radiocompare_greaterthan_orequal.Checked) { _compare_type = SearchCompareTypes.GreaterThanOrEqual; }
3152 else if (radiocompare_lessthan_orequal.Checked) { _compare_type = SearchCompareTypes.LessThanOrEqual; }
3153 else if (radiocompare_notequal.Checked) { _compare_type = SearchCompareTypes.NotEqual; }
3154 else if (radiocompare_between.Checked) { _compare_type = SearchCompareTypes.Between; }
3155 else if (radiocompare_notbetween.Checked) { _compare_type = SearchCompareTypes.NotBetween; }
3156 else { logger.Error.WriteLine("Could not determine search comparison type. (was not == > < >= <= != <> or !<>)"); }
3157 // get compare valure type
3158 if (radio_oldvalue.Checked) { _compare_value_type = CompareValueTypes.OldValue; }
3159 else if (radio_specificvalue.Checked) { _compare_value_type = CompareValueTypes.SpecificValue; }
3160 else { logger.Error.WriteLine("Could not determine search comparison type. (was not old or specific value"); }
3161
3162 if (_compare_value_type == CompareValueTypes.SpecificValue || (_compare_type == SearchCompareTypes.Between || _compare_type == SearchCompareTypes.NotBetween))
3163 {
3164
3165 switch (_data_type)
3166 {
3167 case SearchDataTypes._8bits:
3168 if (_is_unsigned) { start_value = txtStartAddr.ToByte(); }
3169 else { start_value = txtStartAddr.ToSByte(); }
3170 break;
3171 case SearchDataTypes._16bits:
3172 if (_is_unsigned) { start_value = txtStartAddr.ToUInt16(); }
3173 else { start_value = txtStartAddr.ToInt16(); }
3174 break;
3175 case SearchDataTypes._32bits:
3176 if (_is_unsigned) { start_value = txtStartAddr.ToUInt32(); }
3177 else { start_value = txtStartAddr.ToInt32(); }
3178 break;
3179 case SearchDataTypes._64bits:
3180 if (_is_unsigned) { start_value = txtStartAddr.ToUInt64(); }
3181 else { start_value = txtStartAddr.ToInt64(); }
3182 break;
3183 default: throw new InvalidOperationException("In SearchType(): Encounterd an Unkown Search Data Type.");
3184 }
3185 }
3186 if (_compare_type == SearchCompareTypes.Between || _compare_type == SearchCompareTypes.NotBetween)
3187 {
3188 switch (_data_type)
3189 {
3190 case SearchDataTypes._8bits:
3191 if (_is_unsigned) { end_value = txtEndAddr.ToByte(); }
3192 else { end_value = txtEndAddr.ToSByte(); }
3193 break;
3194 case SearchDataTypes._16bits:
3195 if (_is_unsigned) { end_value = txtEndAddr.ToUInt16(); }
3196 else { end_value = txtEndAddr.ToInt16(); }
3197 break;
3198 case SearchDataTypes._32bits:
3199 if (_is_unsigned) { end_value = txtEndAddr.ToUInt32(); }
3200 else { end_value = txtEndAddr.ToInt32(); }
3201 break;
3202 case SearchDataTypes._64bits:
3203 if (_is_unsigned) { end_value = txtEndAddr.ToUInt64(); }
3204 else { end_value = txtEndAddr.ToInt64(); }
3205 break;
3206 default: throw new InvalidOperationException("In SearchType(): Encounterd an Unkown Search Data Type.");
3207 }
3208 }
3209
3210 search_type = new SearchType(_data_type, _is_unsigned, _compare_type, _compare_value_type, start_value, end_value, resultsprogress);
3211
3212 //search_type.LogSearchOptions();
3213
3214 search_type.IsFirstSearch = IsFirstSearch;
3215
3216
3217
3218 DoSearch(search_type);
3219 IsFirstSearch = false;
3220 }
3221 private void DoSearch(SearchType args)
3222 {
3223 if (!args.IsFirstSearch && SearchArgs != null)
3224 {
3225 //args.Results.AddRange(SearchArgs.Results.ToArray());
3226 //args.Results = SearchArgs.Results;
3227 }