1 /* Generic serial interface routines
3 Copyright (C) 1992-2014 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/>. */
25 #include "cli/cli-utils.h"
27 extern void _initialize_serial (void);
29 /* Is serial being debugged? */
31 static unsigned int global_serial_debug_p
;
33 typedef const struct serial_ops
*serial_ops_p
;
34 DEF_VEC_P (serial_ops_p
);
36 /* Serial I/O handlers. */
38 VEC (serial_ops_p
) *serial_ops_list
= NULL
;
40 /* Pointer to list of scb's. */
42 static struct serial
*scb_base
;
44 /* Non-NULL gives filename which contains a recording of the remote session,
45 suitable for playback by gdbserver. */
47 static char *serial_logfile
= NULL
;
48 static struct ui_file
*serial_logfp
= NULL
;
50 static const struct serial_ops
*serial_interface_lookup (const char *);
51 static void serial_logchar (struct ui_file
*stream
,
52 int ch_type
, int ch
, int timeout
);
53 static const char logbase_hex
[] = "hex";
54 static const char logbase_octal
[] = "octal";
55 static const char logbase_ascii
[] = "ascii";
56 static const char *const logbase_enums
[] =
57 {logbase_hex
, logbase_octal
, logbase_ascii
, NULL
};
58 static const char *serial_logbase
= logbase_ascii
;
61 static int serial_current_type
= 0;
63 /* Log char CH of type CHTYPE, with TIMEOUT. */
65 /* Define bogus char to represent a BREAK. Should be careful to choose a value
66 that can't be confused with a normal char, or an error code. */
67 #define SERIAL_BREAK 1235
70 serial_logchar (struct ui_file
*stream
, int ch_type
, int ch
, int timeout
)
72 if (ch_type
!= serial_current_type
)
74 fprintf_unfiltered (stream
, "\n%c ", ch_type
);
75 serial_current_type
= ch_type
;
78 if (serial_logbase
!= logbase_ascii
)
79 fputc_unfiltered (' ', stream
);
84 fprintf_unfiltered (stream
, "<Timeout: %d seconds>", timeout
);
87 fprintf_unfiltered (stream
, "<Error: %s>", safe_strerror (errno
));
90 fputs_unfiltered ("<Eof>", stream
);
93 fputs_unfiltered ("<Break>", stream
);
96 if (serial_logbase
== logbase_hex
)
97 fprintf_unfiltered (stream
, "%02x", ch
& 0xff);
98 else if (serial_logbase
== logbase_octal
)
99 fprintf_unfiltered (stream
, "%03o", ch
& 0xff);
104 fputs_unfiltered ("\\\\", stream
);
107 fputs_unfiltered ("\\b", stream
);
110 fputs_unfiltered ("\\f", stream
);
113 fputs_unfiltered ("\\n", stream
);
116 fputs_unfiltered ("\\r", stream
);
119 fputs_unfiltered ("\\t", stream
);
122 fputs_unfiltered ("\\v", stream
);
125 fprintf_unfiltered (stream
,
126 isprint (ch
) ? "%c" : "\\x%02x", ch
& 0xFF);
133 serial_log_command (struct target_ops
*self
, const char *cmd
)
138 serial_current_type
= 'c';
140 fputs_unfiltered ("\nc ", serial_logfp
);
141 fputs_unfiltered (cmd
, serial_logfp
);
143 /* Make sure that the log file is as up-to-date as possible,
144 in case we are getting ready to dump core or something. */
145 gdb_flush (serial_logfp
);
149 static const struct serial_ops
*
150 serial_interface_lookup (const char *name
)
152 const struct serial_ops
*ops
;
155 for (i
= 0; VEC_iterate (serial_ops_p
, serial_ops_list
, i
, ops
); ++i
)
156 if (strcmp (name
, ops
->name
) == 0)
163 serial_add_interface (const struct serial_ops
*optable
)
165 VEC_safe_push (serial_ops_p
, serial_ops_list
, optable
);
168 /* Return the open serial device for FD, if found, or NULL if FD is
169 not already opened. */
172 serial_for_fd (int fd
)
176 for (scb
= scb_base
; scb
; scb
= scb
->next
)
183 /* Open up a device or a network socket, depending upon the syntax of NAME. */
186 serial_open (const char *name
)
189 const struct serial_ops
*ops
;
190 const char *open_name
= name
;
192 if (strcmp (name
, "pc") == 0)
193 ops
= serial_interface_lookup ("pc");
194 else if (strncmp (name
, "lpt", 3) == 0)
195 ops
= serial_interface_lookup ("parallel");
196 else if (strncmp (name
, "|", 1) == 0)
198 ops
= serial_interface_lookup ("pipe");
199 /* Discard ``|'' and any space before the command itself. */
201 open_name
= skip_spaces_const (open_name
);
203 /* Check for a colon, suggesting an IP address/port pair.
204 Do this *after* checking for all the interesting prefixes. We
205 don't want to constrain the syntax of what can follow them. */
206 else if (strchr (name
, ':'))
207 ops
= serial_interface_lookup ("tcp");
209 ops
= serial_interface_lookup ("hardwire");
214 scb
= XNEW (struct serial
);
219 scb
->bufp
= scb
->buf
;
223 /* `...->open (...)' would get expanded by the open(2) syscall macro. */
224 if ((*scb
->ops
->open
) (scb
, open_name
))
230 scb
->name
= xstrdup (name
);
231 scb
->next
= scb_base
;
233 scb
->async_state
= 0;
234 scb
->async_handler
= NULL
;
235 scb
->async_context
= NULL
;
238 if (serial_logfile
!= NULL
)
240 serial_logfp
= gdb_fopen (serial_logfile
, "w");
241 if (serial_logfp
== NULL
)
242 perror_with_name (serial_logfile
);
248 /* Open a new serial stream using a file handle, using serial
249 interface ops OPS. */
251 static struct serial
*
252 serial_fdopen_ops (const int fd
, const struct serial_ops
*ops
)
258 ops
= serial_interface_lookup ("terminal");
260 ops
= serial_interface_lookup ("hardwire");
266 scb
= XCNEW (struct serial
);
271 scb
->bufp
= scb
->buf
;
276 scb
->next
= scb_base
;
278 scb
->async_state
= 0;
279 scb
->async_handler
= NULL
;
280 scb
->async_context
= NULL
;
283 if ((ops
->fdopen
) != NULL
)
284 (*ops
->fdopen
) (scb
, fd
);
292 serial_fdopen (const int fd
)
294 return serial_fdopen_ops (fd
, NULL
);
298 do_serial_close (struct serial
*scb
, int really_close
)
300 struct serial
*tmp_scb
;
304 fputs_unfiltered ("\nEnd of log\n", serial_logfp
);
305 serial_current_type
= 0;
307 /* XXX - What if serial_logfp == gdb_stdout or gdb_stderr? */
308 ui_file_delete (serial_logfp
);
312 /* ensure that the FD has been taken out of async mode. */
313 if (scb
->async_handler
!= NULL
)
314 serial_async (scb
, NULL
, NULL
);
317 scb
->ops
->close (scb
);
322 /* For serial_is_open. */
326 scb_base
= scb_base
->next
;
328 for (tmp_scb
= scb_base
; tmp_scb
; tmp_scb
= tmp_scb
->next
)
330 if (tmp_scb
->next
!= scb
)
333 tmp_scb
->next
= tmp_scb
->next
->next
;
341 serial_close (struct serial
*scb
)
343 do_serial_close (scb
, 1);
347 serial_un_fdopen (struct serial
*scb
)
349 do_serial_close (scb
, 0);
353 serial_is_open (struct serial
*scb
)
355 return scb
->bufp
!= NULL
;
359 serial_ref (struct serial
*scb
)
365 serial_unref (struct serial
*scb
)
368 if (scb
->refcnt
== 0)
373 serial_readchar (struct serial
*scb
, int timeout
)
377 /* FIXME: cagney/1999-10-11: Don't enable this check until the ASYNC
379 if (0 && serial_is_async_p (scb
) && timeout
< 0)
380 internal_error (__FILE__
, __LINE__
,
381 _("serial_readchar: blocking read in async mode"));
383 ch
= scb
->ops
->readchar (scb
, timeout
);
384 if (serial_logfp
!= NULL
)
386 serial_logchar (serial_logfp
, 'r', ch
, timeout
);
388 /* Make sure that the log file is as up-to-date as possible,
389 in case we are getting ready to dump core or something. */
390 gdb_flush (serial_logfp
);
392 if (serial_debug_p (scb
))
394 fprintf_unfiltered (gdb_stdlog
, "[");
395 serial_logchar (gdb_stdlog
, 'r', ch
, timeout
);
396 fprintf_unfiltered (gdb_stdlog
, "]");
397 gdb_flush (gdb_stdlog
);
404 serial_write (struct serial
*scb
, const void *buf
, size_t count
)
406 if (serial_logfp
!= NULL
)
408 const char *str
= buf
;
411 for (c
= 0; c
< count
; c
++)
412 serial_logchar (serial_logfp
, 'w', str
[c
] & 0xff, 0);
414 /* Make sure that the log file is as up-to-date as possible,
415 in case we are getting ready to dump core or something. */
416 gdb_flush (serial_logfp
);
418 if (serial_debug_p (scb
))
420 const char *str
= buf
;
423 for (c
= 0; c
< count
; c
++)
425 fprintf_unfiltered (gdb_stdlog
, "[");
426 serial_logchar (gdb_stdlog
, 'w', str
[count
] & 0xff, 0);
427 fprintf_unfiltered (gdb_stdlog
, "]");
429 gdb_flush (gdb_stdlog
);
432 return (scb
->ops
->write (scb
, buf
, count
));
436 serial_printf (struct serial
*desc
, const char *format
,...)
440 va_start (args
, format
);
442 buf
= xstrvprintf (format
, args
);
443 serial_write (desc
, buf
, strlen (buf
));
450 serial_drain_output (struct serial
*scb
)
452 return scb
->ops
->drain_output (scb
);
456 serial_flush_output (struct serial
*scb
)
458 return scb
->ops
->flush_output (scb
);
462 serial_flush_input (struct serial
*scb
)
464 return scb
->ops
->flush_input (scb
);
468 serial_send_break (struct serial
*scb
)
470 if (serial_logfp
!= NULL
)
471 serial_logchar (serial_logfp
, 'w', SERIAL_BREAK
, 0);
473 return (scb
->ops
->send_break (scb
));
477 serial_raw (struct serial
*scb
)
479 scb
->ops
->go_raw (scb
);
483 serial_get_tty_state (struct serial
*scb
)
485 return scb
->ops
->get_tty_state (scb
);
489 serial_copy_tty_state (struct serial
*scb
, serial_ttystate ttystate
)
491 return scb
->ops
->copy_tty_state (scb
, ttystate
);
495 serial_set_tty_state (struct serial
*scb
, serial_ttystate ttystate
)
497 return scb
->ops
->set_tty_state (scb
, ttystate
);
501 serial_print_tty_state (struct serial
*scb
,
502 serial_ttystate ttystate
,
503 struct ui_file
*stream
)
505 scb
->ops
->print_tty_state (scb
, ttystate
, stream
);
509 serial_noflush_set_tty_state (struct serial
*scb
,
510 serial_ttystate new_ttystate
,
511 serial_ttystate old_ttystate
)
513 return scb
->ops
->noflush_set_tty_state (scb
, new_ttystate
, old_ttystate
);
517 serial_setbaudrate (struct serial
*scb
, int rate
)
519 return scb
->ops
->setbaudrate (scb
, rate
);
523 serial_setstopbits (struct serial
*scb
, int num
)
525 return scb
->ops
->setstopbits (scb
, num
);
529 serial_can_async_p (struct serial
*scb
)
531 return (scb
->ops
->async
!= NULL
);
535 serial_is_async_p (struct serial
*scb
)
537 return (scb
->ops
->async
!= NULL
) && (scb
->async_handler
!= NULL
);
541 serial_async (struct serial
*scb
,
542 serial_event_ftype
*handler
,
545 int changed
= ((scb
->async_handler
== NULL
) != (handler
== NULL
));
547 scb
->async_handler
= handler
;
548 scb
->async_context
= context
;
549 /* Only change mode if there is a need. */
551 scb
->ops
->async (scb
, handler
!= NULL
);
555 serial_debug (struct serial
*scb
, int debug_p
)
557 scb
->debug_p
= debug_p
;
561 serial_debug_p (struct serial
*scb
)
563 return scb
->debug_p
|| global_serial_debug_p
;
568 serial_wait_handle (struct serial
*scb
, HANDLE
*read
, HANDLE
*except
)
570 if (scb
->ops
->wait_handle
)
571 scb
->ops
->wait_handle (scb
, read
, except
);
574 *read
= (HANDLE
) _get_osfhandle (scb
->fd
);
580 serial_done_wait_handle (struct serial
*scb
)
582 if (scb
->ops
->done_wait_handle
)
583 scb
->ops
->done_wait_handle (scb
);
588 serial_pipe (struct serial
*scbs
[2])
590 const struct serial_ops
*ops
;
593 ops
= serial_interface_lookup ("pipe");
600 if (gdb_pipe (fildes
) == -1)
603 scbs
[0] = serial_fdopen_ops (fildes
[0], ops
);
604 scbs
[1] = serial_fdopen_ops (fildes
[1], ops
);
608 /* Serial set/show framework. */
610 static struct cmd_list_element
*serial_set_cmdlist
;
611 static struct cmd_list_element
*serial_show_cmdlist
;
614 serial_set_cmd (char *args
, int from_tty
)
616 printf_unfiltered ("\"set serial\" must be followed "
617 "by the name of a command.\n");
618 help_list (serial_set_cmdlist
, "set serial ", -1, gdb_stdout
);
622 serial_show_cmd (char *args
, int from_tty
)
624 cmd_show_list (serial_show_cmdlist
, from_tty
, "");
627 /* Baud rate specified for talking to serial target systems. Default
628 is left as -1, so targets can choose their own defaults. */
629 /* FIXME: This means that "show serial baud" and gr_files_info can
630 print -1 or (unsigned int)-1. This is a Bad User Interface. */
635 serial_baud_show_cmd (struct ui_file
*file
, int from_tty
,
636 struct cmd_list_element
*c
, const char *value
)
638 fprintf_filtered (file
, _("Baud rate for remote serial I/O is %s.\n"),
643 _initialize_serial (void)
646 add_com ("connect", class_obscure
, connect_command
, _("\
647 Connect the terminal directly up to the command monitor.\n\
648 Use <CR>~. or <CR>~^D to break out."));
651 add_prefix_cmd ("serial", class_maintenance
, serial_set_cmd
, _("\
652 Set default serial/parallel port configuration."),
653 &serial_set_cmdlist
, "set serial ",
657 add_prefix_cmd ("serial", class_maintenance
, serial_show_cmd
, _("\
658 Show default serial/parallel port configuration."),
659 &serial_show_cmdlist
, "show serial ",
663 /* If target is open when baud changes, it doesn't take effect until
664 the next open (I think, not sure). */
665 add_setshow_zinteger_cmd ("baud", no_class
, &baud_rate
, _("\
666 Set baud rate for remote serial I/O."), _("\
667 Show baud rate for remote serial I/O."), _("\
668 This value is used to set the speed of the serial port when debugging\n\
669 using remote targets."),
671 serial_baud_show_cmd
,
672 &serial_set_cmdlist
, &serial_show_cmdlist
);
674 /* The commands "set/show serial baud" used to have a different name.
675 Add aliases to those names to facilitate the transition, and mark
676 them as deprecated, in order to make users aware of the fact that
677 the command names have been changed. */
679 const char *cmd_name
;
680 struct cmd_list_element
*cmd
;
682 /* FIXME: There is a limitation in the deprecation mechanism,
683 and the warning ends up not being displayed for prefixed
684 aliases. So use a real command instead of an alias. */
685 add_setshow_zinteger_cmd ("remotebaud", class_alias
, &baud_rate
, _("\
686 Set baud rate for remote serial I/O."), _("\
687 Show baud rate for remote serial I/O."), _("\
688 This value is used to set the speed of the serial port when debugging\n\
689 using remote targets."),
691 serial_baud_show_cmd
,
692 &setlist
, &showlist
);
693 cmd_name
= "remotebaud";
694 cmd
= lookup_cmd (&cmd_name
, setlist
, "", -1, 1);
695 deprecate_cmd (cmd
, "set serial baud");
697 = "remotebaud"; /* needed because lookup_cmd updates the pointer */
698 cmd
= lookup_cmd (&cmd_name
, showlist
, "", -1, 1);
699 deprecate_cmd (cmd
, "show serial baud");
702 add_setshow_filename_cmd ("remotelogfile", no_class
, &serial_logfile
, _("\
703 Set filename for remote session recording."), _("\
704 Show filename for remote session recording."), _("\
705 This file is used to record the remote session for future playback\n\
708 NULL
, /* FIXME: i18n: */
709 &setlist
, &showlist
);
711 add_setshow_enum_cmd ("remotelogbase", no_class
, logbase_enums
,
712 &serial_logbase
, _("\
713 Set numerical base for remote session logging"), _("\
714 Show numerical base for remote session logging"), NULL
,
716 NULL
, /* FIXME: i18n: */
717 &setlist
, &showlist
);
719 add_setshow_zuinteger_cmd ("serial", class_maintenance
,
720 &global_serial_debug_p
, _("\
721 Set serial debugging."), _("\
722 Show serial debugging."), _("\
723 When non-zero, serial port debugging is enabled."),
725 NULL
, /* FIXME: i18n: */
726 &setdebuglist
, &showdebuglist
);