[deliverable/binutils-gdb.git] / gdb / gdbserver / server.c

/* Main code for remote server for GDB.
   Copyright 1989, 1993, 1994, 1995, 1997, 1998, 1999, 2000, 2002
   Free Software Foundation, Inc.

   This file is part of GDB.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.  */

#include "server.h"

#include <unistd.h>
#include <signal.h>
#include <sys/wait.h>

int cont_thread;
int general_thread;
int step_thread;
int thread_from_wait;
int old_thread_from_wait;
int extended_protocol;
int server_waiting;

jmp_buf toplevel;

/* The PID of the originally created or attached inferior.  Used to
   send signals to the process when GDB sends us an asynchronous interrupt
   (user hitting Control-C in the client), and to wait for the child to exit
   when no longer debugging it.  */

int signal_pid;

static unsigned char
start_inferior (char *argv[], char *statusptr)
{
  signal (SIGTTOU, SIG_DFL);
  signal (SIGTTIN, SIG_DFL);

  signal_pid = create_inferior (argv[0], argv);

  fprintf (stderr, "Process %s created; pid = %d\n", argv[0],
	   signal_pid);

  signal (SIGTTOU, SIG_IGN);
  signal (SIGTTIN, SIG_IGN);
  tcsetpgrp (fileno (stderr), signal_pid);

  /* Wait till we are at 1st instruction in program, return signal number.  */
  return mywait (statusptr, 0);
}

static int
attach_inferior (int pid, char *statusptr, unsigned char *sigptr)
{
  /* myattach should return -1 if attaching is unsupported,
     0 if it succeeded, and call error() otherwise.  */

  if (myattach (pid) != 0)
    return -1;

  /* FIXME - It may be that we should get the SIGNAL_PID from the
     attach function, so that it can be the main thread instead of
     whichever we were told to attach to.  */
  signal_pid = pid;

  *sigptr = mywait (statusptr, 0);

  return 0;
}

extern int remote_debug;

/* Handle all of the extended 'q' packets.  */
void
handle_query (char *own_buf)
{
  static struct inferior_list_entry *thread_ptr;

  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_ptr->id);
      thread_ptr = thread_ptr->next;
      return;
    }
  
  if (strcmp ("qsThreadInfo", own_buf) == 0)
    {
      if (thread_ptr != NULL)
	{
	  sprintf (own_buf, "m%x", thread_ptr->id);
	  thread_ptr = thread_ptr->next;
	  return;
	}
      else
	{
	  sprintf (own_buf, "l");
	  return;
	}
    }
      
  /* Otherwise we didn't know what packet it was.  Say we didn't
     understand it.  */
  own_buf[0] = 0;
}

static int attached;

static void
gdbserver_usage (void)
{
  error ("Usage:\tgdbserver COMM PROG [ARGS ...]\n"
	 "\tgdbserver COMM --attach PID\n"
	 "\n"
	 "COMM may either be a tty device (for serial debugging), or \n"
	 "HOST:PORT to listen for a TCP connection.\n");
}

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);
	      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);
	      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;
		}
	    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 ();
	}
    }
}
Commit	Line	Data
c906108c	1	/* Main code for remote server for GDB.
db728ff7	2	Copyright 1989, 1993, 1994, 1995, 1997, 1998, 1999, 2000, 2002
b6ba6518	3	Free Software Foundation, Inc.
c906108c	4
c5aa993b	5	This file is part of GDB.
c906108c	6
c5aa993b JM	7	This program is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License as published by
	9	the Free Software Foundation; either version 2 of the License, or
	10	(at your option) any later version.
c906108c	11
c5aa993b JM	12	This program is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
c906108c	16
c5aa993b JM	17	You should have received a copy of the GNU General Public License
	18	along with this program; if not, write to the Free Software
	19	Foundation, Inc., 59 Temple Place - Suite 330,
	20	Boston, MA 02111-1307, USA. */
c906108c SS	21
	22	#include "server.h"
	23
a9fa9f7d DJ	24	#include <unistd.h>
	25	#include <signal.h>
	26	#include <sys/wait.h>
	27
c906108c SS	28	int cont_thread;
c906108c SS	29	int general_thread;
0d62e5e8	30	int step_thread;
c906108c SS	31	int thread_from_wait;
	32	int old_thread_from_wait;
	33	int extended_protocol;
0d62e5e8 DJ	34	int server_waiting;
0d62e5e8 DJ	35
c906108c	36	jmp_buf toplevel;
c906108c	37
a9fa9f7d DJ	38	/* The PID of the originally created or attached inferior. Used to
	39	send signals to the process when GDB sends us an asynchronous interrupt
	40	(user hitting Control-C in the client), and to wait for the child to exit
	41	when no longer debugging it. */
	42
	43	int signal_pid;
	44
