1/* Main code for remote server for GDB.
2   Copyright (C) 1989, 1993, 1994, 1995, 1997, 1998, 1999, 2000, 2002, 2003,
3   2004, 2005, 2006, 2007 Free Software Foundation, Inc.
4
5   This file is part of GDB.
6
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 3 of the License, or
10   (at your option) any later version.
11
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.
16
17   You should have received a copy of the GNU General Public License
18   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
19
20#include "server.h"
21
22#if HAVE_UNISTD_H
23#include <unistd.h>
24#endif
25#if HAVE_SIGNAL_H
26#include <signal.h>
27#endif
28#if HAVE_SYS_WAIT_H
29#include <sys/wait.h>
30#endif
31
32unsigned long cont_thread;
33unsigned long general_thread;
34unsigned long step_thread;
35unsigned long thread_from_wait;
36unsigned long old_thread_from_wait;
37int extended_protocol;
38int server_waiting;
39
40/* Enable miscellaneous debugging output.  The name is historical - it
41   was originally used to debug LinuxThreads support.  */
42int debug_threads;
43
44int pass_signals[TARGET_SIGNAL_LAST];
45
46jmp_buf toplevel;
47
48/* The PID of the originally created or attached inferior.  Used to
49   send signals to the process when GDB sends us an asynchronous interrupt
50   (user hitting Control-C in the client), and to wait for the child to exit
51   when no longer debugging it.  */
52
53unsigned long signal_pid;
54
55#ifdef SIGTTOU
56/* A file descriptor for the controlling terminal.  */
57int terminal_fd;
58
59/* TERMINAL_FD's original foreground group.  */
60pid_t old_foreground_pgrp;
61
62/* Hand back terminal ownership to the original foreground group.  */
63
64static void
65restore_old_foreground_pgrp (void)
66{
67  tcsetpgrp (terminal_fd, old_foreground_pgrp);
68}
69#endif
70
71static int
72start_inferior (char *argv[], char *statusptr)
73{
74#ifdef SIGTTOU
75  signal (SIGTTOU, SIG_DFL);
76  signal (SIGTTIN, SIG_DFL);
77#endif
78
79  signal_pid = create_inferior (argv[0], argv);
80
81  /* FIXME: we don't actually know at this point that the create
82     actually succeeded.  We won't know that until we wait.  */
83  fprintf (stderr, "Process %s created; pid = %ld\n", argv[0],
84	   signal_pid);
85  fflush (stderr);
86
87#ifdef SIGTTOU
88  signal (SIGTTOU, SIG_IGN);
89  signal (SIGTTIN, SIG_IGN);
90  terminal_fd = fileno (stderr);
91  old_foreground_pgrp = tcgetpgrp (terminal_fd);
92  tcsetpgrp (terminal_fd, signal_pid);
93  atexit (restore_old_foreground_pgrp);
94#endif
95
96  /* Wait till we are at 1st instruction in program, return signal
97     number (assuming success).  */
98  return mywait (statusptr, 0);
99}
100
101static int
102attach_inferior (int pid, char *statusptr, int *sigptr)
103{
104  /* myattach should return -1 if attaching is unsupported,
105     0 if it succeeded, and call error() otherwise.  */
106
107  if (myattach (pid) != 0)
108    return -1;
109
110  fprintf (stderr, "Attached; pid = %d\n", pid);
111  fflush (stderr);
112
113  /* FIXME - It may be that we should get the SIGNAL_PID from the
114     attach function, so that it can be the main thread instead of
115     whichever we were told to attach to.  */
116  signal_pid = pid;
117
118  *sigptr = mywait (statusptr, 0);
119
120  /* GDB knows to ignore the first SIGSTOP after attaching to a running
121     process using the "attach" command, but this is different; it's
122     just using "target remote".  Pretend it's just starting up.  */
123  if (*statusptr == 'T' && *sigptr == TARGET_SIGNAL_STOP)
124    *sigptr = TARGET_SIGNAL_TRAP;
125
126  return 0;
127}
128
129extern int remote_debug;
130
131/* Decode a qXfer read request.  Return 0 if everything looks OK,
132   or -1 otherwise.  */
133
134static int
135decode_xfer_read (char *buf, char **annex, CORE_ADDR *ofs, unsigned int *len)
136{
137  /* Extract and NUL-terminate the annex.  */
138  *annex = buf;
139  while (*buf && *buf != ':')
140    buf++;
141  if (*buf == '\0')
142    return -1;
143  *buf++ = 0;
144
145  /* After the read marker and annex, qXfer looks like a
146     traditional 'm' packet.  */
147  decode_m_packet (buf, ofs, len);
148
149  return 0;
150}
151
152/* Write the response to a successful qXfer read.  Returns the
153   length of the (binary) data stored in BUF, corresponding
154   to as much of DATA/LEN as we could fit.  IS_MORE controls
155   the first character of the response.  */
156static int
157write_qxfer_response (char *buf, const void *data, int len, int is_more)
158{
159  int out_len;
160
161  if (is_more)
162    buf[0] = 'm';
163  else
164    buf[0] = 'l';
165
166  return remote_escape_output (data, len, (unsigned char *) buf + 1, &out_len,
167			       PBUFSIZ - 2) + 1;
168}
169
170/* Handle all of the extended 'Q' packets.  */
171void
172handle_general_set (char *own_buf)
173{
174  if (strncmp ("QPassSignals:", own_buf, strlen ("QPassSignals:")) == 0)
175    {
176      int numsigs = (int) TARGET_SIGNAL_LAST, i;
177      const char *p = own_buf + strlen ("QPassSignals:");
178      CORE_ADDR cursig;
179
180      p = decode_address_to_semicolon (&cursig, p);
181      for (i = 0; i < numsigs; i++)
182	{
183	  if (i == cursig)
184	    {
185	      pass_signals[i] = 1;
186	      if (*p == '\0')
187		/* Keep looping, to clear the remaining signals.  */
188		cursig = -1;
189	      else
190		p = decode_address_to_semicolon (&cursig, p);
191	    }
192	  else
193	    pass_signals[i] = 0;
194	}
195      strcpy (own_buf, "OK");
196      return;
197    }
198
199  /* Otherwise we didn't know what packet it was.  Say we didn't
200     understand it.  */
201  own_buf[0] = 0;
202}
203
204static const char *
205get_features_xml (const char *annex)
206{
207  static int features_supported = -1;
208  static char *document;
209
210#ifdef USE_XML
211  extern const char *const xml_builtin[][2];
212  int i;
213
214  /* Look for the annex.  */
215  for (i = 0; xml_builtin[i][0] != NULL; i++)
216    if (strcmp (annex, xml_builtin[i][0]) == 0)
217      break;
218
219  if (xml_builtin[i][0] != NULL)
220    return xml_builtin[i][1];
221#endif
222
223  if (strcmp (annex, "target.xml") != 0)
224    return NULL;
225
226  if (features_supported == -1)
227    {
228      const char *arch = NULL;
229      if (the_target->arch_string != NULL)
230	arch = (*the_target->arch_string) ();
231
232      if (arch == NULL)
233	features_supported = 0;
234      else
235	{
236	  features_supported = 1;
237	  document = malloc (64 + strlen (arch));
238	  snprintf (document, 64 + strlen (arch),
239		    "<target><architecture>%s</architecture></target>",
240		    arch);
241	}
242    }
243
244  return document;
245}
246
247void
248monitor_show_help (void)
249{
250  monitor_output ("The following monitor commands are supported:\n");
251  monitor_output ("  set debug <0|1>\n");
252  monitor_output ("    Enable general debugging messages\n");
253  monitor_output ("  set remote-debug <0|1>\n");
254  monitor_output ("    Enable remote protocol debugging messages\n");
255}
256
257/* Handle all of the extended 'q' packets.  */
258void
259handle_query (char *own_buf, int packet_len, int *new_packet_len_p)
260{
261  static struct inferior_list_entry *thread_ptr;
262
263  /* Reply the current thread id.  */
264  if (strcmp ("qC", own_buf) == 0)
265    {
266      thread_ptr = all_threads.head;
267      sprintf (own_buf, "QC%x",
268	thread_to_gdb_id ((struct thread_info *)thread_ptr));
269      return;
270    }
271
272  if (strcmp ("qSymbol::", own_buf) == 0)
273    {
274      if (the_target->look_up_symbols != NULL)
275	(*the_target->look_up_symbols) ();
276
277      strcpy (own_buf, "OK");
278      return;
279    }
280
281  if (strcmp ("qfThreadInfo", own_buf) == 0)
282    {
283      thread_ptr = all_threads.head;
284      sprintf (own_buf, "m%x", thread_to_gdb_id ((struct thread_info *)thread_ptr));
285      thread_ptr = thread_ptr->next;
286      return;
287    }
288
289  if (strcmp ("qsThreadInfo", own_buf) == 0)
290    {
291      if (thread_ptr != NULL)
292	{
293	  sprintf (own_buf, "m%x", thread_to_gdb_id ((struct thread_info *)thread_ptr));
294	  thread_ptr = thread_ptr->next;
295	  return;
296	}
297      else
298	{
299	  sprintf (own_buf, "l");
300	  return;
301	}
302    }
303
304  if (the_target->read_offsets != NULL
305      && strcmp ("qOffsets", own_buf) == 0)
306    {
307      CORE_ADDR text, data;
308
309      if (the_target->read_offsets (&text, &data))
310	sprintf (own_buf, "Text=%lX;Data=%lX;Bss=%lX",
311		 (long)text, (long)data, (long)data);
312      else
313	write_enn (own_buf);
314
315      return;
316    }
317
318  if (the_target->qxfer_spu != NULL
319      && strncmp ("qXfer:spu:read:", own_buf, 15) == 0)
320    {
321      char *annex;
322      int n;
323      unsigned int len;
324      CORE_ADDR ofs;
325      unsigned char *spu_buf;
326
327      strcpy (own_buf, "E00");
328      if (decode_xfer_read (own_buf + 15, &annex, &ofs, &len) < 0)
329	  return;
330      if (len > PBUFSIZ - 2)
331	len = PBUFSIZ - 2;
332      spu_buf = malloc (len + 1);
333      if (!spu_buf)
334        return;
335
336      n = (*the_target->qxfer_spu) (annex, spu_buf, NULL, ofs, len + 1);
337      if (n < 0)
338	write_enn (own_buf);
339      else if (n > len)
340	*new_packet_len_p = write_qxfer_response
341			      (own_buf, spu_buf, len, 1);
342      else
343	*new_packet_len_p = write_qxfer_response
344			      (own_buf, spu_buf, n, 0);
345
346      free (spu_buf);
347      return;
348    }
349
350  if (the_target->qxfer_spu != NULL
351      && strncmp ("qXfer:spu:write:", own_buf, 16) == 0)
352    {
353      char *annex;
354      int n;
355      unsigned int len;
356      CORE_ADDR ofs;
357      unsigned char *spu_buf;
358
359      strcpy (own_buf, "E00");
360      spu_buf = malloc (packet_len - 15);
361      if (!spu_buf)
362        return;
363      if (decode_xfer_write (own_buf + 16, packet_len - 16, &annex,
364			     &ofs, &len, spu_buf) < 0)
365	{
366	  free (spu_buf);
367	  return;
368	}
369
370      n = (*the_target->qxfer_spu)
371	(annex, NULL, (unsigned const char *)spu_buf, ofs, len);
372      if (n < 0)
373	write_enn (own_buf);
374      else
375	sprintf (own_buf, "%x", n);
376
377      free (spu_buf);
378      return;
379    }
380
381  if (the_target->read_auxv != NULL
382      && strncmp ("qXfer:auxv:read:", own_buf, 16) == 0)
383    {
384      unsigned char *data;
385      int n;
386      CORE_ADDR ofs;
387      unsigned int len;
388      char *annex;
389
390      /* Reject any annex; grab the offset and length.  */
391      if (decode_xfer_read (own_buf + 16, &annex, &ofs, &len) < 0
392	  || annex[0] != '\0')
393	{
394	  strcpy (own_buf, "E00");
395	  return;
396	}
397
398      /* Read one extra byte, as an indicator of whether there is
399	 more.  */
400      if (len > PBUFSIZ - 2)
401	len = PBUFSIZ - 2;
402      data = malloc (len + 1);
403      n = (*the_target->read_auxv) (ofs, data, len + 1);
404      if (n < 0)
405	write_enn (own_buf);
406      else if (n > len)
407	*new_packet_len_p = write_qxfer_response (own_buf, data, len, 1);
408      else
409	*new_packet_len_p = write_qxfer_response (own_buf, data, n, 0);
410
411      free (data);
412
413      return;
414    }
415
416  if (strncmp ("qXfer:features:read:", own_buf, 20) == 0)
417    {
418      CORE_ADDR ofs;
419      unsigned int len, total_len;
420      const char *document;
421      char *annex;
422
423      /* Check for support.  */
424      document = get_features_xml ("target.xml");
425      if (document == NULL)
426	{
427	  own_buf[0] = '\0';
428	  return;
429	}
430
431      /* Grab the annex, offset, and length.  */
432      if (decode_xfer_read (own_buf + 20, &annex, &ofs, &len) < 0)
433	{
434	  strcpy (own_buf, "E00");
435	  return;
436	}
437
438      /* Now grab the correct annex.  */
439      document = get_features_xml (annex);
440      if (document == NULL)
441	{
442	  strcpy (own_buf, "E00");
443	  return;
444	}
445
446      total_len = strlen (document);
447      if (len > PBUFSIZ - 2)
448	len = PBUFSIZ - 2;
449
450      if (ofs > total_len)
451	write_enn (own_buf);
452      else if (len < total_len - ofs)
453	*new_packet_len_p = write_qxfer_response (own_buf, document + ofs,
454						  len, 1);
455      else
456	*new_packet_len_p = write_qxfer_response (own_buf, document + ofs,
457						  total_len - ofs, 0);
458
459      return;
460    }
461
462  if (strncmp ("qXfer:libraries:read:", own_buf, 21) == 0)
463    {
464      CORE_ADDR ofs;
465      unsigned int len, total_len;
466      char *document, *p;
467      struct inferior_list_entry *dll_ptr;
468      char *annex;
469
470      /* Reject any annex; grab the offset and length.  */
471      if (decode_xfer_read (own_buf + 21, &annex, &ofs, &len) < 0
472	  || annex[0] != '\0')
473	{
474	  strcpy (own_buf, "E00");
475	  return;
476	}
477
478      /* Over-estimate the necessary memory.  Assume that every character
479	 in the library name must be escaped.  */
480      total_len = 64;
481      for (dll_ptr = all_dlls.head; dll_ptr != NULL; dll_ptr = dll_ptr->next)
482	total_len += 128 + 6 * strlen (((struct dll_info *) dll_ptr)->name);
483
484      document = malloc (total_len);
485      strcpy (document, "<library-list>\n");
486      p = document + strlen (document);
487
488      for (dll_ptr = all_dlls.head; dll_ptr != NULL; dll_ptr = dll_ptr->next)
489	{
490	  struct dll_info *dll = (struct dll_info *) dll_ptr;
491	  char *name;
492
493	  strcpy (p, "  <library name=\"");
494	  p = p + strlen (p);
495	  name = xml_escape_text (dll->name);
496	  strcpy (p, name);
497	  free (name);
498	  p = p + strlen (p);
499	  strcpy (p, "\"><segment address=\"");
500	  p = p + strlen (p);
501	  sprintf (p, "0x%lx", (long) dll->base_addr);
502	  p = p + strlen (p);
503	  strcpy (p, "\"/></library>\n");
504	  p = p + strlen (p);
505	}
506
507      strcpy (p, "</library-list>\n");
508
509      total_len = strlen (document);
510      if (len > PBUFSIZ - 2)
511	len = PBUFSIZ - 2;
512
513      if (ofs > total_len)
514	write_enn (own_buf);
515      else if (len < total_len - ofs)
516	*new_packet_len_p = write_qxfer_response (own_buf, document + ofs,
517						  len, 1);
518      else
519	*new_packet_len_p = write_qxfer_response (own_buf, document + ofs,
520						  total_len - ofs, 0);
521
522      free (document);
523      return;
524    }
525
526  /* Protocol features query.  */
527  if (strncmp ("qSupported", own_buf, 10) == 0
528      && (own_buf[10] == ':' || own_buf[10] == '\0'))
529    {
530      sprintf (own_buf, "PacketSize=%x;QPassSignals+", PBUFSIZ - 1);
531
532      /* We do not have any hook to indicate whether the target backend
533	 supports qXfer:libraries:read, so always report it.  */
534      strcat (own_buf, ";qXfer:libraries:read+");
535
536      if (the_target->read_auxv != NULL)
537	strcat (own_buf, ";qXfer:auxv:read+");
538
539      if (the_target->qxfer_spu != NULL)
540	strcat (own_buf, ";qXfer:spu:read+;qXfer:spu:write+");
541
542      if (get_features_xml ("target.xml") != NULL)
543	strcat (own_buf, ";qXfer:features:read+");
544
545      return;
546    }
547
548  /* Thread-local storage support.  */
549  if (the_target->get_tls_address != NULL
550      && strncmp ("qGetTLSAddr:", own_buf, 12) == 0)
551    {
552      char *p = own_buf + 12;
553      CORE_ADDR parts[3], address = 0;
554      int i, err;
555
556      for (i = 0; i < 3; i++)
557	{
558	  char *p2;
559	  int len;
560
561	  if (p == NULL)
562	    break;
563
564	  p2 = strchr (p, ',');
565	  if (p2)
566	    {
567	      len = p2 - p;
568	      p2++;
569	    }
570	  else
571	    {
572	      len = strlen (p);
573	      p2 = NULL;
574	    }
575
576	  decode_address (&parts[i], p, len);
577	  p = p2;
578	}
579
580      if (p != NULL || i < 3)
581	err = 1;
582      else
583	{
584	  struct thread_info *thread = gdb_id_to_thread (parts[0]);
585
586	  if (thread == NULL)
587	    err = 2;
588	  else
589	    err = the_target->get_tls_address (thread, parts[1], parts[2],
590					       &address);
591	}
592
593      if (err == 0)
594	{
595	  sprintf (own_buf, "%llx", address);
596	  return;
597	}
598      else if (err > 0)
599	{
600	  write_enn (own_buf);
601	  return;
602	}
603
604      /* Otherwise, pretend we do not understand this packet.  */
605    }
606
607  /* Handle "monitor" commands.  */
608  if (strncmp ("qRcmd,", own_buf, 6) == 0)
609    {
610      char *mon = malloc (PBUFSIZ);
611      int len = strlen (own_buf + 6);
612
613      if ((len % 1) != 0 || unhexify (mon, own_buf + 6, len / 2) != len / 2)
614	{
615	  write_enn (own_buf);
616	  free (mon);
617	  return;
618	}
619      mon[len / 2] = '\0';
620
621      write_ok (own_buf);
622
623      if (strcmp (mon, "set debug 1") == 0)
624	{
625	  debug_threads = 1;
626	  monitor_output ("Debug output enabled.\n");
627	}
628      else if (strcmp (mon, "set debug 0") == 0)
629	{
630	  debug_threads = 0;
631	  monitor_output ("Debug output disabled.\n");
632	}
633      else if (strcmp (mon, "set remote-debug 1") == 0)
634	{
635	  remote_debug = 1;
636	  monitor_output ("Protocol debug output enabled.\n");
637	}
638      else if (strcmp (mon, "set remote-debug 0") == 0)
639	{
640	  remote_debug = 0;
641	  monitor_output ("Protocol debug output disabled.\n");
642	}
643      else if (strcmp (mon, "help") == 0)
644	monitor_show_help ();
645      else
646	{
647	  monitor_output ("Unknown monitor command.\n\n");
648	  monitor_show_help ();
649	  write_enn (own_buf);
650	}
651
652      free (mon);
653      return;
654    }
655
656  /* Otherwise we didn't know what packet it was.  Say we didn't
657     understand it.  */
658  own_buf[0] = 0;
659}
660
661/* Parse vCont packets.  */
662void
663handle_v_cont (char *own_buf, char *status, int *signal)
664{
665  char *p, *q;
666  int n = 0, i = 0;
667  struct thread_resume *resume_info, default_action;
668
669  /* Count the number of semicolons in the packet.  There should be one
670     for every action.  */
671  p = &own_buf[5];
672  while (p)
673    {
674      n++;
675      p++;
676      p = strchr (p, ';');
677    }
678  /* Allocate room for one extra action, for the default remain-stopped
679     behavior; if no default action is in the list, we'll need the extra
680     slot.  */
681  resume_info = malloc ((n + 1) * sizeof (resume_info[0]));
682
683  default_action.thread = -1;
684  default_action.leave_stopped = 1;
685  default_action.step = 0;
686  default_action.sig = 0;
687
688  p = &own_buf[5];
689  i = 0;
690  while (*p)
691    {
692      p++;
693
694      resume_info[i].leave_stopped = 0;
695
696      if (p[0] == 's' || p[0] == 'S')
697	resume_info[i].step = 1;
698      else if (p[0] == 'c' || p[0] == 'C')
699	resume_info[i].step = 0;
700      else
701	goto err;
702
703      if (p[0] == 'S' || p[0] == 'C')
704	{
705	  int sig;
706	  sig = strtol (p + 1, &q, 16);
707	  if (p == q)
708	    goto err;
709	  p = q;
710
711	  if (!target_signal_to_host_p (sig))
712	    goto err;
713	  resume_info[i].sig = target_signal_to_host (sig);
714	}
715      else
716	{
717	  resume_info[i].sig = 0;
718	  p = p + 1;
719	}
720
721      if (p[0] == 0)
722	{
723	  resume_info[i].thread = -1;
724	  default_action = resume_info[i];
725
726	  /* Note: we don't increment i here, we'll overwrite this entry
727	     the next time through.  */
728	}
729      else if (p[0] == ':')
730	{
731	  unsigned int gdb_id = strtoul (p + 1, &q, 16);
732	  unsigned long thread_id;
733
734	  if (p == q)
735	    goto err;
736	  p = q;
737	  if (p[0] != ';' && p[0] != 0)
738	    goto err;
739
740	  thread_id = gdb_id_to_thread_id (gdb_id);
741	  if (thread_id)
742	    resume_info[i].thread = thread_id;
743	  else
744	    goto err;
745
746	  i++;
747	}
748    }
749
750  resume_info[i] = default_action;
751
752  /* Still used in occasional places in the backend.  */
753  if (n == 1 && resume_info[0].thread != -1)
754    cont_thread = resume_info[0].thread;
755  else
756    cont_thread = -1;
757  set_desired_inferior (0);
758
759  (*the_target->resume) (resume_info);
760
761  free (resume_info);
762
763  *signal = mywait (status, 1);
764  prepare_resume_reply (own_buf, *status, *signal);
765  return;
766
767err:
768  write_enn (own_buf);
769  free (resume_info);
770  return;
771}
772
773/* Handle all of the extended 'v' packets.  */
774void
775handle_v_requests (char *own_buf, char *status, int *signal)
776{
777  if (strncmp (own_buf, "vCont;", 6) == 0)
778    {
779      handle_v_cont (own_buf, status, signal);
780      return;
781    }
782
783  if (strncmp (own_buf, "vCont?", 6) == 0)
784    {
785      strcpy (own_buf, "vCont;c;C;s;S");
786      return;
787    }
788
789  /* Otherwise we didn't know what packet it was.  Say we didn't
790     understand it.  */
791  own_buf[0] = 0;
792  return;
793}
794
795void
796myresume (int step, int sig)
797{
798  struct thread_resume resume_info[2];
799  int n = 0;
800
801  if (step || sig || (cont_thread != 0 && cont_thread != -1))
802    {
803      resume_info[0].thread
804	= ((struct inferior_list_entry *) current_inferior)->id;
805      resume_info[0].step = step;
806      resume_info[0].sig = sig;
807      resume_info[0].leave_stopped = 0;
808      n++;
809    }
810  resume_info[n].thread = -1;
811  resume_info[n].step = 0;
812  resume_info[n].sig = 0;
813  resume_info[n].leave_stopped = (cont_thread != 0 && cont_thread != -1);
814
815  (*the_target->resume) (resume_info);
816}
817
818static int attached;
819
820static void
821gdbserver_version (void)
822{
823  printf ("GNU gdbserver %s\n"
824	  "Copyright (C) 2007 Free Software Foundation, Inc.\n"
825	  "gdbserver is free software, covered by the GNU General Public License.\n"
826	  "This gdbserver was configured as \"%s\"\n",
827	  version, host_name);
828}
829
830static void
831gdbserver_usage (void)
832{
833  printf ("Usage:\tgdbserver COMM PROG [ARGS ...]\n"
834	  "\tgdbserver COMM --attach PID\n"
835	  "\n"
836	  "COMM may either be a tty device (for serial debugging), or \n"
837	  "HOST:PORT to listen for a TCP connection.\n");
838}
839
840int
841main (int argc, char *argv[])
842{
843  char ch, status, *own_buf;
844  unsigned char *mem_buf;
845  int i = 0;
846  int signal;
847  unsigned int len;
848  CORE_ADDR mem_addr;
849  int bad_attach;
850  int pid;
851  char *arg_end;
852
853  if (argc >= 2 && strcmp (argv[1], "--version") == 0)
854    {
855      gdbserver_version ();
856      exit (0);
857    }
858
859  if (argc >= 2 && strcmp (argv[1], "--help") == 0)
860    {
861      gdbserver_usage ();
862      exit (0);
863    }
864
865  if (setjmp (toplevel))
866    {
867      fprintf (stderr, "Exiting\n");
868      exit (1);
869    }
870
871  bad_attach = 0;
872  pid = 0;
873  attached = 0;
874  if (argc >= 3 && strcmp (argv[2], "--attach") == 0)
875    {
876      if (argc == 4
877	  && argv[3][0] != '\0'
878	  && (pid = strtoul (argv[3], &arg_end, 10)) != 0
879	  && *arg_end == '\0')
880	{
881	  ;
882	}
883      else
884	bad_attach = 1;
885    }
886
887  if (argc < 3 || bad_attach)
888    {
889      gdbserver_usage ();
890      exit (1);
891    }
892
893  initialize_low ();
894
895  own_buf = malloc (PBUFSIZ + 1);
896  mem_buf = malloc (PBUFSIZ);
897
898  if (pid == 0)
899    {
900      /* Wait till we are at first instruction in program.  */
901      signal = start_inferior (&argv[2], &status);
902
903      /* We are now (hopefully) stopped at the first instruction of
904	 the target process.  This assumes that the target process was
905	 successfully created.  */
906
907      /* Don't report shared library events on the initial connection,
908	 even if some libraries are preloaded.  */
909      dlls_changed = 0;
910    }
911  else
912    {
913      switch (attach_inferior (pid, &status, &signal))
914	{
915	case -1:
916	  error ("Attaching not supported on this target");
917	  break;
918	default:
919	  attached = 1;
920	  break;
921	}
922    }
923
924  if (setjmp (toplevel))
925    {
926      fprintf (stderr, "Killing inferior\n");
927      kill_inferior ();
928      exit (1);
929    }
930
931  if (status == 'W' || status == 'X')
932    {
933      fprintf (stderr, "No inferior, GDBserver exiting.\n");
934      exit (1);
935    }
936
937  while (1)
938    {
939      remote_open (argv[1]);
940
941    restart:
942      setjmp (toplevel);
943      while (1)
944	{
945	  unsigned char sig;
946	  int packet_len;
947	  int new_packet_len = -1;
948
949	  packet_len = getpkt (own_buf);
950	  if (packet_len <= 0)
951	    break;
952
953	  i = 0;
954	  ch = own_buf[i++];
955	  switch (ch)
956	    {
957	    case 'q':
958	      handle_query (own_buf, packet_len, &new_packet_len);
959	      break;
960	    case 'Q':
961	      handle_general_set (own_buf);
962	      break;
963	    case 'D':
964	      fprintf (stderr, "Detaching from inferior\n");
965	      if (detach_inferior () != 0)
966		{
967		  write_enn (own_buf);
968		  putpkt (own_buf);
969		}
970	      else
971		{
972		  write_ok (own_buf);
973		  putpkt (own_buf);
974		  remote_close ();
975
976		  /* If we are attached, then we can exit.  Otherwise, we
977		     need to hang around doing nothing, until the child
978		     is gone.  */
979		  if (!attached)
980		    join_inferior ();
981
982		  exit (0);
983		}
984	    case '!':
985	      if (attached == 0)
986		{
987		  extended_protocol = 1;
988		  prepare_resume_reply (own_buf, status, signal);
989		}
990	      else
991		{
992		  /* We can not use the extended protocol if we are
993		     attached, because we can not restart the running
994		     program.  So return unrecognized.  */
995		  own_buf[0] = '\0';
996		}
997	      break;
998	    case '?':
999	      prepare_resume_reply (own_buf, status, signal);
1000	      break;
1001	    case 'H':
1002	      if (own_buf[1] == 'c' || own_buf[1] == 'g' || own_buf[1] == 's')
1003		{
1004		  unsigned long gdb_id, thread_id;
1005
1006		  gdb_id = strtoul (&own_buf[2], NULL, 16);
1007		  thread_id = gdb_id_to_thread_id (gdb_id);
1008		  if (thread_id == 0)
1009		    {
1010		      write_enn (own_buf);
1011		      break;
1012		    }
1013
1014		  if (own_buf[1] == 'g')
1015		    {
1016		      general_thread = thread_id;
1017		      set_desired_inferior (1);
1018		    }
1019		  else if (own_buf[1] == 'c')
1020		    cont_thread = thread_id;
1021		  else if (own_buf[1] == 's')
1022		    step_thread = thread_id;
1023
1024		  write_ok (own_buf);
1025		}
1026	      else
1027		{
1028		  /* Silently ignore it so that gdb can extend the protocol
1029		     without compatibility headaches.  */
1030		  own_buf[0] = '\0';
1031		}
1032	      break;
1033	    case 'g':
1034	      set_desired_inferior (1);
1035	      registers_to_string (own_buf);
1036	      break;
1037	    case 'G':
1038	      set_desired_inferior (1);
1039	      registers_from_string (&own_buf[1]);
1040	      write_ok (own_buf);
1041	      break;
1042	    case 'm':
1043	      decode_m_packet (&own_buf[1], &mem_addr, &len);
1044	      if (read_inferior_memory (mem_addr, mem_buf, len) == 0)
1045		convert_int_to_ascii (mem_buf, own_buf, len);
1046	      else
1047		write_enn (own_buf);
1048	      break;
1049	    case 'M':
1050	      decode_M_packet (&own_buf[1], &mem_addr, &len, mem_buf);
1051	      if (write_inferior_memory (mem_addr, mem_buf, len) == 0)
1052		write_ok (own_buf);
1053	      else
1054		write_enn (own_buf);
1055	      break;
1056	    case 'X':
1057	      if (decode_X_packet (&own_buf[1], packet_len - 1,
1058				   &mem_addr, &len, mem_buf) < 0
1059		  || write_inferior_memory (mem_addr, mem_buf, len) != 0)
1060		write_enn (own_buf);
1061	      else
1062		write_ok (own_buf);
1063	      break;
1064	    case 'C':
1065	      convert_ascii_to_int (own_buf + 1, &sig, 1);
1066	      if (target_signal_to_host_p (sig))
1067		signal = target_signal_to_host (sig);
1068	      else
1069		signal = 0;
1070	      set_desired_inferior (0);
1071	      myresume (0, signal);
1072	      signal = mywait (&status, 1);
1073	      prepare_resume_reply (own_buf, status, signal);
1074	      break;
1075	    case 'S':
1076	      convert_ascii_to_int (own_buf + 1, &sig, 1);
1077	      if (target_signal_to_host_p (sig))
1078		signal = target_signal_to_host (sig);
1079	      else
1080		signal = 0;
1081	      set_desired_inferior (0);
1082	      myresume (1, signal);
1083	      signal = mywait (&status, 1);
1084	      prepare_resume_reply (own_buf, status, signal);
1085	      break;
1086	    case 'c':
1087	      set_desired_inferior (0);
1088	      myresume (0, 0);
1089	      signal = mywait (&status, 1);
1090	      prepare_resume_reply (own_buf, status, signal);
1091	      break;
1092	    case 's':
1093	      set_desired_inferior (0);
1094	      myresume (1, 0);
1095	      signal = mywait (&status, 1);
1096	      prepare_resume_reply (own_buf, status, signal);
1097	      break;
1098	    case 'Z':
1099	      {
1100		char *lenptr;
1101		char *dataptr;
1102		CORE_ADDR addr = strtoul (&own_buf[3], &lenptr, 16);
1103		int len = strtol (lenptr + 1, &dataptr, 16);
1104		char type = own_buf[1];
1105
1106		if (the_target->insert_watchpoint == NULL
1107		    || (type < '2' || type > '4'))
1108		  {
1109		    /* No watchpoint support or not a watchpoint command;
1110		       unrecognized either way.  */
1111		    own_buf[0] = '\0';
1112		  }
1113		else
1114		  {
1115		    int res;
1116
1117		    res = (*the_target->insert_watchpoint) (type, addr, len);
1118		    if (res == 0)
1119		      write_ok (own_buf);
1120		    else if (res == 1)
1121		      /* Unsupported.  */
1122		      own_buf[0] = '\0';
1123		    else
1124		      write_enn (own_buf);
1125		  }
1126		break;
1127	      }
1128	    case 'z':
1129	      {
1130		char *lenptr;
1131		char *dataptr;
1132		CORE_ADDR addr = strtoul (&own_buf[3], &lenptr, 16);
1133		int len = strtol (lenptr + 1, &dataptr, 16);
1134		char type = own_buf[1];
1135
1136		if (the_target->remove_watchpoint == NULL
1137		    || (type < '2' || type > '4'))
1138		  {
1139		    /* No watchpoint support or not a watchpoint command;
1140		       unrecognized either way.  */
1141		    own_buf[0] = '\0';
1142		  }
1143		else
1144		  {
1145		    int res;
1146
1147		    res = (*the_target->remove_watchpoint) (type, addr, len);
1148		    if (res == 0)
1149		      write_ok (own_buf);
1150		    else if (res == 1)
1151		      /* Unsupported.  */
1152		      own_buf[0] = '\0';
1153		    else
1154		      write_enn (own_buf);
1155		  }
1156		break;
1157	      }
1158	    case 'k':
1159	      fprintf (stderr, "Killing inferior\n");
1160	      kill_inferior ();
1161	      /* When using the extended protocol, we start up a new
1162	         debugging session.   The traditional protocol will
1163	         exit instead.  */
1164	      if (extended_protocol)
1165		{
1166		  write_ok (own_buf);
1167		  fprintf (stderr, "GDBserver restarting\n");
1168
1169		  /* Wait till we are at 1st instruction in prog.  */
1170		  signal = start_inferior (&argv[2], &status);
1171		  goto restart;
1172		  break;
1173		}
1174	      else
1175		{
1176		  exit (0);
1177		  break;
1178		}
1179	    case 'T':
1180	      {
1181		unsigned long gdb_id, thread_id;
1182
1183		gdb_id = strtoul (&own_buf[1], NULL, 16);
1184		thread_id = gdb_id_to_thread_id (gdb_id);
1185		if (thread_id == 0)
1186		  {
1187		    write_enn (own_buf);
1188		    break;
1189		  }
1190
1191		if (mythread_alive (thread_id))
1192		  write_ok (own_buf);
1193		else
1194		  write_enn (own_buf);
1195	      }
1196	      break;
1197	    case 'R':
1198	      /* Restarting the inferior is only supported in the
1199	         extended protocol.  */
1200	      if (extended_protocol)
1201		{
1202		  kill_inferior ();
1203		  write_ok (own_buf);
1204		  fprintf (stderr, "GDBserver restarting\n");
1205
1206		  /* Wait till we are at 1st instruction in prog.  */
1207		  signal = start_inferior (&argv[2], &status);
1208		  goto restart;
1209		  break;
1210		}
1211	      else
1212		{
1213		  /* It is a request we don't understand.  Respond with an
1214		     empty packet so that gdb knows that we don't support this
1215		     request.  */
1216		  own_buf[0] = '\0';
1217		  break;
1218		}
1219	    case 'v':
1220	      /* Extended (long) request.  */
1221	      handle_v_requests (own_buf, &status, &signal);
1222	      break;
1223	    default:
1224	      /* It is a request we don't understand.  Respond with an
1225	         empty packet so that gdb knows that we don't support this
1226	         request.  */
1227	      own_buf[0] = '\0';
1228	      break;
1229	    }
1230
1231	  if (new_packet_len != -1)
1232	    putpkt_binary (own_buf, new_packet_len);
1233	  else
1234	    putpkt (own_buf);
1235
1236	  if (status == 'W')
1237	    fprintf (stderr,
1238		     "\nChild exited with status %d\n", signal);
1239	  if (status == 'X')
1240	    fprintf (stderr, "\nChild terminated with signal = 0x%x (%s)\n",
1241		     target_signal_to_host (signal),
1242		     target_signal_to_name (signal));
1243	  if (status == 'W' || status == 'X')
1244	    {
1245	      if (extended_protocol)
1246		{
1247		  fprintf (stderr, "Killing inferior\n");
1248		  kill_inferior ();
1249		  write_ok (own_buf);
1250		  fprintf (stderr, "GDBserver restarting\n");
1251
1252		  /* Wait till we are at 1st instruction in prog.  */
1253		  signal = start_inferior (&argv[2], &status);
1254		  goto restart;
1255		  break;
1256		}
1257	      else
1258		{
1259		  fprintf (stderr, "GDBserver exiting\n");
1260		  exit (0);
1261		}
1262	    }
1263	}
1264
1265      /* We come here when getpkt fails.
1266
1267         For the extended remote protocol we exit (and this is the only
1268         way we gracefully exit!).
1269
1270         For the traditional remote protocol close the connection,
1271         and re-open it at the top of the loop.  */
1272      if (extended_protocol)
1273	{
1274	  remote_close ();
1275	  exit (0);
1276	}
1277      else
1278	{
1279	  fprintf (stderr, "Remote side has terminated connection.  "
1280			   "GDBserver will reopen the connection.\n");
1281	  remote_close ();
1282	}
1283    }
1284}
1285