SDB_API int sdb_array_add_num(Sdb *s, const char *key, ut64 val, ut32 cas) {
char valstr10[64], valstr16[64];
char *v10 = sdb_itoa (val, valstr10, 10);
char *v16 = sdb_itoa (val, valstr16, 16);
// TODO: optimize
// TODO: check cas vs mycas
if (sdb_array_contains (s, key, v10, NULL))
return 0;
return sdb_array_add (s, key, v16, cas); // TODO: v10 or v16
}
static void setHint (RAnal *a, const char *type, ut64 addr, const char *s, ut64 ptr) {
int idx;
char key[128], val[128], *nval = NULL;
setf (key, "hint.0x%"PFMT64x, addr);
idx = sdb_array_indexof (DB, key, type, 0);
if (s) nval = sdb_encode ((const ut8*)s, -1);
else nval = sdb_itoa (ptr, val, 16);
if (idx != -1) {
if (!s) nval = sdb_itoa (ptr, val, 16);
sdb_array_set (DB, key, idx+1, nval, 0);
} else {
sdb_array_push (DB, key, nval, 0);
sdb_array_push (DB, key, type, 0);
}
if (s) free (nval);
}
static int remove_meta_offset(RCore *core, ut64 offset) {
char aoffset[64];
char *aoffsetptr = sdb_itoa (offset, aoffset, 16);
if (!aoffsetptr) {
eprintf ("Failed to convert %"PFMT64x" to a key", offset);
return -1;
}
return sdb_unset (core->bin->cur->sdb_addrinfo, aoffsetptr, 0);
}
static int add_sdb_bin_obj(const char *key, RBinJavaObj *bin_obj) {
int result = R_FALSE;
char *addr, value[1024] = {0};
addr = sdb_itoa ((ut64)(size_t)bin_obj, value, 16);
if (key && bin_obj && DB) {
IFDBG_BIN_JAVA eprintf ("Adding %s:%s to the bin_objs db\n", key, addr);
sdb_set (DB, key, addr, 0);
result = R_TRUE;
}
return result;
}
R_API int r_anal_pin_call(RAnal *a, ut64 addr) {
char buf[64];
const char *key, *name;
key = sdb_itoa (addr, buf, 16);
if (!key) return R_FALSE;
name = sdb_const_get (DB, key, NULL);
if (!name) return R_FALSE;
RAnalEsilPin fcnptr = (RAnalEsilPin)sdb_ptr_get (DB, name, NULL);
if (fcnptr) {
fcnptr (a);
return R_TRUE;
}
return R_FALSE;
}
SDB_API char *sdb_fmt_tostr(void *p, const char *fmt) {
char buf[128], *e_str, *out = NULL;
int n, len = 0;
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*)(p+len)), buf, 10));
break;
case 'd':
concat (sdb_itoa ((ut64)*((int*)(p+len)), buf, 10));
break;
case 'q':
concat (sdb_itoa (*((ut64*)(p+len)), buf, 10));
n = 8;
break;
case 'z':
concat (p+len);
break;
case 's':
e_str = sdb_encode ((const ut8*)*((char**)(p+len)), -1);
concat (e_str);
free (e_str);
break;
case 'p':
concat (sdb_itoa ((ut64)*((size_t*)(p+len)), buf, 16));
n = sizeof (size_t);
break;
}
len += R_MAX ((long)sizeof (void*), n); // align
}
return out;
}
static int cmd_meta_add_fileline(Sdb *s, char *fileline, ut64 offset) {
char aoffset[64];
char *aoffsetptr = sdb_itoa (offset, aoffset, 16);
if (!aoffsetptr) {
return -1;
}
if (!sdb_add (s, aoffsetptr, fileline, 0)) {
sdb_set (s, aoffsetptr, fileline, 0);
}
if (!sdb_add (s, fileline, aoffsetptr, 0)) {
sdb_set (s, fileline, aoffsetptr, 0);
}
return 0;
}
SDB_API int sdb_array_add_sorted_num(Sdb *s, const char *key, ut64 val, ut32 cas) {
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;
}
sdb_const_anext (n, &n);
}
return sdb_array_insert_num (s, key, n? i: -1, val, cas);
}
SDB_API int sdb_array_add_sorted_num(Sdb *s, const char *key, ut64 val, ut32 cas) {
int i;
char valstr[64];
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 != NULL; i++) {
if (val <= sdb_atoi(n))
break;
sdb_const_anext(n, &n);
}
if (n == NULL)
i = -1;
sdb_array_insert_num (s, key, i, val, cas);
return 0;
}
// TODO: use proper dwarf api here.. or deprecate
static int get_line(RBinFile *arch, ut64 addr, char *file, int len, int *line) {
char *ret, *p, *offset_ptr, offset[64];
if (arch->sdb_addrinfo) {
offset_ptr = sdb_itoa (addr, offset, 16);
ret = sdb_get (arch->sdb_addrinfo, offset_ptr, 0);
if (!ret)
return R_FALSE;
p = strchr (ret, '|');
if (p) {
*p = '\0';
strncpy(file, ret, len);
*line = atoi(p + 1);
return R_TRUE;
}
}
return R_FALSE;
}
SDB_API bool sdb_lock(const char *s) {
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 (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;
}
/*
* @param RBinFile
* @return signature of the binary
*/
static char *signature(RBinFile *bf, bool json) {
char buf[64];
QnxObj *qo = bf->o->bin_obj;
return qo? r_str_dup (NULL, sdb_itoa (qo->rwend.signature, buf, 10)): NULL;
}
SDB_VISIBLE int sdb_setn(Sdb *s, const char *key, ut64 v, ut32 cas) {
char b[128];
sdb_itoa (v, b);
return sdb_set (s, key, b, cas);
}
R_API void r_anal_pin_unset (RAnal *a, ut64 addr) {
char buf[64];
const char *key = sdb_itoa (addr, buf, 16);
sdb_unset (DB, key, 0);
}
R_API void r_anal_pin (RAnal *a, ut64 addr, const char *name) {
char buf[64];
const char *key = sdb_itoa (addr, buf, 16);
sdb_set (DB, key, name, 0);
}
// JSON only supports base16 numbers
SDB_API int sdb_json_num_set (Sdb *s, const char *k, const char *p, int v, ut32 cas) {
char *_str, str[64];
_str = sdb_itoa (v, str, 10);
return sdb_json_set (s, k, p, _str, cas);
}
SDB_API int sdb_array_prepend_num(Sdb *s, const char *key, ut64 num, ut32 cas) {
char buf[SDB_NUM_BUFSZ];
char *n = sdb_itoa (num, buf, SDB_NUM_BASE);
return sdb_array_push (s, key, n, cas);
}
// XXX Doesnt works if numbers are stored in different base
SDB_API int sdb_array_contains_num(Sdb *s, const char *key, ut64 num,
ut32 *cas) {
char val[SDB_NUM_BUFSZ];
char *nval = sdb_itoa (num, val, SDB_NUM_BASE);
return sdb_array_contains (s, key, nval, cas);
}
SDB_API int sdb_array_set_num(Sdb *s, const char *key, int idx, ut64 val,
ut32 cas) {
char valstr[SDB_NUM_BUFSZ];
return sdb_array_set (s, key, idx, sdb_itoa (val, valstr, SDB_NUM_BASE),
cas);
}
