int stub_main(int arch_reason)
{
int ret;
int gdb_signal;
gdb_signal = decode_signal(arch_reason);
/* Do not announce stop reply if we were detached. */
if (isattached) {
send_stop_reply(gdb_signal);
}
/* We are now attached. */
isattached = 1;
do {
int cmd;
char *p;
while (getpkt(&pktbuf[0], sizeof(pktbuf)) < 1);
p = &pktbuf[0];
cmd = *p;
if ('?' == cmd) {
send_stop_reply(gdb_signal);
ret = 0;
} else if ('c' == cmd) {
ret = handle_c(p);
} else if ('s' == cmd) {
ret = handle_s(p);
} else if ('D' == cmd) {
ret = handle_D(p);
if (ret & CMD_LEAVE) {
isattached = 0;
}
} else if ('g' == cmd) {
ret = handle_g(p);
} else if ('G' == cmd) {
ret = handle_G(p);
} else if ('P' == cmd) {
ret = handle_P(p);
} else if ('m' == cmd) {
ret = handle_m(p);
} else if ('M' == cmd) {
ret = handle_M(p);
} else {
/*
* For any command not supported by the stub, an empty
* response ('$#00') should be returned.
*/
p = "";
ret = CMD_REPLY;
}
if (ret & CMD_REPLY) {
putpkt(p);
}
} while (!(ret & CMD_LEAVE));
return ret;
}
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){
uint64_t buffer_size = g->data_len * 2 + 8;
char* 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);
if (send_command (g, command) < 0) return -1;
read_packet (g);
free (command);
handle_G (g);
return 0;
}
int gdbr_write_bin_registers(libgdbr_t *g){
if (!g) {
return -1;
}
reg_cache.valid = false;
uint64_t buffer_size = g->data_len * 2 + 8;
char *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);
if (send_msg (g, command) < 0) {
free (command);
return -1;
}
read_packet (g);
free (command);
handle_G (g);
return 0;
}
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;
}
