serialize_core.c File Reference

#include <rz_util/rz_serialize.h>
#include <rz_core.h>

Go to the source code of this file.

Macros
#define	SUB(ns, call)   RZ_SERIALIZE_SUB_DO(db, subdb, res, ns, call, return false;)

Enumerations
enum	FileRet { FILE_SUCCESS , FILE_DOES_NOT_EXIST , FILE_LOAD_FAIL }

Functions
static void	file_save (RZ_NONNULL Sdb *db, RZ_NONNULL RzCore *core, RZ_NULLABLE const char *prj_file)
static bool	file_load (RZ_NONNULL Sdb *db, RZ_NONNULL RzCore *core, RZ_NULLABLE const char *prj_file, RZ_NULLABLE RzSerializeResultInfo *res)
RZ_API void	rz_serialize_core_save (RZ_NONNULL Sdb *db, RZ_NONNULL RzCore *core, RZ_NULLABLE const char *prj_file)
RZ_API bool	rz_serialize_core_load (RZ_NONNULL Sdb *db, RZ_NONNULL RzCore *core, bool load_bin_io, RZ_NULLABLE const char *prj_file, RZ_NULLABLE RzSerializeResultInfo *res)
static char *	prj_dir_abs (const char *prj_file)
static char *	prj_relative_make (const char *prj_dir, const char *abs_file)
static char *	prj_relative_restore (const char *prj_dir, const char *rel_file)
static FileRet	try_load_file (RZ_NONNULL RzCore *core, const char *file, RZ_NULLABLE RzSerializeResultInfo *res)

Variables
static const char *const	config_exclude []

Macro Definition Documentation

SUB

#define SUB	(		ns,
			call
	)		RZ_SERIALIZE_SUB_DO(db, subdb, res, ns, call, return false;)

Enumeration Type Documentation

FileRet

enum FileRet

Enumerator
FILE_SUCCESS
FILE_DOES_NOT_EXIST
FILE_LOAD_FAIL

Definition at line 196 of file serialize_core.c.

             {
    FILE_SUCCESS,
    FILE_DOES_NOT_EXIST,
    FILE_LOAD_FAIL
} FileRet;

Function Documentation

file_load()

static bool file_load ( RZ_NONNULL Sdb *  db, RZ_NONNULL RzCore *  core, RZ_NULLABLE const char *  prj_file, RZ_NULLABLE RzSerializeResultInfo *  res  )

static

Definition at line 217 of file serialize_core.c.

                                            {
    rz_core_file_close_fd(core, -1);
    rz_io_close_all(core->io);
    rz_bin_file_delete_all(core->bin);
 
    FileRet r = FILE_DOES_NOT_EXIST;
    const char *rel = sdb_const_get(db, "relative", 0);
    if (rel && prj_file) {
        char *prj_dir = prj_dir_abs(prj_file);
        if (prj_dir) {
            char *file = prj_relative_restore(prj_dir, rel);
            if (file) {
                r = try_load_file(core, file, res);
                free(file);
            }
            free(prj_dir);
        }
    }
    if (r != FILE_DOES_NOT_EXIST) {
        return r == FILE_SUCCESS;
    }
 
    const char *file = sdb_const_get(db, "absolute", 0);
    if (file) {
        r = try_load_file(core, file, res);
    }
    if (r != FILE_DOES_NOT_EXIST) {
        return r == FILE_SUCCESS;
    }
 
    file = sdb_const_get(db, "raw", 0);
    if (file) {
        r = try_load_file(core, file, res);
    }
    if (r != FILE_DOES_NOT_EXIST) {
        return r == FILE_SUCCESS;
    }
 
    RZ_SERIALIZE_ERR(res, "failed to re-locate file referenced by project");
    return false;
}

References FILE_DOES_NOT_EXIST, FILE_SUCCESS, free(), prj_dir_abs(), prj_relative_restore(), r, rz_bin_file_delete_all(), rz_core_file_close_fd(), rz_io_close_all(), RZ_SERIALIZE_ERR, sdb_const_get(), and try_load_file().

Referenced by rz_serialize_core_load().

file_save()

