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

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

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 568 by william, Thu Jun 6 06:23:19 2013 UTC revision 569 by william, Thu Jun 6 06:44:39 2013 UTC
# Line 1552  namespace RomCheater.Docking Line 1552  namespace RomCheater.Docking
1552                          #region result writing                          #region result writing
1553                          using (SearchResultWriter writer = new SearchResultWriter(0, new_SearchGuid))                          using (SearchResultWriter writer = new SearchResultWriter(0, new_SearchGuid))
1554                          {                          {
                             Last_Whole_Percent_Done = 0;  
                             //int index = 0;  
1555    
1556                              provider.OpenProvider();                              if (SearchWorkerThread.CancellationPending)
                             //int count = (int)((MemoryRangeSize - MemoryRangeStart) / STEP_SIZE);  
                             //SearchResultWriter writer = new SearchResultWriter((int)(count), SearchGuid);                                  
                             uint size = 0;                            
                             switch (sdt)  
1557                              {                              {
1558                                  case SearchDataTypes._8bits: size = (MEM_CHUNK_SIZE / BitTools.SizeOf<uint>(sdt)); break;                                  provider_st.Stop();
1559                                  case SearchDataTypes._16bits: size = (MEM_CHUNK_SIZE / BitTools.SizeOf<uint>(sdt)); break;                                  st.Stop();
1560                                  case SearchDataTypes._32bits: size = (MEM_CHUNK_SIZE / BitTools.SizeOf<uint>(sdt)); break;                                  writer.CancelRequest();
1561                                  case SearchDataTypes._64bits: size = (MEM_CHUNK_SIZE / BitTools.SizeOf<uint>(sdt)); break;                                  writer.Dispose();
1562                                    e.Result = true;
1563                                    provider.CloseProvider();
1564                                    return;
1565                              }                              }
                             //size = STEP_SIZE * 4096;  
                             for (uint i = MemoryRangeStart; i < MemoryRangeSize; i += size)  
                             {  
1566    
1567                                  int bytesRead = 0;  
1568                                  byte[] data = new byte[size];                              for (int i = 0; i < reader_addresses.Length; i++)
1569                                  provider.ReadProcessMemoryAtOnce(i, size, out bytesRead, out data);                              {
1570                                  string message = string.Format(" -> Reading Address: 0x{0:x8}", (i + MemoryRangeStart));                                  if (SearchWorkerThread.CancellationPending)
                                 double double_percent_done = 100.0 * (double)((double)i / (double)MemoryRangeSize);  
                                 int int_percent_done = (int)double_percent_done;  
                                 if ((int_percent_done != Last_Whole_Percent_Done))// && (i % 10000) == 0)  
1571                                  {                                  {
1572                                      UpdateProgress(int_percent_done, message);                                      provider_st.Stop();
1573                                      Last_Whole_Percent_Done = int_percent_done;                                      st.Stop();
1574                                        writer.CancelRequest();
1575                                        writer.Dispose();
1576                                        e.Result = true;
1577                                        provider.CloseProvider();
1578                                        return;
1579                                  }                                  }
1580                                    var address = reader_addresses[i];
1581                                    provider.OpenProvider();
1582    
1583                                    int bytesRead =0;
1584                                    byte[] data = new byte[STEP_SIZE];
1585                                    provider.ReadProcessMemory(address, 0, out bytesRead, out data);
1586    
                                 uint address_index = i;  
                                 int inner_Last_Whole_Percent_Done = 0;  
                                 #region comparison and serialization  
1587                                  switch (sdt)                                  switch (sdt)
1588                                  {                                  {
1589                                      case SearchDataTypes._8bits:                                      case SearchDataTypes._8bits:
1590                                          if (unsigned)                                          if (unsigned)
1591                                          {                                          {
1592                                              #region 8bits - unsigned                                              #region 8bits - unsigned
1593                                              var t_data = data;                                              byte Value = data[0];
1594                                              foreach (var Value in t_data)                                              using (_8bit_unsigned_comparer_ comparer = new _8bit_unsigned_comparer_(SearchArgs, address))
1595                                              {                                              {
1596                                                  string inner_message = string.Format(" -> Parsing value @ Address: 0x{0:x8}", address_index);                                                  byte value = 0;
1597                                                  double inner_double_percent_done = 100.0 * (double)((double)address_index / (double)MemoryRangeSize);                                                  if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
                                                 int inner_int_percent_done = (int)inner_double_percent_done;  
                                                 if ((address_index % 10000) == 0)  
                                                 {  
                                                     UpdateProgress(inner_int_percent_done, inner_message);  
                                                     inner_Last_Whole_Percent_Done = inner_int_percent_done;  
                                                 }  
                                                 if (SearchWorkerThread.CancellationPending) { break; }  
                                                 if (!reader_addresses.Contains(address_index))  
                                                 {  
                                                     address_index += STEP_SIZE;  
                                                     continue;  
                                                 }  
                                                 using (_8bit_unsigned_comparer_ comparer = new _8bit_unsigned_comparer_(SearchArgs, address_index))  
1598                                                  {                                                  {
1599                                                      byte value = 0;                                                      using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
                                                     if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
1600                                                      {                                                      {
1601                                                          using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))                                                          try
1602                                                          {                                                          {
1603                                                              try                                                              gmp.OpenProvider();
1604                                                              {                                                              gmp.ReadMemory(address, out value);
1605                                                                  gmp.OpenProvider();                                                              gmp.CloseProvider();
                                                                 gmp.ReadMemory(address_index, out value);  
                                                                 gmp.CloseProvider();  
                                                             }  
                                                             catch (Exception ex)  
                                                             {  
                                                                 logger.VerboseError.WriteLine(ex.ToString());  
                                                             }  
1606                                                          }                                                          }
1607                                                          comparer.Value = value;                                                          catch (Exception ex)
                                                     }  
                                                     else  
                                                     {  
                                                         value = Convert.ToByte(SearchArgs.CompareStartValue);  
                                                         comparer.Value = value;  
                                                     }  
                                                     if (comparer.Compare(Convert.ToByte(Value), value))  
                                                     {  
                                                         writer.WriteResult<byte>(comparer.Address, comparer.Value);  
                                                     }  
                                                 }  
                                                 address_index += STEP_SIZE;  
                                             }  
                                             #endregion  
                                         }  
                                         else  
                                         {  
                                             #region 8bits - signed  
                                             var t_data = data;  
                                             foreach (var Value in t_data)  
                                             {  
                                                 string inner_message = string.Format(" -> Parsing value @ Address: 0x{0:x8} of 0x{1:x8}", address_index, MemoryRangeSize);  
                                                 double inner_double_percent_done = 100.0 * (double)((double)address_index / (double)MemoryRangeSize);  
                                                 int inner_int_percent_done = (int)inner_double_percent_done;  
                                                 if ((address_index % 10000) == 0)  
                                                 {  
                                                     UpdateProgress(inner_int_percent_done, inner_message);  
                                                     inner_Last_Whole_Percent_Done = inner_int_percent_done;  
                                                 }  
                                                 if (SearchWorkerThread.CancellationPending) { break; }  
                                                 if (!reader_addresses.Contains(address_index))  
                                                 {  
                                                     address_index += STEP_SIZE;  
                                                     continue;  
                                                 }  
                                                 using (_8bit_signed_comparer_ comparer = new _8bit_signed_comparer_(SearchArgs, address_index))  
                                                 {  
                                                     sbyte value = 0;  
                                                     if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
                                                     {  
                                                         using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))  
1608                                                          {                                                          {
1609                                                              try                                                              logger.VerboseError.WriteLine(ex.ToString());
                                                             {  
                                                                 gmp.OpenProvider();  
                                                                 gmp.ReadMemory(address_index, out value);  
                                                                 gmp.CloseProvider();  
                                                             }  
                                                             catch (Exception ex)  
                                                             {  
                                                                 logger.VerboseError.WriteLine(ex.ToString());  
                                                             }  
1610                                                          }                                                          }
                                                         comparer.Value = value;  
                                                     }  
                                                     else  
                                                     {  
                                                         value = Convert.ToSByte(SearchArgs.CompareStartValue);  
                                                         comparer.Value = value;  
1611                                                      }                                                      }
1612                                                      if (comparer.Compare(Convert.ToSByte(Value), value))                                                      comparer.Value = value;
                                                     {  
                                                         writer.WriteResult<sbyte>(comparer.Address, comparer.Value);  
                                                     }  
                                                 }  
                                                 address_index += STEP_SIZE;  
                                             }  
                                             #endregion  
                                         } break;  
                                     case SearchDataTypes._16bits:  
                                         if (unsigned)  
                                         {  
                                             #region 16bits - unsigned  
                                             var t_data = BitTools.ConvertByteArray<ushort>(data, new Func<bool>(ShouldCancelAnySearchOperation));  
                                             foreach (var Value in t_data)  
                                             {  
                                                 string inner_message = string.Format(" -> Parsing value @ Address: 0x{0:x8}", address_index);  
                                                 double inner_double_percent_done = 100.0 * (double)((double)address_index / (double)MemoryRangeSize);  
                                                 int inner_int_percent_done = (int)inner_double_percent_done;  
                                                 if ((address_index % 10000) == 0)  
                                                 {  
                                                     UpdateProgress(inner_int_percent_done, inner_message);  
                                                     inner_Last_Whole_Percent_Done = inner_int_percent_done;  
1613                                                  }                                                  }
1614                                                  if (SearchWorkerThread.CancellationPending) { break; }                                                  else
                                                 if (!reader_addresses.Contains(address_index))  
1615                                                  {                                                  {
1616                                                      address_index += STEP_SIZE;                                                      value = Convert.ToByte(SearchArgs.CompareStartValue);
1617                                                      continue;                                                      comparer.Value = value;
1618                                                  }                                                  }
1619                                                  using (_16bit_unsigned_comparer_ comparer = new _16bit_unsigned_comparer_(SearchArgs, address_index))                                                  if (comparer.Compare(Convert.ToByte(Value), value))
1620                                                  {                                                  {
1621                                                      ushort value = 0;                                                      writer.WriteResult<ushort>(comparer.Address, comparer.Value);
                                                     if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
                                                     {  
                                                         using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))  
                                                         {  
                                                             try  
                                                             {  
                                                                 gmp.OpenProvider();  
                                                                 gmp.ReadMemory(address_index, out value);  
                                                                 gmp.CloseProvider();  
                                                             }  
                                                             catch (Exception ex)  
                                                             {  
                                                                 logger.VerboseError.WriteLine(ex.ToString());  
                                                             }  
                                                         }  
                                                         comparer.Value = value;  
                                                     }  
                                                     else  
                                                     {  
                                                         value = Convert.ToUInt16(SearchArgs.CompareStartValue);  
                                                         comparer.Value = value;  
                                                     }  
                                                     if (comparer.Compare(Convert.ToUInt16(Value), value))  
                                                     {  
                                                         writer.WriteResult<ushort>(comparer.Address, comparer.Value);  
                                                     }  
1622                                                  }                                                  }
                                                 address_index += STEP_SIZE;  
1623                                              }                                              }
1624                                              #endregion                                              #endregion
1625                                          }                                          }
1626                                          else                                          else
1627                                          {                                          {
1628                                              #region 16bits - signed                                              sbyte value = Convert.ToSByte(data[0]);
                                             var t_data = BitTools.ConvertByteArray<short>(data, new Func<bool>(ShouldCancelAnySearchOperation));  
                                             foreach (var Value in t_data)  
                                             {  
                                                 string inner_message = string.Format(" -> Parsing value @ Address: 0x{0:x8}", address_index);  
                                                 double inner_double_percent_done = 100.0 * (double)((double)address_index / (double)MemoryRangeSize);  
                                                 int inner_int_percent_done = (int)inner_double_percent_done;  
                                                 if ((address_index % 10000) == 0)  
                                                 {  
                                                     UpdateProgress(inner_int_percent_done, inner_message);  
                                                     inner_Last_Whole_Percent_Done = inner_int_percent_done;  
                                                 }  
                                                 if (SearchWorkerThread.CancellationPending) { break; }  
                                                 if (!reader_addresses.Contains(address_index))  
                                                 {  
                                                     address_index += STEP_SIZE;  
                                                     continue;  
                                                 }  
                                                 using (_16bit_signed_comparer_ comparer = new _16bit_signed_comparer_(SearchArgs, address_index))  
                                                 {  
                                                     short value = 0;  
                                                     if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
                                                     {  
                                                         using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))  
                                                         {  
                                                             try  
                                                             {  
                                                                 gmp.OpenProvider();  
                                                                 gmp.ReadMemory(address_index, out value);  
                                                                 gmp.CloseProvider();  
                                                             }  
                                                             catch (Exception ex)  
                                                             {  
                                                                 logger.VerboseError.WriteLine(ex.ToString());  
                                                             }  
                                                         }  
                                                         comparer.Value = value;  
                                                     }  
                                                     else  
                                                     {  
                                                         value = Convert.ToInt16(SearchArgs.CompareStartValue);  
                                                         comparer.Value = value;  
                                                     }  
                                                     if (comparer.Compare(Convert.ToSByte(Value), value))  
                                                     {  
                                                         writer.WriteResult<short>(comparer.Address, comparer.Value);  
                                                     }  
                                                 }  
                                                 address_index += STEP_SIZE;  
                                             }  
                                             #endregion  
                                         } break;  
                                     case SearchDataTypes._32bits:  
                                         if (unsigned)  
                                         {  
                                             #region 32bits - unsigned  
                                             var t_data = BitTools.ConvertByteArray<uint>(data, new Func<bool>(ShouldCancelAnySearchOperation));  
                                             foreach (var Value in t_data)  
                                             {  
                                                 string inner_message = string.Format(" -> Parsing value @ Address: 0x{0:x8}", address_index);  
                                                 double inner_double_percent_done = 100.0 * (double)((double)address_index / (double)MemoryRangeSize);  
                                                 int inner_int_percent_done = (int)inner_double_percent_done;  
                                                 if ((address_index % 10000) == 0)  
                                                 {  
                                                     UpdateProgress(inner_int_percent_done, inner_message);  
                                                     inner_Last_Whole_Percent_Done = inner_int_percent_done;  
                                                 }  
                                                 if (SearchWorkerThread.CancellationPending) { break; }  
                                                 if (!reader_addresses.Contains(address_index))  
                                                 {  
                                                     address_index += STEP_SIZE;  
                                                     continue;  
                                                 }  
                                                 using (_32bit_unsigned_comparer_ comparer = new _32bit_unsigned_comparer_(SearchArgs, address_index))  
                                                 {  
                                                     uint value = 0;  
                                                     if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
                                                     {  
                                                         using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))  
                                                         {  
                                                             try  
                                                             {  
                                                                 gmp.OpenProvider();  
                                                                 gmp.ReadMemory(address_index, out value);  
                                                                 gmp.CloseProvider();  
                                                             }  
                                                             catch (Exception ex)  
                                                             {  
                                                                 logger.VerboseError.WriteLine(ex.ToString());  
                                                             }  
                                                         }  
                                                         comparer.Value = value;  
                                                     }  
                                                     else  
                                                     {  
                                                         value = Convert.ToUInt32(SearchArgs.CompareStartValue);  
                                                         comparer.Value = value;  
                                                     }  
                                                     if (comparer.Compare(Convert.ToUInt32(Value), value))  
                                                     {  
                                                         writer.WriteResult<uint>(comparer.Address, comparer.Value);  
                                                     }  
                                                 }  
                                                 address_index += STEP_SIZE;  
                                             }  
                                             #endregion  
1629                                          }                                          }
1630                                          else                                          break;
1631                                          {                                      case SearchDataTypes._16bits:
1632                                              #region 32bits - signed                                          break;
1633                                              var t_data = BitTools.ConvertByteArray<int>(data, new Func<bool>(ShouldCancelAnySearchOperation));                                      case SearchDataTypes._32bits:
1634                                              foreach (var Value in t_data)                                          break;
                                             {  
                                                 string inner_message = string.Format(" -> Parsing value @ Address: 0x{0:x8}", address_index);  
                                                 double inner_double_percent_done = 100.0 * (double)((double)address_index / (double)MemoryRangeSize);  
                                                 int inner_int_percent_done = (int)inner_double_percent_done;  
                                                 if ((address_index % 10000) == 0)  
                                                 {  
                                                     UpdateProgress(inner_int_percent_done, inner_message);  
                                                     inner_Last_Whole_Percent_Done = inner_int_percent_done;  
                                                 }  
                                                 if (SearchWorkerThread.CancellationPending) { break; }  
                                                 if (!reader_addresses.Contains(address_index))  
                                                 {  
                                                     address_index += STEP_SIZE;  
                                                     continue;  
                                                 }  
                                                 using (_32bit_signed_comparer_ comparer = new _32bit_signed_comparer_(SearchArgs, address_index))  
                                                 {  
                                                     int value = 0;  
                                                     if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
                                                     {  
                                                         using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))  
                                                         {  
                                                             try  
                                                             {  
                                                                 gmp.OpenProvider();  
                                                                 gmp.ReadMemory(address_index, out value);  
                                                                 gmp.CloseProvider();  
                                                             }  
                                                             catch (Exception ex)  
                                                             {  
                                                                 logger.VerboseError.WriteLine(ex.ToString());  
                                                             }  
                                                         }  
                                                         comparer.Value = value;  
                                                     }  
                                                     else  
                                                     {  
                                                         value = Convert.ToInt32(SearchArgs.CompareStartValue);  
                                                         comparer.Value = value;  
                                                     }  
                                                     if (comparer.Compare(Convert.ToInt32(Value), value))  
                                                     {  
                                                         writer.WriteResult<int>(comparer.Address, comparer.Value);  
                                                     }  
                                                 }  
                                                 address_index += STEP_SIZE;  
                                             }  
                                             #endregion  
                                         } break;  
1635                                      case SearchDataTypes._64bits:                                      case SearchDataTypes._64bits:
1636                                          if (unsigned)                                          break;
                                         {  
                                             #region 64bits - unsigned  
                                             var t_data = BitTools.ConvertByteArray<ulong>(data, new Func<bool>(ShouldCancelAnySearchOperation));  
                                             foreach (var Value in t_data)  
                                             {  
                                                 string inner_message = string.Format(" -> Parsing value @ Address: 0x{0:x8}", address_index);  
                                                 double inner_double_percent_done = 100.0 * (double)((double)address_index / (double)MemoryRangeSize);  
                                                 int inner_int_percent_done = (int)inner_double_percent_done;  
                                                 if ((address_index % 10000) == 0)  
                                                 {  
                                                     UpdateProgress(inner_int_percent_done, inner_message);  
                                                     inner_Last_Whole_Percent_Done = inner_int_percent_done;  
                                                 }  
                                                 if (SearchWorkerThread.CancellationPending) { break; }  
                                                 if (!reader_addresses.Contains(address_index))  
                                                 {  
                                                     address_index += STEP_SIZE;  
                                                     continue;  
                                                 }  
                                                 using (_64bit_unsigned_comparer_ comparer = new _64bit_unsigned_comparer_(SearchArgs, address_index))  
                                                 {  
                                                     ulong value = 0;  
                                                     if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
                                                     {  
                                                         using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))  
                                                         {  
                                                             try  
                                                             {  
                                                                 gmp.OpenProvider();  
                                                                 gmp.ReadMemory(address_index, out value);  
                                                                 gmp.CloseProvider();  
                                                             }  
                                                             catch (Exception ex)  
                                                             {  
                                                                 logger.VerboseError.WriteLine(ex.ToString());  
                                                             }  
                                                         }  
                                                         comparer.Value = value;  
                                                     }  
                                                     else  
                                                     {  
                                                         value = Convert.ToUInt64(SearchArgs.CompareStartValue);  
                                                         comparer.Value = value;  
                                                     }  
                                                     if (comparer.Compare(Convert.ToUInt64(Value), value))  
                                                     {  
                                                         writer.WriteResult<ulong>(comparer.Address, comparer.Value);  
                                                     }  
                                                 }  
                                                 address_index += STEP_SIZE;  
                                             }  
                                             #endregion  
                                         }  
                                         else  
                                         {  
                                             #region 64bits - signed  
                                             var t_data = BitTools.ConvertByteArray<long>(data, new Func<bool>(ShouldCancelAnySearchOperation));  
                                             foreach (var Value in t_data)  
                                             {  
                                                 string inner_message = string.Format(" -> Parsing value @ Address: 0x{0:x8}", address_index);  
                                                 double inner_double_percent_done = 100.0 * (double)((double)address_index / (double)MemoryRangeSize);  
                                                 int inner_int_percent_done = (int)inner_double_percent_done;  
                                                 if ((address_index % 10000) == 0)  
                                                 {  
                                                     UpdateProgress(inner_int_percent_done, inner_message);  
                                                     inner_Last_Whole_Percent_Done = inner_int_percent_done;  
                                                 }  
                                                 if (SearchWorkerThread.CancellationPending) { break; }  
                                                 if (!reader_addresses.Contains(address_index))  
                                                 {  
                                                     address_index += STEP_SIZE;  
                                                     continue;  
                                                 }  
                                                 using (_64bit_signed_comparer_ comparer = new _64bit_signed_comparer_(SearchArgs, address_index))  
                                                 {  
                                                     long value = 0;  
                                                     if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)  
                                                     {  
                                                         using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))  
                                                         {  
                                                             try  
                                                             {  
                                                                 gmp.OpenProvider();  
                                                                 gmp.ReadMemory(address_index, out value);  
                                                                 gmp.CloseProvider();  
                                                             }  
                                                             catch (Exception ex)  
                                                             {  
                                                                 logger.VerboseError.WriteLine(ex.ToString());  
                                                             }  
                                                         }  
                                                         comparer.Value = value;  
                                                     }  
                                                     else  
                                                     {  
                                                         value = Convert.ToInt64(SearchArgs.CompareStartValue);  
                                                         comparer.Value = value;  
                                                     }  
                                                     if (comparer.Compare(Convert.ToInt64(Value), value))  
                                                     {  
                                                         writer.WriteResult<long>(comparer.Address, comparer.Value);  
                                                     }  
                                                 }  
                                                 address_index += STEP_SIZE;  
                                             }  
                                             #endregion  
                                         } break;  
   
1637                                  }                                  }
                                 #endregion  
1638    
1639                                  if (SearchWorkerThread.CancellationPending)                                  provider.CloseProvider();
                                 {  
                                     provider_st.Stop();  
                                     st.Stop();  
                                     writer.CancelRequest();  
                                     writer.Dispose();  
                                     e.Result = true;  
                                     provider.CloseProvider();  
                                     return;  
                                 }  
1640                              }                              }
1641    
1642                                #region old-code:
1643                                //Last_Whole_Percent_Done = 0;
1644                                ////int index = 0;
1645    
1646                                //provider.OpenProvider();
1647                                ////int count = (int)((MemoryRangeSize - MemoryRangeStart) / STEP_SIZE);
1648                                ////SearchResultWriter writer = new SearchResultWriter((int)(count), SearchGuid);                                
1649                                //uint size = 0;
1650                                //switch (sdt)
1651                                //{
1652                                //    case SearchDataTypes._8bits: size = (MEM_CHUNK_SIZE / BitTools.SizeOf<uint>(sdt)); break;
1653                                //    case SearchDataTypes._16bits: size = (MEM_CHUNK_SIZE / BitTools.SizeOf<uint>(sdt)); break;
1654                                //    case SearchDataTypes._32bits: size = (MEM_CHUNK_SIZE / BitTools.SizeOf<uint>(sdt)); break;
1655                                //    case SearchDataTypes._64bits: size = (MEM_CHUNK_SIZE / BitTools.SizeOf<uint>(sdt)); break;
1656                                //}
1657                                ////size = STEP_SIZE * 4096;
1658                                //for (uint i = MemoryRangeStart; i < MemoryRangeSize; i += size)
1659                                //{
1660                                //    int bytesRead = 0;
1661                                //    byte[] data = new byte[size];
1662                                //    provider.ReadProcessMemoryAtOnce(i, size, out bytesRead, out data);
1663                                //    string message = string.Format(" -> Reading Address: 0x{0:x8}", (i + MemoryRangeStart));
1664                                //    double double_percent_done = 100.0 * (double)((double)i / (double)MemoryRangeSize);
1665                                //    int int_percent_done = (int)double_percent_done;
1666                                //    if ((int_percent_done != Last_Whole_Percent_Done))// && (i % 10000) == 0)
1667                                //    {
1668                                //        UpdateProgress(int_percent_done, message);
1669                                //        Last_Whole_Percent_Done = int_percent_done;
1670                                //    }
1671                                //    uint address_index = i;
1672                                //    int inner_Last_Whole_Percent_Done = 0;
1673                                //    #region comparison and serialization
1674                                //    switch (sdt)
1675                                //    {
1676                                //        case SearchDataTypes._8bits:
1677                                //            if (unsigned)
1678                                //            {
1679                                //                #region 8bits - unsigned
1680                                //                var t_data = data;
1681                                //                foreach (var Value in t_data)
1682                                //                {
1683                                //                    string inner_message = string.Format(" -> Parsing value @ Address: 0x{0:x8}", address_index);
1684                                //                    double inner_double_percent_done = 100.0 * (double)((double)address_index / (double)MemoryRangeSize);
1685                                //                    int inner_int_percent_done = (int)inner_double_percent_done;
1686                                //                    if ((address_index % 10000) == 0)
1687                                //                    {
1688                                //                        UpdateProgress(inner_int_percent_done, inner_message);
1689                                //                        inner_Last_Whole_Percent_Done = inner_int_percent_done;
1690                                //                    }
1691                                //                    if (SearchWorkerThread.CancellationPending) { break; }
1692                                //                    if (!reader_addresses.Contains(address_index))
1693                                //                    {
1694                                //                        address_index += STEP_SIZE;
1695                                //                        continue;
1696                                //                    }
1697                                //                    else
1698                                //                    {
1699                                //                        writer.WriteResult<byte>(address_index, Value);
1700                                //                    }
1701                                //                    address_index += STEP_SIZE;
1702                                //                }
1703                                //                #endregion
1704                                //            }
1705                                //            else
1706                                //            {
1707                                //                #region 8bits - signed
1708                                //                var t_data = data;
1709                                //                foreach (var Value in t_data)
1710                                //                {
1711                                //                    string inner_message = string.Format(" -> Parsing value @ Address: 0x{0:x8} of 0x{1:x8}", address_index, MemoryRangeSize);
1712                                //                    double inner_double_percent_done = 100.0 * (double)((double)address_index / (double)MemoryRangeSize);
1713                                //                    int inner_int_percent_done = (int)inner_double_percent_done;
1714                                //                    if ((address_index % 10000) == 0)
1715                                //                    {
1716                                //                        UpdateProgress(inner_int_percent_done, inner_message);
1717                                //                        inner_Last_Whole_Percent_Done = inner_int_percent_done;
1718                                //                    }
1719                                //                    if (SearchWorkerThread.CancellationPending) { break; }
1720                                //                    if (!reader_addresses.Contains(address_index))
1721                                //                    {
1722                                //                        address_index += STEP_SIZE;
1723                                //                        continue;
1724                                //                    }
1725                                //                    using (_8bit_signed_comparer_ comparer = new _8bit_signed_comparer_(SearchArgs, address_index))
1726                                //                    {
1727                                //                        sbyte value = 0;
1728                                //                        if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1729                                //                        {
1730                                //                            using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1731                                //                            {
1732                                //                                try
1733                                //                                {
1734                                //                                    gmp.OpenProvider();
1735                                //                                    gmp.ReadMemory(address_index, out value);
1736                                //                                    gmp.CloseProvider();
1737                                //                                }
1738                                //                                catch (Exception ex)
1739                                //                                {
1740                                //                                    logger.VerboseError.WriteLine(ex.ToString());
1741                                //                                }
1742                                //                            }
1743                                //                            comparer.Value = value;
1744                                //                        }
1745                                //                        else
1746                                //                        {
1747                                //                            value = Convert.ToSByte(SearchArgs.CompareStartValue);
1748                                //                            comparer.Value = value;
1749                                //                        }
1750                                //                        if (comparer.Compare(Convert.ToSByte(Value), value))
1751                                //                        {
1752                                //                            writer.WriteResult<sbyte>(comparer.Address, comparer.Value);
1753                                //                        }
1754                                //                    }
1755                                //                    address_index += STEP_SIZE;
1756                                //                }
1757                                //                #endregion
1758                                //            } break;
1759                                //        case SearchDataTypes._16bits:
1760                                //            if (unsigned)
1761                                //            {
1762                                //                #region 16bits - unsigned
1763                                //                var t_data = BitTools.ConvertByteArray<ushort>(data, new Func<bool>(ShouldCancelAnySearchOperation));
1764                                //                foreach (var Value in t_data)
1765                                //                {
1766                                //                    string inner_message = string.Format(" -> Parsing value @ Address: 0x{0:x8}", address_index);
1767                                //                    double inner_double_percent_done = 100.0 * (double)((double)address_index / (double)MemoryRangeSize);
1768                                //                    int inner_int_percent_done = (int)inner_double_percent_done;
1769                                //                    if ((address_index % 10000) == 0)
1770                                //                    {
1771                                //                        UpdateProgress(inner_int_percent_done, inner_message);
1772                                //                        inner_Last_Whole_Percent_Done = inner_int_percent_done;
1773                                //                    }
1774                                //                    if (SearchWorkerThread.CancellationPending) { break; }
1775                                //                    if (!reader_addresses.Contains(address_index))
1776                                //                    {
1777                                //                        address_index += STEP_SIZE;
1778                                //                        continue;
1779                                //                    }
1780                                //                    using (_16bit_unsigned_comparer_ comparer = new _16bit_unsigned_comparer_(SearchArgs, address_index))
1781                                //                    {
1782                                //                        ushort value = 0;
1783                                //                        if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1784                                //                        {
1785                                //                            using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1786                                //                            {
1787                                //                                try
1788                                //                                {
1789                                //                                    gmp.OpenProvider();
1790                                //                                    gmp.ReadMemory(address_index, out value);
1791                                //                                    gmp.CloseProvider();
1792                                //                                }
1793                                //                                catch (Exception ex)
1794                                //                                {
1795                                //                                    logger.VerboseError.WriteLine(ex.ToString());
1796                                //                                }
1797                                //                            }
1798                                //                            comparer.Value = value;
1799                                //                        }
1800                                //                        else
1801                                //                        {
1802                                //                            value = Convert.ToUInt16(SearchArgs.CompareStartValue);
1803                                //                            comparer.Value = value;
1804                                //                        }
1805                                //                        if (comparer.Compare(Convert.ToUInt16(Value), value))
1806                                //                        {
1807                                //                            writer.WriteResult<ushort>(comparer.Address, comparer.Value);
1808                                //                        }
1809                                //                    }
1810                                //                    address_index += STEP_SIZE;
1811                                //                }
1812                                //                #endregion
1813                                //            }
1814                                //            else
1815                                //            {
1816                                //                #region 16bits - signed
1817                                //                var t_data = BitTools.ConvertByteArray<short>(data, new Func<bool>(ShouldCancelAnySearchOperation));
1818                                //                foreach (var Value in t_data)
1819                                //                {
1820                                //                    string inner_message = string.Format(" -> Parsing value @ Address: 0x{0:x8}", address_index);
1821                                //                    double inner_double_percent_done = 100.0 * (double)((double)address_index / (double)MemoryRangeSize);
1822                                //                    int inner_int_percent_done = (int)inner_double_percent_done;
1823                                //                    if ((address_index % 10000) == 0)
1824                                //                    {
1825                                //                        UpdateProgress(inner_int_percent_done, inner_message);
1826                                //                        inner_Last_Whole_Percent_Done = inner_int_percent_done;
1827                                //                    }
1828                                //                    if (SearchWorkerThread.CancellationPending) { break; }
1829                                //                    if (!reader_addresses.Contains(address_index))
1830                                //                    {
1831                                //                        address_index += STEP_SIZE;
1832                                //                        continue;
1833                                //                    }
1834                                //                    using (_16bit_signed_comparer_ comparer = new _16bit_signed_comparer_(SearchArgs, address_index))
1835                                //                    {
1836                                //                        short value = 0;
1837                                //                        if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1838                                //                        {
1839                                //                            using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1840                                //                            {
1841                                //                                try
1842                                //                                {
1843                                //                                    gmp.OpenProvider();
1844                                //                                    gmp.ReadMemory(address_index, out value);
1845                                //                                    gmp.CloseProvider();
1846                                //                                }
1847                                //                                catch (Exception ex)
1848                                //                                {
1849                                //                                    logger.VerboseError.WriteLine(ex.ToString());
1850                                //                                }
1851                                //                            }
1852                                //                            comparer.Value = value;
1853                                //                        }
1854                                //                        else
1855                                //                        {
1856                                //                            value = Convert.ToInt16(SearchArgs.CompareStartValue);
1857                                //                            comparer.Value = value;
1858                                //                        }
1859                                //                        if (comparer.Compare(Convert.ToSByte(Value), value))
1860                                //                        {
1861                                //                            writer.WriteResult<short>(comparer.Address, comparer.Value);
1862                                //                        }
1863                                //                    }
1864                                //                    address_index += STEP_SIZE;
1865                                //                }
1866                                //                #endregion
1867                                //            } break;
1868                                //        case SearchDataTypes._32bits:
1869                                //            if (unsigned)
1870                                //            {
1871                                //                #region 32bits - unsigned
1872                                //                var t_data = BitTools.ConvertByteArray<uint>(data, new Func<bool>(ShouldCancelAnySearchOperation));
1873                                //                foreach (var Value in t_data)
1874                                //                {
1875                                //                    string inner_message = string.Format(" -> Parsing value @ Address: 0x{0:x8}", address_index);
1876                                //                    double inner_double_percent_done = 100.0 * (double)((double)address_index / (double)MemoryRangeSize);
1877                                //                    int inner_int_percent_done = (int)inner_double_percent_done;
1878                                //                    if ((address_index % 10000) == 0)
1879                                //                    {
1880                                //                        UpdateProgress(inner_int_percent_done, inner_message);
1881                                //                        inner_Last_Whole_Percent_Done = inner_int_percent_done;
1882                                //                    }
1883                                //                    if (SearchWorkerThread.CancellationPending) { break; }
1884                                //                    if (!reader_addresses.Contains(address_index))
1885                                //                    {
1886                                //                        address_index += STEP_SIZE;
1887                                //                        continue;
1888                                //                    }
1889                                //                    using (_32bit_unsigned_comparer_ comparer = new _32bit_unsigned_comparer_(SearchArgs, address_index))
1890                                //                    {
1891                                //                        uint 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(address_index, 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.ToUInt32(SearchArgs.CompareStartValue);
1912                                //                            comparer.Value = value;
1913                                //                        }
1914                                //                        if (comparer.Compare(Convert.ToUInt32(Value), value))
1915                                //                        {
1916                                //                            writer.WriteResult<uint>(comparer.Address, comparer.Value);
1917                                //                        }
1918                                //                    }
1919                                //                    address_index += STEP_SIZE;
1920                                //                }
1921                                //                #endregion
1922                                //            }
1923                                //            else
1924                                //            {
1925                                //                #region 32bits - signed
1926                                //                var t_data = BitTools.ConvertByteArray<int>(data, new Func<bool>(ShouldCancelAnySearchOperation));
1927                                //                foreach (var Value in t_data)
1928                                //                {
1929                                //                    string inner_message = string.Format(" -> Parsing value @ Address: 0x{0:x8}", address_index);
1930                                //                    double inner_double_percent_done = 100.0 * (double)((double)address_index / (double)MemoryRangeSize);
1931                                //                    int inner_int_percent_done = (int)inner_double_percent_done;
1932                                //                    if ((address_index % 10000) == 0)
1933                                //                    {
1934                                //                        UpdateProgress(inner_int_percent_done, inner_message);
1935                                //                        inner_Last_Whole_Percent_Done = inner_int_percent_done;
1936                                //                    }
1937                                //                    if (SearchWorkerThread.CancellationPending) { break; }
1938                                //                    if (!reader_addresses.Contains(address_index))
1939                                //                    {
1940                                //                        address_index += STEP_SIZE;
1941                                //                        continue;
1942                                //                    }
1943                                //                    using (_32bit_signed_comparer_ comparer = new _32bit_signed_comparer_(SearchArgs, address_index))
1944                                //                    {
1945                                //                        int value = 0;
1946                                //                        if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1947                                //                        {
1948                                //                            using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1949                                //                            {
1950                                //                                try
1951                                //                                {
1952                                //                                    gmp.OpenProvider();
1953                                //                                    gmp.ReadMemory(address_index, out value);
1954                                //                                    gmp.CloseProvider();
1955                                //                                }
1956                                //                                catch (Exception ex)
1957                                //                                {
1958                                //                                    logger.VerboseError.WriteLine(ex.ToString());
1959                                //                                }
1960                                //                            }
1961                                //                            comparer.Value = value;
1962                                //                        }
1963                                //                        else
1964                                //                        {
1965                                //                            value = Convert.ToInt32(SearchArgs.CompareStartValue);
1966                                //                            comparer.Value = value;
1967                                //                        }
1968                                //                        if (comparer.Compare(Convert.ToInt32(Value), value))
1969                                //                        {
1970                                //                            writer.WriteResult<int>(comparer.Address, comparer.Value);
1971                                //                        }
1972                                //                    }
1973                                //                    address_index += STEP_SIZE;
1974                                //                }
1975                                //                #endregion
1976                                //            } break;
1977                                //        case SearchDataTypes._64bits:
1978                                //            if (unsigned)
1979                                //            {
1980                                //                #region 64bits - unsigned
1981                                //                var t_data = BitTools.ConvertByteArray<ulong>(data, new Func<bool>(ShouldCancelAnySearchOperation));
1982                                //                foreach (var Value in t_data)
1983                                //                {
1984                                //                    string inner_message = string.Format(" -> Parsing value @ Address: 0x{0:x8}", address_index);
1985                                //                    double inner_double_percent_done = 100.0 * (double)((double)address_index / (double)MemoryRangeSize);
1986                                //                    int inner_int_percent_done = (int)inner_double_percent_done;
1987                                //                    if ((address_index % 10000) == 0)
1988                                //                    {
1989                                //                        UpdateProgress(inner_int_percent_done, inner_message);
1990                                //                        inner_Last_Whole_Percent_Done = inner_int_percent_done;
1991                                //                    }
1992                                //                    if (SearchWorkerThread.CancellationPending) { break; }
1993                                //                    if (!reader_addresses.Contains(address_index))
1994                                //                    {
1995                                //                        address_index += STEP_SIZE;
1996                                //                        continue;
1997                                //                    }
1998                                //                    using (_64bit_unsigned_comparer_ comparer = new _64bit_unsigned_comparer_(SearchArgs, address_index))
1999                                //                    {
2000                                //                        ulong value = 0;
2001                                //                        if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
2002                                //                        {
2003                                //                            using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
2004                                //                            {
2005                                //                                try
2006                                //                                {
2007                                //                                    gmp.OpenProvider();
2008                                //                                    gmp.ReadMemory(address_index, out value);
2009                                //                                    gmp.CloseProvider();
2010                                //                                }
2011                                //                                catch (Exception ex)
2012                                //                                {
2013                                //                                    logger.VerboseError.WriteLine(ex.ToString());
2014                                //                                }
2015                                //                            }
2016                                //                            comparer.Value = value;
2017                                //                        }
2018                                //                        else
2019                                //                        {
2020                                //                            value = Convert.ToUInt64(SearchArgs.CompareStartValue);
2021                                //                            comparer.Value = value;
2022                                //                        }
2023                                //                        if (comparer.Compare(Convert.ToUInt64(Value), value))
2024                                //                        {
2025                                //                            writer.WriteResult<ulong>(comparer.Address, comparer.Value);
2026                                //                        }
2027                                //                    }
2028                                //                    address_index += STEP_SIZE;
2029                                //                }
2030                                //                #endregion
2031                                //            }
2032                                //            else
2033                                //            {
2034                                //                #region 64bits - signed
2035                                //                var t_data = BitTools.ConvertByteArray<long>(data, new Func<bool>(ShouldCancelAnySearchOperation));
2036                                //                foreach (var Value in t_data)
2037                                //                {
2038                                //                    string inner_message = string.Format(" -> Parsing value @ Address: 0x{0:x8}", address_index);
2039                                //                    double inner_double_percent_done = 100.0 * (double)((double)address_index / (double)MemoryRangeSize);
2040                                //                    int inner_int_percent_done = (int)inner_double_percent_done;
2041                                //                    if ((address_index % 10000) == 0)
2042                                //                    {
2043                                //                        UpdateProgress(inner_int_percent_done, inner_message);
2044                                //                        inner_Last_Whole_Percent_Done = inner_int_percent_done;
2045                                //                    }
2046                                //                    if (SearchWorkerThread.CancellationPending) { break; }
2047                                //                    if (!reader_addresses.Contains(address_index))
2048                                //                    {
2049                                //                        address_index += STEP_SIZE;
2050                                //                        continue;
2051                                //                    }
2052                                //                    using (_64bit_signed_comparer_ comparer = new _64bit_signed_comparer_(SearchArgs, address_index))
2053                                //                    {
2054                                //                        long value = 0;
2055                                //                        if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
2056                                //                        {
2057                                //                            using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
2058                                //                            {
2059                                //                                try
2060                                //                                {
2061                                //                                    gmp.OpenProvider();
2062                                //                                    gmp.ReadMemory(address_index, out value);
2063                                //                                    gmp.CloseProvider();
2064                                //                                }
2065                                //                                catch (Exception ex)
2066                                //                                {
2067                                //                                    logger.VerboseError.WriteLine(ex.ToString());
2068                                //                                }
2069                                //                            }
2070                                //                            comparer.Value = value;
2071                                //                        }
2072                                //                        else
2073                                //                        {
2074                                //                            value = Convert.ToInt64(SearchArgs.CompareStartValue);
2075                                //                            comparer.Value = value;
2076                                //                        }
2077                                //                        if (comparer.Compare(Convert.ToInt64(Value), value))
2078                                //                        {
2079                                //                            writer.WriteResult<long>(comparer.Address, comparer.Value);
2080                                //                        }
2081                                //                    }
2082                                //                    address_index += STEP_SIZE;
2083                                //                }
2084                                //                #endregion
2085                                //            } break;
2086                                //    }
2087                                //    #endregion
2088                                //    if (SearchWorkerThread.CancellationPending)
2089                                //    {
2090                                //        provider_st.Stop();
2091                                //        st.Stop();
2092                                //        writer.CancelRequest();
2093                                //        writer.Dispose();
2094                                //        e.Result = true;
2095                                //        provider.CloseProvider();
2096                                //        return;
2097                                //    }
2098                                //}
2099                                #endregion
2100                          }                          }
2101                          #endregion                          #endregion
2102    

Legend:
Removed from v.568  
changed lines
  Added in v.569

  ViewVC Help
Powered by ViewVC 1.1.22