1 /* Generic serial interface routines
3 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
4 2002, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
5 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
25 #include "gdb_string.h"
28 extern void _initialize_serial (void);
30 /* Is serial being debugged? */
32 static int global_serial_debug_p
;
34 /* Linked list of serial I/O handlers. */
36 static struct serial_ops
*serial_ops_list
= NULL
;
38 /* This is the last serial stream opened. Used by connect command. */
40 static struct serial
*last_serial_opened
= NULL
;
42 /* Pointer to list of scb's. */
44 static struct serial
*scb_base
;
46 /* Non-NULL gives filename which contains a recording of the remote session,
47 suitable for playback by gdbserver. */
49 static char *serial_logfile
= NULL
;
50 static struct ui_file
*serial_logfp
= NULL
;
52 static struct serial_ops
*serial_interface_lookup (const char *);
53 static void serial_logchar (struct ui_file
*stream
,
54 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 static int serial_current_type
= 0;
65 /* Log char CH of type CHTYPE, with TIMEOUT. */
67 /* Define bogus char to represent a BREAK. Should be careful to choose a value
68 that can't be confused with a normal char, or an error code. */
69 #define SERIAL_BREAK 1235
72 serial_logchar (struct ui_file
*stream
, int ch_type
, int ch
, int timeout
)
74 if (ch_type
!= serial_current_type
)
76 fprintf_unfiltered (stream
, "\n%c ", ch_type
);
77 serial_current_type
= ch_type
;
80 if (serial_logbase
!= logbase_ascii
)
81 fputc_unfiltered (' ', stream
);
86 fprintf_unfiltered (stream
, "<Timeout: %d seconds>", timeout
);
89 fprintf_unfiltered (stream
, "<Error: %s>", safe_strerror (errno
));
92 fputs_unfiltered ("<Eof>", stream
);
95 fputs_unfiltered ("<Break>", stream
);
98 if (serial_logbase
== logbase_hex
)
99 fprintf_unfiltered (stream
, "%02x", ch
& 0xff);
100 else if (serial_logbase
== logbase_octal
)
101 fprintf_unfiltered (stream
, "%03o", ch
& 0xff);
106 fputs_unfiltered ("\\\\", stream
);
109 fputs_unfiltered ("\\b", stream
);
112 fputs_unfiltered ("\\f", stream
);
115 fputs_unfiltered ("\\n", stream
);
118 fputs_unfiltered ("\\r", stream
);
121 fputs_unfiltered ("\\t", stream
);
124 fputs_unfiltered ("\\v", stream
);
127 fprintf_unfiltered (stream
,
128 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 (const 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
, "pc") == 0)
187 ops
= serial_interface_lookup ("pc");
188 else if (strncmp (name
, "lpt", 3) == 0)
189 ops
= serial_interface_lookup ("parallel");
190 else if (strncmp (name
, "|", 1) == 0)
192 ops
= serial_interface_lookup ("pipe");
193 /* Discard ``|'' and any space before the command itself. */
195 while (isspace (*open_name
))
198 /* Check for a colon, suggesting an IP address/port pair.
199 Do this *after* checking for all the interesting prefixes. We
200 don't want to constrain the syntax of what can follow them. */
201 else if (strchr (name
, ':'))
202 ops
= serial_interface_lookup ("tcp");
204 ops
= serial_interface_lookup ("hardwire");
209 scb
= XMALLOC (struct serial
);
214 scb
->bufp
= scb
->buf
;
217 /* `...->open (...)' would get expanded by the open(2) syscall macro. */
218 if ((*scb
->ops
->open
) (scb
, open_name
))
224 scb
->name
= xstrdup (name
);
225 scb
->next
= scb_base
;
228 scb
->async_state
= 0;
229 scb
->async_handler
= NULL
;
230 scb
->async_context
= NULL
;
233 last_serial_opened
= scb
;
235 if (serial_logfile
!= NULL
)
237 serial_logfp
= gdb_fopen (serial_logfile
, "w");
238 if (serial_logfp
== NULL
)
239 perror_with_name (serial_logfile
);
245 /* Return the open serial device for FD, if found, or NULL if FD
246 is not already opened. */
249 serial_for_fd (int fd
)
253 for (scb
= scb_base
; scb
; scb
= scb
->next
)
260 /* Open a new serial stream using a file handle, using serial
261 interface ops OPS. */
263 static struct serial
*
264 serial_fdopen_ops (const int fd
, struct serial_ops
*ops
)
268 scb
= serial_for_fd (fd
);
277 ops
= serial_interface_lookup ("terminal");
279 ops
= serial_interface_lookup ("hardwire");
285 scb
= XCALLOC (1, struct serial
);
290 scb
->bufp
= scb
->buf
;
294 scb
->next
= scb_base
;
297 scb
->async_state
= 0;
298 scb
->async_handler
= NULL
;
299 scb
->async_context
= NULL
;
302 if ((ops
->fdopen
) != NULL
)
303 (*ops
->fdopen
) (scb
, fd
);
307 last_serial_opened
= scb
;
313 serial_fdopen (const int fd
)
315 return serial_fdopen_ops (fd
, NULL
);
319 do_serial_close (struct serial
*scb
, int really_close
)
321 struct serial
*tmp_scb
;
323 last_serial_opened
= NULL
;
327 fputs_unfiltered ("\nEnd of log\n", serial_logfp
);
328 serial_current_type
= 0;
330 /* XXX - What if serial_logfp == gdb_stdout or gdb_stderr? */
331 ui_file_delete (serial_logfp
);
335 /* This is bogus. It's not our fault if you pass us a bad scb...! Rob, you
336 should fix your code instead. */
345 /* ensure that the FD has been taken out of async mode. */
346 if (scb
->async_handler
!= NULL
)
347 serial_async (scb
, NULL
, NULL
);
350 scb
->ops
->close (scb
);
356 scb_base
= scb_base
->next
;
358 for (tmp_scb
= scb_base
; tmp_scb
; tmp_scb
= tmp_scb
->next
)
360 if (tmp_scb
->next
!= scb
)
363 tmp_scb
->next
= tmp_scb
->next
->next
;
371 serial_close (struct serial
*scb
)
373 do_serial_close (scb
, 1);
377 serial_un_fdopen (struct serial
*scb
)
379 do_serial_close (scb
, 0);
383 serial_readchar (struct serial
*scb
, int timeout
)
387 /* FIXME: cagney/1999-10-11: Don't enable this check until the ASYNC
389 if (0 && serial_is_async_p (scb
) && timeout
< 0)
390 internal_error (__FILE__
, __LINE__
,
391 _("serial_readchar: blocking read in async mode"));
393 ch
= scb
->ops
->readchar (scb
, timeout
);
394 if (serial_logfp
!= NULL
)
396 serial_logchar (serial_logfp
, 'r', ch
, timeout
);
398 /* Make sure that the log file is as up-to-date as possible,
399 in case we are getting ready to dump core or something. */
400 gdb_flush (serial_logfp
);
402 if (serial_debug_p (scb
))
404 fprintf_unfiltered (gdb_stdlog
, "[");
405 serial_logchar (gdb_stdlog
, 'r', ch
, timeout
);
406 fprintf_unfiltered (gdb_stdlog
, "]");
407 gdb_flush (gdb_stdlog
);
414 serial_write (struct serial
*scb
, const char *str
, int len
)
416 if (serial_logfp
!= NULL
)
420 for (count
= 0; count
< len
; count
++)
421 serial_logchar (serial_logfp
, 'w', str
[count
] & 0xff, 0);
423 /* Make sure that the log file is as up-to-date as possible,
424 in case we are getting ready to dump core or something. */
425 gdb_flush (serial_logfp
);
427 if (serial_debug_p (scb
))
431 for (count
= 0; count
< len
; count
++)
433 fprintf_unfiltered (gdb_stdlog
, "[");
434 serial_logchar (gdb_stdlog
, 'w', str
[count
] & 0xff, 0);
435 fprintf_unfiltered (gdb_stdlog
, "]");
437 gdb_flush (gdb_stdlog
);
440 return (scb
->ops
->write (scb
, str
, len
));
444 serial_printf (struct serial
*desc
, const char *format
,...)
448 va_start (args
, format
);
450 buf
= xstrvprintf (format
, args
);
451 serial_write (desc
, buf
, strlen (buf
));
458 serial_drain_output (struct serial
*scb
)
460 return scb
->ops
->drain_output (scb
);
464 serial_flush_output (struct serial
*scb
)
466 return scb
->ops
->flush_output (scb
);
470 serial_flush_input (struct serial
*scb
)
472 return scb
->ops
->flush_input (scb
);
476 serial_send_break (struct serial
*scb
)
478 if (serial_logfp
!= NULL
)
479 serial_logchar (serial_logfp
, 'w', SERIAL_BREAK
, 0);
481 return (scb
->ops
->send_break (scb
));
485 serial_raw (struct serial
*scb
)
487 scb
->ops
->go_raw (scb
);
491 serial_get_tty_state (struct serial
*scb
)
493 return scb
->ops
->get_tty_state (scb
);
497 serial_copy_tty_state (struct serial
*scb
, serial_ttystate ttystate
)
499 return scb
->ops
->copy_tty_state (scb
, ttystate
);
503 serial_set_tty_state (struct serial
*scb
, serial_ttystate ttystate
)
505 return scb
->ops
->set_tty_state (scb
, ttystate
);
509 serial_print_tty_state (struct serial
*scb
,
510 serial_ttystate ttystate
,
511 struct ui_file
*stream
)
513 scb
->ops
->print_tty_state (scb
, ttystate
, stream
);
517 serial_noflush_set_tty_state (struct serial
*scb
,
518 serial_ttystate new_ttystate
,
519 serial_ttystate old_ttystate
)
521 return scb
->ops
->noflush_set_tty_state (scb
, new_ttystate
, old_ttystate
);
525 serial_setbaudrate (struct serial
*scb
, int rate
)
527 return scb
->ops
->setbaudrate (scb
, rate
);
531 serial_setstopbits (struct serial
*scb
, int num
)
533 return scb
->ops
->setstopbits (scb
, num
);
537 serial_can_async_p (struct serial
*scb
)
539 return (scb
->ops
->async
!= NULL
);
543 serial_is_async_p (struct serial
*scb
)
545 return (scb
->ops
->async
!= NULL
) && (scb
->async_handler
!= NULL
);
549 serial_async (struct serial
*scb
,
550 serial_event_ftype
*handler
,
553 int changed
= ((scb
->async_handler
== NULL
) != (handler
== NULL
));
555 scb
->async_handler
= handler
;
556 scb
->async_context
= context
;
557 /* Only change mode if there is a need. */
559 scb
->ops
->async (scb
, handler
!= NULL
);
563 deprecated_serial_fd (struct serial
*scb
)
565 /* FIXME: should this output a warning that deprecated code is being
569 internal_error (__FILE__
, __LINE__
,
570 _("serial: FD not valid"));
572 return scb
->fd
; /* sigh */
576 serial_debug (struct serial
*scb
, int debug_p
)
578 scb
->debug_p
= debug_p
;
582 serial_debug_p (struct serial
*scb
)
584 return scb
->debug_p
|| global_serial_debug_p
;
589 serial_wait_handle (struct serial
*scb
, HANDLE
*read
, HANDLE
*except
)
591 if (scb
->ops
->wait_handle
)
592 scb
->ops
->wait_handle (scb
, read
, except
);
595 *read
= (HANDLE
) _get_osfhandle (scb
->fd
);
601 serial_done_wait_handle (struct serial
*scb
)
603 if (scb
->ops
->done_wait_handle
)
604 scb
->ops
->done_wait_handle (scb
);
609 serial_pipe (struct serial
*scbs
[2])
611 struct serial_ops
*ops
;
614 ops
= serial_interface_lookup ("pipe");
621 if (gdb_pipe (fildes
) == -1)
624 scbs
[0] = serial_fdopen_ops (fildes
[0], ops
);
625 scbs
[1] = serial_fdopen_ops (fildes
[1], ops
);
630 /* The connect command is #if 0 because I hadn't thought of an elegant
631 way to wait for I/O on two `struct serial *'s simultaneously. Two
632 solutions came to mind:
634 1) Fork, and have have one fork handle the to user direction,
635 and have the other hand the to target direction. This
636 obviously won't cut it for MSDOS.
638 2) Use something like select. This assumes that stdin and
639 the target side can both be waited on via the same
640 mechanism. This may not be true for DOS, if GDB is
641 talking to the target via a TCP socket.
642 -grossman, 8 Jun 93 */
644 /* Connect the user directly to the remote system. This command acts just like
645 the 'cu' or 'tip' command. Use <CR>~. or <CR>~^D to break out. */
647 static struct serial
*tty_desc
; /* Controlling terminal */
650 cleanup_tty (serial_ttystate ttystate
)
652 printf_unfiltered ("\r\n[Exiting connect mode]\r\n");
653 serial_set_tty_state (tty_desc
, ttystate
);
655 serial_close (tty_desc
);
659 connect_command (char *args
, int fromtty
)
663 serial_ttystate ttystate
;
664 struct serial
*port_desc
; /* TTY port */
669 fprintf_unfiltered (gdb_stderr
,
670 "This command takes no args. "
671 "They have been ignored.\n");
673 printf_unfiltered ("[Entering connect mode. Use ~. or ~^D to escape]\n");
675 tty_desc
= serial_fdopen (0);
676 port_desc
= last_serial_opened
;
678 ttystate
= serial_get_tty_state (tty_desc
);
680 serial_raw (tty_desc
);
681 serial_raw (port_desc
);
683 make_cleanup (cleanup_tty
, ttystate
);
689 mask
= serial_wait_2 (tty_desc
, port_desc
, -1);
697 c
= serial_readchar (tty_desc
, 0);
699 if (c
== SERIAL_TIMEOUT
)
703 perror_with_name (_("connect"));
706 serial_write (port_desc
, &cx
, 1);
721 if (c
== '.' || c
== '\004')
735 c
= serial_readchar (port_desc
, 0);
737 if (c
== SERIAL_TIMEOUT
)
741 perror_with_name (_("connect"));
745 serial_write (tty_desc
, &cx
, 1);
752 /* Serial set/show framework. */
754 static struct cmd_list_element
*serial_set_cmdlist
;
755 static struct cmd_list_element
*serial_show_cmdlist
;
758 serial_set_cmd (char *args
, int from_tty
)
760 printf_unfiltered ("\"set serial\" must be followed "
761 "by the name of a command.\n");
762 help_list (serial_set_cmdlist
, "set serial ", -1, gdb_stdout
);
766 serial_show_cmd (char *args
, int from_tty
)
768 cmd_show_list (serial_show_cmdlist
, from_tty
, "");
773 _initialize_serial (void)
776 add_com ("connect", class_obscure
, connect_command
, _("\
777 Connect the terminal directly up to the command monitor.\n\
778 Use <CR>~. or <CR>~^D to break out."));
781 add_prefix_cmd ("serial", class_maintenance
, serial_set_cmd
, _("\
782 Set default serial/parallel port configuration."),
783 &serial_set_cmdlist
, "set serial ",
787 add_prefix_cmd ("serial", class_maintenance
, serial_show_cmd
, _("\
788 Show default serial/parallel port configuration."),
789 &serial_show_cmdlist
, "show serial ",
793 add_setshow_filename_cmd ("remotelogfile", no_class
, &serial_logfile
, _("\
794 Set filename for remote session recording."), _("\
795 Show filename for remote session recording."), _("\
796 This file is used to record the remote session for future playback\n\
799 NULL
, /* FIXME: i18n: */
800 &setlist
, &showlist
);
802 add_setshow_enum_cmd ("remotelogbase", no_class
, logbase_enums
,
803 &serial_logbase
, _("\
804 Set numerical base for remote session logging"), _("\
805 Show numerical base for remote session logging"), NULL
,
807 NULL
, /* FIXME: i18n: */
808 &setlist
, &showlist
);
810 add_setshow_zinteger_cmd ("serial", class_maintenance
,
811 &global_serial_debug_p
, _("\
812 Set serial debugging."), _("\
813 Show serial debugging."), _("\
814 When non-zero, serial port debugging is enabled."),
816 NULL
, /* FIXME: i18n: */
817 &setdebuglist
, &showdebuglist
);