sdb.h File Reference

#include <rz_types.h>
#include "sdbht.h"
#include "ls.h"
#include "cdb.h"
#include "cdb_make.h"

Go to the source code of this file.

Classes
struct	sdb_t
struct	sdb_ns_t
struct	sdb_diff_t

Macros
#define	SDB_CDB_MIN_VALUE   1
#define	SDB_CDB_MAX_VALUE   CDB_MAX_VALUE
#define	SDB_CDB_MIN_KEY   1
#define	SDB_CDB_MAX_KEY   CDB_MAX_KEY
#define	SDB_MODE   0644
#define	SDB_RS   ','
#define	SDB_SS   ","
#define	SDB_MAX_PATH   256
#define	SDB_NUM_BASE   16
#define	SDB_NUM_BUFSZ   64
#define	SDB_OPTION_NONE   0
#define	SDB_OPTION_ALL   0xff
#define	SDB_OPTION_SYNC   (1 << 0)
#define	SDB_OPTION_NOSTAMP   (1 << 1)
#define	SDB_OPTION_FS   (1 << 2)
#define	SDB_OPTION_JOURNAL   (1 << 3)
#define	SDB_LIST_UNSORTED   0
#define	SDB_LIST_SORTED   1
#define	sdb_aforeach(x, y)
#define	sdb_aforeach_next(x)

Typedefs
typedef struct sdb_t	Sdb
typedef struct sdb_ns_t	SdbNs
typedef bool(*	SdbForeachCallback) (void *user, const char *k, const char *v)
typedef struct sdb_diff_t	SdbDiff
typedef void(*	SdbDiffCallback) (const SdbDiff *diff, void *user)
typedef void(*	SdbHook) (Sdb *s, void *user, const char *k, const char *v)

Functions
RZ_API Sdb *	sdb_new0 (void)
RZ_API Sdb *	sdb_new (const char *path, const char *file, int lock)
RZ_API int	sdb_open (Sdb *s, const char *file)
RZ_API void	sdb_close (Sdb *s)
RZ_API void	sdb_config (Sdb *s, int options)
RZ_API bool	sdb_free (Sdb *s)
RZ_API void	sdb_file (Sdb *s, const char *dir)
RZ_API bool	sdb_merge (Sdb *d, Sdb *s)
RZ_API int	sdb_count (Sdb *s)
RZ_API void	sdb_reset (Sdb *s)
RZ_API void	sdb_setup (Sdb *s, int options)
RZ_API void	sdb_drain (Sdb *, Sdb *)
RZ_API void	sdb_copy (Sdb *src, Sdb *dst)
RZ_API bool	sdb_stats (Sdb *s, ut32 *disk, ut32 *mem)
RZ_API bool	sdb_dump_hasnext (Sdb *s)
RZ_API bool	sdb_foreach (Sdb *s, SdbForeachCallback cb, void *user)
RZ_API SdbList *	sdb_foreach_list (Sdb *s, bool sorted)
RZ_API SdbList *	sdb_foreach_list_filter_user (Sdb *s, SdbForeachCallback filter, bool sorted, void *user)
RZ_API SdbList *	sdb_foreach_list_filter (Sdb *s, SdbForeachCallback filter, bool sorted)
RZ_API SdbList *	sdb_foreach_match (Sdb *s, const char *expr, bool sorted)
RZ_API int	sdb_query (Sdb *s, const char *cmd)
RZ_API int	sdb_queryf (Sdb *s, const char *fmt,...)
RZ_API int	sdb_query_lines (Sdb *s, const char *cmd)
RZ_API char *	sdb_querys (Sdb *s, char *buf, size_t len, const char *cmd)
RZ_API char *	sdb_querysf (Sdb *s, char *buf, size_t buflen, const char *fmt,...)
RZ_API int	sdb_query_file (Sdb *s, const char *file)
RZ_API bool	sdb_exists (Sdb *, const char *key)
RZ_API bool	sdb_remove (Sdb *, const char *key, ut32 cas)
RZ_API int	sdb_unset (Sdb *, const char *key, ut32 cas)
RZ_API int	sdb_unset_like (Sdb *s, const char *k)
RZ_API char **	sdb_like (Sdb *s, const char *k, const char *v, SdbForeachCallback cb)
RZ_API int	sdb_diff_format (char *str, int size, const SdbDiff *diff)
RZ_API bool	sdb_diff (Sdb *a, Sdb *b, SdbDiffCallback cb, void *cb_user)
RZ_API char *	sdb_get (Sdb *, const char *key, ut32 *cas)
RZ_API char *	sdb_get_len (Sdb *, const char *key, int *vlen, ut32 *cas)
RZ_API const char *	sdb_const_get (Sdb *, const char *key, ut32 *cas)
RZ_API const char *	sdb_const_get_len (Sdb *s, const char *key, int *vlen, ut32 *cas)
RZ_API int	sdb_set (Sdb *, const char *key, const char *data, ut32 cas)
RZ_API int	sdb_set_owned (Sdb *s, const char *key, char *val, ut32 cas)
RZ_API int	sdb_concat (Sdb *s, const char *key, const char *value, ut32 cas)
RZ_API int	sdb_uncat (Sdb *s, const char *key, const char *value, ut32 cas)
RZ_API int	sdb_add (Sdb *s, const char *key, const char *val, ut32 cas)
RZ_API bool	sdb_sync (Sdb *)
RZ_API void	sdbkv_free (SdbKv *kv)
RZ_API bool	sdb_num_exists (Sdb *, const char *key)
RZ_API int	sdb_num_base (const char *s)
RZ_API ut64	sdb_num_get (Sdb *s, const char *key, ut32 *cas)
RZ_API int	sdb_num_set (Sdb *s, const char *key, ut64 v, ut32 cas)
RZ_API int	sdb_num_add (Sdb *s, const char *key, ut64 v, ut32 cas)
RZ_API ut64	sdb_num_inc (Sdb *s, const char *key, ut64 n, ut32 cas)
RZ_API ut64	sdb_num_dec (Sdb *s, const char *key, ut64 n, ut32 cas)
RZ_API int	sdb_num_min (Sdb *s, const char *key, ut64 v, ut32 cas)
RZ_API int	sdb_num_max (Sdb *s, const char *key, ut64 v, ut32 cas)
RZ_API int	sdb_ptr_set (Sdb *db, const char *key, void *p, ut32 cas)
RZ_API void *	sdb_ptr_get (Sdb *db, const char *key, ut32 *cas)
RZ_API bool	sdb_disk_create (Sdb *s)
RZ_API bool	sdb_disk_insert (Sdb *s, const char *key, const char *val)
RZ_API bool	sdb_disk_finish (Sdb *s)
RZ_API bool	sdb_disk_unlink (Sdb *s)
RZ_API bool	sdb_text_save_fd (Sdb *s, int fd, bool sort)
RZ_API bool	sdb_text_save (Sdb *s, const char *file, bool sort)
RZ_API bool	sdb_text_load_buf (Sdb *s, char *buf, size_t sz)
RZ_API bool	sdb_text_load (Sdb *s, const char *file)
RZ_API void	sdb_dump_begin (Sdb *s)
RZ_API SdbKv *	sdb_dump_next (Sdb *s)
RZ_API bool	sdb_dump_dupnext (Sdb *s, char *key, char **value, int *_vlen)
RZ_API bool	sdb_journal_close (Sdb *s)
RZ_API bool	sdb_journal_open (Sdb *s)
RZ_API int	sdb_journal_load (Sdb *s)
RZ_API bool	sdb_journal_log (Sdb *s, const char *key, const char *val)
RZ_API bool	sdb_journal_clear (Sdb *s)
RZ_API bool	sdb_journal_unlink (Sdb *s)
RZ_API char *	sdb_itoa (ut64 n, char *s, int base)
RZ_API ut64	sdb_atoi (const char *s)
RZ_API const char *	sdb_itoca (ut64 n)
RZ_API bool	sdb_lock (const char *s)
RZ_API const char *	sdb_lock_file (const char *f)
RZ_API void	sdb_unlock (const char *s)
RZ_API bool	sdb_unlink (Sdb *s)
RZ_API int	sdb_lock_wait (RZ_UNUSED const char *s)
RZ_API bool	sdb_expire_set (Sdb *s, const char *key, ut64 expire, ut32 cas)
RZ_API ut64	sdb_expire_get (Sdb *s, const char *key, ut32 *cas)
RZ_API ut64	sdb_now (void)
RZ_API ut64	sdb_unow (void)
RZ_API ut32	sdb_hash (const char *key)
RZ_API ut32	sdb_hash_len (const char *key, ut32 *len)
RZ_API ut8	sdb_hash_byte (const char *s)
RZ_API Sdb *	sdb_ns (Sdb *s, const char *name, int create)
RZ_API Sdb *	sdb_ns_path (Sdb *s, const char *path, int create)
RZ_API void	sdb_ns_init (Sdb *s)
RZ_API void	sdb_ns_free_all (Sdb *s)
RZ_API void	sdb_ns_lock (Sdb *s, int lock, int depth)
RZ_API void	sdb_ns_sync (Sdb *s)
RZ_API int	sdb_ns_set (Sdb *s, const char *name, Sdb *r)
RZ_API bool	sdb_ns_unset (Sdb *s, const char *name, Sdb *r)
RZ_API bool	sdb_array_contains (Sdb *s, const char *key, const char *val, ut32 *cas)
RZ_API bool	sdb_array_contains_num (Sdb *s, const char *key, ut64 val, ut32 *cas)
RZ_API int	sdb_array_indexof (Sdb *s, const char *key, const char *val, ut32 cas)
RZ_API int	sdb_array_set (Sdb *s, const char *key, int idx, const char *val, ut32 cas)
RZ_API int	sdb_array_set_num (Sdb *s, const char *key, int idx, ut64 val, ut32 cas)
RZ_API bool	sdb_array_append (Sdb *s, const char *key, const char *val, ut32 cas)
RZ_API bool	sdb_array_append_num (Sdb *s, const char *key, ut64 val, ut32 cas)
RZ_API bool	sdb_array_prepend (Sdb *s, const char *key, const char *val, ut32 cas)
RZ_API bool	sdb_array_prepend_num (Sdb *s, const char *key, ut64 val, ut32 cas)
RZ_API char *	sdb_array_get (Sdb *s, const char *key, int idx, ut32 *cas)
RZ_API ut64	sdb_array_get_num (Sdb *s, const char *key, int idx, ut32 *cas)
RZ_API int	sdb_array_get_idx (Sdb *s, const char *key, const char *val, ut32 cas)
RZ_API int	sdb_array_insert (Sdb *s, const char *key, int idx, const char *val, ut32 cas)
RZ_API int	sdb_array_insert_num (Sdb *s, const char *key, int idx, ut64 val, ut32 cas)
RZ_API int	sdb_array_unset (Sdb *s, const char *key, int n, ut32 cas)
RZ_API int	sdb_array_delete (Sdb *s, const char *key, int n, ut32 cas)
RZ_API void	sdb_array_sort (Sdb *s, const char *key, ut32 cas)
RZ_API void	sdb_array_sort_num (Sdb *s, const char *key, ut32 cas)
RZ_API int	sdb_array_add (Sdb *s, const char *key, const char *val, ut32 cas)
RZ_API int	sdb_array_add_num (Sdb *s, const char *key, ut64 val, ut32 cas)
RZ_API int	sdb_array_add_sorted (Sdb *s, const char *key, const char *val, ut32 cas)
RZ_API int	sdb_array_add_sorted_num (Sdb *s, const char *key, ut64 val, ut32 cas)
RZ_API int	sdb_array_remove (Sdb *s, const char *key, const char *val, ut32 cas)
RZ_API int	sdb_array_remove_num (Sdb *s, const char *key, ut64 val, ut32 cas)
RZ_API char *	sdb_anext (char *str, char **next)
RZ_API const char *	sdb_const_anext (const char *str)
RZ_API int	sdb_alen (const char *str)
RZ_API int	sdb_alen_ignore_empty (const char *str)
RZ_API int	sdb_array_size (Sdb *s, const char *key)
RZ_API int	sdb_array_length (Sdb *s, const char *key)
int	sdb_array_list (Sdb *s, const char *key)
RZ_API bool	sdb_array_push (Sdb *s, const char *key, const char *val, ut32 cas)
RZ_API char *	sdb_array_pop (Sdb *s, const char *key, ut32 *cas)
RZ_API int	sdb_array_push_num (Sdb *s, const char *key, ut64 num, ut32 cas)
RZ_API ut64	sdb_array_pop_num (Sdb *s, const char *key, ut32 *cas)
RZ_API char *	sdb_array_pop_head (Sdb *s, const char *key, ut32 *cas)
RZ_API char *	sdb_array_pop_tail (Sdb *s, const char *key, ut32 *cas)
RZ_API void	sdb_global_hook (SdbHook hook, void *user)
RZ_API bool	sdb_hook (Sdb *s, SdbHook cb, void *user)
RZ_API bool	sdb_unhook (Sdb *s, SdbHook h)
RZ_API int	sdb_hook_call (Sdb *s, const char *k, const char *v)
RZ_API void	sdb_hook_free (Sdb *s)
RZ_API int	sdb_isnum (const char *s)
RZ_API bool	sdb_isempty (Sdb *s)
RZ_API const char *	sdb_type (const char *k)
RZ_API bool	sdb_match (const char *str, const char *glob)
RZ_API int	sdb_bool_set (Sdb *db, const char *str, bool v, ut32 cas)
RZ_API bool	sdb_bool_get (Sdb *db, const char *str, ut32 *cas)
RZ_API ut8 *	sdb_decode (const char *in, int *len)
RZ_API char *	sdb_encode (const ut8 *bin, int len)
RZ_API void	sdb_encode_raw (char *bout, const ut8 *bin, int len)
RZ_API int	sdb_decode_raw (ut8 *bout, const char *bin, int len)
RZ_API char *	sdb_fmt (const char *fmt,...) RZ_PRINTF_CHECK(1
RZ_API char RZ_API int	sdb_fmt_init (void *p, const char *fmt)
RZ_API void	sdb_fmt_free (void *p, const char *fmt)
RZ_API int	sdb_fmt_tobin (const char *_str, const char *fmt, void *stru)
RZ_API char *	sdb_fmt_tostr (void *stru, const char *fmt)
RZ_API char **	sdb_fmt_array (const char *list)
RZ_API ut64 *	sdb_fmt_array_num (const char *list)
RZ_API char *	sdb_array_compact (char *p)
RZ_API char *	sdb_aslice (char *out, int from, int to)

Macro Definition Documentation

sdb_aforeach

#define sdb_aforeach	(		x,
			y
	)

Value:

    { \
        char *next; \
        if (y) \
            for (x = y;;) { \
                x = sdb_anext(x, &next);

Definition at line 342 of file sdb.h.

sdb_aforeach_next

#define sdb_aforeach_next

(

x

)

Value:

    if (!next) \
        break; \
    *(next - 1) = ','; \
    x = next; \
    } \
    }

Definition at line 348 of file sdb.h.

SDB_CDB_MAX_KEY

#define SDB_CDB_MAX_KEY   CDB_MAX_KEY

Definition at line 21 of file sdb.h.

SDB_CDB_MAX_VALUE

#define SDB_CDB_MAX_VALUE   CDB_MAX_VALUE

Definition at line 19 of file sdb.h.

SDB_CDB_MIN_KEY

#define SDB_CDB_MIN_KEY   1

Definition at line 20 of file sdb.h.

SDB_CDB_MIN_VALUE

#define SDB_CDB_MIN_VALUE   1

Definition at line 18 of file sdb.h.

SDB_LIST_SORTED

#define SDB_LIST_SORTED   1

Definition at line 61 of file sdb.h.

SDB_LIST_UNSORTED

#define SDB_LIST_UNSORTED   0

Definition at line 60 of file sdb.h.

SDB_MAX_PATH

#define SDB_MAX_PATH   256

Definition at line 49 of file sdb.h.

SDB_MODE

#define SDB_MODE   0644

Definition at line 42 of file sdb.h.

SDB_NUM_BASE

#define SDB_NUM_BASE   16

Definition at line 50 of file sdb.h.

SDB_NUM_BUFSZ

#define SDB_NUM_BUFSZ   64

Definition at line 51 of file sdb.h.

SDB_OPTION_ALL

#define SDB_OPTION_ALL   0xff

Definition at line 54 of file sdb.h.

SDB_OPTION_FS

#define SDB_OPTION_FS   (1 << 2)

Definition at line 57 of file sdb.h.

SDB_OPTION_JOURNAL

#define SDB_OPTION_JOURNAL   (1 << 3)

Definition at line 58 of file sdb.h.

SDB_OPTION_NONE

#define SDB_OPTION_NONE   0

Definition at line 53 of file sdb.h.

SDB_OPTION_NOSTAMP

#define SDB_OPTION_NOSTAMP   (1 << 1)

Definition at line 56 of file sdb.h.

SDB_OPTION_SYNC

#define SDB_OPTION_SYNC   (1 << 0)

Definition at line 55 of file sdb.h.

SDB_RS

#define SDB_RS   ','

Definition at line 47 of file sdb.h.

SDB_SS

#define SDB_SS   ","

Definition at line 48 of file sdb.h.

Typedef Documentation

Sdb

typedef struct sdb_t Sdb

SdbDiff

typedef struct sdb_diff_t SdbDiff

SdbDiffCallback

typedef void(* SdbDiffCallback) (const SdbDiff *diff, void *user)

Definition at line 145 of file sdb.h.

SdbForeachCallback

typedef bool(* SdbForeachCallback) (void *user, const char *k, const char *v)

Definition at line 115 of file sdb.h.

SdbHook

typedef void(* SdbHook) (Sdb *s, void *user, const char *k, const char *v)

Definition at line 308 of file sdb.h.

SdbNs

typedef struct sdb_ns_t SdbNs

Function Documentation

sdb_add()

RZ_API int sdb_add	(	Sdb *	s,
		const char *	key,
		const char *	val,
		ut32	cas
	)

Definition at line 351 of file sdb.c.

                                                                       {
    if (sdb_exists(s, key)) {
        return 0;
    }
    return sdb_set(s, key, val, cas);
}

References key, s, sdb_exists(), sdb_set(), and val.

Referenced by sdb_num_add().

sdb_alen()

RZ_API int sdb_alen

(

const char *

str

)

Definition at line 151 of file util.c.

                                     {
    int len = 1;
    const char *n, *p = str;
    if (!p || !*p) {
        return 0;
    }
    for (len = 0;; len++) {
        n = strchr(p, SDB_RS);
        if (!n) {
            break;
        }
        p = n + 1;
    }
    return ++len;
}

References len, n, p, SDB_RS, and cmd_descs_generate::str.

Referenced by get_enum_type(), get_struct_type(), get_union_type(), rz_analysis_class_base_get_all(), rz_analysis_class_method_get_all(), rz_analysis_class_vtable_get_all(), sdb_array_delete(), sdb_array_get(), sdb_array_set(), sdb_array_size(), sdb_fmt_array(), and sdb_fmt_array_num().

sdb_alen_ignore_empty()

RZ_API int sdb_alen_ignore_empty

(

const char *

str

)

Definition at line 167 of file util.c.

                                                  {
    int len = 1;
    const char *n, *p = str;
    if (!p || !*p) {
        return 0;
    }
    while (*p == SDB_RS) {
        p++;
    }
    for (len = 0;;) {
        n = strchr(p, SDB_RS);
        if (!n) {
            break;
        }
        p = n + 1;
        if (*(p) == SDB_RS) {
            continue;
        }
        len++;
    }
    if (*p)
        len++;
    return len;
}

References len, n, p, SDB_RS, and cmd_descs_generate::str.

Referenced by sdb_array_length().

sdb_anext()

RZ_API char* sdb_anext	(	char *	str,
		char **	next
	)

Definition at line 192 of file util.c.

                                               {
    char *nxt, *p = strchr(str, SDB_RS);
    if (p) {
        *p = 0;
        nxt = p + 1;
    } else {
        nxt = NULL;
    }
    if (next) {
        *next = nxt;
    }
    return str;
}

References NULL, p, SDB_RS, and cmd_descs_generate::str.

Referenced by get_callable_type(), get_struct_type(), get_union_type(), rz_analysis_class_base_get(), rz_analysis_class_method_get(), rz_analysis_class_vtable_get(), rz_analysis_dwarf_integrate_functions(), and sdb_fmt_tobin().

sdb_array_add()

RZ_API int sdb_array_add	(	Sdb *	s,
		const char *	key,
		const char *	val,
		ut32	cas
	)

