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

/* Main code for remote server for GDB.
   Copyright 1989, 1993, 1994, 1995, 1997, 1998, 1999, 2000, 2002, 2003, 2004,
   2005
   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>

unsigned long cont_thread;
unsigned long general_thread;
unsigned long step_thread;
unsigned long thread_from_wait;
unsigned long 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.  */

unsigned long 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 = %ld\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;

  fprintf (stderr, "Attached; pid = %d\n", pid);

  /* 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%lx", thread_ptr->id);
      thread_ptr = thread_ptr->next;
      return;
    }

  if (strcmp ("qsThreadInfo", own_buf) == 0)
    {
      if (thread_ptr != NULL)
	{
	  sprintf (own_buf, "m%lx", thread_ptr->id);
	  thread_ptr = thread_ptr->next;
	  return;
	}
      else
	{
	  sprintf (own_buf, "l");
	  return;
	}
    }

  if (the_target->read_auxv != NULL
      && strncmp ("qPart:auxv:read::", own_buf, 17) == 0)
    {
      char data[(PBUFSIZ - 1) / 2];
      CORE_ADDR ofs;
      unsigned int len;
      int n;
      decode_m_packet (&own_buf[17], &ofs, &len); /* "OFS,LEN" */
      if (len > sizeof data)
	len = sizeof data;
      n = (*the_target->read_auxv) (ofs, data, len);
      if (n == 0)
	write_ok (own_buf);
      else if (n < 0)
	write_enn (own_buf);
      else
	convert_int_to_ascii (data, own_buf, n);
      return;
    }

  /* Otherwise we didn't know what packet it was.  Say we didn't
     understand it.  */
  own_buf[0] = 0;
}

/* Parse vCont packets.  */
void
handle_v_cont (char *own_buf, char *status, unsigned char *signal)
{
  char *p, *q;
  int n = 0, i = 0;
  struct thread_resume *resume_info, default_action;

  /* Count the number of semicolons in the packet.  There should be one
     for every action.  */
  p = &own_buf[5];
  while (p)
    {
      n++;
      p++;
      p = strchr (p, ';');
    }
  /* Allocate room for one extra action, for the default remain-stopped
     behavior; if no default action is in the list, we'll need the extra
     slot.  */
  resume_info = malloc ((n + 1) * sizeof (resume_info[0]));

  default_action.thread = -1;
  default_action.leave_stopped = 1;
  default_action.step = 0;
  default_action.sig = 0;

  p = &own_buf[5];
  i = 0;
  while (*p)
    {
      p++;

      resume_info[i].leave_stopped = 0;

      if (p[0] == 's' || p[0] == 'S')
	resume_info[i].step = 1;
      else if (p[0] == 'c' || p[0] == 'C')
	resume_info[i].step = 0;
      else
	goto err;

      if (p[0] == 'S' || p[0] == 'C')
	{
	  int sig;
	  sig = strtol (p + 1, &q, 16);
	  if (p == q)
	    goto err;
	  p = q;

	  if (!target_signal_to_host_p (sig))
	    goto err;
	  resume_info[i].sig = target_signal_to_host (sig);
	}
      else
	{
	  resume_info[i].sig = 0;
	  p = p + 1;
	}

      if (p[0] == 0)
	{
	  resume_info[i].thread = -1;
	  default_action = resume_info[i];

	  /* Note: we don't increment i here, we'll overwrite this entry
	     the next time through.  */
	}
      else if (p[0] == ':')
	{
	  resume_info[i].thread = strtoul (p + 1, &q, 16);
	  if (p == q)
	    goto err;
	  p = q;
	  if (p[0] != ';' && p[0] != 0)
	    goto err;

	  i++;
	}
    }

  resume_info[i] = default_action;

  /* Still used in occasional places in the backend.  */
  if (n == 1 && resume_info[0].thread != -1)
    cont_thread = resume_info[0].thread;
  else
    cont_thread = -1;
  set_desired_inferior (0);

  (*the_target->resume) (resume_info);

  free (resume_info);

  *signal = mywait (status, 1);
  prepare_resume_reply (own_buf, *status, *signal);
  return;

err:
  /* No other way to report an error... */
  strcpy (own_buf, "");
  free (resume_info);
  return;
}

