// Copyright (c) 2015-2026 Vector 35 Inc

//

// 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.

#include <algorithm>

#include <iterator>

#include <memory>

#include "binaryninjaapi.h"

using namespace BinaryNinja;

using namespace std;

struct SymbolQueueResolveContext

{

std::function<std::pair<Ref<Symbol>, Confidence<Ref<Type>>>()> resolve;

};

struct SymbolQueueAddContext

{

std::function<void(Symbol*, const Confidence<Ref<Type>>&)> add;

};

uint64_t BinaryDataNotification::NotificationBarrierCallback(void* ctxt, BNBinaryView* object)

{

BinaryDataNotification* notify = (BinaryDataNotification*)ctxt;

Ref<BinaryView> view = new BinaryView(BNNewViewReference(object));

return notify->OnNotificationBarrier(view);

}

void BinaryDataNotification::DataWrittenCallback(void* ctxt, BNBinaryView* object, uint64_t offset, size_t len)

{

BinaryDataNotification* notify = (BinaryDataNotification*)ctxt;

Ref<BinaryView> view = new BinaryView(BNNewViewReference(object));

notify->OnBinaryDataWritten(view, offset, len);

}

void BinaryDataNotification::DataInsertedCallback(void* ctxt, BNBinaryView* object, uint64_t offset, size_t len)

{

BinaryDataNotification* notify = (BinaryDataNotification*)ctxt;

Ref<BinaryView> view = new BinaryView(BNNewViewReference(object));

notify->OnBinaryDataInserted(view, offset, len);

}

void BinaryDataNotification::DataRemovedCallback(void* ctxt, BNBinaryView* object, uint64_t offset, uint64_t len)

{

BinaryDataNotification* notify = (BinaryDataNotification*)ctxt;

Ref<BinaryView> view = new BinaryView(BNNewViewReference(object));

notify->OnBinaryDataRemoved(view, offset, len);

}

void BinaryDataNotification::FunctionAddedCallback(void* ctxt, BNBinaryView* object, BNFunction* func)

{

BinaryDataNotification* notify = (BinaryDataNotification*)ctxt;

Ref<BinaryView> view = new BinaryView(BNNewViewReference(object));

Ref<Function> funcObj = new Function(BNNewFunctionReference(func));

notify->OnAnalysisFunctionAdded(view, funcObj);

}

void BinaryDataNotification::FunctionRemovedCallback(void* ctxt, BNBinaryView* object, BNFunction* func)

{

BinaryDataNotification* notify = (BinaryDataNotification*)ctxt;

Ref<BinaryView> view = new BinaryView(BNNewViewReference(object));

Ref<Function> funcObj = new Function(BNNewFunctionReference(func));

notify->OnAnalysisFunctionRemoved(view, funcObj);

}

void BinaryDataNotification::FunctionUpdatedCallback(void* ctxt, BNBinaryView* object, BNFunction* func)

{

BinaryDataNotification* notify = (BinaryDataNotification*)ctxt;

Ref<BinaryView> view = new BinaryView(BNNewViewReference(object));

Ref<Function> funcObj = new Function(BNNewFunctionReference(func));

notify->OnAnalysisFunctionUpdated(view, funcObj);

}

void BinaryDataNotification::FunctionUpdateRequestedCallback(void* ctxt, BNBinaryView* object, BNFunction* func)

{

BinaryDataNotification* notify = (BinaryDataNotification*)ctxt;

Ref<BinaryView> view = new BinaryView(BNNewViewReference(object));

Ref<Function> funcObj = new Function(BNNewFunctionReference(func));

notify->OnAnalysisFunctionUpdateRequested(view, funcObj);

}

void BinaryDataNotification::DataVariableAddedCallback(void* ctxt, BNBinaryView* object, BNDataVariable* var)

{

BinaryDataNotification* notify = (BinaryDataNotification*)ctxt;

Ref<BinaryView> view = new BinaryView(BNNewViewReference(object));

DataVariable varObj(var->address,

Confidence<Ref<Type>>(new Type(BNNewTypeReference(var->type)), var->typeConfidence), var->autoDiscovered);

notify->OnDataVariableAdded(view, varObj);

}

void BinaryDataNotification::DataVariableRemovedCallback(void* ctxt, BNBinaryView* object, BNDataVariable* var)

{

BinaryDataNotification* notify = (BinaryDataNotification*)ctxt;

Ref<BinaryView> view = new BinaryView(BNNewViewReference(object));

DataVariable varObj(var->address,

Confidence<Ref<Type>>(new Type(BNNewTypeReference(var->type)), var->typeConfidence), var->autoDiscovered);

notify->OnDataVariableRemoved(view, varObj);

}

void BinaryDataNotification::DataVariableUpdatedCallback(void* ctxt, BNBinaryView* object, BNDataVariable* var)

{

BinaryDataNotification* notify = (BinaryDataNotification*)ctxt;

Ref<BinaryView> view = new BinaryView(BNNewViewReference(object));

DataVariable varObj(var->address,

Confidence<Ref<Type>>(new Type(BNNewTypeReference(var->type)), var->typeConfidence), var->autoDiscovered);

notify->OnDataVariableUpdated(view, varObj);

}

void BinaryDataNotification::DataMetadataUpdatedCallback(void* ctxt, BNBinaryView* object, uint64_t offset)

{

BinaryDataNotification* notify = (BinaryDataNotification*)ctxt;

Ref<BinaryView> view = new BinaryView(BNNewViewReference(object));

notify->OnDataMetadataUpdated(view, offset);

}

