1 /* Generic serial interface routines
3 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
4 2002, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA. */
26 #include "gdb_string.h"
29 extern void _initialize_serial (void);
31 /* Is serial being debugged? */
33 static int global_serial_debug_p
;
35 /* Linked list of serial I/O handlers */
37 static struct serial_ops
*serial_ops_list
= NULL
;
39 /* This is the last serial stream opened. Used by connect command. */
41 static struct serial
*last_serial_opened
= NULL
;
43 /* Pointer to list of scb's. */
45 static struct serial
*scb_base
;
47 /* Non-NULL gives filename which contains a recording of the remote session,
48 suitable for playback by gdbserver. */
50 static char *serial_logfile
= NULL
;
51 static struct ui_file
*serial_logfp
= NULL
;
53 static struct serial_ops
*serial_interface_lookup (char *);
54 static void serial_logchar (struct ui_file
*stream
, 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
, isprint (ch
) ? "%c" : "\\x%02x", ch
& 0xFF);
134 serial_log_command (const char *cmd
)
139 serial_current_type
= 'c';
141 fputs_unfiltered ("\nc ", serial_logfp
);
142 fputs_unfiltered (cmd
, serial_logfp
);
144 /* Make sure that the log file is as up-to-date as possible,
145 in case we are getting ready to dump core or something. */
146 gdb_flush (serial_logfp
);
150 static struct serial_ops
*
151 serial_interface_lookup (char *name
)
153 struct serial_ops
*ops
;
155 for (ops
= serial_ops_list
; ops
; ops
= ops
->next
)
156 if (strcmp (name
, ops
->name
) == 0)
163 serial_add_interface (struct serial_ops
*optable
)
165 optable
->next
= serial_ops_list
;
166 serial_ops_list
= optable
;
169 /* Open up a device or a network socket, depending upon the syntax of NAME. */
172 serial_open (const char *name
)
175 struct serial_ops
*ops
;
176 const char *open_name
= name
;
178 for (scb
= scb_base
; scb
; scb
= scb
->next
)
179 if (scb
->name
&& strcmp (scb
->name
, name
) == 0)
185 if (strcmp (name
, "pc") == 0)
186 ops
= serial_interface_lookup ("pc");
187 else if (strncmp (name
, "lpt", 3) == 0)
188 ops
= serial_interface_lookup ("parallel");
189 else if (strncmp (name
, "|", 1) == 0)
191 ops
= serial_interface_lookup ("pipe");
192 /* Discard ``|'' and any space before the command itself. */
194 while (isspace (*open_name
))
197 /* Check for a colon, suggesting an IP address/port pair.
198 Do this *after* checking for all the interesting prefixes. We
199 don't want to constrain the syntax of what can follow them. */
200 else if (strchr (name
, ':'))
201 ops
= serial_interface_lookup ("tcp");
203 ops
= serial_interface_lookup ("hardwire");
208 scb
= XMALLOC (struct serial
);
213 scb
->bufp
= scb
->buf
;
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
)
250 struct serial_ops
*ops
;
252 for (scb
= scb_base
; scb
; scb
= scb
->next
)
260 serial_fdopen (const int fd
)
263 struct serial_ops
*ops
;
265 for (scb
= scb_base
; scb
; scb
= scb
->next
)
272 ops
= serial_interface_lookup ("terminal");
274 ops
= serial_interface_lookup ("hardwire");
279 scb
= XCALLOC (1, struct serial
);
284 scb
->bufp
= scb
->buf
;
289 scb
->next
= scb_base
;
292 scb
->async_state
= 0;
293 scb
->async_handler
= NULL
;
294 scb
->async_context
= NULL
;
297 last_serial_opened
= scb
;
303 do_serial_close (struct serial
*scb
, int really_close
)
305 struct serial
*tmp_scb
;
307 last_serial_opened
= NULL
;
311 fputs_unfiltered ("\nEnd of log\n", serial_logfp
);
312 serial_current_type
= 0;
314 /* XXX - What if serial_logfp == gdb_stdout or gdb_stderr? */
315 ui_file_delete (serial_logfp
);
319 /* This is bogus. It's not our fault if you pass us a bad scb...! Rob, you
320 should fix your code instead. */
329 /* ensure that the FD has been taken out of async mode */
330 if (scb
->async_handler
!= NULL
)
331 serial_async (scb
, NULL
, NULL
);
334 scb
->ops
->close (scb
);
340 scb_base
= scb_base
->next
;
342 for (tmp_scb
= scb_base
; tmp_scb
; tmp_scb
= tmp_scb
->next
)
344 if (tmp_scb
->next
!= scb
)
347 tmp_scb
->next
= tmp_scb
->next
->next
;
355 serial_close (struct serial
*scb
)
357 do_serial_close (scb
, 1);
361 serial_un_fdopen (struct serial
*scb
)
363 do_serial_close (scb
, 0);
367 serial_readchar (struct serial
*scb
, int timeout
)
371 /* FIXME: cagney/1999-10-11: Don't enable this check until the ASYNC
373 if (0 && serial_is_async_p (scb
) && timeout
< 0)
374 internal_error (__FILE__
, __LINE__
,
375 _("serial_readchar: blocking read in async mode"));
377 ch
= scb
->ops
->readchar (scb
, timeout
);
378 if (serial_logfp
!= NULL
)
380 serial_logchar (serial_logfp
, 'r', ch
, timeout
);
382 /* Make sure that the log file is as up-to-date as possible,
383 in case we are getting ready to dump core or something. */
384 gdb_flush (serial_logfp
);
386 if (serial_debug_p (scb
))
388 fprintf_unfiltered (gdb_stdlog
, "[");
389 serial_logchar (gdb_stdlog
, 'r', ch
, timeout
);
390 fprintf_unfiltered (gdb_stdlog
, "]");
391 gdb_flush (gdb_stdlog
);
398 serial_write (struct serial
*scb
, const char *str
, int len
)
400 if (serial_logfp
!= NULL
)
404 for (count
= 0; count
< len
; count
++)
405 serial_logchar (serial_logfp
, 'w', str
[count
] & 0xff, 0);
407 /* Make sure that the log file is as up-to-date as possible,
408 in case we are getting ready to dump core or something. */
409 gdb_flush (serial_logfp
);
412 return (scb
->ops
->write (scb
, str
, len
));
416 serial_printf (struct serial
*desc
, const char *format
,...)
420 va_start (args
, format
);
422 buf
= xstrvprintf (format
, args
);
423 serial_write (desc
, buf
, strlen (buf
));
430 serial_drain_output (struct serial
*scb
)
432 return scb
->ops
->drain_output (scb
);
436 serial_flush_output (struct serial
*scb
)
438 return scb
->ops
->flush_output (scb
);
442 serial_flush_input (struct serial
*scb
)
444 return scb
->ops
->flush_input (scb
);
448 serial_send_break (struct serial
*scb
)
450 if (serial_logfp
!= NULL
)
451 serial_logchar (serial_logfp
, 'w', SERIAL_BREAK
, 0);
453 return (scb
->ops
->send_break (scb
));
457 serial_raw (struct serial
*scb
)
459 scb
->ops
->go_raw (scb
);
463 serial_get_tty_state (struct serial
*scb
)
465 return scb
->ops
->get_tty_state (scb
);
469 serial_set_tty_state (struct serial
*scb
, serial_ttystate ttystate
)
471 return scb
->ops
->set_tty_state (scb
, ttystate
);
475 serial_print_tty_state (struct serial
*scb
,
476 serial_ttystate ttystate
,
477 struct ui_file
*stream
)
479 scb
->ops
->print_tty_state (scb
, ttystate
, stream
);
483 serial_noflush_set_tty_state (struct serial
*scb
,
484 serial_ttystate new_ttystate
,
485 serial_ttystate old_ttystate
)
487 return scb
->ops
->noflush_set_tty_state (scb
, new_ttystate
, old_ttystate
);
491 serial_setbaudrate (struct serial
*scb
, int rate
)
493 return scb
->ops
->setbaudrate (scb
, rate
);
497 serial_setstopbits (struct serial
*scb
, int num
)
499 return scb
->ops
->setstopbits (scb
, num
);
503 serial_can_async_p (struct serial
*scb
)
505 return (scb
->ops
->async
!= NULL
);
509 serial_is_async_p (struct serial
*scb
)
511 return (scb
->ops
->async
!= NULL
) && (scb
->async_handler
!= NULL
);
515 serial_async (struct serial
*scb
,
516 serial_event_ftype
*handler
,
519 /* Only change mode if there is a need. */
520 if ((scb
->async_handler
== NULL
)
521 != (handler
== NULL
))
522 scb
->ops
->async (scb
, handler
!= NULL
);
523 scb
->async_handler
= handler
;
524 scb
->async_context
= context
;
528 deprecated_serial_fd (struct serial
*scb
)
530 /* FIXME: should this output a warning that deprecated code is being
534 internal_error (__FILE__
, __LINE__
,
535 _("serial: FD not valid"));
537 return scb
->fd
; /* sigh */
541 serial_debug (struct serial
*scb
, int debug_p
)
543 scb
->debug_p
= debug_p
;
547 serial_debug_p (struct serial
*scb
)
549 return scb
->debug_p
|| global_serial_debug_p
;
554 serial_wait_handle (struct serial
*scb
, HANDLE
*read
, HANDLE
*except
)
556 if (scb
->ops
->wait_handle
)
557 scb
->ops
->wait_handle (scb
, read
, except
);
560 *read
= (HANDLE
) _get_osfhandle (scb
->fd
);
566 serial_done_wait_handle (struct serial
*scb
)
568 if (scb
->ops
->done_wait_handle
)
569 scb
->ops
->done_wait_handle (scb
);
574 /* The connect command is #if 0 because I hadn't thought of an elegant
575 way to wait for I/O on two `struct serial *'s simultaneously. Two
576 solutions came to mind:
578 1) Fork, and have have one fork handle the to user direction,
579 and have the other hand the to target direction. This
580 obviously won't cut it for MSDOS.
582 2) Use something like select. This assumes that stdin and
583 the target side can both be waited on via the same
584 mechanism. This may not be true for DOS, if GDB is
585 talking to the target via a TCP socket.
586 -grossman, 8 Jun 93 */
588 /* Connect the user directly to the remote system. This command acts just like
589 the 'cu' or 'tip' command. Use <CR>~. or <CR>~^D to break out. */
591 static struct serial
*tty_desc
; /* Controlling terminal */
594 cleanup_tty (serial_ttystate ttystate
)
596 printf_unfiltered ("\r\n[Exiting connect mode]\r\n");
597 serial_set_tty_state (tty_desc
, ttystate
);
599 serial_close (tty_desc
);
603 connect_command (char *args
, int fromtty
)
607 serial_ttystate ttystate
;
608 struct serial
*port_desc
; /* TTY port */
613 fprintf_unfiltered (gdb_stderr
, "This command takes no args. They have been ignored.\n");
615 printf_unfiltered ("[Entering connect mode. Use ~. or ~^D to escape]\n");
617 tty_desc
= serial_fdopen (0);
618 port_desc
= last_serial_opened
;
620 ttystate
= serial_get_tty_state (tty_desc
);
622 serial_raw (tty_desc
);
623 serial_raw (port_desc
);
625 make_cleanup (cleanup_tty
, ttystate
);
631 mask
= serial_wait_2 (tty_desc
, port_desc
, -1);
639 c
= serial_readchar (tty_desc
, 0);
641 if (c
== SERIAL_TIMEOUT
)
645 perror_with_name (_("connect"));
648 serial_write (port_desc
, &cx
, 1);
663 if (c
== '.' || c
== '\004')
677 c
= serial_readchar (port_desc
, 0);
679 if (c
== SERIAL_TIMEOUT
)
683 perror_with_name (_("connect"));
687 serial_write (tty_desc
, &cx
, 1);
694 /* Serial set/show framework. */
696 static struct cmd_list_element
*serial_set_cmdlist
;
697 static struct cmd_list_element
*serial_show_cmdlist
;
700 serial_set_cmd (char *args
, int from_tty
)
702 printf_unfiltered ("\"set serial\" must be followed by the name of a command.\n");
703 help_list (serial_set_cmdlist
, "set serial ", -1, gdb_stdout
);
707 serial_show_cmd (char *args
, int from_tty
)
709 cmd_show_list (serial_show_cmdlist
, from_tty
, "");
714 _initialize_serial (void)
717 add_com ("connect", class_obscure
, connect_command
, _("\
718 Connect the terminal directly up to the command monitor.\n\
719 Use <CR>~. or <CR>~^D to break out."));
722 add_prefix_cmd ("serial", class_maintenance
, serial_set_cmd
, _("\
723 Set default serial/parallel port configuration."),
724 &serial_set_cmdlist
, "set serial ",
728 add_prefix_cmd ("serial", class_maintenance
, serial_show_cmd
, _("\
729 Show default serial/parallel port configuration."),
730 &serial_show_cmdlist
, "show serial ",
734 add_setshow_filename_cmd ("remotelogfile", no_class
, &serial_logfile
, _("\
735 Set filename for remote session recording."), _("\
736 Show filename for remote session recording."), _("\
737 This file is used to record the remote session for future playback\n\
740 NULL
, /* FIXME: i18n: */
741 &setlist
, &showlist
);
743 add_setshow_enum_cmd ("remotelogbase", no_class
, logbase_enums
,
744 &serial_logbase
, _("\
745 Set numerical base for remote session logging"), _("\
746 Show numerical base for remote session logging"), NULL
,
748 NULL
, /* FIXME: i18n: */
749 &setlist
, &showlist
);
751 add_setshow_zinteger_cmd ("serial", class_maintenance
,
752 &global_serial_debug_p
, _("\
753 Set serial debugging."), _("\
754 Show serial debugging."), _("\
755 When non-zero, serial port debugging is enabled."),
757 NULL
, /* FIXME: i18n: */
758 &setdebuglist
, &showdebuglist
);