/* Handle all of the extended 'v' packets.  */
void
handle_v_requests (char *own_buf, char *status, unsigned char *signal)
{
  if (strncmp (own_buf, "vCont;", 6) == 0)
    {
      handle_v_cont (own_buf, status, signal);
      return;
    }

  if (strncmp (own_buf, "vCont?", 6) == 0)
    {
      strcpy (own_buf, "vCont;c;C;s;S");
      return;
    }

  /* Otherwise we didn't know what packet it was.  Say we didn't
     understand it.  */
  own_buf[0] = 0;
  return;
}

void
myresume (int step, int sig)
{
  struct thread_resume resume_info[2];
  int n = 0;

  if (step || sig || cont_thread > 0)
    {
      resume_info[0].thread
	= ((struct inferior_list_entry *) current_inferior)->id;
      resume_info[0].step = step;
      resume_info[0].sig = sig;
      resume_info[0].leave_stopped = 0;
      n++;
    }
  resume_info[n].thread = -1;
  resume_info[n].step = 0;
  resume_info[n].sig = 0;
  resume_info[n].leave_stopped = (cont_thread > 0);

  (*the_target->resume) (resume_info);
}

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 = strtoul (&own_buf[2], NULL, 16);
		  write_ok (own_buf);
		  set_desired_inferior (1);
		  break;
		case 'c':
		  cont_thread = strtoul (&own_buf[2], NULL, 16);
		  write_ok (own_buf);
		  break;
		case 's':
		  step_thread = strtoul (&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 (strtoul (&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 ();
	}
    }
}
Commit	Line	Data
c906108c	1	/* Main code for remote server for GDB.
a1928bad DJ	2	Copyright 1989, 1993, 1994, 1995, 1997, 1998, 1999, 2000, 2002, 2003, 2004,
a1928bad DJ	3	2005
b6ba6518	4	Free Software Foundation, Inc.
c906108c	5
c5aa993b	6	This file is part of GDB.
c906108c	7
c5aa993b JM	8	This program is free software; you can redistribute it and/or modify
	9	it under the terms of the GNU General Public License as published by
	10	the Free Software Foundation; either version 2 of the License, or
	11	(at your option) any later version.
c906108c	12
c5aa993b JM	13	This program is distributed in the hope that it will be useful,
	14	but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	GNU General Public License for more details.
c906108c	17
c5aa993b JM	18	You should have received a copy of the GNU General Public License
	19	along with this program; if not, write to the Free Software
	20	Foundation, Inc., 59 Temple Place - Suite 330,
	21	Boston, MA 02111-1307, USA. */
c906108c SS	22
	23	#include "server.h"
	24
a9fa9f7d DJ	25	#include <unistd.h>
	26	#include <signal.h>
	27	#include <sys/wait.h>
	28
a1928bad DJ	29	unsigned long cont_thread;
	30	unsigned long general_thread;
	31	unsigned long step_thread;
	32	unsigned long thread_from_wait;
	33	unsigned long old_thread_from_wait;
c906108c	34	int extended_protocol;
0d62e5e8 DJ	35	int server_waiting;
0d62e5e8 DJ	36
c906108c	37	jmp_buf toplevel;
c906108c	38
a9fa9f7d DJ	39	/* The PID of the originally created or attached inferior. Used to
	40	send signals to the process when GDB sends us an asynchronous interrupt
	41	(user hitting Control-C in the client), and to wait for the child to exit
	42	when no longer debugging it. */
	43