Definition at line 224 of file array.c.

                                                                             {
    if (sdb_array_contains(s, key, val, NULL)) {
        return 0;
    }
    return sdb_array_insert(s, key, -1, val, cas);
}

References key, NULL, s, sdb_array_contains(), sdb_array_insert(), and val.

Referenced by hook_command(), hook_flag_read(), hook_reg_read(), hook_reg_write(), rz_agraph_add_edge(), rz_agraph_add_node_with_color(), rz_analysis_class_rename_attr_raw(), rz_analysis_class_set_attr_raw(), sdb_array_add_num(), and sdb_querys().

sdb_array_add_num()

RZ_API int sdb_array_add_num	(	Sdb *	s,
		const char *	key,
		ut64	val,
		ut32	cas
	)

Definition at line 211 of file array.c.

                                                                          {
    char buf[SDB_NUM_BUFSZ];
    char *v = sdb_itoa(val, buf, SDB_NUM_BASE);
    if (!sdb_array_contains(s, key, v, NULL)) {
        if (val < 256) {
            char *v = sdb_itoa(val, buf, 10);
            return sdb_array_add(s, key, v, cas);
        }
    }
    return sdb_array_add(s, key, v, cas);
}

References key, NULL, s, sdb_array_add(), sdb_array_contains(), sdb_itoa(), SDB_NUM_BASE, SDB_NUM_BUFSZ, v, and val.

Referenced by core_analysis_graph_construct_edges(), hook_mem_read(), and hook_mem_write().

sdb_array_add_sorted()

RZ_API int sdb_array_add_sorted	(	Sdb *	s,
		const char *	key,
		const char *	val,
		ut32	cas
	)

Definition at line 231 of file array.c.

                                                                                    {
    int lstr, lval, i, j;
    const char *str_e, *str_lp, *str_p, *str = sdb_const_get_len(s, key, &lstr, 0);
    char *nstr, *nstr_p, **vals;
    const char null = '\0';
    if (!str || !*str) {
        str = &null;
        lstr = 0;
    }
    str_e = str + lstr;
    str_lp = str_p = str;
    if (!val || !*val) {
        return 1;
    }
    lval = strlen(val);
    vals = sdb_fmt_array(val);
    for (i = 0; vals[i]; i++) {
        /* empty */
    }
    if (i > 1) {
        qsort(vals, i, sizeof(ut64 *), cstring_cmp);
    }
    nstr_p = nstr = malloc(lstr + lval + 3);
    if (!nstr) {
        return 1;
    }
    for (i = 0; vals[i]; i++) {
        while (str_p < str_e) {
            if (astrcmp(vals[i], str_p) < 0) {
                break;
            }
            str_p = sdb_const_anext(str_p);
            if (!str_p) {
                str_p = str_e;
            }
        }
        memcpy(nstr_p, str_lp, str_p - str_lp);
        nstr_p += str_p - str_lp;
        if (str_p == str_e && str_lp != str_e) {
            *(nstr_p++) = SDB_RS;
        }
        str_lp = str_p;
        j = strlen(vals[i]);
        memcpy(nstr_p, vals[i], j);
        nstr_p += j;
        *(nstr_p++) = SDB_RS;
    }
    if (str_lp < str_e) {
        memcpy(nstr_p, str_lp, str_e - str_lp);
        nstr_p += str_e - str_lp;
        *(nstr_p) = '\0';
    } else {
        *(--nstr_p) = '\0';
    }
    sdb_set_owned(s, key, nstr, cas);
    free(vals);
    return 0;
}

References astrcmp(), cstring_cmp(), free(), i, key, malloc(), memcpy(), qsort(), s, sdb_const_anext(), sdb_const_get_len(), sdb_fmt_array(), SDB_RS, sdb_set_owned(), cmd_descs_generate::str, ut64(), and val.

Referenced by sdb_querys().

sdb_array_add_sorted_num()

RZ_API int sdb_array_add_sorted_num	(	Sdb *	s,
		const char *	key,
		ut64	val,
		ut32	cas
	)

Definition at line 290 of file array.c.

              {
    int i;
    char valstr[SDB_NUM_BUFSZ];
    const char *str = sdb_const_get(s, key, 0);
    const char *n = str;
    if (!str || !*str) {
        return sdb_set(s, key, sdb_itoa(val, valstr, SDB_NUM_BASE), cas);
    }
    for (i = 0; n; i++) {
        if (val <= sdb_atoi(n)) {
            break;
        }
        n = sdb_const_anext(n);
    }
    return sdb_array_insert_num(s, key, n ? i : -1, val, cas);
}

References i, key, n, s, sdb_array_insert_num(), sdb_atoi(), sdb_const_anext(), sdb_const_get(), sdb_itoa(), SDB_NUM_BASE, SDB_NUM_BUFSZ, sdb_set(), cmd_descs_generate::str, and val.

Referenced by sdb_querys().

sdb_array_append()

RZ_API bool sdb_array_append	(	Sdb *	s,
		const char *	key,
		const char *	val,
		ut32	cas
	)

Definition at line 312 of file array.c.

              {
    int str_len = 0;
    ut32 kas = cas;
    const char *str = sdb_const_get_len(s, key, &str_len, &kas);
    if (!val || (cas && cas != kas)) {
        return false;
    }
    cas = kas;
    if (str && *str && str_len > 0) {
        int val_len = strlen(val);
        char *newval = malloc(str_len + val_len + 2);
        if (!newval) {
            return false;
        }
        memcpy(newval, str, str_len);
        newval[str_len] = SDB_RS;
        memcpy(newval + str_len + 1, val, val_len);
        newval[str_len + val_len + 1] = 0;
        sdb_set_owned(s, key, newval, cas);
    } else {
        sdb_set(s, key, val, cas);
    }
    return true;
}

References key, malloc(), memcpy(), s, sdb_const_get_len(), SDB_RS, sdb_set(), sdb_set_owned(), cmd_descs_generate::str, and val.

sdb_array_append_num()

RZ_API bool sdb_array_append_num	(	Sdb *	s,
		const char *	key,
		ut64	val,
		ut32	cas
	)

Definition at line 338 of file array.c.

                                                                              {
    return sdb_array_set_num(s, key, -1, val, cas);
}

References key, s, sdb_array_set_num(), and val.

sdb_array_compact()

RZ_API char* sdb_array_compact

(

char *

p

)

Definition at line 99 of file util.c.

                                        {
    char *e;
    // remove empty elements
    while (*p) {
        if (!strncmp(p, ",,", 2)) {
            p++;
            for (e = p + 1; *e == ','; e++) {
            };
            memmove(p, e, strlen(e) + 1);
        } else {
            p++;
        }
    }
    return p;
}

References e, and p.

sdb_array_contains()

RZ_API bool sdb_array_contains	(	Sdb *	s,
		const char *	key,
		const char *	val,
		ut32 *	cas
	)

Definition at line 497 of file array.c.

                                                                                    {
    if (!s || !key || !val) {
        return false;
    }
    const char *next, *ptr = sdb_const_get(s, key, cas);
    if (ptr && *ptr) {
        size_t vlen = strlen(val);
        while (1) {
            next = strchr(ptr, SDB_RS);
            size_t len = next ? (size_t)(next - ptr) : strlen(ptr);
            if (len == vlen && !memcmp(ptr, val, len)) {
                return true;
            }
            if (!next) {
                break;
            }
            ptr = next + 1;
        }
    }
    return false;
}

References key, len, s, sdb_const_get(), SDB_RS, and val.

Referenced by rz_analysis_class_rename_attr_raw(), rz_analysis_class_unique_attr_id_raw(), sdb_array_add(), sdb_array_add_num(), and sdb_array_contains_num().

sdb_array_contains_num()

RZ_API bool sdb_array_contains_num	(	Sdb *	s,
		const char *	key,
		ut64	val,
		ut32 *	cas
	)

Definition at line 491 of file array.c.

                                                                                 {
    char val[SDB_NUM_BUFSZ];
    char *nval = sdb_itoa(num, val, SDB_NUM_BASE);
    return sdb_array_contains(s, key, nval, cas);
}

References key, num, s, sdb_array_contains(), sdb_itoa(), SDB_NUM_BASE, SDB_NUM_BUFSZ, and val.

sdb_array_delete()

RZ_API int sdb_array_delete	(	Sdb *	s,
		const char *	key,
		int	n,
		ut32	cas
	)

Definition at line 456 of file array.c.

                                                                        {
    int i;
    char *p, *n, *str = sdb_get(s, key, 0);
    p = str;
    if (!str || !*str) {
        free(str);
        return 0;
    }
    if (idx < 0) {
        idx = sdb_alen(str);
        if (idx)
            idx--;
    }
    for (i = 0; i < idx; i++) {
        if ((n = strchr(p, SDB_RS))) {
            p = n + 1;
        } else {
            free(str);
            return 0;
        }
    }
    n = strchr(p, SDB_RS);
    if (n) {
        memmove(p, n + 1, strlen(n));
    } else {
        if (p != str)
            p--; // remove tailing SDB_RS
        *p = 0;
        p[1] = 0;
    }
    sdb_set_owned(s, key, str, cas);
    return 1;
}

References free(), i, setup::idx, key, n, p, s, sdb_alen(), sdb_get(), SDB_RS, sdb_set_owned(), and cmd_descs_generate::str.

Referenced by sdb_array_remove(), sdb_array_remove_num(), and sdb_querys().

sdb_array_get()

RZ_API char* sdb_array_get	(	Sdb *	s,
		const char *	key,
		int	idx,
		ut32 *	cas
	)

Definition at line 81 of file array.c.

                                                                        {
    const char *str = sdb_const_get(s, key, cas);
    const char *p = str;
    char *o, *n;
    int i, len;
    if (!str || !*str) {
        return NULL;
    }
    if (idx < 0) {
        int len = sdb_alen(str);
        idx = -idx;
        if (idx > len) {
            return NULL;
        }
        idx = len - idx;
    }
    if (!idx) {
        n = strchr(str, SDB_RS);
        if (!n) {
            return strdup(str);
        }
        len = n - str;
        o = malloc(len + 1);
        if (!o) {
            return NULL;
        }
        memcpy(o, str, len);
        o[len] = 0;
        return o;
    }
    for (i = 0; i < idx; i++) {
        n = strchr(p, SDB_RS);
        if (!n)
            return NULL;
        p = n + 1;
    }
    n = strchr(p, SDB_RS);
    if (!n) {
        return strdup(p);
    }
    len = n - p;
    o = malloc(len + 1);
    if (o) {
        memcpy(o, p, len);
        o[len] = 0;
        return o;
    }
    return NULL;
}

References i, setup::idx, key, len, malloc(), memcpy(), n, NULL, p, s, sdb_alen(), sdb_const_get(), SDB_RS, cmd_descs_generate::str, and strdup().

Referenced by sdb_querys().

sdb_array_get_idx()

RZ_API int sdb_array_get_idx	(	Sdb *	s,
		const char *	key,
		const char *	val,
		ut32	cas
	)

sdb_array_get_num()

RZ_API ut64 sdb_array_get_num	(	Sdb *	s,
		const char *	key,
		int	idx,
		ut32 *	cas
	)

Definition at line 63 of file array.c.

                                                                           {
    int i;
    const char *n, *str = sdb_const_get(s, key, cas);
    if (!str || !*str) {
        return 0LL;
    }
    if (idx) {
        for (i = 0; i < idx; i++) {
            n = strchr(str, SDB_RS);
            if (!n) {
                return 0LL;
            }
            str = n + 1;
        }
    }
    return sdb_atoi(str);
}

References i, setup::idx, key, n, s, sdb_atoi(), sdb_const_get(), SDB_RS, and cmd_descs_generate::str.

Referenced by rz_syscall_get_num(), and sdb_querys().

sdb_array_indexof()

RZ_API int sdb_array_indexof	(	Sdb *	s,
		const char *	key,
		const char *	val,
		ut32	cas
	)

Definition at line 415 of file array.c.

              {
    const char *str = sdb_const_get(s, key, 0);
    const char *n, *p = str;
    int i;
    for (i = 0;; i++) {
        if (!p) {
            break;
        }
        if (!astrcmp(p, val)) {
            return i;
        }
        n = strchr(p, SDB_RS);
        if (!n)
            break;
        p = n + 1;
    }
    return -1;
}

References astrcmp(), i, key, n, p, s, sdb_const_get(), SDB_RS, cmd_descs_generate::str, and val.

sdb_array_insert()

RZ_API int sdb_array_insert	(	Sdb *	s,
		const char *	key,
		int	idx,
		const char *	val,
		ut32	cas
	)

Definition at line 139 of file array.c.

              {
    int lnstr, lstr;
    size_t lval;
    char *x, *ptr;
    const char *str = sdb_const_get_len(s, key, &lstr, 0);
    if (!str || !*str) {
        return sdb_set(s, key, val, cas);
    }
    lval = strlen(val);
    lstr--;
    // XXX: lstr is wrongly computed in sdb_const_get_with an off-by-one
    // we can optimize this by caching value len in memory . add
    // sdb_const_get_size()
    lstr = strlen(str);
 
    // When removing strlen this conversion should be checked
    size_t lstr_tmp = lstr;
    if (SZT_ADD_OVFCHK(lval, lstr_tmp) || SZT_ADD_OVFCHK(lval + lstr_tmp, 2)) {
        return false;
    }
    x = malloc(lval + lstr_tmp + 2);
    if (!x) {
        return false;
    }
 
    if (idx == -1) {
        memcpy(x, str, lstr);
        x[lstr] = SDB_RS;
        memcpy(x + lstr + 1, val, lval + 1);
    } else if (!idx) {
        memcpy(x, val, lval);
        x[lval] = SDB_RS;
        memcpy(x + lval + 1, str, lstr + 1);
    } else {
        char *nstr = malloc(lstr + 1);
        if (!nstr) {
            free(x);
            return false;
        }
        memcpy(nstr, str, lstr + 1);
        ptr = (char *)Aindexof(nstr, idx);
        if (ptr) {
            int lptr = (nstr + lstr + 1) - ptr;
            char *p_1 = ptr > nstr ? ptr - 1 : ptr;
            *p_1 = 0;
            lnstr = ptr - nstr - 1;
            memcpy(x, nstr, lnstr);
            x[lnstr] = SDB_RS;
            memcpy(x + lnstr + 1, val, lval);
            x[lnstr + lval + 1] = SDB_RS;
            // TODO: this strlen hurts performance
            memcpy(x + lval + 2 + lnstr, ptr, lptr); // strlen (ptr)+1);
            free(nstr);
        } else {
            // this is not efficient
            free(nstr);
            free(x);
            // fallback for empty buckets
            return sdb_array_set(s, key, idx, val, cas);
        }
    }
    return sdb_set_owned(s, key, x, cas);
}

References Aindexof(), free(), setup::idx, key, malloc(), memcpy(), s, sdb_array_set(), sdb_const_get_len(), SDB_RS, sdb_set(), sdb_set_owned(), cmd_descs_generate::str, SZT_ADD_OVFCHK, val, and x.

Referenced by rz_agraph_add_edge_at(), sdb_array_add(), sdb_array_insert_num(), sdb_array_set(), and sdb_querys().

sdb_array_insert_num()

RZ_API int sdb_array_insert_num	(	Sdb *	s,
		const char *	key,
		int	idx,
		ut64	val,
		ut32	cas
	)

Definition at line 131 of file array.c.

              {
    char valstr[64];
    return sdb_array_insert(s, key, idx,
        sdb_itoa(val, valstr, SDB_NUM_BASE), cas);
}

References setup::idx, key, s, sdb_array_insert(), sdb_itoa(), SDB_NUM_BASE, and val.

Referenced by sdb_array_add_sorted_num().

sdb_array_length()

RZ_API int sdb_array_length	(	Sdb *	s,
		const char *	key
	)

Definition at line 524 of file array.c.

                                                     {
    return sdb_alen_ignore_empty(sdb_const_get(s, key, 0));
}

References key, s, sdb_alen_ignore_empty(), and sdb_const_get().

Referenced by sdb_querys().

sdb_array_list()

int sdb_array_list	(	Sdb *	s,
		const char *	key
	)

sdb_array_pop()

RZ_API char* sdb_array_pop	(	Sdb *	s,
		const char *	key,
		ut32 *	cas
	)

Definition at line 589 of file array.c.

                                                               {
    return sdb_array_pop_head(s, key, cas);
}

References key, s, and sdb_array_pop_head().

Referenced by sdb_array_pop_num(), and sdb_querys().

sdb_array_pop_head()

RZ_API char* sdb_array_pop_head	(	Sdb *	s,
		const char *	key,
		ut32 *	cas
	)

Definition at line 593 of file array.c.

                                                                    {
    // remove last element in
    ut32 kas;
    char *end, *str = sdb_get(s, key, &kas);
    if (!str || !*str) {
        free(str);
        return NULL;
    }
    if (cas && *cas != kas) {
        *cas = kas;
    }
    end = strchr(str, SDB_RS);
    if (end) {
        *end = 0;
        sdb_set(s, key, end + 1, 0);
    } else {
        sdb_unset(s, key, 0);
    }
    return str;
}

References test_evm::end, free(), key, NULL, s, sdb_get(), SDB_RS, sdb_set(), sdb_unset(), and cmd_descs_generate::str.

Referenced by sdb_array_pop().

sdb_array_pop_num()

RZ_API ut64 sdb_array_pop_num	(	Sdb *	s,
		const char *	key,
		ut32 *	cas
	)

Definition at line 572 of file array.c.

                                                                  {
    ut64 ret;
    char *a = sdb_array_pop(s, key, cas);
    if (!a) {
        if (cas) {
            *cas = UT32_MAX; // invalid
        }
        return UT64_MAX;
    }
    if (cas) {
        *cas = 0;
    }
    ret = sdb_atoi(a);
    free(a);
    return ret;
}

References a, free(), key, s, sdb_array_pop(), sdb_atoi(), UT32_MAX, ut64(), and UT64_MAX.

sdb_array_pop_tail()

RZ_API char* sdb_array_pop_tail	(	Sdb *	s,
		const char *	key,
		ut32 *	cas
	)

Definition at line 614 of file array.c.

                                                                    {
    ut32 kas;
    char *end, *str = sdb_get(s, key, &kas);
    if (!str || !*str) {
        free(str);
        return NULL;
    }
    if (cas && *cas != kas) {
        *cas = kas;
    }
    for (end = str + strlen(str) - 1; end > str && *end != SDB_RS; end--) {
        // nothing to see here
    }
    if (*end == SDB_RS) {
        *end++ = 0;
    }
    sdb_set_owned(s, key, str, 0);
    // XXX: probably wrong
    return strdup(end);
}

References test_evm::end, free(), key, NULL, s, sdb_get(), SDB_RS, sdb_set_owned(), cmd_descs_generate::str, and strdup().

sdb_array_prepend()

RZ_API bool sdb_array_prepend	(	Sdb *	s,
		const char *	key,
		const char *	val,
		ut32	cas
	)

Definition at line 543 of file array.c.

                                                                                  {
    if (!s || !key || !val) {
        return false;
    }
    int str_len = 0;
    ut32 kas = cas;
    const char *str = sdb_const_get_len(s, key, &str_len, &kas);
    if (!val || (cas && cas != kas)) {
        return false;
    }
    cas = kas;
    if (str && *str) {
        int val_len = strlen(val);
        char *newval = malloc(str_len + val_len + 2);
        if (!newval) {
            return false;
        }
        memcpy(newval, val, val_len);
        newval[val_len] = SDB_RS;
        memcpy(newval + val_len + 1, str, str_len);
        newval[str_len + val_len + 1] = 0;
        // TODO: optimize this because we already have allocated and strlened everything
        sdb_set_owned(s, key, newval, cas);
    } else {
        sdb_set(s, key, val, cas);
    }
    return true;
}

References key, malloc(), memcpy(), s, sdb_const_get_len(), SDB_RS, sdb_set(), sdb_set_owned(), cmd_descs_generate::str, and val.

Referenced by sdb_array_push().

sdb_array_prepend_num()

RZ_API bool sdb_array_prepend_num	(	Sdb *	s,
		const char *	key,
		ut64	val,
		ut32	cas
	)

Definition at line 537 of file array.c.

                                                                               {
    char buf[SDB_NUM_BUFSZ];
    char *n = sdb_itoa(num, buf, SDB_NUM_BASE);
    return sdb_array_push(s, key, n, cas);
}

References key, n, num, s, sdb_array_push(), sdb_itoa(), SDB_NUM_BASE, and SDB_NUM_BUFSZ.

