Test01-AB1.1

Author: SoulRune

control

@@ -1,6 +1,6 @@
 Package: com.vanson.modifier
 Name: VansonModifier
-Version: 3.1.2
+Version: 3.1.2.1
 Architecture: iphoneos-arm
 Description: Vanson U Know?
 Maintainer: Vanson

include/VMMemoryEngine.h

@@ -150,6 +150,16 @@ typedef enum : NSUInteger {
               isNextSearch:(BOOL)isNext
                 completion:(void (^)(NSUInteger count, NSString *msg))comp;
 
+// Multi-type: in one logical search, it goes through several types
+// (the first scan adds the results of each type to one set).
+// The results are mixed - each stores its own type; next/filter is checked per-item.
+- (void)scanMemoryWithMode:(VMSearchMode)mode
+                    valStr:(NSString *)valStr
+                 dataTypes:(NSArray<NSNumber *> *)types
+                 fuzzyType:(VMFuzzyType)fuzzyType
+              isNextSearch:(BOOL)isNext
+                completion:(void (^)(NSUInteger count, NSString *msg))comp;
+
 - (void)scanMemoryWithMode:(VMSearchMode)mode
                     valStr:(NSString *)valStr
               coreDataType:(uint8_t)coreType

src/memory/VMMemoryEngine.mm

@@ -641,16 +641,89 @@ - (void)scanMemoryWithMode:(VMSearchMode)mode
                  fuzzyType:(VMFuzzyType)fuzzyType
               isNextSearch:(BOOL)isNext
                 completion:(void (^)(NSUInteger count, NSString *msg))comp {
-  
-  VMCore::DataType coreType = convertToCoreDataType(type);
+
   [self scanMemoryWithMode:mode
                     valStr:valStr
-              coreDataType:(uint8_t)coreType
+                 dataTypes:@[ @(type) ]
                  fuzzyType:fuzzyType
               isNextSearch:isNext
                 completion:comp];
 }
 
+- (void)scanMemoryWithMode:(VMSearchMode)mode
+                    valStr:(NSString *)valStr
+                 dataTypes:(NSArray<NSNumber *> *)types
+                 fuzzyType:(VMFuzzyType)fuzzyType
+              isNextSearch:(BOOL)isNext
+                completion:(void (^)(NSUInteger count, NSString *msg))comp {
+
+  if (self.targetTask == MACH_PORT_NULL) {
+    if (comp)
+      comp(0, TR(@"Msg_Target_Not_Found"));
+    return;
+  }
+  if (types.count == 0) {
+    if (comp)
+      comp(0, TR(@"Msg_Search_No_Res"));
+    return;
+  }
+
+  VMDataType primary = (VMDataType)[types.firstObject unsignedIntegerValue];
+  self.currentDataType = primary;
+
+  // Snapshot of the list of types in C++ for a background thread
+  std::vector<VMCore::DataType> coreTypes;
+  coreTypes.reserve(types.count);
+  for (NSNumber *t in types) {
+    coreTypes.push_back(convertToCoreDataType((VMDataType)[t unsignedIntegerValue]));
+  }
+
+  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{
+    std::string cValStr = [valStr UTF8String] ?: "";
+    int cMode = (int)mode;
+
+    if (isNext) {
+      int finalMode;
+      if (mode == VMSearchModeExact) {
+        finalMode = 100;
+      } else if (mode == VMSearchModeBetween) {
+        finalMode = 101;
+      } else if (mode == VMSearchModeFuzzy) {
+        finalMode = (int)fuzzyType;
+      } else {
+        finalMode = cMode;
+      }
+      // Core re-checks each result by its own stored type - representative type isn't critical
+      _core->nextScan({}, coreTypes.front(), cValStr, finalMode);
+    } else {
+      _core->clearBaselineSnapshot();
+
+      // First scan: iterate each type, appending results into one set
+      bool first = true;
+      for (VMCore::DataType ct : coreTypes) {
+        _core->scan(ct, cValStr, cMode, self.searchRangeStart,
+                    self.searchRangeEnd, /*append=*/!first);
+        first = false;
+      }
+
+      if (mode == VMSearchModeFuzzy && _core->getResultCount() > 0) {
+        _core->saveBaselineSnapshot();
+      }
+    }
+
+    self.resultCount = _core->getResultCount();
+    self.resultFilePath = self.resultCount > 0 ? [self getPathA] : nil;
+
+    dispatch_async(dispatch_get_main_queue(), ^{
+      if (comp) {
+        NSString *msg = self.resultCount > 0 ? TR(@"Msg_Search_Success")
+                                             : TR(@"Msg_Search_No_Res");
+        comp(self.resultCount, msg);
+      }
+    });
+  });
+}
+
 - (void)scanMemoryWithMode:(VMSearchMode)mode
                     valStr:(NSString *)valStr
               coreDataType:(uint8_t)coreType
