Module `ida_netnode`

Functions that provide the lowest level public interface to the database. Namely, we use Btree. To learn more about BTree:

\link{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 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(n: netnode) ‑> bool: exist(n) -> bool

@param n: netnode const &
def netnode_exist(_name: char const *): exist(_name) -> bool Does the netnode with the specified name exist?

@param _name: (C++: const char *) char const *

Classes

class netnode (*args)

Proxy of C++ netnode class.

init(self, num=nodeidx_t(-1)) -> netnode

@param num: nodeidx_t

init(self, _name, namlen=0, do_create=False) -> netnode

@param _name: char const * @param namlen: size_t @param do_create: bool

Static methods

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

@param _name: (C++: const char *) char const *

Instance variables

var thisown: The membership flag

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.

@param alt: nodeidx_t @param 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.

@param tag: (C++: uchar) tag of array @return: success
def altdel_ea(self, *args) ‑> bool: altdel_ea(self, ea, tag=atag) -> bool

@param ea: ea_t @param tag: uchar
def altdel_idx8(self, alt: uchar, tag: uchar): altdel_idx8(self, alt, tag) -> bool

@param alt: uchar @param tag: uchar
def altfirst(self, *args): altfirst(self, tag=atag) -> nodeidx_t Get first existing element of altval array.

@param 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, tag: uchar): altfirst_idx8(self, tag) -> nodeidx_t

@param tag: uchar
def altlast(self, *args): altlast(self, tag=atag) -> nodeidx_t Get last element of altval array.

@param 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, tag: uchar): altlast_idx8(self, tag) -> nodeidx_t

@param tag: uchar
def altnext(self, *args): altnext(self, cur, tag=atag) -> nodeidx_t Get next existing element of altval array.

@param cur: (C++: nodeidx_t) current index @param 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, cur: uchar, tag: uchar): altnext_idx8(self, cur, tag) -> nodeidx_t

@param cur: uchar @param tag: uchar
def altprev(self, *args): altprev(self, cur, tag=atag) -> nodeidx_t Get previous existing element of altval array.

@param cur: (C++: nodeidx_t) current index @param 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, cur: uchar, tag: uchar): altprev_idx8(self, cur, tag) -> nodeidx_t

@param cur: uchar @param tag: uchar
def altset(self, *args) ‑> bool: altset(self, alt, value, tag=atag) -> bool Set value of altval array.

@param alt: (C++: nodeidx_t) index into array of altvals @param value: (C++: nodeidx_t) new value of altval element @param 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

@param ea: ea_t @param value: nodeidx_t @param tag: uchar
def altset_idx8(self, alt: uchar, val: nodeidx_t, tag: uchar): altset_idx8(self, alt, val, tag) -> bool

@param alt: uchar @param val: nodeidx_t @param tag: uchar
def altshift(self, *args): 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)

@param from: (C++: nodeidx_t) @param to: (C++: nodeidx_t) @param size: (C++: nodeidx_t) @param tag: (C++: uchar) @return: number of shifted elements
def altval(self, *args): altval(self, alt, tag=atag) -> nodeidx_t Get altval element of the specified array.

@param alt: (C++: nodeidx_t) index into array of altvals @param 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): altval_ea(self, ea, tag=atag) -> nodeidx_t

@param ea: ea_t @param tag: uchar
def altval_idx8(self, alt: uchar, tag: uchar): altval_idx8(self, alt, tag) -> nodeidx_t

@param alt: uchar @param tag: uchar
def blobshift(self, _from: nodeidx_t, to: nodeidx_t, size: nodeidx_t, tag: uchar): 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)

@param from: (C++: nodeidx_t) @param to: (C++: nodeidx_t) @param size: (C++: nodeidx_t) @param tag: (C++: uchar) @return: number of shifted elements
def blobsize(self, _start: nodeidx_t, tag: uchar): blobsize(self, _start, tag) -> size_t Get size of blob.

@param _start: (C++: nodeidx_t) index of the first supval element used to store blob @param tag: (C++: uchar) tag of supval array @return: number of bytes required to store a blob
def blobsize_ea(self, ea: ea_t, tag: uchar): blobsize_ea(self, ea, tag) -> size_t

@param ea: ea_t @param tag: uchar
def chardel(self, alt: nodeidx_t, tag: uchar): chardel(self, alt, tag) -> bool

@param alt: nodeidx_t @param tag: uchar
def chardel_ea(self, ea: ea_t, tag: uchar): chardel_ea(self, ea, tag) -> bool