sdb_array_push()

RZ_API bool sdb_array_push	(	Sdb *	s,
		const char *	key,
		const char *	val,
		ut32	cas
	)

Definition at line 533 of file array.c.

                                                                               {
    return sdb_array_prepend(s, key, val, cas);
}

References key, s, sdb_array_prepend(), and val.

Referenced by sdb_array_prepend_num(), sdb_array_push_num(), and sdb_querys().

sdb_array_push_num()

RZ_API int sdb_array_push_num	(	Sdb *	s,
		const char *	key,
		ut64	num,
		ut32	cas
	)

Definition at line 528 of file array.c.

                                                                           {
    char buf[SDB_NUM_BUFSZ], *n = sdb_itoa(num, buf, SDB_NUM_BASE);
    return sdb_array_push(s, key, n, cas);
}

References key, n, num, s, sdb_array_push(), sdb_itoa(), SDB_NUM_BASE, and SDB_NUM_BUFSZ.

Referenced by core_analysis_graph_construct_nodes().

sdb_array_remove()

RZ_API int sdb_array_remove	(	Sdb *	s,
		const char *	key,
		const char *	val,
		ut32	cas
	)

Definition at line 436 of file array.c.

              {
    const char *str = sdb_const_get(s, key, 0);
    const char *n, *p = str;
    int idx;
    if (p) {
        for (idx = 0;; idx++) {
            if (!astrcmp(p, val)) {
                return sdb_array_delete(s, key, idx, cas);
            }
            n = strchr(p, SDB_RS);
            if (!n) {
                break;
            }
            p = n + 1;
        }
    }
    return 0;
}

References astrcmp(), setup::idx, key, n, p, s, sdb_array_delete(), sdb_const_get(), SDB_RS, cmd_descs_generate::str, and val.

Referenced by rz_agraph_del_edge(), rz_agraph_del_node(), rz_analysis_class_delete_attr_raw(), rz_analysis_class_rename_attr_raw(), and sdb_querys().

sdb_array_remove_num()

RZ_API int sdb_array_remove_num	(	Sdb *	s,
		const char *	key,
		ut64	val,
		ut32	cas
	)

Definition at line 394 of file array.c.

                                                                             {
    const char *n, *p, *str = sdb_const_get(s, key, 0);
    int idx = 0;
    ut64 num;
    if (str) {
        for (p = str;; idx++) {
            num = sdb_atoi(p);
            if (num == val) {
                return sdb_array_delete(s, key, idx, cas);
            }
            n = strchr(p, SDB_RS);
            if (!n) {
                break;
            }
            p = n + 1;
        }
    }
    return 0;
}

References setup::idx, key, n, num, p, s, sdb_array_delete(), sdb_atoi(), sdb_const_get(), SDB_RS, cmd_descs_generate::str, ut64(), and val.

sdb_array_set()

RZ_API int sdb_array_set	(	Sdb *	s,
		const char *	key,
		int	idx,
		const char *	val,
		ut32	cas
	)

Definition at line 342 of file array.c.

              {
    int lstr, lval, len;
    const char *usr, *str = sdb_const_get_len(s, key, &lstr, 0);
    char *ptr;
 
    if (!str || !*str) {
        return sdb_set(s, key, val, cas);
    }
    // XXX: should we cache sdb_alen value inside kv?
    len = sdb_alen(str);
    lstr--;
    if (idx < 0 || idx == len) { // append
        return sdb_array_insert(s, key, -1, val, cas);
    }
    lval = strlen(val);
    if (idx > len) {
        int ret, i, ilen = idx - len;
        char *newkey = malloc(ilen + lval + 1);
        if (!newkey) {
            return 0;
        }
        for (i = 0; i < ilen; i++) {
            newkey[i] = SDB_RS;
        }
        memcpy(newkey + i, val, lval + 1);
        ret = sdb_array_insert(s, key, -1, newkey, cas);
        free(newkey);
        return ret;
    }
    // lstr = strlen (str);
    ptr = (char *)Aindexof(str, idx);
    if (ptr) {
        int diff = ptr - str;
        char *nstr = malloc(lstr + lval + 2);
        if (!nstr) {
            return false;
        }
        ptr = nstr + diff;
        // memcpy (nstr, str, lstr+1);
        memcpy(nstr, str, diff);
        memcpy(ptr, val, lval + 1);
        usr = Aindexof(str, idx + 1);
        if (usr) {
            ptr[lval] = SDB_RS;
            strcpy(ptr + lval + 1, usr);
        }
        return sdb_set_owned(s, key, nstr, 0);
    }
    return 0;
}

References Aindexof(), free(), i, setup::idx, key, len, malloc(), memcpy(), s, sdb_alen(), sdb_array_insert(), sdb_const_get_len(), SDB_RS, sdb_set(), sdb_set_owned(), cmd_descs_generate::str, and val.

Referenced by sdb_array_insert(), sdb_array_set_num(), sdb_array_unset(), and sdb_querys().

sdb_array_set_num()

RZ_API int sdb_array_set_num	(	Sdb *	s,
		const char *	key,
		int	idx,
		ut64	val,
		ut32	cas
	)

Definition at line 204 of file array.c.

              {
    char valstr[SDB_NUM_BUFSZ];
    return sdb_array_set(s, key, idx, sdb_itoa(val, valstr, SDB_NUM_BASE),
        cas);
}

References setup::idx, key, s, sdb_array_set(), sdb_itoa(), SDB_NUM_BASE, SDB_NUM_BUFSZ, and val.

Referenced by sdb_array_append_num(), and sdb_querys().

sdb_array_size()

RZ_API int sdb_array_size	(	Sdb *	s,
		const char *	key
	)

Definition at line 519 of file array.c.

                                                   {
    return sdb_alen(sdb_const_get(s, key, 0));
}

References key, s, sdb_alen(), and sdb_const_get().

sdb_array_sort()

RZ_API void sdb_array_sort	(	Sdb *	s,
		const char *	key,
		ut32	cas
	)

Definition at line 635 of file array.c.

                                                              {
    char *nstr, *str, **strs;
    int lstr, j, i;
    str = sdb_get_len(s, key, &lstr, 0);
    if (!str) {
        return;
    }
    if (!*str) {
        free(str);
        return;
    }
    strs = sdb_fmt_array(str);
    for (i = 0; strs[i]; i++) {
        // nothing to see here
    }
    qsort(strs, i, sizeof(char *), cstring_cmp);
    nstr = str;
    for (i = 0; strs[i]; i++) {
        j = strlen(strs[i]);
        memcpy(nstr, strs[i], j);
        nstr += j;
        *(nstr++) = SDB_RS;
    }
    if (nstr > str) {
        *(--nstr) = '\0';
    } else {
        *nstr = '\0';
    }
    sdb_set_owned(s, key, str, cas);
    free(strs);
}

References cstring_cmp(), free(), i, key, memcpy(), qsort(), s, sdb_fmt_array(), sdb_get_len(), SDB_RS, sdb_set_owned(), and cmd_descs_generate::str.

Referenced by sdb_querys().

sdb_array_sort_num()

RZ_API void sdb_array_sort_num	(	Sdb *	s,
		const char *	key,
		ut32	cas
	)

Definition at line 667 of file array.c.

                                                                  {
    char *ret, *nstr;
 
    char *str = sdb_get(s, key, 0);
    if (!str) {
        return;
    }
    if (!*str) {
        free(str);
        return;
    }
    ut64 *nums = sdb_fmt_array_num(str);
    free(str);
    if (!nums) {
        return;
    }
 
    qsort(nums + 1, (int)*nums, sizeof(ut64), int_cmp);
 
    nstr = malloc(*nums + 1);
    if (!nstr) {
        free(nums);
        return;
    }
    memset(nstr, 'q', *nums);
    nstr[*nums] = '\0';
 
    ret = sdb_fmt_tostr(nums + 1, nstr);
    sdb_set_owned(s, key, ret, cas);
 
    free(nstr);
    free(nums);
    return;
}

References free(), int_cmp(), key, malloc(), memset(), qsort(), s, sdb_fmt_array_num(), sdb_fmt_tostr(), sdb_get(), sdb_set_owned(), cmd_descs_generate::str, and ut64().

Referenced by sdb_querys().

sdb_array_unset()

RZ_API int sdb_array_unset	(	Sdb *	s,
		const char *	key,
		int	n,
		ut32	cas
	)

Definition at line 308 of file array.c.

                                                                       {
    return sdb_array_set(s, key, idx, "", cas);
}

References setup::idx, key, s, and sdb_array_set().

sdb_aslice()

RZ_API char* sdb_aslice	(	char *	out,
		int	from,
		int	to
	)

Definition at line 116 of file util.c.

                                                     {
    int len, idx = 0;
    char *str = NULL;
    char *end = NULL;
    char *p = out;
    if (from >= to) {
        return NULL;
    }
    while (*p) {
        if (!str && idx == from) {
            str = p;
        }
        if (idx == to) {
            end = p;
            break;
        }
        if (*p == ',') {
            idx++;
        }
        p++;
    }
    if (str) {
        if (!end) {
            end = str + strlen(str);
        }
        len = (size_t)(end - str);
        memmove(out, str, len);
        out[len] = 0;
        return out;
    }
    return NULL;
}

References test_evm::end, from, setup::idx, len, NULL, out, p, cmd_descs_generate::str, and to.

sdb_atoi()

RZ_API ut64 sdb_atoi

(

const char *

s

)

Definition at line 88 of file util.c.

                                    {
    char *p;
    ut64 ret;
    if (!s || *s == '-') {
        return 0LL;
    }
    ret = strtoull(s, &p, 0);
    return p ? ret : 0LL;
}

References p, s, and ut64().

Referenced by __computeTotal(), deserialize_checkpoints_cb(), deserialize_memory_cb(), deserialize_registers_cb(), rz_core_analysis_esil_init_mem(), sdb_array_add_sorted_num(), sdb_array_get_num(), sdb_array_pop_num(), sdb_array_remove_num(), sdb_fmt_array_num(), sdb_fmt_tobin(), sdb_num_get(), sdb_num_max(), sdb_num_min(), and sdb_querys().

sdb_bool_get()

RZ_API bool sdb_bool_get	(	Sdb *	db,
		const char *	str,
		ut32 *	cas
	)

Definition at line 76 of file num.c.

                                                              {
    const char *b = sdb_const_get(db, str, cas);
    return b && (!strcmp(b, "1") || !strcmp(b, "true"));
}

References b, sdb_const_get(), and cmd_descs_generate::str.

Referenced by get_callable_type(), rz_analysis_is_noreturn(), and rz_analysis_noreturn_at_addr().

sdb_bool_set()

RZ_API int sdb_bool_set	(	Sdb *	db,
		const char *	str,
		bool	v,
		ut32	cas
	)

Definition at line 72 of file num.c.

                                                                    {
    return sdb_set(db, str, v ? "true" : "false", cas);
}

References sdb_set(), cmd_descs_generate::str, and v.

Referenced by agraph_sdb_init(), rz_analysis_noreturn_add(), and save_callable().

sdb_close()

RZ_API void sdb_close

(

Sdb *

s

)

Definition at line 416 of file sdb.c.

                              {
    if (s) {
        if (s->fd != -1) {
            if (s->db.fd != -1 && s->db.fd == s->fd) {
                /* close db fd as well */
                s->db.fd = -1;
            }
            close(s->fd);
            s->fd = -1;
        }
        if (s->dir) {
            free(s->dir);
            s->dir = NULL;
        }
    }
}

References close, rz_socket_t::fd, free(), NULL, and s.

Referenced by __func_name_from_ord(), rz_analysis_function_cc_load_handler(), sdb_concat_by_path(), sdb_load_arch_platform_by_path(), sdb_load_arch_profile_by_path(), sdb_load_by_path(), sdb_load_from_string(), sdb_reset(), and session_sdb_save().

sdb_concat()

RZ_API int sdb_concat	(	Sdb *	s,
		const char *	key,
		const char *	value,
		ut32	cas
	)

Definition at line 329 of file sdb.c.

                                                                            {
    int kl, vl;
    const char *p;
    char *o;
    if (!s || !key || !*key || !value || !*value) {
        return 0;
    }
    p = sdb_const_get_len(s, key, &kl, 0);
    if (!p) {
        return sdb_set(s, key, value, cas);
    }
    vl = strlen(value);
    o = malloc(kl + vl + 1);
    if (o) {
        memcpy(o, p, kl);
        memcpy(o + kl, value, vl + 1);
        return sdb_set_owned(s, key, o, cas);
    }
    return 0;
}

References key, malloc(), memcpy(), p, s, sdb_const_get_len(), sdb_set(), sdb_set_owned(), and value.

Referenced by rz_core_search_rop(), and sdb_querys().

sdb_config()

RZ_API void sdb_config	(	Sdb *	s,
		int	options
	)

Definition at line 1041 of file sdb.c.

                                            {
    s->options = options;
    if (options & SDB_OPTION_SYNC) {
        // sync on every query
    }
    if (options & SDB_OPTION_JOURNAL) {
        // sync on every query
        sdb_journal_open(s);
        // load journaling if exists
        sdb_journal_load(s);
        sdb_journal_clear(s);
    } else {
        sdb_journal_close(s);
    }
    if (options & SDB_OPTION_NOSTAMP) {
        // sync on every query
        s->last = 0LL;
    }
    if (options & SDB_OPTION_FS) {
        // have access to fs (handle '.' or not in query)
    }
}

References options, s, sdb_journal_clear(), sdb_journal_close(), sdb_journal_load(), sdb_journal_open(), SDB_OPTION_FS, SDB_OPTION_JOURNAL, SDB_OPTION_NOSTAMP, and SDB_OPTION_SYNC.

Referenced by createdb(), main(), and sdb_grep_dump().

sdb_const_anext()

RZ_API const char* sdb_const_anext

(

const char *

str

)

Definition at line 206 of file util.c.

                                                    {
    const char *p = strchr(str, SDB_RS);
    return p ? p + 1 : NULL;
}

References NULL, p, SDB_RS, and cmd_descs_generate::str.

Referenced by sdb_array_add_sorted(), and sdb_array_add_sorted_num().

sdb_const_get()

RZ_API const char* sdb_const_get	(	Sdb *	s,
		const char *	key,
		ut32 *	cas
	)

Definition at line 279 of file sdb.c.

                                                                     {
    return sdb_const_get_len(s, key, NULL, cas);
}

References key, NULL, s, and sdb_const_get_len().

Referenced by append_shortcut(), bin_elf_versioninfo_verneed(), bin_elf_versioninfo_versym(), bin_pe_versioninfo(), file_load(), get_atomic_type(), get_callable_type(), get_enum_type(), get_msg_type(), parse_format(), rz_analysis_cc_arg(), rz_analysis_cc_default(), rz_analysis_cc_error(), rz_analysis_cc_exist(), rz_analysis_cc_get(), rz_analysis_cc_max_arg(), rz_analysis_cc_ret(), rz_analysis_cc_self(), rz_analysis_syscc_default(), rz_core_analysis_esil_init_mem(), rz_core_bin_export_info(), rz_core_bin_get_compile_time(), rz_project_load(), rz_serialize_flag_load(), rz_syscall_get(), rz_syscall_get_i(), sdb_array_add_sorted_num(), sdb_array_contains(), sdb_array_get(), sdb_array_get_num(), sdb_array_indexof(), sdb_array_length(), sdb_array_remove(), sdb_array_remove_num(), sdb_array_size(), sdb_bool_get(), sdb_diff_kv_cb(), sdb_num_add(), sdb_num_exists(), sdb_num_get(), sdb_num_max(), sdb_num_min(), sdb_num_set(), and sdb_querys().

sdb_const_get_len()

RZ_API const char* sdb_const_get_len	(	Sdb *	s,
		const char *	key,
		int *	vlen,
		ut32 *	cas
	)

Definition at line 220 of file sdb.c.

                                                                                    {
    ut32 pos, len;
    ut64 now = 0LL;
    bool found;
 
    if (cas) {
        *cas = 0;
    }
    if (vlen) {
        *vlen = 0;
    }
    if (!s || !key) {
        return NULL;
    }
    // TODO: optimize, iterate once
    size_t keylen = strlen(key);
 
    /* search in memory */
    SdbKv *kv = (SdbKv *)sdb_ht_find_kvp(s->ht, key, &found);
    if (found) {
        if (!sdbkv_value(kv) || !*sdbkv_value(kv)) {
            return NULL;
        }
        if (s->timestamped && kv->expire) {
            if (!now) {
                now = sdb_now();
            }
            if (now > kv->expire) {
                sdb_unset(s, key, 0);
                return NULL;
            }
        }
        if (cas) {
            *cas = kv->cas;
        }
        if (vlen) {
            *vlen = sdbkv_value_len(kv);
        }
        return sdbkv_value(kv);
    }
    /* search in disk */
    if (s->fd == -1) {
        return NULL;
    }
    (void)cdb_findstart(&s->db);
    if (cdb_findnext(&s->db, s->ht->opt.hashfn(key), key, keylen) < 1) {
        return NULL;
    }
    len = cdb_datalen(&s->db);
    if (len < SDB_CDB_MIN_VALUE || len >= SDB_CDB_MAX_VALUE) {
        return NULL;
    }
    if (vlen) {
        *vlen = len;
    }
    pos = cdb_datapos(&s->db);
    return s->db.map + pos;
}

References sdb_kv::cas, cdb_datalen, cdb_datapos, cdb_findnext(), cdb_findstart(), sdb_kv::expire, rz_socket_t::fd, found, key, len, NULL, pos, s, SDB_CDB_MAX_VALUE, sdb_ht_find_kvp(), sdb_now(), sdb_unset(), sdbkv_value(), sdbkv_value_len(), and ut64().

Referenced by sdb_array_add_sorted(), sdb_array_append(), sdb_array_insert(), sdb_array_prepend(), sdb_array_set(), sdb_concat(), sdb_const_get(), and sdb_get_len().

sdb_copy()

RZ_API void sdb_copy	(	Sdb *	src,
		Sdb *	dst
	)

Definition at line 1084 of file sdb.c.

                                         {
    sdb_foreach(src, copy_foreach_cb, dst);
    SdbListIter *it;
    SdbNs *ns;
    ls_foreach (src->ns, it, ns) {
        sdb_copy(ns->sdb, sdb_ns(dst, ns->name, true));
    }
}

References copy_foreach_cb(), dst, ls_foreach, sdb_ns_t::name, sdb_ns_t::sdb, sdb_foreach(), sdb_ns(), and src.

Referenced by rz_serialize_analysis_cc_load(), rz_serialize_analysis_cc_save(), rz_serialize_analysis_classes_load(), rz_serialize_analysis_classes_save(), rz_serialize_analysis_function_noreturn_load(), rz_serialize_analysis_function_noreturn_save(), rz_serialize_flag_load(), rz_serialize_flag_save(), and session_sdb_load_ns().

sdb_count()

RZ_API int sdb_count

(

Sdb *

s

)

Definition at line 163 of file sdb.c.

                             {
    int count = 0;
    if (s) {
        if (s->db.fd != -1) {
            sdb_dump_begin(s);
            while (sdb_dump_hasnext(s)) {
                count++;
            }
        }
        if (s->ht) {
            count += s->ht->count;
        }
    }
    return count;
}

References count, rz_socket_t::fd, s, sdb_dump_begin(), and sdb_dump_hasnext().

Referenced by __update_modal(), and resolve_syscalls().

sdb_decode()

RZ_API ut8* sdb_decode	(	const char *	in,
		int *	len
	)

Definition at line 37 of file base64.c.

                                                 {
    ut8 *out;
    ut32 size;
    int olen, ilen;
    if (len) {
        *len = 0;
    }
    if (!in) {
        return NULL;
    }
    ilen = strlen(in);
    if (!ilen) {
        return NULL;
    }
    size = (ilen * 3) + 16;
    if (size < (ut32)ilen) {
        return NULL;
    }
    out = calloc(1, size);
    if (!out) {
        return NULL;
    }
    olen = sdb_decode_raw(out, in, ilen);
    if (!olen) {
        free(out);
        return NULL;
    }
    out[olen] = 0;
    if (len) {
        *len = olen;
    }
    return out;
}

References calloc(), free(), in, len, NULL, out, and sdb_decode_raw().

Referenced by base64decode(), bin_pe_versioninfo(), compareString(), deserialize_checkpoints_cb(), foreach_list_cb(), meta_variable_comment_append(), rz_comment_unique_handler(), sdb_fmt_tobin(), and sdb_querys().

sdb_decode_raw()

