static int debug_gdb_read_at(ut8 *buf, int sz, ut64 addr) {
ut32 size_max = 500;
ut32 packets = sz / size_max;
ut32 last = sz % size_max;
ut32 x;
if (c_buff && addr != UT64_MAX && addr == c_addr) {
memcpy (buf, c_buff, sz);
return sz;
}
if (sz < 1 || addr >= UT64_MAX) return -1;
for (x = 0; x < packets; x++) {
gdbr_read_memory (desc, addr + x * size_max, size_max);
memcpy ((buf + x * size_max), desc->data + x * size_max, size_max);
}
if (last) {
gdbr_read_memory (desc, addr + x * size_max, last);
memcpy ((buf + x * size_max), desc->data + x * size_max, last);
}
c_addr = addr;
c_size = sz;
#if SILLY_CACHE
free (c_buff);
c_buff = r_mem_dup (buf, sz);
#endif
return sz;
}
R_API int r_core_write_op(RCore *core, const char *arg, char op) {
int i, j, len, ret = false;
char *str = NULL;
ut8 *buf;
// XXX we can work with config.block instead of dupping it
buf = (ut8 *)malloc (core->blocksize);
if (!buf) {
goto beach;
}
memcpy (buf, core->block, core->blocksize);
if (op!='e') {
// fill key buffer either from arg or from clipboard
if (arg) { // parse arg for key
// r_hex_str2bin() is guaranteed to output maximum half the
// input size, or 1 byte if there is just a single nibble.
str = (char *)malloc (strlen (arg) / 2 + 1);
if (!str) {
goto beach;
}
len = r_hex_str2bin (arg, (ut8 *)str);
// Output is invalid if there was just a single nibble,
// but in that case, len is negative (-1).
if (len <= 0) {
eprintf ("Invalid hexpair string\n");
goto beach;
}
} else { // use clipboard as key
len = core->yank_buf->length;
if (len <= 0) {
eprintf ("Clipboard is empty and no value argument(s) given\n");
goto beach;
}
str = r_mem_dup (core->yank_buf->buf, len);
if (!str) {
goto beach;
}
}
} else {
len = 0;
}
// execute the operand
if (op=='e') {
int wordsize = 1;
char *os, *p, *s = strdup (arg);
int n = 0, from = 0, to = UT8_MAX, dif = 0, step = 1;
os = s;
p = strchr (s, ' ');
if (p) {
*p = 0;
from = r_num_math (core->num, s);
s = p + 1;
}
p = strchr (s, ' ');
if (p) {
*p = 0;
to = r_num_math (core->num, s);
s = p + 1;
}
p = strchr (s, ' ');
if (p) {
*p = 0;
step = r_num_math (core->num, s);
s = p + 1;
wordsize = r_num_math (core->num, s);
} else {
step = r_num_math (core->num, s);
}
free (os);
eprintf ("from %d to %d step %d size %d\n", from, to, step, wordsize);
dif = (to <= from)? UT8_MAX: to - from + 1;
if (wordsize == 1) {
from %= (UT8_MAX + 1);
}
if (dif < 1) {
dif = UT8_MAX + 1;
}
if (step < 1) {
step = 1;
}
if (wordsize < 1) {
wordsize = 1;
}
if (wordsize == 1) {
for (i = n = 0; i < core->blocksize; i++, n += step) {
buf[i] = (ut8)(n % dif) + from;
}
} else if (wordsize == 2) {
ut16 num16 = from;
for (i = 0; i < core->blocksize; i += wordsize, num16 += step) {
r_write_le16 (buf + i, num16);
}
} else if (wordsize == 4) {
ut32 num32 = from;
for (i = 0; i < core->blocksize; i += wordsize, num32 += step) {
r_write_le32 (buf + i, num32);
}
} else if (wordsize == 8) {
ut64 num64 = from;
for (i = 0; i < core->blocksize; i += wordsize, num64 += step) {
r_write_le64 (buf + i, num64);
}
} else {
eprintf ("Invalid word size. Use 1, 2, 4 or 8\n");
}
} else if (op=='2' || op=='4') {
op -= '0';
// if i < core->blocksize would pass the test but buf[i+3] goes beyond the buffer
if (core->blocksize > 3) {
for (i=0; i<core->blocksize-3; i+=op) {
/* endian swap */
ut8 tmp = buf[i];
buf[i] = buf[i+3];
buf[i+3] = tmp;
if (op == 4) {
tmp = buf[i + 1];
buf[i + 1] = buf[i + 2];
buf[i + 2] = tmp;
}
}
}
} else {
for (i=j=0; i<core->blocksize; i++) {
switch (op) {
case 'x': buf[i] ^= str[j]; break;
case 'a': buf[i] += str[j]; break;
case 's': buf[i] -= str[j]; break;
case 'm': buf[i] *= str[j]; break;
case 'w': buf[i] = str[j]; break;
case 'd': buf[i] = (str[j])? buf[i] / str[j]: 0; break;
case 'r': buf[i] >>= str[j]; break;
case 'l': buf[i] <<= str[j]; break;
case 'o': buf[i] |= str[j]; break;
case 'A': buf[i] &= str[j]; break;
}
j++;
if (j >= len) {
j = 0; /* cyclic key */
}
}
}
ret = r_core_write_at (core, core->offset, buf, core->blocksize);
beach:
free (buf);
free (str);
return ret;
}
