netnode.hpp

Go to the documentation of this file.

/*
 *      Interactive disassembler (IDA).
 *      Copyright (c) 1990-2025 Hex-Rays
 *      ALL RIGHTS RESERVED.
 *
 */
 
#ifndef _NETNODE_HPP
#define _NETNODE_HPP
 
#include <functional>

 
#include <range.hpp>
 
//--------------------------------------------------------------------------
const int MAXNAMESIZE = 512;

const int MAX_NODENAME_SIZE = 32*1024;

const int MAXSPECSIZE = 1024;

typedef uint64 nodeidx64_t;
typedef uint32 nodeidx32_t;
#ifdef __EA64__
typedef nodeidx64_t nodeidx_t;
#else
typedef nodeidx32_t nodeidx_t;
#endif

#define BADNODE nodeidx_t(-1)

const uchar atag = 'A';                 
const uchar stag = 'S';                 
const uchar htag = 'H';                 
const uchar vtag = 'V';                 
const uchar ntag = 'N';                 
const uchar ltag = 'L';                 
 
// Internal bit used to request ea2node() mapping of alt and sup indexes
const int NETMAP_IDX = 0x100;
// Internal bit used to request ea2node() mapping of alt values.
// Such values are stored after being incremented by one.
const int NETMAP_VAL = 0x200;
// Internal bit used to make sure a string obtained with getblob() is
// null-terminated.
const int NETMAP_STR = 0x400;
// Internal bit: use 8-bit indexes.
const int NETMAP_X8 = 0x800;
// Internal bit: use 8-bit values.
const int NETMAP_V8 = 0x1000;
// Internal bit: value is a netnode index
const int NETMAP_VAL_NDX = 0x2000;

struct altadjust_visitor_t
{
  virtual bool should_skip(nodeidx_t ea) = 0;
};

