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 /* Discard ``|'' and any space before the command itself. */
194 while (isspace (*open_name))
197 /* Check for a colon, suggesting an IP address/port pair.
198 Do this *after* checking for all the interesting prefixes. We
199 don't want to constrain the syntax of what can follow them. */
200 else if (strchr (name, ':'))
201 ops = serial_interface_lookup ("tcp");
203 ops = serial_interface_lookup ("hardwire");
208 scb = XMALLOC (struct serial);
213 scb->bufp = scb->buf;
215 if (scb->ops->open (scb, open_name))
221 scb->name = xstrdup (name);
222 scb->next = scb_base;
225 scb->async_state = 0;
226 scb->async_handler = NULL;
227 scb->async_context = NULL;
230 last_serial_opened = scb;
232 if (serial_logfile != NULL)
234 serial_logfp = gdb_fopen (serial_logfile, "w");
235 if (serial_logfp == NULL)
236 perror_with_name (serial_logfile);
242 /* Return the open serial device for FD, if found, or NULL if FD
243 is not already opened. */
246 serial_for_fd (int fd)
249 struct serial_ops *ops;
251 for (scb = scb_base; scb; scb = scb->next)
259 serial_fdopen (const int fd)
262 struct serial_ops *ops;
264 for (scb = scb_base; scb; scb = scb->next)
271 ops = serial_interface_lookup ("terminal");
273 ops = serial_interface_lookup ("hardwire");
278 scb = XCALLOC (1, struct serial);
283 scb->bufp = scb->buf;
288 scb->next = scb_base;
291 scb->async_state = 0;
292 scb->async_handler = NULL;
293 scb->async_context = NULL;
296 last_serial_opened = scb;
302 do_serial_close (struct serial *scb, int really_close)
304 struct serial *tmp_scb;
306 last_serial_opened = NULL;
310 fputs_unfiltered ("\nEnd of log\n", serial_logfp);
311 serial_current_type = 0;
313 /* XXX - What if serial_logfp == gdb_stdout or gdb_stderr? */
314 ui_file_delete (serial_logfp);
318 /* This is bogus. It's not our fault if you pass us a bad scb...! Rob, you
319 should fix your code instead. */
328 /* ensure that the FD has been taken out of async mode */
329 if (scb->async_handler != NULL)
330 serial_async (scb, NULL, NULL);
333 scb->ops->close (scb);
339 scb_base = scb_base->next;
341 for (tmp_scb = scb_base; tmp_scb; tmp_scb = tmp_scb->next)
343 if (tmp_scb->next != scb)
346 tmp_scb->next = tmp_scb->next->next;
354 serial_close (struct serial *scb)
356 do_serial_close (scb, 1);
360 serial_un_fdopen (struct serial *scb)
362 do_serial_close (scb, 0);
366 serial_readchar (struct serial *scb, int timeout)
370 /* FIXME: cagney/1999-10-11: Don't enable this check until the ASYNC
372 if (0 && serial_is_async_p (scb) && timeout < 0)
373 internal_error (__FILE__, __LINE__,
374 _("serial_readchar: blocking read in async mode"));
376 ch = scb->ops->readchar (scb, timeout);
377 if (serial_logfp != NULL)
379 serial_logchar (serial_logfp, 'r', ch, timeout);
381 /* Make sure that the log file is as up-to-date as possible,
382 in case we are getting ready to dump core or something. */
383 gdb_flush (serial_logfp);
385 if (serial_debug_p (scb))
387 fprintf_unfiltered (gdb_stdlog, "[");
388 serial_logchar (gdb_stdlog, 'r', ch, timeout);
389 fprintf_unfiltered (gdb_stdlog, "]");
390 gdb_flush (gdb_stdlog);
397 serial_write (struct serial *scb, const char *str, int len)
399 if (serial_logfp != NULL)
403 for (count = 0; count < len; count++)
404 serial_logchar (serial_logfp, 'w', str[count] & 0xff, 0);
406 /* Make sure that the log file is as up-to-date as possible,
407 in case we are getting ready to dump core or something. */
408 gdb_flush (serial_logfp);
411 return (scb->ops->write (scb, str, len));
415 serial_printf (struct serial *desc, const char *format,...)
419 va_start (args, format);
421 buf = xstrvprintf (format, args);
422 serial_write (desc, buf, strlen (buf));
429 serial_drain_output (struct serial *scb)
431 return scb->ops->drain_output (scb);
435 serial_flush_output (struct serial *scb)
437 return scb->ops->flush_output (scb);
441 serial_flush_input (struct serial *scb)
443 return scb->ops->flush_input (scb);
447 serial_send_break (struct serial *scb)
449 if (serial_logfp != NULL)
450 serial_logchar (serial_logfp, 'w', SERIAL_BREAK, 0);
452 return (scb->ops->send_break (scb));
456 serial_raw (struct serial *scb)
458 scb->ops->go_raw (scb);
462 serial_get_tty_state (struct serial *scb)
464 return scb->ops->get_tty_state (scb);
468 serial_set_tty_state (struct serial *scb, serial_ttystate ttystate)
470 return scb->ops->set_tty_state (scb, ttystate);
474 serial_print_tty_state (struct serial *scb,
475 serial_ttystate ttystate,
476 struct ui_file *stream)
478 scb->ops->print_tty_state (scb, ttystate, stream);
482 serial_noflush_set_tty_state (struct serial *scb,
483 serial_ttystate new_ttystate,
484 serial_ttystate old_ttystate)
486 return scb->ops->noflush_set_tty_state (scb, new_ttystate, old_ttystate);
490 serial_setbaudrate (struct serial *scb, int rate)
492 return scb->ops->setbaudrate (scb, rate);
496 serial_setstopbits (struct serial *scb, int num)
498 return scb->ops->setstopbits (scb, num);
502 serial_can_async_p (struct serial *scb)
504 return (scb->ops->async != NULL);
508 serial_is_async_p (struct serial *scb)
510 return (scb->ops->async != NULL) && (scb->async_handler != NULL);
514 serial_async (struct serial *scb,
515 serial_event_ftype *handler,
518 /* Only change mode if there is a need. */
519 if ((scb->async_handler == NULL)
520 != (handler == NULL))
521 scb->ops->async (scb, handler != NULL);
522 scb->async_handler = handler;
523 scb->async_context = context;
527 deprecated_serial_fd (struct serial *scb)
529 /* FIXME: should this output a warning that deprecated code is being
533 internal_error (__FILE__, __LINE__,
534 _("serial: FD not valid"));
536 return scb->fd; /* sigh */
540 serial_debug (struct serial *scb, int debug_p)
542 scb->debug_p = debug_p;
546 serial_debug_p (struct serial *scb)
548 return scb->debug_p || global_serial_debug_p;
553 serial_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except)
555 if (scb->ops->wait_handle)
556 scb->ops->wait_handle (scb, read, except);
559 *read = (HANDLE) _get_osfhandle (scb->fd);
565 serial_done_wait_handle (struct serial *scb)
567 if (scb->ops->done_wait_handle)
568 scb->ops->done_wait_handle (scb);
573 /* The connect command is #if 0 because I hadn't thought of an elegant
574 way to wait for I/O on two `struct serial *'s simultaneously. Two
575 solutions came to mind:
577 1) Fork, and have have one fork handle the to user direction,
578 and have the other hand the to target direction. This
579 obviously won't cut it for MSDOS.
581 2) Use something like select. This assumes that stdin and
582 the target side can both be waited on via the same
583 mechanism. This may not be true for DOS, if GDB is
584 talking to the target via a TCP socket.
585 -grossman, 8 Jun 93 */
587 /* Connect the user directly to the remote system. This command acts just like
588 the 'cu' or 'tip' command. Use <CR>~. or <CR>~^D to break out. */
590 static struct serial *tty_desc; /* Controlling terminal */
593 cleanup_tty (serial_ttystate ttystate)
595 printf_unfiltered ("\r\n[Exiting connect mode]\r\n");
596 serial_set_tty_state (tty_desc, ttystate);
598 serial_close (tty_desc);
602 connect_command (char *args, int fromtty)
606 serial_ttystate ttystate;
607 struct serial *port_desc; /* TTY port */
612 fprintf_unfiltered (gdb_stderr, "This command takes no args. They have been ignored.\n");
614 printf_unfiltered ("[Entering connect mode. Use ~. or ~^D to escape]\n");
616 tty_desc = serial_fdopen (0);
617 port_desc = last_serial_opened;
619 ttystate = serial_get_tty_state (tty_desc);
621 serial_raw (tty_desc);
622 serial_raw (port_desc);
624 make_cleanup (cleanup_tty, ttystate);
630 mask = serial_wait_2 (tty_desc, port_desc, -1);
638 c = serial_readchar (tty_desc, 0);
640 if (c == SERIAL_TIMEOUT)
644 perror_with_name (_("connect"));
647 serial_write (port_desc, &cx, 1);
662 if (c == '.' || c == '\004')
676 c = serial_readchar (port_desc, 0);
678 if (c == SERIAL_TIMEOUT)
682 perror_with_name (_("connect"));
686 serial_write (tty_desc, &cx, 1);
693 /* Serial set/show framework. */
695 static struct cmd_list_element *serial_set_cmdlist;
696 static struct cmd_list_element *serial_show_cmdlist;
699 serial_set_cmd (char *args, int from_tty)
701 printf_unfiltered ("\"set serial\" must be followed by the name of a command.\n");
702 help_list (serial_set_cmdlist, "set serial ", -1, gdb_stdout);
706 serial_show_cmd (char *args, int from_tty)
708 cmd_show_list (serial_show_cmdlist, from_tty, "");
713 _initialize_serial (void)
716 add_com ("connect", class_obscure, connect_command, _("\
717 Connect the terminal directly up to the command monitor.\n\
718 Use <CR>~. or <CR>~^D to break out."));
721 add_prefix_cmd ("serial", class_maintenance, serial_set_cmd, _("\
722 Set default serial/parallel port configuration."),
723 &serial_set_cmdlist, "set serial ",
727 add_prefix_cmd ("serial", class_maintenance, serial_show_cmd, _("\
728 Show default serial/parallel port configuration."),
729 &serial_show_cmdlist, "show serial ",
733 add_setshow_filename_cmd ("remotelogfile", no_class, &serial_logfile, _("\
734 Set filename for remote session recording."), _("\
735 Show filename for remote session recording."), _("\
736 This file is used to record the remote session for future playback\n\
739 NULL, /* FIXME: i18n: */
740 &setlist, &showlist);
742 add_setshow_enum_cmd ("remotelogbase", no_class, logbase_enums,
743 &serial_logbase, _("\
744 Set numerical base for remote session logging"), _("\
745 Show numerical base for remote session logging"), NULL,
747 NULL, /* FIXME: i18n: */
748 &setlist, &showlist);
750 add_setshow_zinteger_cmd ("serial", class_maintenance,
751 &global_serial_debug_p, _("\
752 Set serial debugging."), _("\
753 Show serial debugging."), _("\
754 When non-zero, serial port debugging is enabled."),
756 NULL, /* FIXME: i18n: */
757 &setdebuglist, &showdebuglist);