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

/* Main code for remote server for GDB.
   Copyright (C) 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., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, 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 int
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, int *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%x", thread_to_gdb_id ((struct thread_info *)thread_ptr));
      thread_ptr = thread_ptr->next;
      return;
    }

  if (strcmp ("qsThreadInfo", own_buf) == 0)
    {
      if (thread_ptr != NULL)
	{
	  sprintf (own_buf, "m%x", thread_to_gdb_id ((struct thread_info *)thread_ptr));
	  thread_ptr = thread_ptr->next;
	  return;
	}
      else
	{
	  sprintf (own_buf, "l");
	  return;
	}
    }

  if (the_target->read_auxv != NULL
      && strncmp ("qPart:auxv:read::", own_buf, 17) == 0)
    {
      unsigned 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, int *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] == ':')
	{
	  unsigned int gdb_id = strtoul (p + 1, &q, 16);
	  unsigned long thread_id;

	  if (p == q)
	    goto err;
	  p = q;
	  if (p[0] != ';' && p[0] != 0)
	    goto err;

	  thread_id = gdb_id_to_thread_id (gdb_id);
	  if (thread_id)
	    resume_info[i].thread = thread_id;
	  else
	    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, int *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 && cont_thread != -1))
    {
      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 && cont_thread != -1);

  (*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;
  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 (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);
  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 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':
	      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 '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;
	    }

	  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.
6f0f660e	2	Copyright (C) 1989, 1993, 1994, 1995, 1997, 1998, 1999, 2000, 2002, 2003, 2004,
a1928bad	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
c5aa993b JM	19	along with this program; if not, write to the Free Software
6f0f660e EZ	20	Foundation, Inc., 51 Franklin Street, Fifth Floor,
6f0f660e EZ	21	Boston, MA 02110-1301, 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
fc620387	46	static int
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	65	static int
fc620387	66	attach_inferior (int pid, char statusptr, int sigptr)
45b7b345 DJ	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;
a06660f7	106	sprintf (own_buf, "m%x", thread_to_gdb_id ((struct thread_info *)thread_ptr));
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	{
a06660f7	115	sprintf (own_buf, "m%x", thread_to_gdb_id ((struct thread_info *)thread_ptr));
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	{
f450004a	129	unsigned char data[(PBUFSIZ - 1) / 2];
aa691b87 RM	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. */
64386c31 DJ	152	void
fc620387	153	handle_v_cont (char own_buf, char status, int *signal)
64386c31 DJ	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	{
a06660f7 DJ	221	unsigned int gdb_id = strtoul (p + 1, &q, 16);
	222	unsigned long thread_id;
	223
64386c31 DJ	224	if (p == q)
	225	goto err;
	226	p = q;
	227	if (p[0] != ';' && p[0] != 0)
	228	goto err;
	229
a06660f7 DJ	230	thread_id = gdb_id_to_thread_id (gdb_id);
	231	if (thread_id)
	232	resume_info[i].thread = thread_id;
	233	else
	234	goto err;
	235
64386c31 DJ	236	i++;
	237	}
	238	}
	239
	240	resume_info[i] = default_action;
	241
	242	/* Still used in occasional places in the backend. */
	243	if (n == 1 && resume_info[0].thread != -1)
	244	cont_thread = resume_info[0].thread;
	245	else
	246	cont_thread = -1;
dc3f8883	247	set_desired_inferior (0);
64386c31 DJ	248
	249	(*the_target->resume) (resume_info);
	250
	251	free (resume_info);
	252
	253	*signal = mywait (status, 1);
	254	prepare_resume_reply (own_buf, status, signal);
	255	return;
	256
	257	err:
	258	/* No other way to report an error... */
	259	strcpy (own_buf, "");
	260	free (resume_info);
	261	return;
	262	}
	263
	264	/* Handle all of the extended 'v' packets. */
	265	void