class netnode;
class linput_t;
idaman bool ida_export netnode_check(netnode *, const char *name, size_t namlen, bool create);
idaman void ida_export netnode_kill(netnode *);
idaman bool ida_export netnode_start(netnode *);
idaman bool ida_export netnode_end(netnode *);
idaman bool ida_export netnode_next(netnode *);
idaman bool ida_export netnode_prev(netnode *);
idaman ssize_t ida_export netnode_get_name(nodeidx_t num, qstring *out);
idaman bool ida_export netnode_rename(nodeidx_t num, const char *newname, size_t namlen);
idaman ssize_t ida_export netnode_valobj(nodeidx_t num, void *buf, size_t bufsize);
idaman ssize_t ida_export netnode_valstr(nodeidx_t num, char *buf, size_t bufsize);
idaman ssize_t ida_export netnode_qvalstr(nodeidx_t num, qstring *buf);
idaman bool ida_export netnode_set(nodeidx_t num, const void *value, size_t length);
idaman bool ida_export netnode_delvalue(nodeidx_t num);
idaman nodeidx_t ida_export netnode_altval(nodeidx_t num, nodeidx_t alt, int tag);
idaman uchar ida_export netnode_charval(nodeidx_t num, nodeidx_t alt, int tag);
idaman nodeidx_t ida_export netnode_altval_idx8(nodeidx_t num, uchar alt, int tag);
idaman uchar ida_export netnode_charval_idx8(nodeidx_t num, uchar alt, int tag);
idaman ssize_t ida_export netnode_supval(nodeidx_t num, nodeidx_t alt, void *buf, size_t bufsize, int tag);
idaman ssize_t ida_export netnode_supstr(nodeidx_t num, nodeidx_t alt, char *buf, size_t bufsize, int tag);
idaman ssize_t ida_export netnode_qsupstr(nodeidx_t num, qstring *buf, nodeidx_t alt, int tag);
idaman bool ida_export netnode_supset(nodeidx_t num, nodeidx_t alt, const void *value, size_t length, int tag);
idaman bool ida_export netnode_supdel(nodeidx_t num, nodeidx_t alt, int tag);
idaman nodeidx_t ida_export netnode_lower_bound(nodeidx_t num, nodeidx_t cur, int tag);
idaman nodeidx_t ida_export netnode_supfirst(nodeidx_t num, int tag);
idaman nodeidx_t ida_export netnode_supnext(nodeidx_t num, nodeidx_t cur, int tag);
idaman nodeidx_t ida_export netnode_suplast(nodeidx_t num, int tag);
idaman nodeidx_t ida_export netnode_supprev(nodeidx_t num, nodeidx_t cur, int tag);
idaman ssize_t ida_export netnode_supval_idx8(nodeidx_t num, uchar alt, void *buf, size_t bufsize, int tag);
idaman ssize_t ida_export netnode_supstr_idx8(nodeidx_t num, uchar alt, char *buf, size_t bufsize, int tag);
idaman ssize_t ida_export netnode_qsupstr_idx8(nodeidx_t num, qstring *buf, uchar alt, int tag);
idaman bool ida_export netnode_supset_idx8(nodeidx_t num, uchar alt, const void *value, size_t length, int tag);
idaman bool ida_export netnode_supdel_idx8(nodeidx_t num, uchar alt, int tag);
idaman nodeidx_t ida_export netnode_lower_bound_idx8(nodeidx_t num, uchar alt, int tag);
idaman nodeidx_t ida_export netnode_supfirst_idx8(nodeidx_t num, int tag);
idaman nodeidx_t ida_export netnode_supnext_idx8(nodeidx_t num, uchar alt, int tag);
idaman nodeidx_t ida_export netnode_suplast_idx8(nodeidx_t num, int tag);
idaman nodeidx_t ida_export netnode_supprev_idx8(nodeidx_t num, uchar alt, int tag);
idaman bool ida_export netnode_supdel_all(nodeidx_t num, int tag);
idaman int ida_export netnode_supdel_range(nodeidx_t num, nodeidx_t idx1, nodeidx_t idx2, int tag);
idaman int ida_export netnode_supdel_range_idx8(nodeidx_t num, nodeidx_t idx1, nodeidx_t idx2, int tag);
idaman ssize_t ida_export netnode_hashval(nodeidx_t num, const char *idx, void *buf, size_t bufsize, int tag);
idaman ssize_t ida_export netnode_hashstr(nodeidx_t num, const char *idx, char *buf, size_t bufsize, int tag);
idaman ssize_t ida_export netnode_qhashstr(nodeidx_t num, qstring *buf, const char *idx, int tag);
idaman nodeidx_t ida_export netnode_hashval_long(nodeidx_t num, const char *idx, int tag);
idaman bool ida_export netnode_hashset(nodeidx_t num, const char *idx, const void *value, size_t length, int tag);
idaman bool ida_export netnode_hashdel(nodeidx_t num, const char *idx, int tag);
idaman ssize_t ida_export netnode_hashfirst(nodeidx_t num, char *buf, size_t bufsize, int tag);
idaman ssize_t ida_export netnode_qhashfirst(nodeidx_t num, qstring *buf, int tag);
idaman ssize_t ida_export netnode_hashnext(nodeidx_t num, const char *idx, char *buf, size_t bufsize, int tag);
idaman ssize_t ida_export netnode_qhashnext(nodeidx_t num, qstring *buf, const char *idx, int tag);
idaman ssize_t ida_export netnode_hashlast(nodeidx_t num, char *buf, size_t bufsize, int tag);
idaman ssize_t ida_export netnode_qhashlast(nodeidx_t num, qstring *buf, int tag);
idaman ssize_t ida_export netnode_hashprev(nodeidx_t num, const char *idx, char *buf, size_t bufsize, int tag);
idaman ssize_t ida_export netnode_qhashprev(nodeidx_t num, qstring *buf, const char *idx, int tag);
idaman size_t ida_export netnode_blobsize(nodeidx_t num, nodeidx_t start, int tag);
idaman void *ida_export netnode_getblob(nodeidx_t num, void *buf, size_t *bufsize, nodeidx_t start, int tag);
idaman ssize_t ida_export netnode_qgetblob(nodeidx_t num, bytevec_t *buf, size_t elsize, nodeidx_t start, int tag);
idaman bool ida_export netnode_setblob(nodeidx_t num, const void *buf, size_t size, nodeidx_t start, int tag);
idaman int ida_export netnode_delblob(nodeidx_t num, nodeidx_t start, int tag);
idaman bool ida_export netnode_inited(void);
idaman bool ida_export netnode_is_available(void);
idaman size_t ida_export netnode_copy(nodeidx_t num, nodeidx_t count, nodeidx_t target, bool move);
idaman size_t ida_export netnode_altshift(nodeidx_t num, nodeidx_t from, nodeidx_t to, nodeidx_t size, int tag);
idaman size_t ida_export netnode_charshift(nodeidx_t num, nodeidx_t from, nodeidx_t to, nodeidx_t size, int tag);
idaman size_t ida_export netnode_supshift(nodeidx_t num, nodeidx_t from, nodeidx_t to, nodeidx_t size, int tag);
idaman size_t ida_export netnode_blobshift(nodeidx_t num, nodeidx_t from, nodeidx_t to, nodeidx_t size, int tag);
idaman void ida_export netnode_altadjust(nodeidx_t num, nodeidx_t from, nodeidx_t to, nodeidx_t size, bool (idaapi *should_skip)(nodeidx_t ea));
idaman void ida_export netnode_altadjust2(nodeidx_t num, nodeidx_t from, nodeidx_t to, nodeidx_t size, altadjust_visitor_t &av);
idaman bool ida_export netnode_exist(const netnode &n);
 
