Trait binaryninja::binaryview::BinaryViewExt

[−]
pub trait BinaryViewExt: BinaryViewBase {

Show 101 methods    fn file(&self) -> Ref<FileMetadata> { ... }
    fn type_name(&self) -> BnString { ... }
    fn parent_view(&self) -> Result<Ref<BinaryView>> { ... }
    fn raw_view(&self) -> Result<Ref<BinaryView>> { ... }
    fn view_type(&self) -> BnString { ... }
    fn read_vec(&self, offset: u64, len: usize) -> Vec<u8> { ... }
    fn read_into_vec(&self, dest: &mut Vec<u8>, offset: u64, len: usize) -> usize { ... }
    fn notify_data_written(&self, offset: u64, len: usize) { ... }
    fn notify_data_inserted(&self, offset: u64, len: usize) { ... }
    fn notify_data_removed(&self, offset: u64, len: usize) { ... }
    fn offset_has_code_semantics(&self, offset: u64) -> bool { ... }
    fn offset_has_writable_semantics(&self, offset: u64) -> bool { ... }
    fn end(&self) -> u64 { ... }
    fn update_analysis_and_wait(&self) { ... }
    fn update_analysis(&self) { ... }
    fn default_arch(&self) -> Option<CoreArchitecture> { ... }
    fn set_default_arch<A: Architecture>(&self, arch: &A) { ... }
    fn default_platform(&self) -> Option<Ref<Platform>> { ... }
    fn set_default_platform(&self, plat: &Platform) { ... }
    fn instruction_len<A: Architecture>(
        &self,
        arch: &A,
        addr: u64
    ) -> Option<usize> { ... }
    fn symbol_by_address(&self, addr: u64) -> Result<Ref<Symbol>> { ... }
    fn symbol_by_raw_name<S: BnStrCompatible>(
        &self,
        raw_name: S
    ) -> Result<Ref<Symbol>> { ... }
    fn symbols(&self) -> Array<Symbol> { ... }
    fn symbols_by_name<S: BnStrCompatible>(&self, name: S) -> Array<Symbol> { ... }
    fn symbols_in_range(&self, range: Range<u64>) -> Array<Symbol> { ... }
    fn symbols_of_type(&self, ty: SymbolType) -> Array<Symbol> { ... }
    fn symbols_of_type_in_range(
        &self,
        ty: SymbolType,
        range: Range<u64>
    ) -> Array<Symbol> { ... }
    fn define_auto_symbol(&self, sym: &Symbol) { ... }
    fn define_auto_symbol_with_type<'a, T: Into<Option<&'a Type>>>(
        &self,
        sym: &Symbol,
        plat: &Platform,
        ty: T
    ) -> Result<Ref<Symbol>> { ... }
    fn undefine_auto_symbol(&self, sym: &Symbol) { ... }
    fn define_user_symbol(&self, sym: &Symbol) { ... }
    fn undefine_user_symbol(&self, sym: &Symbol) { ... }
    fn data_variables(&self) -> Array<DataVariable> { ... }
    fn define_auto_data_var(&self, dv: DataVariable) { ... }
    fn define_user_data_var(&self, dv: DataVariable) { ... }
    fn undefine_auto_data_var(&self, addr: u64) { ... }
    fn undefine_user_data_var(&self, addr: u64) { ... }
    fn define_auto_type<S: BnStrCompatible>(
        &self,
        name: S,
        source: S,
        type_obj: &Type
    ) -> QualifiedName { ... }
    fn define_user_type<S: BnStrCompatible>(&self, name: S, type_obj: &Type) { ... }
    fn define_auto_types<S: BnStrCompatible>(
        &self,
        names_sources_and_types: Vec<(S, S, &Type)>,
        progress: Option<Box<dyn Fn(usize, usize) -> Result<()>>>
    ) -> HashMap<String, QualifiedName> { ... }
    fn define_user_types<S: BnStrCompatible>(
        &self,
        names_and_types: Vec<(S, &Type)>,
        progress: Option<Box<dyn Fn(usize, usize) -> Result<()>>>
    ) { ... }
    fn undefine_auto_type<S: BnStrCompatible>(&self, id: S) { ... }
    fn undefine_user_type<S: BnStrCompatible>(&self, name: S) { ... }
    fn types(&self) -> Array<QualifiedNameAndType> { ... }
    fn dependency_sorted_types(&self) -> Array<QualifiedNameAndType> { ... }
    fn get_type_by_name<S: BnStrCompatible>(&self, name: S) -> Option<Ref<Type>> { ... }
    fn get_type_by_ref(&self, ref_: &NamedTypeReference) -> Option<Ref<Type>> { ... }
    fn get_type_by_id<S: BnStrCompatible>(&self, id: S) -> Option<Ref<Type>> { ... }
    fn get_type_name_by_id<S: BnStrCompatible>(
        &self,
        id: S
    ) -> Option<QualifiedName> { ... }
    fn get_type_id<S: BnStrCompatible>(&self, name: S) -> Option<BnString> { ... }
    fn is_type_auto_defined<S: BnStrCompatible>(&self, name: S) -> bool { ... }
    fn segments(&self) -> Array<Segment> { ... }
    fn segment_at(&self, addr: u64) -> Option<Segment> { ... }
    fn add_segment(&self, segment: SegmentBuilder) { ... }
    fn add_section<S: BnStrCompatible>(&self, section: SectionBuilder<S>) { ... }
    fn remove_auto_section<S: BnStrCompatible>(&self, name: S) { ... }
    fn remove_user_section<S: BnStrCompatible>(&self, name: S) { ... }
    fn section_by_name<S: BnStrCompatible>(&self, name: S) -> Result<Section> { ... }
    fn sections(&self) -> Array<Section> { ... }
    fn sections_at(&self, addr: u64) -> Array<Section> { ... }
    fn add_auto_function(
        &self,
        plat: &Platform,
        addr: u64
    ) -> Option<Ref<Function>> { ... }
    fn add_function_with_type(
        &self,
        plat: &Platform,
        addr: u64,
        auto_discovered: bool,
        func_type: Option<&Type>
    ) -> Option<Ref<Function>> { ... }
    fn add_entry_point(&self, plat: &Platform, addr: u64) { ... }
    fn create_user_function(
        &self,
        plat: &Platform,
        addr: u64
    ) -> Result<Ref<Function>> { ... }
    fn has_functions(&self) -> bool { ... }
    fn entry_point_function(&self) -> Result<Ref<Function>> { ... }
    fn functions(&self) -> Array<Function> { ... }
    fn functions_at(&self, addr: u64) -> Array<Function> { ... }
    fn functions_containing(&self, addr: u64) -> Array<Function> { ... }
    fn function_at(&self, platform: &Platform, addr: u64) -> Result<Ref<Function>> { ... }
    fn basic_blocks_containing(
        &self,
        addr: u64
    ) -> Array<BasicBlock<NativeBlock>> { ... }
    fn basic_blocks_starting_at(
        &self,
        addr: u64
    ) -> Array<BasicBlock<NativeBlock>> { ... }
    fn is_new_auto_function_analysis_suppressed(&self) -> bool { ... }
    fn set_new_auto_function_analysis_suppressed(&self, suppress: bool) { ... }
    fn read_buffer(&self, offset: u64, len: usize) -> Result<DataBuffer> { ... }
    fn debug_info(&self) -> Ref<DebugInfo> { ... }
    fn set_debug_info(&self, debug_info: &DebugInfo) { ... }
    fn apply_debug_info(&self, debug_info: &DebugInfo) { ... }
    fn show_graph_report<S: BnStrCompatible>(&self, raw_name: S, graph: FlowGraph) { ... }
    fn load_settings<S: BnStrCompatible>(
        &self,
        view_type_name: S
    ) -> Result<Ref<Settings>> { ... }
    fn set_load_settings<S: BnStrCompatible>(
        &self,
        view_type_name: S,
        settings: &Settings
    ) { ... }
    fn create_tag_type<N: BnStrCompatible, I: BnStrCompatible>(
        &self,
        name: N,
        icon: I
    ) -> Ref<TagType> { ... }
    fn remove_tag_type(&self, tag_type: &TagType) { ... }
    fn get_tag_type<S: BnStrCompatible>(&self, name: S) -> Option<Ref<TagType>> { ... }
    fn get_tag<S: BnStrCompatible>(&self, id: S) -> Option<Ref<Tag>> { ... }
    fn add_tag<S: BnStrCompatible>(
        &self,
        addr: u64,
        t: &TagType,
        data: S,
        user: bool
    ) { ... }
    fn remove_auto_data_tag(&self, addr: u64, tag: &Tag) { ... }
    fn remove_user_data_tag(&self, addr: u64, tag: &Tag) { ... }
    fn get_next_linear_disassembly_lines(
        &self,
        pos: &mut LinearViewCursor
    ) -> Array<LinearDisassemblyLine> { ... }
    fn get_previous_linear_disassembly_lines(
        &self,
        pos: &mut LinearViewCursor
    ) -> Array<LinearDisassemblyLine> { ... }
    fn query_metadata<S: BnStrCompatible>(&self, key: S) -> Option<Ref<Metadata>> { ... }
    fn get_metadata<T, S: BnStrCompatible>(&self, key: S) -> Option<Result<T>>
    where
        T: for<'a> TryFrom<&'a Metadata>,
    { ... }
    fn store_metadata<V, S: BnStrCompatible>(
        &self,
        key: S,
        value: V,
        is_auto: bool
    )
    where
        V: Into<Ref<Metadata>>,
    { ... }
    fn remove_metadata<S: BnStrCompatible>(&self, key: S) { ... }
    fn get_code_refs(&self, addr: u64) -> Array<CodeReference> { ... }
    fn get_code_refs_in_range(&self, range: Range<u64>) -> Array<CodeReference> { ... }
    fn get_data_refs(&self, addr: u64) -> Array<DataReference> { ... }
    fn get_data_refs_from(&self, addr: u64) -> Array<DataReference> { ... }
    fn get_data_refs_in_range(&self, range: Range<u64>) -> Array<DataReference> { ... }
    fn get_code_refs_for_type<B: BnStrCompatible>(
        &self,
        name: B
    ) -> Array<CodeReference> { ... }
    fn get_data_refs_for_type<B: BnStrCompatible>(
        &self,
        name: B
    ) -> Array<DataReference> { ... }

}