@param ea: ea_t @param tag: uchar
def chardel_idx8(self, alt: uchar, tag: uchar): chardel_idx8(self, alt, tag) -> bool

@param alt: uchar @param tag: uchar
def charfirst(self, tag: uchar): charfirst(self, tag) -> nodeidx_t

@param tag: uchar
def charfirst_idx8(self, tag: uchar): charfirst_idx8(self, tag) -> nodeidx_t

@param tag: uchar
def charlast(self, tag: uchar): charlast(self, tag) -> nodeidx_t

@param tag: uchar
def charlast_idx8(self, tag: uchar): charlast_idx8(self, tag) -> nodeidx_t

@param tag: uchar
def charnext(self, cur: nodeidx_t, tag: uchar): charnext(self, cur, tag) -> nodeidx_t

@param cur: nodeidx_t @param tag: uchar
def charnext_idx8(self, cur: uchar, tag: uchar): charnext_idx8(self, cur, tag) -> nodeidx_t

@param cur: uchar @param tag: uchar
def charprev(self, cur: nodeidx_t, tag: uchar): charprev(self, cur, tag) -> nodeidx_t

@param cur: nodeidx_t @param tag: uchar
def charprev_idx8(self, cur: uchar, tag: uchar): charprev_idx8(self, cur, tag) -> nodeidx_t

@param cur: uchar @param tag: uchar
def charset(self, alt: nodeidx_t, val: uchar, tag: uchar): charset(self, alt, val, tag) -> bool

@param alt: nodeidx_t @param val: uchar @param tag: uchar
def charset_ea(self, ea: ea_t, val: uchar, tag: uchar): charset_ea(self, ea, val, tag) -> bool

@param ea: ea_t @param val: uchar @param tag: uchar
def charset_idx8(self, alt: uchar, val: uchar, tag: uchar): charset_idx8(self, alt, val, tag) -> bool

@param alt: uchar @param val: uchar @param tag: uchar
def charshift(self, _from: nodeidx_t, to: nodeidx_t, size: nodeidx_t, tag: uchar): charshift(self, _from, to, size, tag) -> size_t

@param from: nodeidx_t @param to: nodeidx_t @param size: nodeidx_t @param tag: uchar
def charval(self, alt: nodeidx_t, tag: uchar): charval(self, alt, tag) -> uchar

@param alt: nodeidx_t @param tag: uchar
def charval_ea(self, ea: ea_t, tag: uchar): charval_ea(self, ea, tag) -> uchar

@param ea: ea_t @param tag: uchar
def charval_idx8(self, alt: uchar, tag: uchar): charval_idx8(self, alt, tag) -> uchar

@param alt: uchar @param tag: uchar
def copyto(self, destnode: netnode, count: nodeidx_t = 1): copyto(self, destnode, count=1) -> size_t

@param destnode: netnode @param 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

@param _name: char const * @param namlen: size_t

create(self) -> bool
def delblob(self, _start: nodeidx_t, tag: uchar): delblob(self, _start, tag) -> int Delete a blob.

@param _start: (C++: nodeidx_t) index of the first supval element used to store blob @param tag: (C++: uchar) tag of supval array @return: number of deleted supvals
def delblob_ea(self, ea: ea_t, tag: uchar): delblob_ea(self, ea, tag) -> int

@param ea: ea_t @param tag: uchar
def delvalue(self) ‑> bool: delvalue(self) -> bool Delete value of netnode. @retval 1: ok @retval 0: failed, netnode is bad or other error
def eadel(self, ea: ea_t, tag: uchar): eadel(self, ea, tag) -> bool

@param ea: ea_t @param tag: uchar
def eadel_idx8(self, idx: uchar, tag: uchar): eadel_idx8(self, idx, tag) -> bool

@param idx: uchar @param tag: uchar
def eaget(self, ea: ea_t, tag: uchar): eaget(self, ea, tag) -> ea_t

@param ea: ea_t @param tag: uchar
def eaget_idx(self, idx: nodeidx_t, tag: uchar): eaget_idx(self, idx, tag) -> ea_t

@param idx: nodeidx_t @param tag: uchar
def eaget_idx8(self, idx: uchar, tag: uchar): eaget_idx8(self, idx, tag) -> ea_t

@param idx: uchar @param tag: uchar
def easet(self, ea: ea_t, addr: ea_t, tag: uchar): easet(self, ea, addr, tag) -> bool Store/retrieve/delete an address value in the netnode that corresponds to an address.

@param ea: (C++: ea_t) @param addr: (C++: ea_t) @param tag: (C++: uchar)
def easet_idx(self, idx: nodeidx_t, addr: ea_t, tag: uchar): easet_idx(self, idx, addr, tag) -> bool