void BinaryDataNotification::TagTypeUpdatedCallback(void* ctxt, BNBinaryView* object, BNTagType* tagType)

{

BinaryDataNotification* notify = (BinaryDataNotification*)ctxt;

Ref<BinaryView> view = new BinaryView(BNNewViewReference(object));

Ref<TagType> tagTypeRef = new TagType(BNNewTagTypeReference(tagType));

notify->OnTagTypeUpdated(view, tagTypeRef);

}

void BinaryDataNotification::TagAddedCallback(void* ctxt, BNBinaryView* object, BNTagReference* tagRef)

{

BinaryDataNotification* notify = (BinaryDataNotification*)ctxt;

Ref<BinaryView> view = new BinaryView(BNNewViewReference(object));

notify->OnTagAdded(view, TagReference(*tagRef));

}

void BinaryDataNotification::TagUpdatedCallback(void* ctxt, BNBinaryView* object, BNTagReference* tagRef)

{

BinaryDataNotification* notify = (BinaryDataNotification*)ctxt;

Ref<BinaryView> view = new BinaryView(BNNewViewReference(object));

notify->OnTagUpdated(view, TagReference(*tagRef));

}

void BinaryDataNotification::TagRemovedCallback(void* ctxt, BNBinaryView* object, BNTagReference* tagRef)

{

BinaryDataNotification* notify = (BinaryDataNotification*)ctxt;

Ref<BinaryView> view = new BinaryView(BNNewViewReference(object));

notify->OnTagRemoved(view, TagReference(*tagRef));

}

void BinaryDataNotification::SymbolAddedCallback(void* ctxt, BNBinaryView* object, BNSymbol* symobj)

{

BinaryDataNotification* notify = (BinaryDataNotification*)ctxt;

Ref<BinaryView> view = new BinaryView(BNNewViewReference(object));

Ref<Symbol> sym = new Symbol(BNNewSymbolReference(symobj));

notify->OnSymbolAdded(view, sym);

}

void BinaryDataNotification::SymbolUpdatedCallback(void* ctxt, BNBinaryView* object, BNSymbol* symobj)

{

BinaryDataNotification* notify = (BinaryDataNotification*)ctxt;

Ref<BinaryView> view = new BinaryView(BNNewViewReference(object));

Ref<Symbol> sym = new Symbol(BNNewSymbolReference(symobj));

notify->OnSymbolUpdated(view, sym);

}

void BinaryDataNotification::SymbolRemovedCallback(void* ctxt, BNBinaryView* object, BNSymbol* symobj)

{

BinaryDataNotification* notify = (BinaryDataNotification*)ctxt;

Ref<BinaryView> view = new BinaryView(BNNewViewReference(object));

Ref<Symbol> sym = new Symbol(BNNewSymbolReference(symobj));

notify->OnSymbolRemoved(view, sym);

}

void BinaryDataNotification::StringFoundCallback(

void* ctxt, BNBinaryView* object, BNStringType type, uint64_t offset, size_t len)

{

BinaryDataNotification* notify = (BinaryDataNotification*)ctxt;

Ref<BinaryView> view = new BinaryView(BNNewViewReference(object));

notify->OnStringFound(view, type, offset, len);

}

void BinaryDataNotification::StringRemovedCallback(

void* ctxt, BNBinaryView* object, BNStringType type, uint64_t offset, size_t len)

{

BinaryDataNotification* notify = (BinaryDataNotification*)ctxt;

Ref<BinaryView> view = new BinaryView(BNNewViewReference(object));

notify->OnStringRemoved(view, type, offset, len);

}

void BinaryDataNotification::DerivedStringFoundCallback(void* ctxt, BNBinaryView* data, BNDerivedString* str)

{

BinaryDataNotification* notify = (BinaryDataNotification*)ctxt;

Ref<BinaryView> view = new BinaryView(BNNewViewReference(data));

notify->OnDerivedStringFound(view, DerivedString::FromAPIObject(str, false));

}

void BinaryDataNotification::DerivedStringRemovedCallback(void* ctxt, BNBinaryView* data, BNDerivedString* str)

{

BinaryDataNotification* notify = (BinaryDataNotification*)ctxt;

Ref<BinaryView> view = new BinaryView(BNNewViewReference(data));

notify->OnDerivedStringRemoved(view, DerivedString::FromAPIObject(str, false));

}

void BinaryDataNotification::TypeDefinedCallback(void* ctxt, BNBinaryView* data, BNQualifiedName* name, BNType* type)

{

BinaryDataNotification* notify = (BinaryDataNotification*)ctxt;

Ref<BinaryView> view = new BinaryView(BNNewViewReference(data));

Ref<Type> typeObj = new Type(BNNewTypeReference(type));

notify->OnTypeDefined(view, QualifiedName::FromAPIObject(name), typeObj);

}

void BinaryDataNotification::TypeUndefinedCallback(void* ctxt, BNBinaryView* data, BNQualifiedName* name, BNType* type)

{

BinaryDataNotification* notify = (BinaryDataNotification*)ctxt;

Ref<BinaryView> view = new BinaryView(BNNewViewReference(data));

Ref<Type> typeObj = new Type(BNNewTypeReference(type));

notify->OnTypeUndefined(view, QualifiedName::FromAPIObject(name), typeObj);

}

void BinaryDataNotification::TypeReferenceChangedCallback(

void* ctxt, BNBinaryView* data, BNQualifiedName* name, BNType* type)

{

BinaryDataNotification* notify = (BinaryDataNotification*)ctxt;

Ref<BinaryView> view = new BinaryView(BNNewViewReference(data));

Ref<Type> typeObj = new Type(BNNewTypeReference(type));

notify->OnTypeReferenceChanged(view, QualifiedName::FromAPIObject(name), typeObj);

}