static void file_save ( RZ_NONNULL Sdb *  db, RZ_NONNULL RzCore *  core, RZ_NULLABLE const char *  prj_file  )

static

Definition at line 154 of file serialize_core.c.

                                                                                                     {
    rz_return_if_fail(db && core);
 
    if (!core->file) {
        return;
    }
    RzIODesc *desc = rz_io_desc_get(core->io, core->file->fd);
    if (!desc) {
        return;
    }
    if (!desc->plugin || strcmp(desc->plugin->name, "default")) {
        eprintf("Warning: The current file is not loaded as a regular file. "
            "This is not supported in projects yet and it will be necessary to manually re-load to use the project.\n");
        return;
    }
    const char *filename = desc->uri;
    if (!filename) {
        return;
    }
    sdb_set(db, "raw", filename, 0);
    char *abs = rz_file_abspath(filename);
    if (!abs) {
        return;
    }
    sdb_set(db, "absolute", abs, 0);
    if (prj_file) {
        char *prj_dir = prj_dir_abs(prj_file);
        if (!prj_dir) {
            goto beach;
        }
        char *rel = prj_relative_make(prj_dir, abs);
        if (rel) {
            sdb_set(db, "relative", rel, 0);
            free(rel);
        }
        free(prj_dir);
    }
beach:
    free(abs);
    return;
}

References desc, eprintf, free(), prj_dir_abs(), prj_relative_make(), rz_file_abspath(), rz_io_desc_get(), rz_return_if_fail, and sdb_set().

Referenced by rz_serialize_core_save().

prj_dir_abs()

static char* prj_dir_abs ( const char *  prj_file )

static

Definition at line 120 of file serialize_core.c.

                                               {
    char *prj_abs = rz_file_abspath(prj_file);
    if (!prj_abs) {
        return NULL;
    }
    char *r = rz_file_dirname(prj_abs);
    free(prj_abs);
    return r;
}

References free(), NULL, r, rz_file_abspath(), and rz_file_dirname().

Referenced by file_load(), and file_save().

prj_relative_make()

static char* prj_relative_make ( const char *  prj_dir, const char *  abs_file  )

static

Definition at line 131 of file serialize_core.c.

                                                                          {
    char *rel = rz_file_relpath(prj_dir, abs_file);
    if (!rel) {
        return NULL;
    }
    // convert only the relative path to a common format because it is the only path that makes any sense
    // when a project file is relocated to another machine. Absolute and raw are always specific to one environment.
    char *rel_unix = rz_file_path_local_to_unix(rel);
    free(rel);
    return rel_unix;
}

References free(), NULL, rz_file_path_local_to_unix(), and rz_file_relpath().

Referenced by file_save().

prj_relative_restore()

static char* prj_relative_restore ( const char *  prj_dir, const char *  rel_file  )

static

Definition at line 144 of file serialize_core.c.

                                                                             {
    char *rel_local = rz_file_path_unix_to_local(rel_file);
    if (!rel_local) {
        return NULL;
    }
    char *abs = rz_file_abspath_rel(prj_dir, rel_local);
    free(rel_local);
    return abs;
}

References free(), NULL, rz_file_abspath_rel(), and rz_file_path_unix_to_local().

Referenced by file_load().

rz_serialize_core_load()

RZ_API bool rz_serialize_core_load	(	RZ_NONNULL Sdb *	db,
		RZ_NONNULL RzCore *	core,
		bool	load_bin_io,
		RZ_NULLABLE const char *	prj_file,
		RZ_NULLABLE RzSerializeResultInfo *	res
	)

Definition at line 69 of file serialize_core.c.

                                                                              {
    Sdb *subdb;
 
#define SUB(ns, call) RZ_SERIALIZE_SUB_DO(db, subdb, res, ns, call, return false;)
 
    if (load_bin_io) {
        SUB("file", file_load(subdb, core, prj_file, res));
    }
    SUB("config", rz_serialize_config_load(subdb, core->config, config_exclude, res));
    SUB("flags", rz_serialize_flag_load(subdb, core->flags, res));
    SUB("analysis", rz_serialize_analysis_load(subdb, core->analysis, res));
    SUB("debug", rz_serialize_debug_load(subdb, core->dbg, res));
 
    const char *str = sdb_get(db, "offset", 0);
    if (!str || !*str) {
        RZ_SERIALIZE_ERR(res, "missing offset in core");
        return false;
    }
    core->offset = strtoull(str, NULL, 0);
 
    str = sdb_get(db, "blocksize", 0);
    if (!str || !*str) {
        RZ_SERIALIZE_ERR(res, "missing blocksize in core");
        return false;
    }
    ut64 bs = strtoull(str, NULL, 0);
    rz_core_block_size(core, (int)bs);
 
    // handled by config already:
    // cfglog, cmdrepeat, cmdtimes
 
    return true;
}

