char *EMSCRIPTEN_KEEPALIVE GroestlCoinHash(char *hexstring)
{
size_t i, sl;
unsigned char *unhexed;
uint32_t hashA[16], hashB[16];
sph_groestl512_context ctx_groestl[2];
//output buffer [we're not releasing it, so it'll be a memory leak. don't care in this case]
if(!g_pHexedOutput)
{
g_pHexedOutput = malloc(65);
for(i=0; i<65; i++)
g_pHexedOutput[i] = 0;
}
//input length
sl = 0;
while(hexstring[sl])
sl++;
sl /= 2;
unhexed = malloc(sl);
if(unhexed)
{
//unhex the buffer
for(i = 0; i < sl; i++)
unhexed[i] = unhexify(hexstring[i*2]) * 16 + unhexify(hexstring[i*2+1]);
//grs 1 pass
sph_groestl512_init(&ctx_groestl[0]);
sph_groestl512(&ctx_groestl[0], unhexed, sl);
sph_groestl512_close(&ctx_groestl[0], hashA);
free(unhexed);
//grs 2 pass
sph_groestl512_init(&ctx_groestl[1]);
sph_groestl512(&ctx_groestl[1], hashA, 64);
sph_groestl512_close(&ctx_groestl[1], hashB);
//copy result
for(i = 0; i < 32; i++)
{
unsigned ch = ((unsigned char*)hashB)[i];
g_pHexedOutput[i*2] = hexify(ch >> 4);
g_pHexedOutput[i*2+1] = hexify(ch & 0x0F);
}
}
return g_pHexedOutput;
}
static int icdi_get_cmd_result(void *handle)
{
struct icdi_usb_handle_s *h;
int offset = 0;
char ch;
assert(handle != NULL);
h = (struct icdi_usb_handle_s *)handle;
do {
ch = h->read_buffer[offset++];
if (offset > h->read_count)
return ERROR_FAIL;
} while (ch != '$');
if (memcmp("OK", h->read_buffer + offset, 2) == 0)
return ERROR_OK;
if (h->read_buffer[offset] == 'E') {
/* get error code */
char result;
if (unhexify(&result, h->read_buffer + offset + 1, 1) != 1)
return ERROR_FAIL;
return result;
}
/* for now we assume everything else is ok */
return ERROR_OK;
}
static int icdi_usb_read_reg(void *handle, int num, uint32_t *val)
{
int result;
struct icdi_usb_handle_s *h;
char cmd[10];
h = (struct icdi_usb_handle_s *)handle;
snprintf(cmd, sizeof(cmd), "p%x", num);
result = icdi_send_cmd(handle, cmd);
if (result != ERROR_OK)
return result;
/* check result */
result = icdi_get_cmd_result(handle);
if (result != ERROR_OK) {
LOG_ERROR("register read failed: 0x%x", result);
return ERROR_FAIL;
}
/* convert result */
if (unhexify((char *)val, h->read_buffer + 2, 4) != 4) {
LOG_ERROR("failed to convert result");
return ERROR_FAIL;
}
return result;
}
static int icdi_usb_version(void *handle)
{
struct icdi_usb_handle_s *h;
h = (struct icdi_usb_handle_s *)handle;
char version[20];
/* get info about icdi */
int result = icdi_send_remote_cmd(handle, "version");
if (result != ERROR_OK)
return result;
if (h->read_count < 8) {
LOG_ERROR("Invalid Reply Received");
return ERROR_FAIL;
}
/* convert reply */
if (unhexify(version, h->read_buffer + 2, 4) != 4) {
LOG_WARNING("unable to get ICDI version");
return ERROR_OK;
}
/* null terminate and print info */
version[4] = 0;
LOG_INFO("ICDI Firmware version: %s", version);
return ERROR_OK;
}
int main(void) {
{
char path[] = "./test/casper/formelement.input.test.coffee.tested.do";
char dir[sizeof path];
char base[sizeof path];
dirname(dir, base, path);
eqStr(dir, "./test/casper");
eqStr(base, "formelement.input.test.coffee.tested.do");
}
{
const char *filename = "dir/file.tar.gz";
char *iter = (char*)filename;
eqStr(iter, "dir/file.tar.gz");
iter = nextExtension(iter);
eqStr(iter, ".tar.gz");
iter = nextExtension(iter);
eqStr(iter, ".gz");
iter = nextExtension(iter);
eqStr(iter, "");
}
{
const char *s = "/this/is/a/file.gz";
char hex[strlen(s)*2+1];
char unhex[sizeof hex + 1];
hexify(hex, s);
eqStr(hex, "-_this-_is-_a-_file.gz");
unhexify(unhex, hex);
eqStr(unhex, "/this/is/a/file.gz");
}
{
char cwd[] = "/root",
target[] = "./a/b",
dest[4096];
normalizePath(dest, cwd, target);
eqStr(dest, "/root/a/b");
}
{
char cwd[] = "/root/other",
target[] = "./a/../b/dir/e",
dest[4096];
normalizePath(dest, cwd, target);
eqStr(dest, "/root/other/b/dir/e");
}
return 0;
}
TEST(wire_reader_t, ints) {
auto buff = make_buff(unhexify("7FFF"));
wire_reader_t reader(buff.get());
ASSERT_EQ(127, reader.int8());
ASSERT_EQ(-1, reader.int8());
buff = make_buff(unhexify("AAFF"));
reader = wire_reader_t(buff.get());
ASSERT_EQ((int16_t)0xAAFF, reader.int16());
buff = make_buff(unhexify("ABCD0123"));
reader = wire_reader_t(buff.get());
ASSERT_EQ((int32_t)0xABCD0123, reader.int32());
buff = make_buff(unhexify("0123456789ABCDEF"));
reader = wire_reader_t(buff.get());
ASSERT_EQ(0x0123456789ABCDEF, reader.int64());
}
void manpage(void)
{
unsigned char *lines[] = {
#include "strcmp.man.hex"
0
};
unhexify(lines);
return;
} /* manpage */
/* Return a malloced canonical S-Expression with the serial number
converted from the hex string HEXSN. Return NULL on memory
error. */
ksba_sexp_t
hexsn_to_sexp (const char *hexsn)
{
char *buffer, *p;
size_t len;
char numbuf[40];
len = unhexify (NULL, hexsn);
snprintf (numbuf, sizeof numbuf, "(%u:", (unsigned int)len);
buffer = xtrymalloc (strlen (numbuf) + len + 2 );
if (!buffer)
return NULL;
p = stpcpy (buffer, numbuf);
len = unhexify (p, hexsn);
p[len] = ')';
p[len+1] = 0;
return buffer;
}
void GdbServer::handle_q_packet (char *packet, int len) {
unsigned long addr, alen;
if (!strncmp (packet, "qRcmd,", 6)) {
int datalen;
/* calculate size and allocate buffer for command */
datalen = (len - 6) / 2;
char data [datalen + 1];
/* dehexify command */
unhexify ((unsigned char*) data, (const unsigned char*)packet + 6, datalen);
data[datalen] = 0; /* add terminating null */
int c = mon.command (data);
if (c < 0)
gdb_putpacketz ("");
else if (c == 0)
gdb_putpacketz ("OK");
else
gdb_putpacketz ("E");
} else if (!strncmp (packet, "qSupported", 10)) {
/* Query supported protocol features */
gdb_putpacket_f ("PacketSize=%X;qXfer:memory-map:read+;qXfer:features:read+", BUF_SIZE);
} else if (strncmp (packet, "qXfer:memory-map:read::", 23) == 0) {
/* Read target XML memory map */
if ((!target) || (!target->xml_mem_map)) {
gdb_putpacketz ("E01");
return;
}
handle_q_string_reply (target->xml_mem_map, packet + 23);
} else if (strncmp (packet, "qXfer:features:read:target.xml:", 31) == 0) {
/* Read target description */
if ((!target) || (!target->tdesc)) {
gdb_putpacketz ("E01");
return;
}
handle_q_string_reply (target->tdesc, packet + 31);
} else if (sscanf (packet, "qCRC:%08lx,%08lx", &addr, &alen) == 2) {
if (!target) {
gdb_putpacketz ("E01");
return;
}
gdb_putpacket_f ("C%lx", target->generic_crc32 (addr, alen));
} else {
debug ("*** Unsupported packet: %s\n", packet);
gdb_putpacket ("", 0);
}
}
void
gdb_main(void)
{
int size;
bool single_step = false;
char last_activity = 0;
DEBUG("Entring GDB protocol main loop\n");
/* GDB protocol main loop */
while(1) {
SET_IDLE_STATE(1);
size = gdb_getpacket(pbuf, BUF_SIZE);
SET_IDLE_STATE(0);
continue_activity:
switch(pbuf[0]) {
/* Implementation of these is mandatory! */
case 'g': { /* 'g': Read general registers */
ERROR_IF_NO_TARGET();
uint8_t arm_regs[target_regs_size(cur_target)];
target_regs_read(cur_target, arm_regs);
gdb_putpacket(hexify(pbuf, arm_regs, sizeof(arm_regs)),
sizeof(arm_regs) * 2);
break;
}
case 'm': { /* 'm addr,len': Read len bytes from addr */
uint32_t addr, len;
ERROR_IF_NO_TARGET();
sscanf(pbuf, "m%" SCNx32 ",%" SCNx32, &addr, &len);
DEBUG("m packet: addr = %" PRIx32 ", len = %" PRIx32 "\n", addr, len);
uint8_t mem[len];
target_mem_read(cur_target, mem, addr, len);
if(target_check_error(cur_target))
gdb_putpacketz("E01");
else
gdb_putpacket(hexify(pbuf, mem, len), len*2);
break;
}
case 'G': { /* 'G XX': Write general registers */
ERROR_IF_NO_TARGET();
uint8_t arm_regs[target_regs_size(cur_target)];
unhexify(arm_regs, &pbuf[1], sizeof(arm_regs));
target_regs_write(cur_target, arm_regs);
gdb_putpacketz("OK");
break;
}
case 'M': { /* 'M addr,len:XX': Write len bytes to addr */
uint32_t addr, len;
int hex;
ERROR_IF_NO_TARGET();
sscanf(pbuf, "M%" SCNx32 ",%" SCNx32 ":%n", &addr, &len, &hex);
DEBUG("M packet: addr = %" PRIx32 ", len = %" PRIx32 "\n", addr, len);
uint8_t mem[len];
unhexify(mem, pbuf + hex, len);
target_mem_write(cur_target, addr, mem, len);
if(target_check_error(cur_target))
gdb_putpacketz("E01");
else
gdb_putpacketz("OK");
break;
}
case 's': /* 's [addr]': Single step [start at addr] */
single_step = true;
// Fall through to resume target
case 'c': /* 'c [addr]': Continue [at addr] */
if(!cur_target) {
gdb_putpacketz("X1D");
break;
}
target_halt_resume(cur_target, single_step);
SET_RUN_STATE(1);
single_step = false;
// Fall through to wait for target halt
case '?': { /* '?': Request reason for target halt */
/* This packet isn't documented as being mandatory,
* but GDB doesn't work without it. */
uint32_t watch_addr;
int sig;
if(!cur_target) {
/* Report "target exited" if no target */
gdb_putpacketz("W00");
break;
}
last_activity = pbuf[0];
/* Wait for target halt */
while(!(sig = target_halt_wait(cur_target))) {
unsigned char c = gdb_if_getchar_to(0);
if((c == '\x03') || (c == '\x04')) {
target_halt_request(cur_target);
last_activity = 's';
}
}
SET_RUN_STATE(0);
/* Negative signal indicates we're in a syscall */
if (sig < 0)
break;
/* Target disappeared */
if (cur_target == NULL) {
gdb_putpacket_f("X%02X", sig);
break;
}
/* Report reason for halt */
if(target_check_hw_wp(cur_target, &watch_addr)) {
/* Watchpoint hit */
gdb_putpacket_f("T%02Xwatch:%08X;", sig, watch_addr);
} else {
gdb_putpacket_f("T%02X", sig);
}
break;
}
case 'F': { /* Semihosting call finished */
int retcode, errcode, items;
char c, *p;
if (pbuf[1] == '-')
p = &pbuf[2];
else
p = &pbuf[1];
items = sscanf(p, "%x,%x,%c", &retcode, &errcode, &c);
if (pbuf[1] == '-')
retcode = -retcode;
target_hostio_reply(cur_target, retcode, errcode);
/* if break is requested */
if (items == 3 && c == 'C') {
gdb_putpacketz("T02");
break;
}
pbuf[0] = last_activity;
goto continue_activity;
}
/* Optional GDB packet support */
case '!': /* Enable Extended GDB Protocol. */
/* This doesn't do anything, we support the extended
* protocol anyway, but GDB will never send us a 'R'
* packet unless we answer 'OK' here.
*/
gdb_putpacketz("OK");
break;
case 0x04:
case 'D': /* GDB 'detach' command. */
if(cur_target)
target_detach(cur_target);
last_target = cur_target;
cur_target = NULL;
gdb_putpacketz("OK");
break;
case 'k': /* Kill the target */
if(cur_target) {
target_reset(cur_target);
target_detach(cur_target);
last_target = cur_target;
cur_target = NULL;
}
break;
case 'r': /* Reset the target system */
case 'R': /* Restart the target program */
if(cur_target)
target_reset(cur_target);
else if(last_target) {
cur_target = target_attach(last_target,
gdb_target_destroy_callback);
target_reset(cur_target);
}
break;
case 'X': { /* 'X addr,len:XX': Write binary data to addr */
uint32_t addr, len;
int bin;
ERROR_IF_NO_TARGET();
sscanf(pbuf, "X%" SCNx32 ",%" SCNx32 ":%n", &addr, &len, &bin);
DEBUG("X packet: addr = %" PRIx32 ", len = %" PRIx32 "\n", addr, len);
target_mem_write(cur_target, addr, pbuf+bin, len);
if(target_check_error(cur_target))
gdb_putpacketz("E01");
else
gdb_putpacketz("OK");
break;
}
case 'q': /* General query packet */
handle_q_packet(pbuf, size);
break;
case 'v': /* General query packet */
handle_v_packet(pbuf, size);
break;
/* These packet implement hardware break-/watchpoints */
case 'Z': /* Z type,addr,len: Set breakpoint packet */
case 'z': /* z type,addr,len: Clear breakpoint packet */
ERROR_IF_NO_TARGET();
handle_z_packet(pbuf, size);
break;
default: /* Packet not implemented */
DEBUG("*** Unsupported packet: %s\n", pbuf);
gdb_putpacketz("");
}
}
}
int gdb_main_loop(struct target_controller *tc, bool in_syscall)
{
int size;
bool single_step = false;
/* GDB protocol main loop */
while(1) {
SET_IDLE_STATE(1);
size = gdb_getpacket(pbuf, BUF_SIZE);
SET_IDLE_STATE(0);
switch(pbuf[0]) {
/* Implementation of these is mandatory! */
case 'g': { /* 'g': Read general registers */
ERROR_IF_NO_TARGET();
uint8_t arm_regs[target_regs_size(cur_target)];
target_regs_read(cur_target, arm_regs);
gdb_putpacket(hexify(pbuf, arm_regs, sizeof(arm_regs)),
sizeof(arm_regs) * 2);
break;
}
case 'm': { /* 'm addr,len': Read len bytes from addr */
uint32_t addr, len;
ERROR_IF_NO_TARGET();
sscanf(pbuf, "m%" SCNx32 ",%" SCNx32, &addr, &len);
if (len > sizeof(pbuf) / 2) {
gdb_putpacketz("E02");
break;
}
DEBUG("m packet: addr = %" PRIx32 ", len = %" PRIx32 "\n", addr, len);
uint8_t mem[len];
if (target_mem_read(cur_target, mem, addr, len))
gdb_putpacketz("E01");
else
gdb_putpacket(hexify(pbuf, mem, len), len*2);
break;
}
case 'G': { /* 'G XX': Write general registers */
ERROR_IF_NO_TARGET();
uint8_t arm_regs[target_regs_size(cur_target)];
unhexify(arm_regs, &pbuf[1], sizeof(arm_regs));
target_regs_write(cur_target, arm_regs);
gdb_putpacketz("OK");
break;
}
case 'M': { /* 'M addr,len:XX': Write len bytes to addr */
uint32_t addr, len;
int hex;
ERROR_IF_NO_TARGET();
sscanf(pbuf, "M%" SCNx32 ",%" SCNx32 ":%n", &addr, &len, &hex);
if (len > (unsigned)(size - hex) / 2) {
gdb_putpacketz("E02");
break;
}
DEBUG("M packet: addr = %" PRIx32 ", len = %" PRIx32 "\n", addr, len);
uint8_t mem[len];
unhexify(mem, pbuf + hex, len);
if (target_mem_write(cur_target, addr, mem, len))
gdb_putpacketz("E01");
else
gdb_putpacketz("OK");
break;
}
case 's': /* 's [addr]': Single step [start at addr] */
single_step = true;
/* fall through */
case 'c': /* 'c [addr]': Continue [at addr] */
if(!cur_target) {
gdb_putpacketz("X1D");
break;
}
target_halt_resume(cur_target, single_step);
SET_RUN_STATE(1);
single_step = false;
/* fall through */
case '?': { /* '?': Request reason for target halt */
/* This packet isn't documented as being mandatory,
* but GDB doesn't work without it. */
target_addr watch;
enum target_halt_reason reason;
if(!cur_target) {
/* Report "target exited" if no target */
gdb_putpacketz("W00");
break;
}
/* Wait for target halt */
while(!(reason = target_halt_poll(cur_target, &watch))) {
unsigned char c = gdb_if_getchar_to(0);
if((c == '\x03') || (c == '\x04')) {
target_halt_request(cur_target);
}
}
SET_RUN_STATE(0);
/* Translate reason to GDB signal */
switch (reason) {
case TARGET_HALT_ERROR:
gdb_putpacket_f("X%02X", GDB_SIGLOST);
morse("TARGET LOST.", true);
break;
case TARGET_HALT_REQUEST:
gdb_putpacket_f("T%02X", GDB_SIGINT);
break;
case TARGET_HALT_WATCHPOINT:
gdb_putpacket_f("T%02Xwatch:%08X;", GDB_SIGTRAP, watch);
break;
case TARGET_HALT_FAULT:
gdb_putpacket_f("T%02X", GDB_SIGSEGV);
break;
default:
gdb_putpacket_f("T%02X", GDB_SIGTRAP);
}
break;
}
case 'F': /* Semihosting call finished */
if (in_syscall) {
return hostio_reply(tc, pbuf, size);
} else {
DEBUG("*** F packet when not in syscall! '%s'\n", pbuf);
gdb_putpacketz("");
}
break;
/* Optional GDB packet support */
case '!': /* Enable Extended GDB Protocol. */
/* This doesn't do anything, we support the extended
* protocol anyway, but GDB will never send us a 'R'
* packet unless we answer 'OK' here.
*/
gdb_putpacketz("OK");
break;
case 0x04:
case 'D': /* GDB 'detach' command. */
if(cur_target)
target_detach(cur_target);
last_target = cur_target;
cur_target = NULL;
gdb_putpacketz("OK");
break;
case 'k': /* Kill the target */
if(cur_target) {
target_reset(cur_target);
target_detach(cur_target);
last_target = cur_target;
cur_target = NULL;
}
break;
case 'r': /* Reset the target system */
case 'R': /* Restart the target program */
if(cur_target)
target_reset(cur_target);
else if(last_target) {
cur_target = target_attach(last_target,
&gdb_controller);
target_reset(cur_target);
}
break;
case 'X': { /* 'X addr,len:XX': Write binary data to addr */
uint32_t addr, len;
int bin;
ERROR_IF_NO_TARGET();
sscanf(pbuf, "X%" SCNx32 ",%" SCNx32 ":%n", &addr, &len, &bin);
if (len > (unsigned)(size - bin)) {
gdb_putpacketz("E02");
break;
}
DEBUG("X packet: addr = %" PRIx32 ", len = %" PRIx32 "\n", addr, len);
if (target_mem_write(cur_target, addr, pbuf+bin, len))
gdb_putpacketz("E01");
else
gdb_putpacketz("OK");
break;
}
case 'q': /* General query packet */
handle_q_packet(pbuf, size);
break;
case 'v': /* General query packet */
handle_v_packet(pbuf, size);
break;
/* These packet implement hardware break-/watchpoints */
case 'Z': /* Z type,addr,len: Set breakpoint packet */
case 'z': /* z type,addr,len: Clear breakpoint packet */
ERROR_IF_NO_TARGET();
handle_z_packet(pbuf, size);
break;
default: /* Packet not implemented */
DEBUG("*** Unsupported packet: %s\n", pbuf);
gdb_putpacketz("");
}
}
}
/**
* storage_findfiles(path):
* Look for files named "blks_<16 hex digits>" in the directory ${path}.
* Return an elastic queue of struct storage_file, in order of increasing
* fileno.
*/
struct elasticqueue *
storage_findfiles(const char * path)
{
struct stat sb;
DIR * dir;
struct dirent * dp;
struct ptrheap * H;
struct storage_file * sf;
char * s;
uint8_t fileno_exp[8];
struct elasticqueue * Q;
/* Create a heap for holding storage_file structures. */
if ((H = ptrheap_init(fs_compar, NULL, NULL)) == NULL)
goto err0;
/* Create a queue for holding the structures in sorted order. */
if ((Q = elasticqueue_init(sizeof(struct storage_file))) == NULL)
goto err1;
/* Open the storage directory. */
if ((dir = opendir(path)) == NULL) {
warnp("Cannot open storage directory: %s", path);
goto err2;
}
/*
* Look for files named "blks_<64-bit hexified first block #>" and
* create storage_file structures for each.
*/
while ((errno = 0), ((dp = readdir(dir)) != NULL)) {
/* Skip anything which isn't the right length. */
if (strlen(dp->d_name) != strlen("blks_0123456789abcdef"))
continue;
/* Skip anything which doesn't start with "blks_". */
if (strncmp(dp->d_name, "blks_", 5))
continue;
/* Make sure the name has 8 hexified bytes and parse. */
if (unhexify(&dp->d_name[5], fileno_exp, 8))
continue;
/* Construct a full path to the file and stat. */
if (asprintf(&s, "%s/%s", path, dp->d_name) == -1) {
warnp("asprintf");
goto err3;
}
if (lstat(s, &sb)) {
warnp("stat(%s)", s);
goto err4;
}
/* Skip anything other than regular files. */
if (!S_ISREG(sb.st_mode))
goto next;
/* Allocate a file_state structure. */
if ((sf = malloc(sizeof(struct storage_file))) == NULL)
goto err4;
/* Fill in file number and size. */
sf->fileno = be64dec(fileno_exp);
sf->len = sb.st_size;
/* Insert the file into the heap. */
if (ptrheap_add(H, sf))
goto err5;
next:
/* Free the full path to the file. */
free(s);
}
if (errno != 0) {
warnp("Error reading storage directory: %s", path);
goto err3;
}
/* Close the storage directory. */
while (closedir(dir)) {
/* Retry if we were interrupted. */
if (errno == EINTR)
continue;
/* Oops, something bad happened. */
warnp("Error closing storage directory: %s", path);
goto err2;
}
/* Suck structures from the heap into the queue. */
while ((sf = ptrheap_getmin(H)) != NULL) {
if (elasticqueue_add(Q, sf))
goto err2;
free(sf);
ptrheap_deletemin(H);
}
/* Free the (now empty) heap. */
ptrheap_free(H);
/* Success! */
return (Q);
err5:
free(sf);
err4:
free(s);
err3:
closedir(dir);
err2:
elasticqueue_free(Q);
err1:
while ((sf = ptrheap_getmin(H)) != NULL) {
ptrheap_deletemin(H);
free(sf);
}
ptrheap_free(H);
err0:
/* Failure! */
return (NULL);
}
/* Handle all of the extended 'q' packets. */
static
void handle_query (char *arg_own_buf, int *new_packet_len_p)
{
static struct inferior_list_entry *thread_ptr;
/* qRcmd, monitor command handling. */
if (strncmp ("qRcmd,", arg_own_buf, 6) == 0) {
char *p = arg_own_buf + 6;
int cmdlen = strlen(p)/2;
char cmd[cmdlen+1];
if (unhexify (cmd, p, cmdlen) != cmdlen) {
write_enn (arg_own_buf);
return;
}
cmd[cmdlen] = '\0';
if (handle_gdb_monitor_command (cmd)) {
/* In case the command is from a standalone vgdb,
connection will be closed soon => flush the output. */
VG_(message_flush) ();
write_ok (arg_own_buf);
return;
} else {
/* cmd not recognised */
VG_(gdb_printf)
("command '%s' not recognised\n"
"In gdb, try 'monitor help'\n"
"In a shell, try 'vgdb help'\n",
cmd);
write_ok (arg_own_buf);
return;
}
}
/* provide some valgrind specific info in return to qThreadExtraInfo. */
if (strncmp ("qThreadExtraInfo,", arg_own_buf, 17) == 0) {
unsigned long gdb_id;
struct thread_info *ti;
ThreadState *tst;
char status[100];
gdb_id = strtoul (&arg_own_buf[17], NULL, 16);
ti = gdb_id_to_thread (gdb_id);
if (ti != NULL) {
tst = (ThreadState *) inferior_target_data (ti);
/* Additional info is the tid and the thread status. */
VG_(snprintf) (status, sizeof(status), "tid %d %s",
tst->tid,
VG_(name_of_ThreadStatus)(tst->status));
hexify (arg_own_buf, status, strlen(status));
return;
} else {
write_enn (arg_own_buf);
return;
}
}
if (strcmp ("qAttached", arg_own_buf) == 0) {
/* tell gdb to always detach, never kill the process */
arg_own_buf[0] = '1';
arg_own_buf[1] = 0;
return;
}
if (strcmp ("qSymbol::", arg_own_buf) == 0) {
/* We have no symbol to read. */
write_ok (arg_own_buf);
return;
}
if (strcmp ("qfThreadInfo", arg_own_buf) == 0) {
thread_ptr = all_threads.head;
VG_(sprintf) (arg_own_buf, "m%x",
thread_to_gdb_id ((struct thread_info *)thread_ptr));
thread_ptr = thread_ptr->next;
return;
}
if (strcmp ("qsThreadInfo", arg_own_buf) == 0) {
if (thread_ptr != NULL) {
VG_(sprintf) (arg_own_buf, "m%x",
thread_to_gdb_id ((struct thread_info *)thread_ptr));
thread_ptr = thread_ptr->next;
return;
} else {
VG_(sprintf) (arg_own_buf, "l");
return;
}
}
if (valgrind_target_xml(VG_(clo_vgdb_shadow_registers)) != NULL
&& strncmp ("qXfer:features:read:", arg_own_buf, 20) == 0) {
CORE_ADDR ofs;
unsigned int len, doc_len;
const char *annex = NULL;
// First, the annex is extracted from the packet received.
// Then, it is replaced by the corresponding file name.
int fd;
/* Grab the annex, offset, and length. */
if (decode_xfer_read (arg_own_buf + 20, &annex, &ofs, &len) < 0) {
strcpy (arg_own_buf, "E00");
return;
}
if (strcmp (annex, "target.xml") == 0) {
annex = valgrind_target_xml(VG_(clo_vgdb_shadow_registers));
if (annex != NULL && VG_(clo_vgdb_shadow_registers)) {
/* Ensure the shadow registers are initialized. */
initialize_shadow_low(True);
}
if (annex == NULL) {
strcpy (arg_own_buf, "E00");
return;
}
}
{
char doc[VG_(strlen)(VG_(libdir)) + 1 + VG_(strlen)(annex) + 1];
struct vg_stat stat_doc;
char toread[len];
int len_read;
VG_(sprintf)(doc, "%s/%s", VG_(libdir), annex);
fd = VG_(fd_open) (doc, VKI_O_RDONLY, 0);
if (fd == -1) {
strcpy (arg_own_buf, "E00");
return;
}
if (VG_(fstat) (fd, &stat_doc) != 0) {
VG_(close) (fd);
strcpy (arg_own_buf, "E00");
return;
}
doc_len = stat_doc.size;
if (len > PBUFSIZ - POVERHSIZ)
len = PBUFSIZ - POVERHSIZ;
if (ofs > doc_len) {
write_enn (arg_own_buf);
VG_(close) (fd);
return;
}
VG_(lseek) (fd, ofs, VKI_SEEK_SET);
len_read = VG_(read) (fd, toread, len);
*new_packet_len_p = write_qxfer_response (arg_own_buf, (unsigned char *)toread,
len_read, ofs + len_read < doc_len);
VG_(close) (fd);
return;
}
}
if (strncmp ("qXfer:auxv:read:", arg_own_buf, 16) == 0) {
unsigned char *data;
int n;
CORE_ADDR ofs;
unsigned int len;
const char *annex;
/* Reject any annex; grab the offset and length. */
if (decode_xfer_read (arg_own_buf + 16, &annex, &ofs, &len) < 0
|| annex[0] != '\0') {
strcpy (arg_own_buf, "E00");
return;
}
if (len > PBUFSIZ - 2)
len = PBUFSIZ - 2;
data = malloc (len);
{
UWord *client_auxv = VG_(client_auxv);
unsigned int client_auxv_len = 0;
while (*client_auxv != 0) {
dlog(4, "auxv %lld %llx\n",
(ULong)*client_auxv,
(ULong)*(client_auxv+1));
client_auxv++;
client_auxv++;
client_auxv_len += 2 * sizeof(UWord);
}
client_auxv_len += 2 * sizeof(UWord);
dlog(4, "auxv len %d\n", client_auxv_len);
if (ofs >= client_auxv_len)
n = -1;
else {
n = client_auxv_len - ofs;
VG_(memcpy) (data, (unsigned char *) VG_(client_auxv), n);
}
}
if (n < 0)
write_enn (arg_own_buf);
else if (n > len)
*new_packet_len_p = write_qxfer_response (arg_own_buf, data, len, 1);
else
*new_packet_len_p = write_qxfer_response (arg_own_buf, data, n, 0);
free (data);
return;
}
/* Protocol features query. */
if (strncmp ("qSupported", arg_own_buf, 10) == 0
&& (arg_own_buf[10] == ':' || arg_own_buf[10] == '\0')) {
VG_(sprintf) (arg_own_buf, "PacketSize=%x", PBUFSIZ - 1);
/* Note: max packet size including frame and checksum, but without
trailing null byte, which is not sent/received. */
strcat (arg_own_buf, ";QStartNoAckMode+");
strcat (arg_own_buf, ";QPassSignals+");
if (VG_(client_auxv))
strcat (arg_own_buf, ";qXfer:auxv:read+");
if (valgrind_target_xml(VG_(clo_vgdb_shadow_registers)) != NULL) {
strcat (arg_own_buf, ";qXfer:features:read+");
/* if a new gdb connects to us, we have to reset the register
set to the normal register sets to allow this new gdb to
decide to use or not the shadow registers.
Note that the reset is only done for gdb that are sending
qSupported packets. If a user first connected with a recent
gdb using shadow registers and then with a very old gdb
that does not use qSupported packet, then the old gdb will
not properly connect. */
initialize_shadow_low(False);
}
return;
}
/* Otherwise we didn't know what packet it was. Say we didn't
understand it. */
arg_own_buf[0] = 0;
}
/* Handle all of the extended 'q' packets. */
void
handle_query (char *own_buf, int packet_len, int *new_packet_len_p)
{
static struct inferior_list_entry *thread_ptr;
/* Reply the current thread id. */
if (strcmp ("qC", own_buf) == 0)
{
thread_ptr = all_threads.head;
if (thread_ptr == NULL)
strcpy (own_buf, "unset");
else
sprintf (own_buf, "QC%x",
thread_to_gdb_id ((struct thread_info *)thread_ptr));
return;
}
if (strcmp ("qSymbol::", own_buf) == 0)
{
if (the_target->look_up_symbols != NULL)
(*the_target->look_up_symbols) ();
strcpy (own_buf, "OK");
return;
}
if (strcmp ("qfThreadInfo", own_buf) == 0)
{
thread_ptr = all_threads.head;
sprintf (own_buf, "m%x", thread_to_gdb_id ((struct thread_info *)thread_ptr));
thread_ptr = thread_ptr->next;
return;
}
if (strcmp ("qsThreadInfo", own_buf) == 0)
{
if (thread_ptr != NULL)
{
sprintf (own_buf, "m%x", thread_to_gdb_id ((struct thread_info *)thread_ptr));
thread_ptr = thread_ptr->next;
return;
}
else
{
sprintf (own_buf, "l");
return;
}
}
if (the_target->read_offsets != NULL
&& strcmp ("qOffsets", own_buf) == 0)
{
CORE_ADDR text, data;
if (the_target->read_offsets (&text, &data))
sprintf (own_buf, "Text=%lX;Data=%lX;Bss=%lX",
(long)text, (long)data, (long)data);
else
write_enn (own_buf);
return;
}
if (the_target->qxfer_spu != NULL
&& strncmp ("qXfer:spu:read:", own_buf, 15) == 0)
{
char *annex;
int n;
unsigned int len;
CORE_ADDR ofs;
unsigned char *spu_buf;
strcpy (own_buf, "E00");
if (decode_xfer_read (own_buf + 15, &annex, &ofs, &len) < 0)
return;
if (len > PBUFSIZ - 2)
len = PBUFSIZ - 2;
spu_buf = malloc (len + 1);
if (!spu_buf)
return;
n = (*the_target->qxfer_spu) (annex, spu_buf, NULL, ofs, len + 1);
if (n < 0)
write_enn (own_buf);
else if (n > len)
*new_packet_len_p = write_qxfer_response
(own_buf, spu_buf, len, 1);
else
*new_packet_len_p = write_qxfer_response
(own_buf, spu_buf, n, 0);
free (spu_buf);
return;
}
if (the_target->qxfer_spu != NULL
&& strncmp ("qXfer:spu:write:", own_buf, 16) == 0)
{
char *annex;
int n;
unsigned int len;
CORE_ADDR ofs;
unsigned char *spu_buf;
strcpy (own_buf, "E00");
spu_buf = malloc (packet_len - 15);
if (!spu_buf)
return;
if (decode_xfer_write (own_buf + 16, packet_len - 16, &annex,
&ofs, &len, spu_buf) < 0)
{
free (spu_buf);
return;
}
n = (*the_target->qxfer_spu)
(annex, NULL, (unsigned const char *)spu_buf, ofs, len);
if (n < 0)
write_enn (own_buf);
else
sprintf (own_buf, "%x", n);
free (spu_buf);
return;
}
if (the_target->read_auxv != NULL
&& strncmp ("qXfer:auxv:read:", own_buf, 16) == 0)
{
unsigned char *data;
int n;
CORE_ADDR ofs;
unsigned int len;
char *annex;
/* Reject any annex; grab the offset and length. */
if (decode_xfer_read (own_buf + 16, &annex, &ofs, &len) < 0
|| annex[0] != '\0')
{
strcpy (own_buf, "E00");
return;
}
/* Read one extra byte, as an indicator of whether there is
more. */
if (len > PBUFSIZ - 2)
len = PBUFSIZ - 2;
data = malloc (len + 1);
n = (*the_target->read_auxv) (ofs, data, len + 1);
if (n < 0)
write_enn (own_buf);
else if (n > len)
*new_packet_len_p = write_qxfer_response (own_buf, data, len, 1);
else
*new_packet_len_p = write_qxfer_response (own_buf, data, n, 0);
free (data);
return;
}
if (strncmp ("qXfer:features:read:", own_buf, 20) == 0)
{
CORE_ADDR ofs;
unsigned int len, total_len;
const char *document;
char *annex;
/* Check for support. */
document = get_features_xml ("target.xml");
if (document == NULL)
{
own_buf[0] = '\0';
return;
}
/* Grab the annex, offset, and length. */
if (decode_xfer_read (own_buf + 20, &annex, &ofs, &len) < 0)
{
strcpy (own_buf, "E00");
return;
}
/* Now grab the correct annex. */
document = get_features_xml (annex);
if (document == NULL)
{
strcpy (own_buf, "E00");
return;
}
total_len = strlen (document);
if (len > PBUFSIZ - 2)
len = PBUFSIZ - 2;
if (ofs > total_len)
write_enn (own_buf);
else if (len < total_len - ofs)
*new_packet_len_p = write_qxfer_response (own_buf, document + ofs,
len, 1);
else
*new_packet_len_p = write_qxfer_response (own_buf, document + ofs,
total_len - ofs, 0);
return;
}
if (strncmp ("qXfer:libraries:read:", own_buf, 21) == 0)
{
CORE_ADDR ofs;
unsigned int len, total_len;
char *document, *p;
struct inferior_list_entry *dll_ptr;
char *annex;
/* Reject any annex; grab the offset and length. */
if (decode_xfer_read (own_buf + 21, &annex, &ofs, &len) < 0
|| annex[0] != '\0')
{
strcpy (own_buf, "E00");
return;
}
/* Over-estimate the necessary memory. Assume that every character
in the library name must be escaped. */
total_len = 64;
for (dll_ptr = all_dlls.head; dll_ptr != NULL; dll_ptr = dll_ptr->next)
total_len += 128 + 6 * strlen (((struct dll_info *) dll_ptr)->name);
document = malloc (total_len);
strcpy (document, "<library-list>\n");
p = document + strlen (document);
for (dll_ptr = all_dlls.head; dll_ptr != NULL; dll_ptr = dll_ptr->next)
{
struct dll_info *dll = (struct dll_info *) dll_ptr;
char *name;
strcpy (p, " <library name=\"");
p = p + strlen (p);
name = xml_escape_text (dll->name);
strcpy (p, name);
free (name);
p = p + strlen (p);
strcpy (p, "\"><segment address=\"");
p = p + strlen (p);
sprintf (p, "0x%lx", (long) dll->base_addr);
p = p + strlen (p);
strcpy (p, "\"/></library>\n");
p = p + strlen (p);
}
strcpy (p, "</library-list>\n");
total_len = strlen (document);
if (len > PBUFSIZ - 2)
len = PBUFSIZ - 2;
if (ofs > total_len)
write_enn (own_buf);
else if (len < total_len - ofs)
*new_packet_len_p = write_qxfer_response (own_buf, document + ofs,
len, 1);
else
*new_packet_len_p = write_qxfer_response (own_buf, document + ofs,
total_len - ofs, 0);
free (document);
return;
}
/* Protocol features query. */
if (strncmp ("qSupported", own_buf, 10) == 0
&& (own_buf[10] == ':' || own_buf[10] == '\0'))
{
sprintf (own_buf, "PacketSize=%x", PBUFSIZ - 1);
#if !defined (NO_PASS_SIGNALS)
strcat (own_buf, ";QPassSignals+", PBUFSIZ - 1);
#endif
#if !defined (NO_LIBRARIES)
/* We do not have any hook to indicate whether the target backend
supports qXfer:libraries:read, so always report it. */
strcat (own_buf, ";qXfer:libraries:read+");
#endif
strcat (own_buf, ";qXfer:memory map:read+");
if (the_target->read_auxv != NULL)
strcat (own_buf, ";qXfer:auxv:read+");
if (the_target->qxfer_spu != NULL)
strcat (own_buf, ";qXfer:spu:read+;qXfer:spu:write+");
if (get_features_xml ("target.xml") != NULL)
strcat (own_buf, ";qXfer:features:read+");
return;
}
/* Thread-local storage support. */
if (the_target->get_tls_address != NULL
&& strncmp ("qGetTLSAddr:", own_buf, 12) == 0)
{
char *p = own_buf + 12;
CORE_ADDR parts[3], address = 0;
int i, err;
for (i = 0; i < 3; i++)
{
char *p2;
int len;
if (p == NULL)
break;
p2 = strchr (p, ',');
if (p2)
{
len = p2 - p;
p2++;
}
else
{
len = strlen (p);
p2 = NULL;
}
decode_address (&parts[i], p, len);
p = p2;
}
if (p != NULL || i < 3)
err = 1;
else
{
struct thread_info *thread = gdb_id_to_thread (parts[0]);
if (thread == NULL)
err = 2;
else
err = the_target->get_tls_address (thread, parts[1], parts[2],
&address);
}
if (err == 0)
{
sprintf (own_buf, "%llx", address);
return;
}
else if (err > 0)
{
write_enn (own_buf);
return;
}
/* Otherwise, pretend we do not understand this packet. */
}
/* Handle "monitor" commands. */
if (strncmp ("qRcmd,", own_buf, 6) == 0)
{
char *mon = malloc (PBUFSIZ);
int len = strlen (own_buf + 6);
if ((len % 1) != 0 || unhexify (mon, own_buf + 6, len / 2) != len / 2)
{
write_enn (own_buf);
free (mon);
return;
}
mon[len / 2] = '\0';
write_ok (own_buf);
if (strcmp (mon, "set debug 1") == 0)
{
debug_threads = 1;
monitor_output ("Debug output enabled.\n");
}
else if (strcmp (mon, "set debug 0") == 0)
{
debug_threads = 0;
monitor_output ("Debug output disabled.\n");
}
else if (strcmp (mon, "set remote-debug 1") == 0)
{
remote_debug = 1;
monitor_output ("Protocol debug output enabled.\n");
}
else if (strcmp (mon, "set remote-debug 0") == 0)
{
remote_debug = 0;
monitor_output ("Protocol debug output disabled.\n");
}
else if (strcmp (mon, "help") == 0)
monitor_show_help ();
else
{
int ok = 0;
if (the_target->commands)
ok = (*the_target->commands) (mon, len);
else
monitor_output ("Unknown monitor command.\n\n");
if (!ok)
{
monitor_show_help ();
write_enn (own_buf);
}
}
free (mon);
return;
}
/* Otherwise we didn't know what packet it was. Say we didn't
understand it. */
own_buf[0] = 0;
}
/* Run a new program. Return 1 if successful, 0 if failure. */
static int
handle_v_run (char *own_buf, char *status, int *signal)
{
char *p, **pp, *next_p, **new_argv;
int i, new_argc;
new_argc = 0;
for (p = own_buf + strlen ("vRun;"); p && *p; p = strchr (p, ';'))
{
p++;
new_argc++;
}
new_argv = malloc ((new_argc + 2) * sizeof (char *));
i = 0;
for (p = own_buf + strlen ("vRun;"); *p; p = next_p)
{
next_p = strchr (p, ';');
if (next_p == NULL)
next_p = p + strlen (p);
if (i == 0 && p == next_p)
new_argv[i] = NULL;
else
{
new_argv[i] = malloc (1 + (next_p - p) / 2);
unhexify (new_argv[i], p, (next_p - p) / 2);
new_argv[i][(next_p - p) / 2] = '\0';
}
if (*next_p)
next_p++;
i++;
}
new_argv[i] = NULL;
if (new_argv[0] == NULL)
{
if (program_argv == NULL)
{
write_enn (own_buf);
return 0;
}
new_argv[0] = strdup (program_argv[0]);
}
/* Free the old argv. */
if (program_argv)
{
for (pp = program_argv; *pp != NULL; pp++)
free (*pp);
free (program_argv);
}
program_argv = new_argv;
*signal = start_inferior (program_argv, status);
if (*status == 'T')
{
prepare_resume_reply (own_buf, *status, *signal);
return 1;
}
else
{
write_enn (own_buf);
return 0;
}
}
uint32_t GdbServer::Up (char *pbuf, uint32_t plen) {
debug ("Up::%d:\"%s\"\n", plen, pbuf);
lock.lock();
size = plen;
continue_activity:
switch (pbuf[0]) {
case 0: { // Ctrl - C
debug ("GdbServer::Up Ctrl-C\n");
target->halt_request ();
last_activity = 's';
break;
}
/* Implementation of these is mandatory! */
case 'g': { /* 'g': Read general registers */
if (!target_check ()) break;
int rsize = target->get_regs_size();
debug ("RSIZE = %d\n", rsize);
uint8_t arm_regs [rsize];
target->regs_read (arm_regs);
/* Výstup po blocích délky max. 240 bytů byl vynucen větší déklou dat registrů
* CortexM4F. Zdá se, že to funguje.
*/
const int chunk = 120;
int block, start = 0;
for (;;) {
if (rsize > chunk) block = chunk;
else block = rsize;
char* tptr = (char*) hexify (pbuf, (const unsigned char*) arm_regs + start, block);
gdb_putpacket (tptr , block * 2);
start += block;
rsize -= block;
if (!rsize) break;
}
break;
}
case 'm': { /* 'm addr,len': Read len bytes from addr */
unsigned long addr, len;
if (!target_check ()) break;
sscanf ((char*)pbuf, "m%08lx,%08lx", &addr, &len);
debug ("m packet: addr = %08lX, len = %08lX\n", addr, len);
uint8_t mem[len];
if ( ( (addr & 3) == 0) && ( (len & 3) == 0))
target->mem_read_words ((uint32_t*) mem, addr, len);
else
target->mem_read_bytes (mem, addr, len);
if (target->check_error ())
gdb_putpacketz ("E01");
else
gdb_putpacket ((char*)hexify (pbuf, mem, len), len*2);
break;
}
case 'G': { /* 'G XX': Write general registers */
if (!target_check ()) break;
int rsize = target->get_regs_size();
uint8_t arm_regs [rsize];
unhexify (arm_regs, (unsigned char*) &pbuf[1], rsize);
target->regs_write (arm_regs);
gdb_putpacketz ("OK");
break;
}
case 'M': { /* 'M addr,len:XX': Write len bytes to addr */
unsigned long addr, len;
int hex;
if (!target_check ()) break;
sscanf ((char*)pbuf, "M%08lx,%08lx:%n", &addr, &len, &hex);
debug ("M packet: addr = %08lX, len = %08lX\n", addr, len);
uint8_t mem[len];
unhexify (mem, (unsigned char*)pbuf + hex, len);
if ( ( (addr & 3) == 0) && ( (len & 3) == 0))
target->mem_write_words (addr, (const uint32_t*) mem, len);
else
target->mem_write_bytes (addr, mem, len);
if (target->check_error ())
gdb_putpacketz ("E01");
else
gdb_putpacketz ("OK");
break;
}
case 's': /* 's [addr]': Single step [start at addr] */
single_step = true;
// Fall through to resume target
case 'c': /* 'c [addr]': Continue [at addr] */
if (!target) {
gdb_putpacketz ("X1D");
break;
}
target->halt_resume (single_step);
single_step = false;
// Fall through to wait for target halt
case '?': { /* '?': Request reason for target halt */
/* This packet isn't documented as being mandatory,
* but GDB doesn't work without it. */
if (!target) {
/* Report "target exited" if no target */
gdb_putpacketz ("W00");
break;
}
if (!target->attached) {
/* Report "target exited" if no target */
gdb_putpacketz ("W00");
break;
}
last_activity = pbuf[0];
/* Wait for target halt */
debug("? WAIT HALT\n");
SetActive (); // timto se prepne do mainloop, kde ceka na zastaveni
break;
}
case 'F': { /* Semihosting call finished */
int retcode, errcode, items;
char c, *p;
if (pbuf[1] == '-')
p = (char*) &pbuf[2];
else
p = (char*) &pbuf[1];
items = sscanf (p, "%x,%x,%c", &retcode, &errcode, &c);
if (pbuf[1] == '-')
retcode = -retcode;
target->hostio_reply (retcode, errcode);
/* if break is requested */
if (items == 3 && c == 'C') {
gdb_putpacketz ("T02");
break;
}
pbuf[0] = last_activity;
goto continue_activity;
}
/* Optional GDB packet support */
case '!': /* Enable Extended GDB Protocol. */
/* This doesn't do anything, we support the extended
* protocol anyway, but GDB will never send us a 'R'
* packet unless we answer 'OK' here.
*/
gdb_putpacketz ("OK");
break;
case 0x04: // ???
debug ("CASE 4 packet ???\n");
case 'D': /* GDB 'detach' command. */
if (target) {
if (target->attached) {
target->detach ();
target->reset ();
}
}
gdb_putpacketz ("OK");
break;
case 'k': /* Kill the target */
if (target) {
target->detach ();
target->reset ();
}
break;
case 'r': /* Reset the target system */
case 'R': /* Restart the target program */
if (target && target->attach()) {
target->reset ();
SetActive ();
}
break;
case 'X': { /* 'X addr,len:XX': Write binary data to addr */
unsigned long addr, len;
int bin, icp;
if (!target_check ()) break;
sscanf ((char*)pbuf, "X%08lx,%08lx:%n", &addr, &len, &bin);
// On Cortex-M0 word align param to write_words
for (icp=0; icp<(int)len; icp++) pbuf[icp] = pbuf[icp + bin];
debug ("X packet: addr = %08lX, len = %08lX\n", addr, len);
if ( ( (addr & 3) == 0) && ( (len & 3) == 0))
target->mem_write_words (addr, (const uint32_t*) pbuf, len);
else
target->mem_write_bytes (addr, (unsigned char*) pbuf, len);
if (target->check_error ())
gdb_putpacketz ("E01");
else
gdb_putpacketz ("OK");
break;
}
case 'q': /* General query packet */
handle_q_packet ((char*)pbuf, size);
break;
case 'v': /* General query packet */
handle_v_packet ((char*)pbuf, size);
break;
/* These packet implement hardware break-/watchpoints */
case 'Z': /* Z type,addr,len: Set breakpoint packet */
case 'z': /* z type,addr,len: Clear breakpoint packet */
if (!target_check ()) break;
handle_z_packet ((char*)pbuf, size);
break;
default: /* Packet not implemented */
debug ("*** Unsupported packet: %s\n", pbuf);
gdb_putpacketz ("");
}
lock.unlock();
//return BaseLayer::Up (pbuf, plen);
return plen;
}
static void
handle_q_packet(char *packet, int len)
{
uint32_t addr, alen;
if(!strncmp(packet, "qRcmd,", 6)) {
char *data;
int datalen;
/* calculate size and allocate buffer for command */
datalen = (len - 6) / 2;
data = alloca(datalen+1);
/* dehexify command */
unhexify(data, packet+6, datalen);
data[datalen] = 0; /* add terminating null */
int c = command_process(cur_target, data);
if(c < 0)
gdb_putpacketz("");
else if(c == 0)
gdb_putpacketz("OK");
else
gdb_putpacketz("E");
} else if (!strncmp (packet, "qSupported", 10)) {
/* Query supported protocol features */
gdb_putpacket_f("PacketSize=%X;qXfer:memory-map:read+;qXfer:features:read+", BUF_SIZE);
} else if (strncmp (packet, "qXfer:memory-map:read::", 23) == 0) {
/* Read target XML memory map */
if((!cur_target) && last_target) {
/* Attach to last target if detached. */
cur_target = target_attach(last_target,
gdb_target_destroy_callback);
}
if (!cur_target) {
gdb_putpacketz("E01");
return;
}
handle_q_string_reply(target_mem_map(cur_target), packet + 23);
} else if (strncmp (packet, "qXfer:features:read:target.xml:", 31) == 0) {
/* Read target description */
if((!cur_target) && last_target) {
/* Attach to last target if detached. */
cur_target = target_attach(last_target,
gdb_target_destroy_callback);
}
if (!cur_target) {
gdb_putpacketz("E01");
return;
}
handle_q_string_reply(target_tdesc(cur_target), packet + 31);
} else if (sscanf(packet, "qCRC:%" PRIx32 ",%" PRIx32, &addr, &alen) == 2) {
if(!cur_target) {
gdb_putpacketz("E01");
return;
}
gdb_putpacket_f("C%lx", generic_crc32(cur_target, addr, alen));
} else {
DEBUG("*** Unsupported packet: %s\n", packet);
gdb_putpacket("", 0);
}
}
/* rtos_qsymbol() processes and replies to all qSymbol packets from GDB.
*
* GDB sends a qSymbol:: packet (empty address, empty name) to notify
* that it can now answer qSymbol::hexcodedname queries, to look up symbols.
*
* If the qSymbol packet has no address that means GDB did not find the
* symbol, in which case auto-detect will move on to try the next RTOS.
*
* rtos_qsymbol() then calls the next_symbol() helper function, which
* iterates over symbol names for the current RTOS until it finds the
* symbol in the received GDB packet, and then returns the next entry
* in the list of symbols.
*
* If GDB replied about the last symbol for the RTOS and the RTOS was
* specified explicitly, then no further symbol lookup is done. When
* auto-detecting, the RTOS driver _detect() function must return success.
*
* rtos_qsymbol() returns 1 if an RTOS has been detected, or 0 otherwise.
*/
int rtos_qsymbol(struct connection *connection, char const *packet, int packet_size)
{
int rtos_detected = 0;
uint64_t addr = 0;
size_t reply_len;
char reply[GDB_BUFFER_SIZE], cur_sym[GDB_BUFFER_SIZE / 2] = "";
symbol_table_elem_t *next_sym = NULL;
struct target *target = get_target_from_connection(connection);
struct rtos *os = target->rtos;
reply_len = sprintf(reply, "OK");
if (!os)
goto done;
/* Decode any symbol name in the packet*/
int len = unhexify(cur_sym, strchr(packet + 8, ':') + 1, strlen(strchr(packet + 8, ':') + 1));
cur_sym[len] = 0;
if ((strcmp(packet, "qSymbol::") != 0) && /* GDB is not offering symbol lookup for the first time */
(!sscanf(packet, "qSymbol:%" SCNx64 ":", &addr)) && /* GDB did not find an address for a symbol */
is_symbol_mandatory(os, cur_sym)) { /* the symbol is mandatory for this RTOS */
/* GDB could not find an address for the previous symbol */
if (!target->rtos_auto_detect) {
LOG_WARNING("RTOS %s not detected. (GDB could not find symbol \'%s\')", os->type->name, cur_sym);
goto done;
} else {
/* Autodetecting RTOS - try next RTOS */
if (!rtos_try_next(target)) {
LOG_WARNING("No RTOS could be auto-detected!");
goto done;
}
/* Next RTOS selected - invalidate current symbol */
cur_sym[0] = '\x00';
}
}
next_sym = next_symbol(os, cur_sym, addr);
if (!next_sym->symbol_name) {
/* No more symbols need looking up */
if (!target->rtos_auto_detect) {
rtos_detected = 1;
goto done;
}
if (os->type->detect_rtos(target)) {
LOG_INFO("Auto-detected RTOS: %s", os->type->name);
rtos_detected = 1;
goto done;
} else {
LOG_WARNING("No RTOS could be auto-detected!");
goto done;
}
}
if (8 + (strlen(next_sym->symbol_name) * 2) + 1 > sizeof(reply)) {
LOG_ERROR("ERROR: RTOS symbol '%s' name is too long for GDB!", next_sym->symbol_name);
goto done;
}
reply_len = snprintf(reply, sizeof(reply), "qSymbol:");
reply_len += hexify(reply + reply_len, next_sym->symbol_name, 0, sizeof(reply) - reply_len);
done:
gdb_put_packet(connection, reply, reply_len);
return rtos_detected;
}
/* Handle all of the extended 'q' packets. */
static
void handle_query (char *arg_own_buf, int *new_packet_len_p)
{
static struct inferior_list_entry *thread_ptr;
/* thread local storage query */
if (strncmp ("qGetTLSAddr:", arg_own_buf, 12) == 0) {
char *from, *to;
char *end = arg_own_buf + strlen(arg_own_buf);
unsigned long gdb_id;
CORE_ADDR lm;
CORE_ADDR offset;
struct thread_info *ti;
from = arg_own_buf + 12;
to = strchr(from, ',');
*to = 0;
gdb_id = strtoul (from, NULL, 16);
from = to + 1;
to = strchr(from, ',');
decode_address (&offset, from, to - from);
from = to + 1;
to = end;
decode_address (&lm, from, to - from);
dlog(2, "qGetTLSAddr thread %lu offset %p lm %p\n",
gdb_id, (void*)offset, (void*)lm);
ti = gdb_id_to_thread (gdb_id);
if (ti != NULL) {
ThreadState *tst;
Addr tls_addr;
tst = (ThreadState *) inferior_target_data (ti);
if (valgrind_get_tls_addr(tst, offset, lm, &tls_addr)) {
VG_(sprintf) (arg_own_buf, "%lx", tls_addr);
return;
}
// else we will report we do not support qGetTLSAddr
} else {
write_enn (arg_own_buf);
return;
}
}
/* qRcmd, monitor command handling. */
if (strncmp ("qRcmd,", arg_own_buf, 6) == 0) {
char *p = arg_own_buf + 6;
int cmdlen = strlen(p)/2;
char cmd[cmdlen+1];
if (unhexify (cmd, p, cmdlen) != cmdlen) {
write_enn (arg_own_buf);
return;
}
cmd[cmdlen] = '\0';
if (handle_gdb_monitor_command (cmd)) {
write_ok (arg_own_buf);
return;
} else {
/* cmd not recognised */
VG_(gdb_printf)
("command '%s' not recognised\n"
"In gdb, try 'monitor help'\n"
"In a shell, try 'vgdb help'\n",
cmd);
write_ok (arg_own_buf);
return;
}
}
/* provide some valgrind specific info in return to qThreadExtraInfo. */
if (strncmp ("qThreadExtraInfo,", arg_own_buf, 17) == 0) {
unsigned long gdb_id;
struct thread_info *ti;
ThreadState *tst;
gdb_id = strtoul (&arg_own_buf[17], NULL, 16);
ti = gdb_id_to_thread (gdb_id);
if (ti != NULL) {
tst = (ThreadState *) inferior_target_data (ti);
/* Additional info is the tid, the thread status and the thread's
name, if any. */
SizeT len = strlen(VG_(name_of_ThreadStatus)(tst->status)) + 20;
if (tst->thread_name) len += strlen(tst->thread_name);
/* As the string will be hexified and copied into own_buf we need
to limit the length to avoid buffer overflow. */
if (len * 2 > (PBUFSIZ + POVERHSIZ))
len = (PBUFSIZ + POVERHSIZ) / 2;
char status[len];
if (tst->thread_name) {
VG_(snprintf) (status, sizeof(status), "tid %d %s %s",
tst->tid,
VG_(name_of_ThreadStatus)(tst->status),
tst->thread_name);
} else {
VG_(snprintf) (status, sizeof(status), "tid %d %s",
tst->tid,
VG_(name_of_ThreadStatus)(tst->status));
}
hexify (arg_own_buf, status, strlen(status));
return;
} else {
write_enn (arg_own_buf);
return;
}
}
if (strcmp ("qAttached", arg_own_buf) == 0) {
/* tell gdb to always detach, never kill the process */
arg_own_buf[0] = '1';
arg_own_buf[1] = 0;
return;
}
if (strcmp ("qSymbol::", arg_own_buf) == 0) {
/* We have no symbol to read. */
write_ok (arg_own_buf);
return;
}
if (strcmp ("qfThreadInfo", arg_own_buf) == 0) {
thread_ptr = all_threads.head;
VG_(sprintf) (arg_own_buf, "m%x",
thread_to_gdb_id ((struct thread_info *)thread_ptr));
thread_ptr = thread_ptr->next;
return;
}
if (strcmp ("qsThreadInfo", arg_own_buf) == 0) {
if (thread_ptr != NULL) {
VG_(sprintf) (arg_own_buf, "m%x",
thread_to_gdb_id ((struct thread_info *)thread_ptr));
thread_ptr = thread_ptr->next;
return;
} else {
VG_(sprintf) (arg_own_buf, "l");
return;
}
}
if (valgrind_target_xml(VG_(clo_vgdb_shadow_registers)) != NULL
&& strncmp ("qXfer:features:read:", arg_own_buf, 20) == 0) {
CORE_ADDR ofs;
unsigned int len, doc_len;
const char *annex = NULL;
// First, the annex is extracted from the packet received.
// Then, it is replaced by the corresponding file name.
int fd;
/* Grab the annex, offset, and length. */
if (decode_xfer_read (arg_own_buf + 20, &annex, &ofs, &len) < 0) {
strcpy (arg_own_buf, "E00");
return;
}
if (strcmp (annex, "target.xml") == 0) {
annex = valgrind_target_xml(VG_(clo_vgdb_shadow_registers));
if (annex != NULL && VG_(clo_vgdb_shadow_registers)) {
/* Ensure the shadow registers are initialized. */
initialize_shadow_low(True);
}
if (annex == NULL) {
strcpy (arg_own_buf, "E00");
return;
}
}
{
char doc[VG_(strlen)(VG_(libdir)) + 1 + VG_(strlen)(annex) + 1];
struct vg_stat stat_doc;
char toread[len];
int len_read;
VG_(sprintf)(doc, "%s/%s", VG_(libdir), annex);
fd = VG_(fd_open) (doc, VKI_O_RDONLY, 0);
if (fd == -1) {
strcpy (arg_own_buf, "E00");
return;
}
if (VG_(fstat) (fd, &stat_doc) != 0) {
VG_(close) (fd);
strcpy (arg_own_buf, "E00");
return;
}
doc_len = stat_doc.size;
if (len > PBUFSIZ - POVERHSIZ)
len = PBUFSIZ - POVERHSIZ;
if (ofs > doc_len) {
write_enn (arg_own_buf);
VG_(close) (fd);
return;
}
VG_(lseek) (fd, ofs, VKI_SEEK_SET);
len_read = VG_(read) (fd, toread, len);
*new_packet_len_p = write_qxfer_response (arg_own_buf,
(unsigned char *)toread,
len_read,
ofs + len_read < doc_len);
VG_(close) (fd);
return;
}
}
if (strncmp ("qXfer:auxv:read:", arg_own_buf, 16) == 0) {
unsigned char *data;
int n;
CORE_ADDR ofs;
unsigned int len;
const char *annex;
/* Reject any annex; grab the offset and length. */
if (decode_xfer_read (arg_own_buf + 16, &annex, &ofs, &len) < 0
|| annex[0] != '\0') {
strcpy (arg_own_buf, "E00");
return;
}
if (len > PBUFSIZ - POVERHSIZ)
len = PBUFSIZ - POVERHSIZ;
data = malloc (len);
{
UWord *client_auxv = VG_(client_auxv);
unsigned int client_auxv_len = 0;
while (*client_auxv != 0) {
dlog(4, "auxv %lld %llx\n",
(ULong)*client_auxv,
(ULong)*(client_auxv+1));
client_auxv++;
client_auxv++;
client_auxv_len += 2 * sizeof(UWord);
}
client_auxv_len += 2 * sizeof(UWord);
dlog(4, "auxv len %d\n", client_auxv_len);
if (ofs >= client_auxv_len)
n = -1;
else {
n = client_auxv_len - ofs;
VG_(memcpy) (data, (unsigned char *) VG_(client_auxv), n);
}
}
if (n < 0)
write_enn (arg_own_buf);
else if (n > len)
*new_packet_len_p = write_qxfer_response (arg_own_buf, data, len, 1);
else
*new_packet_len_p = write_qxfer_response (arg_own_buf, data, n, 0);
free (data);
return;
}
if (strncmp ("qXfer:exec-file:read:", arg_own_buf, 21) == 0) {
unsigned char *data;
int n;
CORE_ADDR ofs;
unsigned int len;
const char *annex;
unsigned long pid;
const HChar *name;
/* grab the annex, offset and length. */
if (decode_xfer_read (arg_own_buf + 21, &annex, &ofs, &len) < 0) {
strcpy (arg_own_buf, "E00");
return;
}
/* Reject any annex with invalid/unexpected pid */
if (strlen(annex) > 0)
pid = strtoul (annex, NULL, 16);
else
pid = 0;
if ((int)pid != VG_(getpid)() && pid != 0) {
VG_(sprintf) (arg_own_buf,
"E.Valgrind gdbserver pid is %d."
" Cannot give info for pid %d",
VG_(getpid)(), (int) pid);
return;
}
if (len > PBUFSIZ - 2)
len = PBUFSIZ - 2;
data = malloc (len);
if (!VG_(resolve_filename)(VG_(cl_exec_fd), &name)) {
VG_(sprintf) (arg_own_buf,
"E.Valgrind gdbserver could not"
" resolve pid %d exec filename.",
VG_(getpid)());
return;
}
if (ofs >= strlen(name))
n = -1;
else {
n = strlen(name) - ofs;
VG_(memcpy) (data, name, n);
}
if (n < 0)
write_enn (arg_own_buf);
else if (n > len)
*new_packet_len_p = write_qxfer_response (arg_own_buf, data, len, 1);
else
*new_packet_len_p = write_qxfer_response (arg_own_buf, data, n, 0);
free (data);
return;
}
if (strncmp ("qXfer:siginfo:read:", arg_own_buf, 19) == 0) {
vki_siginfo_t info;
int n;
CORE_ADDR ofs;
unsigned int len;
const char *annex;
/* Reject any annex; grab the offset and length. */
if (decode_xfer_read (arg_own_buf + 19, &annex, &ofs, &len) < 0
|| annex[0] != '\0') {
strcpy (arg_own_buf, "E00");
return;
}
if (len > PBUFSIZ - POVERHSIZ)
len = PBUFSIZ - POVERHSIZ;
gdbserver_pending_signal_to_report(&info);
if (ofs >= sizeof(info))
n = -1;
else
n = sizeof(info) - ofs;
if (n < 0)
write_enn (arg_own_buf);
else if (n > len)
*new_packet_len_p = write_qxfer_response (arg_own_buf,
(unsigned char *)&info,
len, 1);
else
*new_packet_len_p = write_qxfer_response (arg_own_buf,
(unsigned char *)&info,
n, 0);
return;
}
/* Protocol features query. */
if (strncmp ("qSupported", arg_own_buf, 10) == 0
&& (arg_own_buf[10] == ':' || arg_own_buf[10] == '\0')) {
VG_(sprintf) (arg_own_buf, "PacketSize=%x", PBUFSIZ - 1);
/* Note: max packet size including frame and checksum, but without
trailing null byte, which is not sent/received. */
strcat (arg_own_buf, ";QStartNoAckMode+");
strcat (arg_own_buf, ";QPassSignals+");
if (VG_(client_auxv))
strcat (arg_own_buf, ";qXfer:auxv:read+");
if (valgrind_target_xml(VG_(clo_vgdb_shadow_registers)) != NULL) {
strcat (arg_own_buf, ";qXfer:features:read+");
/* if a new gdb connects to us, we have to reset the register
set to the normal register sets to allow this new gdb to
decide to use or not the shadow registers.
Note that the reset is only done for gdb that are sending
qSupported packets. If a user first connected with a recent
gdb using shadow registers and then with a very old gdb
that does not use qSupported packet, then the old gdb will
not properly connect. */
initialize_shadow_low(False);
}
strcat (arg_own_buf, ";qXfer:exec-file:read+");
strcat (arg_own_buf, ";qXfer:siginfo:read+");
return;
}
/* Otherwise we didn't know what packet it was. Say we didn't
understand it. */
arg_own_buf[0] = 0;
}