dirtree.hpp

Go to the documentation of this file.

 
#ifndef DIRTREE_HPP
#define DIRTREE_HPP
 
//------------------------------------------------------------------------
typedef qvector<inode_t> inodevec_t; // sequence of inodes

typedef uval_t diridx_t;
typedef qvector<diridx_t> dirvec_t; // sequence of directory indexes

typedef ea_t blob_idx_t;
#define BAD_BLOB_IDX blob_idx_t(-1)
 
// We use PACKED to save memory, without it we would spend 64 bits instead of
// 8 bits to store a 1-bit value on ida64.
#pragma pack(push, 1)

struct PACKED direntry_t
{
  uval_t idx;   
  bool isdir;   
 
  static const uval_t BADIDX = uval_t(-1);
  static const uval_t ROOTIDX = 0;
 
  direntry_t(uval_t i=BADIDX, bool d=false) : idx(i), isdir(d) {}
  bool valid() const { return idx != BADIDX; }
 
  bool operator==(const direntry_t &r) const
  {
    return idx == r.idx && isdir == r.isdir;
  }
  bool operator!=(const direntry_t &r) const
  {
    return !(*this == r);
  }
  bool operator<(const direntry_t &r) const
  {
    if ( isdir != r.isdir )
      return isdir;   // any folder is lesser than any inode
    return idx < r.idx;
  }
  bool operator>=(const direntry_t &r) const { return !(*this < r); }
};
#pragma pack(pop)
DECLARE_TYPE_AS_MOVABLE(direntry_t);
typedef qvector<direntry_t> direntry_vec_t;

enum
{
  DTN_FULL_NAME    = 0x00,  
  DTN_DISPLAY_NAME = 0x01,  
};

static constexpr char DIRTREE_FOLDED_SEP = '\x1d';  // ASCII GS

inline void dirtree_restore_prefix_sep(qstring *s)
{
  char from[2] = { DIRTREE_FOLDED_SEP, '\0' };
  s->replace(from, "/");
}
 
//------------------------------------------------------------------------
struct dirspec_t
{
  uint32 dsf_flags;
  enum
  {
    DSF_INODE_EA  = 0x01,  // inode is EA, will be handled during segment moving
    DSF_PRIVRANGE = 0x02,  // inode is tid_t, structure or enum id, will be handled during segment moving
    DSF_ORDERABLE = 0x04,  // items in a folder are ordered by increasing inode # (unless explicitly reordered)
    DSF_UNQ_NAMES = 0x08,  // inode names are globally unique; this is implied for DSF_INODE_EA and DSF_PRIVRANGE
  };
  // netnode name to load/save directory tree
  // If not specified the loading/storing operations are not supported
  // and the undo functionality is not supported.
  qstring id;
 
  dirspec_t(const char *nm=nullptr, uint32 f=0) : dsf_flags(f), id(nm) {}
 
  virtual ~dirspec_t() {}

  virtual bool get_name(
        qstring *out,
        inode_t inode,
        uint32 name_flags=DTN_FULL_NAME) = 0;

  virtual inode_t get_inode(const char *dirpath, const char *name) = 0;
 
  // print additional attributes of the entry. for example, is union? is mapped?
  virtual qstring get_attrs(inode_t inode) const = 0;

  virtual bool rename_inode(inode_t inode, const char *newname) = 0;

  virtual void unlink_inode(inode_t inode) { qnotused(inode); }
 
  bool is_orderable() const { return (dsf_flags & DSF_ORDERABLE) != 0; }
  bool unique_names() const { return (dsf_flags & (DSF_INODE_EA|DSF_PRIVRANGE|DSF_UNQ_NAMES)) != 0; }
  bool has_inode_ea() const { return (dsf_flags & DSF_INODE_EA) != 0; }
};
 
//------------------------------------------------------------------------
struct dirtree_cursor_t
{
  diridx_t parent; 
  size_t rank;     
  dirtree_cursor_t(diridx_t _parent=direntry_t::BADIDX, size_t _rank=size_t(-1))
    : parent(_parent), rank(_rank) {}
  bool valid() const { return parent != direntry_t::BADIDX || rank == 0; }
  bool is_root_cursor() const { return parent == direntry_t::BADIDX && rank == 0; }
  void set_root_cursor() { parent = direntry_t::BADIDX; rank = 0; }
  void swap(dirtree_cursor_t &r)
  {
    qswap(parent, r.parent);
    qswap(rank, r.rank);
  }
 
