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, 2011
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 (const char *);
53 static void serial_logchar (struct ui_file *stream,
54 int ch_type, int ch, int timeout);
55 static const char logbase_hex[] = "hex";
56 static const char logbase_octal[] = "octal";
57 static const char logbase_ascii[] = "ascii";
58 static const char *logbase_enums[] =
59 {logbase_hex, logbase_octal, logbase_ascii, NULL};
60 static const char *serial_logbase = logbase_ascii;
63 static int serial_current_type = 0;
65 /* Log char CH of type CHTYPE, with TIMEOUT. */
67 /* Define bogus char to represent a BREAK. Should be careful to choose a value
68 that can't be confused with a normal char, or an error code. */
69 #define SERIAL_BREAK 1235
72 serial_logchar (struct ui_file *stream, int ch_type, int ch, int timeout)
74 if (ch_type != serial_current_type)
76 fprintf_unfiltered (stream, "\n%c ", ch_type);
77 serial_current_type = ch_type;
80 if (serial_logbase != logbase_ascii)
81 fputc_unfiltered (' ', stream);
86 fprintf_unfiltered (stream, "<Timeout: %d seconds>", timeout);
89 fprintf_unfiltered (stream, "<Error: %s>", safe_strerror (errno));
92 fputs_unfiltered ("<Eof>", stream);
95 fputs_unfiltered ("<Break>", stream);
98 if (serial_logbase == logbase_hex)
99 fprintf_unfiltered (stream, "%02x", ch & 0xff);
100 else if (serial_logbase == logbase_octal)
101 fprintf_unfiltered (stream, "%03o", ch & 0xff);
106 fputs_unfiltered ("\\\\", stream);
109 fputs_unfiltered ("\\b", stream);
112 fputs_unfiltered ("\\f", stream);
115 fputs_unfiltered ("\\n", stream);
118 fputs_unfiltered ("\\r", stream);
121 fputs_unfiltered ("\\t", stream);
124 fputs_unfiltered ("\\v", stream);
127 fprintf_unfiltered (stream,
128 isprint (ch) ? "%c" : "\\x%02x", ch & 0xFF);
135 serial_log_command (const char *cmd)
140 serial_current_type = 'c';
142 fputs_unfiltered ("\nc ", serial_logfp);
143 fputs_unfiltered (cmd, serial_logfp);
145 /* Make sure that the log file is as up-to-date as possible,
146 in case we are getting ready to dump core or something. */
147 gdb_flush (serial_logfp);
151 static struct serial_ops *
152 serial_interface_lookup (const char *name)
154 struct serial_ops *ops;
156 for (ops = serial_ops_list; ops; ops = ops->next)
157 if (strcmp (name, ops->name) == 0)
164 serial_add_interface (struct serial_ops *optable)
166 optable->next = serial_ops_list;
167 serial_ops_list = optable;
170 /* Open up a device or a network socket, depending upon the syntax of NAME. */
173 serial_open (const char *name)
176 struct serial_ops *ops;
177 const char *open_name = name;
179 for (scb = scb_base; scb; scb = scb->next)
180 if (scb->name && strcmp (scb->name, name) == 0)
186 if (strcmp (name, "pc") == 0)
187 ops = serial_interface_lookup ("pc");
188 else if (strncmp (name, "lpt", 3) == 0)
189 ops = serial_interface_lookup ("parallel");
190 else if (strncmp (name, "|", 1) == 0)
192 ops = serial_interface_lookup ("pipe");
193 /* Discard ``|'' and any space before the command itself. */
195 while (isspace (*open_name))
198 /* Check for a colon, suggesting an IP address/port pair.
199 Do this *after* checking for all the interesting prefixes. We
200 don't want to constrain the syntax of what can follow them. */
201 else if (strchr (name, ':'))
202 ops = serial_interface_lookup ("tcp");
204 ops = serial_interface_lookup ("hardwire");
209 scb = XMALLOC (struct serial);
214 scb->bufp = scb->buf;
217 /* `...->open (...)' would get expanded by the open(2) syscall macro. */
218 if ((*scb->ops->open) (scb, open_name))
224 scb->name = xstrdup (name);
225 scb->next = scb_base;
228 scb->async_state = 0;
229 scb->async_handler = NULL;
230 scb->async_context = NULL;
233 last_serial_opened = scb;
235 if (serial_logfile != NULL)
237 serial_logfp = gdb_fopen (serial_logfile, "w");
238 if (serial_logfp == NULL)
239 perror_with_name (serial_logfile);
245 /* Return the open serial device for FD, if found, or NULL if FD
246 is not already opened. */
249 serial_for_fd (int fd)
253 for (scb = scb_base; scb; scb = scb->next)
260 /* Open a new serial stream using a file handle, using serial
261 interface ops OPS. */
263 static struct serial *
264 serial_fdopen_ops (const int fd, struct serial_ops *ops)
268 scb = serial_for_fd (fd);
277 ops = serial_interface_lookup ("terminal");
279 ops = serial_interface_lookup ("hardwire");
285 scb = XCALLOC (1, struct serial);
290 scb->bufp = scb->buf;
294 scb->next = scb_base;
297 scb->async_state = 0;
298 scb->async_handler = NULL;
299 scb->async_context = NULL;
302 if ((ops->fdopen) != NULL)
303 (*ops->fdopen) (scb, fd);
307 last_serial_opened = scb;
313 serial_fdopen (const int fd)
315 return serial_fdopen_ops (fd, NULL);
319 do_serial_close (struct serial *scb, int really_close)
321 struct serial *tmp_scb;
323 last_serial_opened = NULL;
327 fputs_unfiltered ("\nEnd of log\n", serial_logfp);
328 serial_current_type = 0;
330 /* XXX - What if serial_logfp == gdb_stdout or gdb_stderr? */
331 ui_file_delete (serial_logfp);
335 /* This is bogus. It's not our fault if you pass us a bad scb...! Rob, you
336 should fix your code instead. */
345 /* ensure that the FD has been taken out of async mode. */
346 if (scb->async_handler != NULL)
347 serial_async (scb, NULL, NULL);
350 scb->ops->close (scb);
356 scb_base = scb_base->next;
358 for (tmp_scb = scb_base; tmp_scb; tmp_scb = tmp_scb->next)
360 if (tmp_scb->next != scb)
363 tmp_scb->next = tmp_scb->next->next;
371 serial_close (struct serial *scb)
373 do_serial_close (scb, 1);
377 serial_un_fdopen (struct serial *scb)
379 do_serial_close (scb, 0);
383 serial_readchar (struct serial *scb, int timeout)
387 /* FIXME: cagney/1999-10-11: Don't enable this check until the ASYNC
389 if (0 && serial_is_async_p (scb) && timeout < 0)
390 internal_error (__FILE__, __LINE__,
391 _("serial_readchar: blocking read in async mode"));
393 ch = scb->ops->readchar (scb, timeout);
394 if (serial_logfp != NULL)
396 serial_logchar (serial_logfp, 'r', ch, timeout);
398 /* Make sure that the log file is as up-to-date as possible,
399 in case we are getting ready to dump core or something. */
400 gdb_flush (serial_logfp);
402 if (serial_debug_p (scb))
404 fprintf_unfiltered (gdb_stdlog, "[");
405 serial_logchar (gdb_stdlog, 'r', ch, timeout);
406 fprintf_unfiltered (gdb_stdlog, "]");
407 gdb_flush (gdb_stdlog);
414 serial_write (struct serial *scb, const char *str, int len)
416 if (serial_logfp != NULL)
420 for (count = 0; count < len; count++)
421 serial_logchar (serial_logfp, 'w', str[count] & 0xff, 0);
423 /* Make sure that the log file is as up-to-date as possible,
424 in case we are getting ready to dump core or something. */
425 gdb_flush (serial_logfp);
427 if (serial_debug_p (scb))
431 for (count = 0; count < len; count++)
433 fprintf_unfiltered (gdb_stdlog, "[");
434 serial_logchar (gdb_stdlog, 'w', str[count] & 0xff, 0);
435 fprintf_unfiltered (gdb_stdlog, "]");
437 gdb_flush (gdb_stdlog);
440 return (scb->ops->write (scb, str, len));
444 serial_printf (struct serial *desc, const char *format,...)
448 va_start (args, format);
450 buf = xstrvprintf (format, args);
451 serial_write (desc, buf, strlen (buf));
458 serial_drain_output (struct serial *scb)
460 return scb->ops->drain_output (scb);
464 serial_flush_output (struct serial *scb)
466 return scb->ops->flush_output (scb);
470 serial_flush_input (struct serial *scb)
472 return scb->ops->flush_input (scb);
476 serial_send_break (struct serial *scb)
478 if (serial_logfp != NULL)
479 serial_logchar (serial_logfp, 'w', SERIAL_BREAK, 0);
481 return (scb->ops->send_break (scb));
485 serial_raw (struct serial *scb)
487 scb->ops->go_raw (scb);
491 serial_get_tty_state (struct serial *scb)
493 return scb->ops->get_tty_state (scb);
497 serial_set_tty_state (struct serial *scb, serial_ttystate ttystate)
499 return scb->ops->set_tty_state (scb, ttystate);
503 serial_print_tty_state (struct serial *scb,
504 serial_ttystate ttystate,
505 struct ui_file *stream)
507 scb->ops->print_tty_state (scb, ttystate, stream);
511 serial_noflush_set_tty_state (struct serial *scb,
512 serial_ttystate new_ttystate,
513 serial_ttystate old_ttystate)
515 return scb->ops->noflush_set_tty_state (scb, new_ttystate, old_ttystate);
519 serial_setbaudrate (struct serial *scb, int rate)
521 return scb->ops->setbaudrate (scb, rate);
525 serial_setstopbits (struct serial *scb, int num)
527 return scb->ops->setstopbits (scb, num);
531 serial_can_async_p (struct serial *scb)
533 return (scb->ops->async != NULL);
537 serial_is_async_p (struct serial *scb)
539 return (scb->ops->async != NULL) && (scb->async_handler != NULL);
543 serial_async (struct serial *scb,
544 serial_event_ftype *handler,
547 int changed = ((scb->async_handler == NULL) != (handler == NULL));
549 scb->async_handler = handler;
550 scb->async_context = context;
551 /* Only change mode if there is a need. */
553 scb->ops->async (scb, handler != NULL);
557 deprecated_serial_fd (struct serial *scb)
559 /* FIXME: should this output a warning that deprecated code is being
563 internal_error (__FILE__, __LINE__,
564 _("serial: FD not valid"));
566 return scb->fd; /* sigh */
570 serial_debug (struct serial *scb, int debug_p)
572 scb->debug_p = debug_p;
576 serial_debug_p (struct serial *scb)
578 return scb->debug_p || global_serial_debug_p;
583 serial_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except)
585 if (scb->ops->wait_handle)
586 scb->ops->wait_handle (scb, read, except);
589 *read = (HANDLE) _get_osfhandle (scb->fd);
595 serial_done_wait_handle (struct serial *scb)
597 if (scb->ops->done_wait_handle)
598 scb->ops->done_wait_handle (scb);
603 serial_pipe (struct serial *scbs[2])
605 struct serial_ops *ops;
608 ops = serial_interface_lookup ("pipe");
615 if (gdb_pipe (fildes) == -1)
618 scbs[0] = serial_fdopen_ops (fildes[0], ops);
619 scbs[1] = serial_fdopen_ops (fildes[1], ops);
624 /* The connect command is #if 0 because I hadn't thought of an elegant
625 way to wait for I/O on two `struct serial *'s simultaneously. Two
626 solutions came to mind:
628 1) Fork, and have have one fork handle the to user direction,
629 and have the other hand the to target direction. This
630 obviously won't cut it for MSDOS.
632 2) Use something like select. This assumes that stdin and
633 the target side can both be waited on via the same
634 mechanism. This may not be true for DOS, if GDB is
635 talking to the target via a TCP socket.
636 -grossman, 8 Jun 93 */
638 /* Connect the user directly to the remote system. This command acts just like
639 the 'cu' or 'tip' command. Use <CR>~. or <CR>~^D to break out. */
641 static struct serial *tty_desc; /* Controlling terminal */
644 cleanup_tty (serial_ttystate ttystate)
646 printf_unfiltered ("\r\n[Exiting connect mode]\r\n");
647 serial_set_tty_state (tty_desc, ttystate);
649 serial_close (tty_desc);
653 connect_command (char *args, int fromtty)
657 serial_ttystate ttystate;
658 struct serial *port_desc; /* TTY port */
663 fprintf_unfiltered (gdb_stderr,
664 "This command takes no args. "
665 "They have been ignored.\n");
667 printf_unfiltered ("[Entering connect mode. Use ~. or ~^D to escape]\n");
669 tty_desc = serial_fdopen (0);
670 port_desc = last_serial_opened;
672 ttystate = serial_get_tty_state (tty_desc);
674 serial_raw (tty_desc);
675 serial_raw (port_desc);
677 make_cleanup (cleanup_tty, ttystate);
683 mask = serial_wait_2 (tty_desc, port_desc, -1);
691 c = serial_readchar (tty_desc, 0);
693 if (c == SERIAL_TIMEOUT)
697 perror_with_name (_("connect"));
700 serial_write (port_desc, &cx, 1);
715 if (c == '.' || c == '\004')
729 c = serial_readchar (port_desc, 0);
731 if (c == SERIAL_TIMEOUT)
735 perror_with_name (_("connect"));
739 serial_write (tty_desc, &cx, 1);
746 /* Serial set/show framework. */
748 static struct cmd_list_element *serial_set_cmdlist;
749 static struct cmd_list_element *serial_show_cmdlist;
752 serial_set_cmd (char *args, int from_tty)
754 printf_unfiltered ("\"set serial\" must be followed "
755 "by the name of a command.\n");
756 help_list (serial_set_cmdlist, "set serial ", -1, gdb_stdout);
760 serial_show_cmd (char *args, int from_tty)
762 cmd_show_list (serial_show_cmdlist, from_tty, "");
767 _initialize_serial (void)
770 add_com ("connect", class_obscure, connect_command, _("\
771 Connect the terminal directly up to the command monitor.\n\
772 Use <CR>~. or <CR>~^D to break out."));
775 add_prefix_cmd ("serial", class_maintenance, serial_set_cmd, _("\
776 Set default serial/parallel port configuration."),
777 &serial_set_cmdlist, "set serial ",
781 add_prefix_cmd ("serial", class_maintenance, serial_show_cmd, _("\
782 Show default serial/parallel port configuration."),
783 &serial_show_cmdlist, "show serial ",
787 add_setshow_filename_cmd ("remotelogfile", no_class, &serial_logfile, _("\
788 Set filename for remote session recording."), _("\
789 Show filename for remote session recording."), _("\
790 This file is used to record the remote session for future playback\n\
793 NULL, /* FIXME: i18n: */
794 &setlist, &showlist);
796 add_setshow_enum_cmd ("remotelogbase", no_class, logbase_enums,
797 &serial_logbase, _("\
798 Set numerical base for remote session logging"), _("\
799 Show numerical base for remote session logging"), NULL,
801 NULL, /* FIXME: i18n: */
802 &setlist, &showlist);
804 add_setshow_zinteger_cmd ("serial", class_maintenance,
805 &global_serial_debug_p, _("\
806 Set serial debugging."), _("\
807 Show serial debugging."), _("\
808 When non-zero, serial port debugging is enabled."),
810 NULL, /* FIXME: i18n: */
811 &setdebuglist, &showdebuglist);