X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fser-unix.c;h=c49bd84eb63c84481060aeb1a51cc0c8fd477d91;hb=f81e7e2db6d1aaf47561e54356aee12b585533c2;hp=c92567bd0338786fe1db812ef4af44e29100b4a9;hpb=ed288bb597072176e84fc8279707a3f2f475779b;p=deliverable%2Fbinutils-gdb.git

diff --git a/gdb/ser-unix.c b/gdb/ser-unix.c
index c92567bd03..c49bd84eb6 100644
--- a/gdb/ser-unix.c
+++ b/gdb/ser-unix.c
@@ -1,11 +1,12 @@
 /* Serial interface for local (hardwired) serial ports on Un*x like systems
-   Copyright 1992, 1993, 1994, 1998 Free Software Foundation, Inc.
+
+   Copyright (C) 1992-2019 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2 of the License, or
+   the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
@@ -14,88 +15,67 @@
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include "defs.h"
 #include "serial.h"
+#include "ser-base.h"
+#include "ser-unix.h"
+
 #include <fcntl.h>
 #include <sys/types.h>
 #include "terminal.h"
-#ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
+#include <sys/socket.h>
+#include "gdbsupport/gdb_sys_time.h"
 
-#ifdef HAVE_TERMIOS
+#include "gdb_select.h"
+#include "gdbcmd.h"
+#include "gdbsupport/filestuff.h"
+#include <termios.h>
+#include "inflow.h"
 
 struct hardwire_ttystate
   {
     struct termios termios;
   };
-#endif /* termios */
-
-#ifdef HAVE_TERMIO
 
-/* It is believed that all systems which have added job control to SVR3
-   (e.g. sco) have also added termios.  Even if not, trying to figure out
-   all the variations (TIOCGPGRP vs. TCGETPGRP, etc.) would be pretty
-   bewildering.  So we don't attempt it.  */
-
-struct hardwire_ttystate
-  {
-    struct termio termio;
-  };
-#endif /* termio */
+#ifdef CRTSCTS
+/* Boolean to explicitly enable or disable h/w flow control.  */
+static bool serial_hwflow;
+static void
+show_serial_hwflow (struct ui_file *file, int from_tty,
+		    struct cmd_list_element *c, const char *value)
+{
+  fprintf_filtered (file, _("Hardware flow control is %s.\n"), value);
+}
+#endif
 
-#ifdef HAVE_SGTTY
-/* Needed for the code which uses select().  We would include <sys/select.h>
-   too if it existed on all systems.  */
-#include <sys/time.h>
-
-struct hardwire_ttystate
-  {
-    struct sgttyb sgttyb;
-    struct tchars tc;
-    struct ltchars ltc;
-    /* Line discipline flags.  */
-    int lmode;
-  };
-#endif /* sgtty */
-
-static int hardwire_open PARAMS ((serial_t scb, const char *name));
-static void hardwire_raw PARAMS ((serial_t scb));
-static int wait_for PARAMS ((serial_t scb, int timeout));
-static int hardwire_readchar PARAMS ((serial_t scb, int timeout));
-static int rate_to_code PARAMS ((int rate));
-static int hardwire_setbaudrate PARAMS ((serial_t scb, int rate));
-static int hardwire_write PARAMS ((serial_t scb, const char *str, int len));
-static void hardwire_close PARAMS ((serial_t scb));
-static int get_tty_state PARAMS ((serial_t scb, struct hardwire_ttystate * state));
-static int set_tty_state PARAMS ((serial_t scb, struct hardwire_ttystate * state));
-static serial_ttystate hardwire_get_tty_state PARAMS ((serial_t scb));
-static int hardwire_set_tty_state PARAMS ((serial_t scb, serial_ttystate state));
-static int hardwire_noflush_set_tty_state PARAMS ((serial_t, serial_ttystate,
-						   serial_ttystate));
-static void hardwire_print_tty_state PARAMS ((serial_t, serial_ttystate));
-static int hardwire_drain_output PARAMS ((serial_t));
-static int hardwire_flush_output PARAMS ((serial_t));
-static int hardwire_flush_input PARAMS ((serial_t));
-static int hardwire_send_break PARAMS ((serial_t));
-static int hardwire_setstopbits PARAMS ((serial_t, int));
-
-void _initialize_ser_hardwire PARAMS ((void));
-
-extern int (*ui_loop_hook) PARAMS ((int));
-
-/* Open up a real live device for serial I/O */
+static int hardwire_open (struct serial *scb, const char *name);
+static void hardwire_raw (struct serial *scb);
+static int rate_to_code (int rate);
+static int hardwire_setbaudrate (struct serial *scb, int rate);
+static int hardwire_setparity (struct serial *scb, int parity);
+static void hardwire_close (struct serial *scb);
+static int get_tty_state (struct serial *scb,
+			  struct hardwire_ttystate * state);
+static int set_tty_state (struct serial *scb,
+			  struct hardwire_ttystate * state);
+static serial_ttystate hardwire_get_tty_state (struct serial *scb);
+static int hardwire_set_tty_state (struct serial *scb, serial_ttystate state);
+static void hardwire_print_tty_state (struct serial *, serial_ttystate,
+				      struct ui_file *);
+static int hardwire_drain_output (struct serial *);
+static int hardwire_flush_output (struct serial *);
+static int hardwire_flush_input (struct serial *);
+static int hardwire_send_break (struct serial *);
+static int hardwire_setstopbits (struct serial *, int);
+
+/* Open up a real live device for serial I/O.  */
 
 static int
