Module index

Module ida_netnode

Functions that provide the lowest level public interface to the database. Namely, we use Btree. To learn more about BTree:
https://en.wikipedia.org/wiki/B-tree
We do not use Btree directly. Instead, we have another layer built on the top of Btree. Here is a brief explanation of this layer.
An object called "netnode" is modeled on the top of Btree. Each netnode has a unique id: a 32-bit value (64-bit for ida64). Initially there is a trivial mapping of the linear addresses used in the program to netnodes (later this mapping may be modified using ea2node and node2ea functions; this is used for fast database rebasings). If we have additional information about an address (for example, a comment is attached to it), this information is stored in the corresponding netnode. See nalt.hpp to see how the kernel uses netnodes. Also, some netnodes have no corresponding linear address (however, they still have an id). They are used to store information not related to a particular address.
Each netnode _may_ have the following attributes:
  • a name: an arbitrary non-empty string, up to 255KB-1 bytes
  • a value: arbitrary sized object, max size is MAXSPECSIZE
  • altvals: a sparse array of 32-bit values. indexes in this array may be 8-bit or 32-bit values
  • supvals: an array of arbitrary sized objects. (size of each object is limited by MAXSPECSIZE) indexes in this array may be 8-bit or 32-bit values
  • charvals: a sparse array of 8-bit values. indexes in this array may be 8-bit or 32-bit values
  • hashvals: a hash (an associative array). indexes in this array are strings values are arbitrary sized (max size is MAXSPECSIZE)
Initially a new netnode contains no information at all so no disk space is used for it. As you add new information, the netnode grows.
All arrays that are attached to the netnode behave in the same manner. Initially:
  • all members of altvals/charvals array are zeroes
  • all members of supvals/hashvals array are undefined