Provided Methods

Reads up to len bytes from address offset

Appends up to len bytes from address offset into dest

You likely would also like to call Self::define_user_symbol to bind this data variable with a name

fn add_entry_point(&self, plat: &Platform, addr: u64)

List of functions starting at addr

Creates a new TagType and adds it to the view.

Arguments
  • name - the name for the tag
  • icon - the icon (recommended 1 emoji or 2 chars) for the tag

Removes a TagType and all tags that use it

Get a tag type by its name.

Get a tag by its id.

Note this does not tell you anything about where it is used.

Creates and adds a tag to an address

User tag creations will be added to the undo buffer

removes a Tag object at a data address.

removes a Tag object at a data address. Since this removes a user tag, it will be added to the current undo buffer.

Retrieves a list of the next disassembly lines.

get_next_linear_disassembly_lines retrieves an Array over LinearDisassemblyLine objects for the next disassembly lines, and updates the LinearViewCursor passed in. This function can be called repeatedly to get more lines of linear disassembly.

Arguments
  • pos - Position to retrieve linear disassembly lines from

Retrieves a list of the previous disassembly lines.

get_previous_linear_disassembly_lines retrieves an Array over LinearDisassemblyLine objects for the previous disassembly lines, and updates the LinearViewCursor passed in. This function can be called repeatedly to get more lines of linear disassembly.

Arguments
  • pos - Position to retrieve linear disassembly lines relative to

Retrieves a list of CodeReferences pointing to a given address.

Retrieves a list of CodeReferences pointing into a given Range.

Retrieves a list of DataReferences pointing to a given address.

Retrieves a list of DataReferences originating from a given address.

Retrieves a list of DataReferences pointing into a given Range.

Retrieves a list of CodeReferences for locations in code that use a given named type.

TODO: It might be cleaner if this used an already allocated type from the core and used its name instead of this slightly-gross QualifiedName hack. Since the returned object doesn’t have any QualifiedName, I’m assuming the core does not alias the QualifiedName we pass to it and it is safe to destroy it on Drop, as in this function.

Retrieves a list of DataReferences instances of a given named type in data.

TODO: It might be cleaner if this used an already allocated type from the core and used its name instead of this slightly-gross QualifiedName hack. Since the returned object doesn’t have any QualifiedName, I’m assuming the core does not alias the QualifiedName we pass to it and it is safe to destroy it on Drop, as in this function.

Implementors