1 /* Generic serial interface routines
3 Copyright (C) 1992-2018 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
24 #include "cli/cli-utils.h"
26 /* Is serial being debugged? */
28 static unsigned int global_serial_debug_p;
30 typedef const struct serial_ops *serial_ops_p;
31 DEF_VEC_P (serial_ops_p);
33 /* Serial I/O handlers. */
35 VEC (serial_ops_p) *serial_ops_list = NULL;
37 /* Pointer to list of scb's. */
39 static struct serial *scb_base;
41 /* Non-NULL gives filename which contains a recording of the remote session,
42 suitable for playback by gdbserver. */
44 static char *serial_logfile = NULL;
45 static struct ui_file *serial_logfp = NULL;
47 static const struct serial_ops *serial_interface_lookup (const char *);
48 static void serial_logchar (struct ui_file *stream,
49 int ch_type, int ch, int timeout);
50 static const char logbase_hex[] = "hex";
51 static const char logbase_octal[] = "octal";
52 static const char logbase_ascii[] = "ascii";
53 static const char *const logbase_enums[] =
54 {logbase_hex, logbase_octal, logbase_ascii, NULL};
55 static const char *serial_logbase = logbase_ascii;
58 static int serial_current_type = 0;
60 /* Log char CH of type CHTYPE, with TIMEOUT. */
62 /* Define bogus char to represent a BREAK. Should be careful to choose a value
63 that can't be confused with a normal char, or an error code. */
64 #define SERIAL_BREAK 1235
67 serial_logchar (struct ui_file *stream, int ch_type, int ch, int timeout)
69 if (ch_type != serial_current_type)
71 fprintf_unfiltered (stream, "\n%c ", ch_type);
72 serial_current_type = ch_type;
75 if (serial_logbase != logbase_ascii)
76 fputc_unfiltered (' ', stream);
81 fprintf_unfiltered (stream, "<Timeout: %d seconds>", timeout);
84 fprintf_unfiltered (stream, "<Error: %s>", safe_strerror (errno));
87 fputs_unfiltered ("<Eof>", stream);
90 fputs_unfiltered ("<Break>", stream);
93 if (serial_logbase == logbase_hex)
94 fprintf_unfiltered (stream, "%02x", ch & 0xff);
95 else if (serial_logbase == logbase_octal)
96 fprintf_unfiltered (stream, "%03o", ch & 0xff);
101 fputs_unfiltered ("\\\\", stream);
104 fputs_unfiltered ("\\b", stream);
107 fputs_unfiltered ("\\f", stream);
110 fputs_unfiltered ("\\n", stream);
113 fputs_unfiltered ("\\r", stream);
116 fputs_unfiltered ("\\t", stream);
119 fputs_unfiltered ("\\v", stream);
122 fprintf_unfiltered (stream,
123 isprint (ch) ? "%c" : "\\x%02x", ch & 0xFF);
130 serial_log_command (struct target_ops *self, const char *cmd)
135 serial_current_type = 'c';
137 fputs_unfiltered ("\nc ", serial_logfp);
138 fputs_unfiltered (cmd, serial_logfp);
140 /* Make sure that the log file is as up-to-date as possible,
141 in case we are getting ready to dump core or something. */
142 gdb_flush (serial_logfp);
146 static const struct serial_ops *
147 serial_interface_lookup (const char *name)
149 const struct serial_ops *ops;
152 for (i = 0; VEC_iterate (serial_ops_p, serial_ops_list, i, ops); ++i)
153 if (strcmp (name, ops->name) == 0)
160 serial_add_interface (const struct serial_ops *optable)
162 VEC_safe_push (serial_ops_p, serial_ops_list, optable);
165 /* Return the open serial device for FD, if found, or NULL if FD is
166 not already opened. */
169 serial_for_fd (int fd)
173 for (scb = scb_base; scb; scb = scb->next)
180 /* Create a new serial for OPS. */
182 static struct serial *
183 new_serial (const struct serial_ops *ops)
187 scb = XCNEW (struct serial);
191 scb->bufp = scb->buf;
198 static struct serial *serial_open_ops_1 (const struct serial_ops *ops,
199 const char *open_name);
201 /* Open up a device or a network socket, depending upon the syntax of NAME. */
204 serial_open (const char *name)
206 const struct serial_ops *ops;
207 const char *open_name = name;
209 if (startswith (name, "|"))
211 ops = serial_interface_lookup ("pipe");
212 /* Discard ``|'' and any space before the command itself. */
214 open_name = skip_spaces (open_name);
216 /* Check for a colon, suggesting an IP address/port pair.
217 Do this *after* checking for all the interesting prefixes. We
218 don't want to constrain the syntax of what can follow them. */
219 else if (strchr (name, ':'))
220 ops = serial_interface_lookup ("tcp");
222 ops = serial_interface_lookup ("hardwire");
227 return serial_open_ops_1 (ops, open_name);
230 /* Open up a serial for OPS, passing OPEN_NAME to the open method. */
232 static struct serial *
233 serial_open_ops_1 (const struct serial_ops *ops, const char *open_name)
237 scb = new_serial (ops);
239 /* `...->open (...)' would get expanded by the open(2) syscall macro. */
240 if ((*scb->ops->open) (scb, open_name))
246 scb->next = scb_base;
249 if (serial_logfile != NULL)
251 stdio_file_up file (new stdio_file ());
253 if (!file->open (serial_logfile, "w"))
254 perror_with_name (serial_logfile);
256 serial_logfp = file.release ();
265 serial_open_ops (const struct serial_ops *ops)
267 return serial_open_ops_1 (ops, NULL);
270 /* Open a new serial stream using a file handle, using serial
271 interface ops OPS. */
273 static struct serial *
274 serial_fdopen_ops (const int fd, const struct serial_ops *ops)
280 ops = serial_interface_lookup ("terminal");
282 ops = serial_interface_lookup ("hardwire");
288 scb = new_serial (ops);
290 scb->next = scb_base;
293 if ((ops->fdopen) != NULL)
294 (*ops->fdopen) (scb, fd);
302 serial_fdopen (const int fd)
304 return serial_fdopen_ops (fd, NULL);
308 do_serial_close (struct serial *scb, int really_close)
310 struct serial *tmp_scb;
314 fputs_unfiltered ("\nEnd of log\n", serial_logfp);
315 serial_current_type = 0;
317 /* XXX - What if serial_logfp == gdb_stdout or gdb_stderr? */
322 /* ensure that the FD has been taken out of async mode. */
323 if (scb->async_handler != NULL)
324 serial_async (scb, NULL, NULL);
327 scb->ops->close (scb);
329 /* For serial_is_open. */
333 scb_base = scb_base->next;
335 for (tmp_scb = scb_base; tmp_scb; tmp_scb = tmp_scb->next)
337 if (tmp_scb->next != scb)
340 tmp_scb->next = tmp_scb->next->next;
348 serial_close (struct serial *scb)
350 do_serial_close (scb, 1);
354 serial_un_fdopen (struct serial *scb)
356 do_serial_close (scb, 0);
360 serial_is_open (struct serial *scb)
362 return scb->bufp != NULL;
366 serial_ref (struct serial *scb)
372 serial_unref (struct serial *scb)
375 if (scb->refcnt == 0)
380 serial_readchar (struct serial *scb, int timeout)
384 /* FIXME: cagney/1999-10-11: Don't enable this check until the ASYNC
386 if (0 && serial_is_async_p (scb) && timeout < 0)
387 internal_error (__FILE__, __LINE__,
388 _("serial_readchar: blocking read in async mode"));
390 ch = scb->ops->readchar (scb, timeout);
391 if (serial_logfp != NULL)
393 serial_logchar (serial_logfp, 'r', ch, timeout);
395 /* Make sure that the log file is as up-to-date as possible,
396 in case we are getting ready to dump core or something. */
397 gdb_flush (serial_logfp);
399 if (serial_debug_p (scb))
401 fprintf_unfiltered (gdb_stdlog, "[");
402 serial_logchar (gdb_stdlog, 'r', ch, timeout);
403 fprintf_unfiltered (gdb_stdlog, "]");
404 gdb_flush (gdb_stdlog);
411 serial_write (struct serial *scb, const void *buf, size_t count)
413 if (serial_logfp != NULL)
415 const char *str = (const char *) buf;
418 for (c = 0; c < count; c++)
419 serial_logchar (serial_logfp, 'w', str[c] & 0xff, 0);
421 /* Make sure that the log file is as up-to-date as possible,
422 in case we are getting ready to dump core or something. */
423 gdb_flush (serial_logfp);
425 if (serial_debug_p (scb))
427 const char *str = (const char *) buf;
430 for (c = 0; c < count; c++)
432 fprintf_unfiltered (gdb_stdlog, "[");
433 serial_logchar (gdb_stdlog, 'w', str[c] & 0xff, 0);
434 fprintf_unfiltered (gdb_stdlog, "]");
436 gdb_flush (gdb_stdlog);
439 return (scb->ops->write (scb, buf, count));
443 serial_printf (struct serial *desc, const char *format,...)
447 va_start (args, format);
449 buf = xstrvprintf (format, args);
450 serial_write (desc, buf, strlen (buf));
457 serial_drain_output (struct serial *scb)
459 return scb->ops->drain_output (scb);
463 serial_flush_output (struct serial *scb)
465 return scb->ops->flush_output (scb);
469 serial_flush_input (struct serial *scb)
471 return scb->ops->flush_input (scb);
475 serial_send_break (struct serial *scb)
477 if (serial_logfp != NULL)
478 serial_logchar (serial_logfp, 'w', SERIAL_BREAK, 0);
480 return (scb->ops->send_break (scb));
484 serial_raw (struct serial *scb)
486 scb->ops->go_raw (scb);
490 serial_get_tty_state (struct serial *scb)
492 return scb->ops->get_tty_state (scb);
496 serial_copy_tty_state (struct serial *scb, serial_ttystate ttystate)
498 return scb->ops->copy_tty_state (scb, ttystate);
502 serial_set_tty_state (struct serial *scb, serial_ttystate ttystate)
504 return scb->ops->set_tty_state (scb, ttystate);
508 serial_print_tty_state (struct serial *scb,
509 serial_ttystate ttystate,
510 struct ui_file *stream)
512 scb->ops->print_tty_state (scb, ttystate, stream);
516 serial_setbaudrate (struct serial *scb, int rate)
518 return scb->ops->setbaudrate (scb, rate);
522 serial_setstopbits (struct serial *scb, int num)
524 return scb->ops->setstopbits (scb, num);
530 serial_setparity (struct serial *scb, int parity)
532 return scb->ops->setparity (scb, parity);
536 serial_can_async_p (struct serial *scb)
538 return (scb->ops->async != NULL);
542 serial_is_async_p (struct serial *scb)
544 return (scb->ops->async != NULL) && (scb->async_handler != NULL);
548 serial_async (struct serial *scb,
549 serial_event_ftype *handler,
552 int changed = ((scb->async_handler == NULL) != (handler == NULL));
554 scb->async_handler = handler;
555 scb->async_context = context;
556 /* Only change mode if there is a need. */
558 scb->ops->async (scb, handler != NULL);
562 serial_debug (struct serial *scb, int debug_p)
564 scb->debug_p = debug_p;
568 serial_debug_p (struct serial *scb)
570 return scb->debug_p || global_serial_debug_p;
575 serial_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except)
577 if (scb->ops->wait_handle)
578 scb->ops->wait_handle (scb, read, except);
581 *read = (HANDLE) _get_osfhandle (scb->fd);
587 serial_done_wait_handle (struct serial *scb)
589 if (scb->ops->done_wait_handle)
590 scb->ops->done_wait_handle (scb);
595 serial_pipe (struct serial *scbs[2])
597 const struct serial_ops *ops;
600 ops = serial_interface_lookup ("pipe");
607 if (gdb_pipe (fildes) == -1)
610 scbs[0] = serial_fdopen_ops (fildes[0], ops);
611 scbs[1] = serial_fdopen_ops (fildes[1], ops);
615 /* Serial set/show framework. */
617 static struct cmd_list_element *serial_set_cmdlist;
618 static struct cmd_list_element *serial_show_cmdlist;
621 serial_set_cmd (const char *args, int from_tty)
623 printf_unfiltered ("\"set serial\" must be followed "
624 "by the name of a command.\n");
625 help_list (serial_set_cmdlist, "set serial ", all_commands, gdb_stdout);
629 serial_show_cmd (const char *args, int from_tty)
631 cmd_show_list (serial_show_cmdlist, from_tty, "");
634 /* Baud rate specified for talking to serial target systems. Default
635 is left as -1, so targets can choose their own defaults. */
636 /* FIXME: This means that "show serial baud" and gr_files_info can
637 print -1 or (unsigned int)-1. This is a Bad User Interface. */
642 serial_baud_show_cmd (struct ui_file *file, int from_tty,
643 struct cmd_list_element *c, const char *value)
645 fprintf_filtered (file, _("Baud rate for remote serial I/O is %s.\n"),
649 /* Parity for serial port. */
651 int serial_parity = GDBPARITY_NONE;
653 static const char parity_none[] = "none";
654 static const char parity_odd[] = "odd";
655 static const char parity_even[] = "even";
656 static const char *const parity_enums[] =
657 {parity_none, parity_odd, parity_even, NULL};
658 static const char *parity = parity_none;
660 /* Set serial_parity value. */
663 set_parity (const char *ignore_args, int from_tty, struct cmd_list_element *c)
665 if (parity == parity_odd)
666 serial_parity = GDBPARITY_ODD;
667 else if (parity == parity_even)
668 serial_parity = GDBPARITY_EVEN;
670 serial_parity = GDBPARITY_NONE;
674 _initialize_serial (void)
677 add_com ("connect", class_obscure, connect_command, _("\
678 Connect the terminal directly up to the command monitor.\n\
679 Use <CR>~. or <CR>~^D to break out."));
682 add_prefix_cmd ("serial", class_maintenance, serial_set_cmd, _("\
683 Set default serial/parallel port configuration."),
684 &serial_set_cmdlist, "set serial ",
688 add_prefix_cmd ("serial", class_maintenance, serial_show_cmd, _("\
689 Show default serial/parallel port configuration."),
690 &serial_show_cmdlist, "show serial ",
694 /* If target is open when baud changes, it doesn't take effect until
695 the next open (I think, not sure). */
696 add_setshow_zinteger_cmd ("baud", no_class, &baud_rate, _("\
697 Set baud rate for remote serial I/O."), _("\
698 Show baud rate for remote serial I/O."), _("\
699 This value is used to set the speed of the serial port when debugging\n\
700 using remote targets."),
702 serial_baud_show_cmd,
703 &serial_set_cmdlist, &serial_show_cmdlist);
705 add_setshow_enum_cmd ("parity", no_class, parity_enums,
707 Set parity for remote serial I/O"), _("\
708 Show parity for remote serial I/O"), NULL,
710 NULL, /* FIXME: i18n: */
711 &serial_set_cmdlist, &serial_show_cmdlist);
713 add_setshow_filename_cmd ("remotelogfile", no_class, &serial_logfile, _("\
714 Set filename for remote session recording."), _("\
715 Show filename for remote session recording."), _("\
716 This file is used to record the remote session for future playback\n\
719 NULL, /* FIXME: i18n: */
720 &setlist, &showlist);
722 add_setshow_enum_cmd ("remotelogbase", no_class, logbase_enums,
723 &serial_logbase, _("\
724 Set numerical base for remote session logging"), _("\
725 Show numerical base for remote session logging"), NULL,
727 NULL, /* FIXME: i18n: */
728 &setlist, &showlist);
730 add_setshow_zuinteger_cmd ("serial", class_maintenance,
731 &global_serial_debug_p, _("\
732 Set serial debugging."), _("\
733 Show serial debugging."), _("\
734 When non-zero, serial port debugging is enabled."),
736 NULL, /* FIXME: i18n: */
737 &setdebuglist, &showdebuglist);