fc620387	266	handle_v_requests (char own_buf, char status, int *signal)
64386c31 DJ	267	{
	268	if (strncmp (own_buf, "vCont;", 6) == 0)
	269	{
	270	handle_v_cont (own_buf, status, signal);
	271	return;
	272	}
	273
	274	if (strncmp (own_buf, "vCont?", 6) == 0)
	275	{
	276	strcpy (own_buf, "vCont;c;C;s;S");
	277	return;
	278	}
	279
	280	/* Otherwise we didn't know what packet it was. Say we didn't
	281	understand it. */
	282	own_buf[0] = 0;
	283	return;
	284	}
	285
	286	void
	287	myresume (int step, int sig)
	288	{
	289	struct thread_resume resume_info[2];
	290	int n = 0;
	291
d592fa2f	292	if (step \|\| sig \|\| (cont_thread != 0 && cont_thread != -1))
64386c31 DJ	293	{
	294	resume_info[0].thread
	295	= ((struct inferior_list_entry *) current_inferior)->id;
	296	resume_info[0].step = step;
	297	resume_info[0].sig = sig;
	298	resume_info[0].leave_stopped = 0;
	299	n++;
	300	}
	301	resume_info[n].thread = -1;
	302	resume_info[n].step = 0;
	303	resume_info[n].sig = 0;
d592fa2f	304	resume_info[n].leave_stopped = (cont_thread != 0 && cont_thread != -1);
64386c31 DJ	305
	306	(*the_target->resume) (resume_info);
	307	}
	308
0729219d	309	static int attached;
c906108c	310
0bc68c49 DJ	311	static void
	312	gdbserver_usage (void)
	313	{
	314	error ("Usage:\tgdbserver COMM PROG [ARGS ...]\n"
	315	"\tgdbserver COMM --attach PID\n"
	316	"\n"
	317	"COMM may either be a tty device (for serial debugging), or \n"
	318	"HOST:PORT to listen for a TCP connection.\n");
	319	}
	320