//--------------------------------------------------------------------------
//      N E T N O D E
//--------------------------------------------------------------------------

class netnode
{
  friend class netlink;
public:
 
  //--------------------------------------------------------------------------

  netnode(nodeidx_t num=BADNODE) { netnodenumber = num; }

  operator nodeidx_t() const { return netnodenumber; }

  netnode(const char *_name, size_t namlen=0, bool do_create=false)
  {
    netnode_check(this, _name, namlen, do_create);
  }


  friend bool exist(const netnode &n) { return netnode_exist(n); }

  static bool exist(const char *_name) { return netnode(_name) != BADNODE; }
 
  //--------------------------------------------------------------------------

  bool create(const char *_name, size_t namlen=0)
  {
    return netnode_check(this, _name, namlen, true);
  }

  bool create(void) { return create(nullptr); }

  void kill(void) { netnode_kill(this); }

 
  //--------------------------------------------------------------------------

  ssize_t get_name(qstring *buf) const
  {
    return netnode_get_name(*this, buf);
  }

  bool rename(const char *newname, size_t namlen=0)
  {
    return netnode_rename(*this, newname, namlen);
  }

 
  //--------------------------------------------------------------------------

  ssize_t valobj(void *buf, size_t bufsize) const
  {
    return netnode_valobj(*this, buf, bufsize);
  }

  ssize_t valstr(qstring *buf) const
  {
    return netnode_qvalstr(*this, buf);
  }

  ssize_t valstr(char *buf, size_t bufsize) const
  {
    return netnode_valstr(*this, buf, bufsize);
  }

  bool set(const void *value, size_t length=0)
  {
    return netnode_set(*this, value, length);
  }

  bool delvalue(void)
  {
    return netnode_delvalue(*this);
  }

  bool set_long(nodeidx_t x) { return set(&x, sizeof(x)); }
  bool value_exists(void) const { return valobj(nullptr, 0) >= 0; }
  nodeidx_t long_value(void) const
  {
    nodeidx_t v = 0;
    if ( valobj(&v, sizeof(v)) > 0 )
      return v;
    return BADNODE;
  }

 
  //--------------------------------------------------------------------------

  nodeidx_t altval(nodeidx_t alt, uchar tag=atag) const
  {
    return netnode_altval(*this, alt, tag);
  }
  nodeidx_t altval_ea(ea_t ea, uchar tag=atag) const
  {
    return netnode_altval(*this, ea, tag|NETMAP_IDX);
  }

  bool altset(nodeidx_t alt, nodeidx_t value, uchar tag=atag)
  {
    return netnode_supset(*this, alt, &value, sizeof(value), tag);
  }
  bool altset_ea(ea_t ea, nodeidx_t value, uchar tag=atag)
  {
    return netnode_supset(*this, ea, &value, sizeof(value), tag|NETMAP_IDX);
  }

  bool altdel(nodeidx_t alt, uchar tag=atag)
  {
    return netnode_supdel(*this, alt, tag);
  }
  bool altdel_ea(ea_t ea, uchar tag=atag)
  {
    return netnode_supdel(*this, ea, tag|NETMAP_IDX);
  }