a1928bad	44	unsigned long signal_pid;
a9fa9f7d	45
c906108c	46	static unsigned char
da85418c	47	start_inferior (char argv[], char statusptr)
c906108c	48	{
a9fa9f7d DJ	49	signal (SIGTTOU, SIG_DFL);
	50	signal (SIGTTIN, SIG_DFL);
	51
	52	signal_pid = create_inferior (argv[0], argv);
0d62e5e8	53
a1928bad	54	fprintf (stderr, "Process %s created; pid = %ld\n", argv[0],
a9fa9f7d DJ	55	signal_pid);
	56
	57	signal (SIGTTOU, SIG_IGN);
	58	signal (SIGTTIN, SIG_IGN);
	59	tcsetpgrp (fileno (stderr), signal_pid);
c906108c SS	60
c906108c SS	61	/* Wait till we are at 1st instruction in program, return signal number. */
0d62e5e8	62	return mywait (statusptr, 0);
c906108c SS	63	}
c906108c SS	64
45b7b345 DJ	65	static int
	66	attach_inferior (int pid, char statusptr, unsigned char sigptr)
	67	{
	68	/* myattach should return -1 if attaching is unsupported,
	69	0 if it succeeded, and call error() otherwise. */
a9fa9f7d	70
45b7b345 DJ	71	if (myattach (pid) != 0)
	72	return -1;
	73
6910d122 DJ	74	fprintf (stderr, "Attached; pid = %d\n", pid);
6910d122 DJ	75
a9fa9f7d DJ	76	/* FIXME - It may be that we should get the SIGNAL_PID from the
	77	attach function, so that it can be the main thread instead of
	78	whichever we were told to attach to. */
	79	signal_pid = pid;
	80
0d62e5e8	81	*sigptr = mywait (statusptr, 0);
45b7b345 DJ	82
	83	return 0;
	84	}
	85
c906108c	86	extern int remote_debug;
ce3a066d DJ	87
	88	/* Handle all of the extended 'q' packets. */
	89	void
	90	handle_query (char *own_buf)
	91	{
0d62e5e8 DJ	92	static struct inferior_list_entry *thread_ptr;
0d62e5e8 DJ	93
ce3a066d DJ	94	if (strcmp ("qSymbol::", own_buf) == 0)
ce3a066d DJ	95	{
2f2893d9 DJ	96	if (the_target->look_up_symbols != NULL)
	97	(*the_target->look_up_symbols) ();
	98
ce3a066d DJ	99	strcpy (own_buf, "OK");
	100	return;
	101	}
	102
0d62e5e8 DJ	103	if (strcmp ("qfThreadInfo", own_buf) == 0)
	104	{
	105	thread_ptr = all_threads.head;
a1928bad	106	sprintf (own_buf, "m%lx", thread_ptr->id);
0d62e5e8 DJ	107	thread_ptr = thread_ptr->next;
	108	return;
	109	}
aa691b87	110
0d62e5e8 DJ	111	if (strcmp ("qsThreadInfo", own_buf) == 0)
	112	{
	113	if (thread_ptr != NULL)
	114	{
a1928bad	115	sprintf (own_buf, "m%lx", thread_ptr->id);
0d62e5e8 DJ	116	thread_ptr = thread_ptr->next;
	117	return;
	118	}
	119	else
	120	{
	121	sprintf (own_buf, "l");
	122	return;
	123	}
	124	}
aa691b87 RM	125
	126	if (the_target->read_auxv != NULL
	127	&& strncmp ("qPart:auxv:read::", own_buf, 17) == 0)
	128	{
	129	char data[(PBUFSIZ - 1) / 2];
	130	CORE_ADDR ofs;
	131	unsigned int len;
	132	int n;
	133	decode_m_packet (&own_buf[17], &ofs, &len); /* "OFS,LEN" */
	134	if (len > sizeof data)
	135	len = sizeof data;
	136	n = (*the_target->read_auxv) (ofs, data, len);
	137	if (n == 0)
	138	write_ok (own_buf);
	139	else if (n < 0)
	140	write_enn (own_buf);
	141	else
	142	convert_int_to_ascii (data, own_buf, n);
	143	return;
	144	}
	145
ce3a066d DJ	146	/* Otherwise we didn't know what packet it was. Say we didn't
	147	understand it. */
	148	own_buf[0] = 0;
	149	}
	150
