static int __write(RIO *io, RIODesc *fd, const ut8 *buf, int len) {
if (fd->flags & R_IO_WRITE) {
int left, perm;
if (self_in_section (io->off, &left, &perm)) {
int newlen = R_MIN (len, left);
ut8 *ptr = (ut8*)(size_t)io->off;
if (newlen>0)
memcpy (ptr, buf, newlen);
return newlen;
}
}
return -1;
}
static int check_bytes(const ut8 *buf, ut64 length) {
bool rc = false;
if (buf && length >= 32) {
char arch[9] = {0};
strncpy (arch, (const char *)buf+9, R_MIN (length, sizeof (arch)-1));
rc = !memcmp (buf, "\x64\x79\x6c\x64", 4);
if (rc) {
dyld64 = strstr (arch, "64") != NULL;
eprintf ("Arch: %s\n", arch);
}
}
return rc;
}
static int __read(RIO *io, RIODesc *fd, ut8 *buf, int len) {
int left;
int perm;
if (self_in_section (io->off, &left, &perm)) {
if (perm & R_IO_READ) {
int newlen = R_MIN (len, left);
ut8 *ptr = (ut8*)(size_t)io->off;
memcpy (buf, ptr, newlen);
return newlen;
}
}
return 0;
}
R_API int r_diff_buffers_static(RDiff *d, const ut8 *a, int la, const ut8 *b, int lb) {
int i, len;
int hit = 0;
la = R_ABS (la);
lb = R_ABS (lb);
if (la != lb) {
len = R_MIN (la, lb);
eprintf ("Buffer truncated to %d byte(s) (%d not compared)\n", len, R_ABS(lb-la));
} else {
len = la;
}
for (i = 0; i < len; i++) {
if (a[i] != b[i]) {
hit++;
} else {
if (hit > 0) {
int ra = la - (i - hit);
int rb = lb - (i - hit);
struct r_diff_op_t o = {
.a_off = d->off_a+i-hit, .a_buf = a+i-hit, .a_len = R_MIN (hit, ra),
.b_off = d->off_b+i-hit, .b_buf = b+i-hit, .b_len = R_MIN (hit, rb)
};
d->callback (d, d->user, &o);
hit = 0;
}
}
}
if (hit > 0) {
int ra = la - (i - hit);
int rb = lb - (i - hit);
struct r_diff_op_t o = {
.a_off = d->off_a+i-hit, .a_buf = a+i-hit, .a_len = R_MIN (hit, ra),
.b_off = d->off_b+i-hit, .b_buf = b+i-hit, .b_len = R_MIN (hit, rb)
};
d->callback (d, d->user, &o);
hit = 0;
}
return 0;
}
static int disassemble(RAsm *a, RAsmOp *op, const ut8 *buf, int len) {
cs_insn* insn = NULL;
cs_mode mode = 0;
int ret, n = 0;
csh cd;
mode = (a->bits==16)? CS_MODE_THUMB: CS_MODE_ARM;
if (a->big_endian)
mode |= CS_MODE_BIG_ENDIAN;
else
mode |= CS_MODE_LITTLE_ENDIAN;
if (a->cpu && strstr (a->cpu, "m"))
mode |= CS_MODE_MCLASS;
if (a->cpu && strstr (a->cpu, "v8"))
mode |= CS_MODE_V8;
op->size = 4;
op->buf_asm[0] = 0;
ret = (a->bits==64)?
cs_open (CS_ARCH_ARM64, mode, &cd):
cs_open (CS_ARCH_ARM, mode, &cd);
if (ret) {
ret = -1;
goto beach;
}
if (a->syntax == R_ASM_SYNTAX_REGNUM) {
cs_option (cd, CS_OPT_SYNTAX, CS_OPT_SYNTAX_NOREGNAME);
} else cs_option (cd, CS_OPT_SYNTAX, CS_OPT_SYNTAX_DEFAULT);
cs_option (cd, CS_OPT_DETAIL, CS_OPT_OFF);
n = cs_disasm (cd, buf, R_MIN (4, len),
a->pc, 1, &insn);
if (n<1) {
ret = -1;
goto beach;
}
if (insn->size<1) {
ret = -1;
goto beach;
}
op->size = insn->size;
snprintf (op->buf_asm, R_ASM_BUFSIZE, "%s%s%s",
insn->mnemonic,
insn->op_str[0]?" ":"",
insn->op_str);
r_str_rmch (op->buf_asm, '#');
cs_free (insn, n);
beach:
cs_close (&cd);
if (!op->buf_asm[0])
strcpy (op->buf_asm, "invalid");
return op->size;
}
static ut64 r_io_def_mmap_seek(RIO *io, RIOMMapFileObj *mmo, ut64 offset, int whence) {
ut64 seek_val = UT64_MAX;
if (!mmo) return UT64_MAX;
if (mmo->rawio)
return lseek (mmo->fd, offset, whence);
if (!mmo->buf) return UT64_MAX;
seek_val = mmo->buf->cur;
switch (whence) {
case SEEK_SET:
seek_val = R_MIN (mmo->buf->length, offset);
break;
case SEEK_CUR:
seek_val = R_MIN (mmo->buf->length, (offset + mmo->buf->cur));
break;
case SEEK_END:
seek_val = mmo->buf->length;
break;
}
mmo->buf->cur = io->off = seek_val;
return seek_val;
}
bool SetCursorPosConcrete(
struct Tracker_Windows *window,
struct WBlocks *wblock,
NInt tracknum,
int subtrack
){
struct WTracks *wtrack;
int ret=0,tempret;
if(tracknum>=wblock->block->num_tracks || tracknum<TEMPOTRACK) return false;
if(tracknum<0){
if(tracknum==window->curr_track) return true;
if(tracknum>window->curr_track){
while(window->curr_track!=tracknum){
tempret=CursorRight(window,wblock);
ret=R_MAX(tempret,ret);
}
}else{
while(window->curr_track!=tracknum){
tempret=CursorLeft(window,wblock);
ret=R_MAX(tempret,ret);
}
}
}else{
wtrack=ListFindElement1(&wblock->wtracks->l,tracknum);
int num_subtracks = GetNumSubtracks(wtrack);
subtrack=R_MIN(num_subtracks-1,subtrack);
if(tracknum==window->curr_track && subtrack==window->curr_track_sub)
return 0;
if(tracknum>window->curr_track || (tracknum==window->curr_track && subtrack>window->curr_track_sub)){
while(window->curr_track!=tracknum || window->curr_track_sub!=subtrack){
tempret=CursorRight(window,wblock);
//printf("wtrack->num: %d, curr_track: %d, num_tracks: %d\n",wtrack->l.num, window->curr_track,wblock->block->num_tracks);
ret=R_MAX(tempret,ret);
}
}else{
while(window->curr_track!=tracknum || window->curr_track_sub!=subtrack){
tempret=CursorLeft(window,wblock);
ret=R_MAX(tempret,ret);
}
}
}
return true;
}
R_API int r_debug_reg_sync(RDebug *dbg, int type, int write) {
int i, size;
if (!dbg || !dbg->reg || !dbg->h)
return R_FALSE;
// Theres no point in syncing a dead target
if (r_debug_is_dead (dbg))
return R_FALSE;
// Check if the functions needed are available
if (write && !dbg->h->reg_write)
return R_FALSE;
if (!write && !dbg->h->reg_read)
return R_FALSE;
// Sync all the types sequentially if asked
i = (type == R_REG_TYPE_ALL) ? R_REG_TYPE_GPR : type;
do {
if (write) {
ut8 *buf = r_reg_get_bytes (dbg->reg, i, &size);
if (!buf || !dbg->h->reg_write (dbg, i, buf, size)) {
if (i==0)
eprintf ("r_debug_reg: error writing registers %d to %d\n", i, dbg->pid);
return R_FALSE;
}
} else {
//int bufsize = R_MAX (1024, dbg->reg->size*2); // i know. its hacky
int bufsize = dbg->reg->size;
ut8 *buf = malloc (bufsize);
if (!buf) return R_FALSE;
//we have already checked dbg->h and dbg->h->reg_read above
size = dbg->h->reg_read (dbg, i, buf, bufsize);
// we need to check against zero because reg_read can return R_FALSE
if (!size) {
eprintf ("r_debug_reg: error reading registers\n");
free (buf);
return R_FALSE;
} else
r_reg_set_bytes (dbg->reg, i, buf, R_MIN(size, bufsize));
free (buf);
}
// DO NOT BREAK R_REG_TYPE_ALL PLEASE
// break;
// Continue the syncronization or just stop if it was asked only for a single type of regs
} while ((type==R_REG_TYPE_ALL) && (i++ < R_REG_TYPE_LAST));
return R_TRUE;
}
// Precondition: len > 0
// Non-stop IO
// Returns true iff all reads/writes on overlapped maps are complete.
static bool onIterMap(SdbListIter *iter, RIO *io, ut64 vaddr, ut8 *buf,
int len, int match_flg, cbOnIterMap op, void *user) {
// vendaddr may be 0 to denote 2**64
ut64 vendaddr = vaddr + len, len1;
int t;
bool ret = true;
for (; iter; iter = iter->p) {
RIOMap *map = (RIOMap *)iter->data;
ut64 to = r_itv_end (map->itv);
if (r_itv_overlap2 (map->itv, vaddr, len)) {
if ((map->flags & match_flg) == match_flg || io->p_cache) {
t = vaddr < map->itv.addr
? op (io, map->fd, map->delta, buf + map->itv.addr - vaddr,
len1 = R_MIN (vendaddr - map->itv.addr, map->itv.size), map, user)
: op (io, map->fd, map->delta + vaddr - map->itv.addr, buf,
len1 = R_MIN (to - vaddr, len), map, user);
if (t != len1) {
ret = false;
}
}
if (vaddr < map->itv.addr) {
t = onIterMap (iter->p, io, vaddr, buf, map->itv.addr - vaddr, match_flg, op, user);
if (!t) {
ret = false;
}
}
if (to - 1 < vendaddr - 1) {
t = onIterMap (iter->p, io, to, buf + to - vaddr, vendaddr - to, match_flg, op, user);
if (!t) {
ret = false;
}
}
}
}
return ret;
}
static int disassemble(RAsm *a, RAsmOp *op, const ut8 *buf, int len) {
struct disassemble_info disasm_obj;
int mode = 2;
op->buf_asm[0]='\0';
if (len<4)
return -1;
buf_global = op->buf_asm;
Offset = a->pc;
memcpy (bytes, buf, R_MIN (len, 8)); // TODO handle thumb
/* prepare disassembler */
memset (&disasm_obj, '\0', sizeof (struct disassemble_info));
disasm_obj.disassembler_options=(a->bits==64)?"64":"";
disasm_obj.buffer = bytes;
disasm_obj.read_memory_func = &cris_buffer_read_memory;
disasm_obj.symbol_at_address_func = &symbol_at_address;
disasm_obj.memory_error_func = &memory_error_func;
disasm_obj.print_address_func = &print_address;
disasm_obj.endian = !a->big_endian;
disasm_obj.fprintf_func = &buf_fprintf;
disasm_obj.stream = stdout;
if (a->cpu && *a->cpu) {
if (!strcmp (a->cpu, "v10+v32")) {
mode = 1;
} else
if (!strcmp (a->cpu, "v10")) {
mode = 0;
} else
if (!strcmp (a->cpu, "v32")) {
mode = 2;
} else mode = 2;
} else mode = 2;
(void)cris_parse_disassembler_options (&disasm_obj, mode);
if (a->syntax == R_ASM_SYNTAX_ATT) {
op->size = print_insn_crisv10_v32_with_register_prefix (
(bfd_vma)Offset, &disasm_obj);
} else {
op->size = print_insn_crisv10_v32_without_register_prefix (
(bfd_vma)Offset, &disasm_obj);
}
if (op->size == -1)
strncpy (op->buf_asm, " (data)", R_ASM_BUFSIZE);
return op->size;
}
static void readstr (char *s, int sz, const ut8 *buf, int len) {
int die = 0;
int last = R_MIN (len, sz);
strncpy (s, (char *)buf, last + die);
s[last] = 0;
while (*s && *s == '\n') {
s++;
}
#if 1
char *nl = strchr (s, '\n');
if (nl) {
*nl = 0;
}
#endif
virgin = false;
}
static int __read(RIO *io, RIODesc *fd, ut8 *buf, int len) {
vm_size_t size = 0;
int blen, err, copied = 0;
int blocksize = 32;
if (RIOMACH_PID (fd->data) == 0) {
if (io->off<4096)
return len;
}
memset (buf, 0xff, len);
while (copied<len) {
blen = R_MIN ((len-copied), blocksize);
//blen = len;
err = vm_read_overwrite (RIOMACH_TASK (fd->data),
(ut64)io->off+copied, blen, (pointer_t)buf+copied, &size);
switch (err) {
case KERN_PROTECTION_FAILURE:
//eprintf ("r_io_mach_read: kern protection failure.\n");
break;
case KERN_INVALID_ADDRESS:
if (blocksize == 1) {
memset (buf+copied, 0xff, len-copied);
return size+copied;
}
blocksize = 1;
blen = 1;
buf[copied] = 0xff;
//eprintf("invaddr %d\n",len);
break;
}
if (err == -1) {
//eprintf ("Cannot read\n");
return -1;
}
if (size==0) {
if (blocksize == 1) {
memset (buf+copied, 0xff, len-copied);
return len; //size+copied;
}
blocksize = 1;
blen = 1;
buf[copied] = 0xff;
}
//if (size != blen) { return size+copied; }
copied += blen;
}
return len; //(int)size;
}
static int r_debug_gdb_reg_read(RDebug *dbg, int type, ut8 *buf, int size) {
int copy_size;
int buflen = 0;
gdbr_read_registers (desc);
if (!desc) {
return -1;
}
// read the len of the current area
free (r_reg_get_bytes (dbg->reg, type, &buflen));
if (size < desc->data_len) {
eprintf ("r_debug_gdb_reg_read: small buffer %d vs %d\n",
(int)size, (int)desc->data_len);
// return -1;
}
copy_size = R_MIN (desc->data_len, size);
buflen = R_MAX (desc->data_len, buflen);
if (reg_buf) {
if (buf_size < copy_size) { //desc->data_len) {
ut8* new_buf = realloc (reg_buf, copy_size);
if (!new_buf)
return -1;
reg_buf = new_buf;
buflen = copy_size;
buf_size = desc->data_len;
}
} else {
reg_buf = calloc (buflen, 1);
if (!reg_buf)
return -1;
buf_size = buflen;
}
memset ((void*)(volatile void*)buf, 0, size);
memcpy ((void*)(volatile void*)buf, desc->data, copy_size);
memset ((void*)(volatile void*)reg_buf, 0, buflen);
memcpy ((void*)(volatile void*)reg_buf, desc->data, copy_size);
#if 0
int i;
//for(i=0;i<168;i++) {
for(i=0;i<copy_size;i++) {
if (!(i%16)) printf ("\n0x%08x ", i);
printf ("%02x ", buf[i]); //(ut8)desc->data[i]);
}
printf("\n");
#endif
return desc->data_len;
}
R_API void r_cons_canvas_box(RConsCanvas *c, int x, int y, int w, int h, const char *color) {
int i, x_mod;
int roundcorners = 0;
char *row = NULL, *row_ptr;
char corner = '=';
if (w < 1 || h<1) return;
//if (x > c->w*2) return;
//if (y > c->h*2) return;
if (color)
c->attr = color;
row = malloc (w+1);
if (!row)
return;
row[0] = roundcorners?'.':corner;
if (w>2)
memset (row+1, '-', w-2);
if (w>1)
row[w-1] = roundcorners?'.':corner;
row[w] = 0;
row_ptr = row;
x_mod = x;
if (x < -c->sx) {
x_mod = R_MIN(-c->sx, x_mod + w);
row_ptr += x_mod - x;
}
if (G(x_mod, y)) {
W(row_ptr);
}
if (G(x_mod, y+h-1)) {
row[0] = roundcorners?'\'':corner;
row[w-1] = roundcorners?'\'':corner;
W(row_ptr);
}
for (i=1; i<h-1; i++) {
if (G(x, y+i)) W("|");
if (G(x+w-1, y+i)) W("|");
}
free (row);
if (color)
c->attr = Color_RESET;
}
/*========================================================================
* rdisplay_ratio_compute
*
*
*========================================================================*/
void rdisplay_ratio_compute(void)
{
double lratio, lratio_width, lratio_height;
if ( (( rval_get( window_mode ) ) == RDISPLAY_FULLSCREEN) ) {
lratio_width = (double)( rval_get( desktop_width ) ) / (double)( rattr( design_width ) );
lratio_height = (double)( rval_get( desktop_height ) ) / (double)( rattr( design_height ) );
} else {
lratio_width = (double)( rval_get( window_width ) ) / (double)( rattr( design_width ) );
lratio_height = (double)( rval_get( window_height ) ) / (double)( rattr( design_height ) );
}
lratio = R_MIN( lratio_width, lratio_height);
rval_set( rdh_double, ratio_width, lratio_width);
rval_set( rdh_double, ratio_height, lratio_height);
rval_set( rdh_double, ratio, lratio);
/* styles refresh */
{
rlsstyle_iterator iter;
rlsstyle* ls = &( rattr( styles ) );
rstyle* style = rlsstyle_first( &iter, ls );
while (style) {
rstyle_refresh( style, lratio, lratio_width, lratio_height);
style = rlsstyle_next( &iter );
}
}
/* wid ratio/blit */
{
rlswid_iterator iter;
rlswid* ls = &( rattr( wids ) );
rwid* wid = rlswid_first( &iter, ls );
while (wid) {
/* [!] wid list shall sorted with parents first */
rwid_bb_compute( wid );
wid = rlswid_next( &iter );
}
}
}
static int __resize(RIO *io, RIODesc *fd, ut64 count) {
ut8 * new_buf = NULL;
if (fd == NULL || fd->data == NULL || count == 0)
return -1;
if (RIOKDP_OFF (fd) > RIOKDP_SZ (fd))
return -1;
new_buf = malloc (count);
if (!new_buf) return -1;
memcpy (new_buf, RIOKDP_BUF (fd), R_MIN(count, RIOKDP_SZ (fd)));
if (count > RIOKDP_SZ (fd) )
memset (new_buf+RIOKDP_SZ (fd), 0, count-RIOKDP_SZ (fd));
free (RIOKDP_BUF (fd));
RIOKDP_BUF (fd) = new_buf;
RIOKDP_SZ (fd) = count;
return count;
}
R_API void r_cons_canvas_write(RConsCanvas *c, const char *s) {
char *p, ch;
int orig_x, x;
int left, slen, attr_len, piece_len;
if (!c || !s || !*s) {
return;
}
/* split the string into pieces of non-ANSI chars and print them normally,
** using the ANSI chars to set the attr of the canvas */
orig_x = c->x;
do {
const char *s_part = set_attr (c, s);
ch = 0;
piece_len = get_piece (s_part, &ch);
if (piece_len == 0 && ch == '\0' && s_part == s) {
break;
}
left = 0;
p = prefixline (c, &left);
slen = R_MIN (left, piece_len);
attr_len = slen <= 0 && s_part != s? 1: slen;
if (attr_len > 0) {
stamp_attr (c, attr_len);
}
x = c->x - c->sx;
if (G (x, c->y - c->sy)) {
memcpy (p, s_part, slen);
}
s = s_part;
if (ch == '\n') {
c->y++;
c->x = orig_x;
s++;
if (*s == '\0') {
break;
}
} else {
c->x += slen;
}
s += piece_len;
} while (*s);
c->x = orig_x;
}
R_API RAnalData *r_anal_data_new (ut64 addr, int type, ut64 n, const ut8 *buf, int len) {
RAnalData *ad = R_NEW0 (RAnalData);
int l = R_MIN (len, 8);
ad->buf = (ut8*) &(ad->sbuf);
memset (ad->buf, 0, 8);
if (l<1) {
r_anal_data_free (ad);
return NULL;
}
if (buf) {
memcpy (ad->buf, buf, l);
}
ad->addr = addr;
ad->type = type;
ad->str = NULL;
ad->len = l;
ad->ptr = n;
return ad;
}
static int instlen(const ut8 *buf, int len) {
m68k_word bof[8] = {0};
char opcode[256], operands[256];
const unsigned char *buf2;
static struct DisasmPara_68k dp;
/* initialize DisasmPara */
*operands = *opcode = 0;
memcpy (bof, buf, R_MIN(len, sizeof(bof)));
dp.opcode = opcode;
dp.operands = operands;
dp.iaddr = 0LL;
dp.instr = bof;
buf2 = (const ut8*)M68k_Disassemble (&dp);
if (!buf2) {
// invalid instruction
return 2;
}
return (buf2-(const ut8*)bof);
}
static bool __resize(RIO *io, RIODesc *fd, ut64 count) {
ut8 * new_buf = NULL;
if (!fd || !fd->data || count == 0) {
return false;
}
if (RIOMALLOC_OFF (fd) > RIOMALLOC_SZ (fd)) {
return false;
}
new_buf = malloc (count);
if (!new_buf) return -1;
memcpy (new_buf, RIOMALLOC_BUF (fd), R_MIN (count, RIOMALLOC_SZ (fd)));
if (count > RIOMALLOC_SZ (fd)) {
memset (new_buf + RIOMALLOC_SZ (fd), 0, count - RIOMALLOC_SZ (fd));
}
free (RIOMALLOC_BUF (fd));
RIOMALLOC_BUF (fd) = new_buf;
RIOMALLOC_SZ (fd) = count;
return true;
}
static void stream_file_read_pages(R_STREAM_FILE *stream_file, int start_indx, int end_indx, char *res) {
int i, page_offset;
if ((end_indx - start_indx) > stream_file->end) {
stream_file->error = READ_PAGE_FAIL;
return;
}
end_indx = R_MIN (end_indx, stream_file->pages_amount);
for (i = start_indx; i < end_indx; i++) {
page_offset = stream_file->pages[i] * stream_file->page_size;
if (page_offset < 1) {
return;
}
stream_file->buf->cur = page_offset;
r_buf_read_at (stream_file->buf, page_offset,
(ut8*)res, stream_file->page_size);
res += stream_file->page_size;
}
}
static int __read(RIO *io, RIODesc *fd, ut8 *buf, int count) {
int code, rlen;
char *out, *url;
int ret = 0;
if (fd == NULL || fd->data == NULL)
return -1;
url = r_str_newf ("%s/p8%%20%d@%"PFMT64d,
rURL(fd), count, io->off);
out = r_socket_http_get (url, &code, &rlen);
if (out && rlen>0) {
ut8 *tmp = malloc (rlen+1);
ret = r_hex_str2bin (out, tmp);
memcpy (buf, tmp, R_MIN (count, rlen));
free (tmp);
if (ret<0) ret = -ret;
}
free (out);
free (url);
return ret;
}
int gdbr_read_file(libgdbr_t *g, ut8 *buf, ut64 max_len) {
int ret, ret1;
char command[64];
ut64 data_sz;
if (!g || !buf || !max_len) {
return -1;
}
if (max_len >= INT32_MAX) {
eprintf ("%s: Too big a file read requested: %"PFMT64d, __func__, max_len);
return -1;
}
if (g->remote_file_fd < 0) {
eprintf ("%s: No remote file opened\n", __func__);
return -1;
}
g->stub_features.pkt_sz = R_MAX (g->stub_features.pkt_sz, 64);
data_sz = g->stub_features.pkt_sz / 2;
ret = 0;
while (ret < max_len) {
if ((ret1 = snprintf (command, sizeof (command) - 1,
"vFile:pread:%x,%"PFMT64x",%"PFMT64x,
(int)g->remote_file_fd, (ut64)R_MIN(data_sz, max_len - ret),
(ut64)ret)) < 0) {
return -1;
}
if (send_msg (g, command) < 0) {
return -1;
}
if (read_packet (g) < 0) {
return -1;
}
if ((ret1 = handle_vFile_pread (g, buf + ret)) < 0) {
return -1;
}
if (ret1 == 0) {
return ret;
}
ret += ret1;
}
return ret;
}
// XXX: temporary files are
R_API char *r_diff_buffers_unified(RDiff *d, const ut8 *a, int la, const ut8 *b, int lb) {
r_file_dump (".a", a, la, 0);
r_file_dump (".b", b, lb, 0);
#if 0
if (r_mem_is_printable (a, R_MIN (5, la))) {
r_file_dump (".a", a, la, 0);
r_file_dump (".b", b, lb, 0);
} else {
r_file_hexdump (".a", a, la, 0);
r_file_hexdump (".b", b, lb, 0);
}
#endif
char* err = NULL;
char* out = NULL;
int out_len;
(void)r_sys_cmd_str_full ("/usr/bin/diff -u .a .b", NULL, &out, &out_len, &err);
r_file_rm (".a");
r_file_rm (".b");
free (err);
return out;
}
R_API int r_anal_op(RAnal *anal, RAnalOp *op, ut64 addr, const ut8 *data, int len) {
int ret = 0;
RAnalVar *tmp;
//len will end up in memcmp so check for negative
if (!anal || len < 0) {
return -1;
}
if (anal->pcalign) {
if (addr % anal->pcalign) {
memset (op, 0, sizeof (RAnalOp));
op->type = R_ANAL_OP_TYPE_ILL;
op->addr = addr;
op->size = 1;
return -1;
}
}
memset (op, 0, sizeof (RAnalOp));
if (len > 0 && anal->cur && anal->cur->op && strcmp (anal->cur->name, "null")) {
ret = anal->cur->op (anal, op, addr, data, len);
op->addr = addr;
//free the previous var in op->var
tmp = get_used_var (anal, op);
if (tmp) {
r_anal_var_free (op->var);
op->var = tmp;
}
if (ret < 1) {
op->type = R_ANAL_OP_TYPE_ILL;
}
} else {
if (!memcmp (data, "\xff\xff\xff\xff", R_MIN(4, len))) {
op->type = R_ANAL_OP_TYPE_ILL;
ret = 2; // HACK
} else {
op->type = R_ANAL_OP_TYPE_MOV;
}
}
return ret;
}
void CutRange(
struct Blocks *block,
NInt starttrack,
NInt endtrack,
Place *p1,
Place *p2
){
struct Tracks *track;
int lokke;
endtrack = R_MIN(block->num_tracks-1, endtrack);
if (endtrack < starttrack)
return;
track=ListFindElement1(&block->tracks->l,starttrack);
PC_Pause();{
for(lokke=0;lokke<=endtrack-starttrack;lokke++){
CutRange_notes(&track->notes,track->notes,p1,p2);
CutRange_stops(&track->stops,track->stops,p1,p2);
track=NextTrack(track);
if(track==NULL) break;
}
Place *startplace = p1;
Place *endplace = p2;
SCHEME_eval(
talloc_format("(cut-fx-range! %d %d %d (+ %d (/ %d %d)) (+ %d (/ %d %d)))",
block->l.num,
starttrack,
endtrack,
startplace->line, startplace->counter, startplace->dividor,
endplace->line, endplace->counter, endplace->dividor
)
);
}PC_StopPause(NULL);
}
// "dr8" read register state
static int __io_read(RDebug *dbg, int type, ut8 *buf, int size) {
dbg->iob.system (dbg->iob.io, "dr8");
char *regs = strdup (r_cons_get_buffer ());
ut8 *bregs = calloc (1, strlen (regs));
if (!bregs) {
free (regs);
return -1;
}
r_cons_reset ();
int sz = r_hex_str2bin (regs, bregs);
if (sz > 0) {
memcpy (buf, bregs, R_MIN (size, sz));
free (bregs);
free (regs);
return size;
} else {
eprintf ("SIZE %d (%s)\n", sz, regs);
}
free (bregs);
free (regs);
return -1;
}
static int assemble(struct r_asm_t *a, struct r_asm_op_t *op, const char *buf) {
char buf_err[128];
static t_asmmodel asm_obj;
int attempt, constsize, oattempt = 0, oconstsize = 0, ret = 0, oret = 0xCAFE;
/* attempt == 0: First attempt */
/* constsize == 0: Address constants and inmediate data of 16/32b */
for (constsize = 0; constsize < 4; constsize++) {
for (attempt = 0; ret > 0; attempt++) {
ret = Assemble((char*)buf, a->pc, &asm_obj, attempt, constsize, buf_err);
if (ret > 0 && ret < oret) {
oret = ret;
oattempt = attempt;
oconstsize = constsize;
}
}
}
op->size = R_MAX (0, Assemble((char*)buf, a->pc, &asm_obj, oattempt, oconstsize, buf_err));
if (op->size > 0)
memcpy (op->buf, asm_obj.code, R_MIN(op->size, (R_ASM_BUFSIZE-1)));
return op->size;
}
static int r_debug_qnx_reg_read (RDebug *dbg, int type, ut8 *buf, int size) {
int copy_size;
int buflen = 0;
if (!desc) {
return -1;
}
int len = qnxr_read_registers (desc);
if (len <= 0) return -1;
// read the len of the current area
free (r_reg_get_bytes (dbg->reg, type, &buflen));
if (size < len) {
eprintf ("r_debug_qnx_reg_read: small buffer %d vs %d\n",
(int)size, (int)len);
}
copy_size = R_MIN (len, size);
buflen = R_MAX (len, buflen);
if (reg_buf) {
if (buf_size < copy_size) {
ut8 *new_buf = realloc (reg_buf, copy_size);
if (!new_buf)
return -1;
reg_buf = new_buf;
buflen = copy_size;
buf_size = len;
}
} else {
reg_buf = calloc (buflen, 1);
if (!reg_buf)
return -1;
buf_size = buflen;
}
memset ((void *)(volatile void *) buf, 0, size);
memcpy ((void *)(volatile void *) buf, desc->recv.data, copy_size);
memset ((void *)(volatile void *) reg_buf, 0, buflen);
memcpy ((void *)(volatile void *) reg_buf, desc->recv.data, copy_size);
return len;
}
static void dump_cols (ut8 *a, int as, ut8 *b, int bs) {
ut32 sz = R_MIN (as, bs);
ut32 i, j;
printf (" offset 1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8\n");
for (i=0; i<sz; i++) {
char dch = (memcmp (a+i, b+i, 8))? ' ': '!';
printf ("0x%08x%c ", i, dch);
for (j=0; j<8; j++)
printf ("%02x", a[i+j]);
printf (" ");
for (j=0; j<8; j++)
printf ("%c", IS_PRINTABLE (a[i+j])?a[i+j]:'.');
printf (" ");
for (j=0; j<8; j++)
printf ("%02x", b[i+j]);
printf (" ");
for (j=0; j<8; j++)
printf ("%c", IS_PRINTABLE (b[i+j])? b[i+j]:'.');
printf ("\n");
}
if (as != bs)
printf ("...\n");
}