void BinaryDataNotification::TypeFieldReferenceChangedCallback(

void* ctxt, BNBinaryView* data, BNQualifiedName* name, uint64_t offset)

{

BinaryDataNotification* notify = (BinaryDataNotification*)ctxt;

Ref<BinaryView> view = new BinaryView(BNNewViewReference(data));

notify->OnTypeFieldReferenceChanged(view, QualifiedName::FromAPIObject(name), offset);

}

void BinaryDataNotification::SegmentAddedCallback(void* ctxt, BNBinaryView* data, BNSegment* segment)

{

BinaryDataNotification* notify = (BinaryDataNotification*)ctxt;

Ref<BinaryView> view = new BinaryView(BNNewViewReference(data));

Ref<Segment> segmentObj = new Segment(BNNewSegmentReference(segment));

notify->OnSegmentAdded(view, segmentObj);

}

void BinaryDataNotification::SegmentUpdatedCallback(void* ctxt, BNBinaryView* data, BNSegment* segment)

{

BinaryDataNotification* notify = (BinaryDataNotification*)ctxt;

Ref<BinaryView> view = new BinaryView(BNNewViewReference(data));

Ref<Segment> segmentObj = new Segment(BNNewSegmentReference(segment));

notify->OnSegmentUpdated(view, segmentObj);

}

void BinaryDataNotification::SegmentRemovedCallback(void* ctxt, BNBinaryView* data, BNSegment* segment)

{

BinaryDataNotification* notify = (BinaryDataNotification*)ctxt;

Ref<BinaryView> view = new BinaryView(BNNewViewReference(data));

Ref<Segment> segmentObj = new Segment(BNNewSegmentReference(segment));

notify->OnSegmentRemoved(view, segmentObj);

}

void BinaryDataNotification::SectionAddedCallback(void* ctxt, BNBinaryView* data, BNSection* section)

{

BinaryDataNotification* notify = (BinaryDataNotification*)ctxt;

Ref<BinaryView> view = new BinaryView(BNNewViewReference(data));

Ref<Section> sectionObj = new Section(BNNewSectionReference(section));

notify->OnSectionAdded(view, sectionObj);

}

void BinaryDataNotification::SectionUpdatedCallback(void* ctxt, BNBinaryView* data, BNSection* section)

{

BinaryDataNotification* notify = (BinaryDataNotification*)ctxt;

Ref<BinaryView> view = new BinaryView(BNNewViewReference(data));

Ref<Section> sectionObj = new Section(BNNewSectionReference(section));

notify->OnSectionUpdated(view, sectionObj);

}

void BinaryDataNotification::SectionRemovedCallback(void* ctxt, BNBinaryView* data, BNSection* section)

{

BinaryDataNotification* notify = (BinaryDataNotification*)ctxt;

Ref<BinaryView> view = new BinaryView(BNNewViewReference(data));

Ref<Section> sectionObj = new Section(BNNewSectionReference(section));

notify->OnSectionRemoved(view, sectionObj);

}

void BinaryDataNotification::ComponentNameUpdatedCallback(void* ctxt, BNBinaryView* data, char *previousName, BNComponent* bnComponent)

{

BinaryDataNotification* notify = (BinaryDataNotification*)ctxt;

Ref<BinaryView> view = new BinaryView(BNNewViewReference(data));

Ref<Component> component = new Component(BNNewComponentReference(bnComponent));

std::string prevName = previousName;

BNFreeString(previousName);

notify->OnComponentNameUpdated(view, prevName, component);

}

void BinaryDataNotification::ComponentAddedCallback(void* ctxt, BNBinaryView* data, BNComponent* bnComponent)

{

BinaryDataNotification* notify = (BinaryDataNotification*)ctxt;

Ref<BinaryView> view = new BinaryView(BNNewViewReference(data));

Ref<Component> component = new Component(BNNewComponentReference(bnComponent));

notify->OnComponentAdded(view, component);

}

void BinaryDataNotification::ComponentRemovedCallback(void* ctxt, BNBinaryView* data, BNComponent* bnFormerParent,

BNComponent* bnComponent)

{

BinaryDataNotification* notify = (BinaryDataNotification*)ctxt;

Ref<BinaryView> view = new BinaryView(BNNewViewReference(data));

Ref<Component> formerParent = new Component(BNNewComponentReference(bnFormerParent));

Ref<Component> component = new Component(BNNewComponentReference(bnComponent));

notify->OnComponentRemoved(view, formerParent, component);

}

void BinaryDataNotification::ComponentMovedCallback(void* ctxt, BNBinaryView* data, BNComponent* bnFormerParent,

BNComponent* bnNewParent, BNComponent* bnComponent)

{

BinaryDataNotification* notify = (BinaryDataNotification*)ctxt;

Ref<BinaryView> view = new BinaryView(BNNewViewReference(data));

Ref<Component> formerParent = new Component(BNNewComponentReference(bnFormerParent));

Ref<Component> newParent = new Component(BNNewComponentReference(bnNewParent));

Ref<Component> component = new Component(BNNewComponentReference(bnComponent));

notify->OnComponentMoved(view, formerParent, newParent, component);

}

void BinaryDataNotification::ComponentFunctionAddedCallback(void* ctxt, BNBinaryView* data, BNComponent* bnComponent,

BNFunction* func)

