Merging with dev

12 files changed, 367 insertions, 3 deletions

diff --git a/python/__init__.py b/python/__init__.py
index 729e4f8a..fda5f297 100644
--- a/python/__init__.py
+++ b/python/__init__.py
@@ -50,6 +50,7 @@ from .lineardisassembly import *
 from .undoaction import *
 from .highlight import *
 from .scriptingprovider import *
+from .downloadprovider import *
 from .pluginmanager import *
 from .setting import *
 from .metadata import *
diff --git a/python/architecture.py b/python/architecture.py
index c5f87ec6..df22da7f 100644
--- a/python/architecture.py
+++ b/python/architecture.py
@@ -392,6 +392,11 @@ class Architecture(object):
 		return ctypes.addressof(self.handle.contents) != ctypes.addressof(value.handle.contents)
 
 	@property
+	def list(self):
+		"""Allow tab completion to discover metaclass list property"""
+		pass
+
+	@property
 	def full_width_regs(self):
 		"""List of full width register strings (read-only)"""
 		count = ctypes.c_ulonglong()
diff --git a/python/basicblock.py b/python/basicblock.py
index c55e15f0..a79b53ad 100644
--- a/python/basicblock.py
+++ b/python/basicblock.py
@@ -312,6 +312,8 @@ class BasicBlock(object):
 			inst_info = self.arch.get_instruction_info(data, idx)
 			inst_text = self.arch.get_instruction_text(data, idx)
 
+			if inst_info is None:
+				break
 			yield inst_text
 			idx += inst_info.length
 
diff --git a/python/binaryview.py b/python/binaryview.py
index 3c21e499..5bebec8e 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
@@ -156,6 +177,8 @@ class AnalysisProgress(object):
 			return "Disassembling (%d/%d)" % (self.count, self.total)
 		if self.state == AnalysisState.AnalyzeState:
 			return "Analyzing (%d/%d)" % (self.count, self.total)
+		if self.state == AnalysisState.ExtendedAnalyzeState:
+			return "Extended Analysis"
 		return "Idle"
 
 	def __repr__(self):
@@ -343,6 +366,11 @@ class BinaryViewType(object):
 		return ctypes.addressof(self.handle.contents) != ctypes.addressof(value.handle.contents)
 
 	@property
+	def list(self):
+		"""Allow tab completion to discover metaclass list property"""
+		pass
+
+	@property
 	def name(self):
 		"""BinaryView name (read-only)"""
 		return core.BNGetBinaryViewTypeName(self.handle)
@@ -1006,6 +1034,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)
@@ -1093,6 +1135,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)
@@ -2821,6 +2871,8 @@ class BinaryView(object):
 		if start is None:
 			strings = core.BNGetStrings(self.handle, count)
 		else:
+			if length is None:
+				length = self.end - start
 			strings = core.BNGetStringsInRange(self.handle, start, length, count)
 		result = []
 		for i in xrange(0, count.value):
