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
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 (char *);
53 static void serial_logchar (struct ui_file
*stream
, int ch_type
, int ch
, int timeout
);
54 static const char logbase_hex
[] = "hex";
55 static const char logbase_octal
[] = "octal";
56 static const char logbase_ascii
[] = "ascii";
57 static const char *logbase_enums
[] =
58 {logbase_hex
, logbase_octal
, logbase_ascii
, NULL
};
59 static const char *serial_logbase
= logbase_ascii
;
62 static int serial_current_type
= 0;
64 /* Log char CH of type CHTYPE, with TIMEOUT */
66 /* Define bogus char to represent a BREAK. Should be careful to choose a value
67 that can't be confused with a normal char, or an error code. */
68 #define SERIAL_BREAK 1235
71 serial_logchar (struct ui_file
*stream
, int ch_type
, int ch
, int timeout
)
73 if (ch_type
!= serial_current_type
)
75 fprintf_unfiltered (stream
, "\n%c ", ch_type
);
76 serial_current_type
= ch_type
;
79 if (serial_logbase
!= logbase_ascii
)
80 fputc_unfiltered (' ', stream
);
85 fprintf_unfiltered (stream
, "<Timeout: %d seconds>", timeout
);
88 fprintf_unfiltered (stream
, "<Error: %s>", safe_strerror (errno
));
91 fputs_unfiltered ("<Eof>", stream
);
94 fputs_unfiltered ("<Break>", stream
);
97 if (serial_logbase
== logbase_hex
)
98 fprintf_unfiltered (stream
, "%02x", ch
& 0xff);
99 else if (serial_logbase
== logbase_octal
)
100 fprintf_unfiltered (stream
, "%03o", ch
& 0xff);
105 fputs_unfiltered ("\\\\", stream
);
108 fputs_unfiltered ("\\b", stream
);
111 fputs_unfiltered ("\\f", stream
);
114 fputs_unfiltered ("\\n", stream
);
117 fputs_unfiltered ("\\r", stream
);
120 fputs_unfiltered ("\\t", stream
);
123 fputs_unfiltered ("\\v", stream
);
126 fprintf_unfiltered (stream
, isprint (ch
) ? "%c" : "\\x%02x", ch
& 0xFF);
133 serial_log_command (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 struct serial_ops
*
150 serial_interface_lookup (char *name
)
152 struct serial_ops
*ops
;
154 for (ops
= serial_ops_list
; ops
; ops
= ops
->next
)
155 if (strcmp (name
, ops
->name
) == 0)
162 serial_add_interface (struct serial_ops
*optable
)
164 optable
->next
= serial_ops_list
;
165 serial_ops_list
= optable
;
168 /* Open up a device or a network socket, depending upon the syntax of NAME. */
171 serial_open (const char *name
)
174 struct serial_ops
*ops
;
175 const char *open_name
= name
;
177 for (scb
= scb_base
; scb
; scb
= scb
->next
)
178 if (scb
->name
&& strcmp (scb
->name
, name
) == 0)
184 if (strcmp (name
, "pc") == 0)
185 ops
= serial_interface_lookup ("pc");
186 else if (strncmp (name
, "lpt", 3) == 0)
187 ops
= serial_interface_lookup ("parallel");
188 else if (strncmp (name
, "|", 1) == 0)
190 ops
= serial_interface_lookup ("pipe");
191 /* Discard ``|'' and any space before the command itself. */
193 while (isspace (*open_name
))
196 /* Check for a colon, suggesting an IP address/port pair.
197 Do this *after* checking for all the interesting prefixes. We
198 don't want to constrain the syntax of what can follow them. */
199 else if (strchr (name
, ':'))
200 ops
= serial_interface_lookup ("tcp");
202 ops
= serial_interface_lookup ("hardwire");
207 scb
= XMALLOC (struct serial
);
212 scb
->bufp
= scb
->buf
;
215 /* `...->open (...)' would get expanded by an the open(2) syscall macro. */
216 if ((*scb
->ops
->open
) (scb
, open_name
))
222 scb
->name
= xstrdup (name
);
223 scb
->next
= scb_base
;
226 scb
->async_state
= 0;
227 scb
->async_handler
= NULL
;
228 scb
->async_context
= NULL
;
231 last_serial_opened
= scb
;
233 if (serial_logfile
!= NULL
)
235 serial_logfp
= gdb_fopen (serial_logfile
, "w");
236 if (serial_logfp
== NULL
)
237 perror_with_name (serial_logfile
);
243 /* Return the open serial device for FD, if found, or NULL if FD
244 is not already opened. */
247 serial_for_fd (int fd
)
251 for (scb
= scb_base
; scb
; scb
= scb
->next
)
259 serial_fdopen (const int fd
)
262 struct serial_ops
*ops
;
264 for (scb
= scb_base
; scb
; scb
= scb
->next
)
271 ops
= serial_interface_lookup ("terminal");
273 ops
= serial_interface_lookup ("hardwire");
278 scb
= XCALLOC (1, struct serial
);
283 scb
->bufp
= scb
->buf
;
288 scb
->next
= scb_base
;
291 scb
->async_state
= 0;
292 scb
->async_handler
= NULL
;
293 scb
->async_context
= NULL
;
296 last_serial_opened
= scb
;
302 do_serial_close (struct serial
*scb
, int really_close
)
304 struct serial
*tmp_scb
;
306 last_serial_opened
= NULL
;
310 fputs_unfiltered ("\nEnd of log\n", serial_logfp
);
311 serial_current_type
= 0;
313 /* XXX - What if serial_logfp == gdb_stdout or gdb_stderr? */
314 ui_file_delete (serial_logfp
);
318 /* This is bogus. It's not our fault if you pass us a bad scb...! Rob, you
319 should fix your code instead. */
328 /* ensure that the FD has been taken out of async mode */
329 if (scb
->async_handler
!= NULL
)
330 serial_async (scb
, NULL
, NULL
);
333 scb
->ops
->close (scb
);
339 scb_base
= scb_base
->next
;
341 for (tmp_scb
= scb_base
; tmp_scb
; tmp_scb
= tmp_scb
->next
)
343 if (tmp_scb
->next
!= scb
)
346 tmp_scb
->next
= tmp_scb
->next
->next
;
354 serial_close (struct serial
*scb
)
356 do_serial_close (scb
, 1);
360 serial_un_fdopen (struct serial
*scb
)
362 do_serial_close (scb
, 0);
366 serial_readchar (struct serial
*scb
, int timeout
)
370 /* FIXME: cagney/1999-10-11: Don't enable this check until the ASYNC
372 if (0 && serial_is_async_p (scb
) && timeout
< 0)
373 internal_error (__FILE__
, __LINE__
,
374 _("serial_readchar: blocking read in async mode"));
376 ch
= scb
->ops
->readchar (scb
, timeout
);
377 if (serial_logfp
!= NULL
)
379 serial_logchar (serial_logfp
, 'r', ch
, timeout
);
381 /* Make sure that the log file is as up-to-date as possible,
382 in case we are getting ready to dump core or something. */
383 gdb_flush (serial_logfp
);
385 if (serial_debug_p (scb
))
387 fprintf_unfiltered (gdb_stdlog
, "[");
388 serial_logchar (gdb_stdlog
, 'r', ch
, timeout
);
389 fprintf_unfiltered (gdb_stdlog
, "]");
390 gdb_flush (gdb_stdlog
);
397 serial_write (struct serial
*scb
, const char *str
, int len
)
399 if (serial_logfp
!= NULL
)
403 for (count
= 0; count
< len
; count
++)
404 serial_logchar (serial_logfp
, 'w', str
[count
] & 0xff, 0);
406 /* Make sure that the log file is as up-to-date as possible,
407 in case we are getting ready to dump core or something. */
408 gdb_flush (serial_logfp
);
410 if (serial_debug_p (scb
))
414 for (count
= 0; count
< len
; count
++)
416 fprintf_unfiltered (gdb_stdlog
, "[");
417 serial_logchar (gdb_stdlog
, 'w', str
[count
] & 0xff, 0);
418 fprintf_unfiltered (gdb_stdlog
, "]");
420 gdb_flush (gdb_stdlog
);
423 return (scb
->ops
->write (scb
, str
, len
));
427 serial_printf (struct serial
*desc
, const char *format
,...)
431 va_start (args
, format
);
433 buf
= xstrvprintf (format
, args
);
434 serial_write (desc
, buf
, strlen (buf
));
441 serial_drain_output (struct serial
*scb
)
443 return scb
->ops
->drain_output (scb
);
447 serial_flush_output (struct serial
*scb
)
449 return scb
->ops
->flush_output (scb
);
453 serial_flush_input (struct serial
*scb
)
455 return scb
->ops
->flush_input (scb
);
459 serial_send_break (struct serial
*scb
)
461 if (serial_logfp
!= NULL
)
462 serial_logchar (serial_logfp
, 'w', SERIAL_BREAK
, 0);
464 return (scb
->ops
->send_break (scb
));
468 serial_raw (struct serial
*scb
)
470 scb
->ops
->go_raw (scb
);
474 serial_get_tty_state (struct serial
*scb
)
476 return scb
->ops
->get_tty_state (scb
);
480 serial_set_tty_state (struct serial
*scb
, serial_ttystate ttystate
)
482 return scb
->ops
->set_tty_state (scb
, ttystate
);
486 serial_print_tty_state (struct serial
*scb
,
487 serial_ttystate ttystate
,
488 struct ui_file
*stream
)
490 scb
->ops
->print_tty_state (scb
, ttystate
, stream
);
494 serial_noflush_set_tty_state (struct serial
*scb
,
495 serial_ttystate new_ttystate
,
496 serial_ttystate old_ttystate
)
498 return scb
->ops
->noflush_set_tty_state (scb
, new_ttystate
, old_ttystate
);
502 serial_setbaudrate (struct serial
*scb
, int rate
)
504 return scb
->ops
->setbaudrate (scb
, rate
);
508 serial_setstopbits (struct serial
*scb
, int num
)
510 return scb
->ops
->setstopbits (scb
, num
);
514 serial_can_async_p (struct serial
*scb
)
516 return (scb
->ops
->async
!= NULL
);
520 serial_is_async_p (struct serial
*scb
)
522 return (scb
->ops
->async
!= NULL
) && (scb
->async_handler
!= NULL
);
526 serial_async (struct serial
*scb
,
527 serial_event_ftype
*handler
,
530 int changed
= ((scb
->async_handler
== NULL
) != (handler
== NULL
));
532 scb
->async_handler
= handler
;
533 scb
->async_context
= context
;
534 /* Only change mode if there is a need. */
536 scb
->ops
->async (scb
, handler
!= NULL
);
540 deprecated_serial_fd (struct serial
*scb
)
542 /* FIXME: should this output a warning that deprecated code is being
546 internal_error (__FILE__
, __LINE__
,
547 _("serial: FD not valid"));
549 return scb
->fd
; /* sigh */
553 serial_debug (struct serial
*scb
, int debug_p
)
555 scb
->debug_p
= debug_p
;
559 serial_debug_p (struct serial
*scb
)
561 return scb
->debug_p
|| global_serial_debug_p
;
566 serial_wait_handle (struct serial
*scb
, HANDLE
*read
, HANDLE
*except
)
568 if (scb
->ops
->wait_handle
)
569 scb
->ops
->wait_handle (scb
, read
, except
);
572 *read
= (HANDLE
) _get_osfhandle (scb
->fd
);
578 serial_done_wait_handle (struct serial
*scb
)
580 if (scb
->ops
->done_wait_handle
)
581 scb
->ops
->done_wait_handle (scb
);
586 /* The connect command is #if 0 because I hadn't thought of an elegant
587 way to wait for I/O on two `struct serial *'s simultaneously. Two
588 solutions came to mind:
590 1) Fork, and have have one fork handle the to user direction,
591 and have the other hand the to target direction. This
592 obviously won't cut it for MSDOS.
594 2) Use something like select. This assumes that stdin and
595 the target side can both be waited on via the same
596 mechanism. This may not be true for DOS, if GDB is
597 talking to the target via a TCP socket.
598 -grossman, 8 Jun 93 */
600 /* Connect the user directly to the remote system. This command acts just like
601 the 'cu' or 'tip' command. Use <CR>~. or <CR>~^D to break out. */
603 static struct serial
*tty_desc
; /* Controlling terminal */
606 cleanup_tty (serial_ttystate ttystate
)
608 printf_unfiltered ("\r\n[Exiting connect mode]\r\n");
609 serial_set_tty_state (tty_desc
, ttystate
);
611 serial_close (tty_desc
);
615 connect_command (char *args
, int fromtty
)
619 serial_ttystate ttystate
;
620 struct serial
*port_desc
; /* TTY port */
625 fprintf_unfiltered (gdb_stderr
, "This command takes no args. They have been ignored.\n");
627 printf_unfiltered ("[Entering connect mode. Use ~. or ~^D to escape]\n");
629 tty_desc
= serial_fdopen (0);
630 port_desc
= last_serial_opened
;
632 ttystate
= serial_get_tty_state (tty_desc
);
634 serial_raw (tty_desc
);
635 serial_raw (port_desc
);
637 make_cleanup (cleanup_tty
, ttystate
);
643 mask
= serial_wait_2 (tty_desc
, port_desc
, -1);
651 c
= serial_readchar (tty_desc
, 0);
653 if (c
== SERIAL_TIMEOUT
)
657 perror_with_name (_("connect"));
660 serial_write (port_desc
, &cx
, 1);
675 if (c
== '.' || c
== '\004')
689 c
= serial_readchar (port_desc
, 0);
691 if (c
== SERIAL_TIMEOUT
)
695 perror_with_name (_("connect"));
699 serial_write (tty_desc
, &cx
, 1);
706 /* Serial set/show framework. */
708 static struct cmd_list_element
*serial_set_cmdlist
;
709 static struct cmd_list_element
*serial_show_cmdlist
;
712 serial_set_cmd (char *args
, int from_tty
)
714 printf_unfiltered ("\"set serial\" must be followed by the name of a command.\n");
715 help_list (serial_set_cmdlist
, "set serial ", -1, gdb_stdout
);
719 serial_show_cmd (char *args
, int from_tty
)
721 cmd_show_list (serial_show_cmdlist
, from_tty
, "");
726 _initialize_serial (void)
729 add_com ("connect", class_obscure
, connect_command
, _("\
730 Connect the terminal directly up to the command monitor.\n\
731 Use <CR>~. or <CR>~^D to break out."));
734 add_prefix_cmd ("serial", class_maintenance
, serial_set_cmd
, _("\
735 Set default serial/parallel port configuration."),
736 &serial_set_cmdlist
, "set serial ",
740 add_prefix_cmd ("serial", class_maintenance
, serial_show_cmd
, _("\
741 Show default serial/parallel port configuration."),
742 &serial_show_cmdlist
, "show serial ",
746 add_setshow_filename_cmd ("remotelogfile", no_class
, &serial_logfile
, _("\
747 Set filename for remote session recording."), _("\
748 Show filename for remote session recording."), _("\
749 This file is used to record the remote session for future playback\n\
752 NULL
, /* FIXME: i18n: */
753 &setlist
, &showlist
);
755 add_setshow_enum_cmd ("remotelogbase", no_class
, logbase_enums
,
756 &serial_logbase
, _("\
757 Set numerical base for remote session logging"), _("\
758 Show numerical base for remote session logging"), NULL
,
760 NULL
, /* FIXME: i18n: */
761 &setlist
, &showlist
);
763 add_setshow_zinteger_cmd ("serial", class_maintenance
,
764 &global_serial_debug_p
, _("\
765 Set serial debugging."), _("\
766 Show serial debugging."), _("\
767 When non-zero, serial port debugging is enabled."),
769 NULL
, /* FIXME: i18n: */
770 &setdebuglist
, &showdebuglist
);