c906108c	45	static unsigned char
da85418c	46	start_inferior (char argv[], char statusptr)
c906108c	47	{
a9fa9f7d DJ	48	signal (SIGTTOU, SIG_DFL);
	49	signal (SIGTTIN, SIG_DFL);
	50
	51	signal_pid = create_inferior (argv[0], argv);
0d62e5e8 DJ	52
0d62e5e8 DJ	53	fprintf (stderr, "Process %s created; pid = %d\n", argv[0],
a9fa9f7d DJ	54	signal_pid);
	55
	56	signal (SIGTTOU, SIG_IGN);
	57	signal (SIGTTIN, SIG_IGN);
	58	tcsetpgrp (fileno (stderr), signal_pid);
c906108c SS	59
c906108c SS	60	/* Wait till we are at 1st instruction in program, return signal number. */
0d62e5e8	61	return mywait (statusptr, 0);
c906108c SS	62	}
c906108c SS	63
45b7b345 DJ	64	static int
	65	attach_inferior (int pid, char statusptr, unsigned char sigptr)
	66	{
	67	/* myattach should return -1 if attaching is unsupported,
	68	0 if it succeeded, and call error() otherwise. */
a9fa9f7d	69
45b7b345 DJ	70	if (myattach (pid) != 0)
	71	return -1;
	72
a9fa9f7d DJ	73	/* FIXME - It may be that we should get the SIGNAL_PID from the
	74	attach function, so that it can be the main thread instead of
	75	whichever we were told to attach to. */
	76	signal_pid = pid;
	77
0d62e5e8	78	*sigptr = mywait (statusptr, 0);
45b7b345 DJ	79
	80	return 0;
	81	}
	82
c906108c	83	extern int remote_debug;
ce3a066d DJ	84
	85	/* Handle all of the extended 'q' packets. */
	86	void
	87	handle_query (char *own_buf)
	88	{
0d62e5e8 DJ	89	static struct inferior_list_entry *thread_ptr;
0d62e5e8 DJ	90
ce3a066d DJ	91	if (strcmp ("qSymbol::", own_buf) == 0)
ce3a066d DJ	92	{
2f2893d9 DJ	93	if (the_target->look_up_symbols != NULL)
	94	(*the_target->look_up_symbols) ();
	95
ce3a066d DJ	96	strcpy (own_buf, "OK");
	97	return;
	98	}
	99
0d62e5e8 DJ	100	if (strcmp ("qfThreadInfo", own_buf) == 0)
	101	{
	102	thread_ptr = all_threads.head;
	103	sprintf (own_buf, "m%x", thread_ptr->id);
	104	thread_ptr = thread_ptr->next;
	105	return;
	106	}
	107
	108	if (strcmp ("qsThreadInfo", own_buf) == 0)
	109	{
	110	if (thread_ptr != NULL)
	111	{
	112	sprintf (own_buf, "m%x", thread_ptr->id);
	113	thread_ptr = thread_ptr->next;
	114	return;
	115	}
	116	else
	117	{
	118	sprintf (own_buf, "l");
	119	return;
	120	}
	121	}
	122
ce3a066d DJ	123	/* Otherwise we didn't know what packet it was. Say we didn't
	124	understand it. */
	125	own_buf[0] = 0;
	126	}
	127
0729219d	128	static int attached;
c906108c	129
0bc68c49 DJ	130	static void
	131	gdbserver_usage (void)
	132	{
	133	error ("Usage:\tgdbserver COMM PROG [ARGS ...]\n"
	134	"\tgdbserver COMM --attach PID\n"
	135	"\n"
	136	"COMM may either be a tty device (for serial debugging), or \n"
	137	"HOST:PORT to listen for a TCP connection.\n");
	138	}
	139