References config_exclude, file_load(), NULL, rz_core_block_size(), rz_serialize_analysis_load(), rz_serialize_config_load(), rz_serialize_debug_load(), RZ_SERIALIZE_ERR, rz_serialize_flag_load(), sdb_get(), cmd_descs_generate::str, SUB, and ut64().

Referenced by rz_project_load().

rz_serialize_core_save()

RZ_API void rz_serialize_core_save	(	RZ_NONNULL Sdb *	db,
		RZ_NONNULL RzCore *	core,
		RZ_NULLABLE const char *	prj_file
	)

Definition at line 23 of file serialize_core.c.

                                                                                                                  {
    file_save(sdb_ns(db, "file", true), core, prj_file);
    rz_serialize_config_save(sdb_ns(db, "config", true), core->config);
    rz_serialize_flag_save(sdb_ns(db, "flags", true), core->flags);
    rz_serialize_analysis_save(sdb_ns(db, "analysis", true), core->analysis);
    rz_serialize_debug_save(sdb_ns(db, "debug", true), core->dbg);
 
    char buf[0x20];
    if (snprintf(buf, sizeof(buf), "0x%" PFMT64x, core->offset) < 0) {
        return;
    }
    sdb_set(db, "offset", buf, 0);
 
    if (snprintf(buf, sizeof(buf), "0x%" PFMT32x, core->blocksize) < 0) {
        return;
    }
    sdb_set(db, "blocksize", buf, 0);
}

References file_save(), PFMT32x, PFMT64x, rz_serialize_analysis_save(), rz_serialize_config_save(), rz_serialize_debug_save(), rz_serialize_flag_save(), sdb_ns(), sdb_set(), and snprintf.

Referenced by rz_project_save().

try_load_file()

static FileRet try_load_file ( RZ_NONNULL RzCore *  core, const char *  file, RZ_NULLABLE RzSerializeResultInfo *  res  )

static

Definition at line 202 of file serialize_core.c.

                                                                                                                {
    if (!rz_file_is_regular(file)) {
        return FILE_DOES_NOT_EXIST;
    }
 
    RzCoreFile *fh = rz_core_file_open(core, file, RZ_PERM_RX, 0);
    if (!fh) {
        RZ_SERIALIZE_ERR(res, "failed re-open file \"%s\" referenced by project", file);
        return FILE_LOAD_FAIL;
    }
    rz_core_bin_load(core, file, UT64_MAX);
 
    return FILE_SUCCESS;
}

References fh, FILE_DOES_NOT_EXIST, FILE_LOAD_FAIL, FILE_SUCCESS, rz_core_bin_load(), rz_core_file_open(), rz_file_is_regular(), RZ_PERM_RX, RZ_SERIALIZE_ERR, and UT64_MAX.

Referenced by file_load().

Variable Documentation

config_exclude

const char* const config_exclude[]

static

Initial value:

= {
    "dir.home",
    "dir.libs",
    "dir.magic",
    "dir.plugins",
    "dir.prefix",
    "dir.projects",
    "dir.source",
    "dir.tmp",
    "dir.types",
    "http.root",
    "pdb.symstore",
    "scr.color",
    "scr.color.args",
    "scr.color.bytes",
    "scr.color.grep",
    "scr.color.ops",
    "scr.color.pipe",
    "scr.interactive", 
    "scr.prompt", 
    "scr.rainbow",
    "scr.utf8",
    "scr.utf8.curvy",
    "ghidra.sleighhome", 
    NULL
}

Definition at line 42 of file serialize_core.c.

Referenced by rz_serialize_core_load().