diff --git a/python/downloadprovider.py b/python/downloadprovider.py
new file mode 100644
index 00000000..d34ca358
--- /dev/null
+++ b/python/downloadprovider.py
@@ -0,0 +1,269 @@
+# Copyright (c) 2015-2018 Vector 35 LLC
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to
+# deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+# sell copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+# IN THE SOFTWARE.
+
+
+import abc
+import code
+import ctypes
+import sys
+import traceback
+
+# Binary Ninja Components
+import binaryninja._binaryninjacore as core
+from binaryninja.setting import Setting
+from binaryninja import startup
+from binaryninja import log
+
+
+class DownloadInstance(object):
+	def __init__(self, provider, handle = None):
+		if handle is None:
+			self._cb = core.BNDownloadInstanceCallbacks()
+			self._cb.context = 0
+			self._cb.destroyInstance = self._cb.destroyInstance.__class__(self._destroy_instance)
+			self._cb.performRequest = self._cb.performRequest.__class__(self._perform_request)
+			self.handle = core.BNInitDownloadInstance(provider.handle, self._cb)
+		else:
+			self.handle = core.handle_of_type(handle, core.BNDownloadInstance)
+		self._outputCallbacks = None
+
+	def __del__(self):
+		core.BNFreeDownloadInstance(self.handle)
+
+	def _destroy_instance(self, ctxt):
+		try:
+			self.perform_destroy_instance()
+		except:
+			log.log_error(traceback.format_exc())
+
+	def _perform_request(self, ctxt, url):
+		try:
+			return self.perform_request(url)
+		except:
+			log.log_error(traceback.format_exc())
+			return -1
+
+	@abc.abstractmethod
+	def perform_destroy_instance(self):
+		raise NotImplementedError
+
+	@abc.abstractmethod
+	def perform_request(self, ctxt, url):
+		raise NotImplementedError
+
+	def perform_request(self, url, callbacks):
+		return core.BNPerformDownloadRequest(self.handle, url, callbacks)
+
+
+class _DownloadProviderMetaclass(type):
+	@property
+	def list(self):
+		"""List all DownloadProvider types (read-only)"""
+		startup._init_plugins()
+		count = ctypes.c_ulonglong()
+		types = core.BNGetDownloadProviderList(count)
+		result = []
+		for i in xrange(0, count.value):
+			result.append(DownloadProvider(types[i]))
+		core.BNFreeDownloadProviderList(types)
+		return result
+
+	def __iter__(self):
+		startup._init_plugins()
+		count = ctypes.c_ulonglong()
+		types = core.BNGetDownloadProviderList(count)
+		try:
+			for i in xrange(0, count.value):
+				yield DownloadProvider(types[i])
+		finally:
+			core.BNFreeDownloadProviderList(types)
+
+	def __getitem__(self, value):
+		startup._init_plugins()
+		provider = core.BNGetDownloadProviderByName(str(value))
+		if provider is None:
+			raise KeyError("'%s' is not a valid download provider" % str(value))
+		return DownloadProvider(provider)
+
+	def __setattr__(self, name, value):
+		try:
+			type.__setattr__(self, name, value)
+		except AttributeError:
+			raise AttributeError("attribute '%s' is read only" % name)
+
+
+class DownloadProvider(object):
+	__metaclass__ = _DownloadProviderMetaclass
+	name = None
+	instance_class = None
+	_registered_providers = []
+
+	def __init__(self, handle = None):
+		if handle is not None:
+			self.handle = core.handle_of_type(handle, core.BNDownloadProvider)
+			self.__dict__["name"] = core.BNGetDownloadProviderName(handle)
+
+	def register(self):
+		self._cb = core.BNDownloadProviderCallbacks()
+		self._cb.context = 0
+		self._cb.createInstance = self._cb.createInstance.__class__(self._create_instance)
+		self.handle = core.BNRegisterDownloadProvider(self.__class__.name, self._cb)
+		self.__class__._registered_providers.append(self)
+
+	def _create_instance(self, ctxt):
+		try:
+			result = self.__class__.instance_class(self)
+			if result is None:
+				return None
+			return ctypes.cast(core.BNNewDownloadInstanceReference(result.handle), ctypes.c_void_p).value
+		except:
+			log.log_error(traceback.format_exc())
+			return None
+
+	def create_instance(self):
+		result = core.BNCreateDownloadProviderInstance(self.handle)
+		if result is None:
+			return None
+		return DownloadInstance(self, handle = result)
+
+
+if sys.version_info >= (2, 7, 9):
+	try:
+		from urllib.request import urlopen, build_opener, install_opener, ProxyHandler
+		from urllib.error import URLError
+	except ImportError:
+		from urllib2 import urlopen, build_opener, install_opener, ProxyHandler, URLError
+
+	class PythonDownloadInstance(DownloadInstance):
+		def __init__(self, provider):
+			super(PythonDownloadInstance, self).__init__(provider)
+
+		@abc.abstractmethod
+		def perform_destroy_instance(self):
+			pass
+
+		@abc.abstractmethod
+		def perform_request(self, url):
+			try:
+				proxy_setting = Setting('download-client').get_string('https-proxy')
+				if proxy_setting:
+					opener = build_opener(ProxyHandler({'https': proxy_setting}))
+					install_opener(opener)
+
+				r = urlopen(url.decode("charmap"))
+				total_size = int(r.headers.get('content-length', 0))
+				bytes_sent = 0
+				while True:
+					data = r.read(4096)
+					if not data:
+						break
+					raw_bytes = (ctypes.c_ubyte * len(data)).from_buffer_copy(data)
+					bytes_wrote = core.BNWriteDataForDownloadInstance(self.handle, raw_bytes, len(raw_bytes))
+					if bytes_wrote != len(raw_bytes):
+						core.BNSetErrorForDownloadInstance(self.handle, "Bytes written mismatch!")
+						return -1
+					bytes_sent = bytes_sent + bytes_wrote
+					continue_download = core.BNNotifyProgressForDownloadInstance(self.handle, bytes_sent, total_size)
+					if continue_download is False:
+						core.BNSetErrorForDownloadInstance(self.handle, "Download aborted!")
+						return -1
+
+				if not bytes_sent:
+					core.BNSetErrorForDownloadInstance(self.handle, "Received no data!")
+					return -1
+
+			except URLError as e:
+				core.BNSetErrorForDownloadInstance(self.handle, e.__class__.__name__)
+				return -1
+			except:
+				core.BNSetErrorForDownloadInstance(self.handle, "Unknown Exception!")
+				log.log_error(traceback.format_exc())
+				return -1
+
+			return 0
+
+	class PythonDownloadProvider(DownloadProvider):
+		name = "DefaultDownloadProvider"
+		instance_class = PythonDownloadInstance
+
+	PythonDownloadProvider().register()
+else:
+	try:
+		import requests
+		from requests import pyopenssl
+		class PythonDownloadInstance(DownloadInstance):
+			def __init__(self, provider):
+				super(PythonDownloadInstance, self).__init__(provider)
+
+			@abc.abstractmethod
+			def perform_destroy_instance(self):
+				pass
+
+			@abc.abstractmethod
+			def perform_request(self, url):
+				try:
+					proxy_setting = Setting('download-client').get_string('https-proxy')
+					if proxy_setting:
+						proxies = {"https": proxy_setting}
+					else:
+						proxies = None
+
+					r = requests.get(url.decode("charmap"), proxies=proxies)
+					if not r.ok:
+						core.BNSetErrorForDownloadInstance(self.handle, "Received error from server")
+						return -1
+					data = r.content
+					if len(data) == 0:
+						core.BNSetErrorForDownloadInstance(self.handle, "No data received from server!")
+						return -1
+					raw_bytes = (ctypes.c_ubyte * len(data)).from_buffer_copy(data)
+					bytes_wrote = core.BNWriteDataForDownloadInstance(self.handle, raw_bytes, len(raw_bytes))
+					if bytes_wrote != len(raw_bytes):
+						core.BNSetErrorForDownloadInstance(self.handle, "Bytes written mismatch!")
+						return -1
+					continue_download = core.BNNotifyProgressForDownloadInstance(self.handle, bytes_wrote, bytes_wrote)
+					if continue_download is False:
+						core.BNSetErrorForDownloadInstance(self.handle, "Download aborted!")
+						return -1
+				except requests.RequestException as e:
+					core.BNSetErrorForDownloadInstance(self.handle, e.__class__.__name__)
+					return -1
+				except:
+					core.BNSetErrorForDownloadInstance(self.handle, "Unknown Exception!")
+					log.log_error(traceback.format_exc())
+					return -1
+
+				return 0
+
+		class PythonDownloadProvider(DownloadProvider):
+			name = "DefaultDownloadProvider"
+			instance_class = PythonDownloadInstance
+
+		PythonDownloadProvider().register()
+	except ImportError:
+		if sys.platform == "win32":
+			log.log_error("Provided Python version is too old! Only Python 2.7.10 and above are known to work on Windows!")
+		else:
+			log.log_error("On Python versions below 2.7.9, the pip requests[security] package is required for network connectivity!")
+			log.log_error("On an Ubuntu 14.04 install, the following three commands are sufficient to enable networking for the current user:")
+			log.log_error("  sudo apt install python-pip")
+			log.log_error("  python -m pip install pip --upgrade --user")
+			log.log_error("  python -m pip install requests[security] --upgrade --user")
+
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:
diff --git a/python/lowlevelil.py b/python/lowlevelil.py
index 34048704..bd1e9349 100644
--- a/python/lowlevelil.py
+++ b/python/lowlevelil.py
@@ -1809,8 +1809,9 @@ class LowLevelILFunction(object):
 		param_list = []
 		for param in params:
 			param_list.append(param.index)
