static int check(RBinFile *arch) {
const ut8 *bytes = arch ? r_buf_buffer (arch->buf) : NULL;
ut64 sz = arch ? r_buf_size (arch->buf): 0;
return check_bytes (bytes, sz);
}
static int load(RBinFile *arch) {
const ut8 *bytes = arch ? r_buf_buffer (arch->buf) : NULL;
ut64 sz = arch ? r_buf_size (arch->buf): 0;
if (!arch || !arch->o) return R_FALSE;
return check_bytes (bytes, 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 = r_buf_size (core->yank_buf);
if (len <= 0) {
eprintf ("Clipboard is empty and no value argument(s) given\n");
goto beach;
}
str = r_mem_dup (r_buf_buffer (core->yank_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;
}
static void *load_bytes(RBinFile *bf, const ut8 *buf, ut64 sz, ut64 loadaddr, Sdb *sdb) {
if (check_bytes (r_buf_buffer (bf->buf), sz)) {
return memcpy (&n64_header, buf, sizeof (N64Header));
}
return NULL;
}
static bool load(RBinFile *bf) {
const ut8 *bytes = bf ? r_buf_buffer (bf->buf) : NULL;
ut64 sz = bf ? r_buf_size (bf->buf): 0;
ut64 la = (bf && bf->o) ? bf->o->loadaddr: 0;
return load_bytes (bf, bytes, sz, la, bf? bf->sdb: NULL) != NULL;
}
static bool load(RBinFile *arch) {
const ut8 *bytes = arch ? r_buf_buffer (arch->buf) : NULL;
ut64 sz = arch ? r_buf_size (arch->buf): 0;
ut64 la = (arch && arch->o) ? arch->o->loadaddr: 0;
return load_bytes (arch, bytes, sz, la, arch? arch->sdb: NULL) != NULL;
}
static int check(RBinFile *arch) {
if (!arch || !arch->buf) {
return false;
}
return check_bytes (r_buf_buffer (arch->buf), r_buf_size (arch->buf));
}
