1 /* Generic serial interface routines
3 Copyright (C) 1992-2002, 2004-2012 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "gdb_string.h"
26 extern void _initialize_serial (void);
28 /* Is serial being debugged? */
30 static int global_serial_debug_p;
32 /* Linked list of serial I/O handlers. */
34 static struct serial_ops *serial_ops_list = NULL;
36 /* Non-NULL gives filename which contains a recording of the remote session,
37 suitable for playback by gdbserver. */
39 static char *serial_logfile = NULL;
40 static struct ui_file *serial_logfp = NULL;
42 static struct serial_ops *serial_interface_lookup (const char *);
43 static void serial_logchar (struct ui_file *stream,
44 int ch_type, int ch, int timeout);
45 static const char logbase_hex[] = "hex";
46 static const char logbase_octal[] = "octal";
47 static const char logbase_ascii[] = "ascii";
48 static const char *const logbase_enums[] =
49 {logbase_hex, logbase_octal, logbase_ascii, NULL};
50 static const char *serial_logbase = logbase_ascii;
53 static int serial_current_type = 0;
55 /* Log char CH of type CHTYPE, with TIMEOUT. */
57 /* Define bogus char to represent a BREAK. Should be careful to choose a value
58 that can't be confused with a normal char, or an error code. */
59 #define SERIAL_BREAK 1235
62 serial_logchar (struct ui_file *stream, int ch_type, int ch, int timeout)
64 if (ch_type != serial_current_type)
66 fprintf_unfiltered (stream, "\n%c ", ch_type);
67 serial_current_type = ch_type;
70 if (serial_logbase != logbase_ascii)
71 fputc_unfiltered (' ', stream);
76 fprintf_unfiltered (stream, "<Timeout: %d seconds>", timeout);
79 fprintf_unfiltered (stream, "<Error: %s>", safe_strerror (errno));
82 fputs_unfiltered ("<Eof>", stream);
85 fputs_unfiltered ("<Break>", stream);
88 if (serial_logbase == logbase_hex)
89 fprintf_unfiltered (stream, "%02x", ch & 0xff);
90 else if (serial_logbase == logbase_octal)
91 fprintf_unfiltered (stream, "%03o", ch & 0xff);
96 fputs_unfiltered ("\\\\", stream);
99 fputs_unfiltered ("\\b", stream);
102 fputs_unfiltered ("\\f", stream);
105 fputs_unfiltered ("\\n", stream);
108 fputs_unfiltered ("\\r", stream);
111 fputs_unfiltered ("\\t", stream);
114 fputs_unfiltered ("\\v", stream);
117 fprintf_unfiltered (stream,
118 isprint (ch) ? "%c" : "\\x%02x", ch & 0xFF);
125 serial_log_command (const char *cmd)
130 serial_current_type = 'c';
132 fputs_unfiltered ("\nc ", serial_logfp);
133 fputs_unfiltered (cmd, serial_logfp);
135 /* Make sure that the log file is as up-to-date as possible,
136 in case we are getting ready to dump core or something. */
137 gdb_flush (serial_logfp);
141 static struct serial_ops *
142 serial_interface_lookup (const char *name)
144 struct serial_ops *ops;
146 for (ops = serial_ops_list; ops; ops = ops->next)
147 if (strcmp (name, ops->name) == 0)
154 serial_add_interface (struct serial_ops *optable)
156 optable->next = serial_ops_list;
157 serial_ops_list = optable;
160 /* Open up a device or a network socket, depending upon the syntax of NAME. */
163 serial_open (const char *name)
166 struct serial_ops *ops;
167 const char *open_name = name;
169 if (strcmp (name, "pc") == 0)
170 ops = serial_interface_lookup ("pc");
171 else if (strncmp (name, "lpt", 3) == 0)
172 ops = serial_interface_lookup ("parallel");
173 else if (strncmp (name, "|", 1) == 0)
175 ops = serial_interface_lookup ("pipe");
176 /* Discard ``|'' and any space before the command itself. */
178 while (isspace (*open_name))
181 /* Check for a colon, suggesting an IP address/port pair.
182 Do this *after* checking for all the interesting prefixes. We
183 don't want to constrain the syntax of what can follow them. */
184 else if (strchr (name, ':'))
185 ops = serial_interface_lookup ("tcp");
187 ops = serial_interface_lookup ("hardwire");
192 scb = XMALLOC (struct serial);
197 scb->bufp = scb->buf;
200 /* `...->open (...)' would get expanded by the open(2) syscall macro. */
201 if ((*scb->ops->open) (scb, open_name))
207 scb->name = xstrdup (name);
209 scb->async_state = 0;
210 scb->async_handler = NULL;
211 scb->async_context = NULL;
213 if (serial_logfile != NULL)
215 serial_logfp = gdb_fopen (serial_logfile, "w");
216 if (serial_logfp == NULL)
217 perror_with_name (serial_logfile);
223 /* Open a new serial stream using a file handle, using serial
224 interface ops OPS. */
226 static struct serial *
227 serial_fdopen_ops (const int fd, struct serial_ops *ops)
233 ops = serial_interface_lookup ("terminal");
235 ops = serial_interface_lookup ("hardwire");
241 scb = XCALLOC (1, struct serial);
246 scb->bufp = scb->buf;
251 scb->async_state = 0;
252 scb->async_handler = NULL;
253 scb->async_context = NULL;
255 if ((ops->fdopen) != NULL)
256 (*ops->fdopen) (scb, fd);
264 serial_fdopen (const int fd)
266 return serial_fdopen_ops (fd, NULL);
270 do_serial_close (struct serial *scb, int really_close)
272 struct serial *tmp_scb;
276 fputs_unfiltered ("\nEnd of log\n", serial_logfp);
277 serial_current_type = 0;
279 /* XXX - What if serial_logfp == gdb_stdout or gdb_stderr? */
280 ui_file_delete (serial_logfp);
284 /* ensure that the FD has been taken out of async mode. */
285 if (scb->async_handler != NULL)
286 serial_async (scb, NULL, NULL);
289 scb->ops->close (scb);
298 serial_close (struct serial *scb)
300 do_serial_close (scb, 1);
304 serial_un_fdopen (struct serial *scb)
306 do_serial_close (scb, 0);
310 serial_readchar (struct serial *scb, int timeout)
314 /* FIXME: cagney/1999-10-11: Don't enable this check until the ASYNC
316 if (0 && serial_is_async_p (scb) && timeout < 0)
317 internal_error (__FILE__, __LINE__,
318 _("serial_readchar: blocking read in async mode"));
320 ch = scb->ops->readchar (scb, timeout);
321 if (serial_logfp != NULL)
323 serial_logchar (serial_logfp, 'r', ch, timeout);
325 /* Make sure that the log file is as up-to-date as possible,
326 in case we are getting ready to dump core or something. */
327 gdb_flush (serial_logfp);
329 if (serial_debug_p (scb))
331 fprintf_unfiltered (gdb_stdlog, "[");
332 serial_logchar (gdb_stdlog, 'r', ch, timeout);
333 fprintf_unfiltered (gdb_stdlog, "]");
334 gdb_flush (gdb_stdlog);
341 serial_write (struct serial *scb, const char *str, int len)
343 if (serial_logfp != NULL)
347 for (count = 0; count < len; count++)
348 serial_logchar (serial_logfp, 'w', str[count] & 0xff, 0);
350 /* Make sure that the log file is as up-to-date as possible,
351 in case we are getting ready to dump core or something. */
352 gdb_flush (serial_logfp);
354 if (serial_debug_p (scb))
358 for (count = 0; count < len; count++)
360 fprintf_unfiltered (gdb_stdlog, "[");
361 serial_logchar (gdb_stdlog, 'w', str[count] & 0xff, 0);
362 fprintf_unfiltered (gdb_stdlog, "]");
364 gdb_flush (gdb_stdlog);
367 return (scb->ops->write (scb, str, len));
371 serial_printf (struct serial *desc, const char *format,...)
375 va_start (args, format);
377 buf = xstrvprintf (format, args);
378 serial_write (desc, buf, strlen (buf));
385 serial_drain_output (struct serial *scb)
387 return scb->ops->drain_output (scb);
391 serial_flush_output (struct serial *scb)
393 return scb->ops->flush_output (scb);
397 serial_flush_input (struct serial *scb)
399 return scb->ops->flush_input (scb);
403 serial_send_break (struct serial *scb)
405 if (serial_logfp != NULL)
406 serial_logchar (serial_logfp, 'w', SERIAL_BREAK, 0);
408 return (scb->ops->send_break (scb));
412 serial_raw (struct serial *scb)
414 scb->ops->go_raw (scb);
418 serial_get_tty_state (struct serial *scb)
420 return scb->ops->get_tty_state (scb);
424 serial_copy_tty_state (struct serial *scb, serial_ttystate ttystate)
426 return scb->ops->copy_tty_state (scb, ttystate);
430 serial_set_tty_state (struct serial *scb, serial_ttystate ttystate)
432 return scb->ops->set_tty_state (scb, ttystate);
436 serial_print_tty_state (struct serial *scb,
437 serial_ttystate ttystate,
438 struct ui_file *stream)
440 scb->ops->print_tty_state (scb, ttystate, stream);
444 serial_noflush_set_tty_state (struct serial *scb,
445 serial_ttystate new_ttystate,
446 serial_ttystate old_ttystate)
448 return scb->ops->noflush_set_tty_state (scb, new_ttystate, old_ttystate);
452 serial_setbaudrate (struct serial *scb, int rate)
454 return scb->ops->setbaudrate (scb, rate);
458 serial_setstopbits (struct serial *scb, int num)
460 return scb->ops->setstopbits (scb, num);
464 serial_can_async_p (struct serial *scb)
466 return (scb->ops->async != NULL);
470 serial_is_async_p (struct serial *scb)
472 return (scb->ops->async != NULL) && (scb->async_handler != NULL);
476 serial_async (struct serial *scb,
477 serial_event_ftype *handler,
480 int changed = ((scb->async_handler == NULL) != (handler == NULL));
482 scb->async_handler = handler;
483 scb->async_context = context;
484 /* Only change mode if there is a need. */
486 scb->ops->async (scb, handler != NULL);
490 deprecated_serial_fd (struct serial *scb)
492 /* FIXME: should this output a warning that deprecated code is being
496 internal_error (__FILE__, __LINE__,
497 _("serial: FD not valid"));
499 return scb->fd; /* sigh */
503 serial_debug (struct serial *scb, int debug_p)
505 scb->debug_p = debug_p;
509 serial_debug_p (struct serial *scb)
511 return scb->debug_p || global_serial_debug_p;
516 serial_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except)
518 if (scb->ops->wait_handle)
519 scb->ops->wait_handle (scb, read, except);
522 *read = (HANDLE) _get_osfhandle (scb->fd);
528 serial_done_wait_handle (struct serial *scb)
530 if (scb->ops->done_wait_handle)
531 scb->ops->done_wait_handle (scb);
536 serial_pipe (struct serial *scbs[2])
538 struct serial_ops *ops;
541 ops = serial_interface_lookup ("pipe");
548 if (gdb_pipe (fildes) == -1)
551 scbs[0] = serial_fdopen_ops (fildes[0], ops);
552 scbs[1] = serial_fdopen_ops (fildes[1], ops);
556 /* Serial set/show framework. */
558 static struct cmd_list_element *serial_set_cmdlist;
559 static struct cmd_list_element *serial_show_cmdlist;
562 serial_set_cmd (char *args, int from_tty)
564 printf_unfiltered ("\"set serial\" must be followed "
565 "by the name of a command.\n");
566 help_list (serial_set_cmdlist, "set serial ", -1, gdb_stdout);
570 serial_show_cmd (char *args, int from_tty)
572 cmd_show_list (serial_show_cmdlist, from_tty, "");
577 _initialize_serial (void)
580 add_com ("connect", class_obscure, connect_command, _("\
581 Connect the terminal directly up to the command monitor.\n\
582 Use <CR>~. or <CR>~^D to break out."));
585 add_prefix_cmd ("serial", class_maintenance, serial_set_cmd, _("\
586 Set default serial/parallel port configuration."),
587 &serial_set_cmdlist, "set serial ",
591 add_prefix_cmd ("serial", class_maintenance, serial_show_cmd, _("\
592 Show default serial/parallel port configuration."),
593 &serial_show_cmdlist, "show serial ",
597 add_setshow_filename_cmd ("remotelogfile", no_class, &serial_logfile, _("\
598 Set filename for remote session recording."), _("\
599 Show filename for remote session recording."), _("\
600 This file is used to record the remote session for future playback\n\
603 NULL, /* FIXME: i18n: */
604 &setlist, &showlist);
606 add_setshow_enum_cmd ("remotelogbase", no_class, logbase_enums,
607 &serial_logbase, _("\
608 Set numerical base for remote session logging"), _("\
609 Show numerical base for remote session logging"), NULL,
611 NULL, /* FIXME: i18n: */
612 &setlist, &showlist);
614 add_setshow_zinteger_cmd ("serial", class_maintenance,
615 &global_serial_debug_p, _("\
616 Set serial debugging."), _("\
617 Show serial debugging."), _("\
618 When non-zero, serial port debugging is enabled."),
620 NULL, /* FIXME: i18n: */
621 &setdebuglist, &showdebuglist);