-		return self.expr(LowLevelILOperation.LLIL_INTRINSIC, len(outputs), self.add_operand_list(output_list),
-			self.arch.get_intrinsic_index(intrinsic), len(params), self.add_operand_list(param_list), flags = flags)
+		call_param = self.expr(LowLevelILOperation.LLIL_CALL_PARAM, len(params), self.add_operand_list(param_list).index)
+		return self.expr(LowLevelILOperation.LLIL_INTRINSIC, len(outputs), self.add_operand_list(output_list).index,
+			self.arch.get_intrinsic_index(intrinsic), call_param.index, flags = flags)
 
 	def breakpoint(self):
 		"""
diff --git a/python/platform.py b/python/platform.py
index a79e3b9a..dd756178 100644
--- a/python/platform.py
+++ b/python/platform.py
@@ -121,6 +121,11 @@ class Platform(object):
 		return ctypes.addressof(self.handle.contents) != ctypes.addressof(value.handle.contents)
 
 	@property
+	def list(self):
+		"""Allow tab completion to discover metaclass list property"""
+		pass
+
+	@property
 	def default_calling_convention(self):
 		"""
 		Default calling convention.
diff --git a/python/plugin.py b/python/plugin.py
index 30a46412..13ca51af 100644
--- a/python/plugin.py
+++ b/python/plugin.py
@@ -83,6 +83,11 @@ class PluginCommand(object):
 		self.description = str(cmd.description)
 		self.type = PluginCommandType(cmd.type)
 
