1 /* Generic serial interface routines
3 Copyright 1992, 1993, 1996, 1997, 1999, 2000, 2001 Free Software
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 serial_t last_serial_opened = NULL;
43 /* Pointer to list of scb's. */
45 static serial_t 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;
64 static int serial_current_type = 0;
66 /* Log char CH of type CHTYPE, with TIMEOUT */
68 /* Define bogus char to represent a BREAK. Should be careful to choose a value
69 that can't be confused with a normal char, or an error code. */
70 #define SERIAL_BREAK 1235
73 serial_logchar (struct ui_file *stream, int ch_type, int ch, int timeout)
75 if (ch_type != serial_current_type)
77 fprintf_unfiltered (stream, "\n%c ", ch_type);
78 serial_current_type = ch_type;
81 if (serial_logbase != logbase_ascii)
82 fputc_unfiltered (' ', stream);
87 fprintf_unfiltered (stream, "<Timeout: %d seconds>", timeout);
90 fprintf_unfiltered (stream, "<Error: %s>", safe_strerror (errno));
93 fputs_unfiltered ("<Eof>", stream);
96 fputs_unfiltered ("<Break>", stream);
99 if (serial_logbase == logbase_hex)
100 fprintf_unfiltered (stream, "%02x", ch & 0xff);
101 else if (serial_logbase == logbase_octal)
102 fprintf_unfiltered (stream, "%03o", ch & 0xff);
107 fputs_unfiltered ("\\\\", stream);
110 fputs_unfiltered ("\\b", stream);
113 fputs_unfiltered ("\\f", stream);
116 fputs_unfiltered ("\\n", stream);
119 fputs_unfiltered ("\\r", stream);
122 fputs_unfiltered ("\\t", stream);
125 fputs_unfiltered ("\\v", stream);
128 fprintf_unfiltered (stream, isprint (ch) ? "%c" : "\\x%02x", ch & 0xFF);
135 serial_log_command (const char *cmd)
140 serial_current_type = 'c';
142 fputs_unfiltered ("\nc ", serial_logfp);
143 fputs_unfiltered (cmd, serial_logfp);
145 /* Make sure that the log file is as up-to-date as possible,
146 in case we are getting ready to dump core or something. */
147 gdb_flush (serial_logfp);
151 static struct serial_ops *
152 serial_interface_lookup (char *name)
154 struct serial_ops *ops;
156 for (ops = serial_ops_list; ops; ops = ops->next)
157 if (strcmp (name, ops->name) == 0)
164 serial_add_interface (struct serial_ops *optable)
166 optable->next = serial_ops_list;
167 serial_ops_list = optable;
170 /* Open up a device or a network socket, depending upon the syntax of NAME. */
173 serial_open (const char *name)
176 struct serial_ops *ops;
177 const char *open_name = name;
179 for (scb = scb_base; scb; scb = scb->next)
180 if (scb->name && strcmp (scb->name, name) == 0)
186 if (strcmp (name, "ocd") == 0)
187 ops = serial_interface_lookup ("ocd");
188 else 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 = (serial_t) xmalloc (sizeof (struct _serial_t));
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 = (serial_t) xmalloc (sizeof (struct _serial_t));
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 (serial_t scb, int really_close)
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 (serial_t scb)
335 do_serial_close (scb, 1);
339 serial_un_fdopen (serial_t scb)
341 do_serial_close (scb, 0);
345 serial_readchar (serial_t 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 ("serial_readchar: blocking read in async mode");
354 ch = scb->ops->readchar (scb, timeout);
355 if (serial_logfp != NULL)
357 serial_logchar (serial_logfp, 'r', ch, timeout);
359 /* Make sure that the log file is as up-to-date as possible,
360 in case we are getting ready to dump core or something. */
361 gdb_flush (serial_logfp);
363 if (SERIAL_DEBUG_P (scb))
365 fprintf_unfiltered (gdb_stdlog, "[");
366 serial_logchar (gdb_stdlog, 'r', ch, timeout);
367 fprintf_unfiltered (gdb_stdlog, "]");
368 gdb_flush (gdb_stdlog);
375 serial_write (serial_t scb, const char *str, int len)
377 if (serial_logfp != NULL)
381 for (count = 0; count < len; count++)
382 serial_logchar (serial_logfp, 'w', str[count] & 0xff, 0);
384 /* Make sure that the log file is as up-to-date as possible,
385 in case we are getting ready to dump core or something. */
386 gdb_flush (serial_logfp);
389 return (scb->ops->write (scb, str, len));
393 serial_printf (serial_t desc, const char *format,...)
397 va_start (args, format);
399 xvasprintf (&buf, format, args);
400 SERIAL_WRITE (desc, buf, strlen (buf));
407 serial_drain_output (serial_t scb)
409 return scb->ops->drain_output (scb);
413 serial_flush_output (serial_t scb)
415 return scb->ops->flush_output (scb);
419 serial_flush_input (serial_t scb)
421 return scb->ops->flush_input (scb);
425 serial_send_break (serial_t scb)
427 if (serial_logfp != NULL)
428 serial_logchar (serial_logfp, 'w', SERIAL_BREAK, 0);
430 return (scb->ops->send_break (scb));
434 serial_raw (serial_t scb)
436 scb->ops->go_raw (scb);
440 serial_get_tty_state (serial_t scb)
442 return scb->ops->get_tty_state (scb);
446 serial_set_tty_state (serial_t scb, serial_ttystate ttystate)
448 return scb->ops->set_tty_state (scb, ttystate);
452 serial_print_tty_state (serial_t scb,
453 serial_ttystate ttystate,
454 struct ui_file *stream)
456 scb->ops->print_tty_state (scb, ttystate, stream);
460 serial_noflush_set_tty_state (serial_t scb,
461 serial_ttystate new_ttystate,
462 serial_ttystate old_ttystate)
464 return scb->ops->noflush_set_tty_state (scb, new_ttystate, old_ttystate);
468 serial_setbaudrate (serial_t scb, int rate)
470 return scb->ops->setbaudrate (scb, rate);
474 serial_setstopbits (serial_t scb, int num)
476 return scb->ops->setstopbits (scb, num);
480 serial_can_async_p (serial_t scb)
482 return (scb->ops->async != NULL);
486 serial_is_async_p (serial_t scb)
488 return (scb->ops->async != NULL) && (scb->async_handler != NULL);
492 serial_async (serial_t scb,
493 serial_event_ftype *handler,
496 /* Only change mode if there is a need. */
497 if ((scb->async_handler == NULL)
498 != (handler == NULL))
499 scb->ops->async (scb, handler != NULL);
500 scb->async_handler = handler;
501 scb->async_context = context;
505 deprecated_serial_fd (serial_t scb)
507 /* FIXME: should this output a warning that deprecated code is being
511 internal_error ("serial: FD not valid");
513 return scb->fd; /* sigh */
517 serial_debug (serial_t scb, int debug_p)
519 scb->debug_p = debug_p;
523 serial_debug_p (serial_t scb)
525 return scb->debug_p || global_serial_debug_p;
531 The connect command is #if 0 because I hadn't thought of an elegant
532 way to wait for I/O on two serial_t's simultaneously. Two solutions
535 1) Fork, and have have one fork handle the to user direction,
536 and have the other hand the to target direction. This
537 obviously won't cut it for MSDOS.
539 2) Use something like select. This assumes that stdin and
540 the target side can both be waited on via the same
541 mechanism. This may not be true for DOS, if GDB is
542 talking to the target via a TCP socket.
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 serial_t 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 serial_t 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);
653 _initialize_serial (void)
656 add_com ("connect", class_obscure, connect_command,
657 "Connect the terminal directly up to the command monitor.\n\
658 Use <CR>~. or <CR>~^D to break out.");
662 (add_set_cmd ("remotelogfile", no_class,
663 var_filename, (char *) &serial_logfile,
664 "Set filename for remote session recording.\n\
665 This file is used to record the remote session for future playback\n\
671 (add_set_enum_cmd ("remotelogbase", no_class,
672 logbase_enums, &serial_logbase,
673 "Set numerical base for remote session logging",
677 add_show_from_set (add_set_cmd ("serial",
680 (char *)&global_serial_debug_p,
681 "Set serial debugging.\n\
682 When non-zero, serial port debugging is enabled.", &setdebuglist),