c906108c	140	int
da85418c	141	main (int argc, char *argv[])
c906108c	142	{
0a30fbc4	143	char ch, status, *own_buf, mem_buf[2000];
c906108c SS	144	int i = 0;
	145	unsigned char signal;
	146	unsigned int len;
	147	CORE_ADDR mem_addr;
0729219d DJ	148	int bad_attach;
0729219d DJ	149	int pid;
45b7b345	150	char *arg_end;
c906108c	151
c5aa993b	152	if (setjmp (toplevel))
c906108c	153	{
c5aa993b JM	154	fprintf (stderr, "Exiting\n");
c5aa993b JM	155	exit (1);
c906108c SS	156	}
c906108c SS	157
0729219d DJ	158	bad_attach = 0;
	159	pid = 0;
	160	attached = 0;
45b7b345 DJ	161	if (argc >= 3 && strcmp (argv[2], "--attach") == 0)
	162	{
	163	if (argc == 4
	164	&& argv[3] != '\0'
	165	&& (pid = strtoul (argv[3], &arg_end, 10)) != 0
	166	&& *arg_end == '\0')
	167	{
	168	;
	169	}
	170	else
	171	bad_attach = 1;
	172	}
	173
	174	if (argc < 3 \|\| bad_attach)
0bc68c49	175	gdbserver_usage();
c906108c	176
4ce44c66 JM	177	initialize_low ();
4ce44c66 JM	178
0a30fbc4 DJ	179	own_buf = malloc (PBUFSIZ);
0a30fbc4 DJ	180
45b7b345 DJ	181	if (pid == 0)
	182	{
	183	/* Wait till we are at first instruction in program. */
	184	signal = start_inferior (&argv[2], &status);
c906108c	185
45b7b345 DJ	186	/* We are now stopped at the first instruction of the target process */
	187	}
	188	else
	189	{
	190	switch (attach_inferior (pid, &status, &signal))
	191	{
	192	case -1:
	193	error ("Attaching not supported on this target");
	194	break;
	195	default:
	196	attached = 1;
	197	break;
	198	}
	199	}
c906108c SS	200
	201	while (1)
	202	{
	203	remote_open (argv[1]);
	204
c5aa993b JM	205	restart:
c5aa993b JM	206	setjmp (toplevel);
c906108c SS	207	while (getpkt (own_buf) > 0)
	208	{
	209	unsigned char sig;
	210	i = 0;
	211	ch = own_buf[i++];
	212	switch (ch)
	213	{
ce3a066d DJ	214	case 'q':
	215	handle_query (own_buf);
	216	break;
c906108c SS	217	case 'd':
	218	remote_debug = !remote_debug;
	219	break;
6ad8ae5c DJ	220	case 'D':
	221	fprintf (stderr, "Detaching from inferior\n");
	222	detach_inferior ();
	223	write_ok (own_buf);
	224	putpkt (own_buf);
	225	remote_close ();
	226
	227	/* If we are attached, then we can exit. Otherwise, we need to
	228	hang around doing nothing, until the child is gone. */
	229	if (!attached)
	230	{
	231	int status, ret;
	232
	233	do {
	234	ret = waitpid (signal_pid, &status, 0);
	235	if (WIFEXITED (status) \|\| WIFSIGNALED (status))
	236	break;
	237	} while (ret != -1 \|\| errno != ECHILD);
	238	}
	239
	240	exit (0);
	241
c906108c	242	case '!':
45b7b345 DJ	243	if (attached == 0)
	244	{
	245	extended_protocol = 1;
	246	prepare_resume_reply (own_buf, status, signal);
	247	}
	248	else
	249	{
	250	/* We can not use the extended protocol if we are
	251	attached, because we can not restart the running
	252	program. So return unrecognized. */
	253	own_buf[0] = '\0';
	254	}
c906108c SS	255	break;
	256	case '?':
	257	prepare_resume_reply (own_buf, status, signal);
	258	break;
	259	case 'H':
	260	switch (own_buf[1])
	261	{
	262	case 'g':
	263	general_thread = strtol (&own_buf[2], NULL, 16);
	264	write_ok (own_buf);
0d62e5e8	265	set_desired_inferior (1);
c906108c SS	266	break;
	267	case 'c':
	268	cont_thread = strtol (&own_buf[2], NULL, 16);
	269	write_ok (own_buf);
	270	break;
0d62e5e8 DJ	271	case 's':
	272	step_thread = strtol (&own_buf[2], NULL, 16);
	273	write_ok (own_buf);
	274	break;
c906108c SS	275	default:
	276	/* Silently ignore it so that gdb can extend the protocol
	277	without compatibility headaches. */
	278	own_buf[0] = '\0';
	279	break;
	280	}
	281	break;
	282	case 'g':
0d62e5e8	283	set_desired_inferior (1);
0a30fbc4	284	registers_to_string (own_buf);
c906108c SS	285	break;
c906108c SS	286	case 'G':
0d62e5e8	287	set_desired_inferior (1);
0a30fbc4	288	registers_from_string (&own_buf[1]);
c906108c SS	289	write_ok (own_buf);
	290	break;
	291	case 'm':
	292	decode_m_packet (&own_buf[1], &mem_addr, &len);
	293	read_inferior_memory (mem_addr, mem_buf, len);
	294	convert_int_to_ascii (mem_buf, own_buf, len);
	295	break;
	296	case 'M':
	297	decode_M_packet (&own_buf[1], &mem_addr, &len, mem_buf);
	298	if (write_inferior_memory (mem_addr, mem_buf, len) == 0)
	299	write_ok (own_buf);
	300	else
	301	write_enn (own_buf);
	302	break;
	303	case 'C':
	304	convert_ascii_to_int (own_buf + 1, &sig, 1);
0e98d0a7 DJ	305	if (target_signal_to_host_p (sig))
	306	signal = target_signal_to_host (sig);
	307	else
	308	signal = 0;
0d62e5e8	309	set_desired_inferior (0);
0e98d0a7	310	myresume (0, signal);
0d62e5e8	311	signal = mywait (&status, 1);
c906108c SS	312	prepare_resume_reply (own_buf, status, signal);
	313	break;
	314	case 'S':
	315	convert_ascii_to_int (own_buf + 1, &sig, 1);
0e98d0a7 DJ	316	if (target_signal_to_host_p (sig))
	317	signal = target_signal_to_host (sig);
	318	else
	319	signal = 0;
0d62e5e8	320	set_desired_inferior (0);
0e98d0a7	321	myresume (1, signal);
0d62e5e8	322	signal = mywait (&status, 1);
c906108c SS	323	prepare_resume_reply (own_buf, status, signal);
	324	break;
	325	case 'c':
0d62e5e8	326	set_desired_inferior (0);
c906108c	327	myresume (0, 0);
0d62e5e8	328	signal = mywait (&status, 1);
c906108c SS	329	prepare_resume_reply (own_buf, status, signal);
	330	break;
	331	case 's':
0d62e5e8	332	set_desired_inferior (0);
c906108c	333	myresume (1, 0);
0d62e5e8	334	signal = mywait (&status, 1);
c906108c SS	335	prepare_resume_reply (own_buf, status, signal);
	336	break;
	337	case 'k':
	338	fprintf (stderr, "Killing inferior\n");
	339	kill_inferior ();
	340	/* When using the extended protocol, we start up a new
c5aa993b	341	debugging session. The traditional protocol will
c906108c SS	342	exit instead. */
	343	if (extended_protocol)
	344	{
	345	write_ok (own_buf);
	346	fprintf (stderr, "GDBserver restarting\n");
	347
	348	/* Wait till we are at 1st instruction in prog. */
	349	signal = start_inferior (&argv[2], &status);
	350	goto restart;
	351	break;
	352	}
	353	else
	354	{
	355	exit (0);
	356	break;
	357	}
	358	case 'T':
	359	if (mythread_alive (strtol (&own_buf[1], NULL, 16)))
	360	write_ok (own_buf);
	361	else
	362	write_enn (own_buf);
	363	break;
	364	case 'R':
	365	/* Restarting the inferior is only supported in the
c5aa993b	366	extended protocol. */
c906108c SS	367	if (extended_protocol)
	368	{
	369	kill_inferior ();
	370	write_ok (own_buf);
	371	fprintf (stderr, "GDBserver restarting\n");
	372
	373	/* Wait till we are at 1st instruction in prog. */
	374	signal = start_inferior (&argv[2], &status);
	375	goto restart;
	376	break;
	377	}
	378	else
	379	{
	380	/* It is a request we don't understand. Respond with an
	381	empty packet so that gdb knows that we don't support this
	382	request. */
	383	own_buf[0] = '\0';
	384	break;
	385	}
	386	default:
	387	/* It is a request we don't understand. Respond with an
c5aa993b JM	388	empty packet so that gdb knows that we don't support this
c5aa993b JM	389	request. */
c906108c SS	390	own_buf[0] = '\0';
	391	break;
	392	}
	393
	394	putpkt (own_buf);
	395
	396	if (status == 'W')
	397	fprintf (stderr,
	398	"\nChild exited with status %d\n", sig);
	399	if (status == 'X')
	400	fprintf (stderr, "\nChild terminated with signal = 0x%x\n", sig);
	401	if (status == 'W' \|\| status == 'X')
	402	{
	403	if (extended_protocol)
	404	{
	405	fprintf (stderr, "Killing inferior\n");
	406	kill_inferior ();
	407	write_ok (own_buf);
	408	fprintf (stderr, "GDBserver restarting\n");
	409
	410	/* Wait till we are at 1st instruction in prog. */
	411	signal = start_inferior (&argv[2], &status);
	412	goto restart;
	413	break;
	414	}
	415	else
	416	{
	417	fprintf (stderr, "GDBserver exiting\n");
	418	exit (0);
	419	}
	420	}
	421	}
	422
	423	/* We come here when getpkt fails.
	424
c5aa993b JM	425	For the extended remote protocol we exit (and this is the only
c5aa993b JM	426	way we gracefully exit!).
c906108c	427
c5aa993b JM	428	For the traditional remote protocol close the connection,
c5aa993b JM	429	and re-open it at the top of the loop. */
c906108c SS	430	if (extended_protocol)
	431	{
	432	remote_close ();
	433	exit (0);
	434	}
	435	else
	436	{
45b7b345 DJ	437	fprintf (stderr, "Remote side has terminated connection. "
45b7b345 DJ	438	"GDBserver will reopen the connection.\n");
c906108c SS	439	remote_close ();
	440	}
	441	}
	442	}