@param idx: nodeidx_t @param addr: ea_t @param tag: uchar
def easet_idx8(self, idx: uchar, addr: ea_t, tag: uchar): easet_idx8(self, idx, addr, tag) -> bool

@param idx: uchar @param addr: ea_t @param tag: uchar
def end(self) ‑> 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): 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, start: nodeidx_t, tag: char): getblob(self, start, tag) -> bytes or None Get blob from a netnode into a qstring* and make sure the string is null- terminated.

@param start: nodeidx_t @param 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, ea: ea_t, tag: char): getblob_ea(self, ea, tag) -> PyObject *

@param ea: ea_t @param tag: char
def getclob(self, start: nodeidx_t, tag: char): getclob(self, start, tag) -> str

@param start: nodeidx_t @param tag: char
def hashdel(self, *args) ‑> bool: hashdel(self, idx, tag=htag) -> bool Delete hash element.

@param idx: (C++: const char *) index into hash @param 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.

@param tag: (C++: uchar) tag of hash. Default: htag @return: success
def hashfirst(self, *args): hashfirst(self, tag=htag) -> ssize_t @see: hashfirst(qstring *buf, uchar tag=htag) const

@param tag: (C++: uchar)
def hashlast(self, *args): hashlast(self, tag=htag) -> ssize_t @see: hashlast(qstring *buf, uchar tag=htag) const

@param tag: (C++: uchar)
def hashnext(self, *args): hashnext(self, idx, tag=htag) -> ssize_t @see: hashnext(qstring buf, const char idx, uchar tag=htag) const

@param idx: (C++: const char *) char const * @param tag: (C++: uchar)
def hashprev(self, *args): hashprev(self, idx, tag=htag) -> ssize_t @see: hashprev(qstring buf, const char idx, uchar tag=htag) const

@param idx: (C++: const char *) char const * @param tag: (C++: uchar)
def hashset(self, *args) ‑> bool: hashset(self, idx, value, tag=htag) -> bool Set value of hash element to long value.

@param idx: (C++: const char *) index into hash @param value: (C++: nodeidx_t) new value of hash element @param 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

@param idx: char const * @param py_str: PyObject * @param tag: char
def hashset_idx(self, *args) ‑> bool: hashset_idx(self, idx, value, tag=htag) -> bool

@param idx: char const * @param value: nodeidx_t @param tag: uchar
def hashstr(self, *args): hashstr(self, idx, tag=htag) -> ssize_t @see: hashstr(qstring buf, const char idx, uchar tag=htag) const

@param idx: (C++: const char *) char const * @param tag: (C++: uchar)
def hashstr_buf(self, *args): hashstr_buf(self, idx, tag=htag) -> PyObject

@param idx: char const * @param tag: char
def hashval(self, *args): hashval(self, idx, tag=htag) -> ssize_t Get value of the specified hash element.

@param idx: (C++: const char *) index into hash @param 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): hashval_long(self, idx, tag=htag) -> nodeidx_t Get value of the specified hash element.

@param idx: (C++: const char *) index into hash @param 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): index(self) -> nodeidx_t
def kill(self): kill(self) Delete a netnode with all information attached to it.
def long_value(self): long_value(self) -> nodeidx_t
def lower_bound(self, *args): lower_bound(self, cur, tag=stag) -> nodeidx_t Get lower bound of existing elements of supval array.

@param cur: (C++: nodeidx_t) current index @param 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): lower_bound_ea(self, ea, tag=stag) -> nodeidx_t

@param ea: ea_t @param tag: uchar
def lower_bound_idx8(self, alt: uchar, tag: uchar): lower_bound_idx8(self, alt, tag) -> nodeidx_t

@param alt: uchar @param tag: uchar
def moveto(self, destnode: netnode, count: nodeidx_t = 1): moveto(self, destnode, count=1) -> size_t

@param destnode: netnode @param count: nodeidx_t
def next(self) ‑> 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) ‑> 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, newname: char const *, namlen: size_t = 0): rename(self, newname, namlen=0) -> bool Rename a netnode.

@param 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. @param 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, value: void const *): set(self, value) -> bool Set value of netnode.

@param value: (C++: const void *) pointer to value @return: 1 - ok
def set_long(self, x: nodeidx_t): set_long(self, x) -> bool Value of netnode as a long number:

@param x: (C++: nodeidx_t)
def setblob(self, buf: void const *, _start: nodeidx_t, tag: uchar): setblob(self, buf, _start, tag) -> bool Store a blob in a netnode.