RZ_API int sdb_decode_raw	(	ut8 *	bout,
		const char *	bin,
		int	len
	)

Definition at line 14 of file base64.c.

                                                               {
    return rz_base64_decode(bout, bin, len);
}

References len, and rz_base64_decode().

Referenced by sdb_decode().

sdb_diff()

RZ_API bool sdb_diff	(	Sdb *	a,
		Sdb *	b,
		SdbDiffCallback	cb,
		void *	cb_user
	)

Definition at line 159 of file diff.c.

                                                                        {
    SdbDiffCtx ctx;
    ctx.a = a;
    ctx.b = b;
    ctx.equal = true;
    ctx.cb = cb;
    ctx.cb_user = cb_user;
    ctx.path = ls_new();
    if (!ctx.path) {
        return false;
    }
    sdb_diff_ctx(&ctx);
    ls_free(ctx.path);
    return ctx.equal;
}

References a, b, cb, ls_free(), ls_new(), and sdb_diff_ctx().

Referenced by dbdiff().

sdb_diff_format()

RZ_API int sdb_diff_format	(	char *	str,
		int	size,
		const SdbDiff *	diff
	)

Definition at line 6 of file diff.c.

                                                                     {
    int r = 0;
#define APPENDF(...) \
    do { \
        int sr = snprintf(str, size, __VA_ARGS__); \
        if (sr < 0) { \
            return sr; \
        } \
        r += sr; \
        if (sr >= size) { \
            /* no space left, only measure from now on */ \
            str = NULL; \
            size = 0; \
        } else { \
            str += sr; \
            size -= sr; \
        } \
    } while (0)
 
    APPENDF("%c%s ", diff->add ? '+' : '-', diff->v ? "  " : "NS");
 
    SdbListIter *it;
    const char *component;
    ls_foreach (diff->path, it, component) {
        APPENDF("%s/", component);
    }
 
    if (diff->v) {
        APPENDF("%s=%s", diff->k, diff->v);
    } else {
        APPENDF("%s", diff->k);
    }
 
#undef APPENDF
    return r;
}

References sdb_diff_t::add, APPENDF, sdb_diff_t::k, ls_foreach, sdb_diff_t::path, r, and sdb_diff_t::v.

Referenced by dbdiff_cb().

sdb_disk_create()

RZ_API bool sdb_disk_create

(

Sdb *

s

)

Definition at line 17 of file disk.c.

                                    {
    int nlen;
    char *str;
    const char *dir;
    if (!s || s->fdump >= 0) {
        return false; // cannot re-create
    }
    if (!s->dir && s->name) {
        s->dir = strdup(s->name);
    }
    dir = s->dir ? s->dir : "./";
    RZ_FREE(s->ndump);
    nlen = strlen(dir);
    str = malloc(nlen + 5);
    if (!str) {
        return false;
    }
    memcpy(str, dir, nlen + 1);
    char *dirname = rz_file_dirname(str);
    if (!dirname) {
        free(str);
        return false;
    }
    rz_sys_mkdirp(dirname);
    free(dirname);
    memcpy(str + nlen, ".tmp", 5);
    if (s->fdump != -1) {
        close(s->fdump);
    }
#if __WINDOWS__
    wchar_t *wstr = rz_utf8_to_utf16(str);
    if (wstr) {
        s->fdump = _wopen(wstr, O_BINARY | O_RDWR | O_CREAT | O_TRUNC, SDB_MODE);
        free(wstr);
    } else {
        s->fdump = -1;
    }
#else
    s->fdump = open(str, O_BINARY | O_RDWR | O_CREAT | O_TRUNC, SDB_MODE);
#endif
    if (s->fdump == -1) {
        eprintf("sdb: Cannot open '%s' for writing.\n", str);
        free(str);
        return false;
    }
    cdb_make_start(&s->m, s->fdump);
    s->ndump = str;
    return true;
}

References cdb_make_start(), close, eprintf, free(), malloc(), memcpy(), O_BINARY, O_CREAT, O_RDWR, O_TRUNC, rz_file_dirname(), RZ_FREE, rz_sys_mkdirp(), s, SDB_MODE, cmd_descs_generate::str, and strdup().

Referenced by sdb_sync().

sdb_disk_finish()

RZ_API bool sdb_disk_finish

(

Sdb *

s

)

Definition at line 79 of file disk.c.

                                    {
    bool reopen = false, ret = true;
    IFRET(!cdb_make_finish(&s->m));
#if HAVE_HEADER_SYS_MMAN_H
    IFRET(fsync(s->fdump));
#endif
    IFRET(close(s->fdump));
    s->fdump = -1;
    // close current fd to avoid sharing violations
    if (s->fd != -1) {
        close(s->fd);
        s->fd = -1;
        reopen = true;
    }
#if __WINDOWS__
    wchar_t *ndump_ = rz_utf8_to_utf16(s->ndump);
    wchar_t *dir_ = rz_utf8_to_utf16(s->dir);
 
    if (!MoveFileExW(ndump_, dir_, MOVEFILE_REPLACE_EXISTING)) {
        rz_sys_perror("MoveFileExW SDB file to finale location");
    }
    free(ndump_);
    free(dir_);
#else
    if (s->ndump && s->dir) {
        IFRET(rename(s->ndump, s->dir));
    }
#endif
    free(s->ndump);
    s->ndump = NULL;
    // reopen if was open before
    reopen = true; // always reopen if possible
    if (reopen) {
        int rr = sdb_open(s, s->dir);
        if (ret && rr < 0) {
            ret = false;
        }
        cdb_init(&s->db, s->fd);
    }
    return ret;
}

References cdb_init(), cdb_make_finish(), close, rz_socket_t::fd, free(), fsync, IFRET, NULL, rename, rz_sys_perror, s, and sdb_open().

Referenced by sdb_sync().

sdb_disk_insert()

RZ_API bool sdb_disk_insert	(	Sdb *	s,
		const char *	key,
		const char *	val
	)

Definition at line 67 of file disk.c.

                                                                      {
    struct cdb_make *c = &s->m;
    if (!key || !val) {
        return false;
    }
    // if (!*val) return 0; //undefine variable if no value
    return cdb_make_add(c, key, strlen(key), val, strlen(val));
}

References c, cdb_make_add(), key, s, and val.

Referenced by _insert_into_disk(), insertkeys(), and sdb_sync().

sdb_disk_unlink()

RZ_API bool sdb_disk_unlink

(

Sdb *

s

)

Definition at line 121 of file disk.c.

                                    {
    return (s->dir && *(s->dir) && unlink(s->dir) != -1);
}

References s, and unlink.

Referenced by sdb_unlink().

sdb_drain()

RZ_API void sdb_drain	(	Sdb *	s,
		Sdb *	f
	)

Definition at line 1069 of file sdb.c.

                                      {
    if (s && f) {
        f->refs = s->refs;
        sdb_fini(s, 1);
        *s = *f;
        free(f);
    }
}

References f, free(), s, and sdb_fini().

Referenced by rz_cmd_kuery().

sdb_dump_begin()

RZ_API void sdb_dump_begin

(

Sdb *

s

)

Definition at line 835 of file sdb.c.

                                   {
    if (s->fd != -1) {
        s->pos = sizeof(((struct cdb_make *)0)->final);
        seek_set(s->fd, s->pos);
    } else {
        s->pos = 0;
    }
}

References rz_socket_t::fd, s, and seek_set().

Referenced by sdb_count(), sdb_foreach_cdb(), sdb_grep_dump(), sdb_isempty(), and sdb_stats().

sdb_dump_dupnext()

RZ_API bool sdb_dump_dupnext	(	Sdb *	s,
		char *	key,
		char **	value,
		int *	_vlen
	)

Definition at line 877 of file sdb.c.

                                                                          {
    ut32 vlen = 0, klen = 0;
    if (value) {
        *value = NULL;
    }
    if (_vlen) {
        *_vlen = 0;
    }
    if (!cdb_getkvlen(&s->db, &klen, &vlen, s->pos)) {
        return false;
    }
    s->pos += 4;
    if (klen < 1 || vlen < 1) {
        return false;
    }
    if (_vlen) {
        *_vlen = vlen;
    }
    if (key) {
        key[0] = 0;
        if (klen > SDB_CDB_MIN_KEY && klen < SDB_CDB_MAX_KEY) {
            if (getbytes(s, key, klen) == -1) {
                return 0;
            }
            key[klen] = 0;
        }
    }
    if (value) {
        *value = 0;
        if (vlen < SDB_CDB_MAX_VALUE) {
            *value = malloc(vlen + 10);
            if (!*value) {
                return false;
            }
            if (getbytes(s, *value, vlen) == -1) {
                free(*value);
                *value = NULL;
                return false;
            }
            (*value)[vlen] = 0;
        }
    }
    return true;
}

References cdb_getkvlen(), free(), getbytes(), key, malloc(), NULL, s, SDB_CDB_MAX_KEY, SDB_CDB_MAX_VALUE, SDB_CDB_MIN_KEY, and value.

Referenced by sdb_foreach_cdb(), and sdb_grep_dump().

sdb_dump_hasnext()

RZ_API bool sdb_dump_hasnext

(

Sdb *

s

)

Definition at line 844 of file sdb.c.

                                     {
    ut32 k, v;
    if (!cdb_getkvlen(&s->db, &k, &v, s->pos)) {
        return false;
    }
    if (k < 1 || v < 1) {
        return false;
    }
    s->pos += k + v + 4;
    return true;
}

References cdb_getkvlen(), k, s, and v.

Referenced by sdb_count(), sdb_isempty(), and sdb_stats().

sdb_dump_next()

RZ_API SdbKv* sdb_dump_next

(

Sdb *

s

)

sdb_encode()

RZ_API char* sdb_encode	(	const ut8 *	bin,
		int	len
	)

Definition at line 18 of file base64.c.

                                                 {
    char *out;
    if (!bin) {
        return NULL;
    }
    if (len < 0) {
        len = strlen((const char *)bin);
    }
    if (!len) {
        return strdup("");
    }
    out = calloc(8 + (len * 2), sizeof(char));
    if (!out) {
        return NULL;
    }
    sdb_encode_raw(out, bin, len);
    return out;
}

References calloc(), len, NULL, out, sdb_encode_raw(), and strdup().

Referenced by base64encode(), core_analysis_graph_nodes(), meta_variable_comment_print(), Pe_r_bin_store_string(), Pe_r_bin_store_string_table(), rz_agraph_add_node_with_color(), rz_core_meta_print(), rz_core_print_disasm_json(), sdb_fmt_tostr(), sdb_querys(), sdb_set_enc(), and serialize_checkpoints().

sdb_encode_raw()

RZ_API void sdb_encode_raw	(	char *	bout,
		const ut8 *	bin,
		int	len
	)

Definition at line 10 of file base64.c.

                                                                {
    rz_base64_encode(bout, bin, len);
}

References len, and rz_base64_encode().

Referenced by sdb_encode().

sdb_exists()

RZ_API bool sdb_exists	(	Sdb *	s,
		const char *	key
	)

Definition at line 358 of file sdb.c.

                                                {
    ut32 pos;
    char ch;
    bool found;
    int klen = strlen(key) + 1;
    if (!s) {
        return false;
    }
    SdbKv *kv = (SdbKv *)sdb_ht_find_kvp(s->ht, key, &found);
    if (found && kv) {
        char *v = sdbkv_value(kv);
        return v && *v;
    }
    if (s->fd == -1) {
        return false;
    }
    (void)cdb_findstart(&s->db);
    if (cdb_findnext(&s->db, sdb_hash(key), key, klen)) {
        pos = cdb_datapos(&s->db);
        cdb_read(&s->db, &ch, 1, pos);
        return ch != 0;
    }
    return false;
}

References cdb_datapos, cdb_findnext(), cdb_findstart(), cdb_read(), rz_socket_t::fd, found, key, pos, s, sdb_hash(), sdb_ht_find_kvp(), sdbkv_value(), and v.

Referenced by rz_analysis_class_create(), rz_analysis_class_delete_attr_raw(), rz_analysis_class_exists_raw(), and sdb_add().

sdb_expire_get()

RZ_API ut64 sdb_expire_get	(	Sdb *	s,
		const char *	key,
		ut32 *	cas
	)

Definition at line 971 of file sdb.c.

                                                               {
    bool found = false;
    SdbKv *kv = (SdbKv *)sdb_ht_find_kvp(s->ht, key, &found);
    if (found && kv && *sdbkv_value(kv)) {
        if (cas) {
            *cas = kv->cas;
        }
        return kv->expire;
    }
    return 0LL;
}

References sdb_kv::cas, sdb_kv::expire, found, key, s, sdb_ht_find_kvp(), and sdbkv_value().

sdb_expire_set()

RZ_API bool sdb_expire_set	(	Sdb *	s,
		const char *	key,
		ut64	expire,
		ut32	cas
	)

Definition at line 930 of file sdb.c.

                                                                           {
    char *buf;
    ut32 pos, len;
    SdbKv *kv;
    bool found;
    s->timestamped = true;
    if (!key) {
        s->expire = parse_expire(expire);
        return true;
    }
    kv = (SdbKv *)sdb_ht_find_kvp(s->ht, key, &found);
    if (found && kv) {
        if (*sdbkv_value(kv)) {
            if (!cas || cas == kv->cas) {
                kv->expire = parse_expire(expire);
                return true;
            }
        }
        return false;
    }
    if (s->fd == -1) {
        return false;
    }
    (void)cdb_findstart(&s->db);
    if (!cdb_findnext(&s->db, sdb_hash(key), key, strlen(key) + 1)) {
        return false;
    }
    pos = cdb_datapos(&s->db);
    len = cdb_datalen(&s->db);
    if (len < 1 || len >= INT32_MAX) {
        return false;
    }
    if (!(buf = calloc(1, len + 1))) {
        return false;
    }
    cdb_read(&s->db, buf, len, pos);
    buf[len] = 0;
    sdb_set_owned(s, key, buf, cas);
    return sdb_expire_set(s, key, expire, cas); // recursive
}

References calloc(), sdb_kv::cas, cdb_datalen, cdb_datapos, cdb_findnext(), cdb_findstart(), cdb_read(), sdb_kv::expire, rz_socket_t::fd, found, INT32_MAX, key, len, parse_expire(), pos, s, sdb_hash(), sdb_ht_find_kvp(), sdb_set_owned(), and sdbkv_value().

sdb_file()

RZ_API void sdb_file	(	Sdb *	s,
		const char *	dir
	)

Definition at line 128 of file sdb.c.

                                              {
    if (s->lock) {
        sdb_unlock(sdb_lock_file(s->dir));
    }
    free(s->dir);
    s->dir = (dir && *dir) ? strdup(dir) : NULL;
    if (s->lock) {
        sdb_lock(sdb_lock_file(s->dir));
    }
}

References free(), NULL, s, sdb_lock(), sdb_lock_file(), sdb_unlock(), and strdup().

Referenced by rz_cmd_kuery(), and session_sdb_save().

sdb_fmt()

RZ_API char* sdb_fmt	(	const char *	fmt,
			...
	)

sdb_fmt_array()

RZ_API char** sdb_fmt_array

(

const char *

list

)

Definition at line 209 of file fmt.c.

                                              {
    char *_s, **retp, **ret = NULL;
    const char *next, *ptr = list;
    if (list && *list) {
        int len = sdb_alen(list);
        retp = ret = (char **)malloc(2 * strlen(list) +
            ((len + 1) * sizeof(char *)) + 1);
        _s = (char *)ret + ((len + 1) * sizeof(char *));
        if (!ret) {
            return NULL;
        }
        do {
            const char *str = sdb_anext2(ptr, &next);
            int slen = next ? (next - str) - 1 : (int)strlen(str) + 1;
            memcpy(_s, str, slen);
            _s[slen] = 0;
            *retp++ = _s;
            _s += slen + 1;
            ptr = next;
        } while (next);
        *retp = NULL;
    }
    return ret;
}

References len, list(), malloc(), memcpy(), NULL, sdb_alen(), sdb_anext2(), and cmd_descs_generate::str.

Referenced by sdb_array_add_sorted(), and sdb_array_sort().

sdb_fmt_array_num()

RZ_API ut64* sdb_fmt_array_num

(

const char *

list

)

Definition at line 184 of file fmt.c.

                                                 {
    ut64 *retp, *ret = NULL;
    ut32 size;
    const char *next, *ptr = list;
    if (list && *list) {
        ut32 len = (ut32)sdb_alen(list);
        size = sizeof(ut64) * (len + 1);
        if (size < len) {
            return NULL;
        }
        retp = ret = (ut64 *)malloc(size);
        if (!ret) {
            return NULL;
        }
        *retp++ = len;
        do {
            const char *str = sdb_anext2(ptr, &next);
            ut64 n = sdb_atoi(str);
            *retp++ = n;
            ptr = next;
        } while (next);
    }
    return ret;
}

References len, list(), malloc(), n, NULL, sdb_alen(), sdb_anext2(), sdb_atoi(), cmd_descs_generate::str, and ut64().

Referenced by sdb_array_sort_num().

sdb_fmt_free()

RZ_API void sdb_fmt_free	(	void *	p,
		const char *	fmt
	)

Definition at line 128 of file fmt.c.

                                                      {
    int n, len = 0;
    for (; *fmt; fmt++) {
        n = 4;
        switch (*fmt) {
        case 'p': // TODO: leak or wat
        case 'b':
        case 'h':
        case 'd':
            /* do nothing */
            break;
        case 'q':
            n = 8;
            break;
        case 'z':
        case 's':
            free((void *)*((char **)((ut8 *)stru + len)));
            break;
        }
        len += RZ_MAX((long)sizeof(void *), n); // align
    }
}

References free(), len, n, and RZ_MAX.

sdb_fmt_init()

RZ_API char RZ_API int sdb_fmt_init	(	void *	p,
		const char *	fmt
	)

Definition at line 151 of file fmt.c.

                                                  {
    int len = 0;
    for (; *fmt; fmt++) {
        switch (*fmt) {
        case 'b': len += sizeof(ut8); break; // 1
        case 'h': len += sizeof(short); break; // 2
        case 'd': len += sizeof(ut32); break; // 4
        case 'q': len += sizeof(ut64); break; // 8
        case 'z': len += sizeof(char *); break; // void*
        case 's': len += sizeof(char *); break; // void*
        case 'p': len += sizeof(char *); break; // void *
        }
    }
    if (p) {
        memset(p, 0, len);
    }
    return len;
}

References len, memset(), p, ut64(), and ut8.

sdb_fmt_tobin()

RZ_API int sdb_fmt_tobin	(	const char *	_str,
		const char *	fmt,
		void *	stru
	)

Definition at line 84 of file fmt.c.

                                                                        {
    int n, idx = 0, items = 0;
    char *stru8 = (char *)stru;
    char *next, *str, *ptr, *word, *e_str;
    if (!_str || !*_str || !fmt) {
        return 0;
    }
    str = ptr = strdup(_str);
    for (; *fmt; fmt++) {
        word = sdb_anext(ptr, &next);
        if (!word || !*word) {
            break;
        }
        items++;
        n = 4; // ALIGN
        switch (*fmt) {
        case 'b': *((ut8 *)(stru8 + idx)) = (ut8)sdb_atoi(word); break;
        case 'd': *((int *)(stru8 + idx)) = (int)sdb_atoi(word); break;
        case 'q':
            *((ut64 *)(stru8 + idx)) = sdb_atoi(word);
            n = 8;
            break;
        case 'h': *((short *)(stru8 + idx)) = (short)sdb_atoi(word); break;
        case 's':
            e_str = (char *)sdb_decode(word, 0);
            *((char **)(stru8 + idx)) = e_str ? e_str : strdup(word);
            break;
        case 'z':
            *((char **)(stru8 + idx)) = (char *)strdup(word);
            break;
        case 'p':
            *((void **)(stru8 + idx)) = (void *)(size_t)sdb_atoi(word);
            break;
        }
        idx += RZ_MAX((long)sizeof(void *), n); // align
        if (!next) {
            break;
        }
        ptr = next;
    }
    free(str);
    return items;
}

References free(), setup::idx, n, RZ_MAX, sdb_anext(), sdb_atoi(), sdb_decode(), cmd_descs_generate::str, strdup(), and ut64().

sdb_fmt_tostr()

RZ_API char* sdb_fmt_tostr	(	void *	stru,
		const char *	fmt
	)

