1 /* Generic serial interface routines
3 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
4 2001, 2002, 2004, 2005, 2006 Free Software Foundation, Inc.
6 This file is part of GDB.
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.
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.
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., 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA. */
26 #include "gdb_string.h"
29 extern void _initialize_serial (void);
31 /* Is serial being debugged? */
33 static int global_serial_debug_p;
35 /* Linked list of serial I/O handlers */
37 static struct serial_ops *serial_ops_list = NULL;
39 /* This is the last serial stream opened. Used by connect command. */
41 static struct serial *last_serial_opened = NULL;
43 /* Pointer to list of scb's. */
45 static struct serial *scb_base;
47 /* Non-NULL gives filename which contains a recording of the remote session,
48 suitable for playback by gdbserver. */
50 static char *serial_logfile = NULL;
51 static struct ui_file *serial_logfp = NULL;
53 static struct serial_ops *serial_interface_lookup (char *);
54 static void serial_logchar (struct ui_file *stream, 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, isprint (ch) ? "%c" : "\\x%02x", ch & 0xFF);
134 serial_log_command (const char *cmd)
139 serial_current_type = 'c';
141 fputs_unfiltered ("\nc ", serial_logfp);
142 fputs_unfiltered (cmd, serial_logfp);
144 /* Make sure that the log file is as up-to-date as possible,
145 in case we are getting ready to dump core or something. */
146 gdb_flush (serial_logfp);
150 static struct serial_ops *
151 serial_interface_lookup (char *name)
153 struct serial_ops *ops;
155 for (ops = serial_ops_list; ops; ops = ops->next)
156 if (strcmp (name, ops->name) == 0)
163 serial_add_interface (struct serial_ops *optable)
165 optable->next = serial_ops_list;
166 serial_ops_list = optable;
169 /* Open up a device or a network socket, depending upon the syntax of NAME. */
172 serial_open (const char *name)
175 struct serial_ops *ops;
176 const char *open_name = name;
178 for (scb = scb_base; scb; scb = scb->next)
179 if (scb->name && strcmp (scb->name, name) == 0)
185 if (strcmp (name, "pc") == 0)
186 ops = serial_interface_lookup ("pc");
187 else if (strncmp (name, "lpt", 3) == 0)
188 ops = serial_interface_lookup ("parallel");
189 else if (strncmp (name, "|", 1) == 0)
191 ops = serial_interface_lookup ("pipe");
192 open_name = name + 1; /* discard ``|'' */
194 /* Check for a colon, suggesting an IP address/port pair.
195 Do this *after* checking for all the interesting prefixes. We
196 don't want to constrain the syntax of what can follow them. */
197 else if (strchr (name, ':'))
198 ops = serial_interface_lookup ("tcp");
200 ops = serial_interface_lookup ("hardwire");
205 scb = XMALLOC (struct serial);
210 scb->bufp = scb->buf;
212 if (scb->ops->open (scb, open_name))
218 scb->name = xstrdup (name);
219 scb->next = scb_base;
222 scb->async_state = 0;
223 scb->async_handler = NULL;
224 scb->async_context = NULL;
227 last_serial_opened = scb;
229 if (serial_logfile != NULL)
231 serial_logfp = gdb_fopen (serial_logfile, "w");
232 if (serial_logfp == NULL)
233 perror_with_name (serial_logfile);
239 /* Return the open serial device for FD, if found, or NULL if FD
240 is not already opened. */
243 serial_for_fd (int fd)
246 struct serial_ops *ops;
248 for (scb = scb_base; scb; scb = scb->next)
256 serial_fdopen (const int fd)
259 struct serial_ops *ops;
261 for (scb = scb_base; scb; scb = scb->next)
268 ops = serial_interface_lookup ("terminal");
270 ops = serial_interface_lookup ("hardwire");
275 scb = XCALLOC (1, struct serial);
280 scb->bufp = scb->buf;
285 scb->next = scb_base;
288 scb->async_state = 0;
289 scb->async_handler = NULL;
290 scb->async_context = NULL;
293 last_serial_opened = scb;
299 do_serial_close (struct serial *scb, int really_close)
301 struct serial *tmp_scb;
303 last_serial_opened = NULL;
307 fputs_unfiltered ("\nEnd of log\n", serial_logfp);
308 serial_current_type = 0;
310 /* XXX - What if serial_logfp == gdb_stdout or gdb_stderr? */
311 ui_file_delete (serial_logfp);
315 /* This is bogus. It's not our fault if you pass us a bad scb...! Rob, you
316 should fix your code instead. */
325 /* ensure that the FD has been taken out of async mode */
326 if (scb->async_handler != NULL)
327 serial_async (scb, NULL, NULL);
330 scb->ops->close (scb);
336 scb_base = scb_base->next;
338 for (tmp_scb = scb_base; tmp_scb; tmp_scb = tmp_scb->next)
340 if (tmp_scb->next != scb)
343 tmp_scb->next = tmp_scb->next->next;
351 serial_close (struct serial *scb)
353 do_serial_close (scb, 1);
357 serial_un_fdopen (struct serial *scb)
359 do_serial_close (scb, 0);
363 serial_readchar (struct serial *scb, int timeout)
367 /* FIXME: cagney/1999-10-11: Don't enable this check until the ASYNC
369 if (0 && serial_is_async_p (scb) && timeout < 0)
370 internal_error (__FILE__, __LINE__,
371 _("serial_readchar: blocking read in async mode"));
373 ch = scb->ops->readchar (scb, timeout);
374 if (serial_logfp != NULL)
376 serial_logchar (serial_logfp, 'r', ch, timeout);
378 /* Make sure that the log file is as up-to-date as possible,
379 in case we are getting ready to dump core or something. */
380 gdb_flush (serial_logfp);
382 if (serial_debug_p (scb))
384 fprintf_unfiltered (gdb_stdlog, "[");
385 serial_logchar (gdb_stdlog, 'r', ch, timeout);
386 fprintf_unfiltered (gdb_stdlog, "]");
387 gdb_flush (gdb_stdlog);
394 serial_write (struct serial *scb, const char *str, int len)
396 if (serial_logfp != NULL)
400 for (count = 0; count < len; count++)
401 serial_logchar (serial_logfp, 'w', str[count] & 0xff, 0);
403 /* Make sure that the log file is as up-to-date as possible,
404 in case we are getting ready to dump core or something. */
405 gdb_flush (serial_logfp);
408 return (scb->ops->write (scb, str, len));
412 serial_printf (struct serial *desc, const char *format,...)
416 va_start (args, format);
418 buf = xstrvprintf (format, args);
419 serial_write (desc, buf, strlen (buf));
426 serial_drain_output (struct serial *scb)
428 return scb->ops->drain_output (scb);
432 serial_flush_output (struct serial *scb)
434 return scb->ops->flush_output (scb);
438 serial_flush_input (struct serial *scb)
440 return scb->ops->flush_input (scb);
444 serial_send_break (struct serial *scb)
446 if (serial_logfp != NULL)
447 serial_logchar (serial_logfp, 'w', SERIAL_BREAK, 0);
449 return (scb->ops->send_break (scb));
453 serial_raw (struct serial *scb)
455 scb->ops->go_raw (scb);
459 serial_get_tty_state (struct serial *scb)
461 return scb->ops->get_tty_state (scb);
465 serial_set_tty_state (struct serial *scb, serial_ttystate ttystate)
467 return scb->ops->set_tty_state (scb, ttystate);
471 serial_print_tty_state (struct serial *scb,
472 serial_ttystate ttystate,
473 struct ui_file *stream)
475 scb->ops->print_tty_state (scb, ttystate, stream);
479 serial_noflush_set_tty_state (struct serial *scb,
480 serial_ttystate new_ttystate,
481 serial_ttystate old_ttystate)
483 return scb->ops->noflush_set_tty_state (scb, new_ttystate, old_ttystate);
487 serial_setbaudrate (struct serial *scb, int rate)
489 return scb->ops->setbaudrate (scb, rate);
493 serial_setstopbits (struct serial *scb, int num)
495 return scb->ops->setstopbits (scb, num);
499 serial_can_async_p (struct serial *scb)
501 return (scb->ops->async != NULL);
505 serial_is_async_p (struct serial *scb)
507 return (scb->ops->async != NULL) && (scb->async_handler != NULL);
511 serial_async (struct serial *scb,
512 serial_event_ftype *handler,
515 /* Only change mode if there is a need. */
516 if ((scb->async_handler == NULL)
517 != (handler == NULL))
518 scb->ops->async (scb, handler != NULL);
519 scb->async_handler = handler;
520 scb->async_context = context;
524 deprecated_serial_fd (struct serial *scb)
526 /* FIXME: should this output a warning that deprecated code is being
530 internal_error (__FILE__, __LINE__,
531 _("serial: FD not valid"));
533 return scb->fd; /* sigh */
537 serial_debug (struct serial *scb, int debug_p)
539 scb->debug_p = debug_p;
543 serial_debug_p (struct serial *scb)
545 return scb->debug_p || global_serial_debug_p;
550 serial_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except)
552 if (scb->ops->wait_handle)
553 scb->ops->wait_handle (scb, read, except);
556 *read = (HANDLE) _get_osfhandle (scb->fd);
563 /* The connect command is #if 0 because I hadn't thought of an elegant
564 way to wait for I/O on two `struct serial *'s simultaneously. Two
565 solutions came to mind:
567 1) Fork, and have have one fork handle the to user direction,
568 and have the other hand the to target direction. This
569 obviously won't cut it for MSDOS.
571 2) Use something like select. This assumes that stdin and
572 the target side can both be waited on via the same
573 mechanism. This may not be true for DOS, if GDB is
574 talking to the target via a TCP socket.
575 -grossman, 8 Jun 93 */
577 /* Connect the user directly to the remote system. This command acts just like
578 the 'cu' or 'tip' command. Use <CR>~. or <CR>~^D to break out. */
580 static struct serial *tty_desc; /* Controlling terminal */
583 cleanup_tty (serial_ttystate ttystate)
585 printf_unfiltered ("\r\n[Exiting connect mode]\r\n");
586 serial_set_tty_state (tty_desc, ttystate);
588 serial_close (tty_desc);
592 connect_command (char *args, int fromtty)
596 serial_ttystate ttystate;
597 struct serial *port_desc; /* TTY port */
602 fprintf_unfiltered (gdb_stderr, "This command takes no args. They have been ignored.\n");
604 printf_unfiltered ("[Entering connect mode. Use ~. or ~^D to escape]\n");
606 tty_desc = serial_fdopen (0);
607 port_desc = last_serial_opened;
609 ttystate = serial_get_tty_state (tty_desc);
611 serial_raw (tty_desc);
612 serial_raw (port_desc);
614 make_cleanup (cleanup_tty, ttystate);
620 mask = serial_wait_2 (tty_desc, port_desc, -1);
628 c = serial_readchar (tty_desc, 0);
630 if (c == SERIAL_TIMEOUT)
634 perror_with_name (_("connect"));
637 serial_write (port_desc, &cx, 1);
652 if (c == '.' || c == '\004')
666 c = serial_readchar (port_desc, 0);
668 if (c == SERIAL_TIMEOUT)
672 perror_with_name (_("connect"));
676 serial_write (tty_desc, &cx, 1);
683 /* Serial set/show framework. */
685 static struct cmd_list_element *serial_set_cmdlist;
686 static struct cmd_list_element *serial_show_cmdlist;
689 serial_set_cmd (char *args, int from_tty)
691 printf_unfiltered ("\"set serial\" must be followed by the name of a command.\n");
692 help_list (serial_set_cmdlist, "set serial ", -1, gdb_stdout);
696 serial_show_cmd (char *args, int from_tty)
698 cmd_show_list (serial_show_cmdlist, from_tty, "");
703 _initialize_serial (void)
706 add_com ("connect", class_obscure, connect_command, _("\
707 Connect the terminal directly up to the command monitor.\n\
708 Use <CR>~. or <CR>~^D to break out."));
711 add_prefix_cmd ("serial", class_maintenance, serial_set_cmd, _("\
712 Set default serial/parallel port configuration."),
713 &serial_set_cmdlist, "set serial ",
717 add_prefix_cmd ("serial", class_maintenance, serial_show_cmd, _("\
718 Show default serial/parallel port configuration."),
719 &serial_show_cmdlist, "show serial ",
723 add_setshow_filename_cmd ("remotelogfile", no_class, &serial_logfile, _("\
724 Set filename for remote session recording."), _("\
725 Show filename for remote session recording."), _("\
726 This file is used to record the remote session for future playback\n\
729 NULL, /* FIXME: i18n: */
730 &setlist, &showlist);
732 add_setshow_enum_cmd ("remotelogbase", no_class, logbase_enums,
733 &serial_logbase, _("\
734 Set numerical base for remote session logging"), _("\
735 Show numerical base for remote session logging"), NULL,
737 NULL, /* FIXME: i18n: */
738 &setlist, &showlist);
740 add_setshow_zinteger_cmd ("serial", class_maintenance,
741 &global_serial_debug_p, _("\
742 Set serial debugging."), _("\
743 Show serial debugging."), _("\
744 When non-zero, serial port debugging is enabled."),
746 NULL, /* FIXME: i18n: */
747 &setdebuglist, &showdebuglist);