From ed08160e6782b3f8b371370bfad3a04e80e94f4d Mon Sep 17 00:00:00 2001 From: Brandon Miller Date: Mon, 3 Feb 2025 16:33:46 -0500 Subject: Firmware Ninja relationships API --- firmwareninja.cpp | 300 ++++++++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 289 insertions(+), 11 deletions(-) (limited to 'firmwareninja.cpp') diff --git a/firmwareninja.cpp b/firmwareninja.cpp index 8e13fccd..9fd53930 100644 --- a/firmwareninja.cpp +++ b/firmwareninja.cpp @@ -58,6 +58,248 @@ static void FreeMemoryInfoArray(BNFirmwareNinjaFunctionMemoryAccesses** fma, siz } +FirmwareNinjaRelationship::FirmwareNinjaRelationship(Ref view, BNFirmwareNinjaRelationship* handle) +{ + if (handle) + m_object = handle; + else + m_object = BNNewFirmwareNinjaRelationshipReference(BNCreateFirmwareNinjaRelationship(view->GetObject())); +} + + +FirmwareNinjaRelationship::~FirmwareNinjaRelationship() +{ + BNFreeFirmwareNinjaRelationship(m_object); +} + + +void FirmwareNinjaRelationship::SetPrimaryAddress(uint64_t address) +{ + BNFirmwareNinjaRelationshipSetPrimaryAddress(m_object, address); +} + + +void FirmwareNinjaRelationship::SetPrimaryDataVariable(DataVariable& variable) +{ + BNFirmwareNinjaRelationshipSetPrimaryDataVariable(m_object, variable.address); +} + + +void FirmwareNinjaRelationship::SetPrimaryFunction(Ref function) +{ + BNFirmwareNinjaRelationshipSetPrimaryFunction(m_object, function->GetObject()); +} + + +bool FirmwareNinjaRelationship::PrimaryIsAddress() const +{ + return BNFirmwareNinjaRelationshipPrimaryIsAddress(m_object); +} + + +bool FirmwareNinjaRelationship::PrimaryIsDataVariable() const +{ + return BNFirmwareNinjaRelationshipPrimaryIsDataVariable(m_object); +} + + +bool FirmwareNinjaRelationship::PrimaryIsFunction() const +{ + return BNFirmwareNinjaRelationshipPrimaryIsFunction(m_object); +} + + +bool FirmwareNinjaRelationship::GetPrimaryDataVariable(DataVariable& variable) +{ + BNDataVariable bnVariable; + if (!BNFirmwareNinjaRelationshipGetPrimaryDataVariable(m_object, &bnVariable)) + return false; + + variable.address = bnVariable.address; + variable.type = Confidence(new Type(BNNewTypeReference(bnVariable.type)), bnVariable.typeConfidence); + variable.autoDiscovered = bnVariable.autoDiscovered; + BNFreeDataVariable(&bnVariable); + return true; +} + + +std::optional FirmwareNinjaRelationship::GetPrimaryAddress() const +{ + std::optional result; + uint64_t tmp; + if (BNFirmwareNinjaRelationshipGetPrimaryAddress(m_object, &tmp)) + result = tmp; + + return result; +} + + +Ref FirmwareNinjaRelationship::GetPrimaryFunction() const +{ + auto bnFunction = BNFirmwareNinjaRelationshipGetPrimaryFunction(m_object); + if (!bnFunction) + return nullptr; + + return new Function(BNNewFunctionReference(bnFunction)); +} + + +void FirmwareNinjaRelationship::SetSecondaryAddress(uint64_t address) +{ + BNFirmwareNinjaRelationshipSetSecondaryAddress(m_object, address); +} + + +void FirmwareNinjaRelationship::SetSecondaryDataVariable(DataVariable& variable) +{ + BNFirmwareNinjaRelationshipSetSecondaryDataVariable(m_object, variable.address); +} + + +void FirmwareNinjaRelationship::SetSecondaryFunction(Ref function) +{ + BNFirmwareNinjaRelationshipSetSecondaryFunction(m_object, function->GetObject()); +} + + +void FirmwareNinjaRelationship::SetSecondaryExternalAddress(Ref projectFile, uint64_t address) +{ + BNFirmwareNinjaRelationshipSetSecondaryExternalAddress(m_object, projectFile->GetObject(), address); +} + + +void FirmwareNinjaRelationship::SetSecondaryExternalSymbol(Ref projectFile, const std::string& symbol) +{ + BNFirmwareNinjaRelationshipSetSecondaryExternalSymbol(m_object, projectFile->GetObject(), symbol.c_str()); +} + + +bool FirmwareNinjaRelationship::SecondaryIsAddress() const +{ + return BNFirmwareNinjaRelationshipSecondaryIsAddress(m_object); +} + + +bool FirmwareNinjaRelationship::SecondaryIsDataVariable() const +{ + return BNFirmwareNinjaRelationshipSecondaryIsDataVariable(m_object); +} + + +bool FirmwareNinjaRelationship::SecondaryIsFunction() const +{ + return BNFirmwareNinjaRelationshipSecondaryIsFunction(m_object); +} + + +bool FirmwareNinjaRelationship::SecondaryIsExternalAddress() const +{ + return BNFirmwareNinjaRelationshipSecondaryIsExternalAddress(m_object); +} + + +bool FirmwareNinjaRelationship::SecondaryIsExternalSymbol() const +{ + return BNFirmwareNinjaRelationshipSecondaryIsExternalSymbol(m_object); +} + + +Ref FirmwareNinjaRelationship::GetSecondaryExternalProjectFile() const +{ + auto bnProjectFile = BNFirmwareNinjaRelationshipGetSecondaryExternalProjectFile(m_object); + if (!bnProjectFile) + return nullptr; + + return new ProjectFile(BNNewProjectFileReference(bnProjectFile)); +} + + +std::optional FirmwareNinjaRelationship::GetSecondaryAddress() const +{ + std::optional result; + uint64_t tmp; + if (BNFirmwareNinjaRelationshipGetSecondaryAddress(m_object, &tmp)) + result = tmp; + + return result; +} + + +bool FirmwareNinjaRelationship::GetSecondaryDataVariable(DataVariable& variable) +{ + BNDataVariable bnVariable; + if (!BNFirmwareNinjaRelationshipGetSecondaryDataVariable(m_object, &bnVariable)) + return false; + + variable.address = bnVariable.address; + variable.type = Confidence(new Type(BNNewTypeReference(bnVariable.type)), bnVariable.typeConfidence); + variable.autoDiscovered = bnVariable.autoDiscovered; + BNFreeDataVariable(&bnVariable); + return true; +} + + +Ref FirmwareNinjaRelationship::GetSecondaryFunction() const +{ + auto bnFunction = BNFirmwareNinjaRelationshipGetSecondaryFunction(m_object); + if (!bnFunction) + return nullptr; + + return new Function(BNNewFunctionReference(bnFunction)); +} + + +std::string FirmwareNinjaRelationship::GetSecondaryExternalSymbol() const +{ + std::string result = ""; + auto bnSymbol = BNFirmwareNinjaRelationshipGetSecondaryExternalSymbol(m_object); + if (bnSymbol) + result = std::string(bnSymbol); + + return result; +} + + +void FirmwareNinjaRelationship::SetDescription(const std::string& description) +{ + BNFirmwareNinjaRelationshipSetDescription(m_object, description.c_str()); +} + + +std::string FirmwareNinjaRelationship::GetDescription() const +{ + std::string result = ""; + auto bnDescription = BNFirmwareNinjaRelationshipGetDescription(m_object); + if (bnDescription) + result = std::string(bnDescription); + + return result; +} + + +void FirmwareNinjaRelationship::SetProvenance(const std::string& provenance) +{ + BNFirmwareNinjaRelationshipSetProvenance(m_object, provenance.c_str()); +} + + +std::string FirmwareNinjaRelationship::GetProvenance() const +{ + std::string result = ""; + auto bnProvenance = BNFirmwareNinjaRelationshipGetProvenance(m_object); + if (bnProvenance) + result = std::string(bnProvenance); + + return result; +} + + +std::string FirmwareNinjaRelationship::GetGuid() const +{ + return BNFirmwareNinjaRelationshipGetGuid(m_object); +} + + FirmwareNinjaReferenceNode::FirmwareNinjaReferenceNode(BNFirmwareNinjaReferenceNode* node) { m_object = node; @@ -101,14 +343,14 @@ bool FirmwareNinjaReferenceNode::GetFunction(Ref& function) bool FirmwareNinjaReferenceNode::GetDataVariable(DataVariable& variable) { - auto bnVariable = BNFirmwareNinjaReferenceNodeGetDataVariable(m_object); - if (!bnVariable) + BNDataVariable bnVariable; + if (!BNFirmwareNinjaReferenceNodeGetDataVariable(m_object, &bnVariable)) return false; - variable.address = bnVariable->address; - variable.type = Confidence(new Type(BNNewTypeReference(bnVariable->type)), bnVariable->typeConfidence); - variable.autoDiscovered = bnVariable->autoDiscovered; - BNFreeDataVariable(bnVariable); + variable.address = bnVariable.address; + variable.type = Confidence(new Type(BNNewTypeReference(bnVariable.type)), bnVariable.typeConfidence); + variable.autoDiscovered = bnVariable.autoDiscovered; + BNFreeDataVariable(&bnVariable); return true; } @@ -125,8 +367,6 @@ std::vector> FirmwareNinjaReferenceNode::GetChil BNNewFirmwareNinjaReferenceNodeReference(bnChildren[i]))); } - if (count) - BNFreeFirmwareNinjaReferenceNodes(bnChildren, count); return result; } @@ -383,7 +623,7 @@ Ref FirmwareNinja::GetReferenceTree( if (!bnReferenceTree) return nullptr; - return new FirmwareNinjaReferenceNode(bnReferenceTree); + return new FirmwareNinjaReferenceNode(BNNewFirmwareNinjaReferenceNodeReference(bnReferenceTree)); } @@ -401,7 +641,7 @@ Ref FirmwareNinja::GetReferenceTree( if (!bnReferenceTree) return nullptr; - return new FirmwareNinjaReferenceNode(bnReferenceTree); + return new FirmwareNinjaReferenceNode(BNNewFirmwareNinjaReferenceNodeReference(bnReferenceTree)); } @@ -418,5 +658,43 @@ Ref FirmwareNinja::GetReferenceTree( if (!bnReferenceTree) return nullptr; - return new FirmwareNinjaReferenceNode(bnReferenceTree); + return new FirmwareNinjaReferenceNode(BNNewFirmwareNinjaReferenceNodeReference(bnReferenceTree)); +} + + +std::vector> FirmwareNinja::QueryRelationships() +{ + std::vector> result; + size_t count = 0; + auto bnRelationships = BNFirmwareNinjaQueryRelationships(m_object, &count); + result.reserve(count); + for (size_t i = 0; i < count; ++i) + { + result.push_back(new FirmwareNinjaRelationship(m_view, + BNNewFirmwareNinjaRelationshipReference(bnRelationships[i]))); + } + + return result; +} + + +void FirmwareNinja::AddRelationship(Ref relationship) +{ + BNFirmwareNinjaAddRelationship(m_object, relationship->GetObject()); +} + + +Ref FirmwareNinja::GetRelationshipByGuid(const std::string& guid) +{ + auto bnRelationship = BNFirmwareNinjaGetRelationshipByGuid(m_object, guid.c_str()); + if (!bnRelationship) + return nullptr; + + return new FirmwareNinjaRelationship(m_view, BNNewFirmwareNinjaRelationshipReference(bnRelationship)); +} + + +void FirmwareNinja::RemoveRelationshipByGuid(const std::string& guid) +{ + BNFirmwareNinjaRemoveRelationshipByGuid(m_object, guid.c_str()); } -- cgit v1.3.1