{

BinaryDataNotification* notify = (BinaryDataNotification*)ctxt;

Ref<BinaryView> view = new BinaryView(BNNewViewReference(data));

Ref<Component> component = new Component(BNNewComponentReference(bnComponent));

Ref<Function> function = new Function(BNNewFunctionReference(func));

notify->OnComponentFunctionAdded(view, component, function);

}

void BinaryDataNotification::ComponentFunctionRemovedCallback(void* ctxt, BNBinaryView* data, BNComponent* bnComponent,

BNFunction* func)

{

BinaryDataNotification* notify = (BinaryDataNotification*)ctxt;

Ref<BinaryView> view = new BinaryView(BNNewViewReference(data));

Ref<Component> component = new Component(BNNewComponentReference(bnComponent));

Ref<Function> function = new Function(BNNewFunctionReference(func));

notify->OnComponentFunctionRemoved(view, component, function);

}

void BinaryDataNotification::ComponentDataVariableAddedCallback(void* ctxt, BNBinaryView* data, BNComponent* bnComponent,

BNDataVariable* var)

{

BinaryDataNotification* notify = (BinaryDataNotification*)ctxt;

Ref<BinaryView> view = new BinaryView(BNNewViewReference(data));

Ref<Component> component = new Component(BNNewComponentReference(bnComponent));

DataVariable varObj(var->address,

Confidence<Ref<Type>>(new Type(BNNewTypeReference(var->type)), var->typeConfidence), var->autoDiscovered);

notify->OnComponentDataVariableAdded(view, component, varObj);

}

void BinaryDataNotification::ComponentDataVariableRemovedCallback(void* ctxt, BNBinaryView* data,

BNComponent* bnComponent, BNDataVariable* var)

{

BinaryDataNotification* notify = (BinaryDataNotification*)ctxt;

Ref<BinaryView> view = new BinaryView(BNNewViewReference(data));

Ref<Component> component = new Component(BNNewComponentReference(bnComponent));

DataVariable varObj(var->address,

Confidence<Ref<Type>>(new Type(BNNewTypeReference(var->type)), var->typeConfidence), var->autoDiscovered);

notify->OnComponentDataVariableRemoved(view, component, varObj);

}

void BinaryDataNotification::ExternalLibraryAddedCallback(void* ctxt, BNBinaryView* data, BNExternalLibrary* library)

{

BinaryDataNotification* notify = (BinaryDataNotification*)ctxt;

Ref<BinaryView> view = new BinaryView(BNNewViewReference(data));

Ref<ExternalLibrary> libraryObj = new ExternalLibrary(BNNewExternalLibraryReference(library));

notify->OnExternalLibraryAdded(view, libraryObj);

}

void BinaryDataNotification::ExternalLibraryUpdatedCallback(void* ctxt, BNBinaryView* data, BNExternalLibrary* library)

{

BinaryDataNotification* notify = (BinaryDataNotification*)ctxt;

Ref<BinaryView> view = new BinaryView(BNNewViewReference(data));

Ref<ExternalLibrary> libraryObj = new ExternalLibrary(BNNewExternalLibraryReference(library));

notify->OnExternalLibraryUpdated(view, libraryObj);

}

void BinaryDataNotification::ExternalLibraryRemovedCallback(void* ctxt, BNBinaryView* data, BNExternalLibrary* library)

{

BinaryDataNotification* notify = (BinaryDataNotification*)ctxt;

Ref<BinaryView> view = new BinaryView(BNNewViewReference(data));

Ref<ExternalLibrary> libraryObj = new ExternalLibrary(BNNewExternalLibraryReference(library));

notify->OnExternalLibraryRemoved(view, libraryObj);

}

void BinaryDataNotification::ExternalLocationAddedCallback(void* ctxt, BNBinaryView* data, BNExternalLocation* location)

{

BinaryDataNotification* notify = (BinaryDataNotification*)ctxt;

Ref<BinaryView> view = new BinaryView(BNNewViewReference(data));

Ref<ExternalLocation> locationObj = new ExternalLocation(BNNewExternalLocationReference(location));

notify->OnExternalLocationAdded(view, locationObj);

}

void BinaryDataNotification::ExternalLocationUpdatedCallback(void* ctxt, BNBinaryView* data, BNExternalLocation* location)

{

BinaryDataNotification* notify = (BinaryDataNotification*)ctxt;

Ref<BinaryView> view = new BinaryView(BNNewViewReference(data));

Ref<ExternalLocation> locationObj = new ExternalLocation(BNNewExternalLocationReference(location));

notify->OnExternalLocationUpdated(view, locationObj);

}

void BinaryDataNotification::ExternalLocationRemovedCallback(void* ctxt, BNBinaryView* data, BNExternalLocation* location)

{

BinaryDataNotification* notify = (BinaryDataNotification*)ctxt;

Ref<BinaryView> view = new BinaryView(BNNewViewReference(data));

Ref<ExternalLocation> locationObj = new ExternalLocation(BNNewExternalLocationReference(location));

notify->OnExternalLocationRemoved(view, locationObj);

}

void BinaryDataNotification::TypeArchiveAttachedCallback(void* ctxt, BNBinaryView* data, const char* id, const char* path)

{

BinaryDataNotification* notify = (BinaryDataNotification*)ctxt;

Ref<BinaryView> view = new BinaryView(BNNewViewReference(data));

notify->OnTypeArchiveAttached(view, id, path);

}

void BinaryDataNotification::TypeArchiveDetachedCallback(void* ctxt, BNBinaryView* data, const char* id, const char* path)

{

BinaryDataNotification* notify = (BinaryDataNotification*)ctxt;

Ref<BinaryView> view = new BinaryView(BNNewViewReference(data));

notify->OnTypeArchiveDetached(view, id, path);

}