64386c31 DJ	151	/* Parse vCont packets. */
	152	void
	153	handle_v_cont (char own_buf, char status, unsigned char *signal)
	154	{
	155	char p, q;
	156	int n = 0, i = 0;
	157	struct thread_resume *resume_info, default_action;
	158
	159	/* Count the number of semicolons in the packet. There should be one
	160	for every action. */
	161	p = &own_buf[5];
	162	while (p)
	163	{
	164	n++;
	165	p++;
	166	p = strchr (p, ';');
	167	}
	168	/* Allocate room for one extra action, for the default remain-stopped
	169	behavior; if no default action is in the list, we'll need the extra
	170	slot. */
	171	resume_info = malloc ((n + 1) * sizeof (resume_info[0]));
	172
	173	default_action.thread = -1;
	174	default_action.leave_stopped = 1;
	175	default_action.step = 0;
	176	default_action.sig = 0;
	177
	178	p = &own_buf[5];
	179	i = 0;
	180	while (*p)
	181	{
	182	p++;
	183
	184	resume_info[i].leave_stopped = 0;
	185
	186	if (p[0] == 's' \|\| p[0] == 'S')
	187	resume_info[i].step = 1;
	188	else if (p[0] == 'c' \|\| p[0] == 'C')
	189	resume_info[i].step = 0;
	190	else
	191	goto err;
	192
	193	if (p[0] == 'S' \|\| p[0] == 'C')
	194	{
	195	int sig;
	196	sig = strtol (p + 1, &q, 16);
	197	if (p == q)
	198	goto err;
	199	p = q;
	200
	201	if (!target_signal_to_host_p (sig))
	202	goto err;
	203	resume_info[i].sig = target_signal_to_host (sig);
	204	}
	205	else
	206	{
	207	resume_info[i].sig = 0;
	208	p = p + 1;
	209	}
	210
	211	if (p[0] == 0)
	212	{
	213	resume_info[i].thread = -1;
	214	default_action = resume_info[i];
215
216	/* Note: we don't increment i here, we'll overwrite this entry
217	the next time through. */
218	}
219	else if (p[0] == ':')
220	{
a1928bad	221	resume_info[i].thread = strtoul (p + 1, &q, 16);
64386c31 DJ	222	if (p == q)
	223	goto err;
	224	p = q;
	225	if (p[0] != ';' && p[0] != 0)
	226	goto err;
	227
	228	i++;
	229	}
	230	}
	231
	232	resume_info[i] = default_action;
	233
	234	/* Still used in occasional places in the backend. */
	235	if (n == 1 && resume_info[0].thread != -1)
	236	cont_thread = resume_info[0].thread;
	237	else
	238	cont_thread = -1;
dc3f8883	239	set_desired_inferior (0);
64386c31 DJ	240
	241	(*the_target->resume) (resume_info);
	242
	243	free (resume_info);
	244
	245	*signal = mywait (status, 1);
	246	prepare_resume_reply (own_buf, status, signal);
	247	return;
	248
	249	err:
	250	/* No other way to report an error... */
	251	strcpy (own_buf, "");
	252	free (resume_info);
	253	return;
	254	}
	255
	256	/* Handle all of the extended 'v' packets. */
	257	void
	258	handle_v_requests (char own_buf, char status, unsigned char *signal)
	259	{
	260	if (strncmp (own_buf, "vCont;", 6) == 0)
	261	{
	262	handle_v_cont (own_buf, status, signal);
	263	return;
	264	}
	265
	266	if (strncmp (own_buf, "vCont?", 6) == 0)
	267	{
	268	strcpy (own_buf, "vCont;c;C;s;S");
	269	return;
	270	}
	271
	272	/* Otherwise we didn't know what packet it was. Say we didn't
	273	understand it. */
	274	own_buf[0] = 0;
	275	return;
	276	}
	277
	278	void
	279	myresume (int step, int sig)
	280	{
	281	struct thread_resume resume_info[2];
	282	int n = 0;
	283
	284	if (step \|\| sig \|\| cont_thread > 0)
	285	{
	286	resume_info[0].thread
	287	= ((struct inferior_list_entry *) current_inferior)->id;
	288	resume_info[0].step = step;
	289	resume_info[0].sig = sig;
	290	resume_info[0].leave_stopped = 0;
	291	n++;
	292	}
	293	resume_info[n].thread = -1;
	294	resume_info[n].step = 0;
	295	resume_info[n].sig = 0;
	296	resume_info[n].leave_stopped = (cont_thread > 0);
	297
	298	(*the_target->resume) (resume_info);
	299	}
	300
