// Finds the offset of a given value in a cyclic pattern of an integer.
R_API int r_debruijn_offset(ut64 value, bool is_big_endian) {
char* needle, *pattern, buf[9];
int retval = -1;
char* pch;
// 0x10000 should be long enough. This is how peda works, and nobody complains
// ... but is slow. Optimize for common case.
int lens[2] = {0x1000, 0x10000};
int j;
if (value == 0) {
return -1;
}
for (j = 0; j <= 2 && retval == -1; ++j) {
pattern = r_debruijn_pattern (lens[j], 0, debruijn_charset);
buf[8] = '\0';
if (is_big_endian) {
r_write_be64 (buf, value);
} else {
r_write_le64 (buf, value);
}
for (needle = buf; !*needle; needle++) {
/* do nothing here */
}
pch = strstr (pattern, needle);
if (pch) {
retval = (int)(size_t)(pch - pattern);
}
free (pattern);
}
return retval;
}
static ut64 rap__lseek(RIO *io, RIODesc *fd, ut64 offset, int whence) {
RSocket *s = RIORAP_FD (fd);
ut8 tmp[10];
int ret;
// query
tmp[0] = RMT_SEEK;
tmp[1] = (ut8)whence;
r_write_be64 (tmp + 2, offset);
r_socket_write (s, &tmp, 10);
r_socket_flush (s);
// get reply
memset (tmp, 0, 9);
ret = r_socket_read_block (s, (ut8*)&tmp, 9);
if (ret != 9 || tmp[0] != (RMT_SEEK | RMT_REPLY)) {
// eprintf ("%d %d - %02x %02x %02x %02x %02x %02x %02x\n",
// ret, whence, tmp[0], tmp[1], tmp[2], tmp[3], tmp[4], tmp[5], tmp[6]);
eprintf ("Unexpected lseek reply\n");
return -1;
}
offset = r_read_at_be64 (tmp, 1);
return offset;
}
R_API bool r_reg_set_value(RReg *reg, RRegItem *item, ut64 value) {
int fits_in_arena;
ut8 bytes[12];
ut8 *src = bytes;
if (!item) {
eprintf ("r_reg_set_value: item is NULL\n");
return false;
}
switch (item->size) {
case 80:
case 96: // long floating value
r_reg_set_longdouble (reg, item, (long double)value);
break;
case 64:
if (reg->big_endian) {
r_write_be64 (src, value);
} else {
r_write_le64 (src, value);
}
break;
case 32:
if (reg->big_endian) {
r_write_be32 (src, value);
} else {
r_write_le32 (src, value);
}
break;
case 16:
if (reg->big_endian) {
r_write_be16 (src, value);
} else {
r_write_le16 (src, value);
}
break;
case 8:
r_write_ble8 (src, (ut8)(value & UT8_MAX));
break;
case 1:
if (value) {
ut8 *buf = reg->regset[item->arena].arena->bytes + (item->offset / 8);
int bit = (item->offset % 8);
ut8 mask = (1 << bit);
buf[0] = (buf[0] & (0xff ^ mask)) | mask;
} else {
int idx = item->offset / 8;
RRegArena *arena = reg->regset[item->arena].arena;
if (idx + item->size > arena->size) {
eprintf ("RRegSetOverflow %d vs %d\n", idx + item->size, arena->size);
return false;
}
ut8 *buf = arena->bytes + idx;
int bit = item->offset % 8;
ut8 mask = 0xff ^ (1 << bit);
buf[0] = (buf[0] & mask) | 0;
}
return true;
default:
eprintf ("r_reg_set_value: Bit size %d not supported\n", item->size);
return false;
}
fits_in_arena = (reg->regset[item->arena].arena->size - BITS2BYTES (item->offset) - BITS2BYTES (item->size)) >= 0;
if (src && fits_in_arena) {
r_mem_copybits (reg->regset[item->arena].arena->bytes +
BITS2BYTES (item->offset),
src, item->size);
return true;
}
eprintf ("r_reg_set_value: Cannot set %s to 0x%" PFMT64x "\n", item->name, value);
return false;
}
R_API bool r_socket_rap_server_continue (RSocketRapServer *rap_s) {
int i, whence, ret = true;
ut64 offset;
char *ptr = NULL;
if (!rap_s || !rap_s->fd)
return false;
if (!r_socket_is_connected (rap_s->fd))
return false;
r_socket_read_block (rap_s->fd, rap_s->buf, 1);
ret = rap_s->buf[0];
switch (ret) {
case RAP_RMT_OPEN:
r_socket_read_block (rap_s->fd, &rap_s->buf[1], 2);
r_socket_read_block (rap_s->fd, &rap_s->buf[3], (int)rap_s->buf[2]);
rap_s->open (rap_s->user, (const char *)&rap_s->buf[3], (int)rap_s->buf[1], 0);
rap_s->buf[0] = RAP_RMT_OPEN | RAP_RMT_REPLY;
r_socket_write (rap_s->fd, rap_s->buf, 5);
r_socket_flush (rap_s->fd);
break;
case RAP_RMT_READ:
r_socket_read_block (rap_s->fd, &rap_s->buf[1], 4);
i = r_read_be32 (&rap_s->buf[1]);
if (i > RAP_RMT_MAX || i < 0)
i = RAP_RMT_MAX;
rap_s->read (rap_s->user, &rap_s->buf[5], i);
rap_s->buf[0] = RAP_RMT_READ | RAP_RMT_REPLY;
r_socket_write (rap_s->fd, rap_s->buf, i + 5);
r_socket_flush (rap_s->fd);
break;
case RAP_RMT_WRITE:
r_socket_read_block (rap_s->fd, rap_s->buf + 1, 4);
i = r_read_be32 (rap_s->buf + 1);
if (i > RAP_RMT_MAX || i < 0) {
i = RAP_RMT_MAX;
}
r_socket_read_block (rap_s->fd, rap_s->buf + 5, i);
int ret = rap_s->write (rap_s->user, rap_s->buf + 5, i);
r_write_be32 (rap_s->buf + 1, ret);
rap_s->buf[0] = RAP_RMT_WRITE | RAP_RMT_REPLY;
r_socket_write (rap_s->fd, rap_s->buf, 5);
r_socket_flush (rap_s->fd);
break;
case RAP_RMT_SEEK:
r_socket_read_block (rap_s->fd, &rap_s->buf[1], 9);
whence = rap_s->buf[1];
offset = r_read_be64 (rap_s->buf + 2);
offset = rap_s->seek (rap_s->user, offset, whence);
/* prepare reply */
rap_s->buf[0] = RAP_RMT_SEEK | RAP_RMT_REPLY;
r_write_be64 (rap_s->buf + 1, offset);
r_socket_write (rap_s->fd, rap_s->buf, 9);
r_socket_flush (rap_s->fd);
break;
case RAP_RMT_CMD:
r_socket_read_block (rap_s->fd, &rap_s->buf[1], 4);
i = r_read_be32 (&rap_s->buf[1]);
r_socket_read_block (rap_s->fd, &rap_s->buf[5], i);
ptr = rap_s->cmd (rap_s->user, (const char *)&rap_s->buf[5]);
i = (ptr)? strlen (ptr) + 1: 0;
r_write_be32 (&rap_s->buf[1], i);
rap_s->buf[0] = RAP_RMT_CMD | RAP_RMT_REPLY;
r_socket_write (rap_s->fd, rap_s->buf, 5);
if (i) r_socket_write (rap_s->fd, ptr, i);
r_socket_flush (rap_s->fd);
free (ptr);
ptr = NULL;
break;
case RAP_RMT_CLOSE:
r_socket_read_block (rap_s->fd, &rap_s->buf[1], 4);
i = r_read_be32 (&rap_s->buf[1]);
rap_s->close (rap_s->user, i);
rap_s->buf[0] = RAP_RMT_CLOSE | RAP_RMT_REPLY;
r_socket_write (rap_s->fd, rap_s->buf, 5);
r_socket_flush (rap_s->fd);
break;
default:
eprintf ("unknown command 0x%02x\n", \
(unsigned int)(unsigned char)rap_s->buf[0]);
r_socket_close (rap_s->fd);
ret = false;
break;
}
return ret;
}
