1 /* Generic support for remote debugging interfaces.
2 
3    Copyright 1993, 1994, 1995, 1996, 1998, 2000, 2001
4    Free Software Foundation, Inc.
5 
6    This file is part of GDB.
7 
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.
12 
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.
17 
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.  */
22 
23 /*  This file actually contains two distinct logical "packages".  They
24    are packaged together in this one file because they are typically
25    used together.
26 
27    The first package is an addition to the serial package.  The
28    addition provides reading and writing with debugging output and
29    timeouts based on user settable variables.  These routines are
30    intended to support serial port based remote backends.  These
31    functions are prefixed with sr_.
32 
33    The second package is a collection of more or less generic
34    functions for use by remote backends.  They support user settable
35    variables for debugging, retries, and the like.
36 
37    Todo:
38 
39    * a pass through mode a la kermit or telnet.
40    * autobaud.
41    * ask remote to change his baud rate.
42  */
43 
44 #include <ctype.h>
45 
46 #include "defs.h"
47 #include "gdb_string.h"
48 #include "gdbcmd.h"
49 #include "target.h"
50 #include "serial.h"
51 #include "gdbcore.h"		/* for exec_bfd */
52 #include "inferior.h"		/* for generic_mourn_inferior */
53 #include "remote-utils.h"
54 #include "regcache.h"
55 
56 
57 void _initialize_sr_support (void);
58 
59 struct _sr_settings sr_settings =
60 {
61   4,				/* timeout:
62 				   remote-hms.c had 2
63 				   remote-bug.c had "with a timeout of 2, we time out waiting for
64 				   the prompt after an s-record dump."
65 
66 				   remote.c had (2): This was 5 seconds, which is a long time to
67 				   sit and wait. Unless this is going though some terminal server
68 				   or multiplexer or other form of hairy serial connection, I
69 				   would think 2 seconds would be plenty.
70 				 */
71 
72   10,				/* retries */
73   NULL,				/* device */
74   NULL,				/* descriptor */
75 };
76 
77 struct gr_settings *gr_settings = NULL;
78 
79 static void usage (char *, char *);
80 static void sr_com (char *, int);
81 
82 static void
83 usage (char *proto, char *junk)
84 {
85   if (junk != NULL)
86     fprintf_unfiltered (gdb_stderr, "Unrecognized arguments: `%s'.\n", junk);
87 
88   error ("Usage: target %s [DEVICE [SPEED [DEBUG]]]\n\
89 where DEVICE is the name of a device or HOST:PORT", proto);
90 
91   return;
92 }
93 
94 #define CHECKDONE(p, q) \
95 { \
96   if (q == p) \
97     { \
98       if (*p == '\0') \
99 	return; \
100       else \
101 	usage(proto, p); \
102     } \
103 }
104 
105 void
106 sr_scan_args (char *proto, char *args)
107 {
108   int n;
109   char *p, *q;
110 
111   /* if no args, then nothing to do. */
112   if (args == NULL || *args == '\0')
113     return;
114 
115   /* scan off white space.  */
116   for (p = args; isspace (*p); ++p);;
117 
118   /* find end of device name.  */
119   for (q = p; *q != '\0' && !isspace (*q); ++q);;
120 
121   /* check for missing or empty device name.  */
122   CHECKDONE (p, q);
123   sr_set_device (savestring (p, q - p));
124 
125   /* look for baud rate.  */
126   n = strtol (q, &p, 10);
127 
128   /* check for missing or empty baud rate.  */
129   CHECKDONE (p, q);
130   baud_rate = n;
131 
132   /* look for debug value.  */
133   n = strtol (p, &q, 10);
134 
135   /* check for missing or empty debug value.  */
136   CHECKDONE (p, q);
137   sr_set_debug (n);
138 
139   /* scan off remaining white space.  */
140   for (p = q; isspace (*p); ++p);;
141 
142   /* if not end of string, then there's unrecognized junk. */
143   if (*p != '\0')
144     usage (proto, p);
145 
146   return;
147 }
148 
149 void
150 gr_generic_checkin (void)
151 {
152   sr_write_cr ("");
153   gr_expect_prompt ();
154 }
155 
156 void
157 gr_open (char *args, int from_tty, struct gr_settings *gr)
158 {
159   target_preopen (from_tty);
160   sr_scan_args (gr->ops->to_shortname, args);
161   unpush_target (gr->ops);
162 
163   gr_settings = gr;
164 
165   if (sr_get_desc () != NULL)
166     gr_close (0);
167 
168   /* If no args are specified, then we use the device specified by a
169      previous command or "set remotedevice".  But if there is no
170      device, better stop now, not dump core.  */
171 
172   if (sr_get_device () == NULL)
173     usage (gr->ops->to_shortname, NULL);
174 
175   sr_set_desc (serial_open (sr_get_device ()));
176   if (!sr_get_desc ())
177     perror_with_name ((char *) sr_get_device ());
178 
179   if (baud_rate != -1)
180     {
181       if (serial_setbaudrate (sr_get_desc (), baud_rate) != 0)
182 	{
183 	  serial_close (sr_get_desc ());
184 	  perror_with_name (sr_get_device ());
185 	}
186     }
187 
188   serial_raw (sr_get_desc ());
189 
190   /* If there is something sitting in the buffer we might take it as a
191      response to a command, which would be bad.  */
192   serial_flush_input (sr_get_desc ());
193 
194   /* default retries */
195   if (sr_get_retries () == 0)
196     sr_set_retries (1);
197 
198   /* default clear breakpoint function */
199   if (gr_settings->clear_all_breakpoints == NULL)
200     gr_settings->clear_all_breakpoints = remove_breakpoints;
201 
202   if (from_tty)
203     {
204       printf_filtered ("Remote debugging using `%s'", sr_get_device ());
205       if (baud_rate != -1)
206 	printf_filtered (" at baud rate of %d",
207 			 baud_rate);
208       printf_filtered ("\n");
209     }
210 
211   push_target (gr->ops);
212   gr_checkin ();
213   gr_clear_all_breakpoints ();
214   return;
215 }
216 
217 /* Read a character from the remote system masking it down to 7 bits
218    and doing all the fancy timeout stuff.  */
219 
220 int
221 sr_readchar (void)
222 {
223   int buf;
224 
225   buf = serial_readchar (sr_get_desc (), sr_get_timeout ());
226 
227   if (buf == SERIAL_TIMEOUT)
228     error ("Timeout reading from remote system.");
229 
230   if (sr_get_debug () > 0)
231     printf_unfiltered ("%c", buf);
232 
233   return buf & 0x7f;
234 }
235 
236 int
237 sr_pollchar (void)
238 {
239   int buf;
240 
241   buf = serial_readchar (sr_get_desc (), 0);
242   if (buf == SERIAL_TIMEOUT)
243     buf = 0;
244   if (sr_get_debug () > 0)
245     {
246       if (buf)
247 	printf_unfiltered ("%c", buf);
248       else
249 	printf_unfiltered ("<empty character poll>");
250     }
251 
252   return buf & 0x7f;
253 }
254 
255 /* Keep discarding input from the remote system, until STRING is found.
256    Let the user break out immediately.  */
257 void
258 sr_expect (char *string)
259 {
260   char *p = string;
261 
262   immediate_quit++;
263   while (1)
264     {
265       if (sr_readchar () == *p)
266 	{
267 	  p++;
268 	  if (*p == '\0')
269 	    {
270 	      immediate_quit--;
271 	      return;
272 	    }
273 	}
274       else
275 	p = string;
276     }
277 }
278 
279 void
280 sr_write (char *a, int l)
281 {
282   int i;
283 
284   if (serial_write (sr_get_desc (), a, l) != 0)
285     perror_with_name ("sr_write: Error writing to remote");
286 
287   if (sr_get_debug () > 0)
288     for (i = 0; i < l; i++)
289       printf_unfiltered ("%c", a[i]);
290 
291   return;
292 }
293 
294 void
295 sr_write_cr (char *s)
296 {
297   sr_write (s, strlen (s));
298   sr_write ("\r", 1);
299   return;
300 }
301 
302 int
303 sr_timed_read (char *buf, int n)
304 {
305   int i;
306   char c;
307 
308   i = 0;
309   while (i < n)
310     {
311       c = sr_readchar ();
312 
313       if (c == 0)
314 	return i;
315       buf[i] = c;
316       i++;
317 
318     }
319   return i;
320 }
321 
322 /* Get a hex digit from the remote system & return its value. If
323    ignore_space is nonzero, ignore spaces (not newline, tab, etc).  */
324 
325 int
326 sr_get_hex_digit (int ignore_space)
327 {
328   int ch;
329 
330   while (1)
331     {
332       ch = sr_readchar ();
333       if (ch >= '0' && ch <= '9')
334 	return ch - '0';
335       else if (ch >= 'A' && ch <= 'F')
336 	return ch - 'A' + 10;
337       else if (ch >= 'a' && ch <= 'f')
338 	return ch - 'a' + 10;
339       else if (ch != ' ' || !ignore_space)
340 	{
341 	  gr_expect_prompt ();
342 	  error ("Invalid hex digit from remote system.");
343 	}
344     }
345 }
346 
347 /* Get a byte from the remote and put it in *BYT.  Accept any number
348    leading spaces.  */
349 void
350 sr_get_hex_byte (char *byt)
351 {
352   int val;
353 
354   val = sr_get_hex_digit (1) << 4;
355   val |= sr_get_hex_digit (0);
356   *byt = val;
357 }
358 
359 /* Read a 32-bit hex word from the remote, preceded by a space  */
360 long
361 sr_get_hex_word (void)
362 {
363   long val;
364   int j;
365 
366   val = 0;
367   for (j = 0; j < 8; j++)
368     val = (val << 4) + sr_get_hex_digit (j == 0);
369   return val;
370 }
371 
372 /* Put a command string, in args, out to the remote.  The remote is assumed to
373    be in raw mode, all writing/reading done through desc.
374    Ouput from the remote is placed on the users terminal until the
375    prompt from the remote is seen.
376    FIXME: Can't handle commands that take input.  */
377 
378 static void
379 sr_com (char *args, int fromtty)
380 {
381   sr_check_open ();
382 
383   if (!args)
384     return;
385 
386   /* Clear all input so only command relative output is displayed */
387 
388   sr_write_cr (args);
389   sr_write ("\030", 1);
390   registers_changed ();
391   gr_expect_prompt ();
392 }
393 
394 void
395 gr_close (int quitting)
396 {
397   gr_clear_all_breakpoints ();
398 
399   if (sr_is_open ())
400     {
401       serial_close (sr_get_desc ());
402       sr_set_desc (NULL);
403     }
404 
405   return;
406 }
407 
408 /* gr_detach()
409    takes a program previously attached to and detaches it.
410    We better not have left any breakpoints
411    in the program or it'll die when it hits one.
412    Close the open connection to the remote debugger.
413    Use this when you want to detach and do something else
414    with your gdb.  */
415 
416 void
417 gr_detach (char *args, int from_tty)
418 {
419   if (args)
420     error ("Argument given to \"detach\" when remotely debugging.");
421 
422   if (sr_is_open ())
423     gr_clear_all_breakpoints ();
424 
425   pop_target ();
426   if (from_tty)
427     puts_filtered ("Ending remote debugging.\n");
428 
429   return;
430 }
431 
432 void
433 gr_files_info (struct target_ops *ops)
434 {
435 #ifdef __GO32__
436   printf_filtered ("\tAttached to DOS asynctsr\n");
437 #else
438   printf_filtered ("\tAttached to %s", sr_get_device ());
439   if (baud_rate != -1)
440     printf_filtered ("at %d baud", baud_rate);
441   printf_filtered ("\n");
442 #endif
443 
444   if (exec_bfd)
445     {
446       printf_filtered ("\tand running program %s\n",
447 		       bfd_get_filename (exec_bfd));
448     }
449   printf_filtered ("\tusing the %s protocol.\n", ops->to_shortname);
450 }
451 
452 void
453 gr_mourn (void)
454 {
455   gr_clear_all_breakpoints ();
456   unpush_target (gr_get_ops ());
457   generic_mourn_inferior ();
458 }
459 
460 void
461 gr_kill (void)
462 {
463   return;
464 }
465 
466 /* This is called not only when we first attach, but also when the
467    user types "run" after having attached.  */
468 void
469 gr_create_inferior (char *execfile, char *args, char **env)
470 {
471   int entry_pt;
472 
473   if (args && *args)
474     error ("Can't pass arguments to remote process.");
475 
476   if (execfile == 0 || exec_bfd == 0)
477     error ("No executable file specified");
478 
479   entry_pt = (int) bfd_get_start_address (exec_bfd);
480   sr_check_open ();
481 
482   gr_kill ();
483   gr_clear_all_breakpoints ();
484 
485   init_wait_for_inferior ();
486   gr_checkin ();
487 
488   insert_breakpoints ();	/* Needed to get correct instruction in cache */
489   proceed (entry_pt, -1, 0);
490 }
491 
492 /* Given a null terminated list of strings LIST, read the input until we find one of
493    them.  Return the index of the string found or -1 on error.  '?' means match
494    any single character. Note that with the algorithm we use, the initial
495    character of the string cannot recur in the string, or we will not find some
496    cases of the string in the input.  If PASSTHROUGH is non-zero, then
497    pass non-matching data on.  */
498 
499 int
500 gr_multi_scan (char *list[], int passthrough)
501 {
502   char *swallowed = NULL;	/* holding area */
503   char *swallowed_p = swallowed;	/* Current position in swallowed.  */
504   int ch;
505   int ch_handled;
506   int i;
507   int string_count;
508   int max_length;
509   char **plist;
510 
511   /* Look through the strings.  Count them.  Find the largest one so we can
512      allocate a holding area.  */
513 
514   for (max_length = string_count = i = 0;
515        list[i] != NULL;
516        ++i, ++string_count)
517     {
518       int length = strlen (list[i]);
519 
520       if (length > max_length)
521 	max_length = length;
522     }
523 
524   /* if we have no strings, then something is wrong. */
525   if (string_count == 0)
526     return (-1);
527 
528   /* otherwise, we will need a holding area big enough to hold almost two
529      copies of our largest string.  */
530   swallowed_p = swallowed = alloca (max_length << 1);
531 
532   /* and a list of pointers to current scan points. */
533   plist = (char **) alloca (string_count * sizeof (*plist));
534 
535   /* and initialize */
536   for (i = 0; i < string_count; ++i)
537     plist[i] = list[i];
538 
539   for (ch = sr_readchar (); /* loop forever */ ; ch = sr_readchar ())
540     {
541       QUIT;			/* Let user quit and leave process running */
542       ch_handled = 0;
543 
544       for (i = 0; i < string_count; ++i)
545 	{
546 	  if (ch == *plist[i] || *plist[i] == '?')
547 	    {
548 	      ++plist[i];
549 	      if (*plist[i] == '\0')
550 		return (i);
551 
552 	      if (!ch_handled)
553 		*swallowed_p++ = ch;
554 
555 	      ch_handled = 1;
556 	    }
557 	  else
558 	    plist[i] = list[i];
559 	}
560 
561       if (!ch_handled)
562 	{
563 	  char *p;
564 
565 	  /* Print out any characters which have been swallowed.  */
566 	  if (passthrough)
567 	    {
568 	      for (p = swallowed; p < swallowed_p; ++p)
569 		fputc_unfiltered (*p, gdb_stdout);
570 
571 	      fputc_unfiltered (ch, gdb_stdout);
572 	    }
573 
574 	  swallowed_p = swallowed;
575 	}
576     }
577 #if 0
578   /* Never reached.  */
579   return (-1);
580 #endif
581 }
582 
583 /* Get ready to modify the registers array.  On machines which store
584    individual registers, this doesn't need to do anything.  On machines
585    which store all the registers in one fell swoop, this makes sure
586    that registers contains all the registers from the program being
587    debugged.  */
588 
589 void
590 gr_prepare_to_store (void)
591 {
592   /* Do nothing, since we assume we can store individual regs */
593 }
594 
595 void
596 _initialize_sr_support (void)
597 {
598 /* FIXME-now: if target is open... */
599   deprecated_add_show_from_set
600     (add_set_cmd ("remotedevice", no_class,
601 		  var_filename, (char *) &sr_settings.device,
602 		  "Set device for remote serial I/O.\n\
603 This device is used as the serial port when debugging using remote\n\
604 targets.", &setlist),
605      &showlist);
606 
607   add_com ("remote <command>", class_obscure, sr_com,
608 	   "Send a command to the remote monitor.");
609 
610 }
611