Definition at line 43 of file fmt.c.

                                                     {
    char buf[128], *e_str, *out = NULL;
    int n, len = 0;
    if (!p || !fmt) {
        return NULL;
    }
    for (; *fmt; fmt++) {
        n = 4;
        switch (*fmt) {
        case 'b':
            concat(sdb_itoa((ut64) * ((ut8 *)p + len), buf, 10));
            break;
        case 'h':
            concat(sdb_itoa((ut64) * ((short *)((ut8 *)p + len)), buf, 10));
            break;
        case 'd':
            concat(sdb_itoa((ut64) * ((int *)((ut8 *)p + len)), buf, 10));
            break;
        case 'q':
            concat(sdb_itoa(*((ut64 *)((ut8 *)p + len)), buf, 10));
            n = 8;
            break;
        case 'z':
            concat((char *)p + len);
            break;
        case 's':
            e_str = sdb_encode((const ut8 *)*((char **)((ut8 *)p + len)), -1);
            concat(e_str);
            free(e_str);
            break;
        case 'p':
            concat(sdb_itoa((ut64) * ((size_t *)((ut8 *)p + len)), buf, 16));
            n = sizeof(size_t);
            break;
        }
        len += RZ_MAX((long)sizeof(void *), n); // align
    }
    return out;
}

References concat, free(), len, n, NULL, out, p, RZ_MAX, sdb_encode(), sdb_itoa(), and ut64().

Referenced by sdb_array_sort_num().

sdb_foreach()

RZ_API bool sdb_foreach	(	Sdb *	s,
		SdbForeachCallback	cb,
		void *	user
	)

Definition at line 758 of file sdb.c.

                                                                   {
    if (!s) {
        return false;
    }
    s->depth++;
    bool result = sdb_foreach_cdb(s, cb, NULL, user);
    if (!result) {
        return sdb_foreach_end(s, false);
    }
 
    ut32 i;
    for (i = 0; i < s->ht->size; ++i) {
        HtPPBucket *bt = &s->ht->table[i];
        SdbKv *kv;
        ut32 j, count;
 
        BUCKET_FOREACH_SAFE(s->ht, bt, j, count, kv) {
            if (kv && sdbkv_value(kv) && *sdbkv_value(kv)) {
                if (!cb(user, sdbkv_key(kv), sdbkv_value(kv))) {
                    return sdb_foreach_end(s, false);
                }
            }
        }
    }
    return sdb_foreach_end(s, true);
}

References BUCKET_FOREACH_SAFE, cb, count, i, NULL, s, sdb_foreach_cdb(), sdb_foreach_end(), sdbkv_key(), and sdbkv_value().

Referenced by deserialize_checkpoints(), deserialize_memory(), deserialize_registers(), load_flags(), rz_analysis_class_foreach(), rz_cmd_kuery(), rz_config_unserialize(), rz_debug_signal_list(), rz_display_opcode_handler(), rz_project_migrate_v1_v2(), rz_project_migrate_v2_v3(), rz_project_migrate_v3_v4(), rz_serialize_analysis_blocks_load(), rz_serialize_analysis_functions_load(), rz_serialize_analysis_global_var_load(), rz_serialize_analysis_hints_load(), rz_serialize_analysis_imports_load(), rz_serialize_analysis_meta_load(), rz_serialize_analysis_xrefs_load(), rz_serialize_bp_load(), rz_serialize_config_load(), rz_serialize_flag_zones_load(), rz_serialize_spaces_load(), rz_syscall_list(), sdb_copy(), sdb_diff_ctx(), sdb_diff_report(), sdb_foreach_list(), sdb_foreach_list_filter_user(), sdb_foreach_match(), sdb_like(), sdb_merge(), sdb_unset_like(), text_save(), and walk_namespace().

sdb_foreach_list()

RZ_API SdbList* sdb_foreach_list	(	Sdb *	s,
		bool	sorted
	)

Definition at line 630 of file sdb.c.

                                                      {
    SdbList *list = ls_newf((SdbListFree)sdbkv_free);
    sdb_foreach(s, sdb_foreach_list_cb, list);
    if (sorted) {
        ls_sort(list, __cmp_asc);
    }
    return list;
}

References __cmp_asc(), list(), ls_newf(), ls_sort(), s, sdb_foreach(), sdb_foreach_list_cb(), and sdbkv_free().

Referenced by __delete_almighty(), __exec_almighty(), __init_almighty_db(), __set_rcb(), __update_modal(), rop_kuery(), rz_analysis_calling_conventions(), rz_analysis_class_get_all(), rz_analysis_noreturn_functions(), rz_cmd_search(), rz_core_bin_export_info(), rz_flag_tags_list(), sdb_load_arch_profile(), sdb_load_base_types(), sdb_load_platform_profile(), sdb_load_sysregs(), sdb_querys(), text_save(), and typelinks_load_sdb().

sdb_foreach_list_filter()

RZ_API SdbList* sdb_foreach_list_filter	(	Sdb *	s,
		SdbForeachCallback	filter,
		bool	sorted
	)

Definition at line 685 of file sdb.c.

                                                                                        {
    return sdb_foreach_list_filter_user(s, filter, sorted, NULL);
}

References NULL, s, and sdb_foreach_list_filter_user().

Referenced by rz_analysis_dwarf_integrate_functions(), and sdb_load_callables().

sdb_foreach_list_filter_user()

RZ_API SdbList* sdb_foreach_list_filter_user	(	Sdb *	s,
		SdbForeachCallback	filter,
		bool	sorted,
		void *	user
	)

Definition at line 668 of file sdb.c.

                                                                                                         {
    struct foreach_list_filter_t u;
    SdbList *list = ls_newf((SdbListFree)sdbkv_free);
 
    if (!list) {
        return NULL;
    }
    u.filter = filter;
    u.list = list;
    u.user = user;
    sdb_foreach(s, sdb_foreach_list_filter_cb, &u);
    if (sorted) {
        ls_sort(list, __cmp_asc);
    }
    return list;
}

References __cmp_asc(), filter(), foreach_list_filter_t::filter, list(), foreach_list_filter_t::list, ls_newf(), ls_sort(), NULL, s, sdb_foreach(), sdb_foreach_list_filter_cb(), sdbkv_free(), and foreach_list_filter_t::user.

Referenced by sdb_foreach_list_filter().

sdb_foreach_match()

RZ_API SdbList* sdb_foreach_match	(	Sdb *	s,
		const char *	expr,
		bool	sorted
	)

Definition at line 710 of file sdb.c.

                                                                         {
    SdbList *list = ls_newf((SdbListFree)sdbkv_free);
    _match_sdb_user o = { expr, list, single };
    sdb_foreach(s, sdb_foreach_match_cb, &o);
    return list;
}

References expr(), list(), ls_newf(), s, sdb_foreach(), sdb_foreach_match_cb(), and sdbkv_free().

Referenced by sdb_querys().

sdb_free()

RZ_API bool sdb_free

(

Sdb *

s

)

Definition at line 206 of file sdb.c.

                             {
    if (s && s->ht && s->refs) {
        s->refs--;
        if (s->refs < 1) {
            s->refs = 0;
            sdb_fini(s, 0);
            s->ht = NULL;
            free(s);
            return true;
        }
    }
    return false;
}

References free(), NULL, s, and sdb_fini().

Referenced by _parse_resource_directory(), bin_pe_parse_imports(), config_path(), dbdiff(), dot_trace_traverse(), ds_free(), get_gnu_verneed(), get_gnu_versym(), get_vernaux_entry_sdb(), get_verneed_entry_sdb(), get_verneed_entry_sdb_aux(), ns_free_exc_list(), Pe_r_bin_store_string(), Pe_r_bin_store_string_table(), rz_agraph_free(), rz_analysis_esil_free(), rz_analysis_esil_stats(), rz_analysis_free(), rz_analysis_function_cc_load_handler(), rz_asm_free(), rz_asm_use(), rz_bin_elf_free(), rz_bin_elf_get_symbols_info(), rz_bin_file_free(), rz_bin_free(), rz_bin_mdmp_free_pe32_bin(), rz_bin_mdmp_free_pe64_bin(), rz_bin_object_set_items(), rz_core_bin_apply_relocs(), rz_core_fini(), rz_core_sysenv_begin(), rz_debug_free(), rz_debug_session_load(), rz_debug_session_save(), rz_egg_free(), rz_flag_free(), rz_main_rz_bin(), rz_project_free(), rz_project_load_file(), rz_project_load_file_raw(), rz_project_save_file(), rz_syscall_free(), rz_syscall_setup(), sdb_concat_by_path(), sdb_grep_dump(), sdb_load_arch_platform_by_path(), sdb_load_arch_profile_by_path(), sdb_load_by_path(), sdb_load_from_string(), sdb_ns_free(), sdb_ns_set(), session_sdb_load(), session_sdb_load_ns(), set_bin_relocs(), showcount(), and terminate().

sdb_get()

RZ_API char* sdb_get	(	Sdb *	s,
		const char *	key,
		ut32 *	cas
	)

Definition at line 290 of file sdb.c.

                                                         {
    return sdb_get_len(s, key, NULL, cas);
}

References key, NULL, s, and sdb_get_len().

Referenced by __create_panel_db(), __func_name_from_ord(), __search_db(), get_callable_type(), get_enum_type(), get_struct_type(), get_type_data(), get_typedef_type(), get_union_type(), rename_key(), resolveModuleOrdinal(), rz_analysis_class_base_get_all(), rz_analysis_class_delete(), 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(), rz_analysis_class_rename_attr_raw(), rz_analysis_class_vtable_delete_class(), rz_analysis_class_vtable_get_all(), rz_analysis_class_vtable_rename_class(), rz_analysis_dwarf_integrate_functions(), rz_asm_describe(), rz_core_bin_apply_resources(), rz_core_bin_info_print(), rz_egg_option_get(), rz_flag_tags_get(), rz_serialize_core_load(), rz_serialize_spaces_load(), sdb_array_delete(), sdb_array_pop_head(), sdb_array_pop_tail(), sdb_array_sort_num(), sdb_load_platform_profile(), sdb_load_sysregs(), and sdb_querys().

sdb_get_len()

RZ_API char* sdb_get_len	(	Sdb *	s,
		const char *	key,
		int *	vlen,
		ut32 *	cas
	)

Definition at line 285 of file sdb.c.

                                                                        {
    const char *value = sdb_const_get_len(s, key, vlen, cas);
    return value ? strdup(value) : NULL;
}

References key, NULL, s, sdb_const_get_len(), strdup(), and value.

Referenced by sdb_array_sort(), sdb_get(), and sdb_uncat().

sdb_global_hook()

RZ_API void sdb_global_hook	(	SdbHook	hook,
		void *	user
	)

Definition at line 37 of file sdb.c.

                                                      {
    global_hook = hook;
    global_user = user;
}

References global_hook, and global_user.

sdb_hash()

RZ_API ut32 sdb_hash

(

const char *

key

)

Definition at line 22 of file util.c.

                                    {
    return sdb_hash_len(s, NULL);
}

References NULL, s, and sdb_hash_len().

Referenced by __hashify(), cdb_make_add(), HtName_(), rz_il_vm_init(), rz_line_ns_completion_result_new(), sdb_exists(), sdb_expire_set(), sdb_ns(), sdb_ns_set(), sdb_querys(), sdb_set_internal(), and sigdb_entry_hash().

sdb_hash_byte()

RZ_API ut8 sdb_hash_byte

(

const char *

s

)

Definition at line 26 of file util.c.

                                        {
    const ut32 hash = sdb_hash_len(s, NULL);
    const ut8 *h = (const ut8 *)&hash;
    return h[0] ^ h[1] ^ h[2] ^ h[3];
}

References h, NULL, s, and sdb_hash_len().

sdb_hash_len()

RZ_API ut32 sdb_hash_len	(	const char *	key,
		ut32 *	len
	)

Definition at line 7 of file util.c.

                                                   {
    ut32 h = CDB_HASHSTART;
    ut32 count = 0;
    if (s) {
        while (*s) {
            h = (h + (h << 5)) ^ *s++;
            count++;
        }
    }
    if (len) {
        *len = count;
    }
    return h;
}

References CDB_HASHSTART, count, h, len, and s.

Referenced by sdb_hash(), and sdb_hash_byte().

sdb_hook()

RZ_API bool sdb_hook	(	Sdb *	s,
		SdbHook	cb,
		void *	user
	)

Definition at line 983 of file sdb.c.

                                                     {
    int i = 0;
    SdbHook hook;
    SdbListIter *iter;
    if (s->hooks) {
        ls_foreach (s->hooks, iter, hook) {
            if (!(i % 2) && (hook == cb)) {
                return false;
            }
            i++;
        }
    } else {
        s->hooks = ls_new();
        s->hooks->free = NULL;
    }
    ls_append(s->hooks, (void *)cb);
    ls_append(s->hooks, user);
    return true;
}

References cb, i, ls_append(), ls_foreach, ls_new(), NULL, and s.

Referenced by sdb_new().

sdb_hook_call()

RZ_API int sdb_hook_call	(	Sdb *	s,
		const char *	k,
		const char *	v
	)

Definition at line 1019 of file sdb.c.

                                                               {
    SdbListIter *iter;
    SdbHook hook;
    int i = 0;
    if (s->timestamped && s->last) {
        s->last = sdb_now();
    }
    ls_foreach (s->hooks, iter, hook) {
        if (!(i % 2) && k && iter->n) {
            void *u = iter->n->data;
            hook(s, u, k, v);
        }
        i++;
    }
    return i >> 1;
}

References i, k, ls_foreach, s, sdb_now(), and v.

Referenced by sdb_set_internal().

sdb_hook_free()

RZ_API void sdb_hook_free

(

Sdb *

s

)

Definition at line 1036 of file sdb.c.

                                  {
    ls_free(s->hooks);
    s->hooks = NULL;
}

References ls_free(), NULL, and s.

Referenced by sdb_fini().

sdb_isempty()

RZ_API bool sdb_isempty

(

Sdb *

s

)

Definition at line 148 of file sdb.c.

                                {
    if (s) {
        if (s->db.fd != -1) {
            sdb_dump_begin(s);
            while (sdb_dump_hasnext(s)) {
                return false;
            }
        }
        if (s->ht && s->ht->count > 0) {
            return false;
        }
    }
    return true;
}

References rz_socket_t::fd, s, sdb_dump_begin(), and sdb_dump_hasnext().

Referenced by rz_core_analysis_cc_init().

sdb_isnum()

RZ_API int sdb_isnum

(

const char *

s

)

Definition at line 216 of file util.c.

                                    {
    const char vs = *s;
    return ((vs == '-' || vs == '+') || (vs >= '0' && vs <= '9'));
}

References s.

Referenced by sdb_querys(), and sdb_type().

sdb_itoa()

RZ_API char* sdb_itoa	(	ut64	n,
		char *	s,
		int	base
	)

Definition at line 38 of file util.c.

                                                 {
    static const char *lookup = "0123456789abcdef";
    const int imax = 62;
    int i = imax, copy_string = 1, alloc = 0;
    if (s) {
        *s = 0;
    } else {
        alloc = 1;
        s = malloc(64);
        if (!s) {
            return NULL;
        }
    }
    if (base < 0) {
        copy_string = 0;
        base = -base;
    }
    if ((base > 16) || (base < 1)) {
        if (alloc) {
            free(s);
        }
        return NULL;
    }
    if (!n) {
        strcpy(s, "0");
        return s;
    }
    s[imax + 1] = '\0';
    if (base <= 10) {
        for (; n && i > 0; n /= base) {
            s[i--] = (n % base) + '0';
        }
    } else {
        for (; n && i > 0; n /= base) {
            s[i--] = lookup[(n % base)];
        }
        if (i != imax) {
            s[i--] = 'x';
        }
        s[i--] = '0';
    }
    if (copy_string || alloc) {
        // unnecessary memmove in case we use the return value
        // return s + i + 1;
        memmove(s, s + i + 1, strlen(s + i + 1) + 1);
        return s;
    }
    return s + i + 1;
}

References copy_string, free(), i, malloc(), n, NULL, and s.

Referenced by rz_core_analysis_esil_init_mem(), rz_open_binary_list_ascii_handler(), rz_table_tofancystring(), rz_table_tosimplestring(), sdb_array_add_num(), sdb_array_add_sorted_num(), sdb_array_contains_num(), sdb_array_insert_num(), sdb_array_prepend_num(), sdb_array_push_num(), sdb_array_set_num(), sdb_fmt_tostr(), sdb_itoca(), sdb_lock(), sdb_num_add(), sdb_num_set(), sdb_querys(), signature(), and xrefs_graph().

sdb_itoca()

RZ_API const char* sdb_itoca

(

ut64

n

)

Definition at line 32 of file util.c.

                                     {
    return sdb_itoa(n, sdb_fmt(NULL), 16);
}

References n, NULL, sdb_fmt(), and sdb_itoa().

sdb_journal_clear()

RZ_API bool sdb_journal_clear

(

Sdb *

s

)

Definition at line 96 of file journal.c.

                                      {
    if (s->journal != -1) {
        return !ftruncate(s->journal, 0);
    }
    return false;
}

References ftruncate, and s.

Referenced by sdb_config(), and sdb_sync().

sdb_journal_close()

RZ_API bool sdb_journal_close

(

Sdb *

s

)

Definition at line 13 of file journal.c.

                                      {
    if (s->journal == -1) {
        return false;
    }
    close(s->journal);
    s->journal = -1;
    unlink(sdb_journal_filename(s));
    return true;
}

References close, s, sdb_journal_filename(), and unlink.

Referenced by sdb_config(), sdb_fini(), and sdb_journal_unlink().

sdb_journal_load()

RZ_API int sdb_journal_load

(

Sdb *

s

)

Definition at line 38 of file journal.c.

                                    {
    int rr, sz, fd, changes = 0;
    char *eq, *str, *cur, *ptr = NULL;
    if (!s) {
        return 0;
    }
    fd = s->journal;
    if (fd == -1) {
        return 0;
    }
    sz = lseek(fd, 0, SEEK_END);
    if (sz < 1) {
        return 0;
    }
    lseek(fd, 0, SEEK_SET);
    str = malloc(sz + 1);
    if (!str) {
        return 0;
    }
    rr = read(fd, str, sz);
    if (rr < 0) {
        free(str);
        return 0;
    }
    str[sz] = 0;
    for (cur = str;;) {
        ptr = strchr(cur, '\n');
        if (!ptr) {
            break;
        }
        *ptr = 0;
        eq = strchr(cur, '=');
        if (eq) {
            *eq++ = 0;
            sdb_set(s, cur, eq, 0);
            changes++;
        }
        cur = ptr + 1;
    }
    free(str);
    return changes;
}

References eq, fd, free(), lseek, malloc(), NULL, read(), s, sdb_set(), SEEK_END, SEEK_SET, and cmd_descs_generate::str.

Referenced by sdb_config().

sdb_journal_log()

RZ_API bool sdb_journal_log	(	Sdb *	s,
		const char *	key,
		const char *	val
	)

Definition at line 81 of file journal.c.

                                                                      {
    if (s->journal == -1) {
        return false;
    }
    const char *str = sdb_fmt("%s=%s\n", key, val);
    int len = strlen(str);
    if (write(s->journal, str, len) != len) {
        return false;
    }
#if HAVE_HEADER_SYS_MMAN_H
    (void)fsync(s->journal);
#endif
    return true;
}

References fsync, key, len, s, sdb_fmt(), cmd_descs_generate::str, val, and write.

Referenced by sdb_set_internal().

sdb_journal_open()

RZ_API bool sdb_journal_open

(

Sdb *

s

)

Definition at line 23 of file journal.c.

                                     {
    const char *filename;
    if (!s || !s->name) {
        return false;
    }
    filename = sdb_journal_filename(s);
    if (!filename) {
        return false;
    }
    close(s->journal);
    s->journal = open(filename, O_CREAT | O_RDWR | O_APPEND, 0600);
    return s->journal != -1;
}

References close, O_APPEND, O_CREAT, O_RDWR, s, and sdb_journal_filename().

Referenced by sdb_config().

sdb_journal_unlink()

RZ_API bool sdb_journal_unlink

(

Sdb *

s

)

Definition at line 103 of file journal.c.

                                       {
    const char *filename = sdb_journal_filename(s);
    sdb_journal_close(s);
    if (filename) {
        return !unlink(filename);
    }
    return false;
}

References s, sdb_journal_close(), sdb_journal_filename(), and unlink.

sdb_like()

RZ_API char** sdb_like	(	Sdb *	s,
		const char *	k,
		const char *	v,
		SdbForeachCallback	cb
	)

