1 /* Generic serial interface routines
3 Copyright (C) 1992-2002, 2004-2012 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/>. */
23 #include "gdb_string.h"
26 extern void _initialize_serial (void);
28 /* Is serial being debugged? */
30 static int global_serial_debug_p
;
32 /* Linked list of serial I/O handlers. */
34 static struct serial_ops
*serial_ops_list
= NULL
;
36 /* This is the last serial stream opened. Used by connect command. */
38 static struct serial
*last_serial_opened
= 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 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 (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 (const 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 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
)
258 /* Open a new serial stream using a file handle, using serial
259 interface ops OPS. */
261 static struct serial
*
262 serial_fdopen_ops (const int fd
, struct serial_ops
*ops
)
266 scb
= serial_for_fd (fd
);
275 ops
= serial_interface_lookup ("terminal");
277 ops
= serial_interface_lookup ("hardwire");
283 scb
= XCALLOC (1, struct serial
);
288 scb
->bufp
= scb
->buf
;
292 scb
->next
= scb_base
;
295 scb
->async_state
= 0;
296 scb
->async_handler
= NULL
;
297 scb
->async_context
= NULL
;
300 if ((ops
->fdopen
) != NULL
)
301 (*ops
->fdopen
) (scb
, fd
);
305 last_serial_opened
= scb
;
311 serial_fdopen (const int fd
)
313 return serial_fdopen_ops (fd
, NULL
);
317 do_serial_close (struct serial
*scb
, int really_close
)
319 struct serial
*tmp_scb
;
321 last_serial_opened
= NULL
;
325 fputs_unfiltered ("\nEnd of log\n", serial_logfp
);
326 serial_current_type
= 0;
328 /* XXX - What if serial_logfp == gdb_stdout or gdb_stderr? */
329 ui_file_delete (serial_logfp
);
337 /* ensure that the FD has been taken out of async mode. */
338 if (scb
->async_handler
!= NULL
)
339 serial_async (scb
, NULL
, NULL
);
342 scb
->ops
->close (scb
);
348 scb_base
= scb_base
->next
;
350 for (tmp_scb
= scb_base
; tmp_scb
; tmp_scb
= tmp_scb
->next
)
352 if (tmp_scb
->next
!= scb
)
355 tmp_scb
->next
= tmp_scb
->next
->next
;
363 serial_close (struct serial
*scb
)
365 do_serial_close (scb
, 1);
369 serial_un_fdopen (struct serial
*scb
)
371 do_serial_close (scb
, 0);
375 serial_readchar (struct serial
*scb
, int timeout
)
379 /* FIXME: cagney/1999-10-11: Don't enable this check until the ASYNC
381 if (0 && serial_is_async_p (scb
) && timeout
< 0)
382 internal_error (__FILE__
, __LINE__
,
383 _("serial_readchar: blocking read in async mode"));
385 ch
= scb
->ops
->readchar (scb
, timeout
);
386 if (serial_logfp
!= NULL
)
388 serial_logchar (serial_logfp
, 'r', ch
, timeout
);
390 /* Make sure that the log file is as up-to-date as possible,
391 in case we are getting ready to dump core or something. */
392 gdb_flush (serial_logfp
);
394 if (serial_debug_p (scb
))
396 fprintf_unfiltered (gdb_stdlog
, "[");
397 serial_logchar (gdb_stdlog
, 'r', ch
, timeout
);
398 fprintf_unfiltered (gdb_stdlog
, "]");
399 gdb_flush (gdb_stdlog
);
406 serial_write (struct serial
*scb
, const char *str
, int len
)
408 if (serial_logfp
!= NULL
)
412 for (count
= 0; count
< len
; count
++)
413 serial_logchar (serial_logfp
, 'w', str
[count
] & 0xff, 0);
415 /* Make sure that the log file is as up-to-date as possible,
416 in case we are getting ready to dump core or something. */
417 gdb_flush (serial_logfp
);
419 if (serial_debug_p (scb
))
423 for (count
= 0; count
< len
; count
++)
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
, str
, len
));
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 deprecated_serial_fd (struct serial
*scb
)
557 /* FIXME: should this output a warning that deprecated code is being
561 internal_error (__FILE__
, __LINE__
,
562 _("serial: FD not valid"));
564 return scb
->fd
; /* sigh */
568 serial_debug (struct serial
*scb
, int debug_p
)
570 scb
->debug_p
= debug_p
;
574 serial_debug_p (struct serial
*scb
)
576 return scb
->debug_p
|| global_serial_debug_p
;
581 serial_wait_handle (struct serial
*scb
, HANDLE
*read
, HANDLE
*except
)
583 if (scb
->ops
->wait_handle
)
584 scb
->ops
->wait_handle (scb
, read
, except
);
587 *read
= (HANDLE
) _get_osfhandle (scb
->fd
);
593 serial_done_wait_handle (struct serial
*scb
)
595 if (scb
->ops
->done_wait_handle
)
596 scb
->ops
->done_wait_handle (scb
);
601 serial_pipe (struct serial
*scbs
[2])
603 struct serial_ops
*ops
;
606 ops
= serial_interface_lookup ("pipe");
613 if (gdb_pipe (fildes
) == -1)
616 scbs
[0] = serial_fdopen_ops (fildes
[0], ops
);
617 scbs
[1] = serial_fdopen_ops (fildes
[1], ops
);
622 /* The connect command is #if 0 because I hadn't thought of an elegant
623 way to wait for I/O on two `struct serial *'s simultaneously. Two
624 solutions came to mind:
626 1) Fork, and have have one fork handle the to user direction,
627 and have the other hand the to target direction. This
628 obviously won't cut it for MSDOS.
630 2) Use something like select. This assumes that stdin and
631 the target side can both be waited on via the same
632 mechanism. This may not be true for DOS, if GDB is
633 talking to the target via a TCP socket.
634 -grossman, 8 Jun 93 */
636 /* Connect the user directly to the remote system. This command acts just like
637 the 'cu' or 'tip' command. Use <CR>~. or <CR>~^D to break out. */
639 static struct serial
*tty_desc
; /* Controlling terminal */
642 cleanup_tty (serial_ttystate ttystate
)
644 printf_unfiltered ("\r\n[Exiting connect mode]\r\n");
645 serial_set_tty_state (tty_desc
, ttystate
);
647 serial_close (tty_desc
);
651 connect_command (char *args
, int fromtty
)
655 serial_ttystate ttystate
;
656 struct serial
*port_desc
; /* TTY port */
661 fprintf_unfiltered (gdb_stderr
,
662 "This command takes no args. "
663 "They have been ignored.\n");
665 printf_unfiltered ("[Entering connect mode. Use ~. or ~^D to escape]\n");
667 tty_desc
= serial_fdopen (0);
668 port_desc
= last_serial_opened
;
670 ttystate
= serial_get_tty_state (tty_desc
);
672 serial_raw (tty_desc
);
673 serial_raw (port_desc
);
675 make_cleanup (cleanup_tty
, ttystate
);
681 mask
= serial_wait_2 (tty_desc
, port_desc
, -1);
689 c
= serial_readchar (tty_desc
, 0);
691 if (c
== SERIAL_TIMEOUT
)
695 perror_with_name (_("connect"));
698 serial_write (port_desc
, &cx
, 1);
713 if (c
== '.' || c
== '\004')
727 c
= serial_readchar (port_desc
, 0);
729 if (c
== SERIAL_TIMEOUT
)
733 perror_with_name (_("connect"));
737 serial_write (tty_desc
, &cx
, 1);
744 /* Serial set/show framework. */
746 static struct cmd_list_element
*serial_set_cmdlist
;
747 static struct cmd_list_element
*serial_show_cmdlist
;
750 serial_set_cmd (char *args
, int from_tty
)
752 printf_unfiltered ("\"set serial\" must be followed "
753 "by the name of a command.\n");
754 help_list (serial_set_cmdlist
, "set serial ", -1, gdb_stdout
);
758 serial_show_cmd (char *args
, int from_tty
)
760 cmd_show_list (serial_show_cmdlist
, from_tty
, "");
765 _initialize_serial (void)
768 add_com ("connect", class_obscure
, connect_command
, _("\
769 Connect the terminal directly up to the command monitor.\n\
770 Use <CR>~. or <CR>~^D to break out."));
773 add_prefix_cmd ("serial", class_maintenance
, serial_set_cmd
, _("\
774 Set default serial/parallel port configuration."),
775 &serial_set_cmdlist
, "set serial ",
779 add_prefix_cmd ("serial", class_maintenance
, serial_show_cmd
, _("\
780 Show default serial/parallel port configuration."),
781 &serial_show_cmdlist
, "show serial ",
785 add_setshow_filename_cmd ("remotelogfile", no_class
, &serial_logfile
, _("\
786 Set filename for remote session recording."), _("\
787 Show filename for remote session recording."), _("\
788 This file is used to record the remote session for future playback\n\
791 NULL
, /* FIXME: i18n: */
792 &setlist
, &showlist
);
794 add_setshow_enum_cmd ("remotelogbase", no_class
, logbase_enums
,
795 &serial_logbase
, _("\
796 Set numerical base for remote session logging"), _("\
797 Show numerical base for remote session logging"), NULL
,
799 NULL
, /* FIXME: i18n: */
800 &setlist
, &showlist
);
802 add_setshow_zinteger_cmd ("serial", class_maintenance
,
803 &global_serial_debug_p
, _("\
804 Set serial debugging."), _("\
805 Show serial debugging."), _("\
806 When non-zero, serial port debugging is enabled."),
808 NULL
, /* FIXME: i18n: */
809 &setdebuglist
, &showdebuglist
);