@@ -822,7 +895,7 @@ - (VMScanResultItem *)getResultItemAtIndex:(NSUInteger)index
   item.address = cppItem.address;
 
   VMDataType actualType = (VMDataType)cppItem.type;
-  if (actualType >= VMDataTypeInt8 && actualType <= VMDataTypeDouble) {
+  if (actualType >= VMDataTypeInt8 && actualType <= VMDataTypeString) {
     item.type = actualType;
   } else {
     item.type = type;

src/memory/core/MemoryCore.cpp

@@ -494,12 +494,14 @@ void MemoryCore::parseRangeString(const std::string &rangeStr, DataType type,
 std::vector<ScanResult> MemoryCore::scan(DataType type,
                                          const std::string &valueStr,
                                          int searchMode, uint64_t start,
-                                         uint64_t end) {
-  _resultCount = 0;
+                                         uint64_t end, bool append) {
+  if (!append)
+    _resultCount = 0;
   std::vector<ScanResult> emptyRes;
   if (_task == MACH_PORT_NULL || _storagePath.empty())
     return emptyRes;
-  FILE *outFile = fopen(_storagePath.c_str(), "wb");
+  // append=true: add the following type of results to the same file (multi-type)
+  FILE *outFile = fopen(_storagePath.c_str(), append ? "ab" : "wb");
   if (!outFile)
     return emptyRes;
 
@@ -976,54 +978,46 @@ MemoryCore::nextScan(const std::vector<ScanResult> &ignored, DataType type,
     }
   }
 
-  union {
-    int8_t i8;
-    int16_t i16;
-    int32_t i32;
-    int64_t i64;
-    float f;
-    double d;
-  } target;
-  memset(&target, 0, sizeof(target));
-  
-  parseValue(valueStr, type, &target);
-  
-  // Parse range for between mode (101)
-  union {
-    int8_t i8; int16_t i16; int32_t i32; int64_t i64;
-    float f; double d;
-  } rangeMin, rangeMax;
-  memset(&rangeMin, 0, sizeof(rangeMin));
-  memset(&rangeMax, 0, sizeof(rangeMax));
+  // Multi-type: we parse the target for all widths at once, so that each result is
+  // checked against ITS stored type (raw.type), and not against requestedType.
+  int64_t targetIntRaw = 0;
+  double targetDoubleRaw = 0;
+  parseValue(valueStr, DataType::Int64, &targetIntRaw);
+  parseValue(valueStr, DataType::Double, &targetDoubleRaw);
+
+  // Parse range for between mode (101) - separate integer and real numbers
+  int64_t rangeMinIntRaw = 0, rangeMaxIntRaw = 0;
+  double rangeMinDoubleRaw = 0, rangeMaxDoubleRaw = 0;
   if (searchMode == 101) {
-    parseRangeString(valueStr, type, &rangeMin, &rangeMax);
+    parseRangeString(valueStr, DataType::Int64, &rangeMinIntRaw, &rangeMaxIntRaw);
+    parseRangeString(valueStr, DataType::Double, &rangeMinDoubleRaw, &rangeMaxDoubleRaw);
   }
-  
+
   bool isStringType = (type == DataType::String);
   std::string targetString = valueStr;
   size_t targetStringLen = targetString.length();
 
   std::atomic<size_t> newCount(0);
   mach_port_t task = _task;
-  
-  float targetFloat = target.f;
-  double targetDouble = target.d;
-  
-  int8_t targetI8 = target.i8;
-  int16_t targetI16 = target.i16;
-  int32_t targetI32 = target.i32;
-  int64_t targetI64 = target.i64;
+
+  float targetFloat = (float)targetDoubleRaw;
+  double targetDouble = targetDoubleRaw;
+
+  int8_t targetI8 = (int8_t)targetIntRaw;
+  int16_t targetI16 = (int16_t)targetIntRaw;
+  int32_t targetI32 = (int32_t)targetIntRaw;
+  int64_t targetI64 = targetIntRaw;
   double floatTolerance = _floatTolerance;
-  
+
   std::vector<DiffRegion> diffRegionsCopy = diffRegions;
   bool useIncremental = useIncrementalOptimization;
-  
+
   // Range variables for between mode (101)
-  float rangeMinFloat = rangeMin.f, rangeMaxFloat = rangeMax.f;
-  double rangeMinDouble = rangeMin.d, rangeMaxDouble = rangeMax.d;
-  int64_t rangeMinI64 = rangeMin.i64, rangeMaxI64 = rangeMax.i64;
-  
-  DataType requestedType = type;  
+  float rangeMinFloat = (float)rangeMinDoubleRaw, rangeMaxFloat = (float)rangeMaxDoubleRaw;
+  double rangeMinDouble = rangeMinDoubleRaw, rangeMaxDouble = rangeMaxDoubleRaw;
+  int64_t rangeMinI64 = rangeMinIntRaw, rangeMaxI64 = rangeMaxIntRaw;
+
+  (void)isStringType;  // stringiness is determined by per-item by raw.type
 
   const size_t chunkSizeInResults = 500000;
   size_t processed = 0;
@@ -1081,8 +1075,8 @@ MemoryCore::nextScan(const std::vector<ScanResult> &ignored, DataType type,
             }
 
             uint8_t buf[8];
-            
-            if (isStringType) {
+
+            if ((DataType)raw.type == DataType::String) {
               mach_vm_size_t rSz = 64;
               if (mach_vm_read_overwrite(task, raw.address, 64,
                                          (mach_vm_address_t)stringBuffer,
@@ -1133,13 +1127,8 @@ MemoryCore::nextScan(const std::vector<ScanResult> &ignored, DataType type,
               }
             }
 
-            DataType storedType = (DataType)raw.type;
-            DataType actualType = storedType;
+            DataType actualType = (DataType)raw.type;
             size_t actualSize = getSizeForType(actualType);
-            
-            if (storedType != requestedType) {
-              continue;
-            }
 
             bool readSuccess = false;
             if (cachedPage != (uint64_t)-1) {
@@ -1463,9 +1452,7 @@ MemoryCore::scanNearby(const std::vector<ScanResult> &baseResults,
       FILE *fOut = fopen(_swapPath.c_str(), "wb");
       if (fOut) {
         for (const auto &res : results) {
-          RawResult raw;
-          raw.address = res.address;
-          raw.value = res.value.u64;
+          RawResult raw = makeRawResult(res.address, res.value.u64, res.type);
           fwrite(&raw, sizeof(RawResult), 1, fOut);
         }
         fclose(fOut);
@@ -1840,7 +1827,7 @@ size_t MemoryCore::filterResults(FilterMode mode, DataType type,
   }
   RawResult item;
   size_t newCount = 0;
-  size_t dataSize = getSizeForType(type);
+  (void)type;  // the filter checks each result by its type (item.type)
 
   uint64_t cachedPage = (uint64_t)-1;
   uint8_t pageBuffer[4096];
@@ -1849,7 +1836,10 @@ size_t MemoryCore::filterResults(FilterMode mode, DataType type,
     uint8_t buf[8];
     memset(buf, 0, 8);
 
-    uint64_t pageAddr = item.address & ~0xFFF; 
+    DataType itemType = (DataType)item.type;
+    size_t dataSize = getSizeForType(itemType);
+
+    uint64_t pageAddr = item.address & ~0xFFF;
     if (pageAddr != cachedPage) {
       cachedPage = pageAddr;
       mach_vm_size_t readSz = 4096;
@@ -1881,9 +1871,9 @@ size_t MemoryCore::filterResults(FilterMode mode, DataType type,
 
     if (readSuccess) {
       double currentVal = 0;
-      if (type == DataType::Float)
+      if (itemType == DataType::Float)
         currentVal = *(float *)buf;
-      else if (type == DataType::Double)
+      else if (itemType == DataType::Double)
         currentVal = *(double *)buf;
       else if (dataSize == 1)
         currentVal = *(int8_t *)buf;

src/memory/core/MemoryCore.hpp

@@ -82,7 +82,7 @@ class MemoryCore {
 
   std::vector<ScanResult> scan(DataType type, const std::string &valueStr,
                                int searchMode, uint64_t start = 0,
-                               uint64_t end = 0);
+                               uint64_t end = 0, bool append = false);
 
   std::vector<ScanResult>
   nextScan(const std::vector<ScanResult> &previousResults, DataType type,