Definition at line 1155 of file sdb.c.

                                                                                    {
    LikeCallbackData lcd = { s, k, v, cb, NULL, 0, 0 };
    if (cb) {
        sdb_foreach(s, like_cb, &lcd);
        return NULL;
    }
    if (k && !*k) {
        lcd.key = NULL;
    }
    if (v && !*v) {
        lcd.val = NULL;
    }
    lcd.array_size = sizeof(char *) * 2;
    lcd.array = calloc(lcd.array_size, 1);
    if (!lcd.array) {
        return NULL;
    }
    lcd.array_index = 0;
    sdb_foreach(s, like_cb, &lcd);
    if (lcd.array_index == 0) {
        free((void *)lcd.array);
        return NULL;
    }
    return (char **)lcd.array;
}

References LikeCallbackData::array, LikeCallbackData::array_index, LikeCallbackData::array_size, calloc(), cb, free(), k, LikeCallbackData::key, like_cb(), NULL, s, sdb_foreach(), v, and LikeCallbackData::val.

sdb_lock()

RZ_API bool sdb_lock

(

const char *

s

)

Definition at line 29 of file lock.c.

                                    {
    int fd;
    char *pid, pidstr[64];
    if (!s) {
        return false;
    }
    fd = open(s, O_CREAT | O_TRUNC | O_WRONLY | O_EXCL, SDB_MODE);
    if (fd == -1) {
        return false;
    }
    pid = sdb_itoa(rz_sys_getpid(), pidstr, 10);
    if (pid) {
        if ((write(fd, pid, strlen(pid)) < 0) || (write(fd, "\n", 1) < 0)) {
            close(fd);
            return false;
        }
    }
    close(fd);
    return true;
}

References close, fd, O_CREAT, O_EXCL, O_TRUNC, O_WRONLY, pid, rz_sys_getpid(), s, sdb_itoa(), SDB_MODE, and write.

Referenced by sdb_file(), sdb_lock_wait(), and sdb_new().

sdb_lock_file()

RZ_API const char* sdb_lock_file

(

const char *

f

)

Definition at line 14 of file lock.c.

                                                {
    static char buf[128];
    size_t len;
    if (!f || !*f) {
        return NULL;
    }
    len = strlen(f);
    if (len + 10 > sizeof buf) {
        return NULL;
    }
    memcpy(buf, f, len);
    strcpy(buf + len, ".lock");
    return buf;
}

References f, len, memcpy(), and NULL.

Referenced by sdb_file(), sdb_fini(), and sdb_new().

sdb_lock_wait()

RZ_API int sdb_lock_wait

(

RZ_UNUSED const char *

s

)

sdb_match()

RZ_API bool sdb_match	(	const char *	str,
		const char *	glob
	)

Definition at line 95 of file match.c.

                                                         {
    int glob_len, flags = SDB_LIKE_NONE;
    if (!str || !glob) {
        return false;
    }
    glob_len = strlen(glob);
    if (haveSuffix(glob, glob_len, "?i")) {
        glob_len -= 2;
        flags |= SDB_LIKE_ICASE;
    }
    if (havePrefix(glob, glob_len, "%")) {
        glob++;
        glob_len--;
        flags |= SDB_LIKE_BASE64;
    }
    if (havePrefix(glob, glob_len, "^")) {
        glob++;
        glob_len--;
        flags |= SDB_LIKE_START;
    }
    if (haveSuffix(glob, glob_len, "$")) {
        glob_len--;
        flags |= SDB_LIKE_END;
    }
    return compareString(str, glob, glob_len, flags);
}

References compareString(), flags, havePrefix(), haveSuffix(), SDB_LIKE_BASE64, SDB_LIKE_END, SDB_LIKE_ICASE, SDB_LIKE_NONE, SDB_LIKE_START, and cmd_descs_generate::str.

Referenced by like_cb(), and unset_cb().

sdb_merge()

RZ_API bool sdb_merge	(	Sdb *	d,
		Sdb *	s
	)

Definition at line 144 of file sdb.c.

                                      {
    return sdb_foreach(s, sdb_merge_cb, d);
}

References d, s, sdb_foreach(), and sdb_merge_cb().

Referenced by rz_analysis_function_cc_load_handler(), and sdb_concat_by_path().

sdb_new()

RZ_API Sdb* sdb_new	(	const char *	path,
		const char *	file,
		int	lock
	)

Definition at line 47 of file sdb.c.

                                                                  {
    Sdb *s = RZ_NEW0(Sdb);
    if (!s) {
        return NULL;
    }
    s->db.fd = -1;
    s->fd = -1;
    s->refs = 1;
    if (path && !*path) {
        path = NULL;
    }
    if (name && *name && strcmp(name, "-")) {
        if (path && *path) {
            int plen = strlen(path);
            int nlen = strlen(name);
            s->dir = malloc(plen + nlen + 2);
            if (!s->dir) {
                free(s);
                return NULL;
            }
            memcpy(s->dir, path, plen);
            s->dir[plen] = '/';
            memcpy(s->dir + plen + 1, name, nlen + 1);
            s->path = strdup(path);
        } else {
            s->dir = strdup(name);
        }
        switch (lock) {
        case 1:
            if (!sdb_lock(sdb_lock_file(s->dir))) {
                goto fail;
            }
            break;
        case 2:
            if (!sdb_lock_wait(sdb_lock_file(s->dir))) {
                goto fail;
            }
            break;
        }
        if (sdb_open(s, s->dir) == -1) {
            s->last = s->timestamped ? sdb_now() : 0LL;
            // TODO: must fail if we cant open for write in sync
        }
        s->name = strdup(name);
    } else {
        s->last = s->timestamped ? sdb_now() : 0LL;
        s->fd = -1;
    }
    s->journal = -1;
    s->fdump = -1;
    s->depth = 0;
    s->ndump = NULL;
    s->ns = ls_new(); // TODO: should be NULL
    if (!s->ns) {
        goto fail;
    }
    s->ns->free = NULL;
    if (!s->ns) {
        goto fail;
    }
    s->ht = sdb_ht_new();
    s->lock = lock;
    // if open fails ignore
    if (global_hook) {
        sdb_hook(s, global_hook, global_user);
    }
    cdb_init(&s->db, s->fd);
    return s;
fail:
    if (s->fd != -1) {
        close(s->fd);
        s->fd = -1;
    }
    free(s->dir);
    free(s->name);
    free(s->path);
    free(s);
    return NULL;
}

References cdb_init(), close, fail, rz_socket_t::fd, free(), global_hook, global_user, lock(), ls_new(), malloc(), memcpy(), NULL, path, RZ_NEW0, s, sdb_hook(), sdb_ht_new(), sdb_lock(), sdb_lock_file(), sdb_lock_wait(), sdb_now(), sdb_open(), and strdup().

Referenced by __func_name_from_ord(), bin_pe_parse_imports(), config_path(), createdb(), dbdiff(), load_sdb(), main(), rz_analysis_function_cc_load_handler(), rz_asm_use(), rz_cmd_kuery(), rz_core_init(), rz_core_sysenv_begin(), rz_debug_signal_init(), rz_egg_new(), rz_main_rz_bin(), sdb_concat_by_path(), sdb_grep_dump(), sdb_load_arch_platform_by_path(), sdb_load_arch_profile_by_path(), sdb_load_by_path(), sdb_new0(), set_bin_relocs(), and showcount().

sdb_new0()

RZ_API Sdb* sdb_new0

(

void

)

Definition at line 43 of file sdb.c.

                           {
    return sdb_new(NULL, NULL, 0);
}

References NULL, and sdb_new().

Referenced by __init(), _parse_resource_directory(), _store_resource_sdb(), agraph_init(), dot_trace_traverse(), get_gnu_verneed(), get_gnu_versym(), get_sdb(), get_vernaux_entry_sdb(), get_verneed_entry_sdb_aux(), init_msg_types(), load_buffer(), Pe_r_bin_store_fixed_file_info(), Pe_r_bin_store_resource_version_info(), Pe_r_bin_store_string(), Pe_r_bin_store_string_file_info(), Pe_r_bin_store_string_table(), Pe_r_bin_store_var(), Pe_r_bin_store_var_file_info(), rz_analysis_esil_stats(), rz_analysis_new(), rz_bin_dmp64_new_buf(), rz_bin_elf_get_symbols_info(), rz_bin_elf_new_buf(), rz_bin_file_new(), rz_bin_mdmp_new_buf(), rz_bin_mz_init(), rz_bin_new(), rz_bin_pe_new_buf(), rz_bin_te_new_buf(), rz_debug_session_save(), rz_flag_new(), rz_project_load_file_raw(), rz_project_save_file(), rz_syscall_new(), sdb_load_from_string(), sdb_ns_new(), session_sdb_load(), session_sdb_load_ns(), and ssa_get().

sdb_now()

RZ_API ut64 sdb_now

(

void

)

Definition at line 211 of file util.c.

                          {
    ut64 usec = rz_time_now();
    return usec / 1000000;
}

References rz_time_now(), and ut64().

Referenced by parse_expire(), sdb_const_get_len(), sdb_hook_call(), and sdb_new().

sdb_ns()

RZ_API Sdb* sdb_ns	(	Sdb *	s,
		const char *	name,
		int	create
	)

Definition at line 186 of file ns.c.

                                                         {
    SdbListIter *it;
    SdbNs *ns;
    ut32 hash;
    if (!s || !name || !*name) {
        return NULL;
    }
    hash = sdb_hash(name);
    ls_foreach (s->ns, it, ns) {
        if (ns->hash == hash) {
            return ns->sdb;
        }
    }
    if (!create) {
        return NULL;
    }
    if (s->ns_lock) {
        return NULL;
    }
    ns = sdb_ns_new(s, name, hash);
    if (!ns) {
        return NULL;
    }
    ls_append(s->ns, ns);
    return ns->sdb;
}

References create(), sdb_ns_t::hash, ls_append(), ls_foreach, NULL, s, sdb_ns_t::sdb, sdb_hash(), and sdb_ns_new().

Referenced by core_analysis_graph_nodes(), file_save_cb(), load_process_line(), print_rop(), rop_classify(), rop_kuery(), rz_analysis_dwarf_process_info(), rz_analysis_new(), rz_cmd_kuery(), rz_cmd_search(), rz_core_analysis_everything(), rz_core_bin_export_info(), rz_core_bin_get_compile_time(), rz_core_search_rop(), rz_debug_session_serialize(), rz_project_load(), rz_project_migrate_v1_v2(), rz_project_migrate_v2_v3(), rz_project_migrate_v3_v4(), rz_project_migrate_v5_v6(), rz_project_save(), rz_serialize_analysis_classes_load(), rz_serialize_analysis_meta_load(), rz_serialize_analysis_meta_save(), rz_serialize_analysis_save(), rz_serialize_core_save(), rz_serialize_debug_save(), rz_serialize_flag_load(), rz_serialize_flag_save(), rz_serialize_io_files_save(), rz_serialize_io_save(), rz_serialize_spaces_load(), rz_serialize_spaces_save(), sdb_copy(), sdb_diff_ctx(), sdb_ns_path(), sdb_querys(), and update_sdb().

sdb_ns_free_all()

RZ_API void sdb_ns_free_all

(

Sdb *

s

)

Definition at line 74 of file ns.c.

                                    {
    SdbList *list;
    if (!s) {
        return;
    }
    list = ls_new();
    list->free = NULL;
    ns_free_exc_list(s, list);
    ls_free(list);
    ls_free(s->ns);
    s->ns = NULL;
}

References list(), ls_free(), ls_new(), ns_free_exc_list(), NULL, and s.

Referenced by sdb_fini().

sdb_ns_init()

RZ_API void sdb_ns_init

(

Sdb *

s

)

sdb_ns_lock()

RZ_API void sdb_ns_lock	(	Sdb *	s,
		int	lock,
		int	depth
	)

Definition at line 6 of file ns.c.

                                                     {
    SdbListIter *it;
    SdbNs *ns;
    s->ns_lock = lock;
    if (depth) { // handles -1 as infinite
        ls_foreach (s->ns, it, ns) {
            sdb_ns_lock(ns->sdb, lock, depth - 1);
        }
    }
}

References lock(), ls_foreach, s, and sdb_ns_t::sdb.

sdb_ns_path()

RZ_API Sdb* sdb_ns_path	(	Sdb *	s,
		const char *	path,
		int	create
	)

Definition at line 213 of file ns.c.

                                                              {
    char *ptr, *str;
    char *slash;
 
    if (!s || !path || !*path)
        return s;
    ptr = str = strdup(path);
    do {
        slash = strchr(ptr, '/');
        if (slash)
            *slash = 0;
        s = sdb_ns(s, ptr, create);
        if (!s)
            break;
        if (slash)
            ptr = slash + 1;
    } while (slash);
    free(str);
    return s;
}

References create(), free(), path, s, sdb_ns(), cmd_descs_generate::str, and strdup().

Referenced by bin_elf_versioninfo_verneed(), bin_elf_versioninfo_versym(), bin_pe_versioninfo(), rz_cmd_kuery(), rz_core_bin_apply_resources(), and session_sdb_load_ns().

sdb_ns_set()

RZ_API int sdb_ns_set	(	Sdb *	s,
		const char *	name,
		Sdb *	r
	)

Definition at line 156 of file ns.c.

                                                        {
    SdbNs *ns;
    SdbListIter *it;
    ut32 hash = sdb_hash(name);
    if (!s || !r || !name) {
        return 0;
    }
    ls_foreach (s->ns, it, ns) {
        if (ns->hash == hash) {
            if (ns->sdb == r) {
                return 0;
            }
            sdb_free(ns->sdb);
            r->refs++; // sdb_ref / sdb_unref //
            ns->sdb = r;
            return 1;
        }
    }
    if (s->ns_lock) {
        return 0;
    }
    ns = RZ_NEW(SdbNs);
    ns->name = strdup(name);
    ns->hash = hash;
    ns->sdb = r;
    r->refs++;
    ls_append(s->ns, ns);
    return 1;
}

References sdb_ns_t::hash, ls_append(), ls_foreach, sdb_ns_t::name, r, RZ_NEW, s, sdb_ns_t::sdb, sdb_free(), sdb_hash(), and strdup().

Referenced by _parse_resource_directory(), _store_resource_sdb(), get_gnu_verneed(), get_sdb(), get_verneed_entry_sdb(), init_symbols_info_aux(), load(), load_buffer(), Pe_r_bin_store_resource_version_info(), Pe_r_bin_store_string_file_info(), Pe_r_bin_store_string_table(), Pe_r_bin_store_var_file_info(), rz_bin_elf_get_symbols_info(), rz_bin_object_new(), update_sdb(), and update_syscall_ns().

sdb_ns_sync()

RZ_API void sdb_ns_sync

(

Sdb *

s

)

Definition at line 248 of file ns.c.

                                {
    SdbList *list = ls_new();
    ns_sync(s, list);
    list->free = NULL;
    ls_free(list);
}

References list(), ls_free(), ls_new(), ns_sync(), NULL, and s.

sdb_ns_unset()

RZ_API bool sdb_ns_unset	(	Sdb *	s,
		const char *	name,
		Sdb *	r
	)

Definition at line 136 of file ns.c.

                                                           {
    SdbNs *ns;
    SdbListIter *it;
    if (s && (name || r)) {
        ls_foreach (s->ns, it, ns) {
            if (name && (!strcmp(name, ns->name))) {
                sdb_ns_free(ns);
                ls_delete(s->ns, it);
                return true;
            }
            if (r && ns->sdb == r) {
                sdb_ns_free(ns);
                ls_delete(s->ns, it);
                return true;
            }
        }
    }
    return false;
}

References ls_delete(), ls_foreach, sdb_ns_t::name, r, s, sdb_ns_t::sdb, and sdb_ns_free().

Referenced by rz_project_migrate_v6_v7(), rz_project_migrate_v7_v8(), and update_syscall_ns().

sdb_num_add()

RZ_API int sdb_num_add	(	Sdb *	s,
		const char *	key,
		ut64	v,
		ut32	cas
	)

Definition at line 18 of file num.c.

                                                                  {
    char *val, b[SDB_NUM_BUFSZ];
    int numbase = sdb_num_base(sdb_const_get(s, key, NULL));
    val = sdb_itoa(v, b, numbase);
    return sdb_add(s, key, val, cas);
}

References b, key, NULL, s, sdb_add(), sdb_const_get(), sdb_itoa(), sdb_num_base(), SDB_NUM_BUFSZ, v, and val.

Referenced by rz_core_bin_apply_all_info().

sdb_num_base()

RZ_API int sdb_num_base

(

const char *

s

)

Definition at line 221 of file util.c.

                                       {
    if (!s) {
        return SDB_NUM_BASE;
    }
    if (!strncmp(s, "0x", 2)) {
        return 16;
    }
    return (*s == '0' && s[1]) ? 8 : 10;
}

References s, and SDB_NUM_BASE.

Referenced by sdb_num_add(), sdb_num_set(), and sdb_querys().

sdb_num_dec()

RZ_API ut64 sdb_num_dec	(	Sdb *	s,
		const char *	key,
		ut64	n,
		ut32	cas
	)

Definition at line 43 of file num.c.

                                                                    {
    ut32 c;
    ut64 n = sdb_num_get(s, key, &c);
    if (cas && c != cas) {
        return 0LL;
    }
    if (n2 > n) {
        sdb_set(s, key, "0", cas);
        return 0LL; // XXX must be -1LL?
    }
    n -= n2;
    sdb_num_set(s, key, n, cas);
    return n;
}

References c, key, n, s, sdb_num_get(), sdb_num_set(), sdb_set(), and ut64().

Referenced by sdb_querys().

sdb_num_exists()

RZ_API bool sdb_num_exists	(	Sdb *	s,
		const char *	key
	)

Definition at line 8 of file num.c.

                                                    {
    const char *o = sdb_const_get(s, key, NULL);
    return o ? (*o >= '0' && *o <= '9') : false;
}

References key, NULL, s, and sdb_const_get().

sdb_num_get()

RZ_API ut64 sdb_num_get	(	Sdb *	s,
		const char *	key,
		ut32 *	cas
	)

Definition at line 13 of file num.c.

                                                            {
    const char *v = sdb_const_get(s, key, cas);
    return (!v || *v == '-') ? 0LL : sdb_atoi(v);
}

References key, s, sdb_atoi(), sdb_const_get(), and v.

Referenced by _parse_resource_directory(), add_tls_callbacks(), bin_elf_versioninfo_verneed(), bin_elf_versioninfo_versym(), bin_pe_versioninfo(), get_atomic_type(), get_callable_type(), get_entrypoint(), get_graphtrace_node(), rz_analysis_dwarf_integrate_functions(), rz_core_bin_apply_resources(), rz_core_bin_info_print(), rz_debug_session_deserialize(), rz_debug_signal_what(), rz_project_migrate_v4_v5(), rz_syscall_get_swi(), sdb_load_arch_profile(), sdb_load_platform_profile(), sdb_load_sysregs(), sdb_num_dec(), sdb_num_inc(), sdb_ptr_get(), siglistcb(), siglistjsoncb(), and ssa_get().

sdb_num_inc()

RZ_API ut64 sdb_num_inc	(	Sdb *	s,
		const char *	key,
		ut64	n,
		ut32	cas
	)

Definition at line 32 of file num.c.

                                                                    {
    ut32 c;
    ut64 n = sdb_num_get(s, key, &c);
    ut64 res = n + n2;
    if ((cas && c != cas) || res < n) {
        return 0LL;
    }
    sdb_num_set(s, key, res, cas);
    return res;
}

References c, key, n, s, sdb_num_get(), sdb_num_set(), and ut64().

Referenced by sdb_querys(), and ssa_set().

sdb_num_max()

RZ_API int sdb_num_max	(	Sdb *	s,
		const char *	key,
		ut64	v,
		ut32	cas
	)

Definition at line 65 of file num.c.

                                                                 {
    const char *a = sdb_const_get(db, k, NULL);
    return (!a || n > sdb_atoi(a))
        ? sdb_num_set(db, k, n, cas)
        : 0;
}

References a, k, n, NULL, sdb_atoi(), sdb_const_get(), and sdb_num_set().

sdb_num_min()

RZ_API int sdb_num_min	(	Sdb *	s,
		const char *	key,
		ut64	v,
		ut32	cas
	)

Definition at line 58 of file num.c.

                                                                 {
    const char *a = sdb_const_get(db, k, NULL);
    return (!a || n < sdb_atoi(a))
        ? sdb_num_set(db, k, n, cas)
        : 0;
}

References a, k, n, NULL, sdb_atoi(), sdb_const_get(), and sdb_num_set().

