wip

Author: emesare

view/sharedcache/api/sharedcache.cpp

@@ -4,232 +4,205 @@
 
 #include "sharedcacheapi.h"
 
+using namespace BinaryNinja;
 using namespace SharedCacheAPI;
 
-SharedCache::SharedCache(BinaryNinja::Ref<BinaryNinja::BinaryView> view) {
-	m_object = BNGetSharedCache(view->GetObject());
+BNSharedCacheImage ImageToApi(CacheImage image)
+{
+	BNSharedCacheImage apiImage;
+	apiImage.name = BNAllocString(image.name.c_str());
+	apiImage.headerAddress = image.headerAddress;
+	apiImage.regionStartCount = image.regionStarts.size();
+	// TODO: If we alloc then core cannot delete
+	uint64_t* regionStarts = new uint64_t[image.regionStarts.size()];
+	for (size_t i = 0; i < image.regionStarts.size(); i++)
+		regionStarts[i] = image.regionStarts[i];
+	apiImage.regionStarts = regionStarts;
+	return apiImage;
 }
 
-BNDSCViewLoadProgress SharedCache::GetLoadProgress(BinaryNinja::Ref<BinaryNinja::BinaryView> view)
+CacheImage ImageFromApi(BNSharedCacheImage image)
 {
-	return BNDSCViewGetLoadProgress(view->GetFile()->GetSessionId());
+	CacheImage apiImage;
+	apiImage.name = image.name;
+	apiImage.headerAddress = image.headerAddress;
+	apiImage.regionStarts.reserve(image.regionStartCount);
+	for (size_t i = 0; i < image.regionStartCount; i++)
+		apiImage.regionStarts.push_back(image.regionStarts[i]);
+	return apiImage;
 }
 
-uint64_t SharedCache::FastGetBackingCacheCount(BinaryNinja::Ref<BinaryNinja::BinaryView> view)
+BNSharedCacheRegion RegionToApi(const CacheRegion& region)
 {
-	return BNDSCViewFastGetBackingCacheCount(view->GetObject());
+	BNSharedCacheRegion apiRegion;
+	apiRegion.vmAddress = region.start;
+	apiRegion.name = BNAllocString(region.name.c_str());
+	apiRegion.size = region.size;
+	apiRegion.flags = region.flags;
+	apiRegion.regionType = region.type;
+	// If not associated with image this will be zeroed.
+	apiRegion.imageStart = region.imageStart.value_or(0);
+	return apiRegion;
 }
 
-bool SharedCache::LoadImageWithInstallName(std::string installName, bool skipObjC)
+CacheRegion RegionFromApi(BNSharedCacheRegion apiRegion)
 {
-	char* str = BNAllocString(installName.c_str());
-	return BNDSCViewLoadImageWithInstallName(m_object, str, skipObjC);
+	CacheRegion region;
+	region.start = apiRegion.vmAddress;
+	region.name = apiRegion.name;
+	region.size = apiRegion.size;
+	region.flags = apiRegion.flags;
+	region.type = apiRegion.regionType;
+	return region;
 }
 
-bool SharedCache::LoadSectionAtAddress(uint64_t addr)
+BNSharedCacheMappingInfo MappingToApi(const CacheMappingInfo& mapping)
 {
-	return BNDSCViewLoadSectionAtAddress(m_object, addr);
+	BNSharedCacheMappingInfo apiMapping;
+	apiMapping.vmAddress = mapping.vmAddress;
+	apiMapping.size = mapping.size;
+	apiMapping.fileOffset = mapping.fileOffset;
+	return apiMapping;
 }
 
-bool SharedCache::LoadImageContainingAddress(uint64_t addr, bool skipObjC)
+CacheMappingInfo MappingFromApi(BNSharedCacheMappingInfo apiMapping)
 {
-	return BNDSCViewLoadImageContainingAddress(m_object, addr, skipObjC);
+	CacheMappingInfo mapping;
+	mapping.vmAddress = apiMapping.vmAddress;
+	mapping.size = apiMapping.size;
+	mapping.fileOffset = apiMapping.fileOffset;
+	return mapping;
 }
 
-std::vector<std::string> SharedCache::GetAvailableImages()
+BNSharedCacheEntry EntryToApi(const CacheEntry& entry)
 {
-	size_t count;
-	char** value = BNDSCViewGetInstallNames(m_object, &count);
-	if (value == nullptr)
-	{
-		return {};
-	}
-
-	std::vector<std::string> result;
-	for (size_t i = 0; i < count; i++)
-	{
-		result.push_back(value[i]);
-	}
-
-	BNFreeStringList(value, count);
-	return result;
+	BNSharedCacheEntry apiEntry;
+	apiEntry.path = BNAllocString(entry.path.c_str());
+	apiEntry.entryType = entry.entryType;
+	const auto& mappings = entry.mappings;
+	apiEntry.mappingCount = mappings.size();
+	// TODO: If we alloc then the core cannot delete.
+	apiEntry.mappings = new BNSharedCacheMappingInfo[mappings.size()];
+	for (size_t i = 0; i < mappings.size(); i++)
+		apiEntry.mappings[i] = MappingToApi(mappings[i]);
+	return apiEntry;
 }
 
-void SharedCache::ProcessObjCSectionsForImageWithInstallName(const std::string& installName)
+CacheEntry EntryFromApi(BNSharedCacheEntry apiEntry)
 {
-	BNDSCViewProcessObjCSectionsForImageWithInstallName(m_object, installName.c_str());
+	CacheEntry entry;
+	entry.path = apiEntry.path;
+	entry.entryType = apiEntry.entryType;
+	entry.mappings.reserve(apiEntry.mappingCount);
+	for (size_t i = 0; i < apiEntry.mappingCount; i++)
+		entry.mappings.push_back(MappingFromApi(apiEntry.mappings[i]));
+	return entry;
 }
 
-void SharedCache::ProcessAllObjCSections()
+
+SharedCacheController::SharedCacheController(BNSharedCacheController *controller)
 {
-	BNDSCViewProcessAllObjCSections(m_object);
+    m_object = controller;
 }
 
-std::vector<DSCMemoryRegion> SharedCache::GetLoadedMemoryRegions()
+DSCRef<SharedCacheController> SharedCacheController::GetController(Ref<BinaryView> view)
 {
-	size_t count;
-	BNDSCMappedMemoryRegion* value = BNDSCViewGetLoadedRegions(m_object, &count);
-	if (value == nullptr)
-	{
-		return {};
-	}
+    if (!view)
+        return nullptr;
 
-	std::vector<DSCMemoryRegion> result;
-	for (size_t i = 0; i < count; i++)
-	{
-		DSCMemoryRegion region;
-		region.vmAddress = value[i].vmAddress;
-		region.size = value[i].size;
-		region.prettyName = value[i].name;
-		result.push_back(region);
-	}
-
-	BNDSCViewFreeLoadedRegions(value, count);
-	return result;
+    BNSharedCacheController* controller = BNGetSharedCacheController(view->GetObject());
+    if (!controller)
+        return nullptr;
+
+    return new SharedCacheController(controller);
 }
-std::vector<BackingCache> SharedCache::GetBackingCaches()
-{
-	size_t count;
-	BNDSCBackingCache* value = BNDSCViewGetBackingCaches(m_object, &count);
-	if (value == nullptr)
-	{
-		return {};
-	}
 
-	std::vector<BackingCache> result;
-	for (size_t i = 0; i < count; i++)
-	{
-		BackingCache cache;
-		cache.path = value[i].path;
-		cache.cacheType = value[i].cacheType;
-		for (size_t j = 0; j < value[i].mappingCount; j++)
-		{
-			BackingCacheMapping mapping;
-			mapping.vmAddress = value[i].mappings[j].vmAddress;
-			mapping.size = value[i].mappings[j].size;
-			mapping.fileOffset = value[i].mappings[j].fileOffset;
-			cache.mappings.push_back(mapping);
-		}
-		result.push_back(cache);
-	}
-
-	BNDSCViewFreeBackingCaches(value, count);
+bool SharedCacheController::LoadRegion(BinaryView &view, const CacheRegion &region)
+{
+	auto apiRegion = RegionToApi(region);
+    bool result = BNSharedCacheControllerLoadRegion(m_object, view.GetObject(), &apiRegion);
+	BNSharedCacheFreeRegion(apiRegion);
 	return result;
 }
 
-std::vector<DSCImage> SharedCache::GetImages()
+bool SharedCacheController::LoadImage(BinaryView &view, const CacheImage &image)
 {
-	size_t count;
-	BNDSCImage* value = BNDSCViewGetAllImages(m_object, &count);
-	if (value == nullptr)
-	{
-		return {};
-	}
-
-	std::vector<DSCImage> result;
-	for (size_t i = 0; i < count; i++)
-	{
-		DSCImage img;
-		img.name = value[i].name;
-		img.headerAddress = value[i].headerAddress;
-		for (size_t j = 0; j < value[i].mappingCount; j++)
-		{
-			DSCImageMemoryMapping mapping;
-			mapping.filePath = value[i].mappings[j].filePath;
-			mapping.name = value[i].mappings[j].name;
-			mapping.vmAddress = value[i].mappings[j].vmAddress;
-			mapping.rawViewOffset = value[i].mappings[j].rawViewOffset;
-			mapping.size = value[i].mappings[j].size;
-			mapping.loaded = value[i].mappings[j].loaded;
-			img.mappings.push_back(mapping);
-		}
-		result.push_back(img);
-	}
-
-	BNDSCViewFreeAllImages(value, count);
+	auto apiImage = ImageToApi(image);
+	bool result = BNSharedCacheControllerLoadImage(m_object, view.GetObject(), &apiImage);
+	BNSharedCacheFreeImage(apiImage);
 	return result;
 }
 
-std::vector<DSCSymbol> SharedCache::LoadAllSymbolsAndWait()
+std::optional<CacheRegion> SharedCacheController::GetRegionAt(uint64_t address) const
 {
-	size_t count;
-	BNDSCSymbolRep* value = BNDSCViewLoadAllSymbolsAndWait(m_object, &count);
-	if (value == nullptr)
-	{
-		return {};
-	}
-
-	std::vector<DSCSymbol> result;
-	result.reserve(count);
-	for (size_t i = 0; i < count; i++)
-	{
-		DSCSymbol sym;
-		sym.address = value[i].address;
-		sym.name = StringRef(BNDuplicateStringRef(value[i].name));
-		sym.image = value[i].image;
-		result.push_back(sym);
-	}
-
-	BNDSCViewFreeSymbols(value, count);
-	return result;
+	BNSharedCacheRegion apiRegion;
+	if (!BNSharedCacheControllerGetRegionAt(m_object, address, &apiRegion))
+		return std::nullopt;
+	CacheRegion region = RegionFromApi(apiRegion);
+	BNSharedCacheFreeRegion(apiRegion);
+	return region;
 }
 
-std::string SharedCache::GetNameForAddress(uint64_t address)
+std::optional<CacheRegion> SharedCacheController::GetRegionContaining(uint64_t address) const
 {
-	char* name = BNDSCViewGetNameForAddress(m_object, address);
-	if (name == nullptr)
-		return {};
-	std::string result = name;
-	BNFreeString(name);
-	return result;
+	BNSharedCacheRegion apiRegion;
+	if (!BNSharedCacheControllerGetRegionContaining(m_object, address, &apiRegion))
+		return std::nullopt;
+	CacheRegion region = RegionFromApi(apiRegion);
+	BNSharedCacheFreeRegion(apiRegion);
+	return region;
 }
 
-std::string SharedCache::GetImageNameForAddress(uint64_t address)
+std::optional<CacheImage> SharedCacheController::GetImageAt(uint64_t address) const
 {
-	char* name = BNDSCViewGetImageNameForAddress(m_object, address);
-	if (name == nullptr)
-		return {};
-	std::string result = name;
-	BNFreeString(name);
-	return result;
+	BNSharedCacheImage apiImage;
+	if (!BNSharedCacheControllerGetImageAt(m_object, address, &apiImage))
+		return std::nullopt;
+	CacheImage image = ImageFromApi(apiImage);
+	BNSharedCacheFreeImage(apiImage);
+	return image;
 }
 
-std::optional<DSCMachOHeader> SharedCache::GetMachOHeaderForImage(std::string name)
+std::optional<CacheImage> SharedCacheController::GetImageContaining(uint64_t address) const
 {
-	// TODO: This lmfao
-	// char* str = BNAllocString(name.c_str());
-	// char* outputStr = BNDSCViewGetImageHeaderForName(m_object, str);
-	// if (outputStr == nullptr)
-	// 	return {};
-	// std::string output = outputStr;
-	// BNFreeString(outputStr);
-	// if (output.empty())
-	// 	return {};
-	//
-	// return SharedCacheMachOHeader::LoadFromString(output);
-	return std::nullopt;
+	BNSharedCacheImage apiImage;
+	if (!BNSharedCacheControllerGetImageContaining(m_object, address, &apiImage))
+		return std::nullopt;
+	CacheImage image = ImageFromApi(apiImage);
+	BNSharedCacheFreeImage(apiImage);
+	return image;
 }
 
-std::optional<DSCMachOHeader> SharedCache::GetMachOHeaderForAddress(uint64_t address)
+std::optional<CacheImage> SharedCacheController::GetImageWithName(const std::string &name) const
 {
-	// TODO: This lmfao
-	// char* outputStr = BNDSCViewGetImageHeaderForAddress(m_object, address);
-	// if (outputStr == nullptr)
-	// 	return {};
-	// std::string output = outputStr;
-	// BNFreeString(outputStr);
-	// if (output.empty())
-	// 	return {};
-	// return SharedCacheMachOHeader::LoadFromString(output);
-	return std::nullopt;
+	BNSharedCacheImage apiImage;
+	if (!BNSharedCacheControllerGetImageWithName(m_object, name.c_str(), &apiImage))
+		return std::nullopt;
+	CacheImage image = ImageFromApi(apiImage);
+	BNSharedCacheFreeImage(apiImage);
+	return image;
 }
 
-BNDSCViewState SharedCache::GetState()
+std::vector<CacheEntry> SharedCacheController::GetEntries() const
 {
-	return BNDSCViewGetState(m_object);
+	size_t count;
+	BNSharedCacheEntry* entries = BNSharedCacheControllerGetEntries(m_object, &count);
+	std::vector<CacheEntry> result;
+	result.reserve(count);
+	for (size_t i = 0; i < count; i++)
+		result.emplace_back(EntryFromApi(entries[i]));
+	BNSharedCacheFreeEntryList(entries, count);
+	return result;
 }
 
-void SharedCache::FindSymbolAtAddrAndApplyToAddr(uint64_t symbolLocation, uint64_t targetLocation, bool triggerReanalysis) const
+std::vector<CacheImage> SharedCacheController::GetImages() const
 {
-	BNDSCFindSymbolAtAddressAndApplyToAddress(m_object, symbolLocation, targetLocation, triggerReanalysis);
-}
+	size_t count;
+	BNSharedCacheImage* images = BNSharedCacheControllerGetImages(m_object, &count);
+	std::vector<CacheImage> result;
+	result.reserve(count);
+	for (size_t i = 0; i < count; i++)
+		result.emplace_back(ImageFromApi(images[i]));
+	BNSharedCacheFreeImageList(images, count);
+	return result;
+}