dnrops
/
radare2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Ad od scr.col and cjange more settings 

Fix parsing of segmented addresses
Move hud to shlr/hud
Add r_cons_print_clear () for delayed 'clearscreens'
Add blankline option to RCons
Add scr.segoff to show prompt as segmented or not
Add scr.colpos to choose the position of cmd.cprompt
Deprecate old flags code
This commit is contained in:
pancake 2012-11-14 03:25:32 +01:00
parent e09cf7621e
commit 6dadd63c4b
14 changed files with 360 additions and 604 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Makefile
View File

@ -97,7 +97,7 @@ install: install-doc install-man install-www
(cd $$a ; ${MAKE} install LIBDIR=${LIBDIR} PREFIX=${PREFIX} DESTDIR=${DESTDIR} ); \
done
mkdir -p ${DESTDIR}/${LIBDIR}/radare2/${VERSION}/hud
cp -f libr/core/hud/main ${DESTDIR}/${LIBDIR}/radare2/${VERSION}/hud/
cp -f shlr/hud/main ${DESTDIR}/${LIBDIR}/radare2/${VERSION}/hud/
install-www:
rm -rf ${DESTDIR}/${WWWROOT}
@ -124,7 +124,7 @@ symstall install-symlink: install-man-symlink install-doc-symlink install-pkgcon
${MAKE} install-symlink LIBDIR=${LIBDIR} PREFIX=${PREFIX} DESTDIR=${DESTDIR} ); \
done
mkdir -p ${DLIBDIR}/radare2/${VERSION}/hud
ln -fs ${PWD}/libr/core/hud/main ${DLIBDIR}/radare2/${VERSION}/hud/main
ln -fs ${PWD}/shlr/hud/main ${DLIBDIR}/radare2/${VERSION}/hud/main
deinstall uninstall:
cd libr && ${MAKE} uninstall PARENT=1 PREFIX=${PREFIX} DESTDIR=${DESTDIR}

7
libr/cons/cons.c
View File