-hardwire_open (scb, name)
-     serial_t scb;
-     const char *name;
+hardwire_open (struct serial *scb, const char *name)
 {
-  scb->fd = open (name, O_RDWR);
+  scb->fd = gdb_open_cloexec (name, O_RDWR, 0);
   if (scb->fd < 0)
     return -1;
 
@@ -103,513 +83,147 @@ hardwire_open (scb, name)
 }
 
 static int
-get_tty_state (scb, state)
-     serial_t scb;
-     struct hardwire_ttystate *state;
+get_tty_state (struct serial *scb, struct hardwire_ttystate *state)
 {
-#ifdef HAVE_TERMIOS
   if (tcgetattr (scb->fd, &state->termios) < 0)
     return -1;
 
   return 0;
-#endif
-
-#ifdef HAVE_TERMIO
-  if (ioctl (scb->fd, TCGETA, &state->termio) < 0)
-    return -1;
-  return 0;
-#endif
-
-#ifdef HAVE_SGTTY
-  if (ioctl (scb->fd, TIOCGETP, &state->sgttyb) < 0)
-    return -1;
-  if (ioctl (scb->fd, TIOCGETC, &state->tc) < 0)
-    return -1;
-  if (ioctl (scb->fd, TIOCGLTC, &state->ltc) < 0)
-    return -1;
-  if (ioctl (scb->fd, TIOCLGET, &state->lmode) < 0)
-    return -1;
-
-  return 0;
-#endif
 }
 
 static int
-set_tty_state (scb, state)
-     serial_t scb;
-     struct hardwire_ttystate *state;
+set_tty_state (struct serial *scb, struct hardwire_ttystate *state)
 {
-#ifdef HAVE_TERMIOS
   if (tcsetattr (scb->fd, TCSANOW, &state->termios) < 0)
     return -1;
 
   return 0;
-#endif
-
-#ifdef HAVE_TERMIO
-  if (ioctl (scb->fd, TCSETA, &state->termio) < 0)
-    return -1;
-  return 0;
-#endif
-
-#ifdef HAVE_SGTTY
-  if (ioctl (scb->fd, TIOCSETN, &state->sgttyb) < 0)
-    return -1;
-  if (ioctl (scb->fd, TIOCSETC, &state->tc) < 0)
-    return -1;
-  if (ioctl (scb->fd, TIOCSLTC, &state->ltc) < 0)
-    return -1;
-  if (ioctl (scb->fd, TIOCLSET, &state->lmode) < 0)
-    return -1;
-
-  return 0;
-#endif
 }
 
 static serial_ttystate
-hardwire_get_tty_state (scb)
-     serial_t scb;
+hardwire_get_tty_state (struct serial *scb)
 {
-  struct hardwire_ttystate *state;
-
-  state = (struct hardwire_ttystate *) xmalloc (sizeof *state);
+  struct hardwire_ttystate *state = XNEW (struct hardwire_ttystate);
 
   if (get_tty_state (scb, state))
-    return NULL;
+    {
+      xfree (state);
+      return NULL;
+    }
 
   return (serial_ttystate) state;
 }
 
-static int
-hardwire_set_tty_state (scb, ttystate)
-     serial_t scb;
-     serial_ttystate ttystate;
+static serial_ttystate
+hardwire_copy_tty_state (struct serial *scb, serial_ttystate ttystate)
 {
-  struct hardwire_ttystate *state;
+  struct hardwire_ttystate *state = XNEW (struct hardwire_ttystate);
 
-  state = (struct hardwire_ttystate *) ttystate;
+  *state = *(struct hardwire_ttystate *) ttystate;
 
-  return set_tty_state (scb, state);
+  return (serial_ttystate) state;
 }
 
 static int
-hardwire_noflush_set_tty_state (scb, new_ttystate, old_ttystate)
-     serial_t scb;
-     serial_ttystate new_ttystate;
-     serial_ttystate old_ttystate;
+hardwire_set_tty_state (struct serial *scb, serial_ttystate ttystate)
 {
-  struct hardwire_ttystate new_state;
-#ifdef HAVE_SGTTY
-  struct hardwire_ttystate *state = (struct hardwire_ttystate *) old_ttystate;
-#endif
-
-  new_state = *(struct hardwire_ttystate *) new_ttystate;
-
-  /* Don't change in or out of raw mode; we don't want to flush input.
-     termio and termios have no such restriction; for them flushing input
-     is separate from setting the attributes.  */
-
-#ifdef HAVE_SGTTY
-  if (state->sgttyb.sg_flags & RAW)
-    new_state.sgttyb.sg_flags |= RAW;
-  else
-    new_state.sgttyb.sg_flags &= ~RAW;
+  struct hardwire_ttystate *state;
 
-  /* I'm not sure whether this is necessary; the manpage just mentions
-     RAW not CBREAK.  */
-  if (state->sgttyb.sg_flags & CBREAK)
-    new_state.sgttyb.sg_flags |= CBREAK;
-  else
-    new_state.sgttyb.sg_flags &= ~CBREAK;
-#endif
+  state = (struct hardwire_ttystate *) ttystate;
 
-  return set_tty_state (scb, &new_state);
+  return set_tty_state (scb, state);
 }
 
 static void
-hardwire_print_tty_state (scb, ttystate)
-     serial_t scb;
-     serial_ttystate ttystate;
+hardwire_print_tty_state (struct serial *scb,
+			  serial_ttystate ttystate,
+			  struct ui_file *stream)
 {
   struct hardwire_ttystate *state = (struct hardwire_ttystate *) ttystate;
   int i;
 
-#ifdef HAVE_TERMIOS
-  printf_filtered ("c_iflag = 0x%x, c_oflag = 0x%x,\n",
-		   state->termios.c_iflag, state->termios.c_oflag);
-  printf_filtered ("c_cflag = 0x%x, c_lflag = 0x%x\n",
-		   state->termios.c_cflag, state->termios.c_lflag);
+  fprintf_filtered (stream, "c_iflag = 0x%x, c_oflag = 0x%x,\n",
+		    (int) state->termios.c_iflag,
+		    (int) state->termios.c_oflag);
+  fprintf_filtered (stream, "c_cflag = 0x%x, c_lflag = 0x%x\n",
+		    (int) state->termios.c_cflag,
+		    (int) state->termios.c_lflag);
 #if 0
   /* This not in POSIX, and is not really documented by those systems
      which have it (at least not Sun).  */
-  printf_filtered ("c_line = 0x%x.\n", state->termios.c_line);
+  fprintf_filtered (stream, "c_line = 0x%x.\n", state->termios.c_line);
 #endif
-  printf_filtered ("c_cc: ");
+  fprintf_filtered (stream, "c_cc: ");
   for (i = 0; i < NCCS; i += 1)
-    printf_filtered ("0x%x ", state->termios.c_cc[i]);
-  printf_filtered ("\n");
-#endif
-
-#ifdef HAVE_TERMIO
-  printf_filtered ("c_iflag = 0x%x, c_oflag = 0x%x,\n",
-		   state->termio.c_iflag, state->termio.c_oflag);
-  printf_filtered ("c_cflag = 0x%x, c_lflag = 0x%x, c_line = 0x%x.\n",
-		   state->termio.c_cflag, state->termio.c_lflag,
-		   state->termio.c_line);
-  printf_filtered ("c_cc: ");
-  for (i = 0; i < NCC; i += 1)
-    printf_filtered ("0x%x ", state->termio.c_cc[i]);
-  printf_filtered ("\n");
-#endif
-
-#ifdef HAVE_SGTTY
-  printf_filtered ("sgttyb.sg_flags = 0x%x.\n", state->sgttyb.sg_flags);
-
-  printf_filtered ("tchars: ");
-  for (i = 0; i < (int) sizeof (struct tchars); i++)
-    printf_filtered ("0x%x ", ((unsigned char *) &state->tc)[i]);
-  printf_filtered ("\n");
-
-  printf_filtered ("ltchars: ");
-  for (i = 0; i < (int) sizeof (struct ltchars); i++)
-    printf_filtered ("0x%x ", ((unsigned char *) &state->ltc)[i]);
-  printf_filtered ("\n");
-
-  printf_filtered ("lmode:  0x%x\n", state->lmode);
-#endif
+    fprintf_filtered (stream, "0x%x ", state->termios.c_cc[i]);
+  fprintf_filtered (stream, "\n");
 }
 
-/* Wait for the output to drain away, as opposed to flushing (discarding) it */
+/* Wait for the output to drain away, as opposed to flushing
+   (discarding) it.  */
 
 static int
-hardwire_drain_output (scb)
-     serial_t scb;
+hardwire_drain_output (struct serial *scb)
 {
-#ifdef HAVE_TERMIOS
-  return tcdrain (scb->fd);
-#endif
+  /* Ignore SIGTTOU which may occur during the drain.  */
+  scoped_ignore_sigttou ignore_sigttou;
 
-#ifdef HAVE_TERMIO
-  return ioctl (scb->fd, TCSBRK, 1);
-#endif
-
-#ifdef HAVE_SGTTY
-  /* Get the current state and then restore it using TIOCSETP,
-     which should cause the output to drain and pending input
-     to be discarded. */
-  {
-    struct hardwire_ttystate state;
-    if (get_tty_state (scb, &state))
-      {
-	return (-1);
-      }
-    else
-      {
-	return (ioctl (scb->fd, TIOCSETP, &state.sgttyb));
-      }
-  }
-#endif
+  return tcdrain (scb->fd);
 }
 
 static int
-hardwire_flush_output (scb)
-     serial_t scb;
+hardwire_flush_output (struct serial *scb)
 {
-#ifdef HAVE_TERMIOS
   return tcflush (scb->fd, TCOFLUSH);
-#endif
-
-#ifdef HAVE_TERMIO
-  return ioctl (scb->fd, TCFLSH, 1);
-#endif
-
-#ifdef HAVE_SGTTY
-  /* This flushes both input and output, but we can't do better.  */
-  return ioctl (scb->fd, TIOCFLUSH, 0);
-#endif
 }
 
 static int
-hardwire_flush_input (scb)
-     serial_t scb;
+hardwire_flush_input (struct serial *scb)
 {
-  scb->bufcnt = 0;
-  scb->bufp = scb->buf;
+  ser_base_flush_input (scb);
 
-#ifdef HAVE_TERMIOS
   return tcflush (scb->fd, TCIFLUSH);
-#endif
-
-#ifdef HAVE_TERMIO
-  return ioctl (scb->fd, TCFLSH, 0);
-#endif
-
-#ifdef HAVE_SGTTY
-  /* This flushes both input and output, but we can't do better.  */
-  return ioctl (scb->fd, TIOCFLUSH, 0);
-#endif
 }
 
 static int
-hardwire_send_break (scb)
-     serial_t scb;
+hardwire_send_break (struct serial *scb)
 {
-#ifdef HAVE_TERMIOS
   return tcsendbreak (scb->fd, 0);
-#endif
-
-#ifdef HAVE_TERMIO
-  return ioctl (scb->fd, TCSBRK, 0);
-#endif
-
-#ifdef HAVE_SGTTY
-  {
-    int status;
-    struct timeval timeout;
-
-    status = ioctl (scb->fd, TIOCSBRK, 0);
-
-    /* Can't use usleep; it doesn't exist in BSD 4.2.  */
-    /* Note that if this select() is interrupted by a signal it will not wait
-       the full length of time.  I think that is OK.  */
-    timeout.tv_sec = 0;
-    timeout.tv_usec = 250000;
-    select (0, 0, 0, 0, &timeout);
-    status = ioctl (scb->fd, TIOCCBRK, 0);
-    return status;
-  }
-#endif
 }
 
 static void
-hardwire_raw (scb)
-     serial_t scb;
+hardwire_raw (struct serial *scb)
 {
   struct hardwire_ttystate state;
 
   if (get_tty_state (scb, &state))
-    fprintf_unfiltered (gdb_stderr, "get_tty_state failed: %s\n", safe_strerror (errno));
+    fprintf_unfiltered (gdb_stderr, "get_tty_state failed: %s\n",
+			safe_strerror (errno));
 
-#ifdef HAVE_TERMIOS
   state.termios.c_iflag = 0;
   state.termios.c_oflag = 0;
   state.termios.c_lflag = 0;
-  state.termios.c_cflag &= ~(CSIZE | PARENB);
+  state.termios.c_cflag &= ~CSIZE;
   state.termios.c_cflag |= CLOCAL | CS8;
-  state.termios.c_cc[VMIN] = 0;
-  state.termios.c_cc[VTIME] = 0;
-#endif
-
-#ifdef HAVE_TERMIO
-  state.termio.c_iflag = 0;
-  state.termio.c_oflag = 0;
-  state.termio.c_lflag = 0;
-  state.termio.c_cflag &= ~(CSIZE | PARENB);
-  state.termio.c_cflag |= CLOCAL | CS8;
-  state.termio.c_cc[VMIN] = 0;
-  state.termio.c_cc[VTIME] = 0;
+#ifdef CRTSCTS
+  /* h/w flow control.  */
+  if (serial_hwflow)
+    state.termios.c_cflag |= CRTSCTS;
+  else
+    state.termios.c_cflag &= ~CRTSCTS;
+#ifdef CRTS_IFLOW
+  if (serial_hwflow)
+    state.termios.c_cflag |= CRTS_IFLOW;
+  else
+    state.termios.c_cflag &= ~CRTS_IFLOW;
 #endif
-
-#ifdef HAVE_SGTTY
-  state.sgttyb.sg_flags |= RAW | ANYP;
-  state.sgttyb.sg_flags &= ~(CBREAK | ECHO);
 #endif
-
-  scb->current_timeout = 0;
+  state.termios.c_cc[VMIN] = 0;
+  state.termios.c_cc[VTIME] = 0;
 
   if (set_tty_state (scb, &state))
-    fprintf_unfiltered (gdb_stderr, "set_tty_state failed: %s\n", safe_strerror (errno));
-}
-
-/* Wait for input on scb, with timeout seconds.  Returns 0 on success,
-   otherwise SERIAL_TIMEOUT or SERIAL_ERROR.
-
-   For termio{s}, we actually just setup VTIME if necessary, and let the
-   timeout occur in the read() in hardwire_read().
- */
-
-static int
-wait_for (scb, timeout)
-     serial_t scb;
-     int timeout;
-{
-#ifdef HAVE_SGTTY
-  {
-    struct timeval tv;
-    fd_set readfds;
-
-    FD_ZERO (&readfds);
-
-    tv.tv_sec = timeout;
-    tv.tv_usec = 0;
-
-    FD_SET (scb->fd, &readfds);
-
-    while (1)
-      {
-	int numfds;
-
-	if (timeout >= 0)
-	  numfds = select (scb->fd + 1, &readfds, 0, 0, &tv);
-	else
-	  numfds = select (scb->fd + 1, &readfds, 0, 0, 0);
-
-	if (numfds <= 0)
-	  if (numfds == 0)
-	    return SERIAL_TIMEOUT;
-	  else if (errno == EINTR)
-	    continue;
-	  else
-	    return SERIAL_ERROR;	/* Got an error from select or poll */
-
-	return 0;
-      }
-  }
-#endif /* HAVE_SGTTY */
-
-#if defined HAVE_TERMIO || defined HAVE_TERMIOS
-  if (timeout == scb->current_timeout)
-    return 0;
-
-  scb->current_timeout = timeout;
-
-  {
-    struct hardwire_ttystate state;
-
-    if (get_tty_state (scb, &state))
-      fprintf_unfiltered (gdb_stderr, "get_tty_state failed: %s\n", safe_strerror (errno));
-
-#ifdef HAVE_TERMIOS
-    if (timeout < 0)
-      {
-	/* No timeout.  */
-	state.termios.c_cc[VTIME] = 0;
-	state.termios.c_cc[VMIN] = 1;
-      }
-    else
-      {
-	state.termios.c_cc[VMIN] = 0;
-	state.termios.c_cc[VTIME] = timeout * 10;
-	if (state.termios.c_cc[VTIME] != timeout * 10)
-	  {
-
-	    /* If c_cc is an 8-bit signed character, we can't go 
-	       bigger than this.  If it is always unsigned, we could use
-	       25.  */
-
-	    scb->current_timeout = 12;
-	    state.termios.c_cc[VTIME] = scb->current_timeout * 10;
-	    scb->timeout_remaining = timeout - scb->current_timeout;
-	  }
-      }
-#endif
-
-#ifdef HAVE_TERMIO
-    if (timeout < 0)
-      {
-	/* No timeout.  */
-	state.termio.c_cc[VTIME] = 0;
-	state.termio.c_cc[VMIN] = 1;
-      }
-    else
-      {
-	state.termio.c_cc[VMIN] = 0;
-	state.termio.c_cc[VTIME] = timeout * 10;
-	if (state.termio.c_cc[VTIME] != timeout * 10)
-	  {
-	    /* If c_cc is an 8-bit signed character, we can't go 
-	       bigger than this.  If it is always unsigned, we could use
-	       25.  */
-
-	    scb->current_timeout = 12;
-	    state.termio.c_cc[VTIME] = scb->current_timeout * 10;
-	    scb->timeout_remaining = timeout - scb->current_timeout;
-	  }
-      }
-#endif
-
-    if (set_tty_state (scb, &state))
-      fprintf_unfiltered (gdb_stderr, "set_tty_state failed: %s\n", safe_strerror (errno));
-
-    return 0;
-  }
-#endif /* HAVE_TERMIO || HAVE_TERMIOS */
-}
-
-/* Read a character with user-specified timeout.  TIMEOUT is number of seconds
-   to wait, or -1 to wait forever.  Use timeout of 0 to effect a poll.  Returns
-   char if successful.  Returns SERIAL_TIMEOUT if timeout expired, EOF if line
-   dropped dead, or SERIAL_ERROR for any other error (see errno in that case).  */
-static int
-hardwire_readchar (scb, timeout)
-     serial_t scb;
-     int timeout;
-{
-  int status, delta;
-  int detach = 0;
-
-  if (scb->bufcnt-- > 0)
-    return *scb->bufp++;
-
-  if (timeout > 0)
-    timeout++;
-
-  /* We have to be able to keep the GUI alive here, so we break the original
-     timeout into steps of 1 second, running the "keep the GUI alive" hook 
-     each time through the loop.
-     Also, timeout = 0 means to poll, so we just set the delta to 0, so we
-     will only go through the loop once. */
-
-  delta = (timeout == 0 ? 0 : 1);
-  while (1)
-    {
-
-      /* N.B. The UI may destroy our world (for instance by calling
-         remote_stop,) in which case we want to get out of here as
-         quickly as possible.  It is not safe to touch scb, since
-         someone else might have freed it.  The ui_loop_hook signals that 
-         we should exit by returning 1. */
-
-      if (ui_loop_hook)
-	detach = ui_loop_hook (0);
-
-      if (detach)
-	return SERIAL_TIMEOUT;
-
-      scb->timeout_remaining = (timeout < 0 ? timeout : timeout - delta);
-      status = wait_for (scb, delta);
-
-      if (status < 0)
-	return status;
-
-      scb->bufcnt = read (scb->fd, scb->buf, BUFSIZ);
-
-      if (scb->bufcnt <= 0)
-	{
-	  if (scb->bufcnt == 0)
-	    {
-	      /* Zero characters means timeout (it could also be EOF, but
-	         we don't (yet at least) distinguish).  */
-	      if (scb->timeout_remaining > 0)
-		{
-		  timeout = scb->timeout_remaining;
-		  continue;
-		}
-	      else if (scb->timeout_remaining < 0)
-		continue;
-	      else
-		return SERIAL_TIMEOUT;
-	    }
-	  else if (errno == EINTR)
-	    continue;
-	  else
-	    return SERIAL_ERROR;	/* Got an error from read */
-	}
-
-      scb->bufcnt--;
-      scb->bufp = scb->buf;
-      return *scb->bufp++;
-    }
+    fprintf_unfiltered (gdb_stderr, "set_tty_state failed: %s\n",
+			safe_strerror (errno));
 }
 
 #ifndef B19200
@@ -721,54 +335,67 @@ baudtab[] =
 };
 
 static int
-rate_to_code (rate)
-     int rate;
+rate_to_code (int rate)
 {
   int i;
 
   for (i = 0; baudtab[i].rate != -1; i++)
-    if (rate == baudtab[i].rate)
-      return baudtab[i].code;
-
+    {
+      /* test for perfect macth.  */
+      if (rate == baudtab[i].rate)
+        return baudtab[i].code;
+      else
+        {
+	  /* check if it is in between valid values.  */
+          if (rate < baudtab[i].rate)
+	    {
+	      if (i)
+	        {
+	          warning (_("Invalid baud rate %d.  "
+			     "Closest values are %d and %d."),
+			   rate, baudtab[i - 1].rate, baudtab[i].rate);
+		}
+	      else
+	        {
+	          warning (_("Invalid baud rate %d.  Minimum value is %d."),
+			   rate, baudtab[0].rate);
+		}
+	      return -1;
+	    }
+        }
+    }
+ 
+  /* The requested speed was too large.  */
+  warning (_("Invalid baud rate %d.  Maximum value is %d."),
+            rate, baudtab[i - 1].rate);
   return -1;
 }
 
 static int
-hardwire_setbaudrate (scb, rate)
-     serial_t scb;
-     int rate;
+hardwire_setbaudrate (struct serial *scb, int rate)
 {
   struct hardwire_ttystate state;
+  int baud_code = rate_to_code (rate);
+  
+  if (baud_code < 0)
+    {
+      /* The baud rate was not valid.
+         A warning has already been issued.  */
+      errno = EINVAL;
+      return -1;
+    }
 
   if (get_tty_state (scb, &state))
     return -1;
 
-#ifdef HAVE_TERMIOS
-  cfsetospeed (&state.termios, rate_to_code (rate));
-  cfsetispeed (&state.termios, rate_to_code (rate));
-#endif
-
-#ifdef HAVE_TERMIO
-#ifndef CIBAUD
-#define CIBAUD CBAUD
-#endif
-
-  state.termio.c_cflag &= ~(CBAUD | CIBAUD);
-  state.termio.c_cflag |= rate_to_code (rate);
-#endif
-
-#ifdef HAVE_SGTTY
-  state.sgttyb.sg_ispeed = rate_to_code (rate);
-  state.sgttyb.sg_ospeed = rate_to_code (rate);
-#endif
+  cfsetospeed (&state.termios, baud_code);
+  cfsetispeed (&state.termios, baud_code);
 
   return set_tty_state (scb, &state);
 }
 
 static int
-hardwire_setstopbits (scb, num)
-     serial_t scb;
-     int num;
+hardwire_setstopbits (struct serial *scb, int num)
 {
   struct hardwire_ttystate state;
   int newbit;
@@ -789,50 +416,51 @@ hardwire_setstopbits (scb, num)
       return 1;
     }
 
-#ifdef HAVE_TERMIOS
   if (!newbit)
     state.termios.c_cflag &= ~CSTOPB;
   else
     state.termios.c_cflag |= CSTOPB;	/* two bits */
-#endif
-
-#ifdef HAVE_TERMIO
-  if (!newbit)
-    state.termio.c_cflag &= ~CSTOPB;
-  else
-    state.termio.c_cflag |= CSTOPB;	/* two bits */
-#endif
-
-#ifdef HAVE_SGTTY
-  return 0;			/* sgtty doesn't support this */
-#endif
 
   return set_tty_state (scb, &state);
 }
 
+/* Implement the "setparity" serial_ops callback.  */
+
 static int
-hardwire_write (scb, str, len)
-     serial_t scb;
-     const char *str;
-     int len;
+hardwire_setparity (struct serial *scb, int parity)
 {
-  int cc;
+  struct hardwire_ttystate state;
+  int newparity = 0;
 
-  while (len > 0)
-    {
-      cc = write (scb->fd, str, len);
+  if (get_tty_state (scb, &state))
+    return -1;
 
-      if (cc < 0)
-	return 1;
-      len -= cc;
-      str += cc;
+  switch (parity)
+    {
+    case GDBPARITY_NONE:
+      newparity = 0;
+      break;
+    case GDBPARITY_ODD:
+      newparity = PARENB | PARODD;
+      break;
+    case GDBPARITY_EVEN:
+      newparity = PARENB;
+      break;
+    default:
+      internal_warning (__FILE__, __LINE__,
+			"Incorrect parity value: %d", parity);
+      return -1;
     }
-  return 0;
+
+  state.termios.c_cflag &= ~(PARENB | PARODD);
+  state.termios.c_cflag |= newparity;
+
+  return set_tty_state (scb, &state);
 }
 
+
 static void
-hardwire_close (scb)
-     serial_t scb;
+hardwire_close (struct serial *scb)
 {
   if (scb->fd < 0)
     return;
@@ -840,30 +468,62 @@ hardwire_close (scb)
   close (scb->fd);
   scb->fd = -1;
 }
+
+
 
-static struct serial_ops hardwire_ops =
+/* The hardwire ops.  */
+
+static const struct serial_ops hardwire_ops =
 {
   "hardwire",
-  0,
   hardwire_open,
   hardwire_close,
-  hardwire_readchar,
-  hardwire_write,
+  NULL,
+  ser_base_readchar,
+  ser_base_write,
   hardwire_flush_output,
   hardwire_flush_input,
   hardwire_send_break,
   hardwire_raw,
   hardwire_get_tty_state,
+  hardwire_copy_tty_state,
   hardwire_set_tty_state,
   hardwire_print_tty_state,
-  hardwire_noflush_set_tty_state,
   hardwire_setbaudrate,
   hardwire_setstopbits,
-  hardwire_drain_output,	/* wait for output to drain */
+  hardwire_setparity,
+  hardwire_drain_output,
+  ser_base_async,
+  ser_unix_read_prim,
+  ser_unix_write_prim
 };
 
 void
-_initialize_ser_hardwire ()
+_initialize_ser_hardwire (void)
 {
   serial_add_interface (&hardwire_ops);
+
+#ifdef CRTSCTS
+  add_setshow_boolean_cmd ("remoteflow", no_class,
+			   &serial_hwflow, _("\
+Set use of hardware flow control for remote serial I/O."), _("\
+Show use of hardware flow control for remote serial I/O."), _("\
+Enable or disable hardware flow control (RTS/CTS) on the serial port\n\
+when debugging using remote targets."),
+			   NULL,
+			   show_serial_hwflow,
+			   &setlist, &showlist);
+#endif
+}
+
+int
+ser_unix_read_prim (struct serial *scb, size_t count)
+{
+  return read (scb->fd, scb->buf, count);
+}
+
+int
+ser_unix_write_prim (struct serial *scb, const void *buf, size_t len)
+{
+  return write (scb->fd, buf, len);
 }