void BinaryDataNotification::TypeArchiveConnectedCallback(void* ctxt, BNBinaryView* data, BNTypeArchive* archive)

{

BinaryDataNotification* notify = (BinaryDataNotification*)ctxt;

Ref<BinaryView> view = new BinaryView(BNNewViewReference(data));

Ref<TypeArchive> apiArchive = new TypeArchive(BNNewTypeArchiveReference(archive));

notify->OnTypeArchiveConnected(view, apiArchive);

}

void BinaryDataNotification::TypeArchiveDisconnectedCallback(void* ctxt, BNBinaryView* data, BNTypeArchive* archive)

{

BinaryDataNotification* notify = (BinaryDataNotification*)ctxt;

Ref<BinaryView> view = new BinaryView(BNNewViewReference(data));

Ref<TypeArchive> apiArchive = new TypeArchive(BNNewTypeArchiveReference(archive));

notify->OnTypeArchiveDisconnected(view, apiArchive);

}

void BinaryDataNotification::UndoEntryAddedCallback(void* ctxt, BNBinaryView* data, BNUndoEntry* entry)

{

BinaryDataNotification* notify = (BinaryDataNotification*)ctxt;

Ref<BinaryView> view = new BinaryView(BNNewViewReference(data));

Ref<UndoEntry> apiEntry = new UndoEntry(BNNewUndoEntryReference(entry));

notify->OnUndoEntryAdded(view, apiEntry);

}

void BinaryDataNotification::UndoEntryTakenCallback(void* ctxt, BNBinaryView* data, BNUndoEntry* entry)

{

BinaryDataNotification* notify = (BinaryDataNotification*)ctxt;

Ref<BinaryView> view = new BinaryView(BNNewViewReference(data));

Ref<UndoEntry> apiEntry = new UndoEntry(BNNewUndoEntryReference(entry));

notify->OnUndoEntryTaken(view, apiEntry);

}

void BinaryDataNotification::RedoEntryTakenCallback(void* ctxt, BNBinaryView* data, BNUndoEntry* entry)

{

BinaryDataNotification* notify = (BinaryDataNotification*)ctxt;

Ref<BinaryView> view = new BinaryView(BNNewViewReference(data));

Ref<UndoEntry> apiEntry = new UndoEntry(BNNewUndoEntryReference(entry));

notify->OnRedoEntryTaken(view, apiEntry);

}

void BinaryDataNotification::RebasedCallback(void *ctxt, BNBinaryView *oldView, BNBinaryView *newView)

{

BinaryDataNotification* notify = (BinaryDataNotification*)ctxt;

Ref<BinaryView> view1 = new BinaryView(BNNewViewReference(oldView));

Ref<BinaryView> view2 = new BinaryView(BNNewViewReference(newView));

notify->OnRebased(view1, view2);

}

BinaryDataNotification::BinaryDataNotification()

{

m_callbacks.context = this;

m_callbacks.notificationBarrier = nullptr;

m_callbacks.dataWritten = DataWrittenCallback;

m_callbacks.dataInserted = DataInsertedCallback;

m_callbacks.dataRemoved = DataRemovedCallback;

m_callbacks.functionAdded = FunctionAddedCallback;

m_callbacks.functionRemoved = FunctionRemovedCallback;

m_callbacks.functionUpdated = FunctionUpdatedCallback;

m_callbacks.functionUpdateRequested = FunctionUpdateRequestedCallback;

m_callbacks.dataVariableAdded = DataVariableAddedCallback;

m_callbacks.dataVariableRemoved = DataVariableRemovedCallback;

m_callbacks.dataVariableUpdated = DataVariableUpdatedCallback;

m_callbacks.dataMetadataUpdated = DataMetadataUpdatedCallback;

m_callbacks.tagTypeUpdated = TagTypeUpdatedCallback;

m_callbacks.tagAdded = TagAddedCallback;

m_callbacks.tagUpdated = TagUpdatedCallback;

m_callbacks.tagRemoved = TagRemovedCallback;

m_callbacks.symbolAdded = SymbolAddedCallback;

m_callbacks.symbolUpdated = SymbolUpdatedCallback;

m_callbacks.symbolRemoved = SymbolRemovedCallback;

m_callbacks.stringFound = StringFoundCallback;

m_callbacks.stringRemoved = StringRemovedCallback;

m_callbacks.derivedStringFound = DerivedStringFoundCallback;

m_callbacks.derivedStringRemoved = DerivedStringRemovedCallback;

m_callbacks.typeDefined = TypeDefinedCallback;

m_callbacks.typeUndefined = TypeUndefinedCallback;

m_callbacks.typeReferenceChanged = TypeReferenceChangedCallback;

m_callbacks.typeFieldReferenceChanged = TypeFieldReferenceChangedCallback;

m_callbacks.segmentAdded = SegmentAddedCallback;

m_callbacks.segmentUpdated = SegmentUpdatedCallback;

m_callbacks.segmentRemoved = SegmentRemovedCallback;

m_callbacks.sectionAdded = SectionAddedCallback;

m_callbacks.sectionUpdated = SectionUpdatedCallback;

m_callbacks.sectionRemoved = SectionRemovedCallback;

m_callbacks.componentNameUpdated = ComponentNameUpdatedCallback;

m_callbacks.componentAdded = ComponentAddedCallback;

m_callbacks.componentRemoved = ComponentRemovedCallback;

m_callbacks.componentMoved = ComponentMovedCallback;

m_callbacks.componentFunctionAdded = ComponentFunctionAddedCallback;

m_callbacks.componentFunctionRemoved = ComponentFunctionRemovedCallback;

m_callbacks.componentDataVariableAdded = ComponentDataVariableAddedCallback;

m_callbacks.componentDataVariableRemoved = ComponentDataVariableRemovedCallback;

m_callbacks.externalLibraryAdded = ExternalLibraryAddedCallback;

m_callbacks.externalLibraryUpdated = ExternalLibraryUpdatedCallback;

m_callbacks.externalLibraryRemoved = ExternalLibraryRemovedCallback;

m_callbacks.externalLocationAdded = ExternalLocationAddedCallback;

m_callbacks.externalLocationUpdated = ExternalLocationUpdatedCallback;

m_callbacks.externalLocationRemoved = ExternalLocationRemovedCallback;

m_callbacks.typeArchiveAttached = TypeArchiveAttachedCallback;

m_callbacks.typeArchiveDetached = TypeArchiveDetachedCallback;

m_callbacks.typeArchiveConnected = TypeArchiveConnectedCallback;

m_callbacks.typeArchiveDisconnected = TypeArchiveDisconnectedCallback;

m_callbacks.undoEntryAdded = UndoEntryAddedCallback;

m_callbacks.undoEntryTaken = UndoEntryTakenCallback;

m_callbacks.redoEntryTaken = RedoEntryTakenCallback;

m_callbacks.rebased = RebasedCallback;

}