@param buf: (C++: const void *) pointer to blob to save @param _start: (C++: nodeidx_t) @param tag: (C++: uchar) tag of supval array @return: success
def setblob_ea(self, buf: void const *, ea: ea_t, tag: uchar): setblob_ea(self, buf, ea, tag) -> bool

@param buf: void const * @param ea: ea_t @param tag: uchar
def start(self) ‑> 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.

@param alt: nodeidx_t @param tag: uchar

@return: success supdel(self) -> bool
def supdel_all(self, tag: uchar): 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.

@param tag: (C++: uchar) @return: success
def supdel_ea(self, *args) ‑> bool: supdel_ea(self, ea, tag=stag) -> bool

@param ea: ea_t @param tag: uchar
def supdel_idx8(self, alt: uchar, tag: uchar): supdel_idx8(self, alt, tag) -> bool

@param alt: uchar @param tag: uchar
def supdel_range(self, idx1: nodeidx_t, idx2: nodeidx_t, tag: uchar): 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

@param idx1: (C++: nodeidx_t) first element to delete @param idx2: (C++: nodeidx_t) last element to delete + 1 @param tag: (C++: uchar) tag of array @return: number of deleted elements
def supdel_range_idx8(self, idx1: uchar, idx2: uchar, tag: uchar): supdel_range_idx8(self, idx1, idx2, tag) -> int Same as above, but accepts 8-bit indexes.

@param idx1: (C++: uchar) @param idx2: (C++: uchar) @param tag: (C++: uchar)
def supfirst(self, *args): supfirst(self, tag=stag) -> nodeidx_t Get first existing element of supval array.

@param 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, tag: uchar): supfirst_idx8(self, tag) -> nodeidx_t

@param tag: uchar
def suplast(self, *args): suplast(self, tag=stag) -> nodeidx_t Get last existing element of supval array.

@param 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, tag: uchar): suplast_idx8(self, tag) -> nodeidx_t

@param tag: uchar
def supnext(self, *args): supnext(self, cur, tag=stag) -> nodeidx_t Get next existing element of supval array.

@param cur: (C++: nodeidx_t) current index @param 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, alt: uchar, tag: uchar): supnext_idx8(self, alt, tag) -> nodeidx_t

@param alt: uchar @param tag: uchar
def supprev(self, *args): supprev(self, cur, tag=stag) -> nodeidx_t Get previous existing element of supval array.

@param cur: (C++: nodeidx_t) current index @param 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, alt: uchar, tag: uchar): supprev_idx8(self, alt, tag) -> nodeidx_t

@param alt: uchar @param tag: uchar
def supset(self, *args) ‑> bool: supset(self, alt, value, tag=stag) -> bool Set value of supval array element.

@param alt: (C++: nodeidx_t) index into array of supvals @param value: (C++: const void *) pointer to supval value @param 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

@param ea: ea_t @param value: void const * @param tag: uchar
def supset_idx8(self, alt: uchar, value: void const *, tag: uchar): supset_idx8(self, alt, value, tag) -> bool

@param alt: uchar @param value: void const * @param tag: uchar
def supshift(self, *args): 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)

@param from: (C++: nodeidx_t) @param to: (C++: nodeidx_t) @param size: (C++: nodeidx_t) @param tag: (C++: uchar) @return: number of shifted elements
def supstr(self, *args): supstr(self, alt, tag=stag) -> ssize_t @see: supstr(qstring *buf, nodeidx_t alt, uchar tag=stag) const

@param alt: (C++: nodeidx_t) @param tag: (C++: uchar)
def supstr_ea(self, *args): supstr_ea(self, ea, tag=stag) -> ssize_t

@param ea: ea_t @param tag: uchar
def supstr_idx8(self, alt: uchar, tag: uchar): supstr_idx8(self, alt, tag) -> ssize_t

@param alt: uchar @param tag: uchar
def supval(self, *args): 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()!

@param alt: (C++: nodeidx_t) index into array of supvals @param tag: (C++: uchar) tag of array. Default: stag @return: size of value, -1 if element doesn't exist
def supval_ea(self, *args): supval_ea(self, ea, tag=stag) -> ssize_t

@param ea: ea_t @param tag: uchar
def supval_idx8(self, *args): supval_idx8(self, alt, tag) -> ssize_t

@param alt: uchar @param tag: uchar
def valobj(self, *args): 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): valstr(self) -> ssize_t @see: valstr(qstring *buf) const
def value_exists(self) ‑> bool: value_exists(self) -> bool