@ -90,6 +90,7 @@ static void resize (int sig) {
R_API RCons *r_cons_new () {
I.event_interrupt = NULL;
I.blankline = R_TRUE;
I.event_resize = NULL;
I.data = NULL;
I.is_interactive = R_TRUE;
@ -168,6 +169,10 @@ R_API void r_cons_gotoxy(int x, int y) {
r_cons_printf ("\x1b[%d;%dH", y, x);
}
R_API void r_cons_print_clear() {
r_cons_memcat ("\x1b[2J", 4);
}
R_API void r_cons_clear_line() {
#if __WINDOWS__
char white[1024];
@ -298,7 +303,7 @@ R_API void r_cons_visual_write (char *buffer) {
int w = cols-alen;
if (ptr>buffer) r_cons_write (ptr-1, len);
else r_cons_write (ptr, len-1);
if (w>0) {
if (I.blankline && w>0) {
if (w>sizeof (white)-1)
w = sizeof (white)-1;
r_cons_write (white, w);

2
libr/core/cmd_help.c
View File

@ -82,7 +82,7 @@ static int cmd_help(void *data, const char *input) {
memcpy (&f, &n32, sizeof (f));
/* decimal, hexa, octal */
a = n & 0xffff;
s = (n&0xffff0000) >> 16;
s = (n&0xffff0000) >> 8;
r_cons_printf ("%"PFMT64d" 0x%"PFMT64x" 0%"PFMT64o" %04X:%04X ",
n, n, n, s, a);
/* binary and floating point */

8
libr/core/config.c
View File

@ -648,6 +648,8 @@ R_API int r_core_config_init(RCore *core) {
r_config_set_cb (cfg, "scr.tee", "", config_teefile_callback);
r_config_desc (cfg, "scr.tee", "Pipe console output to file if not empty");
r_config_set_cb (cfg, "scr.prompt", "true", &config_scrprompt_callback);
r_config_set (cfg, "scr.segoff", "false");
r_config_desc (cfg, "scr.segoff", "show segmented address in prompt (x86-16)");
r_config_set (cfg, "scr.pipecolor", "false");
r_config_desc (cfg, "scr.pipecolor", "enable colors when using pipes if true");
r_config_set_cb (cfg, "scr.color",
@ -660,8 +662,12 @@ R_API int r_core_config_init(RCore *core) {
r_config_set_cb (cfg, "scr.nkey", "hit", &config_scrnkey_callback);
r_config_desc (cfg, "scr.nkey", "Select the seek mode in visual");
r_config_set (cfg, "scr.seek", "");
r_config_set_i(cfg, "scr.colpos", 80);
r_config_desc (cfg, "scr.colpos", "Column position of cmd.cprompt in visual");
r_config_set_i_cb (cfg, "scr.cols", 16, &config_scrcols_callback);
r_config_desc (cfg, "scr.cols", "Configure the number of columns to print");
r_config_set_cb (cfg, "scr.html", "false", &config_scrhtml_callback);
r_config_desc (cfg, "scr.html", "If enabled disassembly use HTML syntax");
r_config_set (cfg, "search.in", "file");
r_config_desc (cfg, "search.in", "Specify search boundaries (raw, block, file, section)");
r_config_set_i (cfg, "search.kwidx", 0);
@ -682,8 +688,6 @@ R_API int r_core_config_init(RCore *core) {
r_config_desc (cfg, "search.distance", "Search string distance");
r_config_set_i_cb (cfg, "search.align", 0, &config_searchalign_callback);
r_config_desc (cfg, "search.align", "Only catch aligned search hits");
r_config_set_cb (cfg, "scr.html", "false", &config_scrhtml_callback);
r_config_desc (cfg, "scr.html", "If enabled disassembly use HTML syntax");
sprintf (buf, "%d", R_CORE_BLOCKSIZE_MAX);
r_config_set_cb (cfg, "io.maxblk", buf, &config_iomaxblk_callback);

23
libr/core/core.c
View File

@ -586,12 +586,27 @@ R_API int r_core_prompt(RCore *r, int sync) {
if (!r_line_singleton ()->echo)
*prompt = 0;
// TODO: also in visual prompt and disasm/hexdump ?
if (r_config_get_i (r->config, "scr.segoff")) {
#if __UNIX__
else if (r_config_get_i (r->config, "scr.color"))
snprintf (prompt, sizeof (prompt),
Color_YELLOW"[0x%08"PFMT64x"]> "Color_RESET, r->offset);
ut32 a, b;
a = ((r->offset >>16)<<8);
b = (r->offset & 0xffff);
if (r_config_get_i (r->config, "scr.color"))
snprintf (prompt, sizeof (prompt),
Color_YELLOW"[%04x:%04x]> "
Color_RESET, a, b);
#endif
else sprintf (prompt, "[0x%08"PFMT64x"]> ", r->offset);
else sprintf (prompt, "[%04x:%04x]> ", a, b);
} else {
#if __UNIX__
if (r_config_get_i (r->config, "scr.color"))
snprintf (prompt, sizeof (prompt),
Color_YELLOW"[0x%08"PFMT64x"]> "
Color_RESET, r->offset);
#endif
else sprintf (prompt, "[0x%08"PFMT64x"]> ", r->offset);
}
r_line_set_prompt (prompt);
ret = r_cons_fgets (line, sizeof (line), 0, NULL);
if (ret == -2) return R_CORE_CMD_EXIT;

22
libr/core/visual.c
View File

@ -832,7 +832,8 @@ R_API void r_core_visual_title (RCore *core, int color) {
{ /* get flag with delta */
RFlagItem *f = r_flag_get_at (core->flags, core->offset);
if (f) {
if (f->offset == core->offset) snprintf (pos, sizeof (pos), "@ %s", f->name);
if (f->offset == core->offset)
snprintf (pos, sizeof (pos), "@ %s", f->name);
else snprintf (pos, sizeof (pos), "@ %s+%d (0x%"PFMT64x")",
f->name, (int)(core->offset-f->offset), f->offset);
} else pos[0] = 0;
@ -857,30 +858,39 @@ R_API void r_core_visual_title (RCore *core, int color) {
}
static void r_core_visual_refresh (RCore *core) {
RCons *cons;
const char *vi;
if (!core) return;
r_cons_get_size (NULL);
r_print_set_cursor (core->print, curset, ocursor, cursor);
cons = r_cons_singleton ();
cons->blankline = R_TRUE;
if (autoblocksize) {
r_cons_gotoxy (0, 0);
r_cons_flush ();
} else r_cons_clear ();
vi = r_config_get (core->config, "cmd.vprompt");
if (vi) r_core_cmd (core, vi, 0);
r_core_visual_title (core, color);
r_cons_print_clear ();
vi = r_config_get (core->config, "cmd.cprompt");
if (vi && *vi) {
r_cons_printf ("\n[cmd.cprompt] %s\n", vi);
cons->blankline = R_FALSE;
r_cons_printf ("[cmd.cprompt=%s]\n", vi);
r_core_cmd (core, vi, 0);
r_cons_column (80);
r_cons_column (r_config_get_i (core->config, "scr.colpos"));
}
r_core_visual_title (core, color);
r_cons_flush ();
vi = r_config_get (core->config, "cmd.vprompt");
if (vi) r_core_cmd (core, vi, 0);
if (zoom) r_core_cmd (core, "pz", 0);
else r_core_cmd (core, printfmt[PIDX], 0);
blocksize = core->num->value? core->num->value : core->blocksize;
r_cons_visual_flush ();
cons->blankline = R_TRUE;
}
R_API int r_core_visual(RCore *core, const char *input) {

2
libr/flags/Makefile
View File

@ -2,6 +2,6 @@ include ../config.mk
NAME=r_flags
DEPS=r_util r_cons
OBJS=htflags.o sort.o spaces.o
OBJS=flags.o sort.o spaces.o
include ../rules.mk

524
libr/flags/flags.c
View File

@ -1,91 +1,49 @@
#if 0
// DEPRECATE
/* radare - LGPL - Copyright 2007-2012 pancake */
/* radare - LGPL - Copyright 2007-2012 - pancake */
#include <r_flags.h>
#include <r_util.h>
#include <r_cons.h>
#include <stdio.h>
// TODO: remove r_cons dependency here..
// remove btree here.. we want something funnier like.. RMixed :D
/* compare names */
static int ncmp(const void *a, const void *b) {
RFlagItem *fa = (RFlagItem *)a;
RFlagItem *fb = (RFlagItem *)b;
return strcmp (fa->name, fb->name);
}
/* compare offsets */
static int cmp(const void *a, const void *b) {
RFlagItem *fa = (RFlagItem *)a;
RFlagItem *fb = (RFlagItem *)b;
if (fa->offset > fb->offset) return 1;
else if (fa->offset < fb->offset) return -1;
return 0;
}
R_API int r_flag_sort(RFlag *f, int namesort) {
int ret = R_FALSE;
int changes;
RFlagItem *flag, *fi = NULL;
RListIter *iter, *it_elem;
RList *tmp = r_list_new ();
// find bigger ones after this
do {
changes = 0;
fi = NULL;
r_list_foreach (f->flags, iter, flag) {
if (fi == NULL) {
fi = flag;
it_elem = iter;
changes = 1;
} else if (((namesort)? ncmp (fi, flag): cmp (fi, flag)) <= 0) {
fi = flag;
it_elem = iter;
changes = 1;
}
}
if (fi && changes) {
ret = R_TRUE;
r_list_split_iter (f->flags, it_elem);
free (it_elem);
r_list_append (tmp, fi);
}
} while (changes);
free (f->flags);
f->flags = tmp;
f->flags->free = free;
return ret;
}
R_API RFlag * r_flag_free(RFlag *f) {
if (!f) return NULL;
r_list_free (f->flags);
free (f);
return NULL;
}
R_API RFlag * r_flag_new() {
int i;
RFlag *f = R_NEW (RFlag);
if (!f) return NULL;
f->base = 0;
f->flags = r_list_new ();
f->flags->free = free;
f->flags->free = (RListFree) r_flag_item_free;
f->space_idx = -1;
f->space_idx2 = -1;
#if USE_BTREE
btree_init (&f->tree);
btree_init (&f->ntree);
#endif
f->ht_name = r_hashtable64_new ();
f->ht_off = r_hashtable64_new ();
for (i=0; i<R_FLAG_SPACES_MAX; i++)
f->spaces[i] = NULL;
return f;
}
// Deprecated??
R_API void r_flag_item_free (RFlagItem *item) {
free (item->cmd);
free (item->comment);
item->cmd = item->comment = NULL;
free (item);
}
R_API RFlag *r_flag_free(RFlag *f) {
RFlagItem *item;
RListIter *iter;
r_list_foreach (f->flags, iter, item) {
RList *list = r_hashtable64_lookup (f->ht_name, item->namehash);
r_list_free (list);
list = r_hashtable64_lookup (f->ht_off, item->offset);
// XXX: segfault sometimes wtf -- r_list_free (list);
}
r_hashtable64_free (f->ht_off);
r_hashtable64_free (f->ht_name);
r_list_free (f->flags);
free (f);
return NULL;
}
R_API void r_flag_list(RFlag *f, int rad) {
int fs = -1;
RListIter *iter;
@ -99,194 +57,292 @@ R_API void r_flag_list(RFlag *f, int rad) {
fs = flag->space;
r_cons_printf ("fs %s\n", r_flag_space_get_i (f, fs));
}
r_cons_printf ("f %s %"PFMT64d" 0x%08"PFMT64x"\n",
flag->name, flag->size, flag->offset);
r_cons_printf ("f %s %"PFMT64d" 0x%08"PFMT64x" %s\n",
flag->name, flag->size, flag->offset,
flag->comment? flag->comment:"");
} else r_cons_printf("0x%08"PFMT64x" %"PFMT64d" %s\n",
flag->offset, flag->size, flag->name);
}
}
R_API RFlagItem *r_flag_get(RFlag *f, const char *name) {
RFlagItem *flag;
RListIter *iter;
if (strnull (name) || (name[0]>='0' && name[0]<='9'))
return NULL;
ut64 hash = r_str_hash64 (name);
r_list_foreach_prev (f->flags, iter, flag) {
//if (!strcmp (name, flag->name))
if (hash == flag->namehash)
return flag;
RList *list = r_hashtable64_lookup (f->ht_name, r_str_hash64 (name));
if (list) {
RFlagItem *item = r_list_get_top (list);
return item;
}
return NULL;
}
#define R_FLAG_TEST 0
R_API RFlagItem *r_flag_get_i(RFlag *f, ut64 off) {
RList *list = r_hashtable64_lookup (f->ht_off, off);
if (list) {
RFlagItem *item = r_list_get_top (list);
#if R_FLAG_TEST
return item;
#else
// XXX: hack, because some times the hashtable is poluted by ghost values
if (item->offset == off)
return item;
#endif
}
return NULL;
}
R_API int r_flag_set(RFlag *f, const char *name, ut64 off, ut32 size, int dup) {
RList *list2, *list;
dup = 0; // XXX: force nondup
if (dup) {
RFlagItem *item = R_NEW0 (RFlagItem);
item->space = f->space_idx;
r_list_append (f->flags, item);
r_flag_item_set_name (item, name);
item->offset = off + f->base;
item->size = size;
list = r_hashtable64_lookup (f->ht_name, item->namehash);
if (!list) {
list = r_list_new ();
r_hashtable64_insert (f->ht_name, item->namehash, list);
}
r_list_append (list, item);
list2 = r_hashtable64_lookup (f->ht_off, off);
if (list2 == NULL) {
list2 = r_list_new ();
r_hashtable64_insert (f->ht_name, off, list2);
}
r_list_append (list2, item);
} else {
RListIter *iter2 = NULL;
RFlagItem *item2 = NULL, *item = r_flag_get (f, name);
if (item) {
RList *list2, *lol;
if (item->offset == off)
return R_TRUE;
/* remove old entry */
list2 = r_hashtable64_lookup (f->ht_off, item->offset);
if (list2)
/* No _safe loop necessary because we break immediately after the delete. */
r_list_foreach (list2, iter2, item2) {
if (item->namehash != item2->namehash)
continue;
if (item2->offset == item->offset) {
// r_list_delete (list2, iter2);
// delete without freeing contents
r_list_split_iter (list2, iter2);
free (iter2);
if (r_list_empty (list2)) {
r_list_free (list2);
r_hashtable64_remove (f->ht_off, item2->offset);
r_hashtable64_insert (f->ht_off, item2->offset, NULL);
}
break;
}
}
lol = r_hashtable64_lookup (f->ht_off, off);
if (lol == NULL) {
lol = r_list_new ();
r_hashtable64_insert (f->ht_off, off, lol);
}
r_list_append (lol, item);
/* update new entry */
item->offset = off;
item->size = size;
} else {
item = R_NEW0 (RFlagItem);
item->space = f->space_idx;
r_list_append (f->flags, item);
r_flag_item_set_name (item, name);
item->offset = off + f->base;
item->size = size;
list = r_hashtable64_lookup (f->ht_name, item->namehash);
if (!list) {
list = r_list_new ();
r_hashtable64_insert (f->ht_name, item->namehash, list);
}
r_list_append (list, item);
list2 = r_hashtable64_lookup (f->ht_off, off);
if (list2 == NULL) {
list2 = r_list_new ();
r_hashtable64_insert (f->ht_off, off, list2);
}
r_list_append (list2, item);
}
}
return R_FALSE;
}
R_API void r_flag_item_set_comment(RFlagItem *item, const char *comment) {
free (item->comment);
item->comment = strdup (comment);
}
R_API int r_flag_item_set_name(RFlagItem *item, const char *name) {
int len;
if (!item || !r_name_check (name))
return R_FALSE;
strncpy (item->name, name, R_FLAG_NAME_SIZE);
len = R_MIN (R_FLAG_NAME_SIZE, strlen (r_str_chop (item->name)) + 1);
memmove (item->name, r_str_chop (item->name), len);
r_name_filter (item->name, 0);
item->name[R_FLAG_NAME_SIZE-1]='\0';
item->namehash = r_str_hash64 (item->name);
return R_TRUE;
}
R_API int r_flag_rename(RFlag *f, RFlagItem *item, const char *name) {
ut64 hash;
RList *list;
if (!f || !item || !name || !*name) {
eprintf ("r_flag_rename: contract fail\n");
return R_FALSE;
}
hash = r_str_hash64 (item->name);
list = r_hashtable64_lookup (f->ht_name, hash);
if (list) {
RFlagItem *item = r_list_get_top (list);
if (r_list_empty (list)) {
r_list_free (list);
r_hashtable64_remove (f->ht_name, hash);
}
r_list_delete_data (list, item);
if (!r_flag_item_set_name (item, name)) {
r_list_append (list, item);
return R_FALSE;
}
list = r_hashtable64_lookup (f->ht_name, item->namehash);
if (!list) {
list = r_list_new ();
r_hashtable64_insert (f->ht_name, item->namehash, list);
}
r_list_append (list, item);
}
return R_TRUE;
}
R_API int r_flag_unset_i(RFlag *f, ut64 off, RFlagItem *p) {
RFlagItem *flag = r_flag_get_i (f, off);
if (flag) {
r_flag_unset (f, flag->name, NULL); //, flag);
return R_TRUE;
}
return R_FALSE;
}
R_API int r_flag_unset_glob(RFlag *f, const char *glob) {
int n = 0;
RListIter it, *iter;
RFlagItem *flag;
r_list_foreach (f->flags, iter, flag) {
if ((f->space_idx != -1) && (flag->space != f->space_idx))
continue;
if (r_str_glob (flag->name, glob)) {
it.n = iter->n;
r_flag_unset (f, flag->name, flag);
iter = &it;
n++;
}
}
return n;
}
static void unflag(RFlag *f, ut64 namehash) {
RFlagItem *item;
RListIter *iter;
/* No _safe loop necessary because we return immediately after the delete. */
r_list_foreach (f->flags, iter, item) {
if (item->namehash == namehash) {
r_list_delete (f->flags, iter);
break;
}
}
}
R_API int r_flag_unset(RFlag *f, const char *name, RFlagItem *p) {
ut64 off;
RListIter *iter2;
RFlagItem *item2, *item = p;
ut64 hash = r_str_hash64 (name);
RList *list2, *list = r_hashtable64_lookup (f->ht_name, hash);
// list = name hash
// list2 = off hash
if (list && list->head) {
if (!item) item = r_list_pop (list);
if (!item) return R_FALSE;
off = item->offset;
list2 = r_hashtable64_lookup (f->ht_off, off);
if (list2) {
/* delete flag by name */
/* No _safe loop necessary because we break immediately after the delete. */
r_list_foreach (list2, iter2, item2) {
if (hash == item2->namehash) {
r_list_delete (list2, iter2);
break;
}
}
if (list2 && r_list_empty (list2)) {
r_list_free (list2);
r_hashtable64_remove (f->ht_off, off);
}
}
/* delete from f->flags list */
unflag (f, hash);
if (list && r_list_empty (list)) {
r_list_free (list);
r_hashtable64_remove (f->ht_name, hash);
}
return R_TRUE;
}
return R_FALSE;
}
R_API RFlagItem *r_flag_get_at(RFlag *f, ut64 off) {
RFlagItem *item, *nice = NULL;
RListIter *iter;
r_list_foreach (f->flags, iter, item) {
if (item->offset > off) {
if (item->offset == off)
return item;
if (off > item->offset) {
if (nice) {
if (item->offset < nice->offset)
if (nice->offset < item->offset)
nice = item;
}else nice = item;
} else nice = item;
}
}
return nice;
}
R_API RFlagItem *r_flag_get_i(RFlag *f, ut64 off) {
#ifdef MYTEST
int main () {
RFlagItem *i;
#if USE_BTREE
RFlagItem tmp = { .offset = off };
i = btree_get (f->tree, &tmp, cmp);
return i;
#else
/* slow workaround */
RListIter *iter;
r_list_foreach_prev (f->flags, iter, i) {
if (off == i->offset)
return i;
}
return NULL;
#endif
}
RFlag *f = r_flag_new ();
r_flag_set (f, "rip", 0xfff333999000LL, 1, 0);
r_flag_set (f, "rip", 0xfff333999002LL, 1, 0);
r_flag_unset (f, "rip", NULL);
r_flag_set (f, "rip", 3, 4, 0);
r_flag_set (f, "rip", 4, 4, 0);
r_flag_set (f, "corwp", 300, 4, 0);
r_flag_set (f, "barp", 300, 4, 0);
r_flag_set (f, "rip", 3, 4, 0);
r_flag_set (f, "rip", 4, 4, 0);
R_API int r_flag_unset_i(RFlag *f, ut64 addr, RFlagItem *p) {
RFlagItem *item;
RListIter *iter;
i = r_flag_get (f, "rip");
if (i) printf ("nRIP: %p %llx\n", i, i->offset);
else printf ("nRIP: null\n");
#if USE_BTREE
/* XXX */
btree_del (f->tree, item, cmp, NULL);
btree_del (f->ntree, item, ncmp, NULL);
#endif
/* No _safe loop necessary because we return immediately after the delete. */
r_list_foreach (f->flags, iter, item) {
if (item->offset == addr) {
r_list_delete (f->flags, iter);
return R_TRUE;
}
}
return R_FALSE;
#if USE_BTREE
/* XXX */
btree_del (f->tree, item, cmp, NULL);
btree_del (f->ntree, item, ncmp, NULL);
#endif
return 0;
}
R_API int r_flag_unset(RFlag *f, const char *name, RFlagItem *p) {
RFlagItem *item;
RListIter *iter;
if (*name == '*') {
r_list_destroy (f->flags);
} else {
item = r_flag_get (f, name);
// XXX: This is slow.. because get+unlink is traversing the linked list twice
// XXX: we must use a hashtable here
/* MARK: entrypoint to remove flags */
if (item) {
#if USE_BTREE
btree_del (f->tree, item, cmp, NULL);
btree_del (f->ntree, item, ncmp, NULL);
#endif
r_list_unlink (f->flags, item);
}
}
return 0;
}
R_API int r_flag_set(RFlag *fo, const char *name, ut64 addr, ut32 size, int dup) {
RFlagItem *flag = NULL;
#if !USE_BTREE
RListIter *iter;
#endif
if (!dup && !r_flag_name_check (name)) {
eprintf ("r_flag_set: invalid flag name '%s'.\n", name);
return R_FALSE;
}
#if USE_BTREE
{
/* XXX : This is not working properly!! */
RFlagItem tmp;
tmp.namehash = r_str_hash64 (name);
//eprintf("NAME(%s) HASH(%x)\n", name, tmp.namehash);
flag = btree_get (fo->ntree, &tmp, ncmp);
if (flag) {
if (dup) {
/* ignore dupped name+offset */
if (flag->offset == addr)
return 1;
} else {
flag->offset = addr;
flag->size = size; // XXX
flag->format = 0; // XXX
//eprintf("update '%s'\n", f->name);
return R_TRUE;
}
}
// if (flag)
// return R_TRUE;
// else eprintf("NOT REGISTERED(%s)\n", name);
}
#else
RFlagItem *f; // Move to !BTREE section?
ut64 hash = r_str_hash64 (name);
// THIS IS ULTRASLOW!
// XXX: use hashtable here or gtfo
r_list_foreach (fo->flags, iter, f) {
//if (!strcmp(f->name, name)) {
if (hash == f->namehash) {
if (dup) {
/* ignore dupped name+offset */
if (f->offset == addr)
return 1;
} else {
flag = f;
f->offset = addr;
f->size = size; // XXX
f->format = 0; // XXX
return R_TRUE;
}
}
}
#endif
if (flag == NULL) {
/* MARK: entrypoint for flag addition */
flag = R_NEW (RFlagItem);
memset (flag,'\0', sizeof (RFlagItem));
flag->offset = addr;
r_flag_item_set_name (flag, name);
#if USE_BTREE
btree_add (&fo->tree, flag, cmp);
btree_add (&fo->ntree, flag, ncmp);
#endif
r_list_append (fo->flags, flag);
if (flag==NULL)
return R_TRUE;
}
flag->offset = addr;
flag->space = fo->space_idx;
flag->size = size; // XXX
flag->format = 0; // XXX
flag->cmd = NULL;
return R_FALSE;
}
//R_API void r_flag_item_rename(RFlagItem *item, const char *name) {
//}
R_API void r_flag_item_set_name(RFlagItem *item, const char *name) {
int len;
strncpy (item->name, name, R_FLAG_NAME_SIZE);
len = R_MIN (R_FLAG_NAME_SIZE, strlen (r_str_chop (item->name)) + 1);
memmove (item->name, r_str_chop (item->name), len);
item->name[R_FLAG_NAME_SIZE-1]='\0';
item->namehash = r_str_hash64 (item->name);
i = r_flag_get_i (f, 0xfff333999000LL);
if (i) printf ("iRIP: %p %llx\n", i, i->offset);
else printf ("iRIP: null\n");
}
#endif

348
libr/flags/htflags.c
View File

@ -1,348 +0,0 @@
/* radare - LGPL - Copyright 2007-2012 - pancake */
#include <r_flags.h>
#include <r_util.h>
#include <r_cons.h>
#include <stdio.h>
R_API RFlag * r_flag_new() {
int i;
RFlag *f = R_NEW (RFlag);
if (!f) return NULL;
f->base = 0;
f->flags = r_list_new ();
f->flags->free = (RListFree) r_flag_item_free;
f->space_idx = -1;
f->space_idx2 = -1;
f->ht_name = r_hashtable64_new ();
f->ht_off = r_hashtable64_new ();
for (i=0; i<R_FLAG_SPACES_MAX; i++)
f->spaces[i] = NULL;
return f;
}
R_API void r_flag_item_free (RFlagItem *item) {
free (item->cmd);
free (item->comment);
item->cmd = item->comment = NULL;
free (item);
}
R_API RFlag *r_flag_free(RFlag *f) {
RFlagItem *item;
RListIter *iter;
r_list_foreach (f->flags, iter, item) {
RList *list = r_hashtable64_lookup (f->ht_name, item->namehash);
r_list_free (list);
list = r_hashtable64_lookup (f->ht_off, item->offset);
// XXX: segfault sometimes wtf -- r_list_free (list);
}
r_hashtable64_free (f->ht_off);
r_hashtable64_free (f->ht_name);
r_list_free (f->flags);
free (f);
return NULL;
}
R_API void r_flag_list(RFlag *f, int rad) {
int fs = -1;
RListIter *iter;
RFlagItem *flag;
r_list_foreach_prev (f->flags, iter, flag) {
if ((f->space_idx != -1) && (flag->space != f->space_idx))
continue;
if (rad) {
if (fs == -1 || flag->space != fs) {
fs = flag->space;
r_cons_printf ("fs %s\n", r_flag_space_get_i (f, fs));
}
r_cons_printf ("f %s %"PFMT64d" 0x%08"PFMT64x" %s\n",
flag->name, flag->size, flag->offset,
flag->comment? flag->comment:"");
} else r_cons_printf("0x%08"PFMT64x" %"PFMT64d" %s\n",
flag->offset, flag->size, flag->name);
}
}
R_API RFlagItem *r_flag_get(RFlag *f, const char *name) {
RList *list = r_hashtable64_lookup (f->ht_name, r_str_hash64 (name));
if (list) {
RFlagItem *item = r_list_get_top (list);
return item;
}
return NULL;
}
#define R_FLAG_TEST 0
R_API RFlagItem *r_flag_get_i(RFlag *f, ut64 off) {
RList *list = r_hashtable64_lookup (f->ht_off, off);
if (list) {
RFlagItem *item = r_list_get_top (list);
#if R_FLAG_TEST
return item;
#else
// XXX: hack, because some times the hashtable is poluted by ghost values
if (item->offset == off)
return item;
#endif
}
return NULL;
}
R_API int r_flag_set(RFlag *f, const char *name, ut64 off, ut32 size, int dup) {
RList *list2, *list;
dup = 0; // XXX: force nondup
if (dup) {
RFlagItem *item = R_NEW0 (RFlagItem);
item->space = f->space_idx;
r_list_append (f->flags, item);
r_flag_item_set_name (item, name);
item->offset = off + f->base;
item->size = size;
list = r_hashtable64_lookup (f->ht_name, item->namehash);
if (!list) {
list = r_list_new ();
r_hashtable64_insert (f->ht_name, item->namehash, list);
}
r_list_append (list, item);
list2 = r_hashtable64_lookup (f->ht_off, off);
if (list2 == NULL) {
list2 = r_list_new ();
r_hashtable64_insert (f->ht_name, off, list2);
}
r_list_append (list2, item);
} else {
RListIter *iter2 = NULL;
RFlagItem *item2 = NULL, *item = r_flag_get (f, name);
if (item) {
RList *list2, *lol;
if (item->offset == off)
return R_TRUE;
/* remove old entry */
list2 = r_hashtable64_lookup (f->ht_off, item->offset);
if (list2)
/* No _safe loop necessary because we break immediately after the delete. */
r_list_foreach (list2, iter2, item2) {
if (item->namehash != item2->namehash)
continue;
if (item2->offset == item->offset) {
// r_list_delete (list2, iter2);
// delete without freeing contents
r_list_split_iter (list2, iter2);
free (iter2);
if (r_list_empty (list2)) {
r_list_free (list2);
r_hashtable64_remove (f->ht_off, item2->offset);
r_hashtable64_insert (f->ht_off, item2->offset, NULL);
}
break;
}
}
lol = r_hashtable64_lookup (f->ht_off, off);
if (lol == NULL) {
lol = r_list_new ();
r_hashtable64_insert (f->ht_off, off, lol);
}
r_list_append (lol, item);
/* update new entry */
item->offset = off;
item->size = size;
} else {
item = R_NEW0 (RFlagItem);
item->space = f->space_idx;
r_list_append (f->flags, item);
r_flag_item_set_name (item, name);
item->offset = off + f->base;
item->size = size;
list = r_hashtable64_lookup (f->ht_name, item->namehash);
if (!list) {
list = r_list_new ();
r_hashtable64_insert (f->ht_name, item->namehash, list);
}
r_list_append (list, item);
list2 = r_hashtable64_lookup (f->ht_off, off);
if (list2 == NULL) {
list2 = r_list_new ();
r_hashtable64_insert (f->ht_off, off, list2);
}
r_list_append (list2, item);
}
}
return R_FALSE;
}
R_API void r_flag_item_set_comment(RFlagItem *item, const char *comment) {
free (item->comment);
item->comment = strdup (comment);
}
R_API int r_flag_item_set_name(RFlagItem *item, const char *name) {
int len;
if (!item || !r_name_check (name))
return R_FALSE;
strncpy (item->name, name, R_FLAG_NAME_SIZE);
len = R_MIN (R_FLAG_NAME_SIZE, strlen (r_str_chop (item->name)) + 1);
memmove (item->name, r_str_chop (item->name), len);
r_name_filter (item->name, 0);
item->name[R_FLAG_NAME_SIZE-1]='\0';
item->namehash = r_str_hash64 (item->name);
return R_TRUE;
}
R_API int r_flag_rename(RFlag *f, RFlagItem *item, const char *name) {
ut64 hash;
RList *list;
if (!f || !item || !name || !*name) {
eprintf ("r_flag_rename: contract fail\n");
return R_FALSE;
}
hash = r_str_hash64 (item->name);
list = r_hashtable64_lookup (f->ht_name, hash);
if (list) {
RFlagItem *item = r_list_get_top (list);
if (r_list_empty (list)) {
r_list_free (list);
r_hashtable64_remove (f->ht_name, hash);
}
r_list_delete_data (list, item);
if (!r_flag_item_set_name (item, name)) {
r_list_append (list, item);
return R_FALSE;
}
list = r_hashtable64_lookup (f->ht_name, item->namehash);
if (!list) {
list = r_list_new ();
r_hashtable64_insert (f->ht_name, item->namehash, list);
}
r_list_append (list, item);
}
return R_TRUE;
}
R_API int r_flag_unset_i(RFlag *f, ut64 off, RFlagItem *p) {
RFlagItem *flag = r_flag_get_i (f, off);
if (flag) {
r_flag_unset (f, flag->name, NULL); //, flag);
return R_TRUE;
}
return R_FALSE;
}
R_API int r_flag_unset_glob(RFlag *f, const char *glob) {
int n = 0;
RListIter it, *iter;
RFlagItem *flag;
r_list_foreach (f->flags, iter, flag) {
if ((f->space_idx != -1) && (flag->space != f->space_idx))
continue;
if (r_str_glob (flag->name, glob)) {
it.n = iter->n;
r_flag_unset (f, flag->name, flag);
iter = &it;
n++;
}
}
return n;
}
static void unflag(RFlag *f, ut64 namehash) {
RFlagItem *item;
RListIter *iter;
/* No _safe loop necessary because we return immediately after the delete. */
r_list_foreach (f->flags, iter, item) {
if (item->namehash == namehash) {
r_list_delete (f->flags, iter);
break;
}
}
}
R_API int r_flag_unset(RFlag *f, const char *name, RFlagItem *p) {
ut64 off;
RListIter *iter2;
RFlagItem *item2, *item = p;
ut64 hash = r_str_hash64 (name);
RList *list2, *list = r_hashtable64_lookup (f->ht_name, hash);
// list = name hash
// list2 = off hash
if (list && list->head) {
if (!item) item = r_list_pop (list);
if (!item) return R_FALSE;
off = item->offset;
list2 = r_hashtable64_lookup (f->ht_off, off);
if (list2) {
/* delete flag by name */
/* No _safe loop necessary because we break immediately after the delete. */
r_list_foreach (list2, iter2, item2) {
if (hash == item2->namehash) {
r_list_delete (list2, iter2);
break;
}
}
if (list2 && r_list_empty (list2)) {
r_list_free (list2);
r_hashtable64_remove (f->ht_off, off);
}
}
/* delete from f->flags list */
unflag (f, hash);
if (list && r_list_empty (list)) {
r_list_free (list);
r_hashtable64_remove (f->ht_name, hash);
}
return R_TRUE;
}
return R_FALSE;
}
R_API RFlagItem *r_flag_get_at(RFlag *f, ut64 off) {
RFlagItem *item, *nice = NULL;
RListIter *iter;
r_list_foreach (f->flags, iter, item) {
if (item->offset == off)
return item;
if (off > item->offset) {
if (nice) {
if (nice->offset < item->offset)
nice = item;
} else nice = item;
}
}
return nice;
}
#ifdef MYTEST
int main () {
RFlagItem *i;
RFlag *f = r_flag_new ();
r_flag_set (f, "rip", 0xfff333999000LL, 1, 0);
r_flag_set (f, "rip", 0xfff333999002LL, 1, 0);
r_flag_unset (f, "rip", NULL);
r_flag_set (f, "rip", 3, 4, 0);
r_flag_set (f, "rip", 4, 4, 0);
r_flag_set (f, "corwp", 300, 4, 0);
r_flag_set (f, "barp", 300, 4, 0);
r_flag_set (f, "rip", 3, 4, 0);
r_flag_set (f, "rip", 4, 4, 0);
i = r_flag_get (f, "rip");
if (i) printf ("nRIP: %p %llx\n", i, i->offset);
else printf ("nRIP: null\n");
i = r_flag_get_i (f, 0xfff333999000LL);
if (i) printf ("iRIP: %p %llx\n", i, i->offset);
else printf ("iRIP: null\n");
}
#endif

2
libr/include/r_cons.h
View File

@ -80,6 +80,7 @@ typedef struct r_cons_t {
/* Pager (like more or less) to use if the output doesn't fit on the
* current window. If NULL or "" no pager is used. */
char *pager;
int blankline;
} RCons;
// XXX THIS MUST BE A SINGLETON AND WRAPPED INTO RCons */
@ -188,6 +189,7 @@ R_API int r_cons_w32_print(ut8 *ptr, int empty);
/* control */
R_API void r_cons_reset();
R_API void r_cons_print_clear();
R_API void r_cons_clear();
R_API void r_cons_clear00();
R_API void r_cons_clear_line();

1
libr/include/r_util.h
View File

@ -330,6 +330,7 @@ R_API ut64 r_num_get(RNum *num, const char *str);
R_API int r_num_to_bits(char *out, ut64 num);
R_API int r_num_rand(int max);
R_API void r_num_irand();
R_API ut16 r_num_ntohs (ut16 foo);
/* TODO ..use as uppercase maybe? they are macros! */
#define R_BETWEEN(x,y,z) (((y)>=(x)) && ((y)<=(z)))

10
libr/io/section.c
View File

@ -80,9 +80,13 @@ R_API void r_io_section_list(RIO *io, ut64 offset, int rad) {
if (io->va || io->debug)
offset = r_io_section_vaddr_to_offset (io, offset);
r_list_foreach (io->sections, iter, s) {
if (rad) io->printf ("S 0x%08"PFMT64x" 0x%08"PFMT64x" 0x%08"PFMT64x" 0x%08"PFMT64x" %s %s\n",
s->offset, s->vaddr, s->size, s->vsize, s->name, r_str_rwx_i (s->rwx));
else io->printf ("[%.2d] %c 0x%08"PFMT64x" %s va=0x%08"PFMT64x" sz=0x%08"PFMT64x" vsz=%08"PFMT64x" %s\n",
if (rad) {
char *n = strdup (s->name);
r_name_filter (n, strlen (n));
io->printf ("f section.%s %"PFMT64d" 0x%"PFMT64x"\n", n, s->size, s->vaddr);
io->printf ("S 0x%08"PFMT64x" 0x%08"PFMT64x" 0x%08"PFMT64x" 0x%08"PFMT64x" %s %s\n",
s->offset, s->vaddr, s->size, s->vsize, n, r_str_rwx_i (s->rwx));
} else io->printf ("[%.2d] %c 0x%08"PFMT64x" %s va=0x%08"PFMT64x" sz=0x%08"PFMT64x" vsz=%08"PFMT64x" %s\n",
s->id, (offset>=s->offset && offset<s->offset+s->size)?'*':'.',
s->offset, r_str_rwx_i (s->rwx), s->vaddr, s->size, s->vsize, s->name);
i++;

11
libr/util/num.c
View File

@ -3,6 +3,13 @@
#include "r_util.h"
#define R_NUM_USE_CALC 1
R_API ut16 r_num_ntohs (ut16 foo) {
#if LIL_ENDIAN
ut8 *p = (ut8*)&foo;
foo = p[1] | p[0]<<8;
#endif
return foo;
}
#define __htonq(x) (\
(((x) & 0xff00000000000000LL) >> 56) | \
@ -82,9 +89,9 @@ R_API ut64 r_num_get(RNum *num, const char *str) {
if (len>3 && str[4] == ':')
if (sscanf (str, "%04x", &s)==1)
if (sscanf (str+5, "%04x", &a)==1)
return (ut64) ((s<<16) | a);
return (ut64) ((s<<8) + a);
if (sscanf (str, "0x%04x:0x%04x", &s, &a) == 2)
return (ut64) ((s<<16) |a);
return (ut64) ((s<<8) + a);
if (str[0]=='0' && str[1]=='x') {
sscanf (str, "0x%"PFMT64x"", &ret);
} else {

0
libr/core/hud/main → shlr/hud/main
View File