sdb_num_set()

RZ_API int sdb_num_set	(	Sdb *	s,
		const char *	key,
		ut64	v,
		ut32	cas
	)

Definition at line 25 of file num.c.

                                                                  {
    char *val, b[SDB_NUM_BUFSZ];
    int numbase = sdb_num_base(sdb_const_get(s, key, NULL));
    val = sdb_itoa(v, b, numbase);
    return sdb_set(s, key, val, cas);
}

References b, key, NULL, s, sdb_const_get(), sdb_itoa(), sdb_num_base(), SDB_NUM_BUFSZ, sdb_set(), v, and val.

Referenced by _store_resource_sdb(), agraph_set_layout(), bin_pe_init_hdr(), bin_pe_init_overlay(), bin_pe_store_tls_callbacks(), bootimg_header_load(), core_analysis_graph_construct_edges(), core_analysis_graph_construct_nodes(), core_analysis_graph_nodes(), get_class_ro_t(), get_elf_intrp(), get_entrypoint(), get_gnu_verneed(), get_gnu_versym(), get_graphtrace_node(), get_sdb(), get_vernaux_entry_sdb(), get_verneed_entry_sdb_aux(), info(), init_dynstr_sdb(), init_ehdr_sdb(), init_hdr(), init_items(), init_phdr_sdb(), init_shdr_sdb(), init_shstrtab_sdb(), java_set_sdb(), parse_segments(), parse_thread(), Pe_r_bin_store_fixed_file_info(), Pe_r_bin_store_var(), rz_bin_mdmp_init_directory(), rz_bin_mdmp_init_directory_entry(), rz_bin_mdmp_init_hdr(), rz_bin_mz_init_hdr(), rz_bin_te_init_hdr(), rz_debug_session_serialize(), save_callable(), sdb_num_dec(), sdb_num_inc(), sdb_num_max(), sdb_num_min(), sdb_ptr_set(), and update_graph_sizes().

sdb_open()

RZ_API int sdb_open	(	Sdb *	s,
		const char *	file
	)

Definition at line 383 of file sdb.c.

                                              {
    struct stat st;
    if (!s) {
        return -1;
    }
    if (file) {
        if (s->fd != -1) {
            close(s->fd);
            s->fd = -1;
        }
        s->fd = open(file, O_RDONLY | O_BINARY);
        if (file != s->dir) {
            free(s->dir);
            s->dir = strdup(file);
            s->path = NULL; // TODO: path is important
        }
    }
    s->last = 0LL;
    if (s->fd != -1 && fstat(s->fd, &st) != -1) {
        if ((S_IFREG & st.st_mode) != S_IFREG) {
            eprintf("Database must be a file\n");
            close(s->fd);
            s->fd = -1;
            return -1;
        }
        s->last = st.st_mtime;
    }
    if (s->fd != -1) {
        cdb_init(&s->db, s->fd);
    }
    return s->fd;
}

References cdb_init(), close, eprintf, rz_socket_t::fd, free(), fstat, NULL, O_BINARY, O_RDONLY, s, and strdup().

Referenced by load_sdb(), sdb_disk_finish(), sdb_new(), and session_sdb_load_ns().

sdb_ptr_get()

RZ_API void* sdb_ptr_get	(	Sdb *	db,
		const char *	key,
		ut32 *	cas
	)

Definition at line 87 of file num.c.

                                                              {
    return (void *)(size_t)sdb_num_get(db, key, cas);
}

References key, and sdb_num_get().

Referenced by __create_almighty(), __exec_almighty(), __set_rcb(), and rz_analysis_esil_fire_trap().

sdb_ptr_set()

RZ_API int sdb_ptr_set	(	Sdb *	db,
		const char *	key,
		void *	p,
		ut32	cas
	)

Definition at line 83 of file num.c.

                                                                    {
    return sdb_num_set(db, key, (ut64)(size_t)p, cas);
}

References key, p, sdb_num_set(), and ut64().

Referenced by __init_almighty_db(), and __init_rotate_db().

sdb_query()

RZ_API int sdb_query	(	Sdb *	s,
		const char *	cmd
	)

Definition at line 785 of file query.c.

                                              {
    char buf[1024], *out;
    int must_save = ((*cmd == '~') || strchr(cmd, '='));
    out = sdb_querys(s, buf, sizeof(buf) - 1, cmd);
    if (out) {
        if (*out) {
            puts(out);
        }
        if (out != buf) {
            free(out);
        }
    }
    return must_save;
}

References cmd, free(), out, s, and sdb_querys().

Referenced by __sdb_prompt(), init_msg_types(), insertkeys(), main(), rz_main_rz_bin(), sdb_query_lines(), and sdb_queryf().

sdb_query_file()

RZ_API int sdb_query_file	(	Sdb *	s,
		const char *	file
	)

Definition at line 856 of file query.c.

                                                    {
    int ret = 0;
    char *txt = slurp(file);
    if (txt) {
        ret = sdb_query_lines(s, txt);
        free(txt);
    }
    return ret;
}

References free(), s, sdb_query_lines(), and slurp().

Referenced by sdb_querys().

sdb_query_lines()

RZ_API int sdb_query_lines	(	Sdb *	s,
		const char *	cmd
	)

Definition at line 800 of file query.c.

                                                    {
    char *o, *p, *op;
    if (!s || !cmd) {
        return 0;
    }
    op = strdup(cmd);
    if (!op) {
        return 0;
    }
    p = op;
    do {
        o = strchr(p, '\n');
        if (o) {
            *o = 0;
        }
        (void)sdb_query(s, p);
        if (o) {
            p = o + 1;
        }
    } while (o);
    free(op);
    return 1;
}

References cmd, free(), op, p, s, sdb_query(), and strdup().

Referenced by sdb_load_from_string(), and sdb_query_file().

sdb_queryf()

RZ_API int sdb_queryf	(	Sdb *	s,
		const char *	fmt,
			...
	)

Definition at line 57 of file query.c.

                                                    {
    char string[4096];
    int ret;
    va_list ap;
    va_start(ap, fmt);
    vsnprintf(string, sizeof(string), fmt, ap);
    ret = sdb_query(s, string);
    va_end(ap);
    return ret;
}

References s, sdb_query(), and vsnprintf.

Referenced by rz_debug_signal_setup().

sdb_querys()

RZ_API char* sdb_querys	(	Sdb *	s,
		char *	buf,
		size_t	len,
		const char *	cmd
	)

Definition at line 164 of file query.c.

                                                                         {
    int i, d, ok, w, alength, bufset = 0, is_ref = 0, encode = 0;
    const char *p, *q, *val = NULL;
    char *eq, *next, *quot, *slash, *res,
        *cmd, *newcmd = NULL, *original_cmd = NULL;
    StrBuf *out;
    Sdb *s = r;
    ut64 n;
    if (!s || (!_cmd && !buf)) {
        return NULL;
    }
    out = strbuf_new();
    if ((int)len < 1 || !buf) {
        bufset = 1;
        buf = malloc((len = 64));
        if (!buf) {
            strbuf_free(out);
            return NULL;
        }
    }
    if (_cmd) {
        cmd = original_cmd = strdup(_cmd);
        if (!cmd) {
            free(out);
            if (bufset) {
                free(buf);
            }
            return NULL;
        }
    } else {
        cmd = buf;
    }
    // if cmd is null, we take buf as cmd
    next = NULL;
repeat:
    /* skip spaces */
    while (*cmd && (*cmd == ' ' || *cmd == '\t')) {
        cmd++;
    }
    s = r;
    p = cmd;
    eq = NULL;
    encode = 0;
    is_ref = 0;
    quot = NULL;
    if (*p == '#') {
        p++;
        next = strchr(p, ';');
        if (next) {
            *next = 0;
        }
        out_concat(sdb_fmt("0x%08x\n", sdb_hash(p)));
        if (next) {
            *next = ';';
        }
        goto runNext;
    } else if (*p == '%') {
        encode = 1;
        cmd++;
        p++;
    }
    if (next)
        *next = ';';
    eq = strchr(p, '=');
    if (eq) {
        d = 1;
        *eq++ = 0;
        if (*eq == '$') {
            next = strchr(eq + 1, ';');
            if (next)
                *next = 0;
            val = sdb_const_get(s, eq + 1, 0);
            if (!val) {
                eprintf("No value for '%s'\n", eq + 1);
                goto fail;
            }
            if (next)
                *next = ';';
            is_ref = 1; // protect readonly buffer from being processed
        } else {
            val = eq;
        }
    } else {
        val = NULL;
        d = 0;
    }
    if (!is_ref) {
        next = strchr(val ? val : cmd, ';');
    }
    // if (!val) val = eq;
    if (!is_ref && val && *val == '"') {
        val++;
        // TODO: escape \" too
        quot = (char *)val;
    next_quote:
        quot = strchr(quot, '"');
        if (quot) {
            if (*(quot - 1) == '\\') {
                memmove(quot - 1, quot, strlen(quot) + 1);
                goto next_quote;
            }
            *quot++ = 0; // crash on read only mem!!
        } else {
            eprintf("Missing quote\n");
            *eq++ = 0;
            out = strbuf_free(out);
            goto fail;
        }
        next = strchr(quot, ';');
    } else {
        quot = NULL;
    }
    if (next) {
        *next = 0;
    }
    slash = strchr(cmd, '/');
    while (slash) {
        *slash = 0;
        s = sdb_ns(s, cmd, eq ? 1 : 0);
        if (!s) {
            eprintf("Cant find namespace %s\n", cmd);
            out = strbuf_free(out);
            goto fail;
        }
        cmd = slash + 1;
        slash = strchr(cmd, '/');
    }
    if (*cmd == '?') {
        const char *val = sdb_const_get(s, cmd + 1, 0);
        const char *type = sdb_type(val);
        out_concat(type);
    } else if (*cmd == '*') {
        if (!strcmp(cmd, "***")) {
            char root[1024]; // limit namespace length?
            SdbListIter *it;
            SdbNs *ns;
            ls_foreach (s->ns, it, ns) {
                int name_len = strlen(ns->name);
                if (name_len < (long)sizeof(root)) {
                    memcpy(root, ns->name, name_len + 1);
                    walk_namespace(out, root,
                        sizeof(root) - name_len,
                        root + name_len, ns, encode);
                } else {
                    eprintf("TODO: Namespace too long\n");
                }
            }
            goto fail;
        } else if (!strcmp(cmd, "**")) {
            SdbListIter *it;
            SdbNs *ns;
            ls_foreach (s->ns, it, ns) {
                out_concat(ns->name);
            }
            goto fail;
        } else if (!strcmp(cmd, "*")) {
            ForeachListUser user = { out, encode, NULL };
            SdbList *list = sdb_foreach_list(s, true);
            SdbListIter *iter;
            SdbKv *kv;
            ls_foreach (list, iter, kv) {
                foreach_list_cb(&user, sdbkv_key(kv), sdbkv_value(kv));
            }
            ls_free(list);
            goto fail;
        }
    }
    if (*cmd == '[') {
        char *tp = strchr(cmd, ']');
        if (!tp) {
            eprintf("Missing ']'.\n");
            goto fail;
        }
        *tp++ = 0;
        p = (const char *)tp;
    } else {
        p = cmd;
    }
    if (*cmd == '$') {
        free(newcmd);
        char *nc = sdb_get(s, cmd + 1, 0);
        cmd = newcmd = (nc) ? nc : strdup("");
    }
    // cmd = val
    // cmd is key and val is value
    if (*cmd == '.') {
        if (s->options & SDB_OPTION_FS) {
            if (!sdb_query_file(s, cmd + 1)) {
                eprintf("sdb: cannot open '%s'\n", cmd + 1);
                goto fail;
            }
        } else {
            eprintf("sdb: filesystem access disabled in config\n");
        }
    } else if (*cmd == '~') { // delete
        if (cmd[1] == '~') { // grep
            SdbKv *kv;
            SdbListIter *li;
            SdbList *l = sdb_foreach_match(s, cmd + 2, false);
            ls_foreach (l, li, kv) {
                strbuf_append(out, sdbkv_key(kv), 0);
                strbuf_append(out, "=", 0);
                strbuf_append(out, sdbkv_value(kv), 1);
            }
            fflush(stdout);
            ls_free(l);
        } else {
            d = 1;
            sdb_unset_like(s, cmd + 1);
        }
    } else if (*cmd == '+' || *cmd == '-') {
        d = 1;
        if (!buf) {
            buf = calloc(1, len);
            if (!buf) {
                goto fail;
            }
            bufset = 1;
        }
        *buf = 0;
        if (cmd[1] == '[') {
            const char *eb = strchr(cmd, ']');
            if (!eb) {
                eprintf("Missing ']'.\n");
                goto fail;
            }
            int idx = sdb_atoi(cmd + 2);
            /* +[idx]key=n */
            /* -[idx]key=n */
            ut64 curnum = sdb_array_get_num(s,
                eb + 1, idx, 0);
            if (eq) {
                /* +[idx]key=n  -->  key[idx] += n */
                /* -[idx]key=n  -->  key[idx] -= n */
                st64 n = sdb_atoi(eq);
                if (*cmd == '+') {
                    curnum += n;
                } else if (*cmd == '-') {
                    curnum -= n;
                } else {
                    // never happens
                }
                sdb_array_set_num(s, eb + 1, idx, curnum, 0);
            } else {
                /* +[idx]key    -->  key[idx] + 1 */
                /* -[idx]key    -->  key[idx] - 1 */
                char *nstr, numstr[128];
                if (*cmd == '+') {
                    curnum++;
                } else if (*cmd == '-') {
                    curnum--;
                } else {
                    // never happens
                }
                nstr = sdb_itoa(curnum, numstr, 10);
                strbuf_append(out, nstr, 1);
            }
        } else if (val) {
            if (sdb_isnum(val)) {
                int op = *cmd;
                if (*val == '-') {
                    if (*cmd == '-') {
                        op = '+';
                    } else {
                        op = '-';
                    }
                    d = sdb_atoi(val + 1);
                } else {
                    d = sdb_atoi(val);
                }
                if (op == '+') {
                    sdb_num_inc(s, cmd + 1, d, 0);
                } else {
                    sdb_num_dec(s, cmd + 1, d, 0);
                }
            } else {
                if (*cmd == '+') {
                    sdb_concat(s, cmd + 1, val, 0);
                } else {
                    sdb_uncat(s, cmd + 1, val, 0);
                }
            }
        } else {
            int base = sdb_num_base(sdb_const_get(s, cmd + 1, 0));
            if (*cmd == '+') {
                n = sdb_num_inc(s, cmd + 1, d, 0);
            } else {
                n = sdb_num_dec(s, cmd + 1, d, 0);
            }
            // keep base
            if (base == 16) {
                w = snprintf(buf, len - 1, "0x%" PFMT64x "x", n);
                if (w < 0 || (size_t)w > len) {
                    if (bufset && len < 0xff) {
                        free(buf);
                        buf = malloc(len = 0xff);
                        if (!buf) {
                            goto fail;
                        }
                    }
                    bufset = 1;
                    snprintf(buf, 0xff, "0x%" PFMT64x "x", n);
                }
            } else {
                w = snprintf(buf, len - 1, "%" PFMT64x "d", n);
                if (w < 0 || (size_t)w > len) {
                    if (bufset && len < 0xff) {
                        free(buf);
                        buf = malloc(len = 0xff);
                        if (!buf) {
                            goto fail;
                        }
                    }
                    bufset = 1;
                    snprintf(buf, 0xff, "%" PFMT64x "d", n);
                }
            }
        }
        out_concat(buf);
    } else if (*cmd == '[') {
        // [?] - count elements of array
        if (cmd[1] == '?') {
            // if (!eq) ...
            alength = sdb_array_length(s, p);
            if (!buf) {
                buf = malloc(++len);
                if (!buf) {
                    goto fail;
                }
                bufset = 1;
            }
            w = snprintf(buf, len, "%d", alength);
            if (w < 0 || (size_t)w > len) {
                if (bufset) {
                    free(buf);
                }
                buf = malloc(len = 32);
                bufset = 1;
                snprintf(buf, 31, "%d", alength);
            }
            out_concat(buf);
        } else if (cmd[1] == '!') {
            if (cmd[2] == '+') {
                // [!+]key=aa   # add_sorted
                sdb_array_add_sorted(s, p, val, 0);
            } else {
                // [!]key       # sort
                sdb_array_sort(s, p, 0);
            }
        } else if (cmd[1] == '#') {
            // [#+]key=num  # add_sorted_num
            if (cmd[2] == '+') {
                // [#]key       # sort_num
                sdb_array_add_sorted_num(s, p, sdb_atoi(val), 0);
            } else {
                sdb_array_sort_num(s, p, 0);
            }
        } else if (cmd[1] == '+' || cmd[1] == '-') {
            if (cmd[1] == cmd[2]) {
                // stack
                if (cmd[1] == '-' && eq) {
                    /* invalid syntax */
                } else if (cmd[1] == '+' && !eq) {
                    /* invalid syntax */
                } else {
                    if (eq) {
                        sdb_array_push(s, p, val, 0);
                    } else {
                        char *ret = sdb_array_pop(s, p, 0);
                        out_concat(ret);
                        free(ret);
                    }
                }
            } else
                // [+]foo        remove first element */
                // [+]foo=bar    ADD */
                // [-]foo        POP */
                // [-]foo=xx     REMOVE (=xx ignored) */
                if (!cmd[2] || cmd[2] == ']') {
                    // insert
                    if (eq) {
                        if (cmd[1] == '+') {
                            // [+]K=1
                            sdb_array_add(s, p, val, 0);
                        } else {
                            // [-]K= = remove first element
                            sdb_array_remove(s, p, val, 0);
                        }
                        // return NULL;
                    } else {
                        char *ret;
                        if (cmd[1] == '+') {
                            // [+]K = remove first element
                            // XXX: this is a little strange syntax to remove an item
                            ret = sdb_array_get(s, p, 0, 0);
                            if (ret && *ret) {
                                out_concat(ret);
                            }
                            // (+)foo :: remove first element
                            sdb_array_delete(s, p, 0, 0);
                        } else {
                            // [-]K = remove last element
                            ret = sdb_array_get(s, p, -1, 0);
                            if (ret && *ret) {
                                out_concat(ret);
                            }
                            // (-)foo :: remove last element
                            sdb_array_delete(s, p, -1, 0);
                        }
                        free(ret);
                    }
                } else {
                    // get/set specific element in array
                    i = atoi(cmd + 1);
                    if (eq) {
                        /* [+3]foo=bla */
                        if (i < 0) {
                            char *tmp = sdb_array_get(s, p, -i, NULL);
                            if (tmp) {
                                if (encode) {
                                    char *newtmp = (void *)sdb_decode(tmp, NULL);
                                    if (!newtmp) {
                                        goto fail;
                                    }
                                    free(tmp);
                                    tmp = newtmp;
                                }
                                ok = 0;
                                out_concat(tmp);
                                sdb_array_delete(s, p, -i, 0);
                                free(tmp);
                            } else
                                goto fail;
                        } else {
                            if (encode) {
                                val = sdb_encode((const ut8 *)val, -1);
                            }
                            ok = cmd[1] ? ((cmd[1] == '+') ? sdb_array_insert(s, p, i, val, 0) : sdb_array_set(s, p, i, val, 0)) : sdb_array_delete(s, p, i, 0);
                            if (encode) {
                                free((void *)val);
                                val = NULL;
                            }
                        }
                        if (ok && buf)
                            *buf = 0;
                        else
                            buf = NULL;
                    } else {
                        if (i == 0) {
                            /* [-b]foo */
                            if (cmd[1] == '-') {
                                sdb_array_remove(s, p, cmd + 2, 0);
                            } else {
                                eprintf("TODO: [b]foo -> get index of b key inside foo array\n");
                                //  sdb_array_dels (s, p, cmd+1, 0);
                            }
                        } else if (i < 0) {
                            /* [-3]foo */
                            char *tmp = sdb_array_get(s, p, -i, NULL);
                            if (tmp && *tmp) {
                                out_concat(tmp);
                                sdb_array_delete(s, p, -i, 0);
                            }
                            free(tmp);
                        } else {
                            /* [+3]foo */
                            char *tmp = sdb_array_get(s, p, i, NULL);
                            if (tmp && *tmp) {
                                out_concat(tmp);
                            }
                            free(tmp);
                        }
                    }
                }
        } else {
            if (eq) {
                /* [3]foo=bla */
                char *sval = (char *)val;
                if (encode) {
                    sval = sdb_encode((const ut8 *)val, -1);
                }
                if (cmd[1]) {
                    int idx = atoi(cmd + 1);
                    ok = sdb_array_set(s, p, idx, sval, 0);
                    // TODO: handle when idx > sdb_alen
                    if (encode)
                        free(sval);
                } else {
                    if (encode) {
                        ok = sdb_set_owned(s, p, sval, 0);
                    } else {
                        ok = sdb_set(s, p, sval, 0);
                    }
                }
                if (ok && buf) {
                    *buf = 0;
                }
            } else {
                /* [3]foo */
                const char *sval = sdb_const_get(s, p, 0);
                size_t wl;
                if (cmd[1]) {
                    i = atoi(cmd + 1);
                    buf = sdb_array_get(s, p, i, NULL);
                    if (buf) {
                        bufset = 1;
                        len = strlen(buf) + 1;
                    }
                    if (encode) {
                        char *newbuf = (void *)sdb_decode(buf, NULL);
                        if (newbuf) {
                            free(buf);
                            buf = newbuf;
                            len = strlen(buf) + 1;
                        }
                    }
                    out_concat(buf);
                } else {
                    if (!sval) {
                        goto fail;
                    }
                    wl = strlen(sval);
                    if (!buf || wl >= len) {
                        buf = malloc(wl + 2);
                        if (!buf) {
                            free(out->buf);
                            out->buf = NULL;
                            goto fail;
                        }
                        bufset = 1;
                        len = wl + 2;
                    }
                    for (i = 0; sval[i]; i++) {
                        if (sval[i + 1]) {
                            buf[i] = (sval[i] == SDB_RS)
                                ? '\n'
                                : sval[i];
                        } else {
                            buf[i] = sval[i];
                        }
                    }
                    buf[i] = 0;
                    if (encode) {
                        char *newbuf = (void *)sdb_decode(buf, NULL);
                        if (newbuf) {
                            if (bufset) {
                                free(buf);
                            }
                            buf = newbuf;
                            len = strlen(buf) + 1;
                        }
                    }
                    out_concat(buf);
                }
            }
        }
    } else {
        if (eq) {
            // 1 0 kvpath=value
            if (encode) {
                val = sdb_encode((const ut8 *)val, -1);
            }
            while (*val && isspace(*val)) {
                val++;
            }
            int i = strlen(cmd) - 1;
            while (i >= 0 && isspace(cmd[i])) {
                cmd[i] = '\0';
                i--;
            }
            ok = sdb_set(s, cmd, val, 0);
            if (encode) {
                free((void *)val);
                val = NULL;
            }
            if (ok && buf) {
                *buf = 0;
            }
        } else {
            // 0 0 kvpath
            // sdbget
            if ((q = sdb_const_get(s, cmd, 0))) {
                if (encode) {
                    q = (void *)sdb_decode(q, NULL);
                }
                out_concat(q);
                if (encode) {
                    free((void *)q);
                }
            }
        }
    }
runNext:
    if (next) {
        if (bufset) {
            free(buf);
            buf = NULL;
            bufset = 0;
        }
        cmd = next + 1;
        encode = 0;
        goto repeat;
    }
    if (eq) {
        *--eq = '=';
    }
fail:
    if (bufset) {
        free(buf);
    }
    if (out) {
        res = out->buf;
        free(out);
    } else {
        res = NULL;
    }
    free(original_cmd);
    free(newcmd);
    return res;
}