BinaryDataNotification::BinaryDataNotification(NotificationTypes notifications)

{

m_callbacks.context = this;

m_callbacks.notificationBarrier = (notifications & NotificationType::NotificationBarrier) ? NotificationBarrierCallback : nullptr;

m_callbacks.dataWritten = (notifications & NotificationType::DataWritten) ? DataWrittenCallback : nullptr;

m_callbacks.dataInserted = (notifications & NotificationType::DataInserted) ? DataInsertedCallback : nullptr;

m_callbacks.dataRemoved = (notifications & NotificationType::DataRemoved) ? DataRemovedCallback : nullptr;

m_callbacks.functionAdded = (notifications & NotificationType::FunctionAdded) ? FunctionAddedCallback : nullptr;

m_callbacks.functionRemoved = (notifications & NotificationType::FunctionRemoved) ? FunctionRemovedCallback : nullptr;

m_callbacks.functionUpdated = (notifications & NotificationType::FunctionUpdated) ? FunctionUpdatedCallback : nullptr;

m_callbacks.functionUpdateRequested = (notifications & NotificationType::FunctionUpdateRequested) ? FunctionUpdateRequestedCallback : nullptr;

m_callbacks.dataVariableAdded = (notifications & NotificationType::DataVariableAdded) ? DataVariableAddedCallback : nullptr;

m_callbacks.dataVariableRemoved = (notifications & NotificationType::DataVariableRemoved) ? DataVariableRemovedCallback : nullptr;

m_callbacks.dataVariableUpdated = (notifications & NotificationType::DataVariableUpdated) ? DataVariableUpdatedCallback : nullptr;

m_callbacks.dataMetadataUpdated = (notifications & NotificationType::DataMetadataUpdated) ? DataMetadataUpdatedCallback : nullptr;

m_callbacks.tagTypeUpdated = (notifications & NotificationType::TagTypeUpdated) ? TagTypeUpdatedCallback : nullptr;

m_callbacks.tagAdded = (notifications & NotificationType::TagAdded) ? TagAddedCallback : nullptr;

m_callbacks.tagUpdated = (notifications & NotificationType::TagUpdated) ? TagUpdatedCallback : nullptr;

m_callbacks.tagRemoved = (notifications & NotificationType::TagRemoved) ? TagRemovedCallback : nullptr;

m_callbacks.symbolAdded = (notifications & NotificationType::SymbolAdded) ? SymbolAddedCallback : nullptr;

m_callbacks.symbolUpdated = (notifications & NotificationType::SymbolUpdated) ? SymbolUpdatedCallback : nullptr;

m_callbacks.symbolRemoved = (notifications & NotificationType::SymbolRemoved) ? SymbolRemovedCallback : nullptr;

m_callbacks.stringFound = (notifications & NotificationType::StringFound) ? StringFoundCallback : nullptr;

m_callbacks.stringRemoved = (notifications & NotificationType::StringRemoved) ? StringRemovedCallback : nullptr;

m_callbacks.derivedStringFound = (notifications & NotificationType::DerivedStringFound) ? DerivedStringFoundCallback : nullptr;

m_callbacks.derivedStringRemoved = (notifications & NotificationType::DerivedStringRemoved) ? DerivedStringRemovedCallback : nullptr;

m_callbacks.typeDefined = (notifications & NotificationType::TypeDefined) ? TypeDefinedCallback : nullptr;

m_callbacks.typeUndefined = (notifications & NotificationType::TypeUndefined) ? TypeUndefinedCallback : nullptr;

m_callbacks.typeReferenceChanged = (notifications & NotificationType::TypeReferenceChanged) ? TypeReferenceChangedCallback : nullptr;

m_callbacks.typeFieldReferenceChanged = (notifications & NotificationType::TypeFieldReferenceChanged) ? TypeFieldReferenceChangedCallback : nullptr;

m_callbacks.segmentAdded = (notifications & NotificationType::SegmentAdded) ? SegmentAddedCallback : nullptr;

m_callbacks.segmentUpdated = (notifications & NotificationType::SegmentUpdated) ? SegmentUpdatedCallback : nullptr;

m_callbacks.segmentRemoved = (notifications & NotificationType::SegmentRemoved) ? SegmentRemovedCallback : nullptr;

m_callbacks.sectionAdded = (notifications & NotificationType::SectionAdded) ? SectionAddedCallback : nullptr;

m_callbacks.sectionUpdated = (notifications & NotificationType::SectionUpdated) ? SectionUpdatedCallback : nullptr;

m_callbacks.sectionRemoved = (notifications & NotificationType::SectionRemoved) ? SectionRemovedCallback : nullptr;

m_callbacks.componentNameUpdated = (notifications & NotificationType::ComponentNameUpdated) ? ComponentNameUpdatedCallback : nullptr;

m_callbacks.componentAdded = (notifications & NotificationType::ComponentAdded) ? ComponentAddedCallback : nullptr;

m_callbacks.componentRemoved = (notifications & NotificationType::ComponentRemoved) ? ComponentRemovedCallback : nullptr;

m_callbacks.componentMoved = (notifications & NotificationType::ComponentMoved) ? ComponentMovedCallback : nullptr;

m_callbacks.componentFunctionAdded = (notifications & NotificationType::ComponentFunctionAdded) ? ComponentFunctionAddedCallback : nullptr;

m_callbacks.componentFunctionRemoved = (notifications & NotificationType::ComponentFunctionRemoved) ? ComponentFunctionRemovedCallback : nullptr;

m_callbacks.componentDataVariableAdded = (notifications & NotificationType::ComponentDataVariableAdded) ? ComponentDataVariableAddedCallback : nullptr;

m_callbacks.componentDataVariableRemoved = (notifications & NotificationType::ComponentDataVariableRemoved) ? ComponentDataVariableRemovedCallback : nullptr;

m_callbacks.externalLibraryAdded = (notifications & NotificationType::ExternalLibraryAdded) ? ExternalLibraryAddedCallback : nullptr;

m_callbacks.externalLibraryUpdated = (notifications & NotificationType::ExternalLibraryUpdated) ? ExternalLibraryUpdatedCallback : nullptr;

m_callbacks.externalLibraryRemoved = (notifications & NotificationType::ExternalLibraryRemoved) ? ExternalLibraryRemovedCallback : nullptr;

m_callbacks.externalLocationAdded = (notifications & NotificationType::ExternalLocationAdded) ? ExternalLocationAddedCallback : nullptr;

m_callbacks.externalLocationUpdated = (notifications & NotificationType::ExternalLocationUpdated) ? ExternalLocationUpdatedCallback : nullptr;

m_callbacks.externalLocationRemoved = (notifications & NotificationType::ExternalLocationRemoved) ? ExternalLocationRemovedCallback : nullptr;

m_callbacks.typeArchiveAttached = (notifications & NotificationType::TypeArchiveAttached) ? TypeArchiveAttachedCallback : nullptr;

m_callbacks.typeArchiveDetached = (notifications & NotificationType::TypeArchiveDetached) ? TypeArchiveDetachedCallback : nullptr;

m_callbacks.typeArchiveConnected = (notifications & NotificationType::TypeArchiveConnected) ? TypeArchiveConnectedCallback : nullptr;

m_callbacks.typeArchiveDisconnected = (notifications & NotificationType::TypeArchiveDisconnected) ? TypeArchiveDisconnectedCallback : nullptr;

m_callbacks.undoEntryAdded = (notifications & NotificationType::UndoEntryAdded) ? UndoEntryAddedCallback : nullptr;

m_callbacks.undoEntryTaken = (notifications & NotificationType::UndoEntryTaken) ? UndoEntryTakenCallback : nullptr;

m_callbacks.redoEntryTaken = (notifications & NotificationType::RedoEntryTaken) ? RedoEntryTakenCallback : nullptr;

m_callbacks.rebased = (notifications & NotificationType::Rebased) ? RebasedCallback : nullptr;

}