  static dirtree_cursor_t root_cursor()
  {
    dirtree_cursor_t c;
    c.set_root_cursor();
    return c;
  }
 
  DECLARE_COMPARISONS(dirtree_cursor_t)
  {
    if ( parent < r.parent ) return -1;
    if ( parent > r.parent ) return 1;
    if ( rank < r.rank ) return -1;
    if ( rank > r.rank ) return 1;
    return 0;
  }
};
DECLARE_TYPE_AS_MOVABLE(dirtree_cursor_t);
typedef qvector<dirtree_cursor_t> dirtree_cursor_vec_t;
 
//-------------------------------------------------------------------------
struct dirtree_selection_t : public dirtree_cursor_vec_t {};
 
//------------------------------------------------------------------------
struct dirtree_iterator_t
{
  qstring pattern;
  dirtree_cursor_t cursor;
};
 
//------------------------------------------------------------------------
enum dterr_t : uint8
{
  DTE_OK,               
  DTE_ALREADY_EXISTS,   
  DTE_NOT_FOUND,        
  DTE_NOT_DIRECTORY,    
  DTE_NOT_EMPTY,        
  DTE_BAD_PATH,         
  DTE_CANT_RENAME,      
  DTE_OWN_CHILD,        
  DTE_MAX_DIR,          
  DTE_NOT_ORDERABLE,    
  DTE_LAST,
};
 
struct dirtree_bulk_result_t
{
  diridx_t parent;  // parent directory
  direntry_t entry; // entry inside the directory
  dterr_t err;      // error code for the item
  int idx;          // index into the vector of input vector
                    // (useful if parent/entry are wrong)
};
DECLARE_TYPE_AS_MOVABLE(dirtree_bulk_result_t);
typedef qvector<dirtree_bulk_result_t> dirtree_bulk_results_t;
 
class dirtree_t;
class dirtree_impl_t;
struct segm_move_infos_t;
 
//-------------------------------------------------------------------------
struct dirtree_visitor_t
{
  virtual ~dirtree_visitor_t() {}
  virtual ssize_t visit(
        const dirtree_cursor_t &c,
        const direntry_t &de) = 0;
};
 

//------------------------------------------------------------------------
// internal functions; use dirtree_t members instead
#ifndef SWIG
idaman dirtree_impl_t *ida_export create_dirtree(dirtree_t *dt, dirspec_t *ds);
idaman void ida_export delete_dirtree(dirtree_impl_t *d);
idaman bool ida_export load_dirtree(dirtree_impl_t *d);
idaman bool ida_export save_dirtree(dirtree_impl_t *d);
idaman void ida_export reset_dirtree(dirtree_impl_t *d);
idaman const char *ida_export dirtree_errstr(dterr_t err);
idaman bool ida_export dirtree_is_orderable(const dirtree_impl_t *d);
idaman dterr_t ida_export dirtree_chdir(dirtree_impl_t *d, const char *path);
idaman void ida_export dirtree_getcwd(qstring *out, const dirtree_impl_t *d);
idaman void ida_export dirtree_resolve_path(direntry_t *de, const dirtree_impl_t *d, const char *path);
idaman void ida_export dirtree_resolve_cursor(direntry_t *de, const dirtree_impl_t *d, const dirtree_cursor_t &cursor);
idaman void ida_export dirtree_make_cursor(dirtree_cursor_t *cursor, const dirtree_impl_t *d, const char *path);
idaman bool ida_export dirtree_get_entry_name(qstring *out, const dirtree_impl_t *d, const direntry_t &de, uint32 name_flags);
idaman void ida_export dirtree_get_entry_attrs(qstring *out, const dirtree_impl_t *d, const direntry_t &de);
idaman bool ida_export dirtree_is_dir_ordered(const dirtree_impl_t *d, diridx_t diridx);
idaman dterr_t ida_export dirtree_set_natural_order(dirtree_impl_t *d, diridx_t diridx, bool enable);
idaman ssize_t ida_export dirtree_get_dir_size(dirtree_impl_t *d, diridx_t diridx);
idaman bool ida_export dirtree_findfirst(dirtree_impl_t *d, dirtree_iterator_t *ff, const char *pattern);
idaman bool ida_export dirtree_findnext(dirtree_impl_t *d, dirtree_iterator_t *ff);
idaman bool ida_export dirtree_get_abspath_by_cursor(qstring *out, const dirtree_impl_t *d, const dirtree_cursor_t &cursor, uint32 name_flags);
idaman bool ida_export dirtree_get_abspath_by_relpath(qstring *out, const dirtree_impl_t *d, const char *relpath);
idaman dterr_t ida_export dirtree_mkdir(dirtree_impl_t *d, const char *path);
idaman dterr_t ida_export dirtree_rmdir(dirtree_impl_t *d, const char *path);
idaman dterr_t ida_export dirtree_fold_common_prefix(dirtree_impl_t *d, const char *path, char sep);
idaman dterr_t ida_export dirtree_link(dirtree_impl_t *d, const char *path, bool do_link);
idaman dterr_t ida_export dirtree_link_inode(dirtree_impl_t *d, inode_t inode, bool do_link);
idaman dterr_t ida_export dirtree_rename(dirtree_impl_t *d, const char *from, const char *to);
idaman dterr_t ida_export dirtree_bulk_move(dirtree_impl_t *d, const dirtree_cursor_vec_t &items, const char *dstdir, int dst_rank, dirtree_cursor_vec_t *moved_items, dirtree_bulk_results_t *errs);
idaman dterr_t ida_export dirtree_bulk_remove(dirtree_impl_t *d, const dirtree_cursor_vec_t &items, dirtree_bulk_results_t *errs);
idaman ssize_t ida_export dirtree_get_rank(const dirtree_impl_t *d, diridx_t diridx, const direntry_t &de);
idaman dterr_t ida_export dirtree_change_rank(dirtree_impl_t *d, const char *path, ssize_t rank_delta);
idaman void ida_export dirtree_get_parent_cursor(dirtree_cursor_t *out, const dirtree_impl_t *d, const dirtree_cursor_t &cursor);
idaman void ida_export notify_dirtree(dirtree_impl_t *d, bool added, inode_t inode);
idaman const char *ida_export dirtree_get_id(const dirtree_impl_t *d);
idaman void ida_export dirtree_set_id(dirtree_impl_t *d, const char *nm);
idaman const char *ida_export dirtree_get_nodename(const dirtree_impl_t *d);   // compat
idaman void ida_export dirtree_set_nodename(dirtree_impl_t *d, const char *nm);// compat
idaman ssize_t ida_export dirtree_traverse(dirtree_impl_t *d, dirtree_visitor_t &v);
idaman dterr_t ida_export dirtree_find_entry(dirtree_cursor_t *out, const dirtree_t *_dt, const direntry_t &_de);
idaman dirtree_t *ida_export dirtree_new_shadow_dirtree(dirtree_impl_t *d);
idaman void ida_export dirtree_add_event_handler(dirtree_impl_t *d, class event_handler_t *h);
idaman bool ida_export dirtree_remove_event_handler(dirtree_impl_t *d, class event_handler_t *h);
#endif // SWIG
 

 
//------------------------------------------------------------------------
class dirtree_t
{
  dirtree_impl_t *d;
 
  friend struct dirtree_internal_t;
 
public:
  //lint -sem(dirtree_t::dirtree_t, custodial(1))
  dirtree_t(dirspec_t *ds) { d = create_dirtree(this, ds); }
  dirtree_t(dirtree_impl_t *di) { d = di; }
  ~dirtree_t() { delete_dirtree(d); }

  static const char *errstr(dterr_t err) { return dirtree_errstr(err); }

  bool is_orderable() const { return dirtree_is_orderable(d); }

  dterr_t chdir(const char *path) { return dirtree_chdir(d, path); }

  qstring getcwd() const
  {
    qstring out;
    dirtree_getcwd(&out, d);
    return out;
  }

  qstring get_abspath(const dirtree_cursor_t &cursor, uint32 name_flags=DTN_FULL_NAME) const
  {
    qstring out;
    dirtree_get_abspath_by_cursor(&out, d, cursor, name_flags);
    return out;
  }

  qstring get_abspath(const char *relpath) const
  {
    qstring out;
    dirtree_get_abspath_by_relpath(&out, d, relpath);
    return out;
  }

  direntry_t resolve_cursor(const dirtree_cursor_t &cursor) const
  {
    direntry_t de;
    dirtree_resolve_cursor(&de, d, cursor);
    return de;
  }

  dirtree_cursor_t make_cursor(const char *path) const
  {
    dirtree_cursor_t cursor;
    dirtree_make_cursor(&cursor, d, path);
    return cursor;
  }

  direntry_t resolve_path(const char *path) const
  {
    direntry_t de;
    dirtree_resolve_path(&de, d, path);
    return de;
  }
 
  static bool isdir(const direntry_t &de) { return de.valid() && de.isdir; }
  static bool isfile(const direntry_t &de) { return de.valid() && !de.isdir; }

  bool isdir(const char *path) const
  {
    direntry_t de = resolve_path(path);
    return isdir(de);
  }

  bool isfile(const char *path) const
  {
    direntry_t de = resolve_path(path);
    return isfile(de);
  }

  qstring get_entry_name(
        const direntry_t &de,
        uint32 name_flags=DTN_FULL_NAME) const
  {
    qstring out;
    dirtree_get_entry_name(&out, d, de, name_flags);
    return out;
  }

  bool is_dir_ordered(diridx_t diridx) const { return dirtree_is_dir_ordered(d, diridx); }

  dterr_t set_natural_order(diridx_t diridx, bool enable) const
  {
    return dirtree_set_natural_order(d, diridx, enable);
  }

  ssize_t get_dir_size(diridx_t diridx) const { return dirtree_get_dir_size(d, diridx); }

  qstring get_entry_attrs(const direntry_t &de) const
  {
    qstring out;
    dirtree_get_entry_attrs(&out, d, de);
    return out;
  }

  bool findfirst(dirtree_iterator_t *ff, const char *pattern) const
  {
    return dirtree_findfirst(d, ff, pattern);
  }

  bool findnext(dirtree_iterator_t *ff) const
  {
    return dirtree_findnext(d, ff);
  }

  dterr_t mkdir(const char *path) { return dirtree_mkdir(d, path); }

  dterr_t rmdir(const char *path) { return dirtree_rmdir(d, path); }

  dterr_t link(const char *path) { return dirtree_link(d, path, true); }

  dterr_t unlink(const char *path) { return dirtree_link(d, path, false); }

  dterr_t link(inode_t inode) { return dirtree_link_inode(d, inode, true); }

  dterr_t unlink(inode_t inode) { return dirtree_link_inode(d, inode, false); }

  dterr_t rename(const char *from, const char *to)
  {
    return dirtree_rename(d, from, to);
  }

  dterr_t fold_common_prefix(
        const char *path=nullptr,
        char sep=DIRTREE_FOLDED_SEP)
  {
    return dirtree_fold_common_prefix(d, path, sep);
  }

  dterr_t bulk_move(
        const dirtree_cursor_vec_t &items,
        const char *dstdir,
        ssize_t dst_rank=-1,
        dirtree_cursor_vec_t *moved_items=nullptr,
        dirtree_bulk_results_t *errs=nullptr)
  {
    return dirtree_bulk_move(d, items, dstdir, int(dst_rank), moved_items, errs);
  }

  dterr_t bulk_remove(
        const dirtree_cursor_vec_t &items,
        dirtree_bulk_results_t *errs=nullptr)
  {
    return dirtree_bulk_remove(d, items, errs);
  }

  ssize_t get_rank(diridx_t diridx, const direntry_t &de) const
  {
    return dirtree_get_rank(d, diridx, de);
  }

  dterr_t change_rank(const char *path, ssize_t rank_delta)
  {
    return dirtree_change_rank(d, path, rank_delta);
  }

  dirtree_cursor_t get_parent_cursor(const dirtree_cursor_t &cursor) const
  {
    dirtree_cursor_t parent;
    dirtree_get_parent_cursor(&parent, d, cursor);
    return parent;
  }

  bool load()
  {
    return load_dirtree(d);
  }

  bool save() const
  {
    return save_dirtree(d);
  }

  const char *get_id() const
  {
    return dirtree_get_id(d);
  }
 
  void set_id(const char *nm)
  {
    return dirtree_set_id(d, nm);
  }

  void notify_dirtree(bool added, inode_t inode)
  {
    ::notify_dirtree(d, added, inode);
  }

  ssize_t traverse(dirtree_visitor_t &v) const
  {
    return dirtree_traverse(d, v);
  }

  dirtree_cursor_t find_entry(const direntry_t &de) const
  {
    dirtree_cursor_t c;
    dirtree_find_entry(&c, this, de);
    return c;
  }
 
};

enum dirtree_id_t
{
  DIRTREE_LOCAL_TYPES,
  DIRTREE_FUNCS,
  DIRTREE_NAMES,
  DIRTREE_IMPORTS,
  DIRTREE_IDAPLACE_BOOKMARKS,
  DIRTREE_BPTS,
  DIRTREE_LTYPES_BOOKMARKS,
  DIRTREE_SNIPPETS,                
  DIRTREE_END,
};
idaman dirtree_t *ida_export get_std_dirtree(dirtree_id_t id);
 
 
#endif // define DIRTREE_HPP