  bool easet(ea_t ea, ea_t addr, uchar tag)
  {
    return netnode_supset(*this, ea, &addr, sizeof(addr), tag|NETMAP_IDX|NETMAP_VAL);
  }
  ea_t eaget(ea_t ea, uchar tag) const
  {
    return netnode_altval(*this, ea, tag|NETMAP_IDX|NETMAP_VAL);
  }
  bool eadel(ea_t ea, uchar tag)
  {
    return netnode_supdel(*this, ea, tag|NETMAP_IDX);
  }
 
  bool easet_idx(nodeidx_t idx, ea_t addr, uchar tag)
  {
    return netnode_supset(*this, idx, &addr, sizeof(addr), tag|NETMAP_VAL);
  }
  ea_t eaget_idx(nodeidx_t idx, uchar tag)
  {
    return netnode_altval(*this, idx, tag|NETMAP_VAL);
  }
 
  bool easet_idx8(uchar idx, ea_t addr, uchar tag)
  {
    return netnode_supset_idx8(*this, idx, &addr, sizeof(addr), tag|NETMAP_VAL);
  }
  ea_t eaget_idx8(uchar idx, uchar tag) const
  {
    return netnode_altval_idx8(*this, idx, tag|NETMAP_VAL);
  }
  bool eadel_idx8(uchar idx, uchar tag)
  {
    return netnode_supdel_idx8(*this, idx, tag);
  }

  nodeidx_t altfirst(uchar tag=atag) const
  {
    return supfirst(tag);
  }

  nodeidx_t altnext(nodeidx_t cur, uchar tag=atag) const
  {
    return supnext(cur, tag);
  }

  nodeidx_t altlast(uchar tag=atag) const
  {
    return suplast(tag);
  }

  nodeidx_t altprev(nodeidx_t cur, uchar tag=atag) const
  {
    return supprev(cur, tag);
  }

  size_t altshift(nodeidx_t from, nodeidx_t to, nodeidx_t size, uchar tag=atag)
  {
    return netnode_altshift(*this, from, to, size, tag);
  }

  void altadjust(nodeidx_t from, nodeidx_t to, nodeidx_t size, bool (idaapi *should_skip)(nodeidx_t ea)=nullptr)
  {
    netnode_altadjust(*this, from, to, size, should_skip);
  }
  void altadjust2(nodeidx_t from, nodeidx_t to, nodeidx_t size, altadjust_visitor_t &av)
  {
    netnode_altadjust2(*this, from, to, size, av);
  }
 


  uchar charval(nodeidx_t alt, uchar tag) const      { return netnode_charval(*this, alt, tag); }
  bool charset(nodeidx_t alt, uchar val, uchar tag)  { return supset(alt, &val, sizeof(val), tag); }
  bool chardel(nodeidx_t alt, uchar tag)             { return supdel(alt, tag); }
  uchar charval_ea(ea_t ea, uchar tag) const         { return netnode_charval(*this, ea, tag|NETMAP_IDX); }
  bool charset_ea(ea_t ea, uchar val, uchar tag)     { return netnode_supset(*this, ea, &val, sizeof(val), tag|NETMAP_IDX); }
  bool chardel_ea(ea_t ea, uchar tag)                { return netnode_supdel(*this, ea, tag|NETMAP_IDX); }
  nodeidx_t charfirst(uchar tag) const               { return supfirst(tag); }
  nodeidx_t charnext(nodeidx_t cur, uchar tag) const { return supnext(cur, tag); }
  nodeidx_t charlast(uchar tag) const                { return suplast(tag); }
  nodeidx_t charprev(nodeidx_t cur, uchar tag) const { return supprev(cur, tag); }
  size_t charshift(nodeidx_t from, nodeidx_t to, nodeidx_t size, uchar tag)
    { return netnode_charshift(*this, from, to, size, tag); }