If you need to store objects bigger that MAXSPECSIZE, please note that there are high-level functions to store arbitrary sized objects in supvals. See setblob/getblob and other blob-related functions.
You may use netnodes to store additional information about the program. Limitations on the use of netnodes are the following:
  • use netnodes only if you could not find a kernel service to store your type of information
  • do not create netnodes with valid identifier names. Use the "$ " prefix (or any other prefix with characters not allowed in the identifiers for the names of your netnodes. Although you will probably not destroy anything by accident, using already defined names for the names of your netnodes is still discouraged.
  • you may create as many netnodes as you want (creation of an unnamed netnode does not increase the size of the database). however, since each netnode has a number, creating too many netnodes could lead to the exhaustion of the netnode numbers (the numbering starts at 0xFF000000)
  • remember that netnodes are automatically saved to the disk by the kernel.
Advanced info:
In fact a netnode may contain up to 256 arrays of arbitrary sized objects (not only the 4 listed above). Each array has an 8-bit tag. Usually tags are represented by character constants. For example, altvals and supvals are simply 2 of 256 arrays, with the tags 'A' and 'S' respectively.

Global variables

var BADNODE
A number to represent a bad netnode reference.
var MAXNAMESIZE
Maximum length of a netnode name. WILL BE REMOVED IN THE FUTURE.
var MAXSPECSIZE
Maximum length of strings or objects stored in a supval array element.
var MAX_NODENAME_SIZE
Maximum length of a name. We permit names up to 32KB-1 bytes.
var NETMAP_IDX
NETMAP_IDX = 256
var NETMAP_STR
NETMAP_STR = 1024
var NETMAP_V8
NETMAP_V8 = 4096
var NETMAP_VAL
NETMAP_VAL = 512
var NETMAP_VAL_NDX
NETMAP_VAL_NDX = 8192
var NETMAP_X8
NETMAP_X8 = 2048
var SIZEOF_nodeidx_t
SIZEOF_nodeidx_t = 4
var atag
Array of altvals.
var htag
Array of hashvals.
var ltag
Links between netnodes.
var ntag
Name of netnode.
var stag
Array of supvals.
var vtag
Value of netnode.

Functions

def exist(*args) ‑> bool
exist(n) -> bool
n: netnode const &
def netnode_exist(*args) ‑> bool
netnode_exist(_name) -> bool
_name: char const *

Classes

class netnode (*args)
Proxy of C++ netnode class.
__init__(self, num=nodeidx_t(-1)) -> netnode
num: nodeidx_t
__init__(self, _name, namlen=0, do_create=False) -> netnode
_name: char const *
namlen: size_t
do_create: bool

Static methods

def exist(*args) ‑> bool
exist(_name) -> bool
Does the netnode with the specified name exist?
_name: (C++: const char *) char const *

Methods

def altdel(self, *args) ‑> bool
altdel(self, alt, tag=atag) -> bool
Delete all elements of altval array. This function may be applied to 32-bit and 8-bit altval arrays. This function deletes the whole altval array.
alt: nodeidx_t
tag: uchar
return: success
altdel(self) -> bool
def altdel_all(self, *args) ‑> bool
altdel_all(self, tag=atag) -> bool
Delete all elements of the specified altval array. This function may be applied to 32-bit and 8-bit altval arrays. This function deletes the whole altval array.
tag: (C++: uchar) tag of array
return: success
def altdel_ea(self, *args) ‑> bool
altdel_ea(self, ea, tag=atag) -> bool
ea: ea_t
tag: uchar
def altdel_idx8(self, *args) ‑> bool
altdel_idx8(self, alt, tag) -> bool
alt: uchar
tag: uchar
def altfirst(self, *args) ‑> nodeidx_t
altfirst(self, tag=atag) -> nodeidx_t
Get first existing element of altval array.
tag: (C++: uchar) tag of array
return: index of first existing element of altval array, BADNODE if altval
array is empty
def altfirst_idx8(self, *args) ‑> nodeidx_t
altfirst_idx8(self, tag) -> nodeidx_t
tag: uchar
def altlast(self, *args) ‑> nodeidx_t
altlast(self, tag=atag) -> nodeidx_t
Get last element of altval array.
tag: (C++: uchar) tag of array
return: index of last existing element of altval array, BADNODE if altval array
is empty
def altlast_idx8(self, *args) ‑> nodeidx_t
altlast_idx8(self, tag) -> nodeidx_t
tag: uchar
def altnext(self, *args) ‑> nodeidx_t
altnext(self, cur, tag=atag) -> nodeidx_t
Get next existing element of altval array.
cur: (C++: nodeidx_t) current index
tag: (C++: uchar) tag of array
return: index of the next existing element of altval array, BADNODE if no more
altval array elements exist
def altnext_idx8(self, *args) ‑> nodeidx_t
altnext_idx8(self, cur, tag) -> nodeidx_t
cur: uchar
tag: uchar
def altprev(self, *args) ‑> nodeidx_t
altprev(self, cur, tag=atag) -> nodeidx_t
Get previous existing element of altval array.
cur: (C++: nodeidx_t) current index
tag: (C++: uchar) tag of array
return: index of the previous existing element of altval array, BADNODE if no
more altval array elements exist
def altprev_idx8(self, *args) ‑> nodeidx_t
altprev_idx8(self, cur, tag) -> nodeidx_t
cur: uchar
tag: uchar
def altset(self, *args) ‑> bool
altset(self, alt, value, tag=atag) -> bool
Set value of altval array.
alt: (C++: nodeidx_t) index into array of altvals
value: (C++: nodeidx_t) new value of altval element
tag: (C++: uchar) tag of array
retval 1: ok
retval 0: failed, normally should not occur
def altset_ea(self, *args) ‑> bool
altset_ea(self, ea, value, tag=atag) -> bool
ea: ea_t
value: nodeidx_t
tag: uchar
def altset_idx8(self, *args) ‑> bool
altset_idx8(self, alt, val, tag) -> bool
alt: uchar
val: nodeidx_t
tag: uchar
def altshift(self, *args) ‑> size_t
altshift(self, _from, to, size, tag=atag) -> size_t
Shift the altval array elements. Moves the array elements at (from..from+size) to (to..to+size)
from: (C++: nodeidx_t)
to: (C++: nodeidx_t)
size: (C++: nodeidx_t)
tag: (C++: uchar)
return: number of shifted elements
def altval(self, *args) ‑> nodeidx_t
altval(self, alt, tag=atag) -> nodeidx_t
Get altval element of the specified array.
alt: (C++: nodeidx_t) index into array of altvals
tag: (C++: uchar) tag of array. may be omitted
return: value of altval element. nonexistent altval members are returned as
zeroes
def altval_ea(self, *args) ‑> nodeidx_t
altval_ea(self, ea, tag=atag) -> nodeidx_t
ea: ea_t
tag: uchar
def altval_idx8(self, *args) ‑> nodeidx_t
altval_idx8(self, alt, tag) -> nodeidx_t
alt: uchar
tag: uchar
def blobshift(self, *args) ‑> size_t
blobshift(self, _from, to, size, tag) -> size_t
Shift the blob array elements. Moves the array elements at (from..from+size) to (to..to+size)
from: (C++: nodeidx_t)
to: (C++: nodeidx_t)
size: (C++: nodeidx_t)
tag: (C++: uchar)
return: number of shifted elements
def blobsize(self, *args) ‑> size_t
blobsize(self, _start, tag) -> size_t
Get size of blob.
_start: (C++: nodeidx_t) index of the first supval element used to store blob
tag: (C++: uchar) tag of supval array
return: number of bytes required to store a blob
def blobsize_ea(self, *args) ‑> size_t
blobsize_ea(self, ea, tag) -> size_t
ea: ea_t
tag: uchar
def chardel(self, *args) ‑> bool
chardel(self, alt, tag) -> bool
alt: nodeidx_t
tag: uchar
def chardel_ea(self, *args) ‑> bool
chardel_ea(self, ea, tag) -> bool
ea: ea_t
tag: uchar
def chardel_idx8(self, *args) ‑> bool
chardel_idx8(self, alt, tag) -> bool
alt: uchar
tag: uchar
def charfirst(self, *args) ‑> nodeidx_t
charfirst(self, tag) -> nodeidx_t
tag: uchar
def charfirst_idx8(self, *args) ‑> nodeidx_t
charfirst_idx8(self, tag) -> nodeidx_t
tag: uchar
def charlast(self, *args) ‑> nodeidx_t
charlast(self, tag) -> nodeidx_t
tag: uchar
def charlast_idx8(self, *args) ‑> nodeidx_t
charlast_idx8(self, tag) -> nodeidx_t
tag: uchar
def charnext(self, *args) ‑> nodeidx_t
charnext(self, cur, tag) -> nodeidx_t
cur: nodeidx_t
tag: uchar
def charnext_idx8(self, *args) ‑> nodeidx_t
charnext_idx8(self, cur, tag) -> nodeidx_t
cur: uchar
tag: uchar
def charprev(self, *args) ‑> nodeidx_t
charprev(self, cur, tag) -> nodeidx_t
cur: nodeidx_t
tag: uchar
def charprev_idx8(self, *args) ‑> nodeidx_t
charprev_idx8(self, cur, tag) -> nodeidx_t
cur: uchar
tag: uchar
def charset(self, *args) ‑> bool
charset(self, alt, val, tag) -> bool
alt: nodeidx_t
val: uchar
tag: uchar
def charset_ea(self, *args) ‑> bool
charset_ea(self, ea, val, tag) -> bool
ea: ea_t
val: uchar
tag: uchar
def charset_idx8(self, *args) ‑> bool
charset_idx8(self, alt, val, tag) -> bool
alt: uchar
val: uchar
tag: uchar
def charshift(self, *args) ‑> size_t
charshift(self, _from, to, size, tag) -> size_t
from: nodeidx_t
to: nodeidx_t
size: nodeidx_t
tag: uchar
def charval(self, *args) ‑> uchar
charval(self, alt, tag) -> uchar
alt: nodeidx_t
tag: uchar
def charval_ea(self, *args) ‑> uchar
charval_ea(self, ea, tag) -> uchar
ea: ea_t
tag: uchar
def charval_idx8(self, *args) ‑> uchar
charval_idx8(self, alt, tag) -> uchar
alt: uchar
tag: uchar
def copyto(self, *args) ‑> size_t
copyto(self, destnode, count=1) -> size_t
destnode: netnode
count: nodeidx_t
def create(self, *args) ‑> bool
create(self, _name, namlen=0) -> bool
Create unnamed netnode.
retval 1: ok
retval 0: should not happen, indicates internal error
_name: char const *
namlen: size_t
create(self) -> bool
def delblob(self, *args) ‑> int
delblob(self, _start, tag) -> int
Delete a blob.
_start: (C++: nodeidx_t) index of the first supval element used to store blob
tag: (C++: uchar) tag of supval array
return: number of deleted supvals
def delblob_ea(self, *args) ‑> int
delblob_ea(self, ea, tag) -> int
ea: ea_t
tag: uchar
def delvalue(self, *args) ‑> bool
delvalue(self) -> bool
Delete value of netnode.
retval 1: ok
retval 0: failed, netnode is bad or other error
def eadel(self, *args) ‑> bool
eadel(self, ea, tag) -> bool
ea: ea_t
tag: uchar
def eadel_idx8(self, *args) ‑> bool
eadel_idx8(self, idx, tag) -> bool
idx: uchar
tag: uchar
def eaget(self, *args) ‑> ea_t
eaget(self, ea, tag) -> ea_t
ea: ea_t
tag: uchar
def eaget_idx(self, *args) ‑> ea_t
eaget_idx(self, idx, tag) -> ea_t
idx: nodeidx_t
tag: uchar
def eaget_idx8(self, *args) ‑> ea_t
eaget_idx8(self, idx, tag) -> ea_t
idx: uchar
tag: uchar
def easet(self, *args) ‑> bool
easet(self, ea, addr, tag) -> bool
Store/retrieve/delete an address value in the netnode that corresponds to an address.
ea: (C++: ea_t)
addr: (C++: ea_t)
tag: (C++: uchar)
def easet_idx(self, *args) ‑> bool
easet_idx(self, idx, addr, tag) -> bool
idx: nodeidx_t
addr: ea_t
tag: uchar
def easet_idx8(self, *args) ‑> bool
easet_idx8(self, idx, addr, tag) -> bool
idx: uchar
addr: ea_t
tag: uchar
def end(self, *args) ‑> bool
end(self) -> bool
Get last netnode in the graph. Sets netnodenumber to the highest existing number.
retval true: ok
retval false: graph is empty
def get_name(self, *args) ‑> ssize_t
get_name(self) -> ssize_t
Get the netnode name.
return: -1 if netnode is unnamed (buf is untouched in this case), otherwise the
name length
def getblob(self, *args) ‑> PyObject *
getblob(self, start, tag) -> bytes or None
Get blob from a netnode into a qstring* and make sure the string is null- terminated.
start: nodeidx_t
tag: (C++: uchar) tag of supval array
return: -1 if blob doesn't exist size of string (including terminating null)
otherwise
def getblob_ea(self, *args) ‑> PyObject *
getblob_ea(self, ea, tag) -> PyObject *
ea: ea_t
tag: char
def getclob(self, *args) ‑> PyObject *
getclob(self, start, tag) -> str
start: nodeidx_t
tag: char
def hashdel(self, *args) ‑> bool
hashdel(self, idx, tag=htag) -> bool
Delete hash element.
idx: (C++: const char *) index into hash
tag: (C++: uchar) tag of hash. Default: htag
retval true: deleted
retval false: element does not exist
def hashdel_all(self, *args) ‑> bool
hashdel_all(self, tag=htag) -> bool
Delete all elements of hash. This function deletes the whole hash.
tag: (C++: uchar) tag of hash. Default: htag
return: success
def hashfirst(self, *args) ‑> ssize_t
hashfirst(self, tag=htag) -> ssize_t
see: hashfirst(qstring *buf, uchar tag=htag) const
tag: (C++: uchar)
def hashlast(self, *args) ‑> ssize_t
hashlast(self, tag=htag) -> ssize_t
see: hashlast(qstring *buf, uchar tag=htag) const
tag: (C++: uchar)
def hashnext(self, *args) ‑> ssize_t
hashnext(self, idx, tag=htag) -> ssize_t
see: hashnext(qstring *buf, const char *idx, uchar tag=htag) const
idx: (C++: const char *) char const *
tag: (C++: uchar)
def hashprev(self, *args) ‑> ssize_t
hashprev(self, idx, tag=htag) -> ssize_t
see: hashprev(qstring *buf, const char *idx, uchar tag=htag) const
idx: (C++: const char *) char const *
tag: (C++: uchar)
def hashset(self, *args) ‑> bool
hashset(self, idx, value, tag=htag) -> bool
Set value of hash element to long value.
idx: (C++: const char *) index into hash
value: (C++: nodeidx_t) new value of hash element
tag: (C++: uchar) tag of hash. Default: htag
retval 1: ok
retval 0: should not occur - indicates internal error
def hashset_buf(self, *args) ‑> bool
hashset_buf(self, idx, py_str, tag=htag) -> bool
idx: char const *
py_str: PyObject *
tag: char
def hashset_idx(self, *args) ‑> bool
hashset_idx(self, idx, value, tag=htag) -> bool
idx: char const *
value: nodeidx_t
tag: uchar
def hashstr(self, *args) ‑> ssize_t
hashstr(self, idx, tag=htag) -> ssize_t
see: hashstr(qstring *buf, const char *idx, uchar tag=htag) const
idx: (C++: const char *) char const *
tag: (C++: uchar)
def hashstr_buf(self, *args) ‑> PyObject *
hashstr_buf(self, idx, tag=htag) -> PyObject *
idx: char const *
tag: char
def hashval(self, *args) ‑> ssize_t
hashval(self, idx, tag=htag) -> ssize_t
Get value of the specified hash element.
idx: (C++: const char *) index into hash
tag: (C++: uchar) tag of hash. Default: htag
return: -1 if element doesn't exist or idx is nullptr. otherwise returns the
value size in bytes
def hashval_long(self, *args) ‑> nodeidx_t
hashval_long(self, idx, tag=htag) -> nodeidx_t
Get value of the specified hash element.
idx: (C++: const char *) index into hash
tag: (C++: uchar) tag of hash. Default: htag
return: value of hash element (it should be set using hashset(nodeidx_t)), 0 if
the element does not exist
def index(self, *args) ‑> nodeidx_t
index(self) -> nodeidx_t
def kill(self, *args) ‑> void
kill(self)
Delete a netnode with all information attached to it.
def long_value(self, *args) ‑> nodeidx_t
long_value(self) -> nodeidx_t
def lower_bound(self, *args) ‑> nodeidx_t
lower_bound(self, cur, tag=stag) -> nodeidx_t
Get lower bound of existing elements of supval array.
cur: (C++: nodeidx_t) current index
tag: (C++: uchar) tag of array
return: index of first existing element of supval array >= cur BADNODE if
supval array is empty
def lower_bound_ea(self, *args) ‑> nodeidx_t
lower_bound_ea(self, ea, tag=stag) -> nodeidx_t
ea: ea_t
tag: uchar
def lower_bound_idx8(self, *args) ‑> nodeidx_t
lower_bound_idx8(self, alt, tag) -> nodeidx_t
alt: uchar
tag: uchar
def moveto(self, *args) ‑> size_t
moveto(self, destnode, count=1) -> size_t
destnode: netnode
count: nodeidx_t
def next(self, *args) ‑> bool
next(self) -> bool
Get next netnode in the graph. Sets netnodenumber to the next existing number
retval true: ok
retval false: no more netnodes
def prev(self, *args) ‑> bool
prev(self) -> bool
Get prev netnode in the graph. Sets netnodenumber to the previous existing number
retval true: ok
retval false: no more netnodes
def rename(self, *args) ‑> bool
rename(self, newname, namlen=0) -> bool
Rename a netnode.
newname: (C++: const char *) new name of netnode. nullptr or "" means to delete name. names
of user-defined netnodes must have the "$ " prefix in order to avoid clashes with program byte names.
namlen: (C++: size_t) length of new name. if not specified, it will be calculated using
strlen()
retval 1: ok
retval 0: failed, newname is already used
def set(self, *args) ‑> bool
set(self, value) -> bool
Set value of netnode.
value: (C++: const void *) pointer to value
return: 1 - ok
def set_long(self, *args) ‑> bool
set_long(self, x) -> bool
Value of netnode as a long number:
x: (C++: nodeidx_t)
def setblob(self, *args) ‑> bool
setblob(self, buf, _start, tag) -> bool
Store a blob in a netnode.
buf: (C++: const void *) pointer to blob to save
_start: (C++: nodeidx_t)
tag: (C++: uchar) tag of supval array
return: success
def setblob_ea(self, *args) ‑> bool
setblob_ea(self, buf, ea, tag) -> bool
buf: void const *
ea: ea_t
tag: uchar
def start(self, *args) ‑> bool
start(self) -> bool
Get first netnode in the graph. Sets netnodenumber to the lowest existing number.
retval true: ok
retval false: graph is empty
def supdel(self, *args) ‑> bool
supdel(self, alt, tag=stag) -> bool
Delete all elements of supval array. This function may be applied to 32-bit and 8-bit supval arrays. This function deletes the whole supval array.
alt: nodeidx_t
tag: uchar
return: success
supdel(self) -> bool
def supdel_all(self, *args) ‑> bool
supdel_all(self, tag) -> bool
Delete all elements of the specified supval array. This function may be applied to 32-bit and 8-bit supval arrays. This function deletes the whole supval array.
tag: (C++: uchar)
return: success
def supdel_ea(self, *args) ‑> bool
supdel_ea(self, ea, tag=stag) -> bool
ea: ea_t
tag: uchar
def supdel_idx8(self, *args) ‑> bool
supdel_idx8(self, alt, tag) -> bool
alt: uchar
tag: uchar
def supdel_range(self, *args) ‑> int
supdel_range(self, idx1, idx2, tag) -> int
Delete range of elements in the specified supval array. Elements in range [idx1, idx2) will be deleted.
note: This function can also be used to delete a range of altval elements
idx1: (C++: nodeidx_t) first element to delete
idx2: (C++: nodeidx_t) last element to delete + 1
tag: (C++: uchar) tag of array
return: number of deleted elements
def supdel_range_idx8(self, *args) ‑> int
supdel_range_idx8(self, idx1, idx2, tag) -> int
Same as above, but accepts 8-bit indexes.
idx1: (C++: uchar)
idx2: (C++: uchar)
tag: (C++: uchar)
def supfirst(self, *args) ‑> nodeidx_t
supfirst(self, tag=stag) -> nodeidx_t
Get first existing element of supval array.
tag: (C++: uchar) tag of array
return: index of first existing element of supval array, BADNODE if supval
array is empty
def supfirst_idx8(self, *args) ‑> nodeidx_t
supfirst_idx8(self, tag) -> nodeidx_t
tag: uchar
def suplast(self, *args) ‑> nodeidx_t
suplast(self, tag=stag) -> nodeidx_t
Get last existing element of supval array.
tag: (C++: uchar) tag of array
return: index of last existing element of supval array, BADNODE if supval array
is empty
def suplast_idx8(self, *args) ‑> nodeidx_t
suplast_idx8(self, tag) -> nodeidx_t
tag: uchar
def supnext(self, *args) ‑> nodeidx_t
supnext(self, cur, tag=stag) -> nodeidx_t
Get next existing element of supval array.
cur: (C++: nodeidx_t) current index
tag: (C++: uchar) tag of array
return: index of the next existing element of supval array, BADNODE if no more
supval array elements exist
def supnext_idx8(self, *args) ‑> nodeidx_t
supnext_idx8(self, alt, tag) -> nodeidx_t
alt: uchar
tag: uchar
def supprev(self, *args) ‑> nodeidx_t
supprev(self, cur, tag=stag) -> nodeidx_t
Get previous existing element of supval array.
cur: (C++: nodeidx_t) current index
tag: (C++: uchar) tag of array
return: index of the previous existing element of supval array BADNODE if no
more supval array elements exist
def supprev_idx8(self, *args) ‑> nodeidx_t
supprev_idx8(self, alt, tag) -> nodeidx_t
alt: uchar
tag: uchar
def supset(self, *args) ‑> bool
supset(self, alt, value, tag=stag) -> bool
Set value of supval array element.
alt: (C++: nodeidx_t) index into array of supvals
value: (C++: const void *) pointer to supval value
tag: (C++: uchar) tag of array
retval 1: ok
retval 0: should not occur - indicates internal error
def supset_ea(self, *args) ‑> bool
supset_ea(self, ea, value, tag=stag) -> bool
ea: ea_t
value: void const *
tag: uchar
def supset_idx8(self, *args) ‑> bool
supset_idx8(self, alt, value, tag) -> bool
alt: uchar
value: void const *
tag: uchar
def supshift(self, *args) ‑> size_t
supshift(self, _from, to, size, tag=stag) -> size_t
Shift the supval array elements. Moves the array elements at (from..from+size) to (to..to+size)
from: (C++: nodeidx_t)
to: (C++: nodeidx_t)
size: (C++: nodeidx_t)
tag: (C++: uchar)
return: number of shifted elements
def supstr(self, *args) ‑> ssize_t
supstr(self, alt, tag=stag) -> ssize_t
see: supstr(qstring *buf, nodeidx_t alt, uchar tag=stag) const
alt: (C++: nodeidx_t)
tag: (C++: uchar)
def supstr_ea(self, *args) ‑> ssize_t
supstr_ea(self, ea, tag=stag) -> ssize_t
ea: ea_t
tag: uchar
def supstr_idx8(self, *args) ‑> ssize_t
supstr_idx8(self, alt, tag) -> ssize_t
alt: uchar
tag: uchar
def supval(self, *args) ‑> ssize_t
supval(self, alt, tag=stag) -> ssize_t
Get value of the specified supval array element. NB: do not use this function to retrieve strings, see supstr()!
alt: (C++: nodeidx_t) index into array of supvals
tag: (C++: uchar) tag of array. Default: stag
return: size of value, -1 if element doesn't exist
def supval_ea(self, *args) ‑> ssize_t
supval_ea(self, ea, tag=stag) -> ssize_t
ea: ea_t
tag: uchar
def supval_idx8(self, *args) ‑> ssize_t
supval_idx8(self, alt, tag) -> ssize_t
alt: uchar
tag: uchar
def valobj(self, *args) ‑> ssize_t
valobj(self) -> ssize_t
Get value of netnode. Netnode values are arbitrary sized objects with max size is MAXSPECSIZE. NB: do not use this function for strings - see valstr().
return: length of value, -1 if no value present
def valstr(self, *args) ‑> ssize_t
valstr(self) -> ssize_t
see: valstr(qstring *buf) const
def value_exists(self, *args) ‑> bool
value_exists(self) -> bool