Remove legacy unit tests (#3088)
This commit is contained in:
Anton Kochkov
GitHub
parent
ead601655c
commit
a3885e8f99
72 changed files with 4 additions and 1980 deletions
|
|
@ -75,6 +75,10 @@ Files: **/meson_options.txt
|
|||
Copyright: 2021 RizinOrg <info@rizin.re>
|
||||
License: LGPL-3.0-only
|
||||
|
||||
Files: doc/examples/egg/*
|
||||
Copyright: 2009 RadareOrg <pancake@nopcode.org>
|
||||
License: LGPL-3.0-only
|
||||
|
||||
Files: doc/fortunes*
|
||||
Copyright: 2009 RadareOrg <pancake@nopcode.org>
|
||||
License: LGPL-3.0-only
|
||||
|
|
|
|||
|
|
@ -1,11 +0,0 @@
|
|||
CFLAGS+=-I../../include
|
||||
LDFLAGS+=-lrz_cons -L../../librz/cons
|
||||
LDFLAGS+=-lrz_util -L../../librz/util
|
||||
|
||||
all: graph test-rgb
|
||||
|
||||
test-rgb: test-rgb.o
|
||||
$(CC) -o test-rgb test-rgb.o $(LDFLAGS)
|
||||
|
||||
graph: graph.o
|
||||
$(CC) -o graph graph.o $(LDFLAGS)
|
||||
|
|
@ -1,132 +0,0 @@
|
|||
/* Copyright rizin 2014 - Author: pancake */
|
||||
|
||||
#include <rz_cons.h>
|
||||
|
||||
typedef struct {
|
||||
int x;
|
||||
int y;
|
||||
int w;
|
||||
int h;
|
||||
ut64 addr;
|
||||
const char *text;
|
||||
} Node;
|
||||
|
||||
typedef struct {
|
||||
int nth;
|
||||
int from;
|
||||
int to;
|
||||
} Edge;
|
||||
|
||||
int curnode = 0;
|
||||
|
||||
static Node nodes[] = {
|
||||
{ 25, 4, 18, 6, 0x8048320, "push ebp\nmov esp, ebp\njz 0x8048332" },
|
||||
{ 10, 13, 18, 5, 0x8048332, "xor eax, eax\nint 0x80\n" },
|
||||
{ 30, 13, 18, 5, 0x8048324, "pop ebp\nret" },
|
||||
{ NULL }
|
||||
};
|
||||
|
||||
static Edge edges[] = {
|
||||
{ 0, 0, 1 },
|
||||
{ 1, 0, 2 },
|
||||
{ -1 }
|
||||
};
|
||||
|
||||
#define G(x, y) rz_cons_canvas_gotoxy(can, x, y)
|
||||
#define W(x) rz_cons_canvas_write(can, x)
|
||||
#define B(x, y, w, h) rz_cons_canvas_box(can, x, y, w, h)
|
||||
#define L(x, y, x2, y2) rz_cons_canvas_line(can, x, y, x2, y2, 0)
|
||||
#define F(x, y, x2, y2, c) rz_cons_canvas_fill(can, x, y, x2, y2, c, 0)
|
||||
|
||||
static void Node_print(RzConsCanvas *can, Node *n, int cur) {
|
||||
char title[128];
|
||||
|
||||
n->w = rz_str_bounds(n->text, &n->h);
|
||||
n->w += 4;
|
||||
n->h += 4;
|
||||
n->w = RZ_MAX(18, n->w);
|
||||
if (cur) {
|
||||
F(n->x, n->y, n->w, n->h, '.');
|
||||
snprintf(title, sizeof(title) - 1,
|
||||
"-[ 0x%08" PFMT64x " ]-", n->addr);
|
||||
} else {
|
||||
snprintf(title, sizeof(title) - 1,
|
||||
" 0x%08" PFMT64x " ", n->addr);
|
||||
}
|
||||
G(n->x + 1, n->y + 1);
|
||||
W(title);
|
||||
G(n->x + 2, n->y + 2);
|
||||
W(n->text);
|
||||
G(n->x + 1, n->y + 1);
|
||||
W(title);
|
||||
B(n->x, n->y, n->w, n->h);
|
||||
}
|
||||
|
||||
static void Edge_print(RzConsCanvas *can, Node *a, Node *b, int nth) {
|
||||
int x, y, x2, y2;
|
||||
int xinc = 3 + (nth * 3);
|
||||
x = a->x + xinc;
|
||||
y = a->y + a->h;
|
||||
x2 = b->x + xinc;
|
||||
y2 = b->y;
|
||||
L(x, y, x2, y2);
|
||||
}
|
||||
|
||||
main() {
|
||||
int w, h, i;
|
||||
RzConsCanvas *can;
|
||||
RzCons *c = rz_cons_new();
|
||||
w = rz_cons_get_size(&h);
|
||||
can = rz_cons_canvas_new(w - 1, h - 1);
|
||||
repeat:
|
||||
rz_cons_canvas_clear(can);
|
||||
|
||||
for (i = 0; edges[i].nth != -1; i++) {
|
||||
Node *a = &nodes[edges[i].from];
|
||||
Node *b = &nodes[edges[i].to];
|
||||
Edge_print(can, a, b, edges[i].nth);
|
||||
}
|
||||
for (i = 0; nodes[i].text; i++) {
|
||||
Node_print(can, &nodes[i], i == curnode);
|
||||
}
|
||||
// rz_cons_canvas_line (can, 12, 4+5, X+5, 5, 0);
|
||||
|
||||
rz_cons_canvas_print(can);
|
||||
rz_cons_flush();
|
||||
int key = rz_cons_readchar();
|
||||
#define N nodes[curnode]
|
||||
switch (key) {
|
||||
case 9:
|
||||
curnode++;
|
||||
if (!nodes[curnode].text)
|
||||
curnode = 0;
|
||||
break;
|
||||
case 'j': N.y++; break;
|
||||
case 'k': N.y--; break;
|
||||
case 'h': N.x--; break;
|
||||
case 'l': N.x++; break;
|
||||
case 'J': N.y += 2; break;
|
||||
case 'K': N.y -= 2; break;
|
||||
case 'H': N.x -= 2; break;
|
||||
case 'L': N.x += 2; break;
|
||||
case 'q': exit(0);
|
||||
case 27: // ESC
|
||||
if (rz_cons_readchar() == 91) {
|
||||
if (rz_cons_readchar() == 90) {
|
||||
if (curnode < 1) {
|
||||
int i;
|
||||
for (i = 0; nodes[i].text; i++) {
|
||||
};
|
||||
curnode = i - 1;
|
||||
} else
|
||||
curnode--;
|
||||
}
|
||||
}
|
||||
break;
|
||||
default:
|
||||
eprintf("Key %d\n", key);
|
||||
sleep(1);
|
||||
}
|
||||
goto repeat;
|
||||
rz_cons_free(c);
|
||||
}
|
||||
|
|
@ -1,32 +0,0 @@
|
|||
#include <rz_cons.h>
|
||||
|
||||
int main() {
|
||||
int i, j, k;
|
||||
// char *str = "\x1b[38;5;231mpop\x1b[0m";
|
||||
// char *str ="\x1b]4;%d;rgb:30/20/24pop\x1b[0m";
|
||||
char *str = "\x1b\\pop\x1b[0m";
|
||||
i = j = k = 0;
|
||||
|
||||
rz_cons_new();
|
||||
// rz_cons_rgb_init ();
|
||||
printf("3 == %d\n", rz_str_ansi_len(str));
|
||||
for (i = 0; i < 255; i += 40) {
|
||||
for (j = 0; j < 255; j += 40) {
|
||||
for (k = 0; k < 255; k += 40) {
|
||||
rz_cons_rgb(i, j, k, 0);
|
||||
rz_cons_rgb(i, j, k, 1);
|
||||
rz_cons_print("__");
|
||||
rz_cons_reset_colors();
|
||||
|
||||
rz_cons_rgb(i, j, k, 0);
|
||||
// rz_cons_rgb (155, 200, 200, 1);
|
||||
rz_cons_printf(" RGB %d %d %d", i, j, k);
|
||||
rz_cons_reset_colors();
|
||||
rz_cons_newline();
|
||||
}
|
||||
}
|
||||
}
|
||||
rz_cons_flush();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,6 +0,0 @@
|
|||
OBJ=main.o
|
||||
BIN=main
|
||||
BINDEPS=rz_debug rz_bp rz_io rz_reg rz_cons rz_analysis rz_socket rz_syscall rz_db rz_util
|
||||
|
||||
include ../../rules.mk
|
||||
include ../../db/r.mk
|
||||
|
|
@ -1,83 +0,0 @@
|
|||
// SPDX-FileCopyrightText: 2009-2010 pancake <pancake@nopcode.org>
|
||||
// SPDX-License-Identifier: LGPL-3.0-only
|
||||
|
||||
#include <rz_util.h>
|
||||
#include <rz_debug.h>
|
||||
#include <rz_io.h>
|
||||
#include <rz_core.h>
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
int ret, i;
|
||||
RzIODesc *fd;
|
||||
int tid, pid;
|
||||
struct rz_io_t *io;
|
||||
struct rz_debug_t *dbg = NULL;
|
||||
RzCmdStateOutput state = { 0 };
|
||||
rz_cmd_state_output_init(&state, RZ_OUTPUT_MODE_STANDARD);
|
||||
|
||||
io = rz_io_new();
|
||||
printf("Supported IO pluggins:\n");
|
||||
rz_core_io_plugins_print(io, &state);
|
||||
rz_cmd_state_output_print(&state);
|
||||
rz_cmd_state_output_fini(&state);
|
||||
|
||||
fd = rz_io_open_nomap(io, "dbg:///bin/ls", 0, 0);
|
||||
if (!fd) {
|
||||
printf("Cannot open dbg:///bin/ls\n");
|
||||
goto beach;
|
||||
}
|
||||
// rz_io_set_fd(io, ret);
|
||||
printf("rz_io_open_nomap dbg:///bin/ls' = %d\n", io->fd->fd);
|
||||
|
||||
{
|
||||
/* dump process memory */
|
||||
ut8 buf[128];
|
||||
#if __arm__
|
||||
int ret = rz_io_read_at(io, 0x8000, buf, 128);
|
||||
#else
|
||||
int ret = rz_io_read_at(io, 0x8048000, buf, 128);
|
||||
#endif
|
||||
if (ret != 128)
|
||||
eprintf("OOps cannot read 128 bytes\n");
|
||||
else
|
||||
for (i = 0; i < 128; i++) {
|
||||
printf("%02x ", buf[i]);
|
||||
if (!((i + 1) % 16))
|
||||
printf("\n");
|
||||
}
|
||||
}
|
||||
|
||||
dbg = rz_debug_new(true);
|
||||
printf("Supported debugger backends:\n");
|
||||
|
||||
ret = rz_debug_use(dbg, "native");
|
||||
printf("Using native debugger = %s\n", rz_str_bool(ret));
|
||||
|
||||
tid = pid = rz_io_system(io, "pid");
|
||||
eprintf(" My pid is : %d\n", pid);
|
||||
rz_debug_select(dbg, pid, tid);
|
||||
|
||||
// printf("--> regs pre step\n");
|
||||
// rz_io_system(io, "reg");
|
||||
|
||||
rz_debug_reg_sync(dbg, RZ_REG_TYPE_GPR, 0);
|
||||
rz_debug_reg_list(dbg, RZ_REG_TYPE_GPR, 32, NULL);
|
||||
|
||||
printf("--> perform 2 steps (only 1 probably?)\n");
|
||||
rz_debug_step(dbg, 2);
|
||||
|
||||
rz_debug_reg_sync(dbg, RZ_REG_TYPE_GPR, 0);
|
||||
rz_debug_reg_list(dbg, RZ_REG_TYPE_GPR, 32, NULL);
|
||||
|
||||
// printf("--> regs post step\n");
|
||||
// rz_io_system(io, "reg");
|
||||
|
||||
printf("---\n");
|
||||
rz_debug_continue(dbg);
|
||||
printf("---\n");
|
||||
|
||||
beach:
|
||||
rz_io_free(io);
|
||||
rz_debug_free(dbg);
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,25 +0,0 @@
|
|||
TESTS=exit1 hello loop loop2 fun fun2 fun3 fun4
|
||||
TESTS+=nest nest2 nest3
|
||||
|
||||
#ARG PASSING ERR
|
||||
TESTS+=fun5 fun6
|
||||
|
||||
#INVALID SYNTAX
|
||||
#TESTS+=looptail
|
||||
|
||||
include ../../config.mk
|
||||
|
||||
BINDEPS=rz_egg rz_asm rz_parse rz_syscall rz_db rz_util
|
||||
BIN=test
|
||||
OBJ=test.o
|
||||
|
||||
.PHONY: t tests myclean
|
||||
|
||||
include ../../rules.mk
|
||||
include ../../db/r.mk
|
||||
|
||||
t tests:
|
||||
@for TEST in ${TESTS} ; do sh t-$${TEST}.sh ; done
|
||||
|
||||
myclean:
|
||||
rm -f test${EXT_EXE} test.o
|
||||
|
|
@ -1,12 +0,0 @@
|
|||
#!/bin/sh
|
||||
EXIT=1
|
||||
OUTPUT=""
|
||||
cat > t.r <<EOF
|
||||
main@global(128) {
|
||||
: push 1
|
||||
: mov eax, 1
|
||||
: push eax
|
||||
: int 0x80
|
||||
}
|
||||
EOF
|
||||
. ./t.sh
|
||||
|
|
@ -1,22 +0,0 @@
|
|||
#!/bin/sh
|
||||
EXIT=0
|
||||
OUTPUT="loop
|
||||
loop
|
||||
loop"
|
||||
cat > t.r <<EOF
|
||||
exit@syscall(1);
|
||||
write@syscall(4);
|
||||
main();
|
||||
fun@global(128,128) {
|
||||
write (1, "loop\n", 5);
|
||||
}
|
||||
main@global(128,128) {
|
||||
.var0 = 0;
|
||||
while (.var0<2) {
|
||||
fun ("loop\n", 5);
|
||||
.var0 += 1;
|
||||
}
|
||||
exit (0);
|
||||
}
|
||||
EOF
|
||||
. ./t.sh
|
||||
|
|
@ -1,23 +0,0 @@
|
|||
#!/bin/sh
|
||||
EXIT=0
|
||||
OUTPUT="loop
|
||||
loop
|
||||
loop"
|
||||
cat > t.r <<EOF
|
||||
exit@syscall(1);
|
||||
write@syscall(4);
|
||||
main();
|
||||
// naked function for wrapping calls
|
||||
fun@global() {
|
||||
write (1, .arg0, .arg1);
|
||||
}
|
||||
main@global(128,128) {
|
||||
.var0 = 0;
|
||||
while (.var0<2) {
|
||||
fun ("loop\n", 5);
|
||||
.var0 += 1;
|
||||
}
|
||||
exit (0);
|
||||
}
|
||||
EOF
|
||||
. ./t.sh
|
||||
|
|
@ -1,24 +0,0 @@
|
|||
#!/bin/sh
|
||||
EXIT=0
|
||||
OUTPUT="loop
|
||||
loop
|
||||
loop"
|
||||
cat > t.r <<EOF
|
||||
exit@syscall(1);
|
||||
write@syscall(4);
|
||||
|
||||
main();
|
||||
|
||||
fun@(4) {
|
||||
write (1, .arg0, .arg4);
|
||||
}
|
||||
main@global(128,128) {
|
||||
.var0 = 0;
|
||||
while (.var0<2) {
|
||||
fun ("loop\n", 5);
|
||||
.var0 += 1;
|
||||
}
|
||||
exit (0);
|
||||
}
|
||||
EOF
|
||||
. ./t.sh
|
||||
|
|
@ -1,28 +0,0 @@
|
|||
#!/bin/sh
|
||||
EXIT=0
|
||||
OUTPUT="loop
|
||||
loop
|
||||
loop"
|
||||
cat > t.r <<EOF
|
||||
exit@syscall(1);
|
||||
write@syscall(4);
|
||||
|
||||
main();
|
||||
|
||||
fun2@(128) {
|
||||
write (.arg0, .arg4, .arg8);
|
||||
}
|
||||
|
||||
fun@(128) {
|
||||
fun2 (1, .arg0, .arg4);
|
||||
}
|
||||
main@global(128,128) {
|
||||
.var0 = 0;
|
||||
while (.var0<2) {
|
||||
fun ("loop\n", 5);
|
||||
.var0 += 1;
|
||||
}
|
||||
exit (0);
|
||||
}
|
||||
EOF
|
||||
. ./t.sh
|
||||
|
|
@ -1,28 +0,0 @@
|
|||
#!/bin/sh
|
||||
EXIT=0
|
||||
OUTPUT="loop
|
||||
loop
|
||||
loop"
|
||||
cat > t.r <<EOF
|
||||
exit@syscall(1);
|
||||
write@syscall(4);
|
||||
|
||||
main();
|
||||
|
||||
fun2@(1) {
|
||||
write (.arg0, .arg4, .arg8);
|
||||
}
|
||||
|
||||
fun@(1) {
|
||||
fun2 (1, .arg0, .arg4);
|
||||
}
|
||||
main@global(128,128) {
|
||||
.var0 = 0;
|
||||
while (.var0<2) {
|
||||
fun ("loop\n", 5);
|
||||
.var0 += 1;
|
||||
}
|
||||
exit (0);
|
||||
}
|
||||
EOF
|
||||
. ./t.sh
|
||||
|
|
@ -1,31 +0,0 @@
|
|||
#!/bin/sh
|
||||
EXIT=0
|
||||
OUTPUT="loop
|
||||
loop
|
||||
loop"
|
||||
cat > t.r <<EOF
|
||||
exit@syscall(1);
|
||||
write@syscall(4);
|
||||
|
||||
main();
|
||||
|
||||
fun2@(,8) {
|
||||
// XXX: we cant access args in naked functions
|
||||
// write (.arg0, .arg4, .arg8);
|
||||
write (1, "pop\n", 4);
|
||||
}
|
||||
|
||||
fun@(16) {
|
||||
fun2 (1, .arg0, .arg4);
|
||||
}
|
||||
|
||||
main@global(128,128) {
|
||||
.var0 = 0;
|
||||
while (.var0<2) {
|
||||
fun ("loop\n", 5);
|
||||
.var0 += 1;
|
||||
}
|
||||
exit (0);
|
||||
}
|
||||
EOF
|
||||
. ./t.sh
|
||||
|
|
@ -1,13 +0,0 @@
|
|||
#!/bin/sh
|
||||
EXIT=0
|
||||
OUTPUT="hello world"
|
||||
cat > t.r <<EOF
|
||||
exit@syscall(1);
|
||||
write@syscall(4);
|
||||
main@global(128,128) {
|
||||
write (1, "hello world\n", 12);
|
||||
exit (0);
|
||||
}
|
||||
EOF
|
||||
. ./t.sh
|
||||
|
||||
|
|
@ -1,19 +0,0 @@
|
|||
#!/bin/sh
|
||||
EXIT=0
|
||||
OUTPUT="loop
|
||||
loop
|
||||
loop"
|
||||
cat > t.r <<EOF
|
||||
exit@syscall(1);
|
||||
write@syscall(4);
|
||||
main@global(128,128) {
|
||||
.var0 = 3;
|
||||
while (.var0) {
|
||||
write (1, "loop\n", 5);
|
||||
.var0 -= 1;
|
||||
}
|
||||
exit (0);
|
||||
}
|
||||
EOF
|
||||
. ./t.sh
|
||||
|
||||
|
|
@ -1,18 +0,0 @@
|
|||
#!/bin/sh
|
||||
EXIT=0
|
||||
OUTPUT="loop
|
||||
loop
|
||||
loop"
|
||||
cat > t.r <<EOF
|
||||
exit@syscall(1);
|
||||
write@syscall(4);
|
||||
main@global(128,128) {
|
||||
.var0 = 0;
|
||||
while (.var0<2) {
|
||||
write (1, "loop\n", 5);
|
||||
.var0 += 1;
|
||||
}
|
||||
exit (0);
|
||||
}
|
||||
EOF
|
||||
. ./t.sh
|
||||
|
|
@ -1,19 +0,0 @@
|
|||
#!/bin/sh
|
||||
EXIT=0
|
||||
OUTPUT="loop
|
||||
loop
|
||||
loop"
|
||||
cat > t.r <<EOF
|
||||
exit@syscall(1);
|
||||
write@syscall(4);
|
||||
main@global(128,128) {
|
||||
.var0 = 3;
|
||||
{
|
||||
write (1, "loop\n", 5);
|
||||
.var0 -= 1;
|
||||
} while (.var0);
|
||||
exit (0);
|
||||
}
|
||||
EOF
|
||||
. ./t.sh
|
||||
|
||||
|
|
@ -1,30 +0,0 @@
|
|||
#!/bin/sh
|
||||
EXIT=0
|
||||
OUTPUT="one
|
||||
one
|
||||
two
|
||||
one
|
||||
one
|
||||
two"
|
||||
cat > t.r <<EOF
|
||||
exit@syscall(1);
|
||||
write@syscall(4);
|
||||
|
||||
main@global(128,128) {
|
||||
.var0 = 2;
|
||||
: polla:
|
||||
.var4 = 2;
|
||||
while (.var4) {
|
||||
write (1, "one\n", 4);
|
||||
.var4 -= 1;
|
||||
}
|
||||
write (1, "two\n", 4);
|
||||
.var0 -= 1;
|
||||
if (.var0) {
|
||||
goto(polla);
|
||||
}
|
||||
exit (0);
|
||||
}
|
||||
EOF
|
||||
. ./t.sh
|
||||
|
||||
|
|
@ -1,28 +0,0 @@
|
|||
#!/bin/sh
|
||||
EXIT=0
|
||||
OUTPUT="one
|
||||
one
|
||||
two
|
||||
one
|
||||
one
|
||||
two"
|
||||
cat > t.r <<EOF
|
||||
exit@syscall(1);
|
||||
write@syscall(4);
|
||||
|
||||
main@global(128,128) {
|
||||
.var0 = 2;
|
||||
while (.var0) {
|
||||
.var4 = 2;
|
||||
while (.var4) {
|
||||
write (1, "one\n", 4);
|
||||
.var4 -= 1;
|
||||
}
|
||||
write (1, "two\n", 4);
|
||||
.var0 -= 1;
|
||||
}
|
||||
exit (0);
|
||||
}
|
||||
EOF
|
||||
. ./t.sh
|
||||
|
||||
|
|
@ -1,41 +0,0 @@
|
|||
#!/bin/sh
|
||||
EXIT=0
|
||||
OUTPUT="zero
|
||||
zero
|
||||
one
|
||||
zero
|
||||
zero
|
||||
one
|
||||
two
|
||||
zero
|
||||
zero
|
||||
one
|
||||
zero
|
||||
zero
|
||||
one
|
||||
two"
|
||||
cat > t.r <<EOF
|
||||
exit@syscall(1);
|
||||
write@syscall(4);
|
||||
|
||||
main@global(128,128) {
|
||||
.var0 = 2;
|
||||
while (.var0) {
|
||||
.var4 = 2;
|
||||
while (.var4) {
|
||||
.var8 = 2;
|
||||
while (.var8) {
|
||||
write (1, "zero\n", 5);
|
||||
.var8 -= 1;
|
||||
}
|
||||
write (1, "one\n", 4);
|
||||
.var4 -= 1;
|
||||
}
|
||||
write (1, "two\n", 4);
|
||||
.var0 -= 1;
|
||||
}
|
||||
exit (0);
|
||||
}
|
||||
EOF
|
||||
. ./t.sh
|
||||
|
||||
|
|
@ -1,20 +0,0 @@
|
|||
#!/bin/sh
|
||||
EXIT=0
|
||||
OUTPUT="loop
|
||||
loop
|
||||
loop"
|
||||
cat > t.r <<EOF
|
||||
exit@syscall(1);
|
||||
main();
|
||||
main@global(128,128) {
|
||||
.var0 = 0;
|
||||
.var4 = &.var8;
|
||||
.var8 = "helloworld";
|
||||
while (*.var4:1) {
|
||||
.var4 += 1;
|
||||
.var0 += 1;
|
||||
}
|
||||
exit (.var0);
|
||||
}
|
||||
EOF
|
||||
. ./t.sh
|
||||
|
|
@ -1,53 +0,0 @@
|
|||
# test suite tool for r_egg #
|
||||
DEBUG=
|
||||
#DEBUG=gdb --args
|
||||
#DEBUG=valgrind
|
||||
case "$1" in
|
||||
-h)
|
||||
echo "Usage: $0 [-opt]"
|
||||
echo " -r : show source (.r)"
|
||||
echo " -s : show code (assembly)"
|
||||
echo " -b : show bytes (binary)"
|
||||
echo " -d : disassebly (code)"
|
||||
echo " -x : execute"
|
||||
echo " -t : create 't' program"
|
||||
;;
|
||||
-t)
|
||||
rz_gg -FO t.r
|
||||
exit
|
||||
;;
|
||||
-d)
|
||||
rz_asm -d `rz_gg t.r`
|
||||
;;
|
||||
-b)
|
||||
rz_gg t.r
|
||||
;;
|
||||
-r)
|
||||
cat t.r
|
||||
;;
|
||||
-x)
|
||||
rz_gg -FO t.r
|
||||
./t
|
||||
;;
|
||||
-s)
|
||||
rz_gg -s t.r > fail-t-$0.s
|
||||
cat fail-t-$0.s
|
||||
cp t fail-t-$0
|
||||
;;
|
||||
*)
|
||||
eval ${DEBUG} rz_gg -FO t.r
|
||||
rz_run '' program=./t timeout=1 > t.o
|
||||
if [ $? = "${EXIT}" -a "`cat t.o`" = "${OUTPUT}" ]; then
|
||||
out=SUCCESS
|
||||
rm -f fail-t-$0*
|
||||
else
|
||||
out=FAIL
|
||||
rz_gg -s t.r 2>&1 > fail-t-$0.s
|
||||
cp -f t fail-t-$0
|
||||
cp -f t.r fail-t-$0.r
|
||||
fi
|
||||
echo "Testing $0.. $out"
|
||||
;;
|
||||
esac
|
||||
rm -f t.r t.o
|
||||
exit 0
|
||||
|
|
@ -1,61 +0,0 @@
|
|||
// SPDX-FileCopyrightText: 2011-2012 pancake <pancake@nopcode.org>
|
||||
// SPDX-License-Identifier: LGPL-3.0-only
|
||||
|
||||
#include <rz_egg.h>
|
||||
#include <getopt.h>
|
||||
|
||||
static int usage(void) {
|
||||
eprintf("./test [-a x86|arm] [-b 32|64] hi.r\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
const char *arch = "x86";
|
||||
int bits = 32;
|
||||
int c, i;
|
||||
RzBuffer *b;
|
||||
RzEgg *egg = rz_egg_new();
|
||||
|
||||
while ((c = getopt(argc, argv, "ha:b:")) != -1) {
|
||||
switch (c) {
|
||||
case 'a':
|
||||
arch = optarg;
|
||||
break;
|
||||
case 'b':
|
||||
bits = atoi(optarg);
|
||||
break;
|
||||
case 'h':
|
||||
return usage();
|
||||
}
|
||||
}
|
||||
|
||||
if (optind == argc)
|
||||
return usage();
|
||||
|
||||
rz_egg_setup(egg, arch, bits, 0, 0);
|
||||
rz_egg_include(egg, argv[optind], 0);
|
||||
rz_egg_compile(egg);
|
||||
rz_egg_assemble(egg);
|
||||
// rz_egg_setup (egg, "x86", 32, 0, 0);
|
||||
// rz_egg_setup (egg, "x86", 64, 0, 0);
|
||||
|
||||
// printf ("src (%s)\n", rz_egg_get_source (egg));
|
||||
printf("asm (%s)\n", rz_egg_get_assembly(egg));
|
||||
b = rz_egg_get_bin(egg);
|
||||
if (b == NULL) {
|
||||
eprintf("Cannot assemble egg :(\n");
|
||||
} else {
|
||||
printf("BUFFER : %d\n", b->length);
|
||||
for (i = 0; i < b->length; i++) {
|
||||
printf("%02x", b->buf[i]);
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
#if VALA
|
||||
var egg = new RzEgg();
|
||||
egg.include("test.r", 'r');
|
||||
egg.compile();
|
||||
#endif
|
||||
rz_egg_free(egg);
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,14 +0,0 @@
|
|||
/* test calling a function */
|
||||
|
||||
call@global(128) {
|
||||
.arg0
|
||||
}
|
||||
|
||||
main@global(128) {
|
||||
#// printf ("Hello World\n");
|
||||
: nop
|
||||
: mov eax, 1
|
||||
: push eax
|
||||
: int 0x80
|
||||
call(1,2);
|
||||
}
|
||||
|
|
@ -1,7 +0,0 @@
|
|||
include ../../config.mk
|
||||
|
||||
OBJS=parse.o
|
||||
BIN=parse
|
||||
BINDEPS=rz_parse rz_util rz_flags rz_cons rz_analysis rz_reg rz_syscall rz_db
|
||||
|
||||
include ../../rules.mk
|
||||
|
|
@ -1,38 +0,0 @@
|
|||
#include "rz_parse.h"
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
char str[128];
|
||||
struct rz_parse_t *p;
|
||||
p = rz_parse_new();
|
||||
|
||||
if (argc == 1) {
|
||||
printf("List: \n");
|
||||
rz_parse_list(p);
|
||||
printf("Using plugin: \n");
|
||||
rz_parse_use(p, "x86.pseudo");
|
||||
str[0] = '\0';
|
||||
rz_parse_assemble(p, str, strdup("eax=1;int 0x80"));
|
||||
printf("--output--\n");
|
||||
printf("%s\n", str);
|
||||
printf("\n----\n\n");
|
||||
rz_parse_use(p, "att2intel");
|
||||
rz_parse_pseudocode(p, "movl $3, %eax", str); //, sizeof (str));
|
||||
// rz_parse_filter (p, NULL, "movl $3, %eax", str, sizeof (str));
|
||||
printf("%s\n", str);
|
||||
} else {
|
||||
char buf[128];
|
||||
rz_parse_use(p, "att2intel");
|
||||
while (!feof(stdin)) {
|
||||
buf[0] = 0;
|
||||
fgets(buf, sizeof(buf) - 1, stdin);
|
||||
if (feof(stdin))
|
||||
break;
|
||||
buf[strlen(buf) - 1] = 0;
|
||||
if (*buf) {
|
||||
rz_parse_pseudocode(p, buf, str); //, sizeof (str));
|
||||
printf("%s\n", str);
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,5 +0,0 @@
|
|||
OBJ=test.o
|
||||
BIN=regtest
|
||||
BINDEPS=rz_reg rz_util
|
||||
|
||||
include ../../rules.mk
|
||||
|
|
@ -1,27 +0,0 @@
|
|||
#include <sys/syscall.h>
|
||||
#include <stdio.h>
|
||||
#include <unistd.h>
|
||||
#include <sys/ptrace.h>
|
||||
#include <sys/user.h>
|
||||
|
||||
#define offsetof(TYPE, MEMBER) ((unsigned long)&((TYPE *)0)->MEMBER)
|
||||
|
||||
int main() {
|
||||
struct user_regs_struct regs;
|
||||
printf("gpr\teip .32 %d 0\n", offsetof(struct user_regs_struct, eip));
|
||||
printf("gpr\toeax .32 %d 0\n", offsetof(struct user_regs_struct, orig_eax));
|
||||
printf("gpr\teax .32 %d 0\n", offsetof(struct user_regs_struct, eax));
|
||||
printf("gpr\tebx .32 %d 0\n", offsetof(struct user_regs_struct, ebx));
|
||||
printf("gpr\tecx .32 %d 0\n", offsetof(struct user_regs_struct, ecx));
|
||||
printf("gpr\tedx .32 %d 0\n", offsetof(struct user_regs_struct, edx));
|
||||
printf("gpr\tesp .32 %d 0\n", offsetof(struct user_regs_struct, esp));
|
||||
printf("gpr\tebp .32 %d 0\n", offsetof(struct user_regs_struct, ebp));
|
||||
printf("gpr\tesi .32 %d 0\n", offsetof(struct user_regs_struct, esi));
|
||||
printf("gpr\tedi .32 %d 0\n", offsetof(struct user_regs_struct, edi));
|
||||
printf("gpr\txfs .32 %d 0\n", offsetof(struct user_regs_struct, xfs));
|
||||
printf("gpr\txgs .32 %d 0\n", offsetof(struct user_regs_struct, xgs));
|
||||
printf("gpr\txcs .32 %d 0\n", offsetof(struct user_regs_struct, xcs));
|
||||
printf("gpr\txss .32 %d 0\n", offsetof(struct user_regs_struct, xcs));
|
||||
printf("gpr\teflags .32 %d 0\n", offsetof(struct user_regs_struct, eflags));
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,85 +0,0 @@
|
|||
#include <rz_reg.h>
|
||||
#include <rz_util.h>
|
||||
#include <rz_print.h>
|
||||
|
||||
const char *reg_profile =
|
||||
"gpr eax .32 0 0\n"
|
||||
"gpr ecx .32 4 0\n"
|
||||
"gpr edx .32 8 0\n"
|
||||
"gpr ebx .32 12 0\n"
|
||||
"gpr esp .32 16 0\n"
|
||||
"gpr ebp .32 20 0\n"
|
||||
"gpr esi .32 24 0\n"
|
||||
"gpr edi .32 28 0\n"
|
||||
"gpr eip .32 32 0\n"
|
||||
"gpr eflags .32 36 0\n"
|
||||
#if 1
|
||||
"seg cs .32 40 0\n"
|
||||
"seg ss .32 44 0\n"
|
||||
"seg ds .32 48 0\n"
|
||||
"seg es .32 52 0\n"
|
||||
"seg fs .32 56 0\n"
|
||||
"seg gs .32 60 0\n"
|
||||
#endif
|
||||
#if 1
|
||||
"gpr st0 .80 64 0\n"
|
||||
"gpr st1 .80 74 0\n"
|
||||
"gpr st2 .80 84 0\n"
|
||||
"gpr st3 .80 94 0\n"
|
||||
"gpr st4 .80 104 0\n"
|
||||
"gpr st5 .80 114 0\n"
|
||||
"gpr st6 .80 124 0\n"
|
||||
"gpr st7 .80 134 0\n"
|
||||
#endif
|
||||
"gpr fctrl .32 144 0\n"
|
||||
"gpr fstat .32 148 0\n"
|
||||
"gpr ftag .32 152 0\n"
|
||||
"gpr fiseg .32 156 0\n"
|
||||
"gpr fioff .32 160 0\n"
|
||||
"gpr foseg .32 164 0\n"
|
||||
"gpr fooff .32 168 0\n"
|
||||
"gpr fop .32 172 0\n"
|
||||
#if 1
|
||||
"gpr xmm0 .128 176 0\n"
|
||||
"gpr xmm1 .128 192 0\n"
|
||||
"gpr xmm2 .128 208 0\n"
|
||||
"gpr xmm3 .128 224 0\n"
|
||||
"gpr xmm4 .128 240 0\n"
|
||||
"gpr xmm5 .128 256 0\n"
|
||||
"gpr xmm6 .128 272 0\n"
|
||||
"gpr xmm7 .128 288 0\n"
|
||||
#endif
|
||||
"gpr mxcsr .32 304 0\n";
|
||||
|
||||
static void dumpregs(RzReg *reg) {
|
||||
int sz;
|
||||
ut8 *buf = rz_reg_get_bytes(reg, RZ_REG_TYPE_GPR, &sz);
|
||||
rz_print_hexdump(NULL, 0, buf, sz, 16, 16);
|
||||
free(buf);
|
||||
}
|
||||
int main() {
|
||||
int sz, type = RZ_REG_TYPE_GPR;
|
||||
RzReg *reg = rz_reg_new();
|
||||
RzReg *reg2 = rz_reg_new();
|
||||
rz_reg_set_profile_string(reg, reg_profile);
|
||||
rz_reg_set_profile_string(reg2, reg_profile);
|
||||
rz_reg_setv(reg2, "ecx", 0xdeadbeef);
|
||||
RzRegItem *current = NULL;
|
||||
|
||||
free(rz_reg_get_bytes(reg, RZ_REG_TYPE_GPR, &sz));
|
||||
eprintf("arena: %d\n", sz);
|
||||
if (sz != 308) {
|
||||
eprintf("ARENA SIZE IS WRONG\n");
|
||||
}
|
||||
dumpregs(reg);
|
||||
dumpregs(reg2);
|
||||
for (;;) {
|
||||
current = rz_reg_next_diff(reg, type,
|
||||
reg2->regset[type].arena->bytes,
|
||||
sz, current, 32);
|
||||
if (!current)
|
||||
break;
|
||||
eprintf("Reg: <%s>\n", current->name);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,90 +0,0 @@
|
|||
#include <rz_reg.h>
|
||||
|
||||
void show_regs(struct rz_reg_t *reg, int bitsize) {
|
||||
RzList *reglist;
|
||||
RzListIter *iter;
|
||||
RzRegItem *ri;
|
||||
printf("%d bit registers:\n", bitsize);
|
||||
reglist = rz_reg_get_list(reg, bitsize == 1 ? RZ_REG_TYPE_FLG : RZ_REG_TYPE_GPR);
|
||||
rz_list_foreach (reglist, iter, ri) {
|
||||
if (ri->size == bitsize)
|
||||
printf(" - %s : 0x%08" PFMT64x "\n", ri->name, rz_reg_get_value(reg, ri));
|
||||
}
|
||||
}
|
||||
|
||||
void print_eflags_bits(RzReg *reg) {
|
||||
int a;
|
||||
a = rz_reg_getv(reg, "cf");
|
||||
printf(" c:%d", a);
|
||||
printf(" 1");
|
||||
a = rz_reg_getv(reg, "pf");
|
||||
printf(" p:%d", a);
|
||||
printf(" 0");
|
||||
a = rz_reg_getv(reg, "af");
|
||||
printf(" a:%d", a);
|
||||
printf(" 0");
|
||||
a = rz_reg_getv(reg, "zf");
|
||||
printf(" z:%d", a);
|
||||
a = rz_reg_getv(reg, "sf");
|
||||
printf(" s:%d", a);
|
||||
a = rz_reg_getv(reg, "tf");
|
||||
printf(" t:%d", a);
|
||||
a = rz_reg_getv(reg, "if");
|
||||
printf(" i:%d", a);
|
||||
a = rz_reg_getv(reg, "df");
|
||||
printf(" d:%d", a);
|
||||
a = rz_reg_getv(reg, "of");
|
||||
printf(" o:%d", a);
|
||||
printf("\n");
|
||||
}
|
||||
|
||||
int main() {
|
||||
int i;
|
||||
int foo[128];
|
||||
const char *type;
|
||||
struct rz_reg_t *reg;
|
||||
|
||||
for (i = 0; i < 128; i++)
|
||||
foo[i] = i;
|
||||
|
||||
reg = rz_reg_new();
|
||||
rz_reg_set_profile(reg, "./test.regs");
|
||||
rz_reg_read_regs(reg, (const ut8 *)foo, sizeof(foo));
|
||||
{
|
||||
ut64 a;
|
||||
RzRegItem *item;
|
||||
item = rz_reg_get(reg, "eflags", RZ_REG_TYPE_GPR);
|
||||
rz_reg_set_value(reg, item, 0x00000346); // 0xffffffffffff);
|
||||
a = rz_reg_get_value(reg, item);
|
||||
eprintf("A32 = 0x%x\n", (int)a);
|
||||
if ((int)a != -1) {
|
||||
eprintf("1 FAIL\n");
|
||||
}
|
||||
|
||||
print_eflags_bits(reg);
|
||||
item = rz_reg_get(reg, "zf", RZ_REG_TYPE_GPR);
|
||||
a = rz_reg_get_value(reg, item);
|
||||
eprintf("A = %d\n", (int)a);
|
||||
if (a != 1) {
|
||||
eprintf("2 FAIL\n");
|
||||
}
|
||||
|
||||
item = rz_reg_get(reg, "zf", RZ_REG_TYPE_GPR);
|
||||
rz_reg_set_value(reg, item, 1);
|
||||
a = rz_reg_get_value(reg, item);
|
||||
eprintf("A = %d\n", (int)a);
|
||||
if (a != 1) {
|
||||
eprintf("3 FAIL\n");
|
||||
}
|
||||
rz_reg_set_value(reg, item, 0);
|
||||
a = rz_reg_get_value(reg, item);
|
||||
eprintf("A = %d\n", (int)a);
|
||||
if (a != 0) {
|
||||
eprintf("4 FAIL\n");
|
||||
}
|
||||
}
|
||||
show_regs(reg, 1); // 32);
|
||||
|
||||
exit(0);
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,57 +0,0 @@
|
|||
=PC eip
|
||||
=SP esp
|
||||
=BP ebp
|
||||
=A0 eax
|
||||
=A1 ebx
|
||||
=A2 ecx
|
||||
=A3 edi
|
||||
=ZF zf
|
||||
=SF sf
|
||||
=OF of
|
||||
=CF cf
|
||||
gpr eip .32 128 0
|
||||
gpr ip .16 128 0
|
||||
gpr oeax .32 120 0
|
||||
gpr eax .32 80 0
|
||||
gpr ax .16 80 0
|
||||
gpr ah .8 80 0
|
||||
gpr al .8 81 0
|
||||
gpr ebx .32 40 0
|
||||
gpr bx .16 40 0
|
||||
gpr bh .8 40 0
|
||||
gpr bl .8 41 0
|
||||
gpr ecx .32 88 0
|
||||
gpr cx .16 88 0
|
||||
gpr ch .8 88 0
|
||||
gpr cl .8 89 0
|
||||
gpr edx .32 96 0
|
||||
gpr dx .16 96 0
|
||||
gpr dh .8 96 0
|
||||
gpr dl .8 97 0
|
||||
gpr esp .32 152 0
|
||||
gpr sp .16 152 0
|
||||
gpr ebp .32 32 0
|
||||
gpr bp .16 32 0
|
||||
gpr esi .32 104 0
|
||||
gpr si .16 104 0
|
||||
gpr edi .32 112 0
|
||||
gpr di .16 112 0
|
||||
seg xfs .32 200 0
|
||||
seg xgs .32 208 0
|
||||
seg xcs .32 136 0
|
||||
seg cs .16 136 0
|
||||
seg xss .32 160 0
|
||||
gpr eflags .32 144 0 c1p.a.zstido.n.rv
|
||||
gpr flags .16 144 0
|
||||
gpr cf .1 .1152 0 carry
|
||||
gpr pf .1 .1154 0 parity
|
||||
gpr af .1 .1156 0 adjust
|
||||
gpr zf .1 .1158 0 zero
|
||||
gpr sf .1 .1159 0 sign
|
||||
gpr tf .1 .1160 0 trap
|
||||
gpr if .1 .1161 0 interrupt
|
||||
gpr df .1 .1162 0 direction
|
||||
gpr of .1 .1163 0 overflow
|
||||
drx dr0 .32 0 0
|
||||
drx dr1 .32 4 0
|
||||
drx dr2 .32 8 0
|
||||
|
|
@ -1,37 +0,0 @@
|
|||
R=../rz_gg
|
||||
|
||||
all:
|
||||
${MAKE} hello
|
||||
#${MAKE} foo
|
||||
|
||||
foo:
|
||||
rz_bin -c mach0:`rz_asm -a x86.nz -f hello.s` a.out
|
||||
|
||||
bla:
|
||||
${MAKE} hello
|
||||
|
||||
hello:
|
||||
rm -f a.out
|
||||
$R -s hello.r -o hello.s
|
||||
cat hello.s
|
||||
$R -x hello.r
|
||||
$R -F -o a.out hello.r
|
||||
#-./a.out ; RET=$$? ; if [ $$RET = 0 ]; then echo It Works ; else echo Oops.. Fail ; fi
|
||||
|
||||
hi:
|
||||
rm -f a.out
|
||||
$R -s hi.r
|
||||
$R -F -o a.out hi.r
|
||||
-./a.out ; RET=$$? ; if [ $$RET = 0 ]; then echo It Works ; else echo Oops.. Fail ; fi
|
||||
|
||||
customsyscall:
|
||||
rm -f a.out
|
||||
$R -s customsyscall.r
|
||||
$R -F -o a.out customsyscall.r
|
||||
-./a.out ; RET=$$? ; if [ $$RET = 2 ]; then echo It Works ; else echo Oops.. Fail ; fi
|
||||
|
||||
exithello:
|
||||
rm -f a.out
|
||||
$R -s exithello.r
|
||||
$R -F -o a.out exithello.r
|
||||
-./a.out ; RET=$$? ; if [ $$RET = 2 ]; then echo It Works ; else echo Oops.. Fail ; fi
|
||||
|
|
@ -1,11 +0,0 @@
|
|||
/* Hello World */
|
||||
|
||||
exit@syscall(1);
|
||||
|
||||
@syscall() {
|
||||
: int3
|
||||
}
|
||||
|
||||
main@global() {
|
||||
exit(2);
|
||||
}
|
||||
|
|
@ -1,7 +0,0 @@
|
|||
/* Hello World */
|
||||
|
||||
exit@syscall(1);
|
||||
|
||||
main@global() {
|
||||
exit(2);
|
||||
}
|
||||
|
|
@ -1,15 +0,0 @@
|
|||
/* hello world in r_egg */
|
||||
write@syscall(4);
|
||||
exit@syscall(1);
|
||||
|
||||
main@global(128) {
|
||||
.var0 = 4;
|
||||
.var4 = "Hello World\n";
|
||||
.var40 = "LOL\n";
|
||||
while (.var0 > 0) {
|
||||
write (1, .var4, 12);
|
||||
// if (.var0 == 2) { write (1, .var20, 4); }
|
||||
.var0 -= 2;
|
||||
}
|
||||
exit (0);
|
||||
}
|
||||
|
|
@ -1,9 +0,0 @@
|
|||
/* hello world in r_egg */
|
||||
write@syscall(4);
|
||||
exit@syscall(1);
|
||||
|
||||
main@global(128) {
|
||||
.var0 = "hi!\n";
|
||||
write(1,.var0, 4);
|
||||
exit(0);
|
||||
}
|
||||
|
|
@ -1,8 +0,0 @@
|
|||
BINDEPS=rz_search rz_util
|
||||
|
||||
BINS=test${EXT_EXE} test-str${EXT_EXE} test-regexp${EXT_EXE}
|
||||
|
||||
include ../../rules.mk
|
||||
|
||||
myclean:
|
||||
rm -f test${EXT_EXE} test.o test-str${EXT_EXE} test-str.o test-regexp${EXT_EXE} test-regexp.o
|
||||
|
|
@ -1,21 +0,0 @@
|
|||
#include <rz_search.h>
|
||||
|
||||
static const ut8 *buffer = (const ut8 *)"ELF,e,e,e,ELF--fooo";
|
||||
|
||||
static int hit(RzSearchKeyword *kw, void *user, ut64 addr) {
|
||||
const ut8 *buf = (const ut8 *)user;
|
||||
printf("HIT %d AT %" PFMT64d " (%s)\n", kw->count, addr, buf + addr);
|
||||
return 1;
|
||||
}
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
RzSearch *rs = rz_search_new(RZ_SEARCH_REGEXP);
|
||||
rz_search_set_callback(rs, &hit, (void *)buffer);
|
||||
rz_search_kw_add(rs, /* search for /E.F/i */
|
||||
rz_search_keyword_new_str("E.F", "i", NULL, 0));
|
||||
rz_search_begin(rs);
|
||||
printf("Searching strings in '%s'\n", buffer);
|
||||
rz_search_update_i(rs, 0LL, buffer, strlen((const char *)buffer));
|
||||
rs = rz_search_free(rs);
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,22 +0,0 @@
|
|||
#include <rz_search.h>
|
||||
|
||||
const ut8 *buffer = (const ut8 *)"hellowor\x01\x02ldlibis\x01\x02niceandcoolib2loblubljb";
|
||||
|
||||
int hit(RzSearchKeyword *kw, void *user, ut64 addr) {
|
||||
const ut8 *buf = (const ut8 *)user;
|
||||
printf("HIT %d AT %" PFMT64d " (%s)\n", kw->count, addr, buf + addr);
|
||||
return 1;
|
||||
}
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
struct rz_search_t *rs;
|
||||
|
||||
rs = rz_search_new(RZ_SEARCH_STRING);
|
||||
rz_search_set_callback(rs, &hit, (void *)buffer);
|
||||
rz_search_begin(rs);
|
||||
printf("Searching strings in '%s'\n", buffer);
|
||||
rz_search_update_i(rs, 0LL, buffer, strlen((const char *)buffer));
|
||||
rs = rz_search_free(rs);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,48 +0,0 @@
|
|||
#include <rz_search.h>
|
||||
|
||||
// static char *buffer = "helloworldlibisniceandcoolib2loblubljb";
|
||||
char *buffer = "helloworldlibisnlizbiceandcoolib2loblubljb";
|
||||
|
||||
static int hit(RzSearchKeyword *kw, void *user, ut64 addr) {
|
||||
// const ut8 *buf = (ut8*)user;
|
||||
printf("HIT %d AT %" PFMT64d " (%s)\n", kw->count, addr, buffer + addr);
|
||||
return 1;
|
||||
}
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
RzSearch *rs = rz_search_new(RZ_SEARCH_KEYWORD);
|
||||
rz_search_kw_add(rs,
|
||||
rz_search_keyword_new_str("lib", "", NULL, 0));
|
||||
rz_search_set_callback(rs, &hit, buffer);
|
||||
rz_search_set_distance(rs, 0);
|
||||
printf("Distance: %d\n", rs->distance);
|
||||
rz_search_begin(rs);
|
||||
printf("Searching for '%s' in '%s'\n", "lib", buffer);
|
||||
rz_search_update_i(rs, 0LL, (ut8 *)buffer, strlen(buffer));
|
||||
|
||||
printf("--\n");
|
||||
|
||||
rz_search_set_distance(rs, 4);
|
||||
printf("Distance: %d\n", rs->distance);
|
||||
rz_search_begin(rs);
|
||||
printf("Searching for '%s' in '%s'\n", "lib", buffer);
|
||||
rz_search_update_i(rs, 0LL, (ut8 *)buffer, strlen(buffer));
|
||||
rs = rz_search_free(rs);
|
||||
|
||||
printf("--\n");
|
||||
|
||||
/* test binmask */
|
||||
rs = rz_search_new(RZ_SEARCH_KEYWORD);
|
||||
{
|
||||
RzSearchKeyword *kw = rz_search_keyword_new_str("lib", "ff00ff", NULL, 0);
|
||||
printf("Keyword (%02x %02x %02x)\n", kw->bin_binmask[0],
|
||||
kw->bin_binmask[1], kw->bin_binmask[2]);
|
||||
rz_search_kw_add(rs, kw);
|
||||
}
|
||||
rz_search_set_callback(rs, &hit, buffer);
|
||||
rz_search_begin(rs);
|
||||
printf("Searching for '%s' with binmask 'ff00ff' in '%s'\n", "lib", buffer);
|
||||
rz_search_update_i(rs, 0LL, (ut8 *)buffer, strlen(buffer));
|
||||
rs = rz_search_free(rs);
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,5 +0,0 @@
|
|||
OBJ=serverssl.o
|
||||
BIN=serverssl
|
||||
BINDEPS=rz_socket
|
||||
|
||||
include ../../rules.mk
|
||||
|
|
@ -1,14 +0,0 @@
|
|||
#include <rz_socket.h>
|
||||
|
||||
int main() {
|
||||
int ret;
|
||||
char buf[1024];
|
||||
RzSocket *s = rz_socket_new(false);
|
||||
if (rz_socket_connect(s, "localhost", "9090", 0, 10)) {
|
||||
do {
|
||||
ret = rz_socket_gets(s, buf, sizeof(buf));
|
||||
eprintf("((%s))\n", buf);
|
||||
} while (ret >= 0);
|
||||
}
|
||||
rz_socket_free(s);
|
||||
}
|
||||
|
|
@ -1,31 +0,0 @@
|
|||
#include <rz_socket.h>
|
||||
#define MAX_LINE 2048
|
||||
#define PORT "4433"
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
char buf[MAX_LINE + 1];
|
||||
RzSocket *s, *cli;
|
||||
|
||||
if (argc < 2) {
|
||||
eprintf("Use %s <cert>\n", argv[0]);
|
||||
return 1;
|
||||
}
|
||||
s = rz_socket_new(true);
|
||||
if (!rz_socket_listen(s, PORT, argv[1])) {
|
||||
eprintf("Error, cant listen at port: %s\n", PORT);
|
||||
return 1;
|
||||
}
|
||||
while (1) {
|
||||
if (!(cli = rz_socket_accept(s)))
|
||||
break;
|
||||
rz_socket_read(cli, (unsigned char *)buf, 9);
|
||||
strcpy(buf, "HTTP/1.0 200 OK\r\n"
|
||||
"Server: EKRServer\r\n\r\n"
|
||||
"Server test page\r\n");
|
||||
rz_socket_write(cli, buf, strlen(buf));
|
||||
rz_socket_flush(cli);
|
||||
rz_socket_free(cli);
|
||||
}
|
||||
rz_socket_free(s);
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,27 +0,0 @@
|
|||
#include <rz_socket.h>
|
||||
|
||||
int main() {
|
||||
int ret;
|
||||
struct rz_socket_proc_t *sp;
|
||||
char buf[256];
|
||||
char *const args[4] = { "/usr/bin/telnet", "localhost", "9999", 0 };
|
||||
|
||||
sp = rz_socket_proc_open(args);
|
||||
// ret = rz_socket_proc_read(sp, buf, 128);
|
||||
rz_socket_proc_printf(sp, "GET / HTTP/1.1\r\n\r\n");
|
||||
printf("Waiting...\n");
|
||||
for (;;) {
|
||||
if (!rz_socket_proc_ready(sp, 0, 0))
|
||||
break;
|
||||
ret = rz_socket_proc_gets(sp, buf, 128);
|
||||
printf("RET=%d\n", ret);
|
||||
if (ret < 0)
|
||||
break;
|
||||
else if (ret > 0)
|
||||
printf("%d=\"%s\"\n", ret, buf);
|
||||
else
|
||||
printf("--\n");
|
||||
}
|
||||
rz_socket_proc_close(sp);
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,24 +0,0 @@
|
|||
#include <rz_socket.h>
|
||||
|
||||
int main() {
|
||||
int ret;
|
||||
struct rz_socket_proc_t *sp;
|
||||
char buf[256];
|
||||
char *const args[3] = { "/bin/ls", "-l", 0 };
|
||||
|
||||
sp = rz_socket_proc_open(args);
|
||||
|
||||
for (;;) {
|
||||
if (rz_socket_proc_ready(sp, 0, 0) < 0)
|
||||
break;
|
||||
ret = rz_socket_proc_gets(sp, buf, 128);
|
||||
if (ret > 0)
|
||||
printf("%d=\"%s\"\n", ret, buf);
|
||||
else {
|
||||
printf("%d=\n", ret);
|
||||
break;
|
||||
}
|
||||
}
|
||||
rz_socket_proc_close(sp);
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,25 +0,0 @@
|
|||
#include <rz_socket.h>
|
||||
#define MAX_LINE 2048
|
||||
//#define SERVER "www.openssl.org"
|
||||
#define PORT "4433"
|
||||
#define SERVER "127.0.0.1"
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
ut8 buf[MAX_LINE + 1];
|
||||
|
||||
memset(buf, 0, MAX_LINE + 1);
|
||||
RzSocket *s = rz_socket_new(true);
|
||||
if (s == NULL) {
|
||||
fprintf(stderr, "Error, cannot create new socket \n");
|
||||
return 1;
|
||||
}
|
||||
if (!rz_socket_connect_tcp(s, SERVER, PORT)) {
|
||||
fprintf(stderr, "Error, cannot connect to " SERVER "\n");
|
||||
return 1;
|
||||
}
|
||||
printf("%i\n", rz_socket_puts(s, "GET /\r\n\r\n"));
|
||||
while (rz_socket_read(s, buf, MAX_LINE) > 0)
|
||||
printf("%s", buf);
|
||||
rz_socket_free(s);
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,6 +0,0 @@
|
|||
OBJ=hello.o
|
||||
BIN=hello
|
||||
BINDEPS=rz_syscall rz_db rz_util
|
||||
|
||||
include ../../rules.mk
|
||||
include ../../db/r.mk
|
||||
|
|
@ -1,21 +0,0 @@
|
|||
#include <stdio.h>
|
||||
#include "rz_syscall.h"
|
||||
|
||||
int main() {
|
||||
int i, num = 3;
|
||||
RzSyscall *ctx = rz_syscall_new();
|
||||
rz_syscall_setup(ctx, "x86", "linux", 32);
|
||||
|
||||
printf("4 = %s\n", rz_syscall_get_i(ctx, 4, -1));
|
||||
printf("write = %d\n", rz_syscall_get_num(ctx, "write"));
|
||||
|
||||
// if args = 0 { no args }
|
||||
for (i = 1; i <= num; i++) {
|
||||
const char *arg = rz_syscall_reg(ctx, i, num);
|
||||
printf("%d %d: %s\n", i, num, arg);
|
||||
}
|
||||
|
||||
rz_syscall_free(ctx);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,51 +0,0 @@
|
|||
#!/usr/bin/env python
|
||||
# Auto-generate rizin syscall profile for OpenBSD from syscall.h
|
||||
# (c) Edd Barrett 2011
|
||||
|
||||
import copy
|
||||
import sys
|
||||
|
||||
with open("/usr/include/sys/syscall.h", "r", encoding="utf8") as f:
|
||||
rec = {"name": None, "args": None}
|
||||
recs = {}
|
||||
|
||||
for line in f:
|
||||
if line.startswith("/* syscall:"):
|
||||
# extract syscall name
|
||||
openq = line.find('"')
|
||||
closeq = line.find('"', openq + 1)
|
||||
rec["name"] = line[openq + 1 : closeq]
|
||||
|
||||
# extract number of args
|
||||
args = line.find("args:")
|
||||
args = args + len("args: ")
|
||||
rec["args"] = line[args:].count('"') / 2
|
||||
elif line.startswith("#define"):
|
||||
|
||||
if "SYS_MAXSYSCALL" in line:
|
||||
continue
|
||||
|
||||
# extract syscall number
|
||||
sp = line.split("\t")
|
||||
callnum = sp[2].rstrip()
|
||||
|
||||
# check required info is there
|
||||
for i in rec:
|
||||
if i is None:
|
||||
print("missing info for %s" % str(rec))
|
||||
sys.exit(1)
|
||||
|
||||
recs[int(callnum)] = copy.copy(rec)
|
||||
rec = {"name": None, "args": None}
|
||||
with open("openbsd.c", "w", encoding="utf8") as out:
|
||||
out.write('#include "r_syscall.h"\n\n/* syscall-openbsd */\n')
|
||||
out.write("RSyscallItem syscalls_openbsd_x86[] = {\n")
|
||||
|
||||
keys = recs.keys()
|
||||
for call in keys:
|
||||
out.write(
|
||||
' { "%s", 0x80, %d, %d },\n'
|
||||
% (recs[call]["name"], call, recs[call]["args"])
|
||||
)
|
||||
|
||||
out.write("};\n")
|
||||
|
|
@ -1,30 +0,0 @@
|
|||
include ../../config.mk
|
||||
|
||||
BINDEPS=rz_util
|
||||
|
||||
LDFLAGS+=-lrz_util -L..
|
||||
|
||||
BINS=sparse
|
||||
BINS+=array
|
||||
BINS+=pool
|
||||
BINS+=argv
|
||||
BINS+=test_sys
|
||||
BINS+=test_str
|
||||
BINS+=test_file_slurp_hexpairs
|
||||
BINS+=test_cmd_str
|
||||
BINS+=test_tree
|
||||
BINS+=test_graph
|
||||
|
||||
all: ${BINS}
|
||||
|
||||
${BINS}: $(addsuffix .o,$(BINS))
|
||||
$(CC) $(LDFLAGS) -o $@ $@.o
|
||||
|
||||
myclean:
|
||||
rm -f ${BINS} *.o
|
||||
|
||||
clean:: myclean
|
||||
|
||||
.PHONY: myclean clean all
|
||||
|
||||
include ../../rules.mk
|
||||
|
|
@ -1,24 +0,0 @@
|
|||
#include <rz_util.h>
|
||||
|
||||
static void test(const char *str) {
|
||||
int i, argc;
|
||||
char **argv = rz_str_argv(str, &argc);
|
||||
printf("[%s]\n", str);
|
||||
for (i = 0; i < argc; i++)
|
||||
printf(" - %s\n", argv[i]);
|
||||
rz_str_argv_free(argv);
|
||||
}
|
||||
|
||||
int main() {
|
||||
char buf[256];
|
||||
int len = rz_str_bits(buf, (const ut8 *)"012345", 7 * 8, NULL);
|
||||
printf("%d: %s\n", len, buf);
|
||||
|
||||
test(" hello world ");
|
||||
test("hello world");
|
||||
test("hello \"world\"");
|
||||
test("'hello world'");
|
||||
test("/bin/ls -l 'food is pure bar' \"barra cow is low\"");
|
||||
test("'hello' \"world\"");
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,67 +0,0 @@
|
|||
#include "../big.c"
|
||||
/*
|
||||
#include "../big-ssl.c"
|
||||
#include "../big-gmp.c"
|
||||
*/
|
||||
|
||||
void main() {
|
||||
int a, b;
|
||||
RzNumBig n1, n2, n3, zero;
|
||||
|
||||
rz_big_set_st(&n2, -2);
|
||||
rz_big_set_str(&n3, "-3");
|
||||
// rz_big_set_st (&n3, -3);
|
||||
printf("n3last = %d\n", n3.last);
|
||||
printf("%d %d\n", n3.dgts[0], n3.dgts[1]);
|
||||
rz_big_mul(&n2, &n2, &n3);
|
||||
rz_big_print(&n2);
|
||||
printf("--\n");
|
||||
|
||||
rz_big_set_st(&n1, 2);
|
||||
rz_big_set_st(&n2, 3);
|
||||
rz_big_mul(&n1, &n1, &n2);
|
||||
rz_big_print(&n1);
|
||||
|
||||
rz_big_set_st(&n3, 923459999);
|
||||
rz_big_mul(&n1, &n2, &n3);
|
||||
rz_big_mul(&n2, &n1, &n3);
|
||||
rz_big_mul(&n1, &n2, &n3);
|
||||
rz_big_print(&n1);
|
||||
|
||||
rz_big_set_st64(&n2, 9999923459999999);
|
||||
rz_big_set_st64(&n3, 9999992345999999);
|
||||
rz_big_mul(&n1, &n2, &n3);
|
||||
rz_big_mul(&n2, &n1, &n3);
|
||||
rz_big_mul(&n1, &n2, &n3);
|
||||
rz_big_print(&n1);
|
||||
|
||||
while (scanf("%d %d\n", &a, &b) != EOF) {
|
||||
printf("a = %d b = %d\n", a, b);
|
||||
rz_big_set_st(&n1, a);
|
||||
rz_big_set_st(&n2, b);
|
||||
|
||||
rz_big_add(&n3, &n1, &n2);
|
||||
printf("addition -- ");
|
||||
rz_big_print(&n3);
|
||||
|
||||
printf("rz_big_cmp a ? b = %d\n", rz_big_cmp(&n1, &n2));
|
||||
|
||||
rz_big_sub(&n3, &n1, &n2);
|
||||
printf("subtraction -- ");
|
||||
rz_big_print(&n3);
|
||||
|
||||
rz_big_mul(&n3, &n1, &n2);
|
||||
printf("multiplication -- ");
|
||||
rz_big_print(&n3);
|
||||
|
||||
rz_big_set_st(&zero, 0);
|
||||
if (rz_big_cmp(&zero, &n2) == 0)
|
||||
printf("division -- NaN \n");
|
||||
else {
|
||||
rz_big_div(&n3, &n1, &n2);
|
||||
printf("division -- ");
|
||||
rz_big_print(&n3);
|
||||
}
|
||||
printf("--------------------------\n");
|
||||
}
|
||||
}
|
||||
|
|
@ -1,12 +0,0 @@
|
|||
#include <rz_util.h>
|
||||
|
||||
#define F "/etc/services"
|
||||
|
||||
int main() {
|
||||
size_t len;
|
||||
char *out = rz_file_slurp(F, &len);
|
||||
rz_file_dump("a", out, (int)len);
|
||||
system("md5 " F);
|
||||
system("md5 a");
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,5 +0,0 @@
|
|||
BINDEPS=rz_util
|
||||
BIN=test
|
||||
OBJ=test.o
|
||||
|
||||
include ../../rules.mk
|
||||
|
|
@ -1,5 +0,0 @@
|
|||
virum bonum quom laudabant, ita laudabant:
|
||||
bonum agricolam bonumque colonum;
|
||||
amplissime laudari existimabatur qui ita laudabatur.
|
||||
mercatorem autem strenuum studiosumque rei quaerendae existimo,
|
||||
verum, ut supra dixi, periculosum et calamitosum
|
||||
|
|
@ -1,4 +0,0 @@
|
|||
virum bonum quom laudabant, ita laudabant:
|
||||
bonum agricolam bonumque magisterum.
|
||||
mercatorem autem strenuum studiosumque rei quaerendae existimo,
|
||||
verum, ut supra dixi, periculosum et calamitosum
|
||||
|
|
@ -1,102 +0,0 @@
|
|||
#include <rz_diff.h>
|
||||
|
||||
int cb(struct rz_diff_t *d, void *user, struct rz_diff_op_t *op) {
|
||||
int i;
|
||||
|
||||
printf(" 0x%08" PFMT64x " ", op->a_off);
|
||||
for (i = 0; i < op->a_len; i++)
|
||||
printf("%02x", op->a_buf[i]);
|
||||
printf(" => ");
|
||||
for (i = 0; i < op->b_len; i++)
|
||||
printf("%02x", op->b_buf[i]);
|
||||
printf(" 0x%08" PFMT64x "\n", op->b_off);
|
||||
return 1;
|
||||
}
|
||||
|
||||
int test_equal() {
|
||||
struct rz_diff_t *d;
|
||||
char *bufa = "helloworld";
|
||||
char *bufb = "heprswarld";
|
||||
|
||||
printf("Diffing '%s' vs '%s'\n", bufa, bufb);
|
||||
d = rz_diff_new(0, 0);
|
||||
rz_diff_set_delta(d, 0);
|
||||
rz_diff_set_callback(d, &cb, NULL);
|
||||
rz_diff_buffers(d, (ut8 *)bufa, strlen(bufa), (ut8 *)bufb, strlen((char *)bufb));
|
||||
return 1;
|
||||
}
|
||||
|
||||
int test_diff() {
|
||||
struct rz_diff_t *d;
|
||||
char *bufa = "hello";
|
||||
char *bufb = "hellpworld";
|
||||
|
||||
printf("Truncated diffing '%s' vs '%s'\n", bufa, bufb);
|
||||
d = rz_diff_new(0, 0);
|
||||
rz_diff_set_delta(d, 0);
|
||||
rz_diff_set_callback(d, &cb, NULL);
|
||||
rz_diff_buffers(d, (ut8 *)bufa, strlen(bufa), (ut8 *)bufb, strlen(bufb));
|
||||
return 1;
|
||||
}
|
||||
|
||||
int test_delta() {
|
||||
struct rz_diff_t *d;
|
||||
char *bufa = "hello";
|
||||
char *bufb = "heprpworld";
|
||||
|
||||
printf("Delta diffing '%s' vs '%s'\n", bufa, bufb);
|
||||
d = rz_diff_new(0, 0);
|
||||
rz_diff_set_delta(d, 1);
|
||||
rz_diff_set_callback(d, &cb, NULL);
|
||||
rz_diff_buffers(d, (ut8 *)bufa, strlen(bufa), (ut8 *)bufb, strlen(bufb));
|
||||
return 1;
|
||||
}
|
||||
|
||||
int test_distance() {
|
||||
char *bufa = "hello";
|
||||
char *bufb = "heprpworld";
|
||||
ut32 distance = 0;
|
||||
double similarity = 0;
|
||||
|
||||
printf("Similarity: '%s' vs '%s'\n", bufa, bufb);
|
||||
rz_diff_buffers_distance(NULL, (ut8 *)bufa, strlen(bufa), (ut8 *)bufb, strlen(bufb),
|
||||
&distance, &similarity);
|
||||
printf("Levenshtein distance = %i\nSimilarity = %f\n",
|
||||
distance, similarity);
|
||||
return 1;
|
||||
}
|
||||
|
||||
#if 0
|
||||
int test_lines(char *file1, char *file2)
|
||||
{
|
||||
int ret;
|
||||
char *b1, *b2;
|
||||
int s1, s2;
|
||||
|
||||
b1 = rz_file_slurp(file1, &s1);
|
||||
b2 = rz_file_slurp(file2, &s2);
|
||||
if (b1==NULL || b2 == NULL) {
|
||||
eprintf ("Cannot open %s or %s\n", file1, file2);
|
||||
return 0;
|
||||
}
|
||||
ret = rz_diff_lines(file1, b1, s1, file2, b2, s2);
|
||||
printf("Differences: %d\n", ret);
|
||||
return ret;
|
||||
}
|
||||
#endif
|
||||
|
||||
int main() {
|
||||
test_equal();
|
||||
printf("--\n");
|
||||
test_equal();
|
||||
printf("--\n");
|
||||
test_diff();
|
||||
printf("--\n");
|
||||
test_delta();
|
||||
printf("--\n");
|
||||
test_distance();
|
||||
printf("--\n");
|
||||
// test_lines("file1", "file2");
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,12 +0,0 @@
|
|||
7f45 4c46 0101 0100 0000 0000 0000 0000 #.ELF............
|
||||
0200 0300 0100 0000 d09c 0408 3400 0000 #............4...
|
||||
7c93 0100 0000 0000 3400 2000 0a00 2800 #|.......4. ...(.
|
||||
1b00 1a00 0600 0000 3400 0000 3480 0408 #........4...4...
|
||||
3480 0408 4001 0000 4001 0000 0500 0000 #4...@...@.......
|
||||
0400 0000 0300 0000 7401 0000 7481 0408 #........t...t...
|
||||
7481 0408 1300 0000 1300 0000 0400 0000 #t...............
|
||||
0100 0000 0100 0000 0000 0000 0080 0408 #................
|
||||
0080 0408 1c82 0100 1c82 0100 0500 0000 #................
|
||||
0010 0000 0100 0000 f88e 0100 f81e 0608 #................
|
||||
f81e 0608 b403 0000 e80f 0000 0600 0080 #................
|
||||
|
||||
|
|
@ -1,16 +0,0 @@
|
|||
#include <rz_util.h>
|
||||
|
||||
const char *buf[] = { "eax", "ebx", "ecx", NULL };
|
||||
|
||||
int main() {
|
||||
struct rz_mem_pool_t *pool = rz_mem_pool_new(128, 0, 0);
|
||||
void *foo = rz_mem_pool_alloc(pool);
|
||||
eprintf("foo1 = %p\n", foo);
|
||||
foo = rz_mem_pool_alloc(pool);
|
||||
eprintf("foo1 = %p\n", foo);
|
||||
|
||||
printf("%d\n", rz_mem_count((const ut8 **)buf));
|
||||
|
||||
rz_mem_pool_free(pool);
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,8 +0,0 @@
|
|||
#include <rz_util.h>
|
||||
|
||||
int main() {
|
||||
int out;
|
||||
printf("%s\n", rz_sys_cmd_str("less", "hello world\nhow are you\n", &out));
|
||||
printf("out=%d\n", out);
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,15 +0,0 @@
|
|||
#include <stdio.h>
|
||||
#include <rz_util.h>
|
||||
|
||||
int main(int argc, char *argv[]) {
|
||||
int i, size;
|
||||
ut8 *ret = rz_file_slurp_hexpairs("hexpairs.txt", &size);
|
||||
|
||||
if (ret) {
|
||||
for (i = 0; i < size; i++)
|
||||
putchar(ret[i]);
|
||||
} else
|
||||
printf("Error processing the file.\n");
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,147 +0,0 @@
|
|||
#include <stdio.h>
|
||||
#include "rz_util.h"
|
||||
|
||||
void check(const char *exp, const char *act, const char *desc) {
|
||||
if (strcmp(exp, act) == 0)
|
||||
printf("\x1b[34m[+][%s]\x1b[39;49m test passed\n", desc);
|
||||
else
|
||||
printf("\x1b[31m[-][%s]\x1b[39;49m test failed (actual = %s\x1b[39;49m, expected = %s\x1b[39;49m)\n", desc, act, exp);
|
||||
}
|
||||
|
||||
void check_n(const char *exp, const char *act, int len, const char *desc) {
|
||||
if (strncmp(exp, act, len) == 0)
|
||||
printf("\x1b[34m[+][%s]\x1b[39;49m test passed\n", desc);
|
||||
else
|
||||
printf("\x1b[31m[-][%s]\x1b[39;49m test failed (actual = %s\x1b[39;49m, expected = %s\x1b[39;49m)\n", desc, act, exp);
|
||||
}
|
||||
|
||||
void check_int(int exp, int act, const char *desc) {
|
||||
if (exp == act)
|
||||
printf("\x1b[34m[+][%s]\x1b[39;49m test passed\n", desc);
|
||||
else
|
||||
printf("\x1b[31m[-][%s]\x1b[39;49m test failed (actual = %d\x1b[39;49m, expected = %d\x1b[39;49m)\n", desc, act, exp);
|
||||
}
|
||||
|
||||
void check_array(int *exp, int *act, int len, const char *desc) {
|
||||
int i, err_found = 0;
|
||||
for (i = 0; i < len; i++) {
|
||||
if (exp[i] != act[i]) {
|
||||
printf("\x1b[31m[-][%s]\x1b[39;49m test failed element %d (actual = %d\x1b[39;49m, expected = %d\x1b[39;49m)\n", desc, i, act[i], exp[i]);
|
||||
err_found = 1;
|
||||
}
|
||||
}
|
||||
if (!err_found)
|
||||
printf("\x1b[34m[+][%s]\x1b[39;49m test passed\n", desc);
|
||||
else
|
||||
printf("\x1b[31m[-][%s]\x1b[39;49m test failed\n", desc);
|
||||
}
|
||||
|
||||
int main(int argc, char *argv[]) {
|
||||
char head[] = " a";
|
||||
char tail[] = "a ";
|
||||
char head_tail[] = " a ";
|
||||
|
||||
check("a", rz_str_trim_head(head), "trim head \" a\"");
|
||||
check("a", rz_str_trim_tail(tail), "trim tail \"a \"");
|
||||
check("a", rz_str_trim(head_tail), "trim head tail \" a \"");
|
||||
|
||||
char *crop =
|
||||
"This is the first line\n"
|
||||
"This is the second\n"
|
||||
"\n"
|
||||
"And this is the last\n";
|
||||
char *crop_exp =
|
||||
"is is the se\n"
|
||||
"\n"
|
||||
"d this is th\n";
|
||||
check(crop_exp, rz_str_crop(crop, 2, 1, 14, 10), "crop text");
|
||||
check("", rz_str_crop(NULL, 2, 1, 14, 10), "crop NULL");
|
||||
|
||||
char dst[256];
|
||||
char src[] = "This is my text";
|
||||
rz_str_ncpy(dst, src, 4);
|
||||
check("This", dst, "rz_str_ncpy");
|
||||
dst[0] = '\0';
|
||||
rz_str_ncpy(dst, src, 100);
|
||||
check("This is my text", dst, "rz_str_ncpy (n > src length)");
|
||||
|
||||
strcpy(dst, "This is a $mess < fin.txt");
|
||||
rz_str_sanitize(dst);
|
||||
check("This is a _hell _ fin.txt", dst, "rz_str_sanitize");
|
||||
|
||||
strcpy(dst, "\x1b[30mHel\x1b[28mlo");
|
||||
check("lo", rz_str_ansi_chrn(dst, 4), "rz_str_ansi_chrn");
|
||||
|
||||
check_int(5, rz_str_ansi_len(dst), "rz_str_ansi_len 1");
|
||||
strcpy(dst, "Hello");
|
||||
check_int(5, rz_str_ansi_len(dst), "rz_str_ansi_len 2");
|
||||
strcpy(dst, "\x1b[30m");
|
||||
check_int(0, rz_str_ansi_len(dst), "rz_str_ansi_len 3");
|
||||
|
||||
strcpy(dst, "Hello");
|
||||
check_int(5, rz_str_ansi_chop(dst, -1, 5), "rz_str_ansi_chop (normal string)");
|
||||
check("Hello", dst, "rz_str_ansi_chop (normal string)(str)");
|
||||
strcpy(dst, "Hello");
|
||||
check_int(2, rz_str_ansi_chop(dst, -1, 2), "rz_str_ansi_chop 2 (normal string)");
|
||||
check("He", dst, "rz_str_ansi_chop 2 (normal string)(str)");
|
||||
strcpy(dst, "Hello");
|
||||
check_int(0, rz_str_ansi_chop(dst, -1, 0), "rz_str_ansi_chop 3 (normal string)");
|
||||
check("", dst, "rz_str_ansi_chop 3 (normal string)(str)");
|
||||
|
||||
strcpy(dst, "\x1b[30mHel\x1b[29mlo");
|
||||
check_int(0, rz_str_ansi_chop(dst, -1, 0), "rz_str_ansi_chop 1");
|
||||
check("", dst, "rz_str_ansi_chop 1 (str)");
|
||||
strcpy(dst, "\x1b[30mHel\x1b[29mlo");
|
||||
check_int(7, rz_str_ansi_chop(dst, -1, 2), "rz_str_ansi_chop 2");
|
||||
check("\x1b[30mHe", dst, "rz_str_ansi_chop 2 (str)");
|
||||
strcpy(dst, "\x1b[30mHel\x1b[29mlo");
|
||||
check_int(8, rz_str_ansi_chop(dst, -1, 3), "rz_str_ansi_chop 3");
|
||||
check("\x1b[30mHel", dst, "rz_str_ansi_chop 3 (str)");
|
||||
|
||||
char *orig;
|
||||
int *cpos;
|
||||
strcpy(dst, "Hello");
|
||||
check_int(5, rz_str_ansi_filter(dst, NULL, NULL, -1), "rz_str_ansi_filter (normal string)");
|
||||
check("Hello", dst, "rz_str_ansi_filter (normal string(str)");
|
||||
strcpy(dst, "\x1b[30mHel\x1b[29mlo\x1b[28m");
|
||||
check_int(5, rz_str_ansi_filter(dst, NULL, NULL, -1), "rz_str_ansi_filter");
|
||||
check("Hello", dst, "rz_str_ansi_filter (str)");
|
||||
strcpy(dst, "\x1b[30mHel\x1b[29mlo\x1b[28m");
|
||||
check_int(3, rz_str_ansi_filter(dst, NULL, NULL, 8), "rz_str_ansi_filter (length)");
|
||||
check_n("Hel", dst, 3, "rz_str_ansi_filter (length)(str)");
|
||||
strcpy(dst, "\x1b[30mHel\x1b[29mlo\x1b[28m");
|
||||
rz_str_ansi_filter(dst, &orig, NULL, -1);
|
||||
check("\x1b[30mHel\x1b[29mlo\x1b[28m", orig, "rz_str_ansi_filter out orig");
|
||||
strcpy(dst, "\x1b[30mHel\x1b[29mlo\x1b[28m");
|
||||
int res = rz_str_ansi_filter(dst, NULL, &cpos, -1);
|
||||
check_int(5, res, "rz_str_ansi_filter res");
|
||||
int exp_cpos[] = { 5, 6, 7, 13, 14 };
|
||||
check_array(exp_cpos, cpos, res, "rz_str_ansi_filter cpos");
|
||||
|
||||
char clean[256];
|
||||
char *str = malloc(256);
|
||||
strcpy(str, "\x1b[30mHell\x1b[32mo\nIt'\x1b[33ms a test\n");
|
||||
strcpy(clean, "Hello\nIt's a test\n");
|
||||
int thunk[] = { 5, 6, 7, 8, 14, 15, 16, 17, 18, 24, 25, 26, 27, 28, 29, 30, 31, 32 };
|
||||
char *res_s = rz_str_replace_thunked(str, clean, thunk, 18, "est", "\x1b[31mest\x1b[39;49m", 1);
|
||||
check("\x1b[30mHell\x1b[32mo\nIt'\x1b[33ms a t\x1b[31mest\x1b[39;49m\n", res_s, "rz_str_replace_thunked");
|
||||
|
||||
int l;
|
||||
strcpy(str, "\x1b[30mMess\x1b[32mo\nIt'\x1b[33ms a mess\n");
|
||||
l = rz_str_ansi_filter(str, &orig, &cpos, 0);
|
||||
res_s = rz_str_replace_thunked(orig, str, cpos, l, "ell", "\x1b[31mell\x1b[39;49m", 1);
|
||||
check("\x1b[30mH\x1b[31mell\x1b[39;49mo\nIt'\x1b[33ms an h\x1b[31mell\x1b[39;49m\n", res_s, "rz_str_ansi_filter + replace_thunked");
|
||||
|
||||
crop =
|
||||
"\x1b[30mThis is the \x1b[34mfirst line\n"
|
||||
"\x1b[32mThis \x1b[31mis the\x1b[39;49m second\n"
|
||||
"\n"
|
||||
"And this is the \x1b[32mlast\n";
|
||||
crop_exp =
|
||||
"\x1b[30m\x1b[34m\x1b[32mis \x1b[31mis the\x1b[39;49m se\n"
|
||||
"\n"
|
||||
"d this is th\n";
|
||||
check(crop_exp, rz_str_ansi_crop(crop, 2, 1, 14, 10), "rz_str_ansi_crop");
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,16 +0,0 @@
|
|||
#include <stdio.h>
|
||||
#include "rz_util.h"
|
||||
|
||||
int main(int argc, char *argv[]) {
|
||||
int len = 0;
|
||||
char *sterr;
|
||||
char *output = rz_sys_cmd_str("find /etc", 0, &len);
|
||||
int result = rz_sys_cmd_str_full("find /etc", 0, &output, &len, &sterr);
|
||||
printf("RESULT: %d\n", result);
|
||||
printf("STDOUT\n");
|
||||
printf("%s", output);
|
||||
printf("STDERR\n");
|
||||
printf("%s", sterr);
|
||||
printf("bytes in STDOUT: %d\n", len);
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,53 +0,0 @@
|
|||
#include <rz_th.h>
|
||||
#include <rz_util.h>
|
||||
|
||||
int looper(struct rz_th_t *th) {
|
||||
int i;
|
||||
int *ctr = th->user;
|
||||
for (i = 0; i < 9999; i++) {
|
||||
if (th->breaked)
|
||||
break;
|
||||
(*ctr)++;
|
||||
printf("%d loop %d\r", i, *ctr);
|
||||
fflush(stdout);
|
||||
#if __UNIX__
|
||||
sleep(1);
|
||||
#endif
|
||||
}
|
||||
return 0; // do not loop
|
||||
}
|
||||
|
||||
int test1() {
|
||||
int ctr = 0;
|
||||
struct rz_th_t *th;
|
||||
|
||||
th = rz_th_new(&looper, &ctr, 0);
|
||||
th = rz_th_new(&looper, &ctr, 0);
|
||||
// th = rz_th_new (&looper, &ctr, 0);
|
||||
|
||||
#if __i386__ || __x86_64__
|
||||
asm("int3");
|
||||
#endif
|
||||
// rz_th_start (th, true);
|
||||
while (rz_th_wait_async(th)) {
|
||||
printf("\nwaiting...\n");
|
||||
fflush(stdout);
|
||||
rz_sys_usleep(400);
|
||||
// rz_th_break(th);
|
||||
}
|
||||
printf("\nfinished\n");
|
||||
#if 0
|
||||
rz_th_start(th, true);
|
||||
sleep(1);
|
||||
#endif
|
||||
/* wait and free */
|
||||
rz_th_wait(th);
|
||||
rz_th_free(th);
|
||||
|
||||
printf("\nresult %d\n", ctr);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int main() {
|
||||
return test1();
|
||||
}
|
||||
Loading…
Reference in a new issue