References calloc(), cmd, d, encode(), eprintf, eq, fail, foreach_list_cb(), free(), i, setup::idx, isspace, len, list(), ls_foreach, ls_free(), malloc(), memcpy(), n, sdb_ns_t::name, NULL, ok, out, out_concat, p, PFMT64x, r, repeat(), root, s, sdb_array_add(), sdb_array_add_sorted(), sdb_array_add_sorted_num(), sdb_array_delete(), sdb_array_get(), sdb_array_get_num(), sdb_array_insert(), sdb_array_length(), sdb_array_pop(), sdb_array_push(), sdb_array_remove(), sdb_array_set(), sdb_array_set_num(), sdb_array_sort(), sdb_array_sort_num(), sdb_atoi(), sdb_concat(), sdb_const_get(), sdb_decode(), sdb_encode(), sdb_fmt(), sdb_foreach_list(), sdb_foreach_match(), sdb_get(), sdb_hash(), sdb_isnum(), sdb_itoa(), sdb_ns(), sdb_num_base(), sdb_num_dec(), sdb_num_inc(), SDB_OPTION_FS, sdb_query_file(), SDB_RS, sdb_set(), sdb_set_owned(), sdb_type(), sdb_uncat(), sdb_unset_like(), sdbkv_key(), sdbkv_value(), snprintf, st64, strbuf_append(), strbuf_free(), strbuf_new(), strdup(), autogen_x86imm::tmp, type, ut64(), val, w, and walk_namespace().

Referenced by autocomplete_sdb(), cmd_analysis_esil(), DEFINE_HANDLE_TS_FCN_AND_SYMBOL(), num_callback(), rop_classify_arithmetic(), rop_classify_arithmetic_const(), rop_classify_constant(), rop_classify_mov(), rop_classify_nops(), rop_kuery(), rz_cmd_info_kuery(), rz_cmd_kuery(), rz_core_agraph_print_sdb(), rz_core_cmd_foreach(), rz_core_cmd_subst_i(), rz_core_graph_print(), rz_core_kuery_print(), sdb_query(), and sdb_querysf().

sdb_querysf()

RZ_API char* sdb_querysf	(	Sdb *	s,
		char *	buf,
		size_t	buflen,
		const char *	fmt,
			...
	)

Definition at line 68 of file query.c.

                                                                                 {
    char string[4096];
    char *ret;
    va_list ap;
    va_start(ap, fmt);
    vsnprintf(string, sizeof(string), fmt, ap);
    ret = sdb_querys(s, buf, buflen, string);
    va_end(ap);
    return ret;
}

References buflen, s, sdb_querys(), and vsnprintf.

sdb_remove()

RZ_API bool sdb_remove	(	Sdb *	s,
		const char *	key,
		ut32	cas
	)

Definition at line 299 of file sdb.c.

                                                          {
    return sdb_ht_delete(s->ht, key);
}

References key, s, and sdb_ht_delete().

Referenced by __delete_almighty(), rename_key(), rz_analysis_class_delete(), rz_analysis_class_delete_attr_raw(), rz_analysis_class_rename_attr_raw(), and sdb_sync().

sdb_reset()

RZ_API void sdb_reset

(

Sdb *

s

)

Definition at line 433 of file sdb.c.

                              {
    if (!s) {
        return;
    }
    /* ignore disk cache, file is not removed, but we will ignore
     * its values when syncing again */
    sdb_close(s);
    /* empty memory hashtable */
    sdb_ht_free(s->ht);
    s->ht = sdb_ht_new();
}

References s, sdb_close(), sdb_ht_free(), and sdb_ht_new().

Referenced by cmd_analysis_esil(), load_sdb(), rz_agraph_reset(), rz_analysis_esil_stats(), rz_analysis_purge(), rz_core_analysis_cc_init(), rz_core_analysis_esil_deinit(), rz_flag_tags_reset(), rz_serialize_analysis_classes_load(), rz_serialize_analysis_function_noreturn_load(), and rz_type_cc_del_all_handler().

sdb_set()

RZ_API int sdb_set	(	Sdb *	s,
		const char *	key,
		const char *	data,
		ut32	cas
	)

Definition at line 611 of file sdb.c.

                                                                       {
    return sdb_set_internal(s, key, (char *)val, 0, cas);
}

References key, s, sdb_set_internal(), and val.

Referenced by __init_sdb(), _store_resource_sdb(), art_header_load(), bin_pe_init_hdr(), block_store(), bootimg_header_load(), copy_foreach_cb(), core_analysis_graph_construct_edges(), core_analysis_graph_construct_nodes(), core_analysis_graph_nodes(), file_save(), file_save_cb(), flag_save_cb(), function_store(), get_bbnodes(), get_bbupdate(), get_class_ro_t(), get_elf_intrp(), get_gnu_versym(), get_libs(), get_sdb(), get_vernaux_entry_sdb(), get_verneed_entry_sdb_aux(), hints_acc_store_cb(), info(), init_dt_dynamic_sdb(), init_ehdr_sdb(), init_items(), init_phdr_sdb(), init_sdb_formats(), init_shdr_sdb(), java_set_sdb(), kv_loadlibs(), lmf_header_load(), load_process_line(), parse_segments(), parse_signature(), Pe_r_bin_store_string(), Pe_r_bin_store_string_table(), rename_key(), rop_classify(), rz_agraph_del_node(), rz_agraph_set_curnode(), rz_agraph_set_title(), rz_analysis_cc_set(), rz_analysis_cc_set_error(), rz_analysis_cc_set_self(), rz_analysis_class_create(), rz_analysis_class_rename_attr_raw(), rz_analysis_class_set_attr_raw(), rz_analysis_set_cc_default(), rz_analysis_set_syscc_default(), rz_bin_mdmp_init_directory(), rz_bin_mdmp_init_directory_entry(), rz_bin_mdmp_init_hdr(), rz_bin_mdmp_init_parsing(), rz_bin_mz_init_hdr(), rz_bin_te_init_hdr(), rz_config_serialize(), rz_core_analysis_esil_init_mem(), rz_debug_signal_init(), rz_egg_option_set(), rz_flag_tags_set(), rz_project_migrate_v4_v5(), rz_project_save(), rz_serialize_analysis_global_var_save(), rz_serialize_analysis_imports_save(), rz_serialize_bp_save(), rz_serialize_config_save(), rz_serialize_core_save(), rz_serialize_flag_save(), rz_serialize_flag_zones_save(), rz_serialize_spaces_save(), save_atomic_type(), save_callable(), save_enum(), save_struct(), save_typedef(), save_typelink(), save_union(), sdb_add(), sdb_array_add_sorted_num(), sdb_array_append(), sdb_array_insert(), sdb_array_pop_head(), sdb_array_prepend(), sdb_array_set(), sdb_bool_set(), sdb_concat(), sdb_journal_load(), sdb_merge_cb(), sdb_num_dec(), sdb_num_set(), sdb_querys(), sdb_save_dwarf_function(), sdb_set_enc(), sdb_unset(), serialize_checkpoints(), serialize_memory_cb(), serialize_register_cb(), store_xrefs_list_cb(), v1_v2_types_foreach_cb(), and v2_v3_types_foreach_cb().

sdb_set_owned()

RZ_API int sdb_set_owned	(	Sdb *	s,
		const char *	key,
		char *	val,
		ut32	cas
	)

Definition at line 607 of file sdb.c.

                                                                       {
    return sdb_set_internal(s, key, val, 1, cas);
}

References key, s, sdb_set_internal(), and val.

Referenced by bin_pe_init_hdr(), get_vernaux_entry_sdb(), get_versym_entry_sdb_from_verdef(), get_versym_entry_sdb_from_verneed(), rz_agraph_add_node_with_color(), sdb_array_add_sorted(), sdb_array_append(), sdb_array_delete(), sdb_array_insert(), sdb_array_pop_tail(), sdb_array_prepend(), sdb_array_set(), sdb_array_sort(), sdb_array_sort_num(), sdb_concat(), sdb_expire_set(), sdb_querys(), and sdb_uncat().

sdb_setup()

RZ_API void sdb_setup	(	Sdb *	s,
		int	options
	)

sdb_stats()

RZ_API bool sdb_stats	(	Sdb *	s,
		ut32 *	disk,
		ut32 *	mem
	)

Definition at line 856 of file sdb.c.

                                                     {
    if (!s) {
        return false;
    }
    if (disk) {
        ut32 count = 0;
        if (s->fd != -1) {
            sdb_dump_begin(s);
            while (sdb_dump_hasnext(s)) {
                count++;
            }
        }
        *disk = count;
    }
    if (mem) {
        *mem = s->ht->count;
    }
    return disk || mem;
}

References count, rz_socket_t::fd, mem, s, sdb_dump_begin(), and sdb_dump_hasnext().

Referenced by showcount().

sdb_sync()

RZ_API bool sdb_sync

(

Sdb *

s

)

Definition at line 803 of file sdb.c.

                             {
    bool result;
    ut32 i;
 
    if (!s || !sdb_disk_create(s)) {
        return false;
    }
    result = sdb_foreach_cdb(s, _insert_into_disk, _remove_afer_insert, s);
    if (!result) {
        return false;
    }
 
    /* append new keyvalues */
    for (i = 0; i < s->ht->size; ++i) {
        HtPPBucket *bt = &s->ht->table[i];
        SdbKv *kv;
        ut32 j, count;
 
        BUCKET_FOREACH_SAFE(s->ht, bt, j, count, kv) {
            if (sdbkv_key(kv) && sdbkv_value(kv) && *sdbkv_value(kv) && !kv->expire) {
                if (sdb_disk_insert(s, sdbkv_key(kv), sdbkv_value(kv))) {
                    sdb_remove(s, sdbkv_key(kv), 0);
                }
            }
        }
    }
    sdb_disk_finish(s);
    sdb_journal_clear(s);
    // TODO: sdb_reset memory state?
    return true;
}

References _insert_into_disk(), _remove_afer_insert(), BUCKET_FOREACH_SAFE, count, sdb_kv::expire, i, s, sdb_disk_create(), sdb_disk_finish(), sdb_disk_insert(), sdb_foreach_cdb(), sdb_journal_clear(), sdb_remove(), sdbkv_key(), and sdbkv_value().

Referenced by config_path(), createdb(), ns_sync(), rz_cmd_kuery(), rz_core_sysenv_begin(), session_sdb_save(), and terminate().

sdb_text_load()

RZ_API bool sdb_text_load	(	Sdb *	s,
		const char *	file
	)

Definition at line 405 of file text.c.

                                                    {
    int fd = open(file, O_RDONLY | O_BINARY);
    if (fd < 0) {
        return false;
    }
    bool r = false;
    struct stat st;
    if (fstat(fd, &st) || !st.st_size) {
        goto beach;
    }
#if HAVE_HEADER_SYS_MMAN_H
    char *x = mmap(0, st.st_size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
    if (x == MAP_FAILED) {
        goto beach;
    }
#else
    char *x = calloc(1, st.st_size);
    if (!x) {
        goto beach;
    }
    if (read(fd, x, st.st_size) != st.st_size) {
        free(x);
        goto beach;
    }
#endif
    r = sdb_text_load_buf(s, x, st.st_size);
#if HAVE_HEADER_SYS_MMAN_H
    munmap(x, st.st_size);
#else
    free(x);
#endif
beach:
    close(fd);
    return r;
}

References calloc(), close, fd, free(), fstat, MAP_PRIVATE, mmap, munmap, O_BINARY, O_RDONLY, PROT_READ, PROT_WRITE, r, read(), s, sdb_text_load_buf(), and x.

Referenced by createdb(), and rz_project_load_file_raw().

sdb_text_load_buf()

RZ_API bool sdb_text_load_buf	(	Sdb *	s,
		char *	buf,
		size_t	sz
	)

Definition at line 386 of file text.c.

                                                            {
    if (!sz) {
        return true;
    }
    LoadCtx ctx;
    if (!load_ctx_init(&ctx, s, buf, sz)) {
        return false;
    }
    bool ret = true;
    while (ctx.pos < ctx.bufsz) {
        load_process_single_char(&ctx);
    }
    if (ctx.line_begin < ctx.bufsz && ctx.state != STATE_NEWLINE) {
        load_process_final_line(&ctx);
    }
    load_ctx_fini(&ctx);
    return ret;
}

References load_ctx_fini(), load_ctx_init(), load_process_final_line(), load_process_single_char(), s, and STATE_NEWLINE.

Referenced by createdb(), and sdb_text_load().

sdb_text_save()

RZ_API bool sdb_text_save	(	Sdb *	s,
		const char *	file,
		bool	sort
	)

Definition at line 199 of file text.c.

                                                               {
    int fd = open(file, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0644);
    if (fd < 0) {
        return false;
    }
    bool r = sdb_text_save_fd(s, fd, sort);
    close(fd);
    return r;
}

References close, fd, O_BINARY, O_CREAT, O_TRUNC, O_WRONLY, r, s, and sdb_text_save_fd().

Referenced by rz_project_save_file().

sdb_text_save_fd()

RZ_API bool sdb_text_save_fd	(	Sdb *	s,
		int	fd,
		bool	sort
	)

Definition at line 189 of file text.c.

                                                        {
    SdbList *path = ls_new();
    if (!path) {
        return false;
    }
    bool r = text_save(s, fd, sort, path);
    ls_free(path);
    return r;
}

References fd, ls_free(), ls_new(), path, r, s, and text_save().

Referenced by sdb_text_save().

sdb_type()

RZ_API const char* sdb_type

(

const char *

k

)

Definition at line 231 of file util.c.

                                           {
    if (!k || !*k) {
        return "undefined";
    }
    if (sdb_isnum(k)) {
        return "number";
    }
    if (strchr(k, ',')) {
        return "array";
    }
    if (!strcmp(k, "true") || !strcmp(k, "false")) {
        return "boolean";
    }
    return "string";
}

References k, and sdb_isnum().

Referenced by sdb_querys().

sdb_uncat()

RZ_API int sdb_uncat	(	Sdb *	s,
		const char *	key,
		const char *	value,
		ut32	cas
	)

Definition at line 304 of file sdb.c.

                                                                           {
    // remove 'value' from current key value.
    // TODO: cas is ignored here
    int vlen = 0, valen;
    char *p, *v = sdb_get_len(s, key, &vlen, NULL);
    int mod = 0;
    if (!v || !key || !value) {
        free(v);
        return 0;
    }
    valen = strlen(value);
    if (valen > 0) {
        while ((p = strstr(v, value))) {
            memmove(p, p + valen, strlen(p + valen) + 1);
            mod = 1;
        }
    }
    if (mod) {
        sdb_set_owned(s, key, v, 0);
    } else {
        free(v);
    }
    return 0;
}

References free(), key, mod(), NULL, p, s, sdb_get_len(), sdb_set_owned(), v, and value.

Referenced by sdb_querys().

sdb_unhook()

RZ_API bool sdb_unhook	(	Sdb *	s,
		SdbHook	h
	)

Definition at line 1003 of file sdb.c.

                                          {
    int i = 0;
    SdbHook hook;
    SdbListIter *iter, *iter2;
    ls_foreach (s->hooks, iter, hook) {
        if (!(i % 2) && (hook == h)) {
            iter2 = iter->n;
            ls_delete(s->hooks, iter);
            ls_delete(s->hooks, iter2);
            return true;
        }
        i++;
    }
    return false;
}

References h, i, ls_delete(), ls_foreach, and s.

sdb_unlink()

RZ_API bool sdb_unlink

(

Sdb *

s

)

Definition at line 1064 of file sdb.c.

                               {
    sdb_fini(s, 1);
    return sdb_disk_unlink(s);
}

References s, sdb_disk_unlink(), and sdb_fini().

sdb_unlock()

RZ_API void sdb_unlock

(

const char *

s

)

Definition at line 60 of file lock.c.

                                      {
    // flock (fd, LOCK_UN);
    unlink(s);
}

References s, and unlink.

Referenced by sdb_file(), and sdb_fini().

sdb_unow()

RZ_API ut64 sdb_unow

(

void

)

sdb_unset()

RZ_API int sdb_unset	(	Sdb *	s,
		const char *	key,
		ut32	cas
	)

Definition at line 294 of file sdb.c.

                                                        {
    return key ? sdb_set(s, key, "", cas) : 0;
}

References key, s, and sdb_set().

Referenced by rz_analysis_cc_del(), rz_analysis_noreturn_drop(), rz_core_analysis_esil_init_mem_del(), rz_project_migrate_v1_v2(), rz_project_migrate_v2_v3(), rz_project_migrate_v3_v4(), rz_project_migrate_v7_v8(), sdb_array_pop_head(), sdb_const_get_len(), and unset_cb().

sdb_unset_like()

RZ_API int sdb_unset_like	(	Sdb *	s,
		const char *	k
	)

Definition at line 1106 of file sdb.c.

                                                 {
    UnsetCallbackData ucd = { s, k };
    return sdb_foreach(s, unset_cb, &ucd);
}

References k, s, sdb_foreach(), and unset_cb().

Referenced by sdb_querys().

sdbkv_free()

RZ_API void sdbkv_free

(

SdbKv *

kv

)

Definition at line 524 of file sdb.c.

                                  {
    if (kv) {
        free(sdbkv_key(kv));
        free(sdbkv_value(kv));
        RZ_FREE(kv);
    }
}