1 /* Generic serial interface routines
3 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
4 2002, 2004, 2005, 2006, 2007, 2008, 2009, 2010
5 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
25 #include "gdb_string.h"
28 extern void _initialize_serial (void);
30 /* Is serial being debugged? */
32 static int global_serial_debug_p;
34 /* Linked list of serial I/O handlers */
36 static struct serial_ops *serial_ops_list = NULL;
38 /* This is the last serial stream opened. Used by connect command. */
40 static struct serial *last_serial_opened = NULL;
42 /* Pointer to list of scb's. */
44 static struct serial *scb_base;
46 /* Non-NULL gives filename which contains a recording of the remote session,
47 suitable for playback by gdbserver. */
49 static char *serial_logfile = NULL;
50 static struct ui_file *serial_logfp = NULL;
52 static struct serial_ops *serial_interface_lookup (char *);
53 static void serial_logchar (struct ui_file *stream, int ch_type, int ch, int timeout);
54 static const char logbase_hex[] = "hex";
55 static const char logbase_octal[] = "octal";
56 static const char logbase_ascii[] = "ascii";
57 static const char *logbase_enums[] =
58 {logbase_hex, logbase_octal, logbase_ascii, NULL};
59 static const char *serial_logbase = logbase_ascii;
62 static int serial_current_type = 0;
64 /* Log char CH of type CHTYPE, with TIMEOUT */
66 /* Define bogus char to represent a BREAK. Should be careful to choose a value
67 that can't be confused with a normal char, or an error code. */
68 #define SERIAL_BREAK 1235
71 serial_logchar (struct ui_file *stream, int ch_type, int ch, int timeout)
73 if (ch_type != serial_current_type)
75 fprintf_unfiltered (stream, "\n%c ", ch_type);
76 serial_current_type = ch_type;
79 if (serial_logbase != logbase_ascii)
80 fputc_unfiltered (' ', stream);
85 fprintf_unfiltered (stream, "<Timeout: %d seconds>", timeout);
88 fprintf_unfiltered (stream, "<Error: %s>", safe_strerror (errno));
91 fputs_unfiltered ("<Eof>", stream);
94 fputs_unfiltered ("<Break>", stream);
97 if (serial_logbase == logbase_hex)
98 fprintf_unfiltered (stream, "%02x", ch & 0xff);
99 else if (serial_logbase == logbase_octal)
100 fprintf_unfiltered (stream, "%03o", ch & 0xff);
105 fputs_unfiltered ("\\\\", stream);
108 fputs_unfiltered ("\\b", stream);
111 fputs_unfiltered ("\\f", stream);
114 fputs_unfiltered ("\\n", stream);
117 fputs_unfiltered ("\\r", stream);
120 fputs_unfiltered ("\\t", stream);
123 fputs_unfiltered ("\\v", stream);
126 fprintf_unfiltered (stream, isprint (ch) ? "%c" : "\\x%02x", ch & 0xFF);
133 serial_log_command (const char *cmd)
138 serial_current_type = 'c';
140 fputs_unfiltered ("\nc ", serial_logfp);
141 fputs_unfiltered (cmd, serial_logfp);
143 /* Make sure that the log file is as up-to-date as possible,
144 in case we are getting ready to dump core or something. */
145 gdb_flush (serial_logfp);
149 static struct serial_ops *
150 serial_interface_lookup (char *name)
152 struct serial_ops *ops;
154 for (ops = serial_ops_list; ops; ops = ops->next)
155 if (strcmp (name, ops->name) == 0)
162 serial_add_interface (struct serial_ops *optable)
164 optable->next = serial_ops_list;
165 serial_ops_list = optable;
168 /* Open up a device or a network socket, depending upon the syntax of NAME. */
171 serial_open (const char *name)
174 struct serial_ops *ops;
175 const char *open_name = name;
177 for (scb = scb_base; scb; scb = scb->next)
178 if (scb->name && strcmp (scb->name, name) == 0)
184 if (strcmp (name, "pc") == 0)
185 ops = serial_interface_lookup ("pc");
186 else if (strncmp (name, "lpt", 3) == 0)
187 ops = serial_interface_lookup ("parallel");
188 else if (strncmp (name, "|", 1) == 0)
190 ops = serial_interface_lookup ("pipe");
191 /* Discard ``|'' and any space before the command itself. */
193 while (isspace (*open_name))
196 /* Check for a colon, suggesting an IP address/port pair.
197 Do this *after* checking for all the interesting prefixes. We
198 don't want to constrain the syntax of what can follow them. */
199 else if (strchr (name, ':'))
200 ops = serial_interface_lookup ("tcp");
202 ops = serial_interface_lookup ("hardwire");
207 scb = XMALLOC (struct serial);
212 scb->bufp = scb->buf;
215 /* `...->open (...)' would get expanded by an the open(2) syscall macro. */
216 if ((*scb->ops->open) (scb, open_name))
222 scb->name = xstrdup (name);
223 scb->next = scb_base;
226 scb->async_state = 0;
227 scb->async_handler = NULL;
228 scb->async_context = NULL;
231 last_serial_opened = scb;
233 if (serial_logfile != NULL)
235 serial_logfp = gdb_fopen (serial_logfile, "w");
236 if (serial_logfp == NULL)
237 perror_with_name (serial_logfile);
243 /* Return the open serial device for FD, if found, or NULL if FD
244 is not already opened. */
247 serial_for_fd (int fd)
250 struct serial_ops *ops;
252 for (scb = scb_base; scb; scb = scb->next)
260 serial_fdopen (const int fd)
263 struct serial_ops *ops;
265 for (scb = scb_base; scb; scb = scb->next)
272 ops = serial_interface_lookup ("terminal");
274 ops = serial_interface_lookup ("hardwire");
279 scb = XCALLOC (1, struct serial);
284 scb->bufp = scb->buf;
289 scb->next = scb_base;
292 scb->async_state = 0;
293 scb->async_handler = NULL;
294 scb->async_context = NULL;
297 last_serial_opened = scb;
303 do_serial_close (struct serial *scb, int really_close)
305 struct serial *tmp_scb;
307 last_serial_opened = NULL;
311 fputs_unfiltered ("\nEnd of log\n", serial_logfp);
312 serial_current_type = 0;
314 /* XXX - What if serial_logfp == gdb_stdout or gdb_stderr? */
315 ui_file_delete (serial_logfp);
319 /* This is bogus. It's not our fault if you pass us a bad scb...! Rob, you
320 should fix your code instead. */
329 /* ensure that the FD has been taken out of async mode */
330 if (scb->async_handler != NULL)
331 serial_async (scb, NULL, NULL);
334 scb->ops->close (scb);
340 scb_base = scb_base->next;
342 for (tmp_scb = scb_base; tmp_scb; tmp_scb = tmp_scb->next)
344 if (tmp_scb->next != scb)
347 tmp_scb->next = tmp_scb->next->next;
355 serial_close (struct serial *scb)
357 do_serial_close (scb, 1);
361 serial_un_fdopen (struct serial *scb)
363 do_serial_close (scb, 0);
367 serial_readchar (struct serial *scb, int timeout)
371 /* FIXME: cagney/1999-10-11: Don't enable this check until the ASYNC
373 if (0 && serial_is_async_p (scb) && timeout < 0)
374 internal_error (__FILE__, __LINE__,
375 _("serial_readchar: blocking read in async mode"));
377 ch = scb->ops->readchar (scb, timeout);
378 if (serial_logfp != NULL)
380 serial_logchar (serial_logfp, 'r', ch, timeout);
382 /* Make sure that the log file is as up-to-date as possible,
383 in case we are getting ready to dump core or something. */
384 gdb_flush (serial_logfp);
386 if (serial_debug_p (scb))
388 fprintf_unfiltered (gdb_stdlog, "[");
389 serial_logchar (gdb_stdlog, 'r', ch, timeout);
390 fprintf_unfiltered (gdb_stdlog, "]");
391 gdb_flush (gdb_stdlog);
398 serial_write (struct serial *scb, const char *str, int len)
400 if (serial_logfp != NULL)
404 for (count = 0; count < len; count++)
405 serial_logchar (serial_logfp, 'w', str[count] & 0xff, 0);
407 /* Make sure that the log file is as up-to-date as possible,
408 in case we are getting ready to dump core or something. */
409 gdb_flush (serial_logfp);
411 if (serial_debug_p (scb))
415 for (count = 0; count < len; count++)
417 fprintf_unfiltered (gdb_stdlog, "[");
418 serial_logchar (gdb_stdlog, 'w', str[count] & 0xff, 0);
419 fprintf_unfiltered (gdb_stdlog, "]");
421 gdb_flush (gdb_stdlog);
424 return (scb->ops->write (scb, str, len));
428 serial_printf (struct serial *desc, const char *format,...)
432 va_start (args, format);
434 buf = xstrvprintf (format, args);
435 serial_write (desc, buf, strlen (buf));
442 serial_drain_output (struct serial *scb)
444 return scb->ops->drain_output (scb);
448 serial_flush_output (struct serial *scb)
450 return scb->ops->flush_output (scb);
454 serial_flush_input (struct serial *scb)
456 return scb->ops->flush_input (scb);
460 serial_send_break (struct serial *scb)
462 if (serial_logfp != NULL)
463 serial_logchar (serial_logfp, 'w', SERIAL_BREAK, 0);
465 return (scb->ops->send_break (scb));
469 serial_raw (struct serial *scb)
471 scb->ops->go_raw (scb);
475 serial_get_tty_state (struct serial *scb)
477 return scb->ops->get_tty_state (scb);
481 serial_set_tty_state (struct serial *scb, serial_ttystate ttystate)
483 return scb->ops->set_tty_state (scb, ttystate);
487 serial_print_tty_state (struct serial *scb,
488 serial_ttystate ttystate,
489 struct ui_file *stream)
491 scb->ops->print_tty_state (scb, ttystate, stream);
495 serial_noflush_set_tty_state (struct serial *scb,
496 serial_ttystate new_ttystate,
497 serial_ttystate old_ttystate)
499 return scb->ops->noflush_set_tty_state (scb, new_ttystate, old_ttystate);
503 serial_setbaudrate (struct serial *scb, int rate)
505 return scb->ops->setbaudrate (scb, rate);
509 serial_setstopbits (struct serial *scb, int num)
511 return scb->ops->setstopbits (scb, num);
515 serial_can_async_p (struct serial *scb)
517 return (scb->ops->async != NULL);
521 serial_is_async_p (struct serial *scb)
523 return (scb->ops->async != NULL) && (scb->async_handler != NULL);
527 serial_async (struct serial *scb,
528 serial_event_ftype *handler,
531 int changed = ((scb->async_handler == NULL) != (handler == NULL));
532 scb->async_handler = handler;
533 scb->async_context = context;
534 /* Only change mode if there is a need. */
536 scb->ops->async (scb, handler != NULL);
540 deprecated_serial_fd (struct serial *scb)
542 /* FIXME: should this output a warning that deprecated code is being
546 internal_error (__FILE__, __LINE__,
547 _("serial: FD not valid"));
549 return scb->fd; /* sigh */
553 serial_debug (struct serial *scb, int debug_p)
555 scb->debug_p = debug_p;
559 serial_debug_p (struct serial *scb)
561 return scb->debug_p || global_serial_debug_p;
566 serial_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except)
568 if (scb->ops->wait_handle)
569 scb->ops->wait_handle (scb, read, except);
572 *read = (HANDLE) _get_osfhandle (scb->fd);
578 serial_done_wait_handle (struct serial *scb)
580 if (scb->ops->done_wait_handle)
581 scb->ops->done_wait_handle (scb);
586 /* The connect command is #if 0 because I hadn't thought of an elegant
587 way to wait for I/O on two `struct serial *'s simultaneously. Two
588 solutions came to mind:
590 1) Fork, and have have one fork handle the to user direction,
591 and have the other hand the to target direction. This
592 obviously won't cut it for MSDOS.
594 2) Use something like select. This assumes that stdin and
595 the target side can both be waited on via the same
596 mechanism. This may not be true for DOS, if GDB is
597 talking to the target via a TCP socket.
598 -grossman, 8 Jun 93 */
600 /* Connect the user directly to the remote system. This command acts just like
601 the 'cu' or 'tip' command. Use <CR>~. or <CR>~^D to break out. */
603 static struct serial *tty_desc; /* Controlling terminal */
606 cleanup_tty (serial_ttystate ttystate)
608 printf_unfiltered ("\r\n[Exiting connect mode]\r\n");
609 serial_set_tty_state (tty_desc, ttystate);
611 serial_close (tty_desc);
615 connect_command (char *args, int fromtty)
619 serial_ttystate ttystate;
620 struct serial *port_desc; /* TTY port */
625 fprintf_unfiltered (gdb_stderr, "This command takes no args. They have been ignored.\n");
627 printf_unfiltered ("[Entering connect mode. Use ~. or ~^D to escape]\n");
629 tty_desc = serial_fdopen (0);
630 port_desc = last_serial_opened;
632 ttystate = serial_get_tty_state (tty_desc);
634 serial_raw (tty_desc);
635 serial_raw (port_desc);
637 make_cleanup (cleanup_tty, ttystate);
643 mask = serial_wait_2 (tty_desc, port_desc, -1);
651 c = serial_readchar (tty_desc, 0);
653 if (c == SERIAL_TIMEOUT)
657 perror_with_name (_("connect"));
660 serial_write (port_desc, &cx, 1);
675 if (c == '.' || c == '\004')
689 c = serial_readchar (port_desc, 0);
691 if (c == SERIAL_TIMEOUT)
695 perror_with_name (_("connect"));
699 serial_write (tty_desc, &cx, 1);
706 /* Serial set/show framework. */
708 static struct cmd_list_element *serial_set_cmdlist;
709 static struct cmd_list_element *serial_show_cmdlist;
712 serial_set_cmd (char *args, int from_tty)
714 printf_unfiltered ("\"set serial\" must be followed by the name of a command.\n");
715 help_list (serial_set_cmdlist, "set serial ", -1, gdb_stdout);
719 serial_show_cmd (char *args, int from_tty)
721 cmd_show_list (serial_show_cmdlist, from_tty, "");
726 _initialize_serial (void)
729 add_com ("connect", class_obscure, connect_command, _("\
730 Connect the terminal directly up to the command monitor.\n\
731 Use <CR>~. or <CR>~^D to break out."));
734 add_prefix_cmd ("serial", class_maintenance, serial_set_cmd, _("\
735 Set default serial/parallel port configuration."),
736 &serial_set_cmdlist, "set serial ",
740 add_prefix_cmd ("serial", class_maintenance, serial_show_cmd, _("\
741 Show default serial/parallel port configuration."),
742 &serial_show_cmdlist, "show serial ",
746 add_setshow_filename_cmd ("remotelogfile", no_class, &serial_logfile, _("\
747 Set filename for remote session recording."), _("\
748 Show filename for remote session recording."), _("\
749 This file is used to record the remote session for future playback\n\
752 NULL, /* FIXME: i18n: */
753 &setlist, &showlist);
755 add_setshow_enum_cmd ("remotelogbase", no_class, logbase_enums,
756 &serial_logbase, _("\
757 Set numerical base for remote session logging"), _("\
758 Show numerical base for remote session logging"), NULL,
760 NULL, /* FIXME: i18n: */
761 &setlist, &showlist);
763 add_setshow_zinteger_cmd ("serial", class_maintenance,
764 &global_serial_debug_p, _("\
765 Set serial debugging."), _("\
766 Show serial debugging."), _("\
767 When non-zero, serial port debugging is enabled."),
769 NULL, /* FIXME: i18n: */
770 &setdebuglist, &showdebuglist);