c906108c	321	int
da85418c	322	main (int argc, char *argv[])
c906108c	323	{
f450004a	324	char ch, status, *own_buf;
7fb85e41	325	unsigned char *mem_buf;
c906108c	326	int i = 0;
fc620387	327	int signal;
c906108c SS	328	unsigned int len;
c906108c SS	329	CORE_ADDR mem_addr;
0729219d DJ	330	int bad_attach;
0729219d DJ	331	int pid;
45b7b345	332	char *arg_end;
c906108c	333
c5aa993b	334	if (setjmp (toplevel))
c906108c	335	{
c5aa993b JM	336	fprintf (stderr, "Exiting\n");
c5aa993b JM	337	exit (1);
c906108c SS	338	}
c906108c SS	339
0729219d DJ	340	bad_attach = 0;
	341	pid = 0;
	342	attached = 0;
45b7b345 DJ	343	if (argc >= 3 && strcmp (argv[2], "--attach") == 0)
	344	{
	345	if (argc == 4
	346	&& argv[3] != '\0'
	347	&& (pid = strtoul (argv[3], &arg_end, 10)) != 0
	348	&& *arg_end == '\0')
	349	{
	350	;
	351	}
	352	else
	353	bad_attach = 1;
	354	}
	355
	356	if (argc < 3 \|\| bad_attach)
0bc68c49	357	gdbserver_usage();
c906108c	358
4ce44c66 JM	359	initialize_low ();
4ce44c66 JM	360
0a30fbc4	361	own_buf = malloc (PBUFSIZ);
7fb85e41	362	mem_buf = malloc (PBUFSIZ);
0a30fbc4	363
45b7b345 DJ	364	if (pid == 0)
	365	{
	366	/* Wait till we are at first instruction in program. */
	367	signal = start_inferior (&argv[2], &status);
c906108c	368
45b7b345 DJ	369	/* We are now stopped at the first instruction of the target process */
	370	}
	371	else
	372	{
	373	switch (attach_inferior (pid, &status, &signal))
	374	{
	375	case -1:
	376	error ("Attaching not supported on this target");
	377	break;
	378	default:
	379	attached = 1;
	380	break;
	381	}
	382	}
c906108c SS	383
	384	while (1)
	385	{
	386	remote_open (argv[1]);
	387
c5aa993b JM	388	restart:
c5aa993b JM	389	setjmp (toplevel);
c906108c SS	390	while (getpkt (own_buf) > 0)
	391	{
	392	unsigned char sig;
	393	i = 0;
	394	ch = own_buf[i++];
	395	switch (ch)
	396	{
ce3a066d DJ	397	case 'q':
	398	handle_query (own_buf);
	399	break;
c906108c SS	400	case 'd':
	401	remote_debug = !remote_debug;
	402	break;
6ad8ae5c DJ	403	case 'D':
	404	fprintf (stderr, "Detaching from inferior\n");
	405	detach_inferior ();
	406	write_ok (own_buf);
	407	putpkt (own_buf);
aa691b87	408	remote_close ();
6ad8ae5c DJ	409
	410	/* If we are attached, then we can exit. Otherwise, we need to
	411	hang around doing nothing, until the child is gone. */
	412	if (!attached)
	413	{
	414	int status, ret;
	415
	416	do {
	417	ret = waitpid (signal_pid, &status, 0);
	418	if (WIFEXITED (status) \|\| WIFSIGNALED (status))
	419	break;
	420	} while (ret != -1 \|\| errno != ECHILD);
	421	}
	422
	423	exit (0);
	424
c906108c	425	case '!':
45b7b345 DJ	426	if (attached == 0)
	427	{
	428	extended_protocol = 1;
	429	prepare_resume_reply (own_buf, status, signal);
	430	}
	431	else
	432	{
	433	/* We can not use the extended protocol if we are
	434	attached, because we can not restart the running
	435	program. So return unrecognized. */
	436	own_buf[0] = '\0';
	437	}
c906108c SS	438	break;
	439	case '?':
	440	prepare_resume_reply (own_buf, status, signal);
	441	break;
	442	case 'H':
a06660f7	443	if (own_buf[1] == 'c' \|\| own_buf[1] == 'g' \|\| own_buf[1] == 's')
c906108c	444	{
a06660f7 DJ	445	unsigned long gdb_id, thread_id;
	446
	447	gdb_id = strtoul (&own_buf[2], NULL, 16);
	448	thread_id = gdb_id_to_thread_id (gdb_id);
	449	if (thread_id == 0)
	450	{
	451	write_enn (own_buf);
	452	break;
	453	}
	454
	455	if (own_buf[1] == 'g')
	456	{
	457	general_thread = thread_id;
	458	set_desired_inferior (1);
	459	}
	460	else if (own_buf[1] == 'c')
	461	cont_thread = thread_id;
	462	else if (own_buf[1] == 's')
	463	step_thread = thread_id;
	464
0d62e5e8	465	write_ok (own_buf);
a06660f7 DJ	466	}
	467	else
	468	{
c906108c SS	469	/* Silently ignore it so that gdb can extend the protocol
	470	without compatibility headaches. */
	471	own_buf[0] = '\0';
c906108c SS	472	}
	473	break;
	474	case 'g':
0d62e5e8	475	set_desired_inferior (1);
0a30fbc4	476	registers_to_string (own_buf);
c906108c SS	477	break;
c906108c SS	478	case 'G':
0d62e5e8	479	set_desired_inferior (1);
0a30fbc4	480	registers_from_string (&own_buf[1]);
c906108c SS	481	write_ok (own_buf);
	482	break;
	483	case 'm':
	484	decode_m_packet (&own_buf[1], &mem_addr, &len);
c3e735a6 DJ	485	if (read_inferior_memory (mem_addr, mem_buf, len) == 0)
	486	convert_int_to_ascii (mem_buf, own_buf, len);
	487	else
	488	write_enn (own_buf);
c906108c SS	489	break;
	490	case 'M':
	491	decode_M_packet (&own_buf[1], &mem_addr, &len, mem_buf);
	492	if (write_inferior_memory (mem_addr, mem_buf, len) == 0)
	493	write_ok (own_buf);
	494	else
	495	write_enn (own_buf);
	496	break;
	497	case 'C':
	498	convert_ascii_to_int (own_buf + 1, &sig, 1);
0e98d0a7 DJ	499	if (target_signal_to_host_p (sig))
	500	signal = target_signal_to_host (sig);
	501	else
	502	signal = 0;
0d62e5e8	503	set_desired_inferior (0);
0e98d0a7	504	myresume (0, signal);
0d62e5e8	505	signal = mywait (&status, 1);
c906108c SS	506	prepare_resume_reply (own_buf, status, signal);
	507	break;
	508	case 'S':
	509	convert_ascii_to_int (own_buf + 1, &sig, 1);
0e98d0a7 DJ	510	if (target_signal_to_host_p (sig))
	511	signal = target_signal_to_host (sig);
	512	else
	513	signal = 0;
0d62e5e8	514	set_desired_inferior (0);
0e98d0a7	515	myresume (1, signal);
0d62e5e8	516	signal = mywait (&status, 1);
c906108c SS	517	prepare_resume_reply (own_buf, status, signal);
	518	break;
	519	case 'c':
0d62e5e8	520	set_desired_inferior (0);
c906108c	521	myresume (0, 0);
0d62e5e8	522	signal = mywait (&status, 1);
c906108c SS	523	prepare_resume_reply (own_buf, status, signal);
	524	break;
	525	case 's':
0d62e5e8	526	set_desired_inferior (0);
c906108c	527	myresume (1, 0);
0d62e5e8	528	signal = mywait (&status, 1);
c906108c SS	529	prepare_resume_reply (own_buf, status, signal);
c906108c SS	530	break;
e013ee27 OF	531	case 'Z':
	532	{
	533	char *lenptr;
	534	char *dataptr;
	535	CORE_ADDR addr = strtoul (&own_buf[3], &lenptr, 16);
	536	int len = strtol (lenptr + 1, &dataptr, 16);
	537	char type = own_buf[1];
	538
	539	if (the_target->insert_watchpoint == NULL
	540	\|\| (type < '2' \|\| type > '4'))
	541	{
	542	/* No watchpoint support or not a watchpoint command;
	543	unrecognized either way. */
	544	own_buf[0] = '\0';
	545	}
	546	else
	547	{
	548	int res;
	549
	550	res = (*the_target->insert_watchpoint) (type, addr, len);
	551	if (res == 0)
	552	write_ok (own_buf);
	553	else if (res == 1)
	554	/* Unsupported. */
	555	own_buf[0] = '\0';
	556	else
	557	write_enn (own_buf);
	558	}
	559	break;
	560	}
	561	case 'z':
	562	{
	563	char *lenptr;
	564	char *dataptr;
	565	CORE_ADDR addr = strtoul (&own_buf[3], &lenptr, 16);
	566	int len = strtol (lenptr + 1, &dataptr, 16);
	567	char type = own_buf[1];
	568
	569	if (the_target->remove_watchpoint == NULL
	570	\|\| (type < '2' \|\| type > '4'))
	571	{
	572	/* No watchpoint support or not a watchpoint command;
	573	unrecognized either way. */
	574	own_buf[0] = '\0';
	575	}
	576	else
	577	{
	578	int res;
	579
	580	res = (*the_target->remove_watchpoint) (type, addr, len);
	581	if (res == 0)
	582	write_ok (own_buf);
	583	else if (res == 1)
	584	/* Unsupported. */
	585	own_buf[0] = '\0';
	586	else
	587	write_enn (own_buf);
	588	}
	589	break;
	590	}
c906108c SS	591	case 'k':
	592	fprintf (stderr, "Killing inferior\n");
	593	kill_inferior ();
	594	/* When using the extended protocol, we start up a new
c5aa993b	595	debugging session. The traditional protocol will
c906108c SS	596	exit instead. */
	597	if (extended_protocol)
	598	{
	599	write_ok (own_buf);
	600	fprintf (stderr, "GDBserver restarting\n");
	601
	602	/* Wait till we are at 1st instruction in prog. */
	603	signal = start_inferior (&argv[2], &status);
	604	goto restart;
	605	break;
	606	}
	607	else
	608	{
	609	exit (0);
	610	break;
	611	}
	612	case 'T':
a06660f7 DJ	613	{
	614	unsigned long gdb_id, thread_id;
	615
	616	gdb_id = strtoul (&own_buf[1], NULL, 16);
	617	thread_id = gdb_id_to_thread_id (gdb_id);
	618	if (thread_id == 0)
	619	{
	620	write_enn (own_buf);
	621	break;
	622	}
	623
	624	if (mythread_alive (thread_id))
	625	write_ok (own_buf);
	626	else
	627	write_enn (own_buf);
	628	}
c906108c SS	629	break;
	630	case 'R':
	631	/* Restarting the inferior is only supported in the
c5aa993b	632	extended protocol. */
c906108c SS	633	if (extended_protocol)
	634	{
	635	kill_inferior ();
	636	write_ok (own_buf);
	637	fprintf (stderr, "GDBserver restarting\n");
	638
	639	/* Wait till we are at 1st instruction in prog. */
	640	signal = start_inferior (&argv[2], &status);
	641	goto restart;
	642	break;
	643	}
	644	else
	645	{
	646	/* It is a request we don't understand. Respond with an
	647	empty packet so that gdb knows that we don't support this
	648	request. */
	649	own_buf[0] = '\0';
	650	break;
	651	}
64386c31 DJ	652	case 'v':
	653	/* Extended (long) request. */
	654	handle_v_requests (own_buf, &status, &signal);
	655	break;
c906108c SS	656	default:
c906108c SS	657	/* It is a request we don't understand. Respond with an
c5aa993b JM	658	empty packet so that gdb knows that we don't support this
c5aa993b JM	659	request. */
c906108c SS	660	own_buf[0] = '\0';
	661	break;
	662	}
	663
	664	putpkt (own_buf);
	665
	666	if (status == 'W')
	667	fprintf (stderr,
3a7fb99b	668	"\nChild exited with status %d\n", signal);
c906108c	669	if (status == 'X')
3a7fb99b DJ	670	fprintf (stderr, "\nChild terminated with signal = 0x%x\n",
3a7fb99b DJ	671	signal);
c906108c SS	672	if (status == 'W' \|\| status == 'X')
	673	{
	674	if (extended_protocol)
	675	{
	676	fprintf (stderr, "Killing inferior\n");
	677	kill_inferior ();
	678	write_ok (own_buf);
	679	fprintf (stderr, "GDBserver restarting\n");
	680
	681	/* Wait till we are at 1st instruction in prog. */
	682	signal = start_inferior (&argv[2], &status);
	683	goto restart;
	684	break;
	685	}
	686	else
	687	{
	688	fprintf (stderr, "GDBserver exiting\n");
	689	exit (0);
	690	}
	691	}
	692	}
	693
	694	/* We come here when getpkt fails.
	695
c5aa993b JM	696	For the extended remote protocol we exit (and this is the only
c5aa993b JM	697	way we gracefully exit!).
c906108c	698
c5aa993b JM	699	For the traditional remote protocol close the connection,
c5aa993b JM	700	and re-open it at the top of the loop. */
c906108c SS	701	if (extended_protocol)
	702	{
	703	remote_close ();
	704	exit (0);
	705	}
	706	else
	707	{
45b7b345 DJ	708	fprintf (stderr, "Remote side has terminated connection. "
45b7b345 DJ	709	"GDBserver will reopen the connection.\n");
c906108c SS	710	remote_close ();
	711	}
	712	}
	713	}