  nodeidx_t altval_idx8(uchar alt, uchar tag) const   { return netnode_altval_idx8(*this, alt, tag); }
  bool altset_idx8(uchar alt, nodeidx_t val, uchar tag) { return supset_idx8(alt, &val, sizeof(val), tag); }
  bool altdel_idx8(uchar alt, uchar tag)              { return supdel_idx8(alt, tag); }
  nodeidx_t altfirst_idx8(uchar tag) const            { return supfirst_idx8(tag); }
  nodeidx_t altnext_idx8(uchar cur, uchar tag) const  { return supnext_idx8(cur, tag); }
  nodeidx_t altlast_idx8(uchar tag) const             { return suplast_idx8(tag); }
  nodeidx_t altprev_idx8(uchar cur, uchar tag) const  { return supprev_idx8(cur, tag); }

  uchar charval_idx8(uchar alt, uchar tag) const     { return netnode_charval_idx8(*this, alt, tag); }
  bool charset_idx8(uchar alt, uchar val, uchar tag) { return supset_idx8(alt, &val, sizeof(val), tag); }
  bool chardel_idx8(uchar alt, uchar tag)            { return supdel_idx8(alt, tag); }
  nodeidx_t charfirst_idx8(uchar tag) const          { return supfirst_idx8(tag); }
  nodeidx_t charnext_idx8(uchar cur, uchar tag) const { return supnext_idx8(cur, tag); }
  nodeidx_t charlast_idx8(uchar tag) const           { return suplast_idx8(tag); }
  nodeidx_t charprev_idx8(uchar cur, uchar tag) const { return supprev_idx8(cur, tag); }


  bool altdel(void)
  {
    return supdel_all(atag);
  }

  bool altdel_all(uchar tag=atag)
  {
    return supdel_all(tag);
  }

 
  //--------------------------------------------------------------------------

  ssize_t supval(nodeidx_t alt, void *buf, size_t bufsize, uchar tag=stag) const
        { return netnode_supval(*this, alt, buf, bufsize, tag); }
  ssize_t supval_ea(ea_t ea, void *buf, size_t bufsize, uchar tag=stag) const
        { return netnode_supval(*this, ea, buf, bufsize, tag|NETMAP_IDX); }

  ssize_t supstr(qstring *buf, nodeidx_t alt, uchar tag=stag) const
        { return netnode_qsupstr(*this, buf, alt, tag); }
  ssize_t supstr_ea(qstring *buf, ea_t ea, uchar tag=stag) const
        { return netnode_qsupstr(*this, buf, ea, tag|NETMAP_IDX); }

  ssize_t supstr(nodeidx_t alt, char *buf, size_t bufsize, uchar tag=stag) const
        { return netnode_supstr(*this, alt, buf, bufsize, tag); }
  ssize_t supstr_ea(ea_t ea, char *buf, size_t bufsize, uchar tag=stag) const
        { return netnode_supstr(*this, ea, buf, bufsize, tag|NETMAP_IDX); }

  bool supset(nodeidx_t alt, const void *value, size_t length=0, uchar tag=stag)
        { return netnode_supset(*this, alt, value, length, tag); }
  bool supset_ea(ea_t ea, const void *value, size_t length=0, uchar tag=stag)
        { return netnode_supset(*this, ea, value, length, tag|NETMAP_IDX); }

  bool supdel(nodeidx_t alt, uchar tag=stag)
        { return netnode_supdel(*this, alt, tag); }
  bool supdel_ea(ea_t ea, uchar tag=stag)
        { return netnode_supdel(*this, ea, tag|NETMAP_IDX); }

  nodeidx_t lower_bound(nodeidx_t cur, uchar tag=stag) const
        { return netnode_lower_bound(*this, cur, tag); }
  nodeidx_t lower_bound_ea(ea_t ea, uchar tag=stag) const
        { return netnode_lower_bound(*this, ea, tag|NETMAP_IDX); }

  nodeidx_t supfirst(uchar tag=stag) const
        { return netnode_supfirst(*this, tag); }

  nodeidx_t supnext(nodeidx_t cur, uchar tag=stag) const
        { return netnode_supnext(*this, cur, tag); }

  nodeidx_t suplast(uchar tag=stag) const
        { return netnode_suplast(*this, tag); }

  nodeidx_t supprev(nodeidx_t cur, uchar tag=stag) const
        { return netnode_supprev(*this, cur, tag); }
 

