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 /* Non-NULL gives filename which contains a recording of the remote session,
37 suitable for playback by gdbserver. */
39 static char *serial_logfile
= NULL
;
40 static struct ui_file
*serial_logfp
= NULL
;
42 static struct serial_ops
*serial_interface_lookup (const char *);
43 static void serial_logchar (struct ui_file
*stream
,
44 int ch_type
, int ch
, int timeout
);
45 static const char logbase_hex
[] = "hex";
46 static const char logbase_octal
[] = "octal";
47 static const char logbase_ascii
[] = "ascii";
48 static const char *const logbase_enums
[] =
49 {logbase_hex
, logbase_octal
, logbase_ascii
, NULL
};
50 static const char *serial_logbase
= logbase_ascii
;
53 static int serial_current_type
= 0;
55 /* Log char CH of type CHTYPE, with TIMEOUT. */
57 /* Define bogus char to represent a BREAK. Should be careful to choose a value
58 that can't be confused with a normal char, or an error code. */
59 #define SERIAL_BREAK 1235
62 serial_logchar (struct ui_file
*stream
, int ch_type
, int ch
, int timeout
)
64 if (ch_type
!= serial_current_type
)
66 fprintf_unfiltered (stream
, "\n%c ", ch_type
);
67 serial_current_type
= ch_type
;
70 if (serial_logbase
!= logbase_ascii
)
71 fputc_unfiltered (' ', stream
);
76 fprintf_unfiltered (stream
, "<Timeout: %d seconds>", timeout
);
79 fprintf_unfiltered (stream
, "<Error: %s>", safe_strerror (errno
));
82 fputs_unfiltered ("<Eof>", stream
);
85 fputs_unfiltered ("<Break>", stream
);
88 if (serial_logbase
== logbase_hex
)
89 fprintf_unfiltered (stream
, "%02x", ch
& 0xff);
90 else if (serial_logbase
== logbase_octal
)
91 fprintf_unfiltered (stream
, "%03o", ch
& 0xff);
96 fputs_unfiltered ("\\\\", stream
);
99 fputs_unfiltered ("\\b", stream
);
102 fputs_unfiltered ("\\f", stream
);
105 fputs_unfiltered ("\\n", stream
);
108 fputs_unfiltered ("\\r", stream
);
111 fputs_unfiltered ("\\t", stream
);
114 fputs_unfiltered ("\\v", stream
);
117 fprintf_unfiltered (stream
,
118 isprint (ch
) ? "%c" : "\\x%02x", ch
& 0xFF);
125 serial_log_command (const char *cmd
)
130 serial_current_type
= 'c';
132 fputs_unfiltered ("\nc ", serial_logfp
);
133 fputs_unfiltered (cmd
, serial_logfp
);
135 /* Make sure that the log file is as up-to-date as possible,
136 in case we are getting ready to dump core or something. */
137 gdb_flush (serial_logfp
);
141 static struct serial_ops
*
142 serial_interface_lookup (const char *name
)
144 struct serial_ops
*ops
;
146 for (ops
= serial_ops_list
; ops
; ops
= ops
->next
)
147 if (strcmp (name
, ops
->name
) == 0)
154 serial_add_interface (struct serial_ops
*optable
)
156 optable
->next
= serial_ops_list
;
157 serial_ops_list
= optable
;
160 /* Open up a device or a network socket, depending upon the syntax of NAME. */
163 serial_open (const char *name
)
166 struct serial_ops
*ops
;
167 const char *open_name
= name
;
169 if (strcmp (name
, "pc") == 0)
170 ops
= serial_interface_lookup ("pc");
171 else if (strncmp (name
, "lpt", 3) == 0)
172 ops
= serial_interface_lookup ("parallel");
173 else if (strncmp (name
, "|", 1) == 0)
175 ops
= serial_interface_lookup ("pipe");
176 /* Discard ``|'' and any space before the command itself. */
178 while (isspace (*open_name
))
181 /* Check for a colon, suggesting an IP address/port pair.
182 Do this *after* checking for all the interesting prefixes. We
183 don't want to constrain the syntax of what can follow them. */
184 else if (strchr (name
, ':'))
185 ops
= serial_interface_lookup ("tcp");
187 ops
= serial_interface_lookup ("hardwire");
192 scb
= XMALLOC (struct serial
);
197 scb
->bufp
= scb
->buf
;
201 /* `...->open (...)' would get expanded by the open(2) syscall macro. */
202 if ((*scb
->ops
->open
) (scb
, open_name
))
208 scb
->name
= xstrdup (name
);
210 scb
->async_state
= 0;
211 scb
->async_handler
= NULL
;
212 scb
->async_context
= NULL
;
214 if (serial_logfile
!= NULL
)
216 serial_logfp
= gdb_fopen (serial_logfile
, "w");
217 if (serial_logfp
== NULL
)
218 perror_with_name (serial_logfile
);
224 /* Open a new serial stream using a file handle, using serial
225 interface ops OPS. */
227 static struct serial
*
228 serial_fdopen_ops (const int fd
, struct serial_ops
*ops
)
234 ops
= serial_interface_lookup ("terminal");
236 ops
= serial_interface_lookup ("hardwire");
242 scb
= XCALLOC (1, struct serial
);
247 scb
->bufp
= scb
->buf
;
253 scb
->async_state
= 0;
254 scb
->async_handler
= NULL
;
255 scb
->async_context
= NULL
;
257 if ((ops
->fdopen
) != NULL
)
258 (*ops
->fdopen
) (scb
, fd
);
266 serial_fdopen (const int fd
)
268 return serial_fdopen_ops (fd
, NULL
);
272 do_serial_close (struct serial
*scb
, int really_close
)
274 struct serial
*tmp_scb
;
278 fputs_unfiltered ("\nEnd of log\n", serial_logfp
);
279 serial_current_type
= 0;
281 /* XXX - What if serial_logfp == gdb_stdout or gdb_stderr? */
282 ui_file_delete (serial_logfp
);
286 /* ensure that the FD has been taken out of async mode. */
287 if (scb
->async_handler
!= NULL
)
288 serial_async (scb
, NULL
, NULL
);
291 scb
->ops
->close (scb
);
296 /* For serial_is_open. */
303 serial_close (struct serial
*scb
)
305 do_serial_close (scb
, 1);
309 serial_un_fdopen (struct serial
*scb
)
311 do_serial_close (scb
, 0);
315 serial_is_open (struct serial
*scb
)
317 return scb
->bufp
!= NULL
;
321 serial_ref (struct serial
*scb
)
327 serial_unref (struct serial
*scb
)
330 if (scb
->refcnt
== 0)
335 serial_readchar (struct serial
*scb
, int timeout
)
339 /* FIXME: cagney/1999-10-11: Don't enable this check until the ASYNC
341 if (0 && serial_is_async_p (scb
) && timeout
< 0)
342 internal_error (__FILE__
, __LINE__
,
343 _("serial_readchar: blocking read in async mode"));
345 ch
= scb
->ops
->readchar (scb
, timeout
);
346 if (serial_logfp
!= NULL
)
348 serial_logchar (serial_logfp
, 'r', ch
, timeout
);
350 /* Make sure that the log file is as up-to-date as possible,
351 in case we are getting ready to dump core or something. */
352 gdb_flush (serial_logfp
);
354 if (serial_debug_p (scb
))
356 fprintf_unfiltered (gdb_stdlog
, "[");
357 serial_logchar (gdb_stdlog
, 'r', ch
, timeout
);
358 fprintf_unfiltered (gdb_stdlog
, "]");
359 gdb_flush (gdb_stdlog
);
366 serial_write (struct serial
*scb
, const char *str
, int len
)
368 if (serial_logfp
!= NULL
)
372 for (count
= 0; count
< len
; count
++)
373 serial_logchar (serial_logfp
, 'w', str
[count
] & 0xff, 0);
375 /* Make sure that the log file is as up-to-date as possible,
376 in case we are getting ready to dump core or something. */
377 gdb_flush (serial_logfp
);
379 if (serial_debug_p (scb
))
383 for (count
= 0; count
< len
; count
++)
385 fprintf_unfiltered (gdb_stdlog
, "[");
386 serial_logchar (gdb_stdlog
, 'w', str
[count
] & 0xff, 0);
387 fprintf_unfiltered (gdb_stdlog
, "]");
389 gdb_flush (gdb_stdlog
);
392 return (scb
->ops
->write (scb
, str
, len
));
396 serial_printf (struct serial
*desc
, const char *format
,...)
400 va_start (args
, format
);
402 buf
= xstrvprintf (format
, args
);
403 serial_write (desc
, buf
, strlen (buf
));
410 serial_drain_output (struct serial
*scb
)
412 return scb
->ops
->drain_output (scb
);
416 serial_flush_output (struct serial
*scb
)
418 return scb
->ops
->flush_output (scb
);
422 serial_flush_input (struct serial
*scb
)
424 return scb
->ops
->flush_input (scb
);
428 serial_send_break (struct serial
*scb
)
430 if (serial_logfp
!= NULL
)
431 serial_logchar (serial_logfp
, 'w', SERIAL_BREAK
, 0);
433 return (scb
->ops
->send_break (scb
));
437 serial_raw (struct serial
*scb
)
439 scb
->ops
->go_raw (scb
);
443 serial_get_tty_state (struct serial
*scb
)
445 return scb
->ops
->get_tty_state (scb
);
449 serial_copy_tty_state (struct serial
*scb
, serial_ttystate ttystate
)
451 return scb
->ops
->copy_tty_state (scb
, ttystate
);
455 serial_set_tty_state (struct serial
*scb
, serial_ttystate ttystate
)
457 return scb
->ops
->set_tty_state (scb
, ttystate
);
461 serial_print_tty_state (struct serial
*scb
,
462 serial_ttystate ttystate
,
463 struct ui_file
*stream
)
465 scb
->ops
->print_tty_state (scb
, ttystate
, stream
);
469 serial_noflush_set_tty_state (struct serial
*scb
,
470 serial_ttystate new_ttystate
,
471 serial_ttystate old_ttystate
)
473 return scb
->ops
->noflush_set_tty_state (scb
, new_ttystate
, old_ttystate
);
477 serial_setbaudrate (struct serial
*scb
, int rate
)
479 return scb
->ops
->setbaudrate (scb
, rate
);
483 serial_setstopbits (struct serial
*scb
, int num
)
485 return scb
->ops
->setstopbits (scb
, num
);
489 serial_can_async_p (struct serial
*scb
)
491 return (scb
->ops
->async
!= NULL
);
495 serial_is_async_p (struct serial
*scb
)
497 return (scb
->ops
->async
!= NULL
) && (scb
->async_handler
!= NULL
);
501 serial_async (struct serial
*scb
,
502 serial_event_ftype
*handler
,
505 int changed
= ((scb
->async_handler
== NULL
) != (handler
== NULL
));
507 scb
->async_handler
= handler
;
508 scb
->async_context
= context
;
509 /* Only change mode if there is a need. */
511 scb
->ops
->async (scb
, handler
!= NULL
);
515 deprecated_serial_fd (struct serial
*scb
)
517 /* FIXME: should this output a warning that deprecated code is being
521 internal_error (__FILE__
, __LINE__
,
522 _("serial: FD not valid"));
524 return scb
->fd
; /* sigh */
528 serial_debug (struct serial
*scb
, int debug_p
)
530 scb
->debug_p
= debug_p
;
534 serial_debug_p (struct serial
*scb
)
536 return scb
->debug_p
|| global_serial_debug_p
;
541 serial_wait_handle (struct serial
*scb
, HANDLE
*read
, HANDLE
*except
)
543 if (scb
->ops
->wait_handle
)
544 scb
->ops
->wait_handle (scb
, read
, except
);
547 *read
= (HANDLE
) _get_osfhandle (scb
->fd
);
553 serial_done_wait_handle (struct serial
*scb
)
555 if (scb
->ops
->done_wait_handle
)
556 scb
->ops
->done_wait_handle (scb
);
561 serial_pipe (struct serial
*scbs
[2])
563 struct serial_ops
*ops
;
566 ops
= serial_interface_lookup ("pipe");
573 if (gdb_pipe (fildes
) == -1)
576 scbs
[0] = serial_fdopen_ops (fildes
[0], ops
);
577 scbs
[1] = serial_fdopen_ops (fildes
[1], ops
);
581 /* Serial set/show framework. */
583 static struct cmd_list_element
*serial_set_cmdlist
;
584 static struct cmd_list_element
*serial_show_cmdlist
;
587 serial_set_cmd (char *args
, int from_tty
)
589 printf_unfiltered ("\"set serial\" must be followed "
590 "by the name of a command.\n");
591 help_list (serial_set_cmdlist
, "set serial ", -1, gdb_stdout
);
595 serial_show_cmd (char *args
, int from_tty
)
597 cmd_show_list (serial_show_cmdlist
, from_tty
, "");
602 _initialize_serial (void)
605 add_com ("connect", class_obscure
, connect_command
, _("\
606 Connect the terminal directly up to the command monitor.\n\
607 Use <CR>~. or <CR>~^D to break out."));
610 add_prefix_cmd ("serial", class_maintenance
, serial_set_cmd
, _("\
611 Set default serial/parallel port configuration."),
612 &serial_set_cmdlist
, "set serial ",
616 add_prefix_cmd ("serial", class_maintenance
, serial_show_cmd
, _("\
617 Show default serial/parallel port configuration."),
618 &serial_show_cmdlist
, "show serial ",
622 add_setshow_filename_cmd ("remotelogfile", no_class
, &serial_logfile
, _("\
623 Set filename for remote session recording."), _("\
624 Show filename for remote session recording."), _("\
625 This file is used to record the remote session for future playback\n\
628 NULL
, /* FIXME: i18n: */
629 &setlist
, &showlist
);
631 add_setshow_enum_cmd ("remotelogbase", no_class
, logbase_enums
,
632 &serial_logbase
, _("\
633 Set numerical base for remote session logging"), _("\
634 Show numerical base for remote session logging"), NULL
,
636 NULL
, /* FIXME: i18n: */
637 &setlist
, &showlist
);
639 add_setshow_zinteger_cmd ("serial", class_maintenance
,
640 &global_serial_debug_p
, _("\
641 Set serial debugging."), _("\
642 Show serial debugging."), _("\
643 When non-zero, serial port debugging is enabled."),
645 NULL
, /* FIXME: i18n: */
646 &setdebuglist
, &showdebuglist
);