+	@property
+	def list(self):
+		"""Allow tab completion to discover metaclass list property"""
+		pass
+
 	@classmethod
 	def _default_action(cls, view, action):
 		try:
@@ -588,6 +593,11 @@ class BackgroundTask(object):
 		core.BNFreeBackgroundTask(self.handle)
 
 	@property
+	def list(self):
+		"""Allow tab completion to discover metaclass list property"""
+		pass
+
+	@property
 	def progress(self):
 		"""Text description of the progress of the background task (displayed in status bar of the UI)"""
 		return core.BNGetBackgroundTaskProgressText(self.handle)
diff --git a/python/pluginmanager.py b/python/pluginmanager.py
index 2f293577..0cc43aca 100644
--- a/python/pluginmanager.py
+++ b/python/pluginmanager.py
@@ -32,6 +32,7 @@ class RepoPlugin(object):
 	created by parsing the plugins.json in a plugin repository.
 	"""
 	def __init__(self, handle):
+		raise Exception("RepoPlugin temporarily disabled!")
 		self.handle = core.handle_of_type(handle, core.BNRepoPlugin)
 
 	def __del__(self):
@@ -136,6 +137,7 @@ class Repository(object):
 	``Repository`` is a read-only class. Use RepositoryManager to Enable/Disable/Install/Uninstall plugins.
 	"""
 	def __init__(self, handle):
+		raise Exception("Repository temporarily disabled!")
 		self.handle = core.handle_of_type(handle, core.BNRepository)
 
 	def __del__(self):
@@ -199,6 +201,7 @@ class RepositoryManager(object):
 	the plugins that are installed/unstalled enabled/disabled
 	"""
 	def __init__(self, handle=None):
+		raise Exception("RepositoryManager temporarily disabled!")
 		self.handle = core.BNGetRepositoryManager()
 
 	def __getitem__(self, repo_path):
diff --git a/python/scriptingprovider.py b/python/scriptingprovider.py
index 988f856d..9cacc6ad 100644
--- a/python/scriptingprovider.py
+++ b/python/scriptingprovider.py
@@ -304,6 +304,12 @@ class ScriptingProvider(object):
 			self.handle = core.handle_of_type(handle, core.BNScriptingProvider)
 			self.__dict__["name"] = core.BNGetScriptingProviderName(handle)
 
+	@property
+	def list(self):
+		"""Allow tab completion to discover metaclass list property"""
+		pass
+
+
 	def register(self):
 		self._cb = core.BNScriptingProviderCallbacks()
 		self._cb.context = 0
diff --git a/python/transform.py b/python/transform.py
index 59d719e7..3284ed74 100644
--- a/python/transform.py
+++ b/python/transform.py
@@ -200,6 +200,11 @@ class Transform(object):
 			log.log_error(traceback.format_exc())
 			return False
 
+	@property
+	def list(self):
+		"""Allow tab completion to discover metaclass list property"""
+		pass
+
 	@abc.abstractmethod
 	def perform_decode(self, data, params):
 		if self.type == TransformType.InvertingTransform: