class.c File Reference

#include <rz_analysis.h>
#include <rz_vector.h>
#include <rz_util/rz_graph_drawable.h>
#include <rz_util/rz_table.h>
#include "../include/rz_util/rz_graph.h"

Go to the source code of this file.

Classes
struct	DeleteClassCtx
struct	RenameClassCtx

Enumerations
enum	RzAnalysisClassAttrType { RZ_ANALYSIS_CLASS_ATTR_TYPE_METHOD , RZ_ANALYSIS_CLASS_ATTR_TYPE_VTABLE , RZ_ANALYSIS_CLASS_ATTR_TYPE_BASE }

Functions
static void	rz_analysis_class_base_delete_class (RzAnalysis *analysis, const char *class_name)
static void	rz_analysis_class_method_delete_class (RzAnalysis *analysis, const char *class_name)
static void	rz_analysis_class_vtable_delete_class (RzAnalysis *analysis, const char *class_name)
static void	rz_analysis_class_base_rename_class (RzAnalysis *analysis, const char *class_name_old, const char *class_name_new)
static void	rz_analysis_class_method_rename_class (RzAnalysis *analysis, const char *old_class_name, const char *new_class_name)
static void	rz_analysis_class_vtable_rename_class (RzAnalysis *analysis, const char *old_class_name, const char *new_class_name)
static const char *	key_class (const char *name)
static char *	key_attr_types (const char *name)
static char *	key_attr_type_attrs (const char *class_name, const char *attr_type)
static char *	key_attr_content (const char *class_name, const char *attr_type, const char *attr_id)
static char *	key_attr_content_specific (const char *class_name, const char *attr_type, const char *attr_id)
static const char *	attr_type_id (RzAnalysisClassAttrType attr_type)
RZ_API void	rz_analysis_class_recover_from_rzbin (RzAnalysis *analysis)
RZ_API RzAnalysisClassErr	rz_analysis_class_create (RzAnalysis *analysis, const char *name)
RZ_API void	rz_analysis_class_delete (RzAnalysis *analysis, const char *name)
static bool	rz_analysis_class_exists_raw (RzAnalysis *analysis, const char *name)
RZ_API bool	rz_analysis_class_exists (RzAnalysis *analysis, const char *name)
RZ_API SdbList *	rz_analysis_class_get_all (RzAnalysis *analysis, bool sorted)
RZ_API void	rz_analysis_class_foreach (RzAnalysis *analysis, SdbForeachCallback cb, void *user)
static bool	rename_key (Sdb *sdb, const char *key_old, const char *key_new)
RZ_API RzAnalysisClassErr	rz_analysis_class_rename (RzAnalysis *analysis, const char *old_name, const char *new_name)
static char *	rz_analysis_class_get_attr_raw (RzAnalysis *analysis, const char *class_name, RzAnalysisClassAttrType attr_type, const char *attr_id, bool specific)
static char *	rz_analysis_class_get_attr (RzAnalysis *analysis, const char *class_name, RzAnalysisClassAttrType attr_type, const char *attr_id, bool specific)
static RzAnalysisClassErr	rz_analysis_class_set_attr_raw (RzAnalysis *analysis, const char *class_name, RzAnalysisClassAttrType attr_type, const char *attr_id, const char *content)
static RzAnalysisClassErr	rz_analysis_class_set_attr (RzAnalysis *analysis, const char *class_name, RzAnalysisClassAttrType attr_type, const char *attr_id, const char *content)
static RzAnalysisClassErr	rz_analysis_class_delete_attr_raw (RzAnalysis *analysis, const char *class_name, RzAnalysisClassAttrType attr_type, const char *attr_id)
static RzAnalysisClassErr	rz_analysis_class_delete_attr (RzAnalysis *analysis, const char *class_name, RzAnalysisClassAttrType attr_type, const char *attr_id)
static RzAnalysisClassErr	rz_analysis_class_rename_attr_raw (RzAnalysis *analysis, const char *class_name, RzAnalysisClassAttrType attr_type, const char *attr_id_old, const char *attr_id_new)
static RzAnalysisClassErr	rz_analysis_class_rename_attr (RzAnalysis *analysis, const char *class_name, RzAnalysisClassAttrType attr_type, const char *attr_id_old, const char *attr_id_new)
static void	rz_analysis_class_unique_attr_id_raw (RzAnalysis *analysis, const char *class_name, RzAnalysisClassAttrType attr_type, char *out, size_t out_size)
static char *	flagname_attr (const char *attr_type, const char *class_name, const char *attr_id)
static void	rz_analysis_class_set_flag (RzAnalysis *analysis, const char *name, ut64 addr, ut32 size)
static void	rz_analysis_class_unset_flag (RzAnalysis *analysis, const char *name)
static void	rz_analysis_class_rename_flag (RzAnalysis *analysis, const char *old_name, const char *new_name)
static RzAnalysisClassErr	rz_analysis_class_add_attr_unique_raw (RzAnalysis *analysis, const char *class_name, RzAnalysisClassAttrType attr_type, const char *content, char *attr_id_out, size_t attr_id_out_size)
static RzAnalysisClassErr	rz_analysis_class_add_attr_unique (RzAnalysis *analysis, const char *class_name, RzAnalysisClassAttrType attr_type, const char *content, char *attr_id_out, size_t attr_id_out_size)
static int	symbol_method_sort_by_addr (const void *x, const void *y)
static char *	flagname_method (const char *class_name, const char *meth_name)
RZ_API void	rz_analysis_class_method_fini (RzAnalysisMethod *meth)
RZ_API void	rz_analysis_class_method_recover (RzAnalysis *analysis, RzBinClass *cls, RzList *methods)
RZ_API bool	rz_analysis_class_method_exists (RzAnalysis *analysis, const char *class_name, const char *meth_name)
RZ_API bool	rz_analysis_class_method_exists_by_addr (RzAnalysis *analysis, const char *class_name, ut64 addr)
RZ_API RzAnalysisClassErr	rz_analysis_class_method_get_by_addr (RzAnalysis *analysis, const char *class_name, ut64 addr, RzAnalysisMethod *method)
RZ_API RzAnalysisClassErr	rz_analysis_class_method_get (RzAnalysis *analysis, const char *class_name, const char *meth_name, RzAnalysisMethod *meth)
static void	rz_analysis_class_method_fini_proxy (void *e, void *user)
RZ_API RzVector *	rz_analysis_class_method_get_all (RzAnalysis *analysis, const char *class_name)
RZ_API RzAnalysisClassErr	rz_analysis_class_method_set (RzAnalysis *analysis, const char *class_name, RzAnalysisMethod *meth)
RZ_API RzAnalysisClassErr	rz_analysis_class_method_rename (RzAnalysis *analysis, const char *class_name, const char *old_meth_name, const char *new_meth_name)
RZ_API RzAnalysisClassErr	rz_analysis_class_method_delete (RzAnalysis *analysis, const char *class_name, const char *meth_name)
RZ_API void	rz_analysis_class_base_fini (RzAnalysisBaseClass *base)
RZ_API RzAnalysisClassErr	rz_analysis_class_base_get (RzAnalysis *analysis, const char *class_name, const char *base_id, RzAnalysisBaseClass *base)
static void	rz_analysis_class_base_fini_proxy (void *e, void *user)
RZ_API RzVector *	rz_analysis_class_base_get_all (RzAnalysis *analysis, const char *class_name)
static RzAnalysisClassErr	rz_analysis_class_base_set_raw (RzAnalysis *analysis, const char *class_name, RzAnalysisBaseClass *base, const char *base_class_name_sanitized)
RZ_API RzAnalysisClassErr	rz_analysis_class_base_set (RzAnalysis *analysis, const char *class_name, RzAnalysisBaseClass *base)
RZ_API RzAnalysisClassErr	rz_analysis_class_base_delete (RzAnalysis *analysis, const char *class_name, const char *base_id)
static bool	rz_analysis_class_base_delete_class_cb (void *user, const char *k, const char *v)
static bool	rz_analysis_class_base_rename_class_cb (void *user, const char *k, const char *v)
static char *	flagname_vtable (const char *class_name, const char *vtable_id)
RZ_API void	rz_analysis_class_vtable_fini (RzAnalysisVTable *vtable)
RZ_API RzAnalysisClassErr	rz_analysis_class_vtable_get (RzAnalysis *analysis, const char *class_name, const char *vtable_id, RzAnalysisVTable *vtable)
static void	rz_analysis_class_vtable_fini_proxy (void *e, void *user)
RZ_API RzVector *	rz_analysis_class_vtable_get_all (RzAnalysis *analysis, const char *class_name)
RZ_API RzAnalysisClassErr	rz_analysis_class_vtable_set (RzAnalysis *analysis, const char *class_name, RzAnalysisVTable *vtable)
RZ_API RzAnalysisClassErr	rz_analysis_class_vtable_delete (RzAnalysis *analysis, const char *class_name, const char *vtable_id)
RZ_API RzGraph *	rz_analysis_class_get_inheritance_graph (RzAnalysis *analysis)
	Creates RzGraph from class inheritance information where each node has RzGraphNodeInfo as generic data. More...
RZ_API void	rz_analysis_class_recover_all (RzAnalysis *analysis)

Enumeration Type Documentation

RzAnalysisClassAttrType

enum RzAnalysisClassAttrType

Enumerator
RZ_ANALYSIS_CLASS_ATTR_TYPE_METHOD
RZ_ANALYSIS_CLASS_ATTR_TYPE_VTABLE
RZ_ANALYSIS_CLASS_ATTR_TYPE_BASE

Definition at line 38 of file class.c.

             {
    RZ_ANALYSIS_CLASS_ATTR_TYPE_METHOD,
    RZ_ANALYSIS_CLASS_ATTR_TYPE_VTABLE,
    RZ_ANALYSIS_CLASS_ATTR_TYPE_BASE
} RzAnalysisClassAttrType;

Function Documentation

attr_type_id()

static const char* attr_type_id ( RzAnalysisClassAttrType  attr_type )

static

Definition at line 44 of file class.c.

                                                                   {
    switch (attr_type) {
    case RZ_ANALYSIS_CLASS_ATTR_TYPE_METHOD:
        return "method";
    case RZ_ANALYSIS_CLASS_ATTR_TYPE_VTABLE:
        return "vtable";
    case RZ_ANALYSIS_CLASS_ATTR_TYPE_BASE:
        return "base";
    default:
        return NULL;
    }
}

References NULL, RZ_ANALYSIS_CLASS_ATTR_TYPE_BASE, RZ_ANALYSIS_CLASS_ATTR_TYPE_METHOD, and RZ_ANALYSIS_CLASS_ATTR_TYPE_VTABLE.

Referenced by rz_analysis_class_base_get_all(), rz_analysis_class_delete_attr_raw(), rz_analysis_class_get_attr_raw(), rz_analysis_class_method_delete_class(), rz_analysis_class_method_get_all(), rz_analysis_class_method_rename_class(), rz_analysis_class_rename_attr_raw(), rz_analysis_class_set_attr_raw(), rz_analysis_class_unique_attr_id_raw(), rz_analysis_class_vtable_delete_class(), rz_analysis_class_vtable_get_all(), and rz_analysis_class_vtable_rename_class().

flagname_attr()

static char* flagname_attr ( const char *  attr_type, const char *  class_name, const char *  attr_id  )

static

Definition at line 511 of file class.c.

                                                                                               {
    char *class_name_sanitized = rz_str_sanitize_sdb_key(class_name);
    if (!class_name_sanitized) {
        return NULL;
    }
    char *attr_id_sanitized = rz_str_sanitize_sdb_key(attr_id);
    if (!attr_id_sanitized) {
        free(class_name_sanitized);
        return NULL;
    }
    char *r = rz_str_newf("%s.%s.%s", attr_type, class_name, attr_id);
    free(class_name_sanitized);
    free(attr_id_sanitized);
    return r;
}

References free(), NULL, r, rz_str_newf(), and rz_str_sanitize_sdb_key().

Referenced by flagname_method(), and flagname_vtable().

flagname_method()

static char* flagname_method ( const char *  class_name, const char *  meth_name  )

static

Definition at line 599 of file class.c.

                                                                            {
    if (rz_str_startswith(meth_name, "method.")) {
        return rz_str_new(meth_name);
    }
    return flagname_attr("method", class_name, meth_name);
}

References flagname_attr(), rz_str_new(), and rz_str_startswith().

Referenced by rz_analysis_class_method_delete(), rz_analysis_class_method_delete_class(), rz_analysis_class_method_rename(), rz_analysis_class_method_rename_class(), and rz_analysis_class_method_set().

flagname_vtable()

static char* flagname_vtable ( const char *  class_name, const char *  vtable_id  )

static

Definition at line 1065 of file class.c.

                                                                            {
    return flagname_attr("vtable", class_name, vtable_id);
}

References flagname_attr().

Referenced by rz_analysis_class_vtable_delete(), rz_analysis_class_vtable_delete_class(), rz_analysis_class_vtable_rename_class(), and rz_analysis_class_vtable_set().

key_attr_content()

static char* key_attr_content ( const char *  class_name, const char *  attr_type, const char *  attr_id  )

static

Definition at line 30 of file class.c.

                                                                                                  {
    return rz_str_newf("attr.%s.%s.%s", class_name, attr_type, attr_id);
}

References rz_str_newf().

Referenced by rz_analysis_class_delete(), rz_analysis_class_delete_attr_raw(), rz_analysis_class_get_attr_raw(), rz_analysis_class_rename(), rz_analysis_class_rename_attr_raw(), and rz_analysis_class_set_attr_raw().

key_attr_content_specific()

static char* key_attr_content_specific ( const char *  class_name, const char *  attr_type, const char *  attr_id  )

static

Definition at line 34 of file class.c.

                                                                                                           {
    return rz_str_newf("attr.%s.%s.%s.specific", class_name, attr_type, attr_id);
}

References rz_str_newf().

Referenced by rz_analysis_class_delete(), rz_analysis_class_delete_attr_raw(), rz_analysis_class_get_attr_raw(), and rz_analysis_class_rename_attr_raw().

key_attr_type_attrs()

static char* key_attr_type_attrs ( const char *  class_name, const char *  attr_type  )

static

Definition at line 26 of file class.c.

                                                                                {
    return rz_str_newf("attr.%s.%s", class_name, attr_type);
}

References rz_str_newf().

Referenced by rz_analysis_class_base_get_all(), rz_analysis_class_delete(), rz_analysis_class_delete_attr_raw(), rz_analysis_class_method_delete_class(), rz_analysis_class_method_get_all(), rz_analysis_class_method_rename_class(), rz_analysis_class_rename(), rz_analysis_class_rename_attr_raw(), rz_analysis_class_set_attr_raw(), rz_analysis_class_unique_attr_id_raw(), rz_analysis_class_vtable_delete_class(), rz_analysis_class_vtable_get_all(), and rz_analysis_class_vtable_rename_class().

key_attr_types()

static char* key_attr_types ( const char *  name )

static

Definition at line 22 of file class.c.

                                              {
    return rz_str_newf("attrtypes.%s", name);
}

References rz_str_newf().

Referenced by rz_analysis_class_delete(), rz_analysis_class_delete_attr_raw(), rz_analysis_class_rename(), and rz_analysis_class_set_attr_raw().

key_class()

static const char* key_class ( const char *  name )

static

Definition at line 18 of file class.c.

                                               {
    return name;
}

References name.

Referenced by rz_analysis_class_create(), rz_analysis_class_delete(), rz_analysis_class_exists_raw(), and rz_analysis_class_rename().

rename_key()

static bool rename_key ( Sdb *  sdb, const char *  key_old, const char *  key_new  )

static

Definition at line 185 of file class.c.

                                                                           {
    char *content = sdb_get(sdb, key_old, 0);
    if (!content) {
        return false;
    }
    sdb_remove(sdb, key_old, 0);
    sdb_set(sdb, key_new, content, 0);
    free(content);
    return true;
}

References free(), sdb_get(), sdb_remove(), and sdb_set().

Referenced by rz_analysis_class_rename().

rz_analysis_class_add_attr_unique()

static RzAnalysisClassErr rz_analysis_class_add_attr_unique ( RzAnalysis *  analysis, const char *  class_name, RzAnalysisClassAttrType  attr_type, const char *  content, char *  attr_id_out, size_t  attr_id_out_size  )

static

Definition at line 572 of file class.c.

                                                                                                                                                                                                              {
    char *class_name_sanitized = rz_str_sanitize_sdb_key(class_name);
    if (!class_name_sanitized) {
        return RZ_ANALYSIS_CLASS_ERR_OTHER;
    }
 
    RzAnalysisClassErr err = rz_analysis_class_add_attr_unique_raw(analysis, class_name_sanitized, attr_type, content, attr_id_out, attr_id_out_size);
 
    free(class_name_sanitized);
    return err;
}

References err, free(), rz_analysis_class_add_attr_unique_raw(), and rz_str_sanitize_sdb_key().

Referenced by rz_analysis_class_base_set_raw(), and rz_analysis_class_vtable_set().

rz_analysis_class_add_attr_unique_raw()

static RzAnalysisClassErr rz_analysis_class_add_attr_unique_raw ( RzAnalysis *  analysis, const char *  class_name, RzAnalysisClassAttrType  attr_type, const char *  content, char *  attr_id_out, size_t  attr_id_out_size  )

static

Definition at line 556 of file class.c.

                                                                                                                                                                                                                  {
    char attr_id[16];
    rz_analysis_class_unique_attr_id_raw(analysis, class_name, attr_type, attr_id, sizeof(attr_id));
 
    RzAnalysisClassErr err = rz_analysis_class_set_attr(analysis, class_name, attr_type, attr_id, content);
    if (err != RZ_ANALYSIS_CLASS_ERR_SUCCESS) {
        return err;
    }
 
    if (attr_id_out) {
        rz_str_ncpy(attr_id_out, attr_id, attr_id_out_size);
    }
 
    return RZ_ANALYSIS_CLASS_ERR_SUCCESS;
}

References err, rz_analysis_class_set_attr(), rz_analysis_class_unique_attr_id_raw(), and rz_str_ncpy().

Referenced by rz_analysis_class_add_attr_unique().

rz_analysis_class_base_delete()

RZ_API RzAnalysisClassErr rz_analysis_class_base_delete	(	RzAnalysis *	analysis,
		const char *	class_name,
		const char *	base_id
	)

Definition at line 1010 of file class.c.

                                                                                                                           {
    return rz_analysis_class_delete_attr(analysis, class_name, RZ_ANALYSIS_CLASS_ATTR_TYPE_BASE, base_id);
}

References RZ_ANALYSIS_CLASS_ATTR_TYPE_BASE, and rz_analysis_class_delete_attr().

Referenced by rz_analysis_class_base_del_handler(), and rz_analysis_class_base_delete_class_cb().

rz_analysis_class_base_delete_class()

static void rz_analysis_class_base_delete_class ( RzAnalysis *  analysis, const char *  class_name  )

static

Definition at line 1033 of file class.c.

                                                                                              {
    DeleteClassCtx ctx = { analysis, class_name };
    rz_analysis_class_foreach(analysis, rz_analysis_class_base_delete_class_cb, &ctx);
}

References rz_analysis_class_base_delete_class_cb(), and rz_analysis_class_foreach().

Referenced by rz_analysis_class_delete().

rz_analysis_class_base_delete_class_cb()

static bool rz_analysis_class_base_delete_class_cb ( void *  user, const char *  k, const char *  v  )

static

Definition at line 1019 of file class.c.

                                                                                             {
    (void)v;
    DeleteClassCtx *ctx = user;
    RzVector *bases = rz_analysis_class_base_get_all(ctx->analysis, k);
    RzAnalysisBaseClass *base;
    rz_vector_foreach(bases, base) {
        if (base->class_name && strcmp(base->class_name, ctx->class_name) == 0) {
            rz_analysis_class_base_delete(ctx->analysis, k, base->id);
        }
    }
    rz_vector_free(bases);
    return true;
}

References k, rz_analysis_class_base_delete(), rz_analysis_class_base_get_all(), rz_vector_foreach, rz_vector_free(), and v.

Referenced by rz_analysis_class_base_delete_class().

rz_analysis_class_base_fini()

RZ_API void rz_analysis_class_base_fini

(

RzAnalysisBaseClass *

base

)

Definition at line 880 of file class.c.

                                                                   {
    free(base->id);
    free(base->class_name);
}

References free().

Referenced by add_class_bases(), recovery_apply_bases(), rz_analysis_class_base_add_handler(), and rz_analysis_class_base_fini_proxy().

rz_analysis_class_base_fini_proxy()

static void rz_analysis_class_base_fini_proxy ( void *  e, void *  user  )

static

Definition at line 922 of file class.c.

                                                                   {
    (void)user;
    RzAnalysisBaseClass *base = e;
    rz_analysis_class_base_fini(base);
}

References e, and rz_analysis_class_base_fini().

Referenced by rz_analysis_class_base_get_all().

rz_analysis_class_base_get()

RZ_API RzAnalysisClassErr rz_analysis_class_base_get	(	RzAnalysis *	analysis,
		const char *	class_name,
		const char *	base_id,
		RzAnalysisBaseClass *	base
	)

Definition at line 885 of file class.c.

                                                                                                                                                   {
    char *content = rz_analysis_class_get_attr(analysis, class_name, RZ_ANALYSIS_CLASS_ATTR_TYPE_BASE, base_id, false);
    if (!content) {
        return RZ_ANALYSIS_CLASS_ERR_NONEXISTENT_ATTR;
    }
 
    char *cur = content;
    char *next;
    sdb_anext(cur, &next);
 
    base->class_name = strdup(cur);
    if (!base->class_name) {
        free(content);
        return RZ_ANALYSIS_CLASS_ERR_OTHER;
    }
 
    cur = next;
    if (!cur) {
        free(content);
        free(base->class_name);
        return RZ_ANALYSIS_CLASS_ERR_OTHER;
    }
    sdb_anext(cur, NULL);
 
    base->offset = rz_num_math(NULL, cur);
 
    free(content);
 
    base->id = rz_str_sanitize_sdb_key(base_id);
    if (!base->id) {
        free(base->class_name);
        return RZ_ANALYSIS_CLASS_ERR_OTHER;
    }
 
    return RZ_ANALYSIS_CLASS_ERR_SUCCESS;
}

References free(), NULL, RZ_ANALYSIS_CLASS_ATTR_TYPE_BASE, rz_analysis_class_get_attr(), rz_num_math(), rz_str_sanitize_sdb_key(), sdb_anext(), and strdup().

Referenced by rz_analysis_class_base_get_all().

rz_analysis_class_base_get_all()

RZ_API RzVector* rz_analysis_class_base_get_all	(	RzAnalysis *	analysis,
		const char *	class_name
	)

Definition at line 928 of file class.c.

                                                                                                {
    RzVector *vec = rz_vector_new(sizeof(RzAnalysisBaseClass), rz_analysis_class_base_fini_proxy, NULL);
    if (!vec) {
        return NULL;
    }
 
    char *class_name_sanitized = rz_str_sanitize_sdb_key(class_name);
    if (!class_name_sanitized) {
        rz_vector_free(vec);
        return NULL;
    }
    char *key = key_attr_type_attrs(class_name_sanitized, attr_type_id(RZ_ANALYSIS_CLASS_ATTR_TYPE_BASE));
    if (!key) {
        rz_vector_free(vec);
        free(class_name_sanitized);
        return NULL;
    }
    char *array = sdb_get(analysis->sdb_classes_attrs, key, 0);
    free(key);
    free(class_name_sanitized);
 
    rz_vector_reserve(vec, (size_t)sdb_alen(array));
    char *cur;
    sdb_aforeach(cur, array) {
        RzAnalysisBaseClass base;
        if (rz_analysis_class_base_get(analysis, class_name, cur, &base) == RZ_ANALYSIS_CLASS_ERR_SUCCESS) {
            rz_vector_push(vec, &base);
        }
        sdb_aforeach_next(cur);
    }
    free(array);
 
    return vec;
}

References attr_type_id(), free(), key, key_attr_type_attrs(), NULL, RZ_ANALYSIS_CLASS_ATTR_TYPE_BASE, rz_analysis_class_base_fini_proxy(), rz_analysis_class_base_get(), rz_str_sanitize_sdb_key(), rz_vector_free(), rz_vector_new(), rz_vector_push(), rz_vector_reserve(), sdb_aforeach, sdb_aforeach_next, sdb_alen(), rz_analysis_t::sdb_classes_attrs, and sdb_get().

Referenced by analysis_class_print(), analysis_class_print_as_cmd(), analysis_class_print_to_json(), rz_analysis_class_base_delete_class_cb(), rz_analysis_class_base_list_handler(), rz_analysis_class_base_rename_class_cb(), rz_analysis_class_base_set(), and rz_analysis_class_get_inheritance_graph().

rz_analysis_class_base_rename_class()

static void rz_analysis_class_base_rename_class ( RzAnalysis *  analysis, const char *  class_name_old, const char *  class_name_new  )

static

Definition at line 1058 of file class.c.

                                                                                                                              {
    RenameClassCtx ctx = { analysis, class_name_old, class_name_new };
    rz_analysis_class_foreach(analysis, rz_analysis_class_base_rename_class_cb, &ctx);
}

References rz_analysis_class_base_rename_class_cb(), and rz_analysis_class_foreach().

Referenced by rz_analysis_class_rename().

rz_analysis_class_base_rename_class_cb()

static bool rz_analysis_class_base_rename_class_cb ( void *  user, const char *  k, const char *  v  )

static

Definition at line 1044 of file class.c.

                                                                                             {
    (void)v;
    RenameClassCtx *ctx = user;
    RzVector *bases = rz_analysis_class_base_get_all(ctx->analysis, k);
    RzAnalysisBaseClass *base;
    rz_vector_foreach(bases, base) {
        if (base->class_name && strcmp(base->class_name, ctx->class_name_old) == 0) {
            rz_analysis_class_base_set_raw(ctx->analysis, k, base, ctx->class_name_new);
        }
    }
    rz_vector_free(bases);
    return 1;
}

References k, rz_analysis_class_base_get_all(), rz_analysis_class_base_set_raw(), rz_vector_foreach, rz_vector_free(), and v.

Referenced by rz_analysis_class_base_rename_class().

rz_analysis_class_base_set()

RZ_API RzAnalysisClassErr rz_analysis_class_base_set	(	RzAnalysis *	analysis,
		const char *	class_name,
		RzAnalysisBaseClass *	base
	)

Definition at line 983 of file class.c.

                                                                                                                              {
    char *base_class_name_sanitized = rz_str_sanitize_sdb_key(base->class_name);
    if (!base_class_name_sanitized) {
        return RZ_ANALYSIS_CLASS_ERR_OTHER;
    }
 
    if (!rz_analysis_class_exists_raw(analysis, base_class_name_sanitized)) {
        free(base_class_name_sanitized);
        return RZ_ANALYSIS_CLASS_ERR_NONEXISTENT_CLASS;
    }
    RzVector /*<RzAnalysisBaseClass>*/ *bases = rz_analysis_class_base_get_all(analysis, class_name);
    if (bases) {
        RzAnalysisBaseClass *existing_base;
        rz_vector_foreach(bases, existing_base) {
            if (!strcmp(existing_base->class_name, base->class_name)) {
                free(base_class_name_sanitized);
                rz_vector_free(bases);
                return RZ_ANALYSIS_CLASS_ERR_OTHER;
            }
        }
    }
    RzAnalysisClassErr err = rz_analysis_class_base_set_raw(analysis, class_name, base, base_class_name_sanitized);
    free(base_class_name_sanitized);
    rz_vector_free(bases);
    return err;
}

References err, free(), rz_analysis_class_base_get_all(), rz_analysis_class_base_set_raw(), rz_analysis_class_exists_raw(), rz_str_sanitize_sdb_key(), rz_vector_foreach, and rz_vector_free().

Referenced by add_class_bases(), recovery_apply_bases(), and rz_analysis_class_base_add_handler().

rz_analysis_class_base_set_raw()

static RzAnalysisClassErr rz_analysis_class_base_set_raw ( RzAnalysis *  analysis, const char *  class_name, RzAnalysisBaseClass *  base, const char *  base_class_name_sanitized  )

static

Definition at line 963 of file class.c.

                                                                                                                                                                         {
    char *content = rz_str_newf("%s" SDB_SS "%" PFMT64u, base_class_name_sanitized, base->offset);
    if (!content) {
        return RZ_ANALYSIS_CLASS_ERR_OTHER;
    }
    RzAnalysisClassErr err;
    if (base->id) {
        err = rz_analysis_class_set_attr(analysis, class_name, RZ_ANALYSIS_CLASS_ATTR_TYPE_BASE, base->id, content);
    } else {
        base->id = malloc(16);
        if (base->id) {
            err = rz_analysis_class_add_attr_unique(analysis, class_name, RZ_ANALYSIS_CLASS_ATTR_TYPE_BASE, content, base->id, 16);
        } else {
            err = RZ_ANALYSIS_CLASS_ERR_OTHER;
        }
    }
    free(content);
    return err;
}

References err, free(), malloc(), PFMT64u, rz_analysis_class_add_attr_unique(), RZ_ANALYSIS_CLASS_ATTR_TYPE_BASE, rz_analysis_class_set_attr(), rz_str_newf(), and SDB_SS.

Referenced by rz_analysis_class_base_rename_class_cb(), and rz_analysis_class_base_set().

rz_analysis_class_create()

RZ_API RzAnalysisClassErr rz_analysis_class_create	(	RzAnalysis *	analysis,
		const char *	name
	)

Definition at line 79 of file class.c.

                                                                                           {
    char *name_sanitized = rz_str_sanitize_sdb_key(name);
    if (!name_sanitized) {
        return RZ_ANALYSIS_CLASS_ERR_OTHER;
    }
    RzAnalysisClassErr err = RZ_ANALYSIS_CLASS_ERR_SUCCESS;
    const char *key = key_class(name_sanitized);
    if (!sdb_exists(analysis->sdb_classes, key)) {
        sdb_set(analysis->sdb_classes, key, "c", 0);
        RzEventClass event = { .name = name_sanitized };
        rz_event_send(analysis->ev, RZ_EVENT_CLASS_NEW, &event);
    } else {
        err = RZ_ANALYSIS_CLASS_ERR_CLASH;
    }
 
    free(name_sanitized);
    return err;
}

References err, rz_analysis_t::ev, free(), key, key_class(), rz_event_class_t::name, RZ_EVENT_CLASS_NEW, rz_event_send(), rz_str_sanitize_sdb_key(), rz_analysis_t::sdb_classes, sdb_exists(), and sdb_set().

Referenced by recovery_apply_complete_object_locator(), recovery_apply_type_descriptor(), rz_analysis_class_add_handler(), rz_analysis_class_recover_from_rzbin(), and rz_analysis_rtti_itanium_recover_all().

rz_analysis_class_delete()

RZ_API void rz_analysis_class_delete	(	RzAnalysis *	analysis,
		const char *	name
	)

Definition at line 98 of file class.c.

                                                                             {
    char *class_name_sanitized = rz_str_sanitize_sdb_key(name);
    if (!class_name_sanitized) {
        return;
    }
 
    rz_analysis_class_base_delete_class(analysis, class_name_sanitized);
    rz_analysis_class_method_delete_class(analysis, class_name_sanitized);
    rz_analysis_class_vtable_delete_class(analysis, class_name_sanitized);
 
    if (!sdb_remove(analysis->sdb_classes, key_class(class_name_sanitized), 0)) {
        free(class_name_sanitized);
        return;
    }
 
    char *key = key_attr_types(class_name_sanitized);
    if (!key) {
        free(class_name_sanitized);
        return;
    }
    char *attr_type_array = sdb_get(analysis->sdb_classes_attrs, key, 0);
    free(key);
 
    char *attr_type;
    sdb_aforeach(attr_type, attr_type_array) {
        key = key_attr_type_attrs(class_name_sanitized, attr_type);
        if (!key) {
            continue;
        }
        char *attr_id_array = sdb_get(analysis->sdb_classes_attrs, key, 0);
        sdb_remove(analysis->sdb_classes_attrs, key, 0);
        free(key);
        if (attr_id_array) {
            char *attr_id;
            sdb_aforeach(attr_id, attr_id_array) {
                key = key_attr_content(class_name_sanitized, attr_type, attr_id);
                if (key) {
                    sdb_remove(analysis->sdb_classes_attrs, key, 0);
                    free(key);
                }
                key = key_attr_content_specific(class_name_sanitized, attr_type, attr_id);
                if (key) {
                    sdb_remove(analysis->sdb_classes_attrs, key, 0);
                    free(key);
                }
                sdb_aforeach_next(attr_id);
            }
            free(attr_id_array);
        }
        sdb_aforeach_next(attr_type);
    }
    free(attr_type_array);
 
    key = key_attr_types(class_name_sanitized);
    if (key) {
        sdb_remove(analysis->sdb_classes_attrs, key, 0);
        free(key);
    }
 
    RzEventClass event = { .name = class_name_sanitized };
    rz_event_send(analysis->ev, RZ_EVENT_CLASS_DEL, &event);
 
    free(class_name_sanitized);
}

References rz_analysis_t::ev, free(), key, key_attr_content(), key_attr_content_specific(), key_attr_type_attrs(), key_attr_types(), key_class(), rz_event_class_t::name, rz_analysis_class_base_delete_class(), rz_analysis_class_method_delete_class(), rz_analysis_class_vtable_delete_class(), RZ_EVENT_CLASS_DEL, rz_event_send(), rz_str_sanitize_sdb_key(), sdb_aforeach, sdb_aforeach_next, rz_analysis_t::sdb_classes, rz_analysis_t::sdb_classes_attrs, sdb_get(), and sdb_remove().

Referenced by rz_analysis_class_del_handler().

rz_analysis_class_delete_attr()

static RzAnalysisClassErr rz_analysis_class_delete_attr ( RzAnalysis *  analysis, const char *  class_name, RzAnalysisClassAttrType  attr_type, const char *  attr_id  )

static

Definition at line 400 of file class.c.

                                                                                                                                                              {
    char *class_name_sanitized = rz_str_sanitize_sdb_key(class_name);
    if (!class_name_sanitized) {
        return RZ_ANALYSIS_CLASS_ERR_OTHER;
    }
 
    char *attr_id_sanitized = rz_str_sanitize_sdb_key(attr_id);
    if (!attr_id_sanitized) {
        free(class_name_sanitized);
        return RZ_ANALYSIS_CLASS_ERR_OTHER;
    }
 
    RzAnalysisClassErr err = rz_analysis_class_delete_attr_raw(analysis, class_name_sanitized, attr_type, attr_id_sanitized);
 
    free(class_name_sanitized);
    free(attr_id_sanitized);
    return err;
}

References err, free(), rz_analysis_class_delete_attr_raw(), and rz_str_sanitize_sdb_key().

Referenced by rz_analysis_class_base_delete().

rz_analysis_class_delete_attr_raw()

static RzAnalysisClassErr rz_analysis_class_delete_attr_raw ( RzAnalysis *  analysis, const char *  class_name, RzAnalysisClassAttrType  attr_type, const char *  attr_id  )

static

Definition at line 367 of file class.c.

                                                                                                                                                                  {
    const char *attr_type_str = attr_type_id(attr_type);
 
    char *key = key_attr_content(class_name, attr_type_str, attr_id);
    if (key) {
        sdb_remove(analysis->sdb_classes_attrs, key, 0);
        free(key);
    }
    key = key_attr_content_specific(class_name, attr_type_str, attr_id);
    if (key) {
        sdb_remove(analysis->sdb_classes_attrs, key, 0);
        free(key);
    }
 
    key = key_attr_type_attrs(class_name, attr_type_str);
    if (key) {
        sdb_array_remove(analysis->sdb_classes_attrs, key, attr_id, 0);
        if (!sdb_exists(analysis->sdb_classes_attrs, key)) {
            sdb_array_remove(analysis->sdb_classes_attrs, key_attr_types(class_name), attr_type_str, 0);
        }
        free(key);
    }
 
    RzEventClassAttr event = {
        .class_name = class_name,
        .attr_type = attr_type,
        .attr_id = attr_id
    };
    rz_event_send(analysis->ev, RZ_EVENT_CLASS_ATTR_DEL, &event);
 
    return RZ_ANALYSIS_CLASS_ERR_SUCCESS;
}

References attr_type_id(), rz_event_class_attr_t::class_name, rz_analysis_t::ev, free(), key, key_attr_content(), key_attr_content_specific(), key_attr_type_attrs(), key_attr_types(), RZ_EVENT_CLASS_ATTR_DEL, rz_event_send(), sdb_array_remove(), rz_analysis_t::sdb_classes_attrs, sdb_exists(), and sdb_remove().

Referenced by rz_analysis_class_delete_attr(), rz_analysis_class_method_delete(), and rz_analysis_class_vtable_delete().

rz_analysis_class_exists()

RZ_API bool rz_analysis_class_exists	(	RzAnalysis *	analysis,
		const char *	name
	)

Definition at line 167 of file class.c.

                                                                             {
    char *class_name_sanitized = rz_str_sanitize_sdb_key(name);
    if (!class_name_sanitized) {
        return false;
    }
    bool r = rz_analysis_class_exists_raw(analysis, class_name_sanitized);
    free(class_name_sanitized);
    return r;
}

References free(), r, rz_analysis_class_exists_raw(), and rz_str_sanitize_sdb_key().

Referenced by rz_analysis_class_base_list_handler(), rz_analysis_class_info_handler(), rz_analysis_class_recover_from_rzbin(), rz_analysis_class_rename(), rz_analysis_class_vtable_list_handler(), rz_analysis_class_vtable_lookup_handler(), and unique_class_name().

rz_analysis_class_exists_raw()

static bool rz_analysis_class_exists_raw ( RzAnalysis *  analysis, const char *  name  )

static

Definition at line 163 of file class.c.

                                                                                 {
    return sdb_exists(analysis->sdb_classes, key_class(name));
}

References key_class(), rz_analysis_t::sdb_classes, and sdb_exists().

Referenced by rz_analysis_class_base_set(), rz_analysis_class_exists(), and rz_analysis_class_set_attr_raw().

rz_analysis_class_foreach()

RZ_API void rz_analysis_class_foreach	(	RzAnalysis *	analysis,
		SdbForeachCallback	cb,
		void *	user
	)

Definition at line 181 of file class.c.

                                                                                               {
    sdb_foreach(analysis->sdb_classes, cb, user);
}

References cb, rz_analysis_t::sdb_classes, and sdb_foreach().

Referenced by analysis_class_list_print_to_json(), rz_analysis_class_base_delete_class(), and rz_analysis_class_base_rename_class().

rz_analysis_class_get_all()

RZ_API SdbList* rz_analysis_class_get_all	(	RzAnalysis *	analysis,
		bool	sorted
	)

Definition at line 177 of file class.c.

                                                                             {
    return sdb_foreach_list(analysis->sdb_classes, sorted);
}

References rz_analysis_t::sdb_classes, and sdb_foreach_list().

Referenced by rz_analysis_class_get_inheritance_graph(), rz_analysis_class_list_handler(), rz_analysis_class_vtable_lookup_handler(), and rz_core_visual_analysis_classes().

rz_analysis_class_get_attr()

static char* rz_analysis_class_get_attr ( RzAnalysis *  analysis, const char *  class_name, RzAnalysisClassAttrType  attr_type, const char *  attr_id, bool  specific  )

static

Definition at line 291 of file class.c.

                                                                                                                                                             {
    char *class_name_sanitized = rz_str_sanitize_sdb_key(class_name);
    if (!class_name_sanitized) {
        return false;
    }
    char *attr_id_sanitized = rz_str_sanitize_sdb_key(attr_id);
    if (!attr_id_sanitized) {
        free(class_name_sanitized);
        return false;
    }
 
    char *ret = rz_analysis_class_get_attr_raw(analysis, class_name_sanitized, attr_type, attr_id_sanitized, specific);
 
    free(class_name_sanitized);
    free(attr_id_sanitized);
 
    return ret;
}

References free(), rz_analysis_class_get_attr_raw(), and rz_str_sanitize_sdb_key().

Referenced by rz_analysis_class_base_get(), rz_analysis_class_method_exists(), rz_analysis_class_method_get(), and rz_analysis_class_vtable_get().

rz_analysis_class_get_attr_raw()

static char* rz_analysis_class_get_attr_raw ( RzAnalysis *  analysis, const char *  class_name, RzAnalysisClassAttrType  attr_type, const char *  attr_id, bool  specific  )

static

Definition at line 277 of file class.c.

                                                                                                                                                                 {
    const char *attr_type_str = attr_type_id(attr_type);
    char *key = specific
        ? key_attr_content_specific(class_name, attr_type_str, attr_id)
        : key_attr_content(class_name, attr_type_str, attr_id);
    if (!key) {
        return NULL;
    }
    char *ret = sdb_get(analysis->sdb_classes_attrs, key, 0);
    free(key);
    return ret;
}

References attr_type_id(), free(), key, key_attr_content(), key_attr_content_specific(), NULL, rz_analysis_t::sdb_classes_attrs, and sdb_get().

Referenced by rz_analysis_class_get_attr().

rz_analysis_class_get_inheritance_graph()

RZ_API RzGraph* rz_analysis_class_get_inheritance_graph

(

RzAnalysis *

analysis

)

Creates RzGraph from class inheritance information where each node has RzGraphNodeInfo as generic data.

Parameters

analysis

Returns

RzGraph* NULL if failure

Definition at line 1261 of file class.c.

                                                                                {
    rz_return_val_if_fail(analysis, NULL);
    RzGraph *class_graph = rz_graph_new();
    if (!class_graph) {
        return NULL;
    }
    SdbList *classes = rz_analysis_class_get_all(analysis, true);
    if (!classes) {
        rz_graph_free(class_graph);
        return NULL;
    }
    HtPP /*<char *name, RzGraphNode *node>*/ *hashmap = ht_pp_new0();
    if (!hashmap) {
        rz_graph_free(class_graph);
        ls_free(classes);
        return NULL;
    }
    SdbListIter *iter;
    SdbKv *kv;
    // Traverse each class and create a node and edges
    ls_foreach (classes, iter, kv) {
        const char *name = sdbkv_key(kv);
        // create nodes
        RzGraphNode *curr_node = ht_pp_find(hashmap, name, NULL);
        if (!curr_node) {
            curr_node = rz_graph_add_node_info(class_graph, name, NULL, 0);
            if (!curr_node) {
                goto failure;
            }
            ht_pp_insert(hashmap, name, curr_node);
        }
        // create edges between node and it's parents
        RzVector *bases = rz_analysis_class_base_get_all(analysis, name);
        RzAnalysisBaseClass *base;
        rz_vector_foreach(bases, base) {
            bool base_found = false;
            RzGraphNode *base_node = ht_pp_find(hashmap, base->class_name, &base_found);
            // If base isn't processed, do it now
            if (!base_found) {
                base_node = rz_graph_add_node_info(class_graph, base->class_name, NULL, 0);
                if (!base_node) {
                    goto failure;
                }
                ht_pp_insert(hashmap, base->class_name, base_node);
            }
            rz_graph_add_edge(class_graph, base_node, curr_node);
        }
        rz_vector_free(bases);
    }
    ls_free(classes);
    ht_pp_free(hashmap);
    return class_graph;
 
failure:
    ls_free(classes);
    ht_pp_free(hashmap);
    rz_graph_free(class_graph);
    return NULL;
}

References classes(), ls_foreach, ls_free(), NULL, rz_analysis_class_base_get_all(), rz_analysis_class_get_all(), rz_graph_add_edge(), rz_graph_add_node_info(), rz_graph_free(), rz_graph_new(), rz_return_val_if_fail, rz_vector_foreach, rz_vector_free(), and sdbkv_key().

Referenced by rz_analysis_class_graph_handler().

rz_analysis_class_method_delete()

RZ_API RzAnalysisClassErr rz_analysis_class_method_delete	(	RzAnalysis *	analysis,
		const char *	class_name,
		const char *	meth_name
	)

Definition at line 855 of file class.c.

                                                                                                                               {
    char *class_name_sanitized = rz_str_sanitize_sdb_key(class_name);
    if (!class_name_sanitized) {
        return RZ_ANALYSIS_CLASS_ERR_OTHER;
    }
    char *meth_name_sanitized = rz_str_sanitize_sdb_key(meth_name);
    if (!meth_name_sanitized) {
        free(class_name_sanitized);
        return RZ_ANALYSIS_CLASS_ERR_OTHER;
    }
    RzAnalysisClassErr err = rz_analysis_class_delete_attr_raw(analysis, class_name_sanitized, RZ_ANALYSIS_CLASS_ATTR_TYPE_METHOD, meth_name_sanitized);
    if (err == RZ_ANALYSIS_CLASS_ERR_SUCCESS) {
        char *fn = flagname_method(class_name_sanitized, meth_name_sanitized);
        if (fn) {
            rz_analysis_class_unset_flag(analysis, fn);
        }
        free(fn);
    }
    free(class_name_sanitized);
    free(meth_name_sanitized);
    return err;
}

References err, flagname_method(), fn, free(), RZ_ANALYSIS_CLASS_ATTR_TYPE_METHOD, rz_analysis_class_delete_attr_raw(), rz_analysis_class_unset_flag(), and rz_str_sanitize_sdb_key().

Referenced by rz_analysis_class_method_del_handler().

rz_analysis_class_method_delete_class()

static void rz_analysis_class_method_delete_class ( RzAnalysis *  analysis, const char *  class_name  )

static

Definition at line 834 of file class.c.

                                                                                                {
    char *key = key_attr_type_attrs(class_name, attr_type_id(RZ_ANALYSIS_CLASS_ATTR_TYPE_METHOD));
    if (!key) {
        return;
    }
    char *array = sdb_get(analysis->sdb_classes_attrs, key, 0);
    if (!array) {
        return;
    }
    char *cur;
    sdb_aforeach(cur, array) {
        char *fn = flagname_method(class_name, cur);
        if (fn) {
            rz_analysis_class_unset_flag(analysis, fn);
        }
        free(fn);
        sdb_aforeach_next(cur);
    }
    free(array);
}

References attr_type_id(), flagname_method(), fn, free(), key, key_attr_type_attrs(), RZ_ANALYSIS_CLASS_ATTR_TYPE_METHOD, rz_analysis_class_unset_flag(), sdb_aforeach, sdb_aforeach_next, rz_analysis_t::sdb_classes_attrs, and sdb_get().

Referenced by rz_analysis_class_delete().

rz_analysis_class_method_exists()

RZ_API bool rz_analysis_class_method_exists	(	RzAnalysis *	analysis,
		const char *	class_name,
		const char *	meth_name
	)

Definition at line 634 of file class.c.

                                                                                                                 {
    char *content = rz_analysis_class_get_attr(analysis, class_name, RZ_ANALYSIS_CLASS_ATTR_TYPE_METHOD, meth_name, false);
    if (!content) {
        return false;
    }
 
    return true;
}

References RZ_ANALYSIS_CLASS_ATTR_TYPE_METHOD, and rz_analysis_class_get_attr().

Referenced by rz_analysis_class_method_recover().

rz_analysis_class_method_exists_by_addr()

RZ_API bool rz_analysis_class_method_exists_by_addr	(	RzAnalysis *	analysis,
		const char *	class_name,
		ut64	addr
	)

Definition at line 643 of file class.c.

                                                                                                             {
    RzVector *vec = rz_analysis_class_method_get_all(analysis, class_name);
    if (!vec) {
        return false;
    }
    RzAnalysisMethod *meth;
    rz_vector_foreach(vec, meth) {
        if (meth->addr == addr) {
            rz_vector_free(vec);
            return true;
        }
    }
    rz_vector_free(vec);
    return false;
}

References addr, rz_analysis_class_method_get_all(), rz_vector_foreach, and rz_vector_free().

Referenced by recovery_apply_vtable().

rz_analysis_class_method_fini()

RZ_API void rz_analysis_class_method_fini

(

RzAnalysisMethod *

meth

)

Definition at line 606 of file class.c.

                                                                  {
    free(meth->name);
    free(meth->real_name);
}

References free().

Referenced by recovery_apply_vtable(), rz_analysis_class_method_add_handler(), rz_analysis_class_method_fini_proxy(), rz_analysis_class_method_recover(), and rz_analysis_class_method_rename().

rz_analysis_class_method_fini_proxy()

static void rz_analysis_class_method_fini_proxy ( void *  e, void *  user  )

static

Definition at line 729 of file class.c.

                                                                     {
    (void)user;
    RzAnalysisMethod *meth = e;
    rz_analysis_class_method_fini(meth);
}

References e, and rz_analysis_class_method_fini().

Referenced by rz_analysis_class_method_get_all().

rz_analysis_class_method_get()

RZ_API RzAnalysisClassErr rz_analysis_class_method_get	(	RzAnalysis *	analysis,
		const char *	class_name,
		const char *	meth_name,
		RzAnalysisMethod *	meth
	)

Definition at line 682 of file class.c.

                                                                                                                                                    {
    char *content = rz_analysis_class_get_attr(analysis, class_name, RZ_ANALYSIS_CLASS_ATTR_TYPE_METHOD, meth_name, false);
    if (!content) {
        return RZ_ANALYSIS_CLASS_ERR_NONEXISTENT_ATTR;
    }
 
    char *cur = content;
    char *next;
    sdb_anext(cur, &next);
 
    meth->addr = rz_num_math(NULL, cur);
    cur = next;
 
    if (!cur) {
        free(content);
        return RZ_ANALYSIS_CLASS_ERR_OTHER;
    }
    sdb_anext(cur, &next);
    meth->vtable_offset = atoll(cur);
    cur = next;
 
    if (!cur) {
        free(content);
        return RZ_ANALYSIS_CLASS_ERR_OTHER;
    }
    sdb_anext(cur, &next);
    meth->method_type = rz_num_math(NULL, cur);
    cur = next;
 
    if (!cur) {
        free(content);
        return RZ_ANALYSIS_CLASS_ERR_OTHER;
    }
    sdb_anext(cur, NULL);
 
    meth->real_name = rz_str_new(cur);
 
    free(content);
 
    meth->name = rz_str_sanitize_sdb_key(meth_name);
    if (!meth->name) {
        return RZ_ANALYSIS_CLASS_ERR_OTHER;
    }
 
    return RZ_ANALYSIS_CLASS_ERR_SUCCESS;
}

References free(), NULL, RZ_ANALYSIS_CLASS_ATTR_TYPE_METHOD, rz_analysis_class_get_attr(), rz_num_math(), rz_str_new(), rz_str_sanitize_sdb_key(), and sdb_anext().

Referenced by rz_analysis_class_method_get_all(), and rz_analysis_class_method_rename().

rz_analysis_class_method_get_all()

RZ_API RzVector* rz_analysis_class_method_get_all	(	RzAnalysis *	analysis,
		const char *	class_name
	)

Definition at line 735 of file class.c.

                                                                                                  {
    RzVector *vec = rz_vector_new(sizeof(RzAnalysisMethod), rz_analysis_class_method_fini_proxy, NULL);
    if (!vec) {
        return NULL;
    }
 
    char *class_name_sanitized = rz_str_sanitize_sdb_key(class_name);
    if (!class_name_sanitized) {
        rz_vector_free(vec);
        return NULL;
    }
    char *key = key_attr_type_attrs(class_name_sanitized, attr_type_id(RZ_ANALYSIS_CLASS_ATTR_TYPE_METHOD));
    if (!key) {
        rz_vector_free(vec);
        free(class_name_sanitized);
        return NULL;
    }
    char *array = sdb_get(analysis->sdb_classes_attrs, key, 0);
    free(key);
    free(class_name_sanitized);
 
    rz_vector_reserve(vec, (size_t)sdb_alen(array));
    char *cur;
    sdb_aforeach(cur, array) {
        RzAnalysisMethod meth;
        if (rz_analysis_class_method_get(analysis, class_name, cur, &meth) == RZ_ANALYSIS_CLASS_ERR_SUCCESS) {
            rz_vector_push(vec, &meth);
        }
        sdb_aforeach_next(cur);
    }
    free(array);
 
    return vec;
}

References attr_type_id(), free(), key, key_attr_type_attrs(), NULL, RZ_ANALYSIS_CLASS_ATTR_TYPE_METHOD, rz_analysis_class_method_fini_proxy(), rz_analysis_class_method_get(), rz_str_sanitize_sdb_key(), rz_vector_free(), rz_vector_new(), rz_vector_push(), rz_vector_reserve(), sdb_aforeach, sdb_aforeach_next, sdb_alen(), rz_analysis_t::sdb_classes_attrs, and sdb_get().

Referenced by analysis_class_print(), analysis_class_print_as_cmd(), analysis_class_print_to_json(), detect_constructor_destructor(), rz_analysis_class_method_exists_by_addr(), and rz_analysis_class_method_get_by_addr().

rz_analysis_class_method_get_by_addr()

RZ_API RzAnalysisClassErr rz_analysis_class_method_get_by_addr	(	RzAnalysis *	analysis,
		const char *	class_name,
		ut64	addr,
		RzAnalysisMethod *	method
	)

Definition at line 659 of file class.c.

                                                                                                                                                  {
    RzVector *vec = rz_analysis_class_method_get_all(analysis, class_name);
    if (!vec) {
        return RZ_ANALYSIS_CLASS_ERR_OTHER;
    }
    RzAnalysisMethod *meth;
    rz_vector_foreach(vec, meth) {
        if (meth->addr == addr) {
            method->name = rz_str_new(meth->name);
            method->addr = meth->addr;
            method->method_type = meth->method_type;
            method->vtable_offset = meth->vtable_offset;
            method->real_name = rz_str_new(meth->real_name);
            rz_vector_free(vec);
            return RZ_ANALYSIS_CLASS_ERR_SUCCESS;
        }
    }
    rz_vector_free(vec);
    return RZ_ANALYSIS_CLASS_ERR_OTHER;
}

References addr, rz_analysis_class_method_get_all(), rz_str_new(), rz_vector_foreach, and rz_vector_free().

Referenced by recovery_apply_vtable().

rz_analysis_class_method_recover()

RZ_API void rz_analysis_class_method_recover	(	RzAnalysis *	analysis,
		RzBinClass *	cls,
		RzList *	methods
	)

Definition at line 611 of file class.c.

                                                                                                       {
    RzListIter *iter_method;
    RzBinSymbol *sym;
    rz_list_sort(methods, &symbol_method_sort_by_addr);
    rz_list_foreach (methods, iter_method, sym) {
        if (!rz_analysis_class_method_exists(analysis, cls->name, sym->name)) {
            // detect constructor or destructor but not implemented
            // Temporarily set to default
            RzAnalysisMethod method;
            method.addr = sym->vaddr;
            method.vtable_offset = -1;
            RzAnalysisFunction *fcn = rz_analysis_get_function_at(analysis, sym->vaddr);
            char *method_name = rz_str_new(sym->name);
            rz_str_split(method_name, '(');
            method.name = fcn ? rz_str_new(fcn->name) : rz_str_new(method_name);
            method.real_name = method_name;
            method.method_type = RZ_ANALYSIS_CLASS_METHOD_DEFAULT;
            rz_analysis_class_method_set(analysis, cls->name, &method);
            rz_analysis_class_method_fini(&method);
        }
    }
}

References cls(), rz_analysis_function_t::name, rz_bin_symbol_t::name, rz_analysis_class_method_exists(), rz_analysis_class_method_fini(), rz_analysis_class_method_set(), rz_analysis_get_function_at(), rz_list_sort(), rz_str_new(), rz_str_split(), symbol_method_sort_by_addr(), and rz_bin_symbol_t::vaddr.

Referenced by rz_analysis_class_recover_from_rzbin().

rz_analysis_class_method_rename()

RZ_API RzAnalysisClassErr rz_analysis_class_method_rename	(	RzAnalysis *	analysis,
		const char *	class_name,
		const char *	old_meth_name,
		const char *	new_meth_name
	)

Definition at line 788 of file class.c.

                                                                                                                                                              {
    RzAnalysisMethod meth;
    if (rz_analysis_class_method_get(analysis, class_name, old_meth_name, &meth) == RZ_ANALYSIS_CLASS_ERR_SUCCESS) {
        meth.real_name = rz_str_new(new_meth_name);
        rz_analysis_class_method_set(analysis, class_name, &meth);
        rz_analysis_class_method_fini(&meth);
    }
 
    RzAnalysisClassErr err = rz_analysis_class_rename_attr(analysis, class_name, RZ_ANALYSIS_CLASS_ATTR_TYPE_METHOD, old_meth_name, new_meth_name);
    if (err != RZ_ANALYSIS_CLASS_ERR_SUCCESS) {
        return err;
    }
    char *old_fn = flagname_method(class_name, old_meth_name);
    char *new_fn = flagname_method(class_name, new_meth_name);
    if (old_fn && new_fn) {
        rz_analysis_class_rename_flag(analysis, old_fn, new_fn);
    }
    free(old_fn);
    free(new_fn);
    return RZ_ANALYSIS_CLASS_ERR_SUCCESS;
}

References err, flagname_method(), free(), RZ_ANALYSIS_CLASS_ATTR_TYPE_METHOD, rz_analysis_class_method_fini(), rz_analysis_class_method_get(), rz_analysis_class_method_set(), rz_analysis_class_rename_attr(), rz_analysis_class_rename_flag(), and rz_str_new().

Referenced by rz_analysis_class_method_rename_handler().

rz_analysis_class_method_rename_class()

static void rz_analysis_class_method_rename_class ( RzAnalysis *  analysis, const char *  old_class_name, const char *  new_class_name  )

static

Definition at line 810 of file class.c.

                                                                                                                                {
    char *key = key_attr_type_attrs(old_class_name, attr_type_id(RZ_ANALYSIS_CLASS_ATTR_TYPE_METHOD));
    if (!key) {
        return;
    }
    char *array = sdb_get(analysis->sdb_classes_attrs, key, 0);
    free(key);
    if (!array) {
        return;
    }
    char *cur;
    sdb_aforeach(cur, array) {
        char *old_fn = flagname_method(old_class_name, cur);
        char *new_fn = flagname_method(new_class_name, cur);
        if (old_fn && new_fn) {
            rz_analysis_class_rename_flag(analysis, old_fn, new_fn);
        }
        free(old_fn);
        free(new_fn);
        sdb_aforeach_next(cur);
    }
    free(array);
}

References attr_type_id(), flagname_method(), free(), key, key_attr_type_attrs(), RZ_ANALYSIS_CLASS_ATTR_TYPE_METHOD, rz_analysis_class_rename_flag(), sdb_aforeach, sdb_aforeach_next, rz_analysis_t::sdb_classes_attrs, and sdb_get().

Referenced by rz_analysis_class_rename().

rz_analysis_class_method_set()

RZ_API RzAnalysisClassErr rz_analysis_class_method_set	(	RzAnalysis *	analysis,
		const char *	class_name,
		RzAnalysisMethod *	meth
	)

Definition at line 770 of file class.c.

                                                                                                                             {
    char *content = rz_str_newf("%" PFMT64u "%c%" PFMT64d "%c%" PFMT32u "%c%s", meth->addr, SDB_RS, meth->vtable_offset, SDB_RS, meth->method_type, SDB_RS, meth->real_name);
    if (!content) {
        return RZ_ANALYSIS_CLASS_ERR_OTHER;
    }
    RzAnalysisClassErr err = rz_analysis_class_set_attr(analysis, class_name, RZ_ANALYSIS_CLASS_ATTR_TYPE_METHOD, meth->name, content);
    free(content);
    if (err != RZ_ANALYSIS_CLASS_ERR_SUCCESS) {
        return err;
    }
    char *fn = flagname_method(class_name, meth->name);
    if (fn) {
        rz_analysis_class_set_flag(analysis, fn, meth->addr, 0);
        free(fn);
    }
    return RZ_ANALYSIS_CLASS_ERR_SUCCESS;
}

References err, flagname_method(), fn, free(), PFMT32u, PFMT64d, PFMT64u, RZ_ANALYSIS_CLASS_ATTR_TYPE_METHOD, rz_analysis_class_set_attr(), rz_analysis_class_set_flag(), rz_str_newf(), and SDB_RS.

Referenced by detect_constructor_destructor(), recovery_apply_vtable(), rz_analysis_class_method_add_handler(), rz_analysis_class_method_recover(), and rz_analysis_class_method_rename().

rz_analysis_class_recover_all()

RZ_API void rz_analysis_class_recover_all

(

RzAnalysis *

analysis

)

Definition at line 1321 of file class.c.

                                                                {
    rz_analysis_class_recover_from_rzbin(analysis);
    rz_analysis_rtti_recover_all(analysis);
}

References rz_analysis_class_recover_from_rzbin(), and rz_analysis_rtti_recover_all().

Referenced by rz_core_analysis_everything().

rz_analysis_class_recover_from_rzbin()

RZ_API void rz_analysis_class_recover_from_rzbin

(

RzAnalysis *

analysis

)

Definition at line 57 of file class.c.

                                                                       {
    rz_cons_break_push(NULL, NULL);
    RzList *classes = rz_bin_get_classes(analysis->binb.bin);
    if (classes) {
        RzListIter *iter_class;
        RzBinClass *class;
        rz_list_foreach (classes, iter_class, class) {
            if (rz_cons_is_breaked()) {
                break;
            }
            if (!rz_analysis_class_exists(analysis, class->name)) {
                rz_analysis_class_create(analysis, class->name);
                RzList *methods = class->methods;
                if (methods) {
                    rz_analysis_class_method_recover(analysis, class, methods);
                }
            }
        }
    }
    rz_cons_break_pop();
}

References rz_bin_bind_t::bin, rz_analysis_t::binb, classes(), NULL, rz_analysis_class_create(), rz_analysis_class_exists(), rz_analysis_class_method_recover(), rz_bin_get_classes(), rz_cons_break_pop(), rz_cons_break_push(), and rz_cons_is_breaked().

Referenced by rz_analysis_class_recover_all().

rz_analysis_class_rename()

RZ_API RzAnalysisClassErr rz_analysis_class_rename	(	RzAnalysis *	analysis,
		const char *	old_name,
		const char *	new_name
	)

Definition at line 196 of file class.c.

                                                                                                                     {
    if (rz_analysis_class_exists(analysis, new_name)) {
        return RZ_ANALYSIS_CLASS_ERR_CLASH;
    }
 
    char *old_name_sanitized = rz_str_sanitize_sdb_key(old_name);
    if (!old_name_sanitized) {
        return RZ_ANALYSIS_CLASS_ERR_OTHER;
    }
    char *new_name_sanitized = rz_str_sanitize_sdb_key(new_name);
    if (!new_name_sanitized) {
        free(old_name_sanitized);
        return RZ_ANALYSIS_CLASS_ERR_OTHER;
    }
 
    RzAnalysisClassErr err = RZ_ANALYSIS_CLASS_ERR_SUCCESS;
 
    rz_analysis_class_base_rename_class(analysis, old_name, new_name);
    rz_analysis_class_method_rename_class(analysis, old_name, new_name);
    rz_analysis_class_vtable_rename_class(analysis, old_name, new_name);
 
    if (!rename_key(analysis->sdb_classes, key_class(old_name_sanitized), key_class(new_name_sanitized))) {
        err = RZ_ANALYSIS_CLASS_ERR_NONEXISTENT_CLASS;
        goto beach;
    }
 
    char *key = key_attr_types(old_name_sanitized);
    if (key) {
        char *attr_types = sdb_get(analysis->sdb_classes_attrs, key, 0);
        free(key);
        char *attr_type_cur;
        sdb_aforeach(attr_type_cur, attr_types) {
            char *key = key_attr_type_attrs(old_name, attr_type_cur);
            if (!key) {
                continue;
            }
            char *attr_ids = sdb_get(analysis->sdb_classes_attrs, key, 0);
            free(key);
            char *attr_id_cur;
            sdb_aforeach(attr_id_cur, attr_ids) {
                key = key_attr_content(old_name, attr_type_cur, attr_id_cur);
                char *new_key = key_attr_content(new_name, attr_type_cur, attr_id_cur);
                if (key && new_key) {
                    rename_key(analysis->sdb_classes_attrs, key, new_key);
                }
                free(key);
                free(new_key);
                sdb_aforeach_next(attr_id_cur);
            }
            free(attr_ids);
            key = key_attr_type_attrs(old_name, attr_type_cur);
            char *new_key = key_attr_type_attrs(new_name, attr_type_cur);
            if (key && new_key) {
                rename_key(analysis->sdb_classes_attrs, key, new_key);
            }
            sdb_aforeach_next(attr_type_cur);
        }
        free(attr_types);
    }
 
    key = key_attr_types(old_name_sanitized);
    char *new_key = key_attr_types(new_name_sanitized);
    if (key && new_key) {
        rename_key(analysis->sdb_classes_attrs, key, new_key);
    }
    free(key);
    free(new_key);
 
    RzEventClassRename event = {
        .name_old = old_name_sanitized,
        .name_new = new_name_sanitized
    };
    rz_event_send(analysis->ev, RZ_EVENT_CLASS_RENAME, &event);
 
beach:
    free(old_name_sanitized);
    free(new_name_sanitized);
    return err;
}

References err, rz_analysis_t::ev, free(), key, key_attr_content(), key_attr_type_attrs(), key_attr_types(), key_class(), rz_event_class_rename_t::name_old, rename_key(), rz_analysis_class_base_rename_class(), rz_analysis_class_exists(), rz_analysis_class_method_rename_class(), rz_analysis_class_vtable_rename_class(), RZ_EVENT_CLASS_RENAME, rz_event_send(), rz_str_sanitize_sdb_key(), sdb_aforeach, sdb_aforeach_next, rz_analysis_t::sdb_classes, rz_analysis_t::sdb_classes_attrs, and sdb_get().

Referenced by rz_analysis_class_rename_handler().

rz_analysis_class_rename_attr()

static RzAnalysisClassErr rz_analysis_class_rename_attr ( RzAnalysis *  analysis, const char *  class_name, RzAnalysisClassAttrType  attr_type, const char *  attr_id_old, const char *  attr_id_new  )

static

Definition at line 475 of file class.c.

                                                                                                                                                                                           {
    char *class_name_sanitized = rz_str_sanitize_sdb_key(class_name);
    if (!class_name_sanitized) {
        return RZ_ANALYSIS_CLASS_ERR_OTHER;
    }
    char *attr_id_old_sanitized = rz_str_sanitize_sdb_key(attr_id_old);
    if (!attr_id_old_sanitized) {
        free(class_name_sanitized);
        return RZ_ANALYSIS_CLASS_ERR_OTHER;
    }
    char *attr_id_new_sanitized = rz_str_sanitize_sdb_key(attr_id_new);
    if (!attr_id_new_sanitized) {
        free(class_name_sanitized);
        free(attr_id_old_sanitized);
        return RZ_ANALYSIS_CLASS_ERR_OTHER;
    }
    RzAnalysisClassErr ret = rz_analysis_class_rename_attr_raw(analysis, class_name_sanitized, attr_type, attr_id_old_sanitized, attr_id_new_sanitized);
    free(class_name_sanitized);
    free(attr_id_old_sanitized);
    free(attr_id_new_sanitized);
    return ret;
}

References free(), rz_analysis_class_rename_attr_raw(), and rz_str_sanitize_sdb_key().

Referenced by rz_analysis_class_method_rename().

rz_analysis_class_rename_attr_raw()

static RzAnalysisClassErr rz_analysis_class_rename_attr_raw ( RzAnalysis *  analysis, const char *  class_name, RzAnalysisClassAttrType  attr_type, const char *  attr_id_old, const char *  attr_id_new  )

static

Definition at line 419 of file class.c.

                                                                                                                                                                                               {
    const char *attr_type_str = attr_type_id(attr_type);
    char *key = key_attr_type_attrs(class_name, attr_type_str);
    if (!key) {
        return RZ_ANALYSIS_CLASS_ERR_OTHER;
    }
 
    if (sdb_array_contains(analysis->sdb_classes_attrs, key, attr_id_new, 0)) {
        free(key);
        return RZ_ANALYSIS_CLASS_ERR_CLASH;
    }
 
    if (!sdb_array_remove(analysis->sdb_classes_attrs, key, attr_id_old, 0)) {
        free(key);
        return RZ_ANALYSIS_CLASS_ERR_NONEXISTENT_ATTR;
    }
 
    sdb_array_add(analysis->sdb_classes_attrs, key, attr_id_new, 0);
    free(key);
 
    key = key_attr_content(class_name, attr_type_str, attr_id_old);
    if (key) {
        char *content = sdb_get(analysis->sdb_classes_attrs, key, 0);
        if (content) {
            sdb_remove(analysis->sdb_classes_attrs, key, 0);
            key = key_attr_content(class_name, attr_type_str, attr_id_new);
            sdb_set(analysis->sdb_classes_attrs, key, content, 0);
            free(content);
        }
        free(key);
    }
 
    key = key_attr_content_specific(class_name, attr_type_str, attr_id_old);
    if (key) {
        char *content = sdb_get(analysis->sdb_classes_attrs, key, 0);
        if (content) {
            sdb_remove(analysis->sdb_classes_attrs, key, 0);
            key = key_attr_content_specific(class_name, attr_type_str, attr_id_new);
            sdb_set(analysis->sdb_classes_attrs, key, content, 0);
            free(content);
        }
        free(key);
    }
 
    RzEventClassAttrRename event = {
        .attr = {
            .class_name = class_name,
            .attr_type = attr_type,
            .attr_id = attr_id_old },
        .attr_id_new = attr_id_new
    };
    rz_event_send(analysis->ev, RZ_EVENT_CLASS_ATTR_RENAME, &event);
 
    return RZ_ANALYSIS_CLASS_ERR_SUCCESS;
}

References rz_event_class_attr_rename_t::attr, attr_type_id(), rz_event_class_attr_t::class_name, rz_analysis_t::ev, free(), key, key_attr_content(), key_attr_content_specific(), key_attr_type_attrs(), RZ_EVENT_CLASS_ATTR_RENAME, rz_event_send(), sdb_array_add(), sdb_array_contains(), sdb_array_remove(), rz_analysis_t::sdb_classes_attrs, sdb_get(), sdb_remove(), and sdb_set().

Referenced by rz_analysis_class_rename_attr().

rz_analysis_class_rename_flag()

static void rz_analysis_class_rename_flag ( RzAnalysis *  analysis, const char *  old_name, const char *  new_name  )

static

Definition at line 543 of file class.c.

                                                                                                            {
    if (!old_name || !new_name || !analysis->flb.unset || !analysis->flg_class_get || !analysis->flg_class_set) {
        return;
    }
    RzFlagItem *flag = analysis->flg_class_get(analysis->flb.f, old_name);
    if (!flag) {
        return;
    }
    ut64 addr = flag->offset;
    analysis->flb.unset(analysis->flb.f, flag);
    analysis->flg_class_set(analysis->flb.f, new_name, addr, 0);
}

References addr, rz_flag_bind_t::f, rz_analysis_t::flb, rz_analysis_t::flg_class_get, rz_analysis_t::flg_class_set, rz_flag_item_t::offset, rz_flag_bind_t::unset, and ut64().

Referenced by rz_analysis_class_method_rename(), rz_analysis_class_method_rename_class(), and rz_analysis_class_vtable_rename_class().

rz_analysis_class_set_attr()

static RzAnalysisClassErr rz_analysis_class_set_attr ( RzAnalysis *  analysis, const char *  class_name, RzAnalysisClassAttrType  attr_type, const char *  attr_id, const char *  content  )

static

Definition at line 347 of file class.c.

                                                                                                                                                                                {
    char *class_name_sanitized = rz_str_sanitize_sdb_key(class_name);
    if (!class_name_sanitized) {
        return RZ_ANALYSIS_CLASS_ERR_OTHER;
    }
 
    char *attr_id_sanitized = rz_str_sanitize_sdb_key(attr_id);
    if (!attr_id_sanitized) {
        free(class_name_sanitized);
        return RZ_ANALYSIS_CLASS_ERR_OTHER;
    }
 
    RzAnalysisClassErr err = rz_analysis_class_set_attr_raw(analysis, class_name_sanitized, attr_type, attr_id_sanitized, content);
 
    free(class_name_sanitized);
    free(attr_id_sanitized);
 
    return err;
}

References err, free(), rz_analysis_class_set_attr_raw(), and rz_str_sanitize_sdb_key().

Referenced by rz_analysis_class_add_attr_unique_raw(), rz_analysis_class_base_set_raw(), rz_analysis_class_method_set(), and rz_analysis_class_vtable_set().

rz_analysis_class_set_attr_raw()

static RzAnalysisClassErr rz_analysis_class_set_attr_raw ( RzAnalysis *  analysis, const char *  class_name, RzAnalysisClassAttrType  attr_type, const char *  attr_id, const char *  content  )

static

Definition at line 311 of file class.c.

                                                                                                                                                                                    {
    const char *attr_type_str = attr_type_id(attr_type);
 
    if (!rz_analysis_class_exists_raw(analysis, class_name)) {
        return RZ_ANALYSIS_CLASS_ERR_NONEXISTENT_CLASS;
    }
 
    char *key = key_attr_types(class_name);
    if (key) {
        sdb_array_add(analysis->sdb_classes_attrs, key, attr_type_str, 0);
        free(key);
    }
    key = key_attr_type_attrs(class_name, attr_type_str);
    if (key) {
        sdb_array_add(analysis->sdb_classes_attrs, key, attr_id, 0);
        free(key);
    }
    key = key_attr_content(class_name, attr_type_str, attr_id);
    if (key) {
        sdb_set(analysis->sdb_classes_attrs, key, content, 0);
        free(key);
    }
 
    RzEventClassAttrSet event = {
        .attr = {
            .class_name = class_name,
            .attr_type = attr_type,
            .attr_id = attr_id },
        .content = content
    };
    rz_event_send(analysis->ev, RZ_EVENT_CLASS_ATTR_SET, &event);
 
    return RZ_ANALYSIS_CLASS_ERR_SUCCESS;
}

References rz_event_class_attr_set_t::attr, attr_type_id(), rz_event_class_attr_t::class_name, rz_analysis_t::ev, free(), key, key_attr_content(), key_attr_type_attrs(), key_attr_types(), rz_analysis_class_exists_raw(), RZ_EVENT_CLASS_ATTR_SET, rz_event_send(), sdb_array_add(), rz_analysis_t::sdb_classes_attrs, and sdb_set().

Referenced by rz_analysis_class_set_attr().

rz_analysis_class_set_flag()

static void rz_analysis_class_set_flag ( RzAnalysis *  analysis, const char *  name, ut64  addr, ut32  size  )

static

Definition at line 527 of file class.c.

                                                                                                     {
    if (!name || !analysis->flg_class_set) {
        return;
    }
    analysis->flg_class_set(analysis->flb.f, name, addr, size);
}

References addr, rz_flag_bind_t::f, rz_analysis_t::flb, and rz_analysis_t::flg_class_set.

Referenced by rz_analysis_class_method_set(), and rz_analysis_class_vtable_set().

rz_analysis_class_unique_attr_id_raw()

static void rz_analysis_class_unique_attr_id_raw ( RzAnalysis *  analysis, const char *  class_name, RzAnalysisClassAttrType  attr_type, char *  out, size_t  out_size  )

static

Definition at line 498 of file class.c.

                                                                                                                                                              {
    ut64 id = 0;
    char *key = key_attr_type_attrs(class_name, attr_type_id(attr_type));
    if (!key) {
        return;
    }
    do {
        snprintf(out, out_size, "%" PFMT64u, id);
        id++;
    } while (sdb_array_contains(analysis->sdb_classes_attrs, key, out, 0));
    free(key);
}

References attr_type_id(), free(), key, key_attr_type_attrs(), out, PFMT64u, sdb_array_contains(), rz_analysis_t::sdb_classes_attrs, snprintf, and ut64().

Referenced by rz_analysis_class_add_attr_unique_raw().

rz_analysis_class_unset_flag()

static void rz_analysis_class_unset_flag ( RzAnalysis *  analysis, const char *  name  )

static

Definition at line 534 of file class.c.

                                                                                 {
    if (!name || !analysis->flb.unset_name || !analysis->flg_class_get) {
        return;
    }
    if (analysis->flg_class_get(analysis->flb.f, name)) {
        analysis->flb.unset_name(analysis->flb.f, name);
    }
}

References rz_flag_bind_t::f, rz_analysis_t::flb, rz_analysis_t::flg_class_get, and rz_flag_bind_t::unset_name.

Referenced by rz_analysis_class_method_delete(), rz_analysis_class_method_delete_class(), rz_analysis_class_vtable_delete(), and rz_analysis_class_vtable_delete_class().

rz_analysis_class_vtable_delete()

RZ_API RzAnalysisClassErr rz_analysis_class_vtable_delete	(	RzAnalysis *	analysis,
		const char *	class_name,
		const char *	vtable_id
	)

Definition at line 1235 of file class.c.

                                                                                                                               {
    char *class_name_sanitized = rz_str_sanitize_sdb_key(class_name);
    if (!class_name_sanitized) {
        return RZ_ANALYSIS_CLASS_ERR_OTHER;
    }
    char *vtable_id_sanitized = rz_str_sanitize_sdb_key(vtable_id);
    if (!vtable_id_sanitized) {
        free(class_name_sanitized);
        return RZ_ANALYSIS_CLASS_ERR_OTHER;
    }
    RzAnalysisClassErr err = rz_analysis_class_delete_attr_raw(analysis, class_name_sanitized, RZ_ANALYSIS_CLASS_ATTR_TYPE_VTABLE, vtable_id_sanitized);
    if (err == RZ_ANALYSIS_CLASS_ERR_SUCCESS) {
        rz_analysis_class_unset_flag(analysis, flagname_vtable(class_name_sanitized, vtable_id_sanitized));
    }
    free(class_name_sanitized);
    free(vtable_id_sanitized);
    return err;
}

References err, flagname_vtable(), free(), RZ_ANALYSIS_CLASS_ATTR_TYPE_VTABLE, rz_analysis_class_delete_attr_raw(), rz_analysis_class_unset_flag(), and rz_str_sanitize_sdb_key().

Referenced by rz_analysis_class_vtable_del_handler().

rz_analysis_class_vtable_delete_class()

static void rz_analysis_class_vtable_delete_class ( RzAnalysis *  analysis, const char *  class_name  )

static

Definition at line 1217 of file class.c.

                                                                                                {
    char *key = key_attr_type_attrs(class_name, attr_type_id(RZ_ANALYSIS_CLASS_ATTR_TYPE_VTABLE));
    if (!key) {
        return;
    }
    char *array = sdb_get(analysis->sdb_classes_attrs, key, 0);
    free(key);
    if (!array) {
        return;
    }
    char *cur;
    sdb_aforeach(cur, array) {
        rz_analysis_class_unset_flag(analysis, flagname_vtable(class_name, cur));
        sdb_aforeach_next(cur);
    }
    free(array);
}

References attr_type_id(), flagname_vtable(), free(), key, key_attr_type_attrs(), RZ_ANALYSIS_CLASS_ATTR_TYPE_VTABLE, rz_analysis_class_unset_flag(), sdb_aforeach, sdb_aforeach_next, rz_analysis_t::sdb_classes_attrs, and sdb_get().

Referenced by rz_analysis_class_delete().

rz_analysis_class_vtable_fini()

RZ_API void rz_analysis_class_vtable_fini

(

RzAnalysisVTable *

vtable

)

Definition at line 1069 of file class.c.

                                                                    {
    free(vtable->id);
}

References free().

Referenced by recovery_apply_vtable(), rz_analysis_class_vtable_add_handler(), and rz_analysis_class_vtable_fini_proxy().

rz_analysis_class_vtable_fini_proxy()

static void rz_analysis_class_vtable_fini_proxy ( void *  e, void *  user  )

static

Definition at line 1112 of file class.c.

                                                                     {
    (void)user;
    RzAnalysisVTable *vtable = e;
    rz_analysis_class_vtable_fini(vtable);
}

References e, and rz_analysis_class_vtable_fini().

Referenced by rz_analysis_class_vtable_get_all().

rz_analysis_class_vtable_get()

RZ_API RzAnalysisClassErr rz_analysis_class_vtable_get	(	RzAnalysis *	analysis,
		const char *	class_name,
		const char *	vtable_id,
		RzAnalysisVTable *	vtable
	)

Definition at line 1073 of file class.c.

                                                                                                                                                      {
    char *content = rz_analysis_class_get_attr(analysis, class_name, RZ_ANALYSIS_CLASS_ATTR_TYPE_VTABLE, vtable_id, false);
    if (!content) {
        return RZ_ANALYSIS_CLASS_ERR_NONEXISTENT_ATTR;
    }
 
    char *cur = content;
    char *next;
    sdb_anext(cur, &next);
 
    vtable->addr = rz_num_math(NULL, cur);
 
    cur = next;
    if (!cur) {
        free(content);
        return RZ_ANALYSIS_CLASS_ERR_OTHER;
    }
    sdb_anext(cur, &next);
 
    vtable->offset = rz_num_math(NULL, cur);
 
    if (next) {
        cur = next;
        sdb_anext(cur, NULL);
        vtable->size = rz_num_get(NULL, cur);
    } else {
        vtable->size = 0;
    }
 
    free(content);
 
    vtable->id = rz_str_sanitize_sdb_key(vtable_id);
    if (!vtable->id) {
        return RZ_ANALYSIS_CLASS_ERR_OTHER;
    }
 
    return RZ_ANALYSIS_CLASS_ERR_SUCCESS;
}

References free(), NULL, RZ_ANALYSIS_CLASS_ATTR_TYPE_VTABLE, rz_analysis_class_get_attr(), rz_num_get(), rz_num_math(), rz_str_sanitize_sdb_key(), and sdb_anext().

Referenced by rz_analysis_class_vtable_get_all().

rz_analysis_class_vtable_get_all()

RZ_API RzVector* rz_analysis_class_vtable_get_all	(	RzAnalysis *	analysis,
		const char *	class_name
	)

Definition at line 1118 of file class.c.

                                                                                                  {
    RzVector *vec = rz_vector_new(sizeof(RzAnalysisVTable), rz_analysis_class_vtable_fini_proxy, NULL);
    if (!vec) {
        return NULL;
    }
 
    char *class_name_sanitized = rz_str_sanitize_sdb_key(class_name);
    if (!class_name_sanitized) {
        rz_vector_free(vec);
        return NULL;
    }
    char *key = key_attr_type_attrs(class_name_sanitized, attr_type_id(RZ_ANALYSIS_CLASS_ATTR_TYPE_VTABLE));
    if (!key) {
        rz_vector_free(vec);
        free(class_name_sanitized);
        return NULL;
    }
    char *array = sdb_get(analysis->sdb_classes_attrs, key, 0);
    free(key);
    free(class_name_sanitized);
 
    rz_vector_reserve(vec, (size_t)sdb_alen(array));
    char *cur;
    sdb_aforeach(cur, array) {
        RzAnalysisVTable vtable;
        if (rz_analysis_class_vtable_get(analysis, class_name, cur, &vtable) == RZ_ANALYSIS_CLASS_ERR_SUCCESS) {
            rz_vector_push(vec, &vtable);
        }
        sdb_aforeach_next(cur);
    }
    free(array);
 
    return vec;
}

References attr_type_id(), free(), key, key_attr_type_attrs(), NULL, RZ_ANALYSIS_CLASS_ATTR_TYPE_VTABLE, rz_analysis_class_vtable_fini_proxy(), rz_analysis_class_vtable_get(), rz_str_sanitize_sdb_key(), rz_vector_free(), rz_vector_new(), rz_vector_push(), rz_vector_reserve(), sdb_aforeach, sdb_aforeach_next, sdb_alen(), rz_analysis_t::sdb_classes_attrs, and sdb_get().

Referenced by analysis_class_print(), analysis_class_print_as_cmd(), analysis_class_print_to_json(), list_all_functions_at_vtable_offset(), rz_analysis_class_vtable_list_handler(), and rz_analysis_class_vtable_set().

rz_analysis_class_vtable_rename_class()

static void rz_analysis_class_vtable_rename_class ( RzAnalysis *  analysis, const char *  old_class_name, const char *  new_class_name  )

static

Definition at line 1193 of file class.c.

                                                                                                                                {
    char *key = key_attr_type_attrs(old_class_name, attr_type_id(RZ_ANALYSIS_CLASS_ATTR_TYPE_VTABLE));
    if (!key) {
        return;
    }
    char *array = sdb_get(analysis->sdb_classes_attrs, key, 0);
    free(key);
    if (!array) {
        return;
    }
    char *cur;
    sdb_aforeach(cur, array) {
        char *old_fn = flagname_vtable(old_class_name, cur);
        char *new_fn = flagname_vtable(new_class_name, cur);
        if (old_fn && new_fn) {
            rz_analysis_class_rename_flag(analysis, old_fn, new_fn);
        }
        free(old_fn);
        free(new_fn);
        sdb_aforeach_next(cur);
    }
    free(array);
}

References attr_type_id(), flagname_vtable(), free(), key, key_attr_type_attrs(), RZ_ANALYSIS_CLASS_ATTR_TYPE_VTABLE, rz_analysis_class_rename_flag(), sdb_aforeach, sdb_aforeach_next, rz_analysis_t::sdb_classes_attrs, and sdb_get().

Referenced by rz_analysis_class_rename().

rz_analysis_class_vtable_set()

RZ_API RzAnalysisClassErr rz_analysis_class_vtable_set	(	RzAnalysis *	analysis,
		const char *	class_name,
		RzAnalysisVTable *	vtable
	)

Definition at line 1153 of file class.c.

                                                                                                                               {
    /* Check if vtable exists before setting it */
    RzVector /*<RzAnalysisVTable>*/ *vtables = rz_analysis_class_vtable_get_all(analysis, class_name);
    if (vtables) {
        RzAnalysisVTable *existing_vtable;
        rz_vector_foreach(vtables, existing_vtable) {
            if (vtable->addr == existing_vtable->addr) {
                rz_vector_free(vtables);
                return RZ_ANALYSIS_CLASS_ERR_OTHER;
            }
        }
    }
    rz_vector_free(vtables);
 
    char *content = rz_str_newf("0x%" PFMT64x SDB_SS "%" PFMT64u SDB_SS "%" PFMT64u, vtable->addr, vtable->offset, vtable->size);
    if (!content) {
        return RZ_ANALYSIS_CLASS_ERR_OTHER;
    }
    if (vtable->id) {
        RzAnalysisClassErr r = rz_analysis_class_set_attr(analysis, class_name, RZ_ANALYSIS_CLASS_ATTR_TYPE_VTABLE, vtable->id, content);
        free(content);
        return r;
    }
 
    vtable->id = malloc(16);
    if (!vtable->id) {
        free(content);
        return RZ_ANALYSIS_CLASS_ERR_OTHER;
    }
    RzAnalysisClassErr err = rz_analysis_class_add_attr_unique(analysis, class_name, RZ_ANALYSIS_CLASS_ATTR_TYPE_VTABLE, content, vtable->id, 16);
    free(content);
    if (err != RZ_ANALYSIS_CLASS_ERR_SUCCESS) {
        return err;
    }
 
    rz_analysis_class_set_flag(analysis, flagname_vtable(class_name, vtable->id), vtable->addr, vtable->size);
 
    return RZ_ANALYSIS_CLASS_ERR_SUCCESS;
}

References err, flagname_vtable(), free(), malloc(), PFMT64u, PFMT64x, r, rz_analysis_class_add_attr_unique(), RZ_ANALYSIS_CLASS_ATTR_TYPE_VTABLE, rz_analysis_class_set_attr(), rz_analysis_class_set_flag(), rz_analysis_class_vtable_get_all(), rz_str_newf(), rz_vector_foreach, rz_vector_free(), and SDB_SS.

Referenced by recovery_apply_vtable(), and rz_analysis_class_vtable_add_handler().

symbol_method_sort_by_addr()

static int symbol_method_sort_by_addr ( const void *  x, const void *  y  )

static

Definition at line 587 of file class.c.

                                                                    {
    RzBinSymbol *a = (RzBinSymbol *)x;
    RzBinSymbol *b = (RzBinSymbol *)y;
    if (a->vaddr > b->vaddr) {
        return 1;
    }
    if (a->vaddr < b->vaddr) {
        return -1;
    }
    return 0;
}

References a, b, and x.

Referenced by rz_analysis_class_method_recover().