1 /* Generic serial interface routines
3 Copyright 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
4 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., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, 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 #define XMALLOC(TYPE) ((TYPE*) xmalloc (sizeof (TYPE)))
66 static int serial_current_type = 0;
68 /* Log char CH of type CHTYPE, with TIMEOUT */
70 /* Define bogus char to represent a BREAK. Should be careful to choose a value
71 that can't be confused with a normal char, or an error code. */
72 #define SERIAL_BREAK 1235
75 serial_logchar (struct ui_file *stream, int ch_type, int ch, int timeout)
77 if (ch_type != serial_current_type)
79 fprintf_unfiltered (stream, "\n%c ", ch_type);
80 serial_current_type = ch_type;
83 if (serial_logbase != logbase_ascii)
84 fputc_unfiltered (' ', stream);
89 fprintf_unfiltered (stream, "<Timeout: %d seconds>", timeout);
92 fprintf_unfiltered (stream, "<Error: %s>", safe_strerror (errno));
95 fputs_unfiltered ("<Eof>", stream);
98 fputs_unfiltered ("<Break>", stream);
101 if (serial_logbase == logbase_hex)
102 fprintf_unfiltered (stream, "%02x", ch & 0xff);
103 else if (serial_logbase == logbase_octal)
104 fprintf_unfiltered (stream, "%03o", ch & 0xff);
109 fputs_unfiltered ("\\\\", stream);
112 fputs_unfiltered ("\\b", stream);
115 fputs_unfiltered ("\\f", stream);
118 fputs_unfiltered ("\\n", stream);
121 fputs_unfiltered ("\\r", stream);
124 fputs_unfiltered ("\\t", stream);
127 fputs_unfiltered ("\\v", stream);
130 fprintf_unfiltered (stream, isprint (ch) ? "%c" : "\\x%02x", ch & 0xFF);
137 serial_log_command (const char *cmd)
142 serial_current_type = 'c';
144 fputs_unfiltered ("\nc ", serial_logfp);
145 fputs_unfiltered (cmd, serial_logfp);
147 /* Make sure that the log file is as up-to-date as possible,
148 in case we are getting ready to dump core or something. */
149 gdb_flush (serial_logfp);
153 static struct serial_ops *
154 serial_interface_lookup (char *name)
156 struct serial_ops *ops;
158 for (ops = serial_ops_list; ops; ops = ops->next)
159 if (strcmp (name, ops->name) == 0)
166 serial_add_interface (struct serial_ops *optable)
168 optable->next = serial_ops_list;
169 serial_ops_list = optable;
172 /* Open up a device or a network socket, depending upon the syntax of NAME. */
175 serial_open (const char *name)
178 struct serial_ops *ops;
179 const char *open_name = name;
181 for (scb = scb_base; scb; scb = scb->next)
182 if (scb->name && strcmp (scb->name, name) == 0)
188 if (strcmp (name, "pc") == 0)
189 ops = serial_interface_lookup ("pc");
190 else if (strchr (name, ':'))
191 ops = serial_interface_lookup ("tcp");
192 else if (strncmp (name, "lpt", 3) == 0)
193 ops = serial_interface_lookup ("parallel");
194 else if (strncmp (name, "|", 1) == 0)
196 ops = serial_interface_lookup ("pipe");
197 open_name = name + 1; /* discard ``|'' */
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);
240 serial_fdopen (const int fd)
243 struct serial_ops *ops;
245 for (scb = scb_base; scb; scb = scb->next)
252 ops = serial_interface_lookup ("hardwire");
257 scb = XMALLOC (struct serial);
262 scb->bufp = scb->buf;
267 scb->next = scb_base;
270 scb->async_state = 0;
271 scb->async_handler = NULL;
272 scb->async_context = NULL;
275 last_serial_opened = scb;
281 do_serial_close (struct serial *scb, int really_close)
283 struct serial *tmp_scb;
285 last_serial_opened = NULL;
289 fputs_unfiltered ("\nEnd of log\n", serial_logfp);
290 serial_current_type = 0;
292 /* XXX - What if serial_logfp == gdb_stdout or gdb_stderr? */
293 ui_file_delete (serial_logfp);
297 /* This is bogus. It's not our fault if you pass us a bad scb...! Rob, you
298 should fix your code instead. */
307 /* ensure that the FD has been taken out of async mode */
308 if (scb->async_handler != NULL)
309 serial_async (scb, NULL, NULL);
312 scb->ops->close (scb);
318 scb_base = scb_base->next;
320 for (tmp_scb = scb_base; tmp_scb; tmp_scb = tmp_scb->next)
322 if (tmp_scb->next != scb)
325 tmp_scb->next = tmp_scb->next->next;
333 serial_close (struct serial *scb)
335 do_serial_close (scb, 1);
339 serial_un_fdopen (struct serial *scb)
341 do_serial_close (scb, 0);
345 serial_readchar (struct serial *scb, int timeout)
349 /* FIXME: cagney/1999-10-11: Don't enable this check until the ASYNC
351 if (0 && serial_is_async_p (scb) && timeout < 0)
352 internal_error (__FILE__, __LINE__,
353 "serial_readchar: blocking read in async mode");
355 ch = scb->ops->readchar (scb, timeout);
356 if (serial_logfp != NULL)
358 serial_logchar (serial_logfp, 'r', ch, timeout);
360 /* Make sure that the log file is as up-to-date as possible,
361 in case we are getting ready to dump core or something. */
362 gdb_flush (serial_logfp);
364 if (serial_debug_p (scb))
366 fprintf_unfiltered (gdb_stdlog, "[");
367 serial_logchar (gdb_stdlog, 'r', ch, timeout);
368 fprintf_unfiltered (gdb_stdlog, "]");
369 gdb_flush (gdb_stdlog);
376 serial_write (struct serial *scb, const char *str, int len)
378 if (serial_logfp != NULL)
382 for (count = 0; count < len; count++)
383 serial_logchar (serial_logfp, 'w', str[count] & 0xff, 0);
385 /* Make sure that the log file is as up-to-date as possible,
386 in case we are getting ready to dump core or something. */
387 gdb_flush (serial_logfp);
390 return (scb->ops->write (scb, str, len));
394 serial_printf (struct serial *desc, const char *format,...)
398 va_start (args, format);
400 xvasprintf (&buf, format, args);
401 serial_write (desc, buf, strlen (buf));
408 serial_drain_output (struct serial *scb)
410 return scb->ops->drain_output (scb);
414 serial_flush_output (struct serial *scb)
416 return scb->ops->flush_output (scb);
420 serial_flush_input (struct serial *scb)
422 return scb->ops->flush_input (scb);
426 serial_send_break (struct serial *scb)
428 if (serial_logfp != NULL)
429 serial_logchar (serial_logfp, 'w', SERIAL_BREAK, 0);
431 return (scb->ops->send_break (scb));
435 serial_raw (struct serial *scb)
437 scb->ops->go_raw (scb);
441 serial_get_tty_state (struct serial *scb)
443 return scb->ops->get_tty_state (scb);
447 serial_set_tty_state (struct serial *scb, serial_ttystate ttystate)
449 return scb->ops->set_tty_state (scb, ttystate);
453 serial_print_tty_state (struct serial *scb,
454 serial_ttystate ttystate,
455 struct ui_file *stream)
457 scb->ops->print_tty_state (scb, ttystate, stream);
461 serial_noflush_set_tty_state (struct serial *scb,
462 serial_ttystate new_ttystate,
463 serial_ttystate old_ttystate)
465 return scb->ops->noflush_set_tty_state (scb, new_ttystate, old_ttystate);
469 serial_setbaudrate (struct serial *scb, int rate)
471 return scb->ops->setbaudrate (scb, rate);
475 serial_setstopbits (struct serial *scb, int num)
477 return scb->ops->setstopbits (scb, num);
481 serial_can_async_p (struct serial *scb)
483 return (scb->ops->async != NULL);
487 serial_is_async_p (struct serial *scb)
489 return (scb->ops->async != NULL) && (scb->async_handler != NULL);
493 serial_async (struct serial *scb,
494 serial_event_ftype *handler,
497 /* Only change mode if there is a need. */
498 if ((scb->async_handler == NULL)
499 != (handler == NULL))
500 scb->ops->async (scb, handler != NULL);
501 scb->async_handler = handler;
502 scb->async_context = context;
506 deprecated_serial_fd (struct serial *scb)
508 /* FIXME: should this output a warning that deprecated code is being
512 internal_error (__FILE__, __LINE__,
513 "serial: FD not valid");
515 return scb->fd; /* sigh */
519 serial_debug (struct serial *scb, int debug_p)
521 scb->debug_p = debug_p;
525 serial_debug_p (struct serial *scb)
527 return scb->debug_p || global_serial_debug_p;
532 /* The connect command is #if 0 because I hadn't thought of an elegant
533 way to wait for I/O on two `struct serial *'s simultaneously. Two
534 solutions came to mind:
536 1) Fork, and have have one fork handle the to user direction,
537 and have the other hand the to target direction. This
538 obviously won't cut it for MSDOS.
540 2) Use something like select. This assumes that stdin and
541 the target side can both be waited on via the same
542 mechanism. This may not be true for DOS, if GDB is
543 talking to the target via a TCP socket.
544 -grossman, 8 Jun 93 */
546 /* Connect the user directly to the remote system. This command acts just like
547 the 'cu' or 'tip' command. Use <CR>~. or <CR>~^D to break out. */
549 static struct serial *tty_desc; /* Controlling terminal */
552 cleanup_tty (serial_ttystate ttystate)
554 printf_unfiltered ("\r\n[Exiting connect mode]\r\n");
555 serial_set_tty_state (tty_desc, ttystate);
557 serial_close (tty_desc);
561 connect_command (char *args, int fromtty)
565 serial_ttystate ttystate;
566 struct serial *port_desc; /* TTY port */
571 fprintf_unfiltered (gdb_stderr, "This command takes no args. They have been ignored.\n");
573 printf_unfiltered ("[Entering connect mode. Use ~. or ~^D to escape]\n");
575 tty_desc = serial_fdopen (0);
576 port_desc = last_serial_opened;
578 ttystate = serial_get_tty_state (tty_desc);
580 serial_raw (tty_desc);
581 serial_raw (port_desc);
583 make_cleanup (cleanup_tty, ttystate);
589 mask = serial_wait_2 (tty_desc, port_desc, -1);
597 c = serial_readchar (tty_desc, 0);
599 if (c == SERIAL_TIMEOUT)
603 perror_with_name ("connect");
606 serial_write (port_desc, &cx, 1);
621 if (c == '.' || c == '\004')
635 c = serial_readchar (port_desc, 0);
637 if (c == SERIAL_TIMEOUT)
641 perror_with_name ("connect");
645 serial_write (tty_desc, &cx, 1);
652 /* Serial set/show framework. */
654 static struct cmd_list_element *serial_set_cmdlist;
655 static struct cmd_list_element *serial_show_cmdlist;
658 serial_set_cmd (char *args, int from_tty)
660 printf_unfiltered ("\"set serial\" must be followed by the name of a command.\n");
661 help_list (serial_set_cmdlist, "set serial ", -1, gdb_stdout);
665 serial_show_cmd (char *args, int from_tty)
667 cmd_show_list (serial_show_cmdlist, from_tty, "");
672 _initialize_serial (void)
675 add_com ("connect", class_obscure, connect_command,
676 "Connect the terminal directly up to the command monitor.\n\
677 Use <CR>~. or <CR>~^D to break out.");
680 add_prefix_cmd ("serial", class_maintenance, serial_set_cmd, "\
681 Set default serial/parallel port configuration.",
682 &serial_set_cmdlist, "set serial ",
686 add_prefix_cmd ("serial", class_maintenance, serial_show_cmd, "\
687 Show default serial/parallel port configuration.",
688 &serial_show_cmdlist, "show serial ",
693 (add_set_cmd ("remotelogfile", no_class,
694 var_filename, (char *) &serial_logfile,
695 "Set filename for remote session recording.\n\
696 This file is used to record the remote session for future playback\n\
702 (add_set_enum_cmd ("remotelogbase", no_class,
703 logbase_enums, &serial_logbase,
704 "Set numerical base for remote session logging",
708 add_show_from_set (add_set_cmd ("serial",
711 (char *)&global_serial_debug_p,
712 "Set serial debugging.\n\
713 When non-zero, serial port debugging is enabled.", &setdebuglist),