From 9a40763268a7859288875e1ab59a7cf7592529f6 Mon Sep 17 00:00:00 2001 From: Rusty Wagner Date: Wed, 27 Jul 2016 02:51:23 -0400 Subject: Add APIs to add user types --- binaryninjaapi.h | 8 ++++++++ binaryninjacore.h | 9 +++++++++ binaryview.cpp | 53 +++++++++++++++++++++++++++++++++++++++++++++++++++++ python/__init__.py | 42 +++++++++++++++++++++++++++++++++++++----- 4 files changed, 107 insertions(+), 5 deletions(-) diff --git a/binaryninjaapi.h b/binaryninjaapi.h index 1bdaab13..7a6b3280 100644 --- a/binaryninjaapi.h +++ b/binaryninjaapi.h @@ -891,6 +891,14 @@ namespace BinaryNinja DisassemblySettings* settings); bool ParseTypeString(const std::string& text, NameAndType& result, std::string& errors); + + std::map> GetTypes(); + Ref GetTypeByName(const std::string& name); + bool IsTypeAutoDefined(const std::string& name); + void DefineType(const std::string& name, Type* type); + void DefineUserType(const std::string& name, Type* type); + void UndefineType(const std::string& name); + void UndefineUserType(const std::string& name); }; class BinaryData: public BinaryView diff --git a/binaryninjacore.h b/binaryninjacore.h index 241f1f3d..1cc5bd75 100644 --- a/binaryninjacore.h +++ b/binaryninjacore.h @@ -1460,6 +1460,15 @@ extern "C" BINARYNINJACOREAPI bool BNParseTypeString(BNBinaryView* view, const char* text, BNNameAndType* result, char** errors); BINARYNINJACOREAPI void BNFreeNameAndType(BNNameAndType* obj); + BINARYNINJACOREAPI BNNameAndType* BNGetAnalysisTypeList(BNBinaryView* view, size_t* count); + BINARYNINJACOREAPI void BNFreeTypeList(BNNameAndType* types, size_t count); + BINARYNINJACOREAPI BNType* BNGetAnalysisTypeByName(BNBinaryView* view, const char* name); + BINARYNINJACOREAPI bool BNIsAnalysisTypeAutoDefined(BNBinaryView* view, const char* name); + BINARYNINJACOREAPI void BNDefineAnalysisType(BNBinaryView* view, const char* name, BNType* type); + BINARYNINJACOREAPI void BNDefineUserAnalysisType(BNBinaryView* view, const char* name, BNType* type); + BINARYNINJACOREAPI void BNUndefineAnalysisType(BNBinaryView* view, const char* name); + BINARYNINJACOREAPI void BNUndefineUserAnalysisType(BNBinaryView* view, const char* name); + // Disassembly settings BINARYNINJACOREAPI BNDisassemblySettings* BNCreateDisassemblySettings(void); BINARYNINJACOREAPI BNDisassemblySettings* BNNewDisassemblySettingsReference(BNDisassemblySettings* settings); diff --git a/binaryview.cpp b/binaryview.cpp index ee5bda8e..de0870b6 100644 --- a/binaryview.cpp +++ b/binaryview.cpp @@ -1358,6 +1358,59 @@ bool BinaryView::ParseTypeString(const string& text, NameAndType& result, string } +map> BinaryView::GetTypes() +{ + size_t count; + BNNameAndType* types = BNGetAnalysisTypeList(m_object, &count); + + map> result; + for (size_t i = 0; i < count; i++) + result[types[i].name] = new Type(BNNewTypeReference(types[i].type)); + + BNFreeTypeList(types, count); + return result; +} + + +Ref BinaryView::GetTypeByName(const string& name) +{ + BNType* type = BNGetAnalysisTypeByName(m_object, name.c_str()); + if (!type) + return nullptr; + return new Type(type); +} + + +bool BinaryView::IsTypeAutoDefined(const std::string& name) +{ + return BNIsAnalysisTypeAutoDefined(m_object, name.c_str()); +} + + +void BinaryView::DefineType(const std::string& name, Type* type) +{ + BNDefineAnalysisType(m_object, name.c_str(), type->GetObject()); +} + + +void BinaryView::DefineUserType(const std::string& name, Type* type) +{ + BNDefineUserAnalysisType(m_object, name.c_str(), type->GetObject()); +} + + +void BinaryView::UndefineType(const std::string& name) +{ + BNUndefineAnalysisType(m_object, name.c_str()); +} + + +void BinaryView::UndefineUserType(const std::string& name) +{ + BNUndefineUserAnalysisType(m_object, name.c_str()); +} + + BinaryData::BinaryData(FileMetadata* file): BinaryView(BNCreateBinaryDataView(file->GetObject())) { } diff --git a/python/__init__.py b/python/__init__.py index 4d7e7fb8..da8abd02 100644 --- a/python/__init__.py +++ b/python/__init__.py @@ -751,7 +751,7 @@ class BinaryView(object): """Binary View long name""" _registered = False _registered_cb = None - view_type = None + registered_view_type = None """Binary View type""" def __init__(self, file_metadata = None, handle = None): @@ -806,7 +806,7 @@ class BinaryView(object): cls._registered_cb.context = 0 cls._registered_cb.create = cls._registered_cb.create.__class__(cls._create) cls._registered_cb.isValidForData = cls._registered_cb.isValidForData.__class__(cls._is_valid_for_data) - cls.view_type = BinaryViewType(core.BNRegisterBinaryViewType(cls.name, cls.long_name, cls._registered_cb)) + cls.registered_view_type = BinaryViewType(core.BNRegisterBinaryViewType(cls.name, cls.long_name, cls._registered_cb)) cls._registered = True @classmethod @@ -1003,13 +1003,13 @@ class BinaryView(object): return result @property - def type(self): + def view_type(self): """View type (read-only)""" return core.BNGetViewType(self.handle) @property - def available_types(self): - """Available types (read-only)""" + def available_view_types(self): + """Available view types (read-only)""" count = ctypes.c_ulonglong(0) types = core.BNGetBinaryViewTypesForData(self.handle, count) result = [] @@ -1056,6 +1056,17 @@ class BinaryView(object): core.BNFreeDataVariables(var_list, count.value) return result + @property + def types(self): + """List of defined types (read-only)""" + count = ctypes.c_ulonglong(0) + type_list = core.BNGetAnalysisTypeList(self.handle, count) + result = {} + for i in xrange(0, count.value): + result[type_list[i].name] = Type(core.BNNewTypeReference(type_list[i].type)) + core.BNFreeTypeList(type_list, count.value) + return result + def __len__(self): return int(core.BNGetViewLength(self.handle)) @@ -1745,6 +1756,27 @@ class BinaryView(object): core.BNFreeNameAndType(result) return type_obj, name + def get_type_by_name(self, name): + obj = core.BNGetAnalysisTypeByName(self.handle, name) + if not obj: + return None + return Type(obj) + + def is_type_auto_defined(self, name): + return core.BNIsAnalysisTypeAutoDefined(self.handle, name) + + def define_type(self, name, type_obj): + core.BNDefineAnalysisType(self.handle, name, type_obj.handle) + + def define_user_type(self, name, type_obj): + core.BNDefineUserAnalysisType(self.handle, name, type_obj.handle) + + def undefine_type(self, name): + core.BNUndefineAnalysisType(self.handle, name) + + def undefine_user_type(self, name): + core.BNUndefineUserAnalysisType(self.handle, name) + def __setattr__(self, name, value): try: object.__setattr__(self,name,value) -- cgit v1.3.1