Add new API to query active analysis info and set analysis limits.

6 files changed, 143 insertions, 1 deletions

diff --git a/binaryninjaapi.h b/binaryninjaapi.h
index 9c0b9bc4..f2c15fde 100644
--- a/binaryninjaapi.h
+++ b/binaryninjaapi.h
@@ -1022,6 +1022,25 @@ namespace BinaryNinja
 		void Cancel();
 	};
 
+	struct ActiveAnalysisInfo
+	{
+		Ref<Function> func;
+		uint64_t analysisTime;
+		size_t updateCount;
+		size_t submitCount;
+
+		ActiveAnalysisInfo(Ref<Function> f, uint64_t t, size_t uc, size_t sc) : func(f), analysisTime(t), updateCount(uc), submitCount(sc)
+		{
+		}
+	};
+
+	struct AnalysisInfo
+	{
+		BNAnalysisState state;
+		uint64_t analysisTime;
+		std::vector<ActiveAnalysisInfo> activeInfo;
+	};
+
 	struct DataVariable
 	{
 		DataVariable() { }
@@ -1271,6 +1290,7 @@ namespace BinaryNinja
 
 		Ref<AnalysisCompletionEvent> AddAnalysisCompletionEvent(const std::function<void()>& callback);
 
+		AnalysisInfo GetAnalysisInfo();
 		BNAnalysisProgress GetAnalysisProgress();
 		Ref<BackgroundTask> GetBackgroundAnalysisTask();
 
@@ -1350,6 +1370,8 @@ namespace BinaryNinja
 		std::vector<uint8_t> GetRawMetadata(const std::string& key);
 		uint64_t GetUIntMetadata(const std::string& key);
 
+		BNAnalysisParameters GetParametersForAnalysis();
+		void SetParametersForAnalysis(BNAnalysisParameters params);
 		uint64_t GetMaxFunctionSizeForAnalysis();
 		void SetMaxFunctionSizeForAnalysis(uint64_t size);
 	};
@@ -2493,6 +2515,7 @@ namespace BinaryNinja
 
 		bool IsFunctionTooLarge();
 		bool IsAnalysisSkipped();
+		BNAnalysisSkipReason GetAnalysisSkipReason();
 		BNFunctionAnalysisSkipOverride GetAnalysisSkipOverride();
 		void SetAnalysisSkipOverride(BNFunctionAnalysisSkipOverride skip);
 	};
diff --git a/binaryninjacore.h b/binaryninjacore.h
index f77a9475..fda26d47 100644
--- a/binaryninjacore.h
+++ b/binaryninjacore.h
@@ -1480,12 +1480,37 @@ extern "C"
 		ExtendedAnalyzeState
 	};
 
+	struct BNActiveAnalysisInfo
+	{
+		BNFunction* func;
+		uint64_t analysisTime;
+		size_t updateCount;
+		size_t submitCount;
+	};
+
+	struct BNAnalysisInfo
+	{
+		BNAnalysisState state;
+		uint64_t analysisTime;
+		BNActiveAnalysisInfo* activeInfo;
+		size_t count;
+	};
+
 	struct BNAnalysisProgress
 	{
 		BNAnalysisState state;
 		size_t count, total;
 	};
 
+	struct BNAnalysisParameters
+	{
+		uint64_t maxAnalysisTime;
+		uint64_t maxFunctionSize;
+		uint64_t maxFunctionAnalysisTime;
+		size_t maxFunctionUpdateCount;
+		size_t maxFunctionSubmitCount;
+	};
+
 	struct BNDownloadInstanceOutputCallbacks
 	{
 		uint64_t (*writeCallback)(uint8_t* data, uint64_t len, void* ctxt);
@@ -1790,6 +1815,14 @@ extern "C"
 		AlwaysSkipFunctionAnalysis
 	};
 
+	enum BNAnalysisSkipReason
+	{
+		NoSkipReason,
+		AlwaysSkipReason,
+		ExceedFunctionSizeSkipReason,
+		ExceedFunctionAnalysisTimeSkipReason
+	};
+
 	BINARYNINJACOREAPI char* BNAllocString(const char* contents);
 	BINARYNINJACOREAPI void BNFreeString(char* str);
 	BINARYNINJACOREAPI char** BNAllocStringList(const char** contents, size_t size);
@@ -2479,9 +2512,12 @@ extern "C"
 
 	BINARYNINJACOREAPI bool BNIsFunctionTooLarge(BNFunction* func);
 	BINARYNINJACOREAPI bool BNIsFunctionAnalysisSkipped(BNFunction* func);
+	BINARYNINJACOREAPI BNAnalysisSkipReason BNGetAnalysisSkipReason(BNFunction* func);
 	BINARYNINJACOREAPI BNFunctionAnalysisSkipOverride BNGetFunctionAnalysisSkipOverride(BNFunction* func);
 	BINARYNINJACOREAPI void BNSetFunctionAnalysisSkipOverride(BNFunction* func, BNFunctionAnalysisSkipOverride skip);
 
+	BINARYNINJACOREAPI BNAnalysisParameters BNGetParametersForAnalysis(BNBinaryView* view);
+	BINARYNINJACOREAPI void BNSetParametersForAnalysis(BNBinaryView* view, BNAnalysisParameters params);
 	BINARYNINJACOREAPI uint64_t BNGetMaxFunctionSizeForAnalysis(BNBinaryView* view);
 	BINARYNINJACOREAPI void BNSetMaxFunctionSizeForAnalysis(BNBinaryView* view, uint64_t size);
 
@@ -2491,6 +2527,8 @@ extern "C"
 	BINARYNINJACOREAPI void BNFreeAnalysisCompletionEvent(BNAnalysisCompletionEvent* event);
 	BINARYNINJACOREAPI void BNCancelAnalysisCompletionEvent(BNAnalysisCompletionEvent* event);
 
+	BINARYNINJACOREAPI BNAnalysisInfo* BNGetAnalysisInfo(BNBinaryView* view);
+	BINARYNINJACOREAPI void BNFreeAnalysisInfo(BNAnalysisInfo* info);
 	BINARYNINJACOREAPI BNAnalysisProgress BNGetAnalysisProgress(BNBinaryView* view);
 	BINARYNINJACOREAPI BNBackgroundTask* BNGetBackgroundAnalysisTask(BNBinaryView* view);
 
diff --git a/binaryview.cpp b/binaryview.cpp
index 9aaf3595..bebfb801 100644
--- a/binaryview.cpp
+++ b/binaryview.cpp
@@ -1014,6 +1014,21 @@ vector<Ref<Function>> BinaryView::GetAnalysisFunctionList()
 }
 
 
+AnalysisInfo BinaryView::GetAnalysisInfo()
+{
+	AnalysisInfo result;
+	BNAnalysisInfo* info = BNGetAnalysisInfo(m_object);
+	result.state = info->state;
+	result.analysisTime = info->analysisTime;
+	result.activeInfo.reserve(info->count);
+	for (size_t i = 0; i < info->count; i++)
+		result.activeInfo.emplace_back(new Function(BNNewFunctionReference(info->activeInfo[i].func)),
+			info->activeInfo[i].analysisTime, info->activeInfo[i].submitCount, info->activeInfo[i].updateCount);
+	BNFreeAnalysisInfo(info);
+	return result;
+}
+
+
 bool BinaryView::HasFunctions() const
 {
 	return BNHasFunctions(m_object);
@@ -1969,6 +1984,18 @@ uint64_t BinaryView::GetUIntMetadata(const string& key)
 }
 
 
+BNAnalysisParameters BinaryView::GetParametersForAnalysis()
+{
+	return BNGetParametersForAnalysis(m_object);
+}
+
+
+void BinaryView::SetParametersForAnalysis(BNAnalysisParameters params)
+{
+	BNSetParametersForAnalysis(m_object, params);
+}
+
+
 uint64_t BinaryView::GetMaxFunctionSizeForAnalysis()
 {
 	return BNGetMaxFunctionSizeForAnalysis(m_object);
diff --git a/function.cpp b/function.cpp
index 835ab144..9c56c644 100644
--- a/function.cpp
+++ b/function.cpp
@@ -1372,6 +1372,12 @@ bool Function::IsAnalysisSkipped()
 }
 
 
+BNAnalysisSkipReason Function::GetAnalysisSkipReason()
+{
+	return BNGetAnalysisSkipReason(m_object);
+}
+
+
 BNFunctionAnalysisSkipOverride Function::GetAnalysisSkipOverride()
 {
 	return BNGetFunctionAnalysisSkipOverride(m_object);
diff --git a/python/binaryview.py b/python/binaryview.py
index 4360502f..b784106e 100644
--- a/python/binaryview.py
+++ b/python/binaryview.py
@@ -145,6 +145,27 @@ class AnalysisCompletionEvent(object):
 		core.BNCancelAnalysisCompletionEvent(self.handle)
 
 
+class ActiveAnalysisInfo(object):
+	def __init__(self, func, analysis_time, update_count, submit_count):
+		self.func = func
+		self.analysis_time = analysis_time
+		self.update_count = update_count
+		self.submit_count = submit_count
+
+	def __repr__(self):
+		return "<ActiveAnalysisInfo %s, analysis_time %d, update_count %d, submit_count %d>" % (self.func, self.analysis_time, self.update_count, self.submit_count)
+
+
+class AnalysisInfo(object):
+	def __init__(self, state, analysis_time, active_info):
+		self.state = AnalysisState(state)
+		self.analysis_time = analysis_time
+		self.active_info = active_info
+
+	def __repr__(self):
+		return "<AnalysisInfo %s, analysis_time %d, active_info %s>" % (self.state, self.analysis_time, self.active_info)
+
+
 class AnalysisProgress(object):
 	def __init__(self, state, count, total):
 		self.state = state
@@ -936,6 +957,20 @@ class BinaryView(object):
 		self.file.saved = value
 
 	@property
+	def analysis_info(self):
+		"""Relevant analysis information with list of functions under active analysis (read-only)"""
+		info_ref = core.BNGetAnalysisInfo(self.handle)
+		info = info_ref[0]
+		active_info_list = []
+		for i in xrange(0, info.count):
+			func = function.Function(self, core.BNNewFunctionReference(info.activeInfo[i].func))
+			active_info = ActiveAnalysisInfo(func, info.activeInfo[i].analysisTime, info.activeInfo[i].updateCount, info.activeInfo[i].submitCount)
+			active_info_list.append(active_info)
+		result = AnalysisInfo(info.state, info.analysisTime, active_info_list)
+		core.BNFreeAnalysisInfo(info_ref)
+		return result
+
+	@property
 	def analysis_progress(self):
 		"""Status of current analysis (read-only)"""
 		result = core.BNGetAnalysisProgress(self.handle)
@@ -1027,6 +1062,14 @@ class BinaryView(object):
 		return function.RegisterValue(self.arch, result.value, confidence = result.confidence)
 
 	@property
+	def parameters_for_analysis(self):
+		return core.BNGetParametersForAnalysis(self.handle)
+
+	@parameters_for_analysis.setter
+	def parameters_for_analysis(self, params):
+		core.BNSetParametersForAnalysis(self.handle, params)
+
+	@property
 	def max_function_size_for_analysis(self):
 		"""Maximum size of function (sum of basic block sizes in bytes) for auto analysis"""
 		return core.BNGetMaxFunctionSizeForAnalysis(self.handle)
diff --git a/python/function.py b/python/function.py
index 6db44e6d..2f794f47 100644
--- a/python/function.py
+++ b/python/function.py
@@ -24,7 +24,7 @@ import ctypes
 
 # Binary Ninja components
 import _binaryninjacore as core
-from enums import (FunctionGraphType, BranchType, SymbolType, InstructionTextTokenType,
+from enums import (AnalysisSkipReason, FunctionGraphType, BranchType, SymbolType, InstructionTextTokenType,
 	HighlightStandardColor, HighlightColorStyle, RegisterValueType, ImplicitRegisterExtend,
 	DisassemblyOption, IntegerDisplayType, InstructionTextTokenContext, VariableSourceType,
 	FunctionAnalysisSkipOverride)
@@ -828,6 +828,11 @@ class Function(object):
 		"""Whether automatic analysis was skipped for this function"""
 		return core.BNIsFunctionAnalysisSkipped(self.handle)
 
+	@property
+	def analysis_skip_reason(self):
+		"""Function analysis skip reason"""
+		return AnalysisSkipReason(core.BNGetAnalysisSkipReason(self.handle))
+
 	@analysis_skipped.setter
 	def analysis_skipped(self, skip):
 		if skip: