1 /* Generic serial interface routines
3 Copyright 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
4 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., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, 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 #define XMALLOC(TYPE) ((TYPE*) xmalloc (sizeof (TYPE)))
66 static int serial_current_type
= 0;
68 /* Log char CH of type CHTYPE, with TIMEOUT */
70 /* Define bogus char to represent a BREAK. Should be careful to choose a value
71 that can't be confused with a normal char, or an error code. */
72 #define SERIAL_BREAK 1235
75 serial_logchar (struct ui_file
*stream
, int ch_type
, int ch
, int timeout
)
77 if (ch_type
!= serial_current_type
)
79 fprintf_unfiltered (stream
, "\n%c ", ch_type
);
80 serial_current_type
= ch_type
;
83 if (serial_logbase
!= logbase_ascii
)
84 fputc_unfiltered (' ', stream
);
89 fprintf_unfiltered (stream
, "<Timeout: %d seconds>", timeout
);
92 fprintf_unfiltered (stream
, "<Error: %s>", safe_strerror (errno
));
95 fputs_unfiltered ("<Eof>", stream
);
98 fputs_unfiltered ("<Break>", stream
);
101 if (serial_logbase
== logbase_hex
)
102 fprintf_unfiltered (stream
, "%02x", ch
& 0xff);
103 else if (serial_logbase
== logbase_octal
)
104 fprintf_unfiltered (stream
, "%03o", ch
& 0xff);
109 fputs_unfiltered ("\\\\", stream
);
112 fputs_unfiltered ("\\b", stream
);
115 fputs_unfiltered ("\\f", stream
);
118 fputs_unfiltered ("\\n", stream
);
121 fputs_unfiltered ("\\r", stream
);
124 fputs_unfiltered ("\\t", stream
);
127 fputs_unfiltered ("\\v", stream
);
130 fprintf_unfiltered (stream
, isprint (ch
) ? "%c" : "\\x%02x", ch
& 0xFF);
137 serial_log_command (const char *cmd
)
142 serial_current_type
= 'c';
144 fputs_unfiltered ("\nc ", serial_logfp
);
145 fputs_unfiltered (cmd
, serial_logfp
);
147 /* Make sure that the log file is as up-to-date as possible,
148 in case we are getting ready to dump core or something. */
149 gdb_flush (serial_logfp
);
153 static struct serial_ops
*
154 serial_interface_lookup (char *name
)
156 struct serial_ops
*ops
;
158 for (ops
= serial_ops_list
; ops
; ops
= ops
->next
)
159 if (strcmp (name
, ops
->name
) == 0)
166 serial_add_interface (struct serial_ops
*optable
)
168 optable
->next
= serial_ops_list
;
169 serial_ops_list
= optable
;
172 /* Open up a device or a network socket, depending upon the syntax of NAME. */
175 serial_open (const char *name
)
178 struct serial_ops
*ops
;
179 const char *open_name
= name
;
181 for (scb
= scb_base
; scb
; scb
= scb
->next
)
182 if (scb
->name
&& strcmp (scb
->name
, name
) == 0)
188 if (strcmp (name
, "ocd") == 0)
189 ops
= serial_interface_lookup ("ocd");
190 else if (strcmp (name
, "pc") == 0)
191 ops
= serial_interface_lookup ("pc");
192 else if (strchr (name
, ':'))
193 ops
= serial_interface_lookup ("tcp");
194 else if (strncmp (name
, "lpt", 3) == 0)
195 ops
= serial_interface_lookup ("parallel");
196 else if (strncmp (name
, "|", 1) == 0)
198 ops
= serial_interface_lookup ("pipe");
199 open_name
= name
+ 1; /* discard ``|'' */
202 ops
= serial_interface_lookup ("hardwire");
207 scb
= XMALLOC (struct serial
);
212 scb
->bufp
= scb
->buf
;
214 if (scb
->ops
->open (scb
, open_name
))
220 scb
->name
= xstrdup (name
);
221 scb
->next
= scb_base
;
224 scb
->async_state
= 0;
225 scb
->async_handler
= NULL
;
226 scb
->async_context
= NULL
;
229 last_serial_opened
= scb
;
231 if (serial_logfile
!= NULL
)
233 serial_logfp
= gdb_fopen (serial_logfile
, "w");
234 if (serial_logfp
== NULL
)
235 perror_with_name (serial_logfile
);
242 serial_fdopen (const int fd
)
245 struct serial_ops
*ops
;
247 for (scb
= scb_base
; scb
; scb
= scb
->next
)
254 ops
= serial_interface_lookup ("hardwire");
259 scb
= XMALLOC (struct serial
);
264 scb
->bufp
= scb
->buf
;
269 scb
->next
= scb_base
;
272 scb
->async_state
= 0;
273 scb
->async_handler
= NULL
;
274 scb
->async_context
= NULL
;
277 last_serial_opened
= scb
;
283 do_serial_close (struct serial
*scb
, int really_close
)
285 struct serial
*tmp_scb
;
287 last_serial_opened
= NULL
;
291 fputs_unfiltered ("\nEnd of log\n", serial_logfp
);
292 serial_current_type
= 0;
294 /* XXX - What if serial_logfp == gdb_stdout or gdb_stderr? */
295 ui_file_delete (serial_logfp
);
299 /* This is bogus. It's not our fault if you pass us a bad scb...! Rob, you
300 should fix your code instead. */
309 /* ensure that the FD has been taken out of async mode */
310 if (scb
->async_handler
!= NULL
)
311 serial_async (scb
, NULL
, NULL
);
314 scb
->ops
->close (scb
);
320 scb_base
= scb_base
->next
;
322 for (tmp_scb
= scb_base
; tmp_scb
; tmp_scb
= tmp_scb
->next
)
324 if (tmp_scb
->next
!= scb
)
327 tmp_scb
->next
= tmp_scb
->next
->next
;
335 serial_close (struct serial
*scb
)
337 do_serial_close (scb
, 1);
341 serial_un_fdopen (struct serial
*scb
)
343 do_serial_close (scb
, 0);
347 serial_readchar (struct serial
*scb
, int timeout
)
351 /* FIXME: cagney/1999-10-11: Don't enable this check until the ASYNC
353 if (0 && serial_is_async_p (scb
) && timeout
< 0)
354 internal_error (__FILE__
, __LINE__
,
355 "serial_readchar: blocking read in async mode");
357 ch
= scb
->ops
->readchar (scb
, timeout
);
358 if (serial_logfp
!= NULL
)
360 serial_logchar (serial_logfp
, 'r', ch
, timeout
);
362 /* Make sure that the log file is as up-to-date as possible,
363 in case we are getting ready to dump core or something. */
364 gdb_flush (serial_logfp
);
366 if (serial_debug_p (scb
))
368 fprintf_unfiltered (gdb_stdlog
, "[");
369 serial_logchar (gdb_stdlog
, 'r', ch
, timeout
);
370 fprintf_unfiltered (gdb_stdlog
, "]");
371 gdb_flush (gdb_stdlog
);
378 serial_write (struct serial
*scb
, const char *str
, int len
)
380 if (serial_logfp
!= NULL
)
384 for (count
= 0; count
< len
; count
++)
385 serial_logchar (serial_logfp
, 'w', str
[count
] & 0xff, 0);
387 /* Make sure that the log file is as up-to-date as possible,
388 in case we are getting ready to dump core or something. */
389 gdb_flush (serial_logfp
);
392 return (scb
->ops
->write (scb
, str
, len
));
396 serial_printf (struct serial
*desc
, const char *format
,...)
400 va_start (args
, format
);
402 xvasprintf (&buf
, 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_set_tty_state (struct serial
*scb
, serial_ttystate ttystate
)
451 return scb
->ops
->set_tty_state (scb
, ttystate
);
455 serial_print_tty_state (struct serial
*scb
,
456 serial_ttystate ttystate
,
457 struct ui_file
*stream
)
459 scb
->ops
->print_tty_state (scb
, ttystate
, stream
);
463 serial_noflush_set_tty_state (struct serial
*scb
,
464 serial_ttystate new_ttystate
,
465 serial_ttystate old_ttystate
)
467 return scb
->ops
->noflush_set_tty_state (scb
, new_ttystate
, old_ttystate
);
471 serial_setbaudrate (struct serial
*scb
, int rate
)
473 return scb
->ops
->setbaudrate (scb
, rate
);
477 serial_setstopbits (struct serial
*scb
, int num
)
479 return scb
->ops
->setstopbits (scb
, num
);
483 serial_can_async_p (struct serial
*scb
)
485 return (scb
->ops
->async
!= NULL
);
489 serial_is_async_p (struct serial
*scb
)
491 return (scb
->ops
->async
!= NULL
) && (scb
->async_handler
!= NULL
);
495 serial_async (struct serial
*scb
,
496 serial_event_ftype
*handler
,
499 /* Only change mode if there is a need. */
500 if ((scb
->async_handler
== NULL
)
501 != (handler
== NULL
))
502 scb
->ops
->async (scb
, handler
!= NULL
);
503 scb
->async_handler
= handler
;
504 scb
->async_context
= context
;
508 deprecated_serial_fd (struct serial
*scb
)
510 /* FIXME: should this output a warning that deprecated code is being
514 internal_error (__FILE__
, __LINE__
,
515 "serial: FD not valid");
517 return scb
->fd
; /* sigh */
521 serial_debug (struct serial
*scb
, int debug_p
)
523 scb
->debug_p
= debug_p
;
527 serial_debug_p (struct serial
*scb
)
529 return scb
->debug_p
|| global_serial_debug_p
;
534 /* The connect command is #if 0 because I hadn't thought of an elegant
535 way to wait for I/O on two `struct serial *'s simultaneously. Two
536 solutions came to mind:
538 1) Fork, and have have one fork handle the to user direction,
539 and have the other hand the to target direction. This
540 obviously won't cut it for MSDOS.
542 2) Use something like select. This assumes that stdin and
543 the target side can both be waited on via the same
544 mechanism. This may not be true for DOS, if GDB is
545 talking to the target via a TCP socket.
546 -grossman, 8 Jun 93 */
548 /* Connect the user directly to the remote system. This command acts just like
549 the 'cu' or 'tip' command. Use <CR>~. or <CR>~^D to break out. */
551 static struct serial
*tty_desc
; /* Controlling terminal */
554 cleanup_tty (serial_ttystate ttystate
)
556 printf_unfiltered ("\r\n[Exiting connect mode]\r\n");
557 serial_set_tty_state (tty_desc
, ttystate
);
559 serial_close (tty_desc
);
563 connect_command (char *args
, int fromtty
)
567 serial_ttystate ttystate
;
568 struct serial
*port_desc
; /* TTY port */
573 fprintf_unfiltered (gdb_stderr
, "This command takes no args. They have been ignored.\n");
575 printf_unfiltered ("[Entering connect mode. Use ~. or ~^D to escape]\n");
577 tty_desc
= serial_fdopen (0);
578 port_desc
= last_serial_opened
;
580 ttystate
= serial_get_tty_state (tty_desc
);
582 serial_raw (tty_desc
);
583 serial_raw (port_desc
);
585 make_cleanup (cleanup_tty
, ttystate
);
591 mask
= serial_wait_2 (tty_desc
, port_desc
, -1);
599 c
= serial_readchar (tty_desc
, 0);
601 if (c
== SERIAL_TIMEOUT
)
605 perror_with_name ("connect");
608 serial_write (port_desc
, &cx
, 1);
623 if (c
== '.' || c
== '\004')
637 c
= serial_readchar (port_desc
, 0);
639 if (c
== SERIAL_TIMEOUT
)
643 perror_with_name ("connect");
647 serial_write (tty_desc
, &cx
, 1);
654 /* Serial set/show framework. */
656 static struct cmd_list_element
*serial_set_cmdlist
;
657 static struct cmd_list_element
*serial_show_cmdlist
;
660 serial_set_cmd (char *args
, int from_tty
)
662 printf_unfiltered ("\"set serial\" must be followed by the name of a command.\n");
663 help_list (serial_set_cmdlist
, "set serial ", -1, gdb_stdout
);
667 serial_show_cmd (char *args
, int from_tty
)
669 cmd_show_list (serial_show_cmdlist
, from_tty
, "");
674 _initialize_serial (void)
677 add_com ("connect", class_obscure
, connect_command
,
678 "Connect the terminal directly up to the command monitor.\n\
679 Use <CR>~. or <CR>~^D to break out.");
682 add_prefix_cmd ("serial", class_maintenance
, serial_set_cmd
, "\
683 Set default serial/parallel port configuration.",
684 &serial_set_cmdlist
, "set serial ",
688 add_prefix_cmd ("serial", class_maintenance
, serial_show_cmd
, "\
689 Show default serial/parallel port configuration.",
690 &serial_show_cmdlist
, "show serial ",
695 (add_set_cmd ("remotelogfile", no_class
,
696 var_filename
, (char *) &serial_logfile
,
697 "Set filename for remote session recording.\n\
698 This file is used to record the remote session for future playback\n\
704 (add_set_enum_cmd ("remotelogbase", no_class
,
705 logbase_enums
, &serial_logbase
,
706 "Set numerical base for remote session logging",
710 add_show_from_set (add_set_cmd ("serial",
713 (char *)&global_serial_debug_p
,
714 "Set serial debugging.\n\
715 When non-zero, serial port debugging is enabled.", &setdebuglist
),