1 /* Generic serial interface routines
3 Copyright (C) 1992-2016 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/>. */
24 #include "cli/cli-utils.h"
26 extern void _initialize_serial (void);
28 /* Is serial being debugged? */
30 static unsigned int global_serial_debug_p
;
32 typedef const struct serial_ops
*serial_ops_p
;
33 DEF_VEC_P (serial_ops_p
);
35 /* Serial I/O handlers. */
37 VEC (serial_ops_p
) *serial_ops_list
= NULL
;
39 /* Pointer to list of scb's. */
41 static struct serial
*scb_base
;
43 /* Non-NULL gives filename which contains a recording of the remote session,
44 suitable for playback by gdbserver. */
46 static char *serial_logfile
= NULL
;
47 static struct ui_file
*serial_logfp
= NULL
;
49 static const struct serial_ops
*serial_interface_lookup (const char *);
50 static void serial_logchar (struct ui_file
*stream
,
51 int ch_type
, int ch
, int timeout
);
52 static const char logbase_hex
[] = "hex";
53 static const char logbase_octal
[] = "octal";
54 static const char logbase_ascii
[] = "ascii";
55 static const char *const logbase_enums
[] =
56 {logbase_hex
, logbase_octal
, logbase_ascii
, NULL
};
57 static const char *serial_logbase
= logbase_ascii
;
60 static int serial_current_type
= 0;
62 /* Log char CH of type CHTYPE, with TIMEOUT. */
64 /* Define bogus char to represent a BREAK. Should be careful to choose a value
65 that can't be confused with a normal char, or an error code. */
66 #define SERIAL_BREAK 1235
69 serial_logchar (struct ui_file
*stream
, int ch_type
, int ch
, int timeout
)
71 if (ch_type
!= serial_current_type
)
73 fprintf_unfiltered (stream
, "\n%c ", ch_type
);
74 serial_current_type
= ch_type
;
77 if (serial_logbase
!= logbase_ascii
)
78 fputc_unfiltered (' ', stream
);
83 fprintf_unfiltered (stream
, "<Timeout: %d seconds>", timeout
);
86 fprintf_unfiltered (stream
, "<Error: %s>", safe_strerror (errno
));
89 fputs_unfiltered ("<Eof>", stream
);
92 fputs_unfiltered ("<Break>", stream
);
95 if (serial_logbase
== logbase_hex
)
96 fprintf_unfiltered (stream
, "%02x", ch
& 0xff);
97 else if (serial_logbase
== logbase_octal
)
98 fprintf_unfiltered (stream
, "%03o", ch
& 0xff);
103 fputs_unfiltered ("\\\\", stream
);
106 fputs_unfiltered ("\\b", stream
);
109 fputs_unfiltered ("\\f", stream
);
112 fputs_unfiltered ("\\n", stream
);
115 fputs_unfiltered ("\\r", stream
);
118 fputs_unfiltered ("\\t", stream
);
121 fputs_unfiltered ("\\v", stream
);
124 fprintf_unfiltered (stream
,
125 isprint (ch
) ? "%c" : "\\x%02x", ch
& 0xFF);
132 serial_log_command (struct target_ops
*self
, const char *cmd
)
137 serial_current_type
= 'c';
139 fputs_unfiltered ("\nc ", serial_logfp
);
140 fputs_unfiltered (cmd
, serial_logfp
);
142 /* Make sure that the log file is as up-to-date as possible,
143 in case we are getting ready to dump core or something. */
144 gdb_flush (serial_logfp
);
148 static const struct serial_ops
*
149 serial_interface_lookup (const char *name
)
151 const struct serial_ops
*ops
;
154 for (i
= 0; VEC_iterate (serial_ops_p
, serial_ops_list
, i
, ops
); ++i
)
155 if (strcmp (name
, ops
->name
) == 0)
162 serial_add_interface (const struct serial_ops
*optable
)
164 VEC_safe_push (serial_ops_p
, serial_ops_list
, optable
);
167 /* Return the open serial device for FD, if found, or NULL if FD is
168 not already opened. */
171 serial_for_fd (int fd
)
175 for (scb
= scb_base
; scb
; scb
= scb
->next
)
182 /* Create a new serial for OPS. */
184 static struct serial
*
185 new_serial (const struct serial_ops
*ops
)
189 scb
= XCNEW (struct serial
);
193 scb
->bufp
= scb
->buf
;
200 static struct serial
*serial_open_ops_1 (const struct serial_ops
*ops
,
201 const char *open_name
);
203 /* Open up a device or a network socket, depending upon the syntax of NAME. */
206 serial_open (const char *name
)
209 const struct serial_ops
*ops
;
210 const char *open_name
= name
;
212 if (strcmp (name
, "pc") == 0)
213 ops
= serial_interface_lookup ("pc");
214 else if (startswith (name
, "lpt"))
215 ops
= serial_interface_lookup ("parallel");
216 else if (startswith (name
, "|"))
218 ops
= serial_interface_lookup ("pipe");
219 /* Discard ``|'' and any space before the command itself. */
221 open_name
= skip_spaces_const (open_name
);
223 /* Check for a colon, suggesting an IP address/port pair.
224 Do this *after* checking for all the interesting prefixes. We
225 don't want to constrain the syntax of what can follow them. */
226 else if (strchr (name
, ':'))
227 ops
= serial_interface_lookup ("tcp");
229 ops
= serial_interface_lookup ("hardwire");
234 return serial_open_ops_1 (ops
, open_name
);
237 /* Open up a serial for OPS, passing OPEN_NAME to the open method. */
239 static struct serial
*
240 serial_open_ops_1 (const struct serial_ops
*ops
, const char *open_name
)
244 scb
= new_serial (ops
);
246 /* `...->open (...)' would get expanded by the open(2) syscall macro. */
247 if ((*scb
->ops
->open
) (scb
, open_name
))
253 scb
->next
= scb_base
;
256 if (serial_logfile
!= NULL
)
258 serial_logfp
= gdb_fopen (serial_logfile
, "w");
259 if (serial_logfp
== NULL
)
260 perror_with_name (serial_logfile
);
269 serial_open_ops (const struct serial_ops
*ops
)
271 return serial_open_ops_1 (ops
, NULL
);
274 /* Open a new serial stream using a file handle, using serial
275 interface ops OPS. */
277 static struct serial
*
278 serial_fdopen_ops (const int fd
, const struct serial_ops
*ops
)
284 ops
= serial_interface_lookup ("terminal");
286 ops
= serial_interface_lookup ("hardwire");
292 scb
= new_serial (ops
);
294 scb
->next
= scb_base
;
297 if ((ops
->fdopen
) != NULL
)
298 (*ops
->fdopen
) (scb
, fd
);
306 serial_fdopen (const int fd
)
308 return serial_fdopen_ops (fd
, NULL
);
312 do_serial_close (struct serial
*scb
, int really_close
)
314 struct serial
*tmp_scb
;
318 fputs_unfiltered ("\nEnd of log\n", serial_logfp
);
319 serial_current_type
= 0;
321 /* XXX - What if serial_logfp == gdb_stdout or gdb_stderr? */
322 ui_file_delete (serial_logfp
);
326 /* ensure that the FD has been taken out of async mode. */
327 if (scb
->async_handler
!= NULL
)
328 serial_async (scb
, NULL
, NULL
);
331 scb
->ops
->close (scb
);
333 /* For serial_is_open. */
337 scb_base
= scb_base
->next
;
339 for (tmp_scb
= scb_base
; tmp_scb
; tmp_scb
= tmp_scb
->next
)
341 if (tmp_scb
->next
!= scb
)
344 tmp_scb
->next
= tmp_scb
->next
->next
;
352 serial_close (struct serial
*scb
)
354 do_serial_close (scb
, 1);
358 serial_un_fdopen (struct serial
*scb
)
360 do_serial_close (scb
, 0);
364 serial_is_open (struct serial
*scb
)
366 return scb
->bufp
!= NULL
;
370 serial_ref (struct serial
*scb
)
376 serial_unref (struct serial
*scb
)
379 if (scb
->refcnt
== 0)
384 serial_readchar (struct serial
*scb
, int timeout
)
388 /* FIXME: cagney/1999-10-11: Don't enable this check until the ASYNC
390 if (0 && serial_is_async_p (scb
) && timeout
< 0)
391 internal_error (__FILE__
, __LINE__
,
392 _("serial_readchar: blocking read in async mode"));
394 ch
= scb
->ops
->readchar (scb
, timeout
);
395 if (serial_logfp
!= NULL
)
397 serial_logchar (serial_logfp
, 'r', ch
, timeout
);
399 /* Make sure that the log file is as up-to-date as possible,
400 in case we are getting ready to dump core or something. */
401 gdb_flush (serial_logfp
);
403 if (serial_debug_p (scb
))
405 fprintf_unfiltered (gdb_stdlog
, "[");
406 serial_logchar (gdb_stdlog
, 'r', ch
, timeout
);
407 fprintf_unfiltered (gdb_stdlog
, "]");
408 gdb_flush (gdb_stdlog
);
415 serial_write (struct serial
*scb
, const void *buf
, size_t count
)
417 if (serial_logfp
!= NULL
)
419 const char *str
= (const char *) buf
;
422 for (c
= 0; c
< count
; c
++)
423 serial_logchar (serial_logfp
, 'w', str
[c
] & 0xff, 0);
425 /* Make sure that the log file is as up-to-date as possible,
426 in case we are getting ready to dump core or something. */
427 gdb_flush (serial_logfp
);
429 if (serial_debug_p (scb
))
431 const char *str
= (const char *) buf
;
434 for (c
= 0; c
< count
; c
++)
436 fprintf_unfiltered (gdb_stdlog
, "[");
437 serial_logchar (gdb_stdlog
, 'w', str
[c
] & 0xff, 0);
438 fprintf_unfiltered (gdb_stdlog
, "]");
440 gdb_flush (gdb_stdlog
);
443 return (scb
->ops
->write (scb
, buf
, count
));
447 serial_printf (struct serial
*desc
, const char *format
,...)
451 va_start (args
, format
);
453 buf
= xstrvprintf (format
, args
);
454 serial_write (desc
, buf
, strlen (buf
));
461 serial_drain_output (struct serial
*scb
)
463 return scb
->ops
->drain_output (scb
);
467 serial_flush_output (struct serial
*scb
)
469 return scb
->ops
->flush_output (scb
);
473 serial_flush_input (struct serial
*scb
)
475 return scb
->ops
->flush_input (scb
);
479 serial_send_break (struct serial
*scb
)
481 if (serial_logfp
!= NULL
)
482 serial_logchar (serial_logfp
, 'w', SERIAL_BREAK
, 0);
484 return (scb
->ops
->send_break (scb
));
488 serial_raw (struct serial
*scb
)
490 scb
->ops
->go_raw (scb
);
494 serial_get_tty_state (struct serial
*scb
)
496 return scb
->ops
->get_tty_state (scb
);
500 serial_copy_tty_state (struct serial
*scb
, serial_ttystate ttystate
)
502 return scb
->ops
->copy_tty_state (scb
, ttystate
);
506 serial_set_tty_state (struct serial
*scb
, serial_ttystate ttystate
)
508 return scb
->ops
->set_tty_state (scb
, ttystate
);
512 serial_print_tty_state (struct serial
*scb
,
513 serial_ttystate ttystate
,
514 struct ui_file
*stream
)
516 scb
->ops
->print_tty_state (scb
, ttystate
, stream
);
520 serial_noflush_set_tty_state (struct serial
*scb
,
521 serial_ttystate new_ttystate
,
522 serial_ttystate old_ttystate
)
524 return scb
->ops
->noflush_set_tty_state (scb
, new_ttystate
, old_ttystate
);
528 serial_setbaudrate (struct serial
*scb
, int rate
)
530 return scb
->ops
->setbaudrate (scb
, rate
);
534 serial_setstopbits (struct serial
*scb
, int num
)
536 return scb
->ops
->setstopbits (scb
, num
);
542 serial_setparity (struct serial
*scb
, int parity
)
544 return scb
->ops
->setparity (scb
, parity
);
548 serial_can_async_p (struct serial
*scb
)
550 return (scb
->ops
->async
!= NULL
);
554 serial_is_async_p (struct serial
*scb
)
556 return (scb
->ops
->async
!= NULL
) && (scb
->async_handler
!= NULL
);
560 serial_async (struct serial
*scb
,
561 serial_event_ftype
*handler
,
564 int changed
= ((scb
->async_handler
== NULL
) != (handler
== NULL
));
566 scb
->async_handler
= handler
;
567 scb
->async_context
= context
;
568 /* Only change mode if there is a need. */
570 scb
->ops
->async (scb
, handler
!= NULL
);
574 serial_debug (struct serial
*scb
, int debug_p
)
576 scb
->debug_p
= debug_p
;
580 serial_debug_p (struct serial
*scb
)
582 return scb
->debug_p
|| global_serial_debug_p
;
587 serial_wait_handle (struct serial
*scb
, HANDLE
*read
, HANDLE
*except
)
589 if (scb
->ops
->wait_handle
)
590 scb
->ops
->wait_handle (scb
, read
, except
);
593 *read
= (HANDLE
) _get_osfhandle (scb
->fd
);
599 serial_done_wait_handle (struct serial
*scb
)
601 if (scb
->ops
->done_wait_handle
)
602 scb
->ops
->done_wait_handle (scb
);
607 serial_pipe (struct serial
*scbs
[2])
609 const struct serial_ops
*ops
;
612 ops
= serial_interface_lookup ("pipe");
619 if (gdb_pipe (fildes
) == -1)
622 scbs
[0] = serial_fdopen_ops (fildes
[0], ops
);
623 scbs
[1] = serial_fdopen_ops (fildes
[1], ops
);
627 /* Serial set/show framework. */
629 static struct cmd_list_element
*serial_set_cmdlist
;
630 static struct cmd_list_element
*serial_show_cmdlist
;
633 serial_set_cmd (char *args
, int from_tty
)
635 printf_unfiltered ("\"set serial\" must be followed "
636 "by the name of a command.\n");
637 help_list (serial_set_cmdlist
, "set serial ", all_commands
, gdb_stdout
);
641 serial_show_cmd (char *args
, int from_tty
)
643 cmd_show_list (serial_show_cmdlist
, from_tty
, "");
646 /* Baud rate specified for talking to serial target systems. Default
647 is left as -1, so targets can choose their own defaults. */
648 /* FIXME: This means that "show serial baud" and gr_files_info can
649 print -1 or (unsigned int)-1. This is a Bad User Interface. */
654 serial_baud_show_cmd (struct ui_file
*file
, int from_tty
,
655 struct cmd_list_element
*c
, const char *value
)
657 fprintf_filtered (file
, _("Baud rate for remote serial I/O is %s.\n"),
661 /* Parity for serial port. */
663 int serial_parity
= GDBPARITY_NONE
;
665 static const char parity_none
[] = "none";
666 static const char parity_odd
[] = "odd";
667 static const char parity_even
[] = "even";
668 static const char *const parity_enums
[] =
669 {parity_none
, parity_odd
, parity_even
, NULL
};
670 static const char *parity
= parity_none
;
672 /* Set serial_parity value. */
675 set_parity (char *ignore_args
, int from_tty
, struct cmd_list_element
*c
)
677 if (parity
== parity_odd
)
678 serial_parity
= GDBPARITY_ODD
;
679 else if (parity
== parity_even
)
680 serial_parity
= GDBPARITY_EVEN
;
682 serial_parity
= GDBPARITY_NONE
;
686 _initialize_serial (void)
689 add_com ("connect", class_obscure
, connect_command
, _("\
690 Connect the terminal directly up to the command monitor.\n\
691 Use <CR>~. or <CR>~^D to break out."));
694 add_prefix_cmd ("serial", class_maintenance
, serial_set_cmd
, _("\
695 Set default serial/parallel port configuration."),
696 &serial_set_cmdlist
, "set serial ",
700 add_prefix_cmd ("serial", class_maintenance
, serial_show_cmd
, _("\
701 Show default serial/parallel port configuration."),
702 &serial_show_cmdlist
, "show serial ",
706 /* If target is open when baud changes, it doesn't take effect until
707 the next open (I think, not sure). */
708 add_setshow_zinteger_cmd ("baud", no_class
, &baud_rate
, _("\
709 Set baud rate for remote serial I/O."), _("\
710 Show baud rate for remote serial I/O."), _("\
711 This value is used to set the speed of the serial port when debugging\n\
712 using remote targets."),
714 serial_baud_show_cmd
,
715 &serial_set_cmdlist
, &serial_show_cmdlist
);
717 add_setshow_enum_cmd ("parity", no_class
, parity_enums
,
719 Set parity for remote serial I/O"), _("\
720 Show parity for remote serial I/O"), NULL
,
722 NULL
, /* FIXME: i18n: */
723 &serial_set_cmdlist
, &serial_show_cmdlist
);
725 add_setshow_filename_cmd ("remotelogfile", no_class
, &serial_logfile
, _("\
726 Set filename for remote session recording."), _("\
727 Show filename for remote session recording."), _("\
728 This file is used to record the remote session for future playback\n\
731 NULL
, /* FIXME: i18n: */
732 &setlist
, &showlist
);
734 add_setshow_enum_cmd ("remotelogbase", no_class
, logbase_enums
,
735 &serial_logbase
, _("\
736 Set numerical base for remote session logging"), _("\
737 Show numerical base for remote session logging"), NULL
,
739 NULL
, /* FIXME: i18n: */
740 &setlist
, &showlist
);
742 add_setshow_zuinteger_cmd ("serial", class_maintenance
,
743 &global_serial_debug_p
, _("\
744 Set serial debugging."), _("\
745 Show serial debugging."), _("\
746 When non-zero, serial port debugging is enabled."),
748 NULL
, /* FIXME: i18n: */
749 &setdebuglist
, &showdebuglist
);