0729219d	301	static int attached;
c906108c	302
0bc68c49 DJ	303	static void
	304	gdbserver_usage (void)
	305	{
	306	error ("Usage:\tgdbserver COMM PROG [ARGS ...]\n"
	307	"\tgdbserver COMM --attach PID\n"
	308	"\n"
	309	"COMM may either be a tty device (for serial debugging), or \n"
	310	"HOST:PORT to listen for a TCP connection.\n");
	311	}
	312
c906108c	313	int
da85418c	314	main (int argc, char *argv[])
c906108c	315	{
0a30fbc4	316	char ch, status, *own_buf, mem_buf[2000];
c906108c SS	317	int i = 0;
	318	unsigned char signal;
	319	unsigned int len;
	320	CORE_ADDR mem_addr;
0729219d DJ	321	int bad_attach;
0729219d DJ	322	int pid;
45b7b345	323	char *arg_end;
c906108c	324
c5aa993b	325	if (setjmp (toplevel))
c906108c	326	{
c5aa993b JM	327	fprintf (stderr, "Exiting\n");
c5aa993b JM	328	exit (1);
c906108c SS	329	}
c906108c SS	330
0729219d DJ	331	bad_attach = 0;
	332	pid = 0;
	333	attached = 0;
45b7b345 DJ	334	if (argc >= 3 && strcmp (argv[2], "--attach") == 0)
	335	{
	336	if (argc == 4
	337	&& argv[3] != '\0'
	338	&& (pid = strtoul (argv[3], &arg_end, 10)) != 0
	339	&& *arg_end == '\0')
	340	{
	341	;
	342	}
	343	else
	344	bad_attach = 1;
	345	}
	346
	347	if (argc < 3 \|\| bad_attach)
0bc68c49	348	gdbserver_usage();
c906108c	349
4ce44c66 JM	350	initialize_low ();
4ce44c66 JM	351
0a30fbc4 DJ	352	own_buf = malloc (PBUFSIZ);
0a30fbc4 DJ	353
45b7b345 DJ	354	if (pid == 0)
	355	{
	356	/* Wait till we are at first instruction in program. */
	357	signal = start_inferior (&argv[2], &status);
c906108c	358
45b7b345 DJ	359	/* We are now stopped at the first instruction of the target process */
	360	}
	361	else
	362	{
	363	switch (attach_inferior (pid, &status, &signal))
	364	{
	365	case -1:
	366	error ("Attaching not supported on this target");
	367	break;
	368	default:
	369	attached = 1;
	370	break;
	371	}
	372	}
c906108c SS	373
	374	while (1)
	375	{
	376	remote_open (argv[1]);
	377
c5aa993b JM	378	restart:
c5aa993b JM	379	setjmp (toplevel);
c906108c SS	380	while (getpkt (own_buf) > 0)
	381	{
	382	unsigned char sig;
	383	i = 0;
	384	ch = own_buf[i++];
	385	switch (ch)
	386	{
ce3a066d DJ	387	case 'q':
	388	handle_query (own_buf);
	389	break;
c906108c SS	390	case 'd':
	391	remote_debug = !remote_debug;
	392	break;
6ad8ae5c DJ	393	case 'D':
	394	fprintf (stderr, "Detaching from inferior\n");
	395	detach_inferior ();
	396	write_ok (own_buf);
	397	putpkt (own_buf);
aa691b87	398	remote_close ();
6ad8ae5c DJ	399
	400	/* If we are attached, then we can exit. Otherwise, we need to
	401	hang around doing nothing, until the child is gone. */
	402	if (!attached)
	403	{
	404	int status, ret;
	405
	406	do {
	407	ret = waitpid (signal_pid, &status, 0);
	408	if (WIFEXITED (status) \|\| WIFSIGNALED (status))
	409	break;
	410	} while (ret != -1 \|\| errno != ECHILD);
	411	}
	412
	413	exit (0);
	414
c906108c	415	case '!':
45b7b345 DJ	416	if (attached == 0)
	417	{
	418	extended_protocol = 1;
	419	prepare_resume_reply (own_buf, status, signal);
	420	}
	421	else
	422	{
	423	/* We can not use the extended protocol if we are
	424	attached, because we can not restart the running
	425	program. So return unrecognized. */
	426	own_buf[0] = '\0';
	427	}
c906108c SS	428	break;
	429	case '?':
	430	prepare_resume_reply (own_buf, status, signal);
	431	break;
	432	case 'H':
	433	switch (own_buf[1])
	434	{
	435	case 'g':
a1928bad	436	general_thread = strtoul (&own_buf[2], NULL, 16);
c906108c	437	write_ok (own_buf);
0d62e5e8	438	set_desired_inferior (1);
c906108c SS	439	break;
c906108c SS	440	case 'c':
a1928bad	441	cont_thread = strtoul (&own_buf[2], NULL, 16);
c906108c SS	442	write_ok (own_buf);
c906108c SS	443	break;
0d62e5e8	444	case 's':
a1928bad	445	step_thread = strtoul (&own_buf[2], NULL, 16);
0d62e5e8 DJ	446	write_ok (own_buf);
0d62e5e8 DJ	447	break;
c906108c SS	448	default:
	449	/* Silently ignore it so that gdb can extend the protocol
	450	without compatibility headaches. */
	451	own_buf[0] = '\0';
	452	break;
	453	}
	454	break;
	455	case 'g':
0d62e5e8	456	set_desired_inferior (1);
0a30fbc4	457	registers_to_string (own_buf);
c906108c SS	458	break;
c906108c SS	459	case 'G':
0d62e5e8	460	set_desired_inferior (1);
0a30fbc4	461	registers_from_string (&own_buf[1]);
c906108c SS	462	write_ok (own_buf);
	463	break;
	464	case 'm':
	465	decode_m_packet (&own_buf[1], &mem_addr, &len);
c3e735a6 DJ	466	if (read_inferior_memory (mem_addr, mem_buf, len) == 0)
	467	convert_int_to_ascii (mem_buf, own_buf, len);
	468	else
	469	write_enn (own_buf);
c906108c SS	470	break;
	471	case 'M':
	472	decode_M_packet (&own_buf[1], &mem_addr, &len, mem_buf);
	473	if (write_inferior_memory (mem_addr, mem_buf, len) == 0)
	474	write_ok (own_buf);
	475	else
	476	write_enn (own_buf);
	477	break;
	478	case 'C':
	479	convert_ascii_to_int (own_buf + 1, &sig, 1);
0e98d0a7 DJ	480	if (target_signal_to_host_p (sig))
	481	signal = target_signal_to_host (sig);
	482	else
	483	signal = 0;
0d62e5e8	484	set_desired_inferior (0);
0e98d0a7	485	myresume (0, signal);
0d62e5e8	486	signal = mywait (&status, 1);
c906108c SS	487	prepare_resume_reply (own_buf, status, signal);
	488	break;
	489	case 'S':
	490	convert_ascii_to_int (own_buf + 1, &sig, 1);
0e98d0a7 DJ	491	if (target_signal_to_host_p (sig))
	492	signal = target_signal_to_host (sig);
	493	else
	494	signal = 0;
0d62e5e8	495	set_desired_inferior (0);
0e98d0a7	496	myresume (1, signal);
0d62e5e8	497	signal = mywait (&status, 1);
c906108c SS	498	prepare_resume_reply (own_buf, status, signal);
	499	break;
	500	case 'c':
0d62e5e8	501	set_desired_inferior (0);
c906108c	502	myresume (0, 0);
0d62e5e8	503	signal = mywait (&status, 1);
c906108c SS	504	prepare_resume_reply (own_buf, status, signal);
	505	break;
	506	case 's':
0d62e5e8	507	set_desired_inferior (0);
c906108c	508	myresume (1, 0);
0d62e5e8	509	signal = mywait (&status, 1);
c906108c SS	510	prepare_resume_reply (own_buf, status, signal);
	511	break;
	512	case 'k':
	513	fprintf (stderr, "Killing inferior\n");
	514	kill_inferior ();
	515	/* When using the extended protocol, we start up a new
c5aa993b	516	debugging session. The traditional protocol will
c906108c SS	517	exit instead. */
	518	if (extended_protocol)
	519	{
	520	write_ok (own_buf);
	521	fprintf (stderr, "GDBserver restarting\n");
	522
	523	/* Wait till we are at 1st instruction in prog. */
	524	signal = start_inferior (&argv[2], &status);
	525	goto restart;
	526	break;
	527	}
	528	else
	529	{
	530	exit (0);
	531	break;
	532	}
	533	case 'T':
a1928bad	534	if (mythread_alive (strtoul (&own_buf[1], NULL, 16)))
c906108c SS	535	write_ok (own_buf);
	536	else
	537	write_enn (own_buf);
	538	break;
	539	case 'R':
	540	/* Restarting the inferior is only supported in the
c5aa993b	541	extended protocol. */
c906108c SS	542	if (extended_protocol)
	543	{
	544	kill_inferior ();
	545	write_ok (own_buf);
	546	fprintf (stderr, "GDBserver restarting\n");
	547
	548	/* Wait till we are at 1st instruction in prog. */
	549	signal = start_inferior (&argv[2], &status);
	550	goto restart;
	551	break;
	552	}
	553	else
	554	{
	555	/* It is a request we don't understand. Respond with an
	556	empty packet so that gdb knows that we don't support this
	557	request. */
	558	own_buf[0] = '\0';
	559	break;
	560	}
64386c31 DJ	561	case 'v':
	562	/* Extended (long) request. */
	563	handle_v_requests (own_buf, &status, &signal);
	564	break;
c906108c SS	565	default:
c906108c SS	566	/* It is a request we don't understand. Respond with an
c5aa993b JM	567	empty packet so that gdb knows that we don't support this
c5aa993b JM	568	request. */
c906108c SS	569	own_buf[0] = '\0';
	570	break;
	571	}
	572
	573	putpkt (own_buf);
	574
	575	if (status == 'W')
	576	fprintf (stderr,
3a7fb99b	577	"\nChild exited with status %d\n", signal);
c906108c	578	if (status == 'X')
3a7fb99b DJ	579	fprintf (stderr, "\nChild terminated with signal = 0x%x\n",
3a7fb99b DJ	580	signal);
c906108c SS	581	if (status == 'W' \|\| status == 'X')
	582	{
	583	if (extended_protocol)
	584	{
	585	fprintf (stderr, "Killing inferior\n");
	586	kill_inferior ();
	587	write_ok (own_buf);
	588	fprintf (stderr, "GDBserver restarting\n");
	589
	590	/* Wait till we are at 1st instruction in prog. */
	591	signal = start_inferior (&argv[2], &status);
	592	goto restart;
	593	break;
	594	}
	595	else
	596	{
	597	fprintf (stderr, "GDBserver exiting\n");
	598	exit (0);
	599	}
	600	}
	601	}
	602
	603	/* We come here when getpkt fails.
	604
c5aa993b JM	605	For the extended remote protocol we exit (and this is the only
c5aa993b JM	606	way we gracefully exit!).
c906108c	607
c5aa993b JM	608	For the traditional remote protocol close the connection,
c5aa993b JM	609	and re-open it at the top of the loop. */
c906108c SS	610	if (extended_protocol)
	611	{
	612	remote_close ();
	613	exit (0);
	614	}
	615	else
	616	{
45b7b345 DJ	617	fprintf (stderr, "Remote side has terminated connection. "
45b7b345 DJ	618	"GDBserver will reopen the connection.\n");
c906108c SS	619	remote_close ();
	620	}
	621	}
	622	}