/* Generic serial interface routines Copyright (C) 1992-2024 Free Software Foundation, Inc. This file is part of GDB. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include <ctype.h> #include "serial.h" #include "cli/cli-cmds.h" #include "cli/cli-utils.h" /* Is serial being debugged? */ static unsigned int global_serial_debug_p; /* Serial I/O handlers. */ static std::vector<const struct serial_ops *> serial_ops_list; /* Pointer to list of scb's. */ static struct serial *scb_base; /* Non-NULL gives filename which contains a recording of the remote session, suitable for playback by gdbserver. */ static std::string serial_logfile; static struct ui_file *serial_logfp = NULL; static const struct serial_ops *serial_interface_lookup (const char *); static void serial_logchar (struct ui_file *stream, int ch_type, int ch, int timeout); static const char logbase_hex[] = "hex"; static const char logbase_octal[] = "octal"; static const char logbase_ascii[] = "ascii"; static const char *const logbase_enums[] = {logbase_hex, logbase_octal, logbase_ascii, NULL}; static const char *serial_logbase = logbase_ascii; static int serial_current_type = 0; /* Log char CH of type CHTYPE, with TIMEOUT. */ /* Define bogus char to represent a BREAK. Should be careful to choose a value that can't be confused with a normal char, or an error code. */ #define SERIAL_BREAK 1235 static void serial_logchar (struct ui_file *stream, int ch_type, int ch, int timeout) { if (ch_type != serial_current_type) { gdb_printf (stream, "\n%c ", ch_type); serial_current_type = ch_type; } if (serial_logbase != logbase_ascii) gdb_putc (' ', stream); switch (ch) { case SERIAL_TIMEOUT: gdb_printf (stream, "<Timeout: %d seconds>", timeout); return; case SERIAL_ERROR: gdb_printf (stream, "<Error: %s>", safe_strerror (errno)); return; case SERIAL_EOF: gdb_puts ("<Eof>", stream); return; case SERIAL_BREAK: gdb_puts ("<Break>", stream); return; default: if (serial_logbase == logbase_hex) gdb_printf (stream, "%02x", ch & 0xff); else if (serial_logbase == logbase_octal) gdb_printf (stream, "%03o", ch & 0xff); else switch (ch) { case '\\': gdb_puts ("\\\\", stream); break; case '\b': gdb_puts ("\\b", stream); break; case '\f': gdb_puts ("\\f", stream); break; case '\n': gdb_puts ("\\n", stream); break; case '\r': gdb_puts ("\\r", stream); break; case '\t': gdb_puts ("\\t", stream); break; case '\v': gdb_puts ("\\v", stream); break; default: gdb_printf (stream, isprint (ch) ? "%c" : "\\x%02x", ch & 0xFF); break; } } } void serial_log_command (struct target_ops *self, const char *cmd) { if (!serial_logfp) return; serial_current_type = 'c'; gdb_puts ("\nc ", serial_logfp); gdb_puts (cmd, serial_logfp); /* Make sure that the log file is as up-to-date as possible, in case we are getting ready to dump core or something. */ gdb_flush (serial_logfp); } static const struct serial_ops * serial_interface_lookup (const char *name) { for (const serial_ops *ops : serial_ops_list) if (strcmp (name, ops->name) == 0) return ops; return NULL; } void serial_add_interface (const struct serial_ops *optable) { serial_ops_list.push_back (optable); } /* Return the open serial device for FD, if found, or NULL if FD is not already opened. */ struct serial * serial_for_fd (int fd) { struct serial *scb; for (scb = scb_base; scb; scb = scb->next) if (scb->fd == fd) return scb; return NULL; } /* Create a new serial for OPS. */ static gdb::unique_xmalloc_ptr<struct serial> new_serial (const struct serial_ops *ops) { gdb::unique_xmalloc_ptr<struct serial> scb (XCNEW (struct serial)); scb->ops = ops; scb->bufp = scb->buf; scb->error_fd = -1; scb->refcnt = 1; return scb; } static struct serial *serial_open_ops_1 (const struct serial_ops *ops, const char *open_name); /* Open up a device or a network socket, depending upon the syntax of NAME. */ struct serial * serial_open (const char *name) { const struct serial_ops *ops; const char *open_name = name; if (startswith (name, "|")) ops = serial_interface_lookup ("pipe"); /* Check for a colon, suggesting an IP address/port pair. Do this *after* checking for all the interesting prefixes. We don't want to constrain the syntax of what can follow them. */ else if (strchr (name, ':')) ops = serial_interface_lookup ("tcp"); else { #ifndef USE_WIN32API /* Check to see if name is a socket. If it is, then treat it as such. Otherwise assume that it's a character device. */ struct stat sb; if (stat (name, &sb) == 0 && (sb.st_mode & S_IFMT) == S_IFSOCK) ops = serial_interface_lookup ("local"); else #endif ops = serial_interface_lookup ("hardwire"); } if (!ops) error (_("could not find serial handler for '%s'"), name); return serial_open_ops_1 (ops, open_name); } /* Open up a serial for OPS, passing OPEN_NAME to the open method. */ static struct serial * serial_open_ops_1 (const struct serial_ops *ops, const char *open_name) { gdb::unique_xmalloc_ptr<struct serial> scb = new_serial (ops); /* `...->open (...)' would get expanded by the open(2) syscall macro. */ (*scb->ops->open) (scb.get (), open_name); scb->name = open_name != NULL ? xstrdup (open_name) : NULL; scb->next = scb_base; scb_base = scb.get (); if (!serial_logfile.empty ()) { stdio_file_up file (new stdio_file ()); if (!file->open (serial_logfile.c_str (), "w")) perror_with_name (serial_logfile.c_str ()); serial_logfp = file.release (); } return scb.release (); } /* See serial.h. */ struct serial * serial_open_ops (const struct serial_ops *ops) { return serial_open_ops_1 (ops, NULL); } /* Open a new serial stream using a file handle, using serial interface ops OPS. */ static struct serial * serial_fdopen_ops (const int fd, const struct serial_ops *ops) { if (!ops) { ops = serial_interface_lookup ("terminal"); if (!ops) ops = serial_interface_lookup ("hardwire"); } if (!ops) return NULL; gdb::unique_xmalloc_ptr<struct serial> scb = new_serial (ops); scb->name = NULL; scb->next = scb_base; scb_base = scb.get (); if ((ops->fdopen) != NULL) (*ops->fdopen) (scb.get (), fd); else scb->fd = fd; return scb.release (); } struct serial * serial_fdopen (const int fd) { return serial_fdopen_ops (fd, NULL); } static void do_serial_close (struct serial *scb, int really_close) { struct serial *tmp_scb; if (serial_logfp) { gdb_puts ("\nEnd of log\n", serial_logfp); serial_current_type = 0; /* XXX - What if serial_logfp == gdb_stdout or gdb_stderr? */ delete serial_logfp; serial_logfp = NULL; } /* ensure that the FD has been taken out of async mode. */ if (scb->async_handler != NULL) serial_async (scb, NULL, NULL); if (really_close) scb->ops->close (scb); xfree (scb->name); /* For serial_is_open. */ scb->bufp = NULL; if (scb_base == scb) scb_base = scb_base->next; else for (tmp_scb = scb_base; tmp_scb; tmp_scb = tmp_scb->next) { if (tmp_scb->next != scb) continue; tmp_scb->next = tmp_scb->next->next; break; } serial_unref (scb); } void serial_close (struct serial *scb) { do_serial_close (scb, 1); } void serial_un_fdopen (struct serial *scb) { do_serial_close (scb, 0); } int serial_is_open (struct serial *scb) { return scb->bufp != NULL; } void serial_ref (struct serial *scb) { scb->refcnt++; } void serial_unref (struct serial *scb) { --scb->refcnt; if (scb->refcnt == 0) xfree (scb); } int serial_readchar (struct serial *scb, int timeout) { int ch; /* FIXME: cagney/1999-10-11: Don't enable this check until the ASYNC code is finished. */ if (0 && serial_is_async_p (scb) && timeout < 0) internal_error (_("serial_readchar: blocking read in async mode")); ch = scb->ops->readchar (scb, timeout); if (serial_logfp != NULL) { serial_logchar (serial_logfp, 'r', ch, timeout); /* Make sure that the log file is as up-to-date as possible, in case we are getting ready to dump core or something. */ gdb_flush (serial_logfp); } if (serial_debug_p (scb)) { gdb_printf (gdb_stdlog, "["); serial_logchar (gdb_stdlog, 'r', ch, timeout); gdb_printf (gdb_stdlog, "]"); gdb_flush (gdb_stdlog); } return (ch); } void serial_write (struct serial *scb, const void *buf, size_t count) { if (serial_logfp != NULL) { const char *str = (const char *) buf; size_t c; for (c = 0; c < count; c++) serial_logchar (serial_logfp, 'w', str[c] & 0xff, 0); /* Make sure that the log file is as up-to-date as possible, in case we are getting ready to dump core or something. */ gdb_flush (serial_logfp); } if (serial_debug_p (scb)) { const char *str = (const char *) buf; size_t c; for (c = 0; c < count; c++) { gdb_printf (gdb_stdlog, "["); serial_logchar (gdb_stdlog, 'w', str[c] & 0xff, 0); gdb_printf (gdb_stdlog, "]"); } gdb_flush (gdb_stdlog); } scb->ops->write (scb, buf, count); } void serial_printf (struct serial *desc, const char *format, ...) { va_list args; va_start (args, format); std::string buf = string_vprintf (format, args); serial_write (desc, buf.c_str (), buf.length ()); va_end (args); } int serial_drain_output (struct serial *scb) { return scb->ops->drain_output (scb); } int serial_flush_output (struct serial *scb) { return scb->ops->flush_output (scb); } int serial_flush_input (struct serial *scb) { return scb->ops->flush_input (scb); } void serial_send_break (struct serial *scb) { if (serial_logfp != NULL) serial_logchar (serial_logfp, 'w', SERIAL_BREAK, 0); scb->ops->send_break (scb); } void serial_raw (struct serial *scb) { scb->ops->go_raw (scb); } serial_ttystate serial_get_tty_state (struct serial *scb) { return scb->ops->get_tty_state (scb); } serial_ttystate serial_copy_tty_state (struct serial *scb, serial_ttystate ttystate) { return scb->ops->copy_tty_state (scb, ttystate); } int serial_set_tty_state (struct serial *scb, serial_ttystate ttystate) { return scb->ops->set_tty_state (scb, ttystate); } void serial_print_tty_state (struct serial *scb, serial_ttystate ttystate, struct ui_file *stream) { scb->ops->print_tty_state (scb, ttystate, stream); } void serial_setbaudrate (struct serial *scb, int rate) { scb->ops->setbaudrate (scb, rate); } int serial_setstopbits (struct serial *scb, int num) { return scb->ops->setstopbits (scb, num); } /* See serial.h. */ int serial_setparity (struct serial *scb, int parity) { return scb->ops->setparity (scb, parity); } int serial_can_async_p (struct serial *scb) { return (scb->ops->async != NULL); } int serial_is_async_p (struct serial *scb) { return (scb->ops->async != NULL) && (scb->async_handler != NULL); } void serial_async (struct serial *scb, serial_event_ftype *handler, void *context) { int changed = ((scb->async_handler == NULL) != (handler == NULL)); scb->async_handler = handler; scb->async_context = context; /* Only change mode if there is a need. */ if (changed) scb->ops->async (scb, handler != NULL); } void serial_debug (struct serial *scb, int debug_p) { scb->debug_p = debug_p; } int serial_debug_p (struct serial *scb) { return scb->debug_p || global_serial_debug_p; } #ifdef USE_WIN32API void serial_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except) { if (scb->ops->wait_handle) scb->ops->wait_handle (scb, read, except); else { *read = (HANDLE) _get_osfhandle (scb->fd); *except = NULL; } } void serial_done_wait_handle (struct serial *scb) { if (scb->ops->done_wait_handle) scb->ops->done_wait_handle (scb); } #endif int serial_pipe (struct serial *scbs[2]) { const struct serial_ops *ops; int fildes[2]; ops = serial_interface_lookup ("pipe"); if (!ops) { errno = ENOSYS; return -1; } if (gdb_pipe (fildes) == -1) return -1; scbs[0] = serial_fdopen_ops (fildes[0], ops); scbs[1] = serial_fdopen_ops (fildes[1], ops); return 0; } /* Serial set/show framework. */ static struct cmd_list_element *serial_set_cmdlist; static struct cmd_list_element *serial_show_cmdlist; /* See serial.h. */ int baud_rate = -1; static void serial_baud_show_cmd (struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value) { gdb_printf (file, _("Baud rate for remote serial I/O is %s.\n"), value); } /* See serial.h. */ int serial_parity = GDBPARITY_NONE; static const char parity_none[] = "none"; static const char parity_odd[] = "odd"; static const char parity_even[] = "even"; static const char *const parity_enums[] = {parity_none, parity_odd, parity_even, NULL}; static const char *parity = parity_none; /* Set serial_parity value. */ static void set_parity (const char *ignore_args, int from_tty, struct cmd_list_element *c) { if (parity == parity_odd) serial_parity = GDBPARITY_ODD; else if (parity == parity_even) serial_parity = GDBPARITY_EVEN; else serial_parity = GDBPARITY_NONE; } void _initialize_serial (); void _initialize_serial () { #if 0 add_com ("connect", class_obscure, connect_command, _("\ Connect the terminal directly up to the command monitor.\n\ Use <CR>~. or <CR>~^D to break out.")); #endif /* 0 */ add_setshow_prefix_cmd ("serial", class_maintenance, _("Set default serial/parallel port configuration."), _("Show default serial/parallel port configuration."), &serial_set_cmdlist, &serial_show_cmdlist, &setlist, &showlist); /* If target is open when baud changes, it doesn't take effect until the next open (I think, not sure). */ add_setshow_zinteger_cmd ("baud", no_class, &baud_rate, _("\ Set baud rate for remote serial I/O."), _("\ Show baud rate for remote serial I/O."), _("\ This value is used to set the speed of the serial port when debugging\n\ using remote targets."), NULL, serial_baud_show_cmd, &serial_set_cmdlist, &serial_show_cmdlist); add_setshow_enum_cmd ("parity", no_class, parity_enums, &parity, _("\ Set parity for remote serial I/O."), _("\ Show parity for remote serial I/O."), NULL, set_parity, NULL, /* FIXME: i18n: */ &serial_set_cmdlist, &serial_show_cmdlist); add_setshow_filename_cmd ("remotelogfile", no_class, &serial_logfile, _("\ Set filename for remote session recording."), _("\ Show filename for remote session recording."), _("\ This file is used to record the remote session for future playback\n\ by gdbserver."), NULL, NULL, /* FIXME: i18n: */ &setlist, &showlist); add_setshow_enum_cmd ("remotelogbase", no_class, logbase_enums, &serial_logbase, _("\ Set numerical base for remote session logging."), _("\ Show numerical base for remote session logging."), NULL, NULL, NULL, /* FIXME: i18n: */ &setlist, &showlist); add_setshow_zuinteger_cmd ("serial", class_maintenance, &global_serial_debug_p, _("\ Set serial debugging."), _("\ Show serial debugging."), _("\ When non-zero, serial port debugging is enabled."), NULL, NULL, /* FIXME: i18n: */ &setdebuglist, &showdebuglist); }