StringRef::StringRef()

{

m_ref = nullptr;

}

StringRef::StringRef(BNStringRef* ref)

{

m_ref = ref;

}

StringRef::StringRef(const std::string& str)

{

m_ref = BNCreateStringRefOfLength(str.c_str(), str.size());

}

StringRef::StringRef(const StringRef& other)

{

m_ref = other.m_ref ? BNDuplicateStringRef(other.m_ref) : nullptr;

}

StringRef::StringRef(StringRef&& other)

{

m_ref = other.m_ref;

other.m_ref = nullptr;

}

StringRef::~StringRef()

{

if (m_ref)

{

BNFreeStringRef(m_ref);

}

}

StringRef& StringRef::operator=(const StringRef& other)

{

if (m_ref)

{

BNFreeStringRef(m_ref);

m_ref = nullptr;

}

if (other.m_ref)

{

m_ref = BNDuplicateStringRef(other.m_ref);

}

return *this;

}

StringRef& StringRef::operator=(StringRef&& other)

{

if (m_ref)

{

BNFreeStringRef(m_ref);

}

m_ref = other.m_ref;

other.m_ref = nullptr;

return *this;

}

const char* StringRef::c_str() const

{

if (!m_ref)

return ""; // todo: nullptr?

return BNGetStringRefContents(m_ref);

}

size_t StringRef::size() const

{

if (!m_ref)

return 0;

return BNGetStringRefSize(m_ref);

}

Symbol::Symbol(BNSymbolType type, const string& shortName, const string& fullName, const string& rawName, uint64_t addr,

BNSymbolBinding binding, const NameSpace& nameSpace, uint64_t ordinal)

{

BNNameSpace ns = nameSpace.GetAPIObject();

m_object = BNCreateSymbol(type, shortName.c_str(), fullName.c_str(), rawName.c_str(), addr, binding, &ns, ordinal);

NameSpace::FreeAPIObject(&ns);

}

