/[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 473 by william, Mon Jun 3 09:21:03 2013 UTC revision 474 by william, Mon Jun 3 16:48:28 2013 UTC
# Line 1056  namespace RomCheater.Docking Line 1056  namespace RomCheater.Docking
1056                  Debug.WriteLine(ex.ToString());                  Debug.WriteLine(ex.ToString());
1057              }              }
1058          }          }
1059            private void search_provider_OnBytesRead_compare_only(OnBytesReadEventArgs e)
1060            {
1061                if (SearchWorkerThread.CancellationPending) { e.Canceled = true; return; }
1062                SearchDataTypes sdt = SearchArgs.DataType;
1063                bool unsigned = SearchArgs.IsUnsignedDataType;
1064                //int Last_Whole_Percent_Done = 0;
1065                uint CurrentIndex = e.CurrentIndex;
1066                if (e.UserState != null)
1067                {
1068                    SearchResultWriter writer = (e.UserState as SearchResultWriter);
1069                    if (writer == null)
1070                        throw new InvalidOperationException("writer cannot be null");
1071                    using (MemoryStream ms = new MemoryStream(e.Data))
1072                    {
1073                        using (BinaryReader br = new BinaryReader(ms))
1074                        {
1075                            while (br.BaseStream.Position < br.BaseStream.Length)
1076                            {
1077                                try
1078                                {
1079                                    switch (sdt)
1080                                    {
1081                                        case SearchDataTypes._8bits:
1082                                            if (unsigned)
1083                                            {
1084                                                #region 8bits - unsigned
1085                                                var Value = br.ReadByte();
1086                                                using (_8bit_unsigned_comparer_ comparer = new _8bit_unsigned_comparer_(SearchArgs, CurrentIndex))
1087                                                {
1088                                                    byte value = 0;
1089                                                    if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1090                                                    {
1091                                                        using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1092                                                        {
1093                                                            try
1094                                                            {
1095                                                                gmp.OpenProvider();
1096                                                                gmp.ReadMemory(CurrentIndex, out value);
1097                                                                gmp.CloseProvider();
1098                                                            }
1099                                                            catch (Exception ex)
1100                                                            {
1101                                                                logger.VerboseError.WriteLine(ex.ToString());
1102                                                            }
1103                                                        }
1104                                                        comparer.Value = value;
1105                                                    }
1106                                                    else
1107                                                    {
1108                                                        value = Convert.ToByte(SearchArgs.CompareStartValue);
1109                                                        comparer.Value = value;
1110                                                    }
1111                                                    if (comparer.Compare(Convert.ToByte(Value), value))
1112                                                    {
1113                                                        writer.WriteResult<byte>(comparer.Address, comparer.Value);
1114                                                    }
1115                                                }
1116                                                #endregion
1117                                            }
1118                                            else
1119                                            {
1120                                                #region 8bits - signed
1121                                                var Value = br.ReadSByte();
1122                                                using (_8bit_signed_comparer_ comparer = new _8bit_signed_comparer_(SearchArgs, CurrentIndex))
1123                                                {
1124                                                    sbyte value = 0;
1125                                                    if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1126                                                    {
1127                                                        using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1128                                                        {
1129                                                            try
1130                                                            {
1131                                                                gmp.OpenProvider();
1132                                                                gmp.ReadMemory(CurrentIndex, out value);
1133                                                                gmp.CloseProvider();
1134                                                            }
1135                                                            catch (Exception ex)
1136                                                            {
1137                                                                logger.VerboseError.WriteLine(ex.ToString());
1138                                                            }
1139                                                        }
1140                                                        comparer.Value = value;
1141                                                    }
1142                                                    else
1143                                                    {
1144                                                        value = Convert.ToSByte(SearchArgs.CompareStartValue);
1145                                                        comparer.Value = value;
1146                                                    }
1147                                                    if (comparer.Compare(Convert.ToSByte(Value), value))
1148                                                    {
1149                                                        writer.WriteResult<sbyte>(comparer.Address, comparer.Value);
1150                                                    }
1151                                                }
1152                                                #endregion
1153                                            } break;
1154                                        case SearchDataTypes._16bits:
1155                                            if (unsigned)
1156                                            {
1157                                                #region 16bits - unsigned
1158                                                var Value = br.ReadUInt16();
1159                                                using (_16bit_unsigned_comparer_ comparer = new _16bit_unsigned_comparer_(SearchArgs, CurrentIndex))
1160                                                {
1161                                                    ushort value = 0;
1162                                                    if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1163                                                    {
1164                                                        using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1165                                                        {
1166                                                            try
1167                                                            {
1168                                                                gmp.OpenProvider();
1169                                                                gmp.ReadMemory(CurrentIndex, out value);
1170                                                                gmp.CloseProvider();
1171                                                            }
1172                                                            catch (Exception ex)
1173                                                            {
1174                                                                logger.VerboseError.WriteLine(ex.ToString());
1175                                                            }
1176                                                        }
1177                                                        comparer.Value = value;
1178                                                    }
1179                                                    else
1180                                                    {
1181                                                        value = Convert.ToUInt16(SearchArgs.CompareStartValue);
1182                                                        comparer.Value = value;
1183                                                    }
1184                                                    if (comparer.Compare(Convert.ToUInt16(Value), value))
1185                                                    {
1186                                                        writer.WriteResult<ushort>(comparer.Address, comparer.Value);
1187                                                    }
1188                                                }
1189                                                #endregion
1190                                            }
1191                                            else
1192                                            {
1193                                                #region 16bits - signed
1194                                                var Value = br.ReadInt16();
1195                                                using (_16bit_signed_comparer_ comparer = new _16bit_signed_comparer_(SearchArgs, CurrentIndex))
1196                                                {
1197                                                    short value = 0;
1198                                                    if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1199                                                    {
1200                                                        using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1201                                                        {
1202                                                            try
1203                                                            {
1204                                                                gmp.OpenProvider();
1205                                                                gmp.ReadMemory(CurrentIndex, out value);
1206                                                                gmp.CloseProvider();
1207                                                            }
1208                                                            catch (Exception ex)
1209                                                            {
1210                                                                logger.VerboseError.WriteLine(ex.ToString());
1211                                                            }
1212                                                        }
1213                                                        comparer.Value = value;
1214                                                    }
1215                                                    else
1216                                                    {
1217                                                        value = Convert.ToInt16(SearchArgs.CompareStartValue);
1218                                                        comparer.Value = value;
1219                                                    }
1220                                                    if (comparer.Compare(Convert.ToSByte(Value), value))
1221                                                    {
1222                                                        writer.WriteResult<short>(comparer.Address, comparer.Value);
1223                                                    }
1224                                                }
1225                                                #endregion
1226                                            } break;
1227                                        case SearchDataTypes._32bits:
1228                                            if (unsigned)
1229                                            {
1230                                                #region 32bits - unsigned
1231                                                var Value = br.ReadUInt32();
1232                                                using (_32bit_unsigned_comparer_ comparer = new _32bit_unsigned_comparer_(SearchArgs, CurrentIndex))
1233                                                {
1234                                                    uint value = 0;
1235                                                    if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1236                                                    {
1237                                                        using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1238                                                        {
1239                                                            try
1240                                                            {
1241                                                                gmp.OpenProvider();
1242                                                                gmp.ReadMemory(CurrentIndex, out value);
1243                                                                gmp.CloseProvider();
1244                                                            }
1245                                                            catch (Exception ex)
1246                                                            {
1247                                                                logger.VerboseError.WriteLine(ex.ToString());
1248                                                            }
1249                                                        }
1250                                                        comparer.Value = value;
1251                                                    }
1252                                                    else
1253                                                    {
1254                                                        value = Convert.ToUInt32(SearchArgs.CompareStartValue);
1255                                                        comparer.Value = value;
1256                                                    }
1257                                                    if (comparer.Compare(Convert.ToUInt32(Value), value))
1258                                                    {
1259                                                        writer.WriteResult<uint>(comparer.Address, comparer.Value);
1260                                                    }
1261                                                }
1262                                                #endregion
1263                                            }
1264                                            else
1265                                            {
1266                                                #region 32bits - signed
1267                                                var Value = br.ReadInt32();
1268                                                using (_32bit_signed_comparer_ comparer = new _32bit_signed_comparer_(SearchArgs, CurrentIndex))
1269                                                {
1270                                                    int value = 0;
1271                                                    if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1272                                                    {
1273                                                        using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1274                                                        {
1275                                                            try
1276                                                            {
1277                                                                gmp.OpenProvider();
1278                                                                gmp.ReadMemory(CurrentIndex, out value);
1279                                                                gmp.CloseProvider();
1280                                                            }
1281                                                            catch (Exception ex)
1282                                                            {
1283                                                                logger.VerboseError.WriteLine(ex.ToString());
1284                                                            }
1285                                                        }
1286                                                        comparer.Value = value;
1287                                                    }
1288                                                    else
1289                                                    {
1290                                                        value = Convert.ToInt32(SearchArgs.CompareStartValue);
1291                                                        comparer.Value = value;
1292                                                    }
1293                                                    if (comparer.Compare(Convert.ToInt32(Value), value))
1294                                                    {
1295                                                        writer.WriteResult<int>(comparer.Address, comparer.Value);
1296                                                    }
1297                                                }
1298                                                #endregion
1299                                            } break;
1300                                        case SearchDataTypes._64bits:
1301                                            if (unsigned)
1302                                            {
1303                                                #region 64bits - unsigned
1304                                                var Value = br.ReadUInt64();
1305                                                using (_64bit_unsigned_comparer_ comparer = new _64bit_unsigned_comparer_(SearchArgs, CurrentIndex))
1306                                                {
1307                                                    ulong value = 0;
1308                                                    if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1309                                                    {
1310                                                        using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1311                                                        {
1312                                                            try
1313                                                            {
1314                                                                gmp.OpenProvider();
1315                                                                gmp.ReadMemory(CurrentIndex, out value);
1316                                                                gmp.CloseProvider();
1317                                                            }
1318                                                            catch (Exception ex)
1319                                                            {
1320                                                                logger.VerboseError.WriteLine(ex.ToString());
1321                                                            }
1322                                                        }
1323                                                        comparer.Value = value;
1324                                                    }
1325                                                    else
1326                                                    {
1327                                                        value = Convert.ToUInt64(SearchArgs.CompareStartValue);
1328                                                        comparer.Value = value;
1329                                                    }
1330                                                    if (comparer.Compare(Convert.ToUInt64(Value), value))
1331                                                    {
1332                                                        writer.WriteResult<ulong>(comparer.Address, comparer.Value);
1333                                                    }
1334                                                }
1335                                                #endregion
1336                                            }
1337                                            else
1338                                            {
1339                                                #region 64bits - signed
1340                                                var Value = br.ReadInt64();
1341                                                using (_64bit_signed_comparer_ comparer = new _64bit_signed_comparer_(SearchArgs, CurrentIndex))
1342                                                {
1343                                                    long value = 0;
1344                                                    if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1345                                                    {
1346                                                        using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1347                                                        {
1348                                                            try
1349                                                            {
1350                                                                gmp.OpenProvider();
1351                                                                gmp.ReadMemory(CurrentIndex, out value);
1352                                                                gmp.CloseProvider();
1353                                                            }
1354                                                            catch (Exception ex)
1355                                                            {
1356                                                                logger.VerboseError.WriteLine(ex.ToString());
1357                                                            }
1358                                                        }
1359                                                        comparer.Value = value;
1360                                                    }
1361                                                    else
1362                                                    {
1363                                                        value = Convert.ToInt64(SearchArgs.CompareStartValue);
1364                                                        comparer.Value = value;
1365                                                    }
1366                                                    if (comparer.Compare(Convert.ToInt64(Value), value))
1367                                                    {
1368                                                        writer.WriteResult<long>(comparer.Address, comparer.Value);
1369                                                    }
1370                                                }
1371                                                #endregion
1372                                            } break;
1373                                    }
1374                                    if (SearchWorkerThread.CancellationPending) { e.Canceled = true; return; }
1375                                }
1376                                catch (EndOfStreamException) { }
1377                                if (e.ReportProgress)
1378                                {
1379                                    double double_percent_done = 100.0 * (double)((double)CurrentIndex / (double)e.TotalCount);
1380                                    int int_percent_done = (int)double_percent_done;
1381                                    if (CurrentIndex % 10 == 0)
1382                                    {
1383                                        if (int_percent_done <= 100)
1384                                        {
1385                                            new Action<int, string>(UpdateProgress).Invoke(int_percent_done, string.Format(" -> Reading Index: 0x{0:x8} of 0x{1:x8}", CurrentIndex, e.TotalCount));
1386                                        }
1387                                        if (SearchWorkerThread.CancellationPending) { e.Canceled = true; return; }
1388                                    }
1389                                }
1390                                //switch (sdt)
1391                                //{
1392                                //    case SearchDataTypes._8bits:
1393                                //        CurrentIndex += sizeof(byte);
1394                                //        break;
1395                                //    case SearchDataTypes._16bits:
1396                                //        CurrentIndex += sizeof(ushort);
1397                                //        break;
1398                                //    case SearchDataTypes._32bits:
1399                                //        CurrentIndex += sizeof(uint);
1400                                //        break;
1401                                //    case SearchDataTypes._64bits:
1402                                //        CurrentIndex += sizeof(ulong);
1403                                //        break;
1404                                //}
1405                            }
1406    
1407                        }
1408                    }
1409                }
1410                if (SearchWorkerThread.CancellationPending) { e.Canceled = true; return; }
1411            }
1412          private void search_provider_OnBytesRead(OnBytesReadEventArgs e)          private void search_provider_OnBytesRead(OnBytesReadEventArgs e)
1413          {          {
1414              if (SearchWorkerThread.CancellationPending) { e.Canceled = true; return; }              if (SearchWorkerThread.CancellationPending) { e.Canceled = true; return; }
# Line 1187  namespace RomCheater.Docking Line 1540  namespace RomCheater.Docking
1540                                                  }                                                  }
1541                                              }                                              }
1542                                              #endregion                                              #endregion
                                             writer.WriteResult<ushort>(CurrentIndex, br.ReadUInt16());  
1543                                          }                                          }
1544                                          else                                          else
1545                                          {                                          {
# Line 1469  namespace RomCheater.Docking Line 1821  namespace RomCheater.Docking
1821                              byte[] guid = SearchGuid.ToByteArray();                              byte[] guid = SearchGuid.ToByteArray();
1822                              guid[guid.Length - 1]++; // increment the search guid by 1                              guid[guid.Length - 1]++; // increment the search guid by 1
1823                              Guid new_SearchGuid = new Guid(guid);                              Guid new_SearchGuid = new Guid(guid);
1824                              //provider.OnBytesRead += new BaseEventHandler<OnBytesReadEventArgs>(search_provider_OnBytesRead);                              const int item_count = 0x100;
                             //int count = 0;  
                             //int Last_Whole_Percent_Done = 0;  
                             //var results = reader.GetResults(SearchArgs.IsUnsignedDataType, SearchArgs.DataType, new Action<int, string>(UpdateProgress));  
   
                             //reader.WriteUpdatedEntries(new_SearchGuid, SearchArgs.IsUnsignedDataType, SearchArgs.DataType, new Action<int, string>(UpdateProgress));  
   
                             const int item_count = 0x1;  
1825                              using (SearchResultWriter writer = new SearchResultWriter((int)(reader.ResultCount), new_SearchGuid))                              using (SearchResultWriter writer = new SearchResultWriter((int)(reader.ResultCount), new_SearchGuid))
1826                              {                              {
1827                                  //int Last_Whole_Percent_Done = 0;                                  ////int Last_Whole_Percent_Done = 0;
1828                                    //for (int i = 0; i < reader.ResultCount; i += item_count)
1829                                    //{                                  
1830                                    //    var items = reader.GetResultRangeAtIndex(i,item_count, SearchArgs.IsUnsignedDataType, SearchArgs.DataType, new Action<int, string>(UpdateProgress));
1831                                    //    for (int j = 0; j < items.Count(); j++)
1832                                    //    {
1833                                    //        int index = i + j;
1834                                    //        var item = items[j];
1835                                    //        provider.OpenProvider();
1836                                    //        int bytesRead = 0;
1837                                    //        byte[] data = new byte[STEP_SIZE];
1838                                    //        provider.ReadProcessMemory(item.Address, STEP_SIZE, out bytesRead, out data);
1839                                    //        BaseEventHandler<OnBytesReadEventArgs> t = new BaseEventHandler<OnBytesReadEventArgs>(search_provider_OnBytesRead);
1840                                    //        OnBytesReadEventArgs t_args = new OnBytesReadEventArgs(this, writer, data, (uint)index, (uint)reader.ResultCount, false);
1841                                    //        t.Invoke(t_args);
1842                                    //        t = null;
1843                                    //        t_args = null;
1844                                    //        data = null;
1845                                    //        provider.CloseProvider();                                        
1846                                    //        //double double_percent_done = 100.0 * (double)((double)index / (double)reader.ResultCount);
1847                                    //        //int int_percent_done = (int)double_percent_done;
1848                                    //        //if (i % item_count == 0)
1849                                    //        //{
1850                                    //        //    if (int_percent_done <= 100)
1851                                    //        //    {
1852                                    //        //        new Action<int, string>(UpdateProgress).Invoke(int_percent_done, string.Format(" -> Loading value for Address: 0x{0:x8}", item.Address));
1853                                    //        //        //Last_Whole_Percent_Done = int_percent_done;
1854                                    //        //    }
1855                                    //        //}
1856                                    //    }                                    
1857                                    //}
1858                                  for (int i = 0; i < reader.ResultCount; i += item_count)                                  for (int i = 0; i < reader.ResultCount; i += item_count)
1859                                  {                                                                    {
1860                                      var item = reader.GetResultAtIndex(i, SearchArgs.IsUnsignedDataType, SearchArgs.DataType, new Action<int, string>(UpdateProgress));                                      var items = reader.GetResultRangeAtIndex(i, item_count, SearchArgs.IsUnsignedDataType, SearchArgs.DataType, new Action<int, string>(UpdateProgress));
1861    
1862                                        provider.OpenProvider();
1863                                        int count = 0;
1864                                        foreach (var item in items)
1865                                        {
1866                                            uint bytesToRead = STEP_SIZE;
1867                                            int bytesRead = 0;
1868                                            byte[] data = new byte[bytesToRead];
1869                                            provider.ReadProcessMemory(item.Address, bytesToRead, out bytesRead, out data);
1870                                            BaseEventHandler<OnBytesReadEventArgs> t = new BaseEventHandler<OnBytesReadEventArgs>(search_provider_OnBytesRead_compare_only);
1871                                            OnBytesReadEventArgs t_args = new OnBytesReadEventArgs(this, writer, data, (uint)count, (uint)item_count, true);
1872                                            t.Invoke(t_args);
1873                                            t = null;
1874                                            t_args = null;
1875                                            count++;
1876                                        }
1877                                      double double_percent_done = 100.0 * (double)((double)i / (double)reader.ResultCount);                                      double double_percent_done = 100.0 * (double)((double)i / (double)reader.ResultCount);
1878                                      int int_percent_done = (int)double_percent_done;                                      int int_percent_done = (int)double_percent_done;
1879                                      if (i % 10 == 0)                                      if (i % item_count == 0)
1880                                      {                                      {
1881                                          if (int_percent_done <= 100)                                          if (int_percent_done <= 100)
1882                                          {                                          {
1883                                              new Action<int, string>(UpdateProgress).Invoke(int_percent_done, string.Format(" -> Loading value for Address: 0x{0:x8}", item.Address));                                              new Action<int, string>(UpdateProgress).Invoke(int_percent_done, string.Format(" -> Loaded {0} value(s) from index: 0x{1:x8}", item_count, i));
1884                                              //Last_Whole_Percent_Done = int_percent_done;                                              //Last_Whole_Percent_Done = int_percent_done;
1885                                          }                                          }
1886                                      }                                      }
1887                                      //for (int j = 0; j < items.Count(); j++)                                      provider.CloseProvider();
                                     //{  
                                         //var item = items[j];  
                                         provider.OpenProvider();  
                                         int bytesRead = 0;  
                                         byte[] data = new byte[STEP_SIZE];  
                                         provider.ReadProcessMemory(item.Address, STEP_SIZE, out bytesRead, out data);  
                                         BaseEventHandler<OnBytesReadEventArgs> t = new BaseEventHandler<OnBytesReadEventArgs>(search_provider_OnBytesRead);  
                                         OnBytesReadEventArgs t_args = new OnBytesReadEventArgs(this, writer, data, item.Address, (uint)reader.ResultCount, false);  
                                         t.Invoke(t_args);  
                                         t = null;  
                                         t_args = null;  
                                         data = null;  
                                         provider.CloseProvider();  
                                         //double percent_done = 100.0 * ((double)i+(double)j / (double)reader.ResultCount);  
   
                                           
   
                                         //double percent_done = 100.0 * ((double)i / (double)reader.ResultCount);  
                                         //new Action<int, string>(UpdateProgress).Invoke((int)percent_done, string.Format(" -> Reading Address: 0x{0:x8}", item.Address));  
                                     //}                                  
1888                                  }                                  }
1889                              }                              }
1890                              SearchGuid = new_SearchGuid;                              SearchGuid = new_SearchGuid;

Legend:
Removed from v.473  
changed lines
  Added in v.474

  ViewVC Help
Powered by ViewVC 1.1.22