void server_main (void)
{
static char status;
static int zignal;
char ch;
int i = 0;
unsigned int len;
CORE_ADDR mem_addr;
zignal = valgrind_wait (&status);
if (VG_MINIMAL_SETJMP(toplevel)) {
dlog(0, "error caused VG_MINIMAL_LONGJMP to server_main\n");
}
while (1) {
unsigned char sig;
int packet_len;
int new_packet_len = -1;
if (resume_reply_packet_needed) {
/* Send the resume reply to reply to last GDB resume
request. */
resume_reply_packet_needed = False;
prepare_resume_reply (own_buf, status, zignal);
putpkt (own_buf);
}
/* If we our status is terminal (exit or fatal signal) get out
as quickly as we can. We won't be able to handle any request
anymore. */
if (status == 'W' || status == 'X') {
return;
}
packet_len = getpkt (own_buf);
if (packet_len <= 0)
break;
i = 0;
ch = own_buf[i++];
switch (ch) {
case 'Q':
handle_set (own_buf, &new_packet_len);
break;
case 'q':
handle_query (own_buf, &new_packet_len);
break;
case 'd':
/* set/unset debugging is done through valgrind debug level. */
own_buf[0] = '\0';
break;
case 'D':
reset_valgrind_sink("gdb detaching from process");
/* When detaching or kill the process, gdb expects to get
an packet OK back. Any other output will make gdb
believes detach did not work. */
write_ok (own_buf);
putpkt (own_buf);
remote_finish (reset_after_error);
remote_open (VG_(clo_vgdb_prefix));
myresume (0, 0);
resume_reply_packet_needed = False;
return;
case '!':
/* We can not use the extended protocol with valgrind,
because we can not restart the running
program. So return unrecognized. */
own_buf[0] = '\0';
break;
case '?':
prepare_resume_reply (own_buf, status, zignal);
break;
case 'H':
if (own_buf[1] == 'c' || own_buf[1] == 'g' || own_buf[1] == 's') {
unsigned long gdb_id, thread_id;
gdb_id = strtoul (&own_buf[2], NULL, 16);
thread_id = gdb_id_to_thread_id (gdb_id);
if (thread_id == 0) {
write_enn (own_buf);
break;
}
if (own_buf[1] == 'g') {
general_thread = thread_id;
set_desired_inferior (1);
} else if (own_buf[1] == 'c') {
cont_thread = thread_id;
} else if (own_buf[1] == 's') {
step_thread = thread_id;
}
write_ok (own_buf);
} else {
/* Silently ignore it so that gdb can extend the protocol
without compatibility headaches. */
own_buf[0] = '\0';
}
break;
case 'g':
set_desired_inferior (1);
registers_to_string (own_buf);
break;
case 'G':
set_desired_inferior (1);
registers_from_string (&own_buf[1]);
write_ok (own_buf);
break;
case 'P': {
int regno;
char *regbytes;
Bool mod;
ThreadState *tst;
regno = strtol(&own_buf[1], NULL, 16);
regbytes = strchr(&own_buf[0], '=') + 1;
set_desired_inferior (1);
tst = (ThreadState *) inferior_target_data (current_inferior);
/* Only accept changing registers in "runnable state3.
In fact, it would be ok to change most of the registers
except a few "sensitive" registers such as the PC, SP, BP.
We assume we do not need to very specific here, and that we
can just refuse all of these. */
if (tst->status == VgTs_Runnable || tst->status == VgTs_Yielding) {
supply_register_from_string (regno, regbytes, &mod);
write_ok (own_buf);
} else {
/* at least from gdb 6.6 onwards, an E. error
reply is shown to the user. So, we do an error
msg which both is accepted by gdb as an error msg
and is readable by the user. */
VG_(sprintf)
(own_buf,
"E.\n"
"ERROR changing register %s regno %d\n"
"gdb commands changing registers (pc, sp, ...) (e.g. 'jump',\n"
"set pc, calling from gdb a function in the debugged process, ...)\n"
"can only be accepted if the thread is VgTs_Runnable or VgTs_Yielding state\n"
"Thread status is %s\n",
find_register_by_number (regno)->name, regno,
VG_(name_of_ThreadStatus)(tst->status));
if (VG_(clo_verbosity) > 1)
VG_(umsg) ("%s\n", own_buf);
}
break;
}
case 'm':
decode_m_packet (&own_buf[1], &mem_addr, &len);
if (valgrind_read_memory (mem_addr, mem_buf, len) == 0)
convert_int_to_ascii (mem_buf, own_buf, len);
else
write_enn (own_buf);
break;
case 'M':
decode_M_packet (&own_buf[1], &mem_addr, &len, mem_buf);
if (valgrind_write_memory (mem_addr, mem_buf, len) == 0)
write_ok (own_buf);
else
write_enn (own_buf);
break;
case 'X':
if (decode_X_packet (&own_buf[1], packet_len - 1,
&mem_addr, &len, mem_buf) < 0
|| valgrind_write_memory (mem_addr, mem_buf, len) != 0)
write_enn (own_buf);
else
write_ok (own_buf);
break;
case 'C':
convert_ascii_to_int (own_buf + 1, &sig, 1);
if (target_signal_to_host_p (sig))
zignal = target_signal_to_host (sig);
else
zignal = 0;
set_desired_inferior (0);
myresume (0, zignal);
return; // return control to valgrind
case 'S':
convert_ascii_to_int (own_buf + 1, &sig, 1);
if (target_signal_to_host_p (sig))
zignal = target_signal_to_host (sig);
else
zignal = 0;
set_desired_inferior (0);
myresume (1, zignal);
return; // return control to valgrind
case 'c':
set_desired_inferior (0);
myresume (0, 0);
return; // return control to valgrind
case 's':
set_desired_inferior (0);
myresume (1, 0);
return; // return control to valgrind
case 'Z': {
char *lenptr;
char *dataptr;
CORE_ADDR addr = strtoul (&own_buf[3], &lenptr, 16);
int zlen = strtol (lenptr + 1, &dataptr, 16);
char type = own_buf[1];
if (type < '0' || type > '4') {
/* Watchpoint command type unrecognized. */
own_buf[0] = '\0';
} else {
int res;
res = valgrind_insert_watchpoint (type, addr, zlen);
if (res == 0)
write_ok (own_buf);
else if (res == 1)
/* Unsupported. */
own_buf[0] = '\0';
else
write_enn (own_buf);
}
break;
}
case 'z': {
char *lenptr;
char *dataptr;
CORE_ADDR addr = strtoul (&own_buf[3], &lenptr, 16);
int zlen = strtol (lenptr + 1, &dataptr, 16);
char type = own_buf[1];
if (type < '0' || type > '4') {
/* Watchpoint command type unrecognized. */
own_buf[0] = '\0';
} else {
int res;
res = valgrind_remove_watchpoint (type, addr, zlen);
if (res == 0)
write_ok (own_buf);
else if (res == 1)
/* Unsupported. */
own_buf[0] = '\0';
else
write_enn (own_buf);
}
break;
}
case 'k':
kill_request("Gdb request to kill this process\n");
break;
case 'T': {
unsigned long gdb_id, thread_id;
gdb_id = strtoul (&own_buf[1], NULL, 16);
thread_id = gdb_id_to_thread_id (gdb_id);
if (thread_id == 0) {
write_enn (own_buf);
break;
}
if (valgrind_thread_alive (thread_id))
write_ok (own_buf);
else
write_enn (own_buf);
break;
}
case 'R':
/* Restarting the inferior is only supported in the
extended protocol.
=> It is a request we don't understand. Respond with an
empty packet so that gdb knows that we don't support this
request. */
own_buf[0] = '\0';
break;
case 'v':
/* Extended (long) request. */
handle_v_requests (own_buf, &status, &zignal);
break;
default:
/* It is a request we don't understand. Respond with an
empty packet so that gdb knows that we don't support this
request. */
own_buf[0] = '\0';
break;
}
if (new_packet_len != -1)
putpkt_binary (own_buf, new_packet_len);
else
putpkt (own_buf);
if (status == 'W')
VG_(umsg) ("\nChild exited with status %d\n", zignal);
if (status == 'X')
VG_(umsg) ("\nChild terminated with signal = 0x%x (%s)\n",
target_signal_to_host (zignal),
target_signal_to_name (zignal));
if (status == 'W' || status == 'X') {
VG_(umsg) ("Process exiting\n");
VG_(exit) (0);
}
}
/* We come here when getpkt fails => close the connection,
and re-open. Then return control to valgrind.
We return the control to valgrind as we assume that
the connection was closed due to vgdb having finished
to execute a command. */
if (VG_(clo_verbosity) > 1)
VG_(umsg) ("Remote side has terminated connection. "
"GDBserver will reopen the connection.\n");
remote_finish (reset_after_error);
remote_open (VG_(clo_vgdb_prefix));
myresume (0, 0);
resume_reply_packet_needed = False;
return;
}
int
main (int argc, char *argv[])
{
char ch, status, *own_buf, mem_buf[2000];
int i = 0;
unsigned char signal;
unsigned int len;
CORE_ADDR mem_addr;
int bad_attach;
int pid;
char *arg_end;
if (setjmp (toplevel))
{
fprintf (stderr, "Exiting\n");
exit (1);
}
bad_attach = 0;
pid = 0;
attached = 0;
if (argc >= 3 && strcmp (argv[2], "--attach") == 0)
{
if (argc == 4
&& argv[3] != '\0'
&& (pid = strtoul (argv[3], &arg_end, 10)) != 0
&& *arg_end == '\0')
{
;
}
else
bad_attach = 1;
}
if (argc < 3 || bad_attach)
gdbserver_usage();
initialize_low ();
own_buf = malloc (PBUFSIZ);
if (pid == 0)
{
/* Wait till we are at first instruction in program. */
signal = start_inferior (&argv[2], &status);
/* We are now stopped at the first instruction of the target process */
}
else
{
switch (attach_inferior (pid, &status, &signal))
{
case -1:
error ("Attaching not supported on this target");
break;
default:
attached = 1;
break;
}
}
while (1)
{
remote_open (argv[1]);
restart:
setjmp (toplevel);
while (getpkt (own_buf) > 0)
{
unsigned char sig;
i = 0;
ch = own_buf[i++];
switch (ch)
{
case 'q':
handle_query (own_buf);
break;
case 'd':
remote_debug = !remote_debug;
break;
case 'D':
fprintf (stderr, "Detaching from inferior\n");
detach_inferior ();
write_ok (own_buf);
putpkt (own_buf);
remote_close ();
/* If we are attached, then we can exit. Otherwise, we need to
hang around doing nothing, until the child is gone. */
if (!attached)
{
int status, ret;
do {
ret = waitpid (signal_pid, &status, 0);
if (WIFEXITED (status) || WIFSIGNALED (status))
break;
} while (ret != -1 || errno != ECHILD);
}
exit (0);
case '!':
if (attached == 0)
{
extended_protocol = 1;
prepare_resume_reply (own_buf, status, signal);
}
else
{
/* We can not use the extended protocol if we are
attached, because we can not restart the running
program. So return unrecognized. */
own_buf[0] = '\0';
}
break;
case '?':
prepare_resume_reply (own_buf, status, signal);
break;
case 'H':
switch (own_buf[1])
{
case 'g':
general_thread = strtol (&own_buf[2], NULL, 16);
write_ok (own_buf);
set_desired_inferior (1);
break;
case 'c':
cont_thread = strtol (&own_buf[2], NULL, 16);
write_ok (own_buf);
break;
case 's':
step_thread = strtol (&own_buf[2], NULL, 16);
write_ok (own_buf);
break;
default:
/* Silently ignore it so that gdb can extend the protocol
without compatibility headaches. */
own_buf[0] = '\0';
break;
}
break;
case 'g':
set_desired_inferior (1);
registers_to_string (own_buf);
break;
case 'G':
set_desired_inferior (1);
registers_from_string (&own_buf[1]);
write_ok (own_buf);
break;
case 'm':
decode_m_packet (&own_buf[1], &mem_addr, &len);
if (read_inferior_memory (mem_addr, mem_buf, len) == 0)
convert_int_to_ascii (mem_buf, own_buf, len);
else
write_enn (own_buf);
break;
case 'M':
decode_M_packet (&own_buf[1], &mem_addr, &len, mem_buf);
if (write_inferior_memory (mem_addr, mem_buf, len) == 0)
write_ok (own_buf);
else
write_enn (own_buf);
break;
case 'C':
convert_ascii_to_int (own_buf + 1, &sig, 1);
if (target_signal_to_host_p (sig))
signal = target_signal_to_host (sig);
else
signal = 0;
set_desired_inferior (0);
myresume (0, signal);
signal = mywait (&status, 1);
prepare_resume_reply (own_buf, status, signal);
break;
case 'S':
convert_ascii_to_int (own_buf + 1, &sig, 1);
if (target_signal_to_host_p (sig))
signal = target_signal_to_host (sig);
else
signal = 0;
set_desired_inferior (0);
myresume (1, signal);
signal = mywait (&status, 1);
prepare_resume_reply (own_buf, status, signal);
break;
case 'c':
set_desired_inferior (0);
myresume (0, 0);
signal = mywait (&status, 1);
prepare_resume_reply (own_buf, status, signal);
break;
case 's':
set_desired_inferior (0);
myresume (1, 0);
signal = mywait (&status, 1);
prepare_resume_reply (own_buf, status, signal);
break;
case 'k':
fprintf (stderr, "Killing inferior\n");
kill_inferior ();
/* When using the extended protocol, we start up a new
debugging session. The traditional protocol will
exit instead. */
if (extended_protocol)
{
write_ok (own_buf);
fprintf (stderr, "GDBserver restarting\n");
/* Wait till we are at 1st instruction in prog. */
signal = start_inferior (&argv[2], &status);
goto restart;
break;
}
else
{
exit (0);
break;
}
case 'T':
if (mythread_alive (strtol (&own_buf[1], NULL, 16)))
write_ok (own_buf);
else
write_enn (own_buf);
break;
case 'R':
/* Restarting the inferior is only supported in the
extended protocol. */
if (extended_protocol)
{
kill_inferior ();
write_ok (own_buf);
fprintf (stderr, "GDBserver restarting\n");
/* Wait till we are at 1st instruction in prog. */
signal = start_inferior (&argv[2], &status);
goto restart;
break;
}
else
{
/* It is a request we don't understand. Respond with an
empty packet so that gdb knows that we don't support this
request. */
own_buf[0] = '\0';
break;
}
case 'v':
/* Extended (long) request. */
handle_v_requests (own_buf, &status, &signal);
break;
default:
/* It is a request we don't understand. Respond with an
empty packet so that gdb knows that we don't support this
request. */
own_buf[0] = '\0';
break;
}
putpkt (own_buf);
if (status == 'W')
fprintf (stderr,
"\nChild exited with status %d\n", signal);
if (status == 'X')
fprintf (stderr, "\nChild terminated with signal = 0x%x\n",
signal);
if (status == 'W' || status == 'X')
{
if (extended_protocol)
{
fprintf (stderr, "Killing inferior\n");
kill_inferior ();
write_ok (own_buf);
fprintf (stderr, "GDBserver restarting\n");
/* Wait till we are at 1st instruction in prog. */
signal = start_inferior (&argv[2], &status);
goto restart;
break;
}
else
{
fprintf (stderr, "GDBserver exiting\n");
exit (0);
}
}
}
/* We come here when getpkt fails.
For the extended remote protocol we exit (and this is the only
way we gracefully exit!).
For the traditional remote protocol close the connection,
and re-open it at the top of the loop. */
if (extended_protocol)
{
remote_close ();
exit (0);
}
else
{
fprintf (stderr, "Remote side has terminated connection. "
"GDBserver will reopen the connection.\n");
remote_close ();
}
}
}
int
main (int argc, char *argv[])
{
char ch, status, *own_buf;
unsigned char *mem_buf;
int i = 0;
int signal;
unsigned int len;
CORE_ADDR mem_addr;
int bad_attach;
int pid;
char *arg_end;
my_stdout = stdout;
my_stderr = stderr;
myname = argv[0];
if (argc >= 2 && strcmp (argv[1], "--version") == 0)
{
gdbserver_version ();
exit (0);
}
if (argc >= 2 && strcmp (argv[1], "--help") == 0)
{
gdbserver_usage ();
exit (0);
}
if (setjmp (toplevel))
{
warning ("Exiting");
exit (1);
}
bad_attach = 0;
pid = 0;
attached = 0;
if (argc >= 3 && strcmp (argv[2], "--attach") == 0)
{
if (argc == 4
&& argv[3][0] != '\0'
&& (pid = strtoul (argv[3], &arg_end, 10)) != 0
&& *arg_end == '\0')
{
;
}
else
bad_attach = 1;
}
if (argc < 3 || bad_attach)
{
gdbserver_usage ();
exit (1);
}
if (strcmp (argv[1], "pipe") == 0)
{
my_stdout = my_stderr = stderr;
}
initialize_low ();
own_buf = malloc (PBUFSIZ + 1);
mem_buf = malloc (PBUFSIZ);
if (pid == 0)
{
/* Wait till we are at first instruction in program. */
signal = start_inferior (&argv[2], &status);
/* We are now (hopefully) stopped at the first instruction of
the target process. This assumes that the target process was
successfully created. */
/* Don't report shared library events on the initial connection,
even if some libraries are preloaded. */
dlls_changed = 0;
}
else
{
switch (attach_inferior (pid, &status, &signal))
{
case -1:
error ("Attaching not supported on this target");
break;
default:
attached = 1;
break;
}
}
if (setjmp (toplevel))
{
warning ("Killing inferior");
kill_inferior ();
exit (1);
}
if (status == 'W' || status == 'X')
{
warning ("No inferior, GDBserver exiting.");
exit (1);
}
while (1)
{
remote_open (argv[1]);
restart:
if (setjmp (toplevel))
{
if (remote_debug)
printf_filtered ("gdbserver: error returned to main loop\n");
write_enn (own_buf);
putpkt (own_buf);
}
while (1)
{
unsigned char sig;
int packet_len;
int new_packet_len = -1;
packet_len = getpkt (own_buf, PBUFSIZ);
if (packet_len <= 0)
break;
i = 0;
ch = own_buf[i++];
switch (ch)
{
case 'q':
handle_query (own_buf, packet_len, &new_packet_len);
break;
case 'Q':
handle_general_set (own_buf);
break;
case 'D':
warning ("Detaching from inferior");
if (detach_inferior () != 0)
{
write_enn (own_buf);
putpkt (own_buf);
}
else
{
write_ok (own_buf);
putpkt (own_buf);
remote_close ();
/* If we are attached, then we can exit. Otherwise, we
need to hang around doing nothing, until the child
is gone. */
if (!attached)
join_inferior ();
exit (0);
}
case '!':
if (attached == 0)
{
extended_protocol = 1;
prepare_resume_reply (own_buf, status, signal);
}
else
{
/* We can not use the extended protocol if we are
attached, because we can not restart the running
program. So return unrecognized. */
own_buf[0] = '\0';
}
break;
case '?':
prepare_resume_reply (own_buf, status, signal);
break;
case 'H':
if (own_buf[1] == 'c' || own_buf[1] == 'g' || own_buf[1] == 's')
{
unsigned long gdb_id, thread_id;
gdb_id = strtoul (&own_buf[2], NULL, 16);
thread_id = gdb_id_to_thread_id (gdb_id);
if (thread_id == 0)
{
write_enn (own_buf);
break;
}
if (own_buf[1] == 'g')
{
general_thread = thread_id;
set_desired_inferior (1);
}
else if (own_buf[1] == 'c')
cont_thread = thread_id;
else if (own_buf[1] == 's')
step_thread = thread_id;
write_ok (own_buf);
}
else
{
/* Silently ignore it so that gdb can extend the protocol
without compatibility headaches. */
own_buf[0] = '\0';
}
break;
case 'g':
set_desired_inferior (1);
registers_to_string (own_buf);
break;
case 'G':
set_desired_inferior (1);
registers_from_string (&own_buf[1]);
write_ok (own_buf);
break;
case 'm':
decode_m_packet (&own_buf[1], &mem_addr, &len);
if (read_inferior_memory (mem_addr, mem_buf, len) == 0)
convert_int_to_ascii (mem_buf, own_buf, len);
else
write_enn (own_buf);
break;
case 'M':
decode_M_packet (&own_buf[1], &mem_addr, &len, mem_buf);
if (write_inferior_memory (mem_addr, mem_buf, len) == 0)
write_ok (own_buf);
else
write_enn (own_buf);
break;
case 'X':
if (decode_X_packet (&own_buf[1], packet_len - 1,
&mem_addr, &len, mem_buf) < 0
|| write_inferior_memory (mem_addr, mem_buf, len) != 0)
write_enn (own_buf);
else
write_ok (own_buf);
break;
case 'C':
convert_ascii_to_int (own_buf + 1, &sig, 1);
if (target_signal_to_host_p (sig))
signal = target_signal_to_host (sig);
else
signal = 0;
set_desired_inferior (0);
myresume (0, signal);
signal = mywait (&status, 1);
prepare_resume_reply (own_buf, status, signal);
break;
case 'S':
convert_ascii_to_int (own_buf + 1, &sig, 1);
if (target_signal_to_host_p (sig))
signal = target_signal_to_host (sig);
else
signal = 0;
set_desired_inferior (0);
myresume (1, signal);
signal = mywait (&status, 1);
prepare_resume_reply (own_buf, status, signal);
break;
case 'c':
set_desired_inferior (0);
myresume (0, 0);
signal = mywait (&status, 1);
prepare_resume_reply (own_buf, status, signal);
break;
case 's':
set_desired_inferior (0);
myresume (1, 0);
signal = mywait (&status, 1);
prepare_resume_reply (own_buf, status, signal);
break;
case 'z':
case 'Z':
{
char *lenptr;
char *dataptr;
CORE_ADDR addr = strtoul (&own_buf[3], &lenptr, 16);
int len = strtol (lenptr + 1, &dataptr, 16);
char type = own_buf[1];
if (the_target->insert_watchpoint == NULL
|| the_target->remove_watchpoint == NULL
|| (type < '0' || type > '4'))
{
/* No watchpoint support or not a watchpoint command;
unrecognized either way. */
own_buf[0] = '\0';
}
else
{
int res;
if (ch == 'z')
res = (*the_target->remove_watchpoint) (type, addr, len);
else
res = (*the_target->insert_watchpoint) (type, addr, len);
if (res == 0)
write_ok (own_buf);
else if (res == 1)
/* Unsupported. */
own_buf[0] = '\0';
else
write_enn (own_buf);
}
break;
}
case 'k':
warning ("Killing inferior");
kill_inferior ();
/* When using the extended protocol, we start up a new
debugging session. The traditional protocol will
exit instead. */
if (extended_protocol)
{
write_ok (own_buf);
warning ("GDBserver restarting");
/* Wait till we are at 1st instruction in prog. */
signal = start_inferior (&argv[2], &status);
goto restart;
break;
}
else
{
exit (0);
break;
}
case 'T':
{
unsigned long gdb_id, thread_id;
gdb_id = strtoul (&own_buf[1], NULL, 16);
thread_id = gdb_id_to_thread_id (gdb_id);
if (thread_id == 0)
{
write_enn (own_buf);
break;
}
if (mythread_alive (thread_id))
write_ok (own_buf);
else
write_enn (own_buf);
}
break;
case 'R':
/* Restarting the inferior is only supported in the
extended protocol. */
if (extended_protocol)
{
kill_inferior ();
write_ok (own_buf);
warning ("GDBserver restarting");
/* Wait till we are at 1st instruction in prog. */
signal = start_inferior (&argv[2], &status);
goto restart;
break;
}
else
{
/* It is a request we don't understand. Respond with an
empty packet so that gdb knows that we don't support this
request. */
own_buf[0] = '\0';
break;
}
case 'v':
/* Extended (long) request. */
handle_v_requests (own_buf, &status, &signal);
break;
default:
/* It is a request we don't understand. Respond with an
empty packet so that gdb knows that we don't support this
request. */
own_buf[0] = '\0';
break;
}
if (new_packet_len != -1)
putpkt_binary (own_buf, new_packet_len);
else
putpkt (own_buf);
if (status == 'W')
warning ("\nChild exited with status %d", signal);
if (status == 'X')
warning ("\nChild terminated with signal = 0x%x (%s)",
target_signal_to_host (signal),
target_signal_to_name (signal));
if (status == 'W' || status == 'X')
{
if (extended_protocol)
{
warning ("Killing inferior");
kill_inferior ();
write_ok (own_buf);
warning ("GDBserver restarting");
/* Wait till we are at 1st instruction in prog. */
signal = start_inferior (&argv[2], &status);
goto restart;
break;
}
else
{
warning ("GDBserver exiting");
exit (0);
}
}
}
/* We come here when getpkt fails.
For the extended remote protocol we exit (and this is the only
way we gracefully exit!).
For the traditional remote protocol close the connection,
and re-open it at the top of the loop. */
if (extended_protocol)
{
remote_close ();
exit (0);
}
else
{
warning ("Remote side has terminated connection. "
"GDBserver will reopen the connection.");
remote_close ();
}
}
}
int
main (int argc, char *argv[])
{
char ch, status, *own_buf;
unsigned char *mem_buf;
int i = 0;
int signal;
unsigned int len;
CORE_ADDR mem_addr;
int bad_attach;
int pid;
char *arg_end, *port;
char **next_arg = &argv[1];
int multi_mode = 0;
int attach = 0;
int was_running;
while (*next_arg != NULL && **next_arg == '-')
{
if (strcmp (*next_arg, "--version") == 0)
{
gdbserver_version ();
exit (0);
}
else if (strcmp (*next_arg, "--help") == 0)
{
gdbserver_usage (stdout);
exit (0);
}
else if (strcmp (*next_arg, "--attach") == 0)
attach = 1;
else if (strcmp (*next_arg, "--multi") == 0)
multi_mode = 1;
else if (strcmp (*next_arg, "--wrapper") == 0)
{
next_arg++;
wrapper_argv = next_arg;
while (*next_arg != NULL && strcmp (*next_arg, "--") != 0)
next_arg++;
if (next_arg == wrapper_argv || *next_arg == NULL)
{
gdbserver_usage (stderr);
exit (1);
}
/* Consume the "--". */
*next_arg = NULL;
}
else if (strcmp (*next_arg, "--debug") == 0)
debug_threads = 1;
else if (strcmp (*next_arg, "--disable-packet") == 0)
{
gdbserver_show_disableable (stdout);
exit (0);
}
else if (strncmp (*next_arg,
"--disable-packet=",
sizeof ("--disable-packet=") - 1) == 0)
{
char *packets, *tok;
packets = *next_arg += sizeof ("--disable-packet=") - 1;
for (tok = strtok (packets, ",");
tok != NULL;
tok = strtok (NULL, ","))
{
if (strcmp ("vCont", tok) == 0)
disable_packet_vCont = 1;
else if (strcmp ("Tthread", tok) == 0)
disable_packet_Tthread = 1;
else if (strcmp ("qC", tok) == 0)
disable_packet_qC = 1;
else if (strcmp ("qfThreadInfo", tok) == 0)
disable_packet_qfThreadInfo = 1;
else if (strcmp ("threads", tok) == 0)
{
disable_packet_vCont = 1;
disable_packet_Tthread = 1;
disable_packet_qC = 1;
disable_packet_qfThreadInfo = 1;
}
else
{
fprintf (stderr, "Don't know how to disable \"%s\".\n\n",
tok);
gdbserver_show_disableable (stderr);
exit (1);
}
}
}
else
{
fprintf (stderr, "Unknown argument: %s\n", *next_arg);
exit (1);
}
next_arg++;
continue;
}
if (setjmp (toplevel))
{
fprintf (stderr, "Exiting\n");
exit (1);
}
port = *next_arg;
next_arg++;
if (port == NULL || (!attach && !multi_mode && *next_arg == NULL))
{
gdbserver_usage (stderr);
exit (1);
}
bad_attach = 0;
pid = 0;
/* --attach used to come after PORT, so allow it there for
compatibility. */
if (*next_arg != NULL && strcmp (*next_arg, "--attach") == 0)
{
attach = 1;
next_arg++;
}
if (attach
&& (*next_arg == NULL
|| (*next_arg)[0] == '\0'
|| (pid = strtoul (*next_arg, &arg_end, 0)) == 0
|| *arg_end != '\0'
|| next_arg[1] != NULL))
bad_attach = 1;
if (bad_attach)
{
gdbserver_usage (stderr);
exit (1);
}
initialize_async_io ();
initialize_low ();
own_buf = malloc (PBUFSIZ + 1);
mem_buf = malloc (PBUFSIZ);
if (pid == 0 && *next_arg != NULL)
{
int i, n;
n = argc - (next_arg - argv);
program_argv = malloc (sizeof (char *) * (n + 1));
for (i = 0; i < n; i++)
program_argv[i] = strdup (next_arg[i]);
program_argv[i] = NULL;
/* Wait till we are at first instruction in program. */
signal = start_inferior (program_argv, &status);
/* We are now (hopefully) stopped at the first instruction of
the target process. This assumes that the target process was
successfully created. */
}
else if (pid != 0)
{
if (attach_inferior (pid, &status, &signal) == -1)
error ("Attaching not supported on this target");
/* Otherwise succeeded. */
}
else
{
status = 'W';
signal = 0;
}
/* Don't report shared library events on the initial connection,
even if some libraries are preloaded. Avoids the "stopped by
shared library event" notice on gdb side. */
dlls_changed = 0;
if (setjmp (toplevel))
{
fprintf (stderr, "Killing inferior\n");
kill_inferior ();
exit (1);
}
if (status == 'W' || status == 'X')
was_running = 0;
else
was_running = 1;
if (!was_running && !multi_mode)
{
fprintf (stderr, "No program to debug. GDBserver exiting.\n");
exit (1);
}
while (1)
{
noack_mode = 0;
remote_open (port);
restart:
if (setjmp (toplevel) != 0)
{
/* An error occurred. */
if (response_needed)
{
write_enn (own_buf);
putpkt (own_buf);
}
}
disable_async_io ();
while (!exit_requested)
{
unsigned char sig;
int packet_len;
int new_packet_len = -1;
response_needed = 0;
packet_len = getpkt (own_buf);
if (packet_len <= 0)
break;
response_needed = 1;
i = 0;
ch = own_buf[i++];
switch (ch)
{
case 'q':
handle_query (own_buf, packet_len, &new_packet_len);
break;
case 'Q':
handle_general_set (own_buf);
break;
case 'D':
require_running (own_buf);
fprintf (stderr, "Detaching from inferior\n");
if (detach_inferior () != 0)
write_enn (own_buf);
else
{
write_ok (own_buf);
if (extended_protocol)
{
/* Treat this like a normal program exit. */
signal = 0;
status = 'W';
}
else
{
putpkt (own_buf);
remote_close ();
/* If we are attached, then we can exit. Otherwise, we
need to hang around doing nothing, until the child
is gone. */
if (!attached)
join_inferior ();
exit (0);
}
}
break;
case '!':
extended_protocol = 1;
write_ok (own_buf);
break;
case '?':
prepare_resume_reply (own_buf, status, signal);
break;
case 'H':
if (own_buf[1] == 'c' || own_buf[1] == 'g' || own_buf[1] == 's')
{
unsigned long gdb_id, thread_id;
require_running (own_buf);
gdb_id = strtoul (&own_buf[2], NULL, 16);
if (gdb_id == 0 || gdb_id == -1)
thread_id = gdb_id;
else
{
thread_id = gdb_id_to_thread_id (gdb_id);
if (thread_id == 0)
{
write_enn (own_buf);
break;
}
}
if (own_buf[1] == 'g')
{
general_thread = thread_id;
set_desired_inferior (1);
}
else if (own_buf[1] == 'c')
cont_thread = thread_id;
else if (own_buf[1] == 's')
step_thread = thread_id;
write_ok (own_buf);
}
else
{
/* Silently ignore it so that gdb can extend the protocol
without compatibility headaches. */
own_buf[0] = '\0';
}
break;
case 'g':
require_running (own_buf);
set_desired_inferior (1);
registers_to_string (own_buf);
break;
case 'G':
require_running (own_buf);
set_desired_inferior (1);
registers_from_string (&own_buf[1]);
write_ok (own_buf);
break;
case 'm':
require_running (own_buf);
decode_m_packet (&own_buf[1], &mem_addr, &len);
if (read_inferior_memory (mem_addr, mem_buf, len) == 0)
convert_int_to_ascii (mem_buf, own_buf, len);
else
write_enn (own_buf);
break;
case 'M':
require_running (own_buf);
decode_M_packet (&own_buf[1], &mem_addr, &len, mem_buf);
if (write_inferior_memory (mem_addr, mem_buf, len) == 0)
write_ok (own_buf);
else
write_enn (own_buf);
break;
case 'X':
require_running (own_buf);
if (decode_X_packet (&own_buf[1], packet_len - 1,
&mem_addr, &len, mem_buf) < 0
|| write_inferior_memory (mem_addr, mem_buf, len) != 0)
write_enn (own_buf);
else
write_ok (own_buf);
break;
case 'C':
require_running (own_buf);
convert_ascii_to_int (own_buf + 1, &sig, 1);
if (target_signal_to_host_p (sig))
signal = target_signal_to_host (sig);
else
signal = 0;
myresume (own_buf, 0, &signal, &status);
break;
case 'S':
require_running (own_buf);
convert_ascii_to_int (own_buf + 1, &sig, 1);
if (target_signal_to_host_p (sig))
signal = target_signal_to_host (sig);
else
signal = 0;
myresume (own_buf, 1, &signal, &status);
break;
case 'c':
require_running (own_buf);
signal = 0;
myresume (own_buf, 0, &signal, &status);
break;
case 's':
require_running (own_buf);
signal = 0;
myresume (own_buf, 1, &signal, &status);
break;
case 'Z':
{
char *lenptr;
char *dataptr;
CORE_ADDR addr = strtoul (&own_buf[3], &lenptr, 16);
int len = strtol (lenptr + 1, &dataptr, 16);
char type = own_buf[1];
if (the_target->insert_watchpoint == NULL
|| (type < '2' || type > '4'))
{
/* No watchpoint support or not a watchpoint command;
unrecognized either way. */
own_buf[0] = '\0';
}
else
{
int res;
require_running (own_buf);
res = (*the_target->insert_watchpoint) (type, addr, len);
if (res == 0)
write_ok (own_buf);
else if (res == 1)
/* Unsupported. */
own_buf[0] = '\0';
else
write_enn (own_buf);
}
break;
}
case 'z':
{
char *lenptr;
char *dataptr;
CORE_ADDR addr = strtoul (&own_buf[3], &lenptr, 16);
int len = strtol (lenptr + 1, &dataptr, 16);
char type = own_buf[1];
if (the_target->remove_watchpoint == NULL
|| (type < '2' || type > '4'))
{
/* No watchpoint support or not a watchpoint command;
unrecognized either way. */
own_buf[0] = '\0';
}
else
{
int res;
require_running (own_buf);
res = (*the_target->remove_watchpoint) (type, addr, len);
if (res == 0)
write_ok (own_buf);
else if (res == 1)
/* Unsupported. */
own_buf[0] = '\0';
else
write_enn (own_buf);
}
break;
}
case 'k':
response_needed = 0;
if (!target_running ())
/* The packet we received doesn't make sense - but we
can't reply to it, either. */
goto restart;
fprintf (stderr, "Killing inferior\n");
kill_inferior ();
/* When using the extended protocol, we wait with no
program running. The traditional protocol will exit
instead. */
if (extended_protocol)
{
status = 'X';
signal = TARGET_SIGNAL_KILL;
was_running = 0;
goto restart;
}
else
{
exit (0);
break;
}
case 'T':
{
unsigned long gdb_id, thread_id;
require_running (own_buf);
gdb_id = strtoul (&own_buf[1], NULL, 16);
thread_id = gdb_id_to_thread_id (gdb_id);
if (thread_id == 0)
{
write_enn (own_buf);
break;
}
if (mythread_alive (thread_id))
write_ok (own_buf);
else
write_enn (own_buf);
}
break;
case 'R':
response_needed = 0;
/* Restarting the inferior is only supported in the
extended protocol. */
if (extended_protocol)
{
if (target_running ())
kill_inferior ();
fprintf (stderr, "GDBserver restarting\n");
/* Wait till we are at 1st instruction in prog. */
if (program_argv != NULL)
signal = start_inferior (program_argv, &status);
else
{
status = 'X';
signal = TARGET_SIGNAL_KILL;
}
goto restart;
}
else
{
/* It is a request we don't understand. Respond with an
empty packet so that gdb knows that we don't support this
request. */
own_buf[0] = '\0';
break;
}
case 'v':
/* Extended (long) request. */
handle_v_requests (own_buf, &status, &signal,
packet_len, &new_packet_len);
break;
default:
/* It is a request we don't understand. Respond with an
empty packet so that gdb knows that we don't support this
request. */
own_buf[0] = '\0';
break;
}
if (new_packet_len != -1)
putpkt_binary (own_buf, new_packet_len);
else
putpkt (own_buf);
response_needed = 0;
if (was_running && (status == 'W' || status == 'X'))
{
was_running = 0;
if (status == 'W')
fprintf (stderr,
"\nChild exited with status %d\n", signal);
if (status == 'X')
fprintf (stderr, "\nChild terminated with signal = 0x%x (%s)\n",
target_signal_to_host (signal),
target_signal_to_name (signal));
if (extended_protocol)
goto restart;
else
{
fprintf (stderr, "GDBserver exiting\n");
exit (0);
}
}
if (status != 'W' && status != 'X')
was_running = 1;
}
/* If an exit was requested (using the "monitor exit" command),
terminate now. The only other way to get here is for
getpkt to fail; close the connection and reopen it at the
top of the loop. */
if (exit_requested)
{
remote_close ();
if (attached && target_running ())
detach_inferior ();
else if (target_running ())
kill_inferior ();
exit (0);
}
else
{
fprintf (stderr, "Remote side has terminated connection. "
"GDBserver will reopen the connection.\n");
remote_close ();
}
}
}
void
gdbserver_main (void)
{
CORE_ADDR mem_addr;
char *own_buf;
unsigned char *mem_buf;
int i = 0;
unsigned int len;
own_buf = malloc (PBUFSIZ + 1);
mem_buf = malloc (PBUFSIZ);
while (1)
{
remote_open (port);
restart:
#if 0
if (setjmp (toplevel) != 0)
{
/* An error occurred. */
if (response_needed)
{
write_enn (own_buf);
putpkt (own_buf);
}
}
#endif
disable_async_io ();
while (!exit_requested)
{
unsigned char sig;
int packet_len;
int new_packet_len = -1;
response_needed = 0;
packet_len = getpkt (own_buf);
if (packet_len <= 0)
break;
response_needed = 1;
i = 0;
ch = own_buf[i++];
switch (ch)
{
case 'q':
handle_query (own_buf, packet_len, &new_packet_len);
break;
case 'Q':
handle_general_set (own_buf);
break;
case 'D':
require_running (own_buf);
fprintf (stderr, "Detaching from inferior\n");
if (detach_inferior () != 0)
write_enn (own_buf);
else
{
write_ok (own_buf);
if (extended_protocol)
{
/* Treat this like a normal program exit. */
signal = 0;
status = 'W';
}
else
{
putpkt (own_buf);
remote_close ();
/* If we are attached, then we can exit. Otherwise, we
need to hang around doing nothing, until the child
is gone. */
if (!attached)
join_inferior ();
exit (0);
}
}
break;
case '!':
extended_protocol = 1;
write_ok (own_buf);
break;
case '?':
prepare_resume_reply (own_buf, status, signal);
break;
case 'H':
if (own_buf[1] == 'c' || own_buf[1] == 'g' || own_buf[1] == 's')
{
unsigned long gdb_id, thread_id;
require_running (own_buf);
gdb_id = strtoul (&own_buf[2], NULL, 16);
if (gdb_id == 0 || gdb_id == -1)
thread_id = gdb_id;
else
{
thread_id = gdb_id_to_thread_id (gdb_id);
if (thread_id == 0)
{
write_enn (own_buf);
break;
}
}
if (own_buf[1] == 'g')
{
general_thread = thread_id;
set_desired_inferior (1);
}
else if (own_buf[1] == 'c')
cont_thread = thread_id;
else if (own_buf[1] == 's')
step_thread = thread_id;
write_ok (own_buf);
}
else
{
/* Silently ignore it so that gdb can extend the protocol
without compatibility headaches. */
own_buf[0] = '\0';
}
break;
case 'g':
require_running (own_buf);
set_desired_inferior (1);
registers_to_string (own_buf);
break;
case 'G':
require_running (own_buf);
set_desired_inferior (1);
registers_from_string (&own_buf[1]);
write_ok (own_buf);
break;
case 'm':
require_running (own_buf);
decode_m_packet (&own_buf[1], &mem_addr, &len);
if (read_inferior_memory (mem_addr, mem_buf, len) == 0)
convert_int_to_ascii (mem_buf, own_buf, len);
else
write_enn (own_buf);
break;
case 'M':
require_running (own_buf);
decode_M_packet (&own_buf[1], &mem_addr, &len, mem_buf);
if (write_inferior_memory (mem_addr, mem_buf, len) == 0)
write_ok (own_buf);
else
write_enn (own_buf);
break;
case 'X':
require_running (own_buf);
if (decode_X_packet (&own_buf[1], packet_len - 1,
&mem_addr, &len, mem_buf) < 0
|| write_inferior_memory (mem_addr, mem_buf, len) != 0)
write_enn (own_buf);
else
write_ok (own_buf);
break;
case 'C':
require_running (own_buf);
convert_ascii_to_int (own_buf + 1, &sig, 1);
if (target_signal_to_host_p (sig))
signal = target_signal_to_host (sig);
else
signal = 0;
myresume (own_buf, 0, &signal, &status);
break;
case 'S':
require_running (own_buf);
convert_ascii_to_int (own_buf + 1, &sig, 1);
if (target_signal_to_host_p (sig))
signal = target_signal_to_host (sig);
else
signal = 0;
myresume (own_buf, 1, &signal, &status);
break;
case 'c':
require_running (own_buf);
signal = 0;
myresume (own_buf, 0, &signal, &status);
break;
case 's':
require_running (own_buf);
signal = 0;
myresume (own_buf, 1, &signal, &status);
break;
case 'Z':
{
char *lenptr;
char *dataptr;
CORE_ADDR addr = strtoul (&own_buf[3], &lenptr, 16);
int len = strtol (lenptr + 1, &dataptr, 16);
char type = own_buf[1];
if (the_target->insert_watchpoint == NULL
|| (type < '2' || type > '4'))
{
/* No watchpoint support or not a watchpoint command;
unrecognized either way. */
own_buf[0] = '\0';
}
else
{
int res;
require_running (own_buf);
res = (*the_target->insert_watchpoint) (type, addr, len);
if (res == 0)
write_ok (own_buf);
else if (res == 1)
/* Unsupported. */
own_buf[0] = '\0';
else
write_enn (own_buf);
}
break;
}
case 'z':
{
char *lenptr;
char *dataptr;
CORE_ADDR addr = strtoul (&own_buf[3], &lenptr, 16);
int len = strtol (lenptr + 1, &dataptr, 16);
char type = own_buf[1];
if (the_target->remove_watchpoint == NULL
|| (type < '2' || type > '4'))
{
/* No watchpoint support or not a watchpoint command;
unrecognized either way. */
own_buf[0] = '\0';
}
else
{
int res;
require_running (own_buf);
res = (*the_target->remove_watchpoint) (type, addr, len);
if (res == 0)
write_ok (own_buf);
else if (res == 1)
/* Unsupported. */
own_buf[0] = '\0';
else
write_enn (own_buf);
}
break;
}
case 'k':
response_needed = 0;
if (!target_running ())
/* The packet we received doesn't make sense - but we
can't reply to it, either. */
goto restart;
fprintf (stderr, "Killing inferior\n");
kill_inferior ();
/* When using the extended protocol, we wait with no
program running. The traditional protocol will exit
instead. */
if (extended_protocol)
{
status = 'X';
signal = TARGET_SIGNAL_KILL;
was_running = 0;
goto restart;
}
else
{
exit (0);
break;
}
case 'T':
{
unsigned long gdb_id, thread_id;
require_running (own_buf);
gdb_id = strtoul (&own_buf[1], NULL, 16);
thread_id = gdb_id_to_thread_id (gdb_id);
if (thread_id == 0)
{
write_enn (own_buf);
break;
}
if (mythread_alive (thread_id))
write_ok (own_buf);
else
write_enn (own_buf);
}
break;
case 'R':
response_needed = 0;
/* Restarting the inferior is only supported in the
extended protocol. */
if (extended_protocol)
{
if (target_running ())
kill_inferior ();
fprintf (stderr, "GDBserver restarting\n");
/* Wait till we are at 1st instruction in prog. */
if (program_argv != NULL)
signal = start_inferior (program_argv, &status);
else
{
status = 'X';
signal = TARGET_SIGNAL_KILL;
}
goto restart;
}
else
{
/* It is a request we don't understand. Respond with an
empty packet so that gdb knows that we don't support this
request. */
own_buf[0] = '\0';
break;
}
case 'v':
/* Extended (long) request. */
handle_v_requests (own_buf, &status, &signal,
packet_len, &new_packet_len);
break;
default:
/* It is a request we don't understand. Respond with an
empty packet so that gdb knows that we don't support this
request. */
own_buf[0] = '\0';
break;
}
if (new_packet_len != -1)
putpkt_binary (own_buf, new_packet_len);
else
putpkt (own_buf);
response_needed = 0;
if (was_running && (status == 'W' || status == 'X'))
{
was_running = 0;
if (status == 'W')
fprintf (stderr,
"\nChild exited with status %d\n", signal);
if (status == 'X')
fprintf (stderr, "\nChild terminated with signal = 0x%x (%s)\n",
target_signal_to_host (signal),
target_signal_to_name (signal));
if (extended_protocol)
goto restart;
else
{
fprintf (stderr, "GDBserver exiting\n");
exit (0);
}
}
if (status != 'W' && status != 'X')
was_running = 1;
}
/* If an exit was requested (using the "monitor exit" command),
terminate now. The only other way to get here is for
getpkt to fail; close the connection and reopen it at the
top of the loop. */
if (exit_requested)
{
remote_close ();
if (attached && target_running ())
detach_inferior ();
else if (target_running ())
kill_inferior ();
exit (0);
}
else
{
fprintf (stderr, "Remote side has terminated connection. "
"GDBserver will reopen the connection.\n");
remote_close ();
}
}
}
int
main (int argc, char *argv[])
{
char ch, status, *own_buf;
unsigned char *mem_buf;
int i = 0;
int signal;
unsigned int len;
CORE_ADDR mem_addr;
int bad_attach;
int pid;
char *arg_end;
if (argc >= 2 && strcmp (argv[1], "--version") == 0)
{
gdbserver_version ();
exit (0);
}
if (argc >= 2 && strcmp (argv[1], "--help") == 0)
{
gdbserver_usage ();
exit (0);
}
if (setjmp (toplevel))
{
fprintf (stderr, "Exiting\n");
exit (1);
}
bad_attach = 0;
pid = 0;
attached = 0;
if (argc >= 3 && strcmp (argv[2], "--attach") == 0)
{
if (argc == 4
&& argv[3] != '\0'
&& (pid = strtoul (argv[3], &arg_end, 10)) != 0
&& *arg_end == '\0')
{
;
}
else
bad_attach = 1;
}
if (argc < 3 || bad_attach)
{
gdbserver_usage ();
exit (1);
}
initialize_low ();
own_buf = malloc (PBUFSIZ);
mem_buf = malloc (PBUFSIZ);
if (pid == 0)
{
/* Wait till we are at first instruction in program. */
signal = start_inferior (&argv[2], &status);
/* start_inferior() returns an integer, but the wait
* function returns an unsigned char. in the case of
* of an error, the wait returns -1 which means 255. */
if (status == 'W' || status == 'X')
{
fprintf (stderr, "Aborting server; child exited with %i\n", signal);
exit (signal);
}
/* We are now stopped at the first instruction of the target process */
}
else
{
switch (attach_inferior (pid, &status, &signal))
{
case -1:
error ("Attaching not supported on this target");
break;
default:
attached = 1;
break;
}
}
while (1)
{
remote_open (argv[1]);
restart:
setjmp (toplevel);
while (1)
{
unsigned char sig;
int packet_len;
int new_packet_len = -1;
packet_len = getpkt (own_buf);
if (packet_len <= 0)
break;
i = 0;
ch = own_buf[i++];
switch (ch)
{
case 'q':
handle_query (own_buf, &new_packet_len);
break;
case 'd':
remote_debug = !remote_debug;
break;
#ifndef USE_WIN32API
/* Skip "detach" support on mingw32, since we don't have
waitpid. */
case 'D':
fprintf (stderr, "Detaching from inferior\n");
detach_inferior ();
write_ok (own_buf);
putpkt (own_buf);
remote_close ();
/* If we are attached, then we can exit. Otherwise, we need to
hang around doing nothing, until the child is gone. */
if (!attached)
{
int status, ret;
do {
ret = waitpid (signal_pid, &status, 0);
if (WIFEXITED (status) || WIFSIGNALED (status))
break;
} while (ret != -1 || errno != ECHILD);
}
exit (0);
#endif
case '!':
if (attached == 0)
{
extended_protocol = 1;
prepare_resume_reply (own_buf, status, signal);
}
else
{
/* We can not use the extended protocol if we are
attached, because we can not restart the running
program. So return unrecognized. */
own_buf[0] = '\0';
}
break;
case '?':
prepare_resume_reply (own_buf, status, signal);
break;
case 'H':
if (own_buf[1] == 'c' || own_buf[1] == 'g' || own_buf[1] == 's')
{
unsigned long gdb_id, thread_id;
gdb_id = strtoul (&own_buf[2], NULL, 16);
thread_id = gdb_id_to_thread_id (gdb_id);
if (thread_id == 0)
{
write_enn (own_buf);
break;
}
if (own_buf[1] == 'g')
{
general_thread = thread_id;
set_desired_inferior (1);
}
else if (own_buf[1] == 'c')
cont_thread = thread_id;
else if (own_buf[1] == 's')
step_thread = thread_id;
write_ok (own_buf);
}
else
{
/* Silently ignore it so that gdb can extend the protocol
without compatibility headaches. */
own_buf[0] = '\0';
}
break;
case 'g':
set_desired_inferior (1);
registers_to_string (own_buf);
break;
case 'G':
set_desired_inferior (1);
registers_from_string (&own_buf[1]);
write_ok (own_buf);
break;
case 'm':
decode_m_packet (&own_buf[1], &mem_addr, &len);
if (read_inferior_memory (mem_addr, mem_buf, len) == 0)
convert_int_to_ascii (mem_buf, own_buf, len);
else
write_enn (own_buf);
break;
case 'M':
decode_M_packet (&own_buf[1], &mem_addr, &len, mem_buf);
if (write_inferior_memory (mem_addr, mem_buf, len) == 0)
write_ok (own_buf);
else
write_enn (own_buf);
break;
case 'X':
if (decode_X_packet (&own_buf[1], packet_len - 1,
&mem_addr, &len, mem_buf) < 0
|| write_inferior_memory (mem_addr, mem_buf, len) != 0)
write_enn (own_buf);
else
write_ok (own_buf);
break;
case 'C':
convert_ascii_to_int (own_buf + 1, &sig, 1);
if (target_signal_to_host_p (sig))
signal = target_signal_to_host (sig);
else
signal = 0;
set_desired_inferior (0);
myresume (0, signal);
signal = mywait (&status, 1);
prepare_resume_reply (own_buf, status, signal);
break;
case 'S':
convert_ascii_to_int (own_buf + 1, &sig, 1);
if (target_signal_to_host_p (sig))
signal = target_signal_to_host (sig);
else
signal = 0;
set_desired_inferior (0);
myresume (1, signal);
signal = mywait (&status, 1);
prepare_resume_reply (own_buf, status, signal);
break;
case 'c':
set_desired_inferior (0);
myresume (0, 0);
signal = mywait (&status, 1);
prepare_resume_reply (own_buf, status, signal);
break;
case 's':
set_desired_inferior (0);
myresume (1, 0);
signal = mywait (&status, 1);
prepare_resume_reply (own_buf, status, signal);
break;
case 'Z':
{
char *lenptr;
char *dataptr;
CORE_ADDR addr = strtoul (&own_buf[3], &lenptr, 16);
int len = strtol (lenptr + 1, &dataptr, 16);
char type = own_buf[1];
if (the_target->insert_watchpoint == NULL
|| (type < '2' || type > '4'))
{
/* No watchpoint support or not a watchpoint command;
unrecognized either way. */
own_buf[0] = '\0';
}
else
{
int res;
res = (*the_target->insert_watchpoint) (type, addr, len);
if (res == 0)
write_ok (own_buf);
else if (res == 1)
/* Unsupported. */
own_buf[0] = '\0';
else
write_enn (own_buf);
}
break;
}
case 'z':
{
char *lenptr;
char *dataptr;
CORE_ADDR addr = strtoul (&own_buf[3], &lenptr, 16);
int len = strtol (lenptr + 1, &dataptr, 16);
char type = own_buf[1];
if (the_target->remove_watchpoint == NULL
|| (type < '2' || type > '4'))
{
/* No watchpoint support or not a watchpoint command;
unrecognized either way. */
own_buf[0] = '\0';
}
else
{
int res;
res = (*the_target->remove_watchpoint) (type, addr, len);
if (res == 0)
write_ok (own_buf);
else if (res == 1)
/* Unsupported. */
own_buf[0] = '\0';
else
write_enn (own_buf);
}
break;
}
case 'k':
fprintf (stderr, "Killing inferior\n");
kill_inferior ();
/* When using the extended protocol, we start up a new
debugging session. The traditional protocol will
exit instead. */
if (extended_protocol)
{
write_ok (own_buf);
fprintf (stderr, "GDBserver restarting\n");
/* Wait till we are at 1st instruction in prog. */
signal = start_inferior (&argv[2], &status);
goto restart;
break;
}
else
{
exit (0);
break;
}
case 'T':
{
unsigned long gdb_id, thread_id;
gdb_id = strtoul (&own_buf[1], NULL, 16);
thread_id = gdb_id_to_thread_id (gdb_id);
if (thread_id == 0)
{
write_enn (own_buf);
break;
}
if (mythread_alive (thread_id))
write_ok (own_buf);
else
write_enn (own_buf);
}
break;
case 'R':
/* Restarting the inferior is only supported in the
extended protocol. */
if (extended_protocol)
{
kill_inferior ();
write_ok (own_buf);
fprintf (stderr, "GDBserver restarting\n");
/* Wait till we are at 1st instruction in prog. */
signal = start_inferior (&argv[2], &status);
goto restart;
break;
}
else
{
/* It is a request we don't understand. Respond with an
empty packet so that gdb knows that we don't support this
request. */
own_buf[0] = '\0';
break;
}
case 'v':
/* Extended (long) request. */
handle_v_requests (own_buf, &status, &signal);
break;
default:
/* It is a request we don't understand. Respond with an
empty packet so that gdb knows that we don't support this
request. */
own_buf[0] = '\0';
break;
}
if (new_packet_len != -1)
putpkt_binary (own_buf, new_packet_len);
else
putpkt (own_buf);
if (status == 'W')
fprintf (stderr,
"\nChild exited with status %d\n", signal);
if (status == 'X')
fprintf (stderr, "\nChild terminated with signal = 0x%x (%s)\n",
target_signal_to_host (signal),
target_signal_to_name (signal));
if (status == 'W' || status == 'X')
{
if (extended_protocol)
{
fprintf (stderr, "Killing inferior\n");
kill_inferior ();
write_ok (own_buf);
fprintf (stderr, "GDBserver restarting\n");
/* Wait till we are at 1st instruction in prog. */
signal = start_inferior (&argv[2], &status);
goto restart;
break;
}
else
{
fprintf (stderr, "GDBserver exiting\n");
exit (0);
}
}
}
/* We come here when getpkt fails.
For the extended remote protocol we exit (and this is the only
way we gracefully exit!).
For the traditional remote protocol close the connection,
and re-open it at the top of the loop. */
if (extended_protocol)
{
remote_close ();
exit (0);
}
else
{
fprintf (stderr, "Remote side has terminated connection. "
"GDBserver will reopen the connection.\n");
remote_close ();
}
}
}
int
main (int argc, char *argv[])
{
char ch, status, own_buf[PBUFSIZ], mem_buf[2000];
int i = 0;
unsigned char signal;
unsigned int len;
CORE_ADDR mem_addr;
if (setjmp (toplevel))
{
fprintf (stderr, "Exiting\n");
exit (1);
}
if (argc < 3)
error ("Usage: gdbserver tty prog [args ...]");
initialize_low ();
/* Wait till we are at first instruction in program. */
signal = start_inferior (&argv[2], &status);
/* We are now stopped at the first instruction of the target process */
while (1)
{
remote_open (argv[1]);
restart:
setjmp (toplevel);
while (getpkt (own_buf) > 0)
{
unsigned char sig;
i = 0;
ch = own_buf[i++];
switch (ch)
{
case 'd':
remote_debug = !remote_debug;
break;
case '!':
extended_protocol = 1;
prepare_resume_reply (own_buf, status, signal);
break;
case '?':
prepare_resume_reply (own_buf, status, signal);
break;
case 'H':
switch (own_buf[1])
{
case 'g':
general_thread = strtol (&own_buf[2], NULL, 16);
write_ok (own_buf);
fetch_inferior_registers (0);
break;
case 'c':
cont_thread = strtol (&own_buf[2], NULL, 16);
write_ok (own_buf);
break;
default:
/* Silently ignore it so that gdb can extend the protocol
without compatibility headaches. */
own_buf[0] = '\0';
break;
}
break;
case 'g':
convert_int_to_ascii (registers, own_buf, REGISTER_BYTES);
break;
case 'G':
convert_ascii_to_int (&own_buf[1], registers, REGISTER_BYTES);
store_inferior_registers (-1);
write_ok (own_buf);
break;
case 'm':
decode_m_packet (&own_buf[1], &mem_addr, &len);
read_inferior_memory (mem_addr, mem_buf, len);
convert_int_to_ascii (mem_buf, own_buf, len);
break;
case 'M':
decode_M_packet (&own_buf[1], &mem_addr, &len, mem_buf);
if (write_inferior_memory (mem_addr, mem_buf, len) == 0)
write_ok (own_buf);
else
write_enn (own_buf);
break;
case 'C':
convert_ascii_to_int (own_buf + 1, &sig, 1);
myresume (0, sig);
signal = mywait (&status);
prepare_resume_reply (own_buf, status, signal);
break;
case 'S':
convert_ascii_to_int (own_buf + 1, &sig, 1);
myresume (1, sig);
signal = mywait (&status);
prepare_resume_reply (own_buf, status, signal);
break;
case 'c':
myresume (0, 0);
signal = mywait (&status);
prepare_resume_reply (own_buf, status, signal);
break;
case 's':
myresume (1, 0);
signal = mywait (&status);
prepare_resume_reply (own_buf, status, signal);
break;
case 'k':
fprintf (stderr, "Killing inferior\n");
kill_inferior ();
/* When using the extended protocol, we start up a new
debugging session. The traditional protocol will
exit instead. */
if (extended_protocol)
{
write_ok (own_buf);
fprintf (stderr, "GDBserver restarting\n");
/* Wait till we are at 1st instruction in prog. */
signal = start_inferior (&argv[2], &status);
goto restart;
break;
}
else
{
exit (0);
break;
}
case 'T':
if (mythread_alive (strtol (&own_buf[1], NULL, 16)))
write_ok (own_buf);
else
write_enn (own_buf);
break;
case 'R':
/* Restarting the inferior is only supported in the
extended protocol. */
if (extended_protocol)
{
kill_inferior ();
write_ok (own_buf);
fprintf (stderr, "GDBserver restarting\n");
/* Wait till we are at 1st instruction in prog. */
signal = start_inferior (&argv[2], &status);
goto restart;
break;
}
else
{
/* It is a request we don't understand. Respond with an
empty packet so that gdb knows that we don't support this
request. */
own_buf[0] = '\0';
break;
}
default:
/* It is a request we don't understand. Respond with an
empty packet so that gdb knows that we don't support this
request. */
own_buf[0] = '\0';
break;
}
putpkt (own_buf);
if (status == 'W')
fprintf (stderr,
"\nChild exited with status %d\n", sig);
if (status == 'X')
fprintf (stderr, "\nChild terminated with signal = 0x%x\n", sig);
if (status == 'W' || status == 'X')
{
if (extended_protocol)
{
fprintf (stderr, "Killing inferior\n");
kill_inferior ();
write_ok (own_buf);
fprintf (stderr, "GDBserver restarting\n");
/* Wait till we are at 1st instruction in prog. */
signal = start_inferior (&argv[2], &status);
goto restart;
break;
}
else
{
fprintf (stderr, "GDBserver exiting\n");
exit (0);
}
}
}
/* We come here when getpkt fails.
For the extended remote protocol we exit (and this is the only
way we gracefully exit!).
For the traditional remote protocol close the connection,
and re-open it at the top of the loop. */
if (extended_protocol)
{
remote_close ();
exit (0);
}
else
{
fprintf (stderr, "Remote side has terminated connection. GDBserver will reopen the connection.\n");
remote_close ();
}
}
}