Symbol::Symbol(BNSymbolType type, const std::string& name, uint64_t addr, BNSymbolBinding binding,

const NameSpace& nameSpace, uint64_t ordinal)

{

BNNameSpace ns = nameSpace.GetAPIObject();

m_object = BNCreateSymbol(type, name.c_str(), name.c_str(), name.c_str(), addr, binding, &ns, ordinal);

NameSpace::FreeAPIObject(&ns);

}

Symbol::Symbol(BNSymbolType type, const string& shortName, const string& fullName, const string& rawName, uint64_t addr,

BNNameSpace* nameSpace, BNSymbolBinding binding, uint64_t ordinal)

{

m_object = BNCreateSymbol(type, shortName.c_str(), fullName.c_str(), rawName.c_str(), addr, binding, nameSpace, ordinal);

}

Symbol::Symbol(BNSymbolType type, const std::string& name, uint64_t addr, BNNameSpace* nameSpace, BNSymbolBinding binding, uint64_t ordinal)

{

m_object = BNCreateSymbol(type, name.c_str(), name.c_str(), name.c_str(), addr, binding, nameSpace, ordinal);

}

Symbol::Symbol(BNSymbol* sym)

{

m_object = sym;

}

BNSymbolType Symbol::GetType() const

{

return BNGetSymbolType(m_object);

}

BNSymbolBinding Symbol::GetBinding() const

{

return BNGetSymbolBinding(m_object);

}

NameSpace Symbol::GetNameSpace() const

{

BNNameSpace name = BNGetSymbolNameSpace(m_object);

NameSpace result = NameSpace::FromAPIObject(&name);

BNFreeNameSpace(&name);

return result;

}

string Symbol::GetShortName() const

{

char* name = BNGetSymbolShortName(m_object);

string result = name;

BNFreeString(name);

return result;

}

StringRef Symbol::GetShortNameRef() const

{

BNStringRef* name = BNGetSymbolShortNameRef(m_object);

return StringRef(name);

}

string Symbol::GetFullName() const

{

char* name = BNGetSymbolFullName(m_object);

string result = name;

BNFreeString(name);

return result;

}

StringRef Symbol::GetFullNameRef() const

{

BNStringRef* name = BNGetSymbolFullNameRef(m_object);

return StringRef(name);

}

string Symbol::GetRawName() const

{

char* name = BNGetSymbolRawName(m_object);

string result = name;

BNFreeString(name);

return result;

}

StringRef Symbol::GetRawNameRef() const

{

BNStringRef* name = BNGetSymbolRawNameRef(m_object);

return StringRef(name);

}

uint64_t Symbol::GetAddress() const

{

return BNGetSymbolAddress(m_object);

}

uint64_t Symbol::GetOrdinal() const

{

return BNGetSymbolOrdinal(m_object);

}

bool Symbol::IsAutoDefined() const

{

return BNIsSymbolAutoDefined(m_object);

}

Ref<Symbol> Symbol::ImportedFunctionFromImportAddressSymbol(Symbol* sym, uint64_t addr)

{

return new Symbol(BNImportedFunctionFromImportAddressSymbol(sym->GetObject(), addr));

}

AnalysisCompletionEvent::AnalysisCompletionEvent(BinaryView* view, const std::function<void()>& callback) :

m_callback(callback)

{

m_object = BNAddAnalysisCompletionEvent(view->GetObject(), this, CompletionCallback);

}

void AnalysisCompletionEvent::CompletionCallback(void* ctxt)

{

AnalysisCompletionEvent* event = (AnalysisCompletionEvent*)ctxt;

unique_lock<recursive_mutex> lock(event->m_mutex);

event->m_callback();

event->m_callback = []() {

};

}

void AnalysisCompletionEvent::Cancel()

{

unique_lock<recursive_mutex> lock(m_mutex);

m_callback = []() {

};

// This allows the API side to free the BinaryNinja::AnalysisCompletionEvent object

BNCancelAnalysisCompletionEvent(m_object);

}

TagType::TagType(BNTagType* tagType)

{

m_object = tagType;

}

TagType::TagType(BinaryView* view)

{

m_object = BNCreateTagType(view->GetObject());

}

TagType::TagType(BinaryView* view, const std::string& name, const std::string& icon, bool visible, TagType::Type type)

{

m_object = BNCreateTagType(view->GetObject());

SetName(name);

SetIcon(icon);

SetVisible(visible);

SetType(type);

}

BinaryView* TagType::GetView() const

{

return new BinaryView(BNTagTypeGetView(m_object));

}

std::string TagType::GetId() const

{

char* str = BNTagTypeGetId(m_object);

string result = str;

BNFreeString(str);

return result;

}

std::string TagType::GetName() const

{

char* str = BNTagTypeGetName(m_object);

string result = str;

BNFreeString(str);

return result;

}

void TagType::SetName(const std::string& name)

{

BNTagTypeSetName(m_object, name.c_str());

}

std::string TagType::GetIcon() const

{

char* str = BNTagTypeGetIcon(m_object);

string result = str;

BNFreeString(str);

return result;

}

void TagType::SetIcon(const std::string& icon)

{

BNTagTypeSetIcon(m_object, icon.c_str());

}

bool TagType::GetVisible() const

{

return BNTagTypeGetVisible(m_object);

}

void TagType::SetVisible(bool visible)

{

BNTagTypeSetVisible(m_object, visible);

}

TagType::Type TagType::GetType() const

{

return BNTagTypeGetType(m_object);

}

void TagType::SetType(TagType::Type type)

{