  size_t supshift(nodeidx_t from, nodeidx_t to, nodeidx_t size, uchar tag=stag)
    { return netnode_supshift(*this, from, to, size, tag); }


  ssize_t   supval_idx8(uchar alt, void *buf, size_t bufsize, uchar tag) const { return netnode_supval_idx8(*this, alt, buf, bufsize, tag); }
  ssize_t   supstr_idx8(uchar alt, char *buf, size_t bufsize, uchar tag) const { return netnode_supstr_idx8(*this, alt, buf, bufsize, tag); }
  ssize_t   supstr_idx8(qstring *buf, uchar alt, uchar tag) const { return netnode_qsupstr_idx8(*this, buf, alt, tag); }
  bool     supset_idx8(uchar alt, const void *value, size_t length, uchar tag) { return netnode_supset_idx8(*this, alt, value, length, tag); }
  bool     supdel_idx8(uchar alt, uchar tag)        { return netnode_supdel_idx8(*this, alt, tag); }
  nodeidx_t lower_bound_idx8(uchar alt, uchar tag) const { return netnode_lower_bound_idx8(*this, alt, tag); }
  nodeidx_t supfirst_idx8(uchar tag) const           { return netnode_supfirst_idx8(*this, tag); }
  nodeidx_t supnext_idx8(uchar alt, uchar tag) const { return netnode_supnext_idx8(*this, alt, tag); }
  nodeidx_t suplast_idx8(uchar tag) const            { return netnode_suplast_idx8(*this, tag); }
  nodeidx_t supprev_idx8(uchar alt, uchar tag) const { return netnode_supprev_idx8(*this, alt, tag); }


  bool supdel(void)
  {
    return supdel_all(stag);
  }

  bool supdel_all(uchar tag)
  {
    return netnode_supdel_all(*this, tag);
  }

  int supdel_range(nodeidx_t idx1, nodeidx_t idx2, uchar tag)
  {
    return netnode_supdel_range(*this, idx1, idx2, tag);
  }

  int supdel_range_idx8(uchar idx1, uchar idx2, uchar tag)
  {
    return netnode_supdel_range_idx8(*this, idx1, idx2, tag);
  }

 
  //--------------------------------------------------------------------------

  ssize_t hashval(const char *idx, void *buf, size_t bufsize, uchar tag=htag) const
        { return netnode_hashval(*this, idx, buf, bufsize, tag); }

  ssize_t hashstr(qstring *buf, const char *idx, uchar tag=htag) const
        { return netnode_qhashstr(*this, buf, idx, tag); }

  ssize_t hashstr(const char *idx, char *buf, size_t bufsize, uchar tag=htag) const
        { return netnode_hashstr(*this, idx, buf, bufsize, tag); }

  nodeidx_t hashval_long(const char *idx, uchar tag=htag) const
        { return netnode_hashval_long(*this, idx, tag); }

  bool hashset(const char *idx, const void *value, size_t length=0, uchar tag=htag)
        { return netnode_hashset(*this, idx, value, length, tag); }

  bool hashset(const char *idx, nodeidx_t value, uchar tag=htag)
        { return hashset(idx, &value, sizeof(value), tag); }

  bool hashdel(const char *idx, uchar tag=htag)
        { return netnode_hashdel(*this, idx, tag); }

  ssize_t hashfirst(qstring *buf, uchar tag=htag) const
        { return netnode_qhashfirst(*this, buf, tag); }

  ssize_t hashfirst(char *buf, size_t bufsize, uchar tag=htag) const
        { return netnode_hashfirst(*this, buf, bufsize, tag); }

  ssize_t hashnext(qstring *buf, const char *idx, uchar tag=htag) const
        { return netnode_qhashnext(*this, buf, idx, tag); }

  ssize_t hashnext(const char *idx, char *buf, size_t bufsize, uchar tag=htag) const
        { return netnode_hashnext(*this, idx, buf, bufsize, tag); }

  ssize_t hashlast(qstring *buf, uchar tag=htag) const
        { return netnode_qhashlast(*this, buf, tag); }

  ssize_t hashlast(char *buf, size_t bufsize, uchar tag=htag) const
        { return netnode_hashlast(*this, buf, bufsize, tag); }

  ssize_t hashprev(qstring *buf, const char *idx, uchar tag=htag) const
        { return netnode_qhashprev(*this, buf, idx, tag); }

  ssize_t hashprev(const char *idx, char *buf, size_t bufsize, uchar tag=htag) const
        { return netnode_hashprev(*this, idx, buf, bufsize, tag); }

  bool hashdel_all(uchar tag=htag)
  {
    return supdel_all(tag);
  }

 
  //--------------------------------------------------------------------------

  size_t blobsize(nodeidx_t _start, uchar tag)
  {
    return netnode_blobsize(*this, _start, tag);
  }
  size_t blobsize_ea(ea_t ea, uchar tag)
  {
    return netnode_blobsize(*this, ea, tag|NETMAP_IDX);
  }

  void *getblob(
        void *buf,
        size_t *bufsize,
        nodeidx_t _start,
        uchar tag)
  {
    return netnode_getblob(*this, buf, bufsize, _start, tag);
  }
  void *getblob_ea(
        void *buf,
        size_t *bufsize,
        ea_t ea,
        uchar tag)
  {
    return netnode_getblob(*this, buf, bufsize, ea, tag|NETMAP_IDX);
  }

  template <class T>
  ssize_t getblob(
        qvector<T> *blob,
        nodeidx_t _start,
        uchar tag)
  {
    return netnode_qgetblob(*this, (bytevec_t *)blob, sizeof(T), _start, tag);
  }
  template <class T>
  ssize_t getblob_ea(
        qvector<T> *blob,
        ea_t ea,
        uchar tag)
  {
    return netnode_qgetblob(*this, (bytevec_t *)blob, sizeof(T), nodeidx_t(ea), tag|NETMAP_IDX);
  }

  ssize_t getblob(
        qstring *buf,
        nodeidx_t _start,
        uchar tag)
  {
    return netnode_qgetblob(*this, (bytevec_t *)buf, 1, _start, tag|NETMAP_STR);
  }

  bool setblob(
        const void *buf,
        size_t size,
        nodeidx_t _start,
        uchar tag)
  {
    return netnode_setblob(*this, buf, size, _start, tag);
  }
  bool setblob_ea(
        const void *buf,
        size_t size,
        ea_t ea,
        uchar tag)
  {
    return netnode_setblob(*this, buf, size, ea, tag|NETMAP_IDX);
  }

  int delblob(nodeidx_t _start, uchar tag)
  {
    return netnode_delblob(*this, _start, tag);
  }
  int delblob_ea(ea_t ea, uchar tag)
  {
    return netnode_delblob(*this, ea, tag|NETMAP_IDX);
  }

  size_t blobshift(nodeidx_t from, nodeidx_t to, nodeidx_t size, uchar tag)
  {
    return netnode_blobshift(*this, from, to, size, tag);
  }

 
  //--------------------------------------------------------------------------

  bool start(void)
  {
    return netnode_start(this);
  }

  bool end(void)
  {
    return netnode_end(this);
  }

  bool next(void)
  {
    return netnode_next(this);
  }

  bool prev(void)
  {
    return netnode_prev(this);
  }

 
  //--------------------------------------------------------------------------
  size_t copyto(netnode destnode, nodeidx_t count=1) { return netnode_copy(netnodenumber, count, destnode.netnodenumber, false); }
  size_t moveto(netnode destnode, nodeidx_t count=1) { return netnode_copy(netnodenumber, count, destnode.netnodenumber, true); }
 
  //--------------------------------------------------------------------------
  bool operator==(netnode &n) const { return netnodenumber == n.netnodenumber; }
  bool operator!=(netnode &n) const { return netnodenumber != n.netnodenumber; }
  bool operator==(nodeidx_t x) const { return netnodenumber == x; }
  bool operator!=(nodeidx_t x) const { return netnodenumber != x; }
 
 
  static bool inited(void)       { return netnode_inited(); }
  static bool is_available(void) { return netnode_is_available(); }
 
private:
  // The netnode number.
  // Usually this is the linear address that the netnode keeps information about.
  nodeidx_t netnodenumber;
};
#ifdef __EA64__
CASSERT(sizeof(netnode) == 8);
#else
CASSERT(sizeof(netnode) == 4);
#endif
 
 
#endif // _NETNODE_HPP