static int r_debug_gdb_reg_read(RDebug *dbg, int type, ut8 *buf, int size) {
gdbr_read_registers(desc);
// read the len of the current area
int buflen = 0;
free (r_reg_get_bytes (dbg->reg, type, &buflen));
memcpy (buf, desc->data, desc->data_len);
if (!reg_buf) {
reg_buf = calloc (buflen, sizeof (char));
if (!reg_buf) {
return -1;
}
}
else {
if (buf_size < desc->data_len) {
ut8* new_buf = realloc (reg_buf, desc->data_len * sizeof (ut8));
if (!new_buf) {
return -1;
}
reg_buf = new_buf;
buflen = desc->data_len;
buf_size = desc->data_len;
}
}
buflen = R_MIN (desc->data_len, buflen);
memcpy (reg_buf, desc->data, buflen);
return desc->data_len;
}
int gdbr_write_reg(libgdbr_t* g, const char* name, char* value, int len) {
// static variable that keeps the information if writing
// register through packet <P> was possible
static int P = 1;
int i = 0;
while ( g->registers[i].size > 0) {
if (strcmp(g->registers[i].name, name) == 0) {
break;
}
i++;
}
if (g->registers[i].size == 0) {
fprintf(stderr, "Error registername <%s> not found in profile\n", name);
return -1;
}
if (P) {
gdbr_write_register (g, i, value, len);
if (g->last_code == MSG_OK) {
return 0;
}
P = 0;
}
gdbr_read_registers (g);
memcpy (g->data + g->registers[i].offset, value, len);
gdbr_write_bin_registers (g);
return 0;
}
int gdbr_write_registers(libgdbr_t* g, char* registers) {
// read current register set
gdbr_read_registers(g);
int x, len = strlen(registers);
char* buff = calloc(len, sizeof(char));
memcpy(buff, registers, len);
char* reg = strtok(buff, ",");
while ( reg != NULL ) {
char* name_end = strchr(reg, '=');
if (name_end == NULL) {
printf("Malformed argument: %s\n", reg);
free(buff);
return -1;
}
*name_end = '\0'; // change '=' to '\0'
// time to find the current register
int i = 0;
while ( g->registers[i].size > 0) {
if (strcmp(g->registers[i].name, reg) == 0) {
uint64_t register_size = g->registers[i].size;
uint64_t offset = g->registers[i].offset;
char* value = calloc (register_size * 2, sizeof(char));
memset (value, '0', register_size * 2);
name_end++;
// be able to take hex with and without 0x
if (name_end[1] == 'x' || name_end[1] == 'X') name_end += 2;
int val_len = strlen (name_end); // size of the rest
strcpy (value+(register_size * 2 - val_len), name_end);
for (x=0; x < register_size; x++) {
g->data[offset + register_size - x - 1] = hex2char(&value[x * 2]);
}
free(value);
}
i++;
}
reg = strtok(NULL, " ,");
}
free(buff);
uint64_t buffer_size = g->data_len * 2 + 8;
char* command = calloc(buffer_size, sizeof(char));
snprintf (command, buffer_size, "%s", CMD_WRITEREGS);
pack_hex (g->data, g->data_len, command+1);
send_command (g, command);
read_packet (g);
free (command);
handle_G (g);
return 0;
}
int gdbr_write_bin_registers(libgdbr_t* g, char* registers) {
gdbr_read_registers(g);
uint64_t buffer_size = g->data_len * 2 + 8;
char* command = calloc(buffer_size, sizeof(char));
snprintf(command, buffer_size, "%s", CMD_WRITEREGS);
pack_hex(g->data, g->data_len, command+1);
send_command(g, command);
free(command);
return 0;
}
static int r_debug_gdb_reg_read(RDebug *dbg, int type, ut8 *buf, int size) {
int copy_size;
int buflen = 0;
check_connection (dbg);
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) {
if (buflen > buf_size) { //copy_size) {
ut8* new_buf = realloc (reg_buf, buflen);
if (!new_buf) {
return -1;
}
reg_buf = new_buf;
buf_size = buflen;
}
} 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, R_MIN (copy_size, 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;
}
int gdbr_write_registers(libgdbr_t *g, char *registers) {
uint64_t buffer_size;
int ret, i = 0;
unsigned int x, len;
char *command, *reg, *buff;
// read current register set
if (!g) {
return -1;
}
gdbr_read_registers (g);
reg_cache.valid = false;
len = strlen (registers);
buff = calloc (len, sizeof (char));
if (!buff) {
return -1;
}
memcpy (buff, registers, len);
reg = strtok (buff, ",");
while (reg != NULL) {
char *name_end = strchr (reg, '=');
if (name_end == NULL) {
eprintf ("Malformed argument: %s\n", reg);
free (buff);
return -1;
}
*name_end = '\0'; // change '=' to '\0'
// time to find the current register
while (g->registers[i].size > 0) {
if (strcmp (g->registers[i].name, reg) == 0) {
const ut64 register_size = g->registers[i].size;
const ut64 offset = g->registers[i].offset;
char *value = calloc (register_size + 1, 2);
if (!value) {
free (buff);
return -1;
}
memset (value, '0', register_size * 2);
name_end++;
// be able to take hex with and without 0x
if (name_end[1] == 'x' || name_end[1] == 'X') {
name_end += 2;
}
const int val_len = strlen (name_end); // size of the rest
strcpy (value + (register_size * 2 - val_len), name_end);
for (x = 0; x < register_size; x++) {
g->data[offset + register_size - x - 1] = hex2char (&value[x * 2]);
}
free (value);
}
i++;
}
reg = strtok (NULL, " ,");
}
free (buff);
buffer_size = g->data_len * 2 + 8;
command = calloc (buffer_size, sizeof(char));
if (!command) {
return -1;
}
snprintf (command, buffer_size, "%s", CMD_WRITEREGS);
pack_hex (g->data, g->data_len, command + 1);
ret = send_msg (g, command);
if (ret < 0) {
free (command);
return ret;
}
read_packet (g);
free (command);
handle_G (g);
return 0;
}
static int r_debug_gdb_reg_read(RDebug *dbg, int type, ut8 *buf, int size) {
gdbr_read_registers(desc);
memcpy(buf, desc->data, desc->data_len);
return desc->data_len;
}