* NEWS: Mention native Windows support.

	* Makefile.in (gdb_select_h, ser_tcp_h): New.
	(ALLDEPFILES): Add ser-mingw.c.
	(event-loop.o, inflow.o, mingw-hdep.o, posix-hdep.o, ser-base.o)
	(ser-tcp.o, ser-unix.o): Update.
	(ser-mingw.o): New rule.
	* configure: Regenerated.
	* configure.ac: Add ser-mingw.o for mingw32.
	* ser-mingw.c: New file.
	* event-loop.c: Include "gdb_select.h".
	(gdb_select): Remove, moved to mingw-hdep.c and posix-hdep.c.
	* ser-base.c: Include "gdb_select.h".
	(ser_base_wait_for): Use gdb_select.
	* serial.c (serial_for_fd): New function.
	(serial_fdopen): Try "terminal" before "hardwire".  Initialize
	the allocated struct serial.
	(serial_wait_handle): New function.
	* serial.h (serial_for_fd, serial_wait_handle): New prototypes.
	(struct serial_ops) [USE_WIN32API]: Add wait_handle.
	* gdb_select.h: New file.
	* ser-tcp.c: Include "ser-tcp.h".  Remove unused "ser-unix.h" include.
	(net_close, net_read_prim, net_write_prim): Make global.
	(net_open): Likewise.  Pass an exception set to select.  Whitespace fix.
	Document why we can not use gdb_select.
	(_initialize_ser_tcp) [USE_WIN32API]: Do not register TCP support here.
	* ser-tcp.h: New file.
	* inflow.c (gdb_has_a_terminal): Don't initialize stdin_serial here.
	(handle_sigio): Use gdb_select.
	(initialize_stdin_serial): New function.
	* terminal.h (initialize_stdin_serial): New prototype.
	* top.c (gdb_init): Call initialize_stdin_serial.
	* mingw-hdep.c (gdb_select): New function, moved from gdb_select in
	event-loop.c.  Add exception condition support.  Use serial_for_fd
	and serial_wait_handle.  Fix timeout handling.
	* posix-hdep.c: Include "gdb_select.h".
	(gdb_select): New function.
	* remote-st.c (connect_command): Use gdb_select.
	* ser-unix.c: Include "gdb_select.h".
	(hardwire_send_break, wait_for): Use gdb_select.

1 files changed, 796 insertions, 0 deletions

diff --git a/gdb/ser-mingw.c b/gdb/ser-mingw.c
new file mode 100644
index 00000000000..7a6f232379e
--- /dev/null
+++ b/gdb/ser-mingw.c
@@ -0,0 +1,796 @@
+/* Serial interface for local (hardwired) serial ports on Windows systems
+
+   Copyright (C) 2006
+   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
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   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., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.  */
+
+#include "defs.h"
+#include "serial.h"
+#include "ser-base.h"
+#include "ser-tcp.h"
+
+#include <windows.h>
+
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/types.h>
+
+#include "gdb_assert.h"
+#include "gdb_string.h"
+
+void _initialize_ser_windows (void);
+
+struct ser_windows_state
+{
+  int in_progress;
+  OVERLAPPED ov;
+  DWORD lastCommMask;
+  HANDLE except_event;
+};
+
+/* Open up a real live device for serial I/O.  */
+
+static int
+ser_windows_open (struct serial *scb, const char *name)
+{
+  HANDLE h;
+  struct ser_windows_state *state;
+  COMMTIMEOUTS timeouts;
+
+  /* Only allow COM ports.  */
+  if (strncmp (name, "COM", 3) != 0)
+    {
+      errno = ENOENT;
+      return -1;
+    }
+
+  h = CreateFile (name, GENERIC_READ | GENERIC_WRITE, 0, NULL,
+		  OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);
+  if (h == INVALID_HANDLE_VALUE)
+    {
+      errno = ENOENT;
+      return -1;
+    }
+
+  scb->fd = _open_osfhandle ((long) h, O_RDWR);
+  if (scb->fd < 0)
+    {
+      errno = ENOENT;
+      return -1;
+    }
+
+  if (!SetCommMask (h, EV_RXCHAR))
+    {
+      errno = EINVAL;
+      return -1;
+    }
+
+  timeouts.ReadIntervalTimeout = MAXDWORD;
+  timeouts.ReadTotalTimeoutConstant = 0;
+  timeouts.ReadTotalTimeoutMultiplier = 0;
+  timeouts.WriteTotalTimeoutConstant = 0;
+  timeouts.WriteTotalTimeoutMultiplier = 0;
+  if (!SetCommTimeouts (h, &timeouts))
+    {
+      errno = EINVAL;
+      return -1;
+    }
+
+  state = xmalloc (sizeof (struct ser_windows_state));
+  memset (state, 0, sizeof (struct ser_windows_state));
+  scb->state = state;
+
+  /* Create a manual reset event to watch the input buffer.  */
+  state->ov.hEvent = CreateEvent (0, TRUE, FALSE, 0);
+
+  /* Create a (currently unused) handle to record exceptions.  */
+  state->except_event = CreateEvent (0, TRUE, FALSE, 0);
+
+  return 0;
+}
+
+/* Wait for the output to drain away, as opposed to flushing (discarding)
+   it.  */
+
+static int
+ser_windows_drain_output (struct serial *scb)
+{
+  HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
+
+  return (FlushFileBuffers (h) != 0) ? 0 : -1;
+}
+
+static int
+ser_windows_flush_output (struct serial *scb)
+{
+  HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
+
+  return (PurgeComm (h, PURGE_TXCLEAR) != 0) ? 0 : -1;
+}
+
+static int
+ser_windows_flush_input (struct serial *scb)
+{
+  HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
+
+  return (PurgeComm (h, PURGE_RXCLEAR) != 0) ? 0 : -1;
+}
+
+static int
+ser_windows_send_break (struct serial *scb)
+{
+  HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
+
+  if (SetCommBreak (h) == 0)
+    return -1;
+
+  /* Delay for 250 milliseconds.  */
+  Sleep (250);
+
+  if (ClearCommBreak (h))
+    return -1;
+
+  return 0;
+}
+
+static void
+ser_windows_raw (struct serial *scb)
+{
+  HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
+  DCB state;
+
+  if (GetCommState (h, &state) == 0)
+    return;
+
+  state.fParity = FALSE;
+  state.fOutxCtsFlow = FALSE;
+  state.fOutxDsrFlow = FALSE;
+  state.fDtrControl = DTR_CONTROL_ENABLE;
+  state.fDsrSensitivity = FALSE;
+  state.fOutX = FALSE;
+  state.fInX = FALSE;
+  state.fNull = FALSE;
+  state.fAbortOnError = FALSE;
+  state.ByteSize = 8;
+  state.Parity = NOPARITY;
+
+  scb->current_timeout = 0;
+
+  if (SetCommState (h, &state) == 0)
+    warning (_("SetCommState failed\n"));
+}
+
+static int
+ser_windows_setstopbits (struct serial *scb, int num)
+{
+  HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
+  DCB state;
+
+  if (GetCommState (h, &state) == 0)
+    return -1;
+
+  switch (num)
+    {
+    case SERIAL_1_STOPBITS:
+      state.StopBits = ONESTOPBIT;
+      break;
+    case SERIAL_1_AND_A_HALF_STOPBITS:
+      state.StopBits = ONE5STOPBITS;
+      break;
+    case SERIAL_2_STOPBITS:
+      state.StopBits = TWOSTOPBITS;
+      break;
+    default:
+      return 1;
+    }
+
+  return (SetCommState (h, &state) != 0) ? 0 : -1;
+}
+
+static int
+ser_windows_setbaudrate (struct serial *scb, int rate)
+{
+  HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
+  DCB state;
+
+  if (GetCommState (h, &state) == 0)
+    return -1;
+
+  state.BaudRate = rate;
+
+  return (SetCommState (h, &state) != 0) ? 0 : -1;
+}
+
+static void
+ser_windows_close (struct serial *scb)
+{
+  struct ser_windows_state *state;
+
+  /* Stop any pending selects.  */
+  CancelIo ((HANDLE) _get_osfhandle (scb->fd));
+  state = scb->state;
+  CloseHandle (state->ov.hEvent);
+  CloseHandle (state->except_event);
+
+  if (scb->fd < 0)
+    return;
+
+  close (scb->fd);
+  scb->fd = -1;
+
+  xfree (scb->state);
+}
+
+static void
+ser_windows_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except)
+{
+  struct ser_windows_state *state;
+  COMSTAT status;
+  DWORD errors;
+  HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
+
+  state = scb->state;
+
+  *except = state->except_event;
+  *read = state->ov.hEvent;
+
+  if (state->in_progress)
+    return;
+
+  /* Reset the mask - we are only interested in any characters which
+     arrive after this point, not characters which might have arrived
+     and already been read.  */
+
+  /* This really, really shouldn't be necessary - just the second one.
+     But otherwise an internal flag for EV_RXCHAR does not get
+     cleared, and we get a duplicated event, if the last batch
+     of characters included at least two arriving close together.  */
+  if (!SetCommMask (h, 0))
+    warning (_("ser_windows_wait_handle: reseting mask failed"));
+
+  if (!SetCommMask (h, EV_RXCHAR))
+    warning (_("ser_windows_wait_handle: reseting mask failed (2)"));
+
+  /* There's a potential race condition here; we must check cbInQue
+     and not wait if that's nonzero.  */
+
+  ClearCommError (h, &errors, &status);
+  if (status.cbInQue > 0)
+    {
+      SetEvent (state->ov.hEvent);
+      return;
+    }
+
+  state->in_progress = 1;
+  ResetEvent (state->ov.hEvent);
+  state->lastCommMask = -2;
+  if (WaitCommEvent (h, &state->lastCommMask, &state->ov))
+    {
+      gdb_assert (state->lastCommMask & EV_RXCHAR);
+      SetEvent (state->ov.hEvent);
+    }
+  else
+    gdb_assert (GetLastError () == ERROR_IO_PENDING);
+}
+
+static int
+ser_windows_read_prim (struct serial *scb, size_t count)
+{
+  struct ser_windows_state *state;
+  OVERLAPPED ov;
+  DWORD bytes_read, bytes_read_tmp;
+  HANDLE h;
+  gdb_byte *p;
+
+  state = scb->state;
+  if (state->in_progress)
+    {
+      WaitForSingleObject (state->ov.hEvent, INFINITE);
+      state->in_progress = 0;
+      ResetEvent (state->ov.hEvent);
+    }
+
+  memset (&ov, 0, sizeof (OVERLAPPED));
+  ov.hEvent = CreateEvent (0, FALSE, FALSE, 0);
+  h = (HANDLE) _get_osfhandle (scb->fd);
+
+  if (!ReadFile (h, scb->buf, /* count */ 1, &bytes_read, &ov))
+    {
+      if (GetLastError () != ERROR_IO_PENDING
+	  || !GetOverlappedResult (h, &ov, &bytes_read, TRUE))
+	bytes_read = -1;
+    }
+
+  CloseHandle (ov.hEvent);
+  return bytes_read;
+}
+
+static int
+ser_windows_write_prim (struct serial *scb, const void *buf, size_t len)
+{
+  struct ser_windows_state *state;
+  OVERLAPPED ov;
+  DWORD bytes_written;
+  HANDLE h;
+
+  memset (&ov, 0, sizeof (OVERLAPPED));
+  ov.hEvent = CreateEvent (0, FALSE, FALSE, 0);
+  h = (HANDLE) _get_osfhandle (scb->fd);
+  if (!WriteFile (h, buf, len, &bytes_written, &ov))
+    {
+      if (GetLastError () != ERROR_IO_PENDING
+	  || !GetOverlappedResult (h, &ov, &bytes_written, TRUE))
+	bytes_written = -1;
+    }
+
+  CloseHandle (ov.hEvent);
+  return bytes_written;
+}
+
+struct ser_console_state
+{
+  HANDLE read_event;
+  HANDLE except_event;
+
+  HANDLE start_select;
+  HANDLE stop_select;
+};
+
+static DWORD WINAPI
+console_select_thread (void *arg)
+{
+  struct serial *scb = arg;
+  struct ser_console_state *state, state_copy;
+  int event_index, fd;
+  HANDLE h;
+
+  /* Copy useful information out of the control block, to make sure
+     that we do not race with freeing it.  */
+  state_copy = *(struct ser_console_state *) scb->state;
+  state = &state_copy;
+  fd = scb->fd;
+
+  h = (HANDLE) _get_osfhandle (fd);
+
+  while (1)
+    {
+      HANDLE wait_events[2];
+      INPUT_RECORD record;
+      DWORD n_records;
+
+      wait_events[0] = state->start_select;
+      wait_events[1] = state->stop_select;
+
+      if (WaitForMultipleObjects (2, wait_events, FALSE, INFINITE) != WAIT_OBJECT_0)
+	{
+	  CloseHandle (state->stop_select);
+	  return 0;
+	}
+
+    retry:
+      wait_events[0] = state->stop_select;
+      wait_events[1] = h;
+
+      event_index = WaitForMultipleObjects (2, wait_events, FALSE, INFINITE);
+
+      if (event_index == WAIT_OBJECT_0
+	  || WaitForSingleObject (state->stop_select, 0) == WAIT_OBJECT_0)
+	{
+	  CloseHandle (state->stop_select);
+	  return 0;
+	}
+
+      if (event_index != WAIT_OBJECT_0 + 1)
+	{
+	  /* Wait must have failed; assume an error has occured, e.g.
+	     the handle has been closed.  */
+	  SetEvent (state->except_event);
+	  continue;
+	}
+
+      /* We've got a pending event on the console.  See if it's
+	 of interest.  */
+      if (!PeekConsoleInput (h, &record, 1, &n_records) || n_records != 1)
+	{
+	  /* Something went wrong.  Maybe the console is gone.  */
+	  SetEvent (state->except_event);
+	  continue;
+	}
+
+      if (record.EventType == KEY_EVENT && record.Event.KeyEvent.bKeyDown)
+	{
+	  /* This is really a keypress.  */
+	  SetEvent (state->read_event);
+	  continue;
+	}
+
+      /* Otherwise discard it and wait again.  */
+      ReadConsoleInput (h, &record, 1, &n_records);
+      goto retry;
+    }
+}
+
+static int
+fd_is_pipe (int fd)
+{
+  if (PeekNamedPipe ((HANDLE) _get_osfhandle (fd), NULL, 0, NULL, NULL, NULL))
+    return 1;
+  else
+    return 0;
+}
+
+static DWORD WINAPI
+pipe_select_thread (void *arg)
+{
+  struct serial *scb = arg;
+  struct ser_console_state *state, state_copy;
+  int event_index, fd;
+  HANDLE h;
+
+  /* Copy useful information out of the control block, to make sure
+     that we do not race with freeing it.  */
+  state_copy = *(struct ser_console_state *) scb->state;
+  state = &state_copy;
+  fd = scb->fd;
+
+  h = (HANDLE) _get_osfhandle (fd);
+
+  while (1)
+    {
+      HANDLE wait_events[2];
+      DWORD n_avail;
+
+      wait_events[0] = state->start_select;
+      wait_events[1] = state->stop_select;
+
+      if (WaitForMultipleObjects (2, wait_events, FALSE, INFINITE) != WAIT_OBJECT_0)
+	{
+	  CloseHandle (state->stop_select);
+	  return 0;
+	}
+
+    retry:
+      if (!PeekNamedPipe (h, NULL, 0, NULL, &n_avail, NULL))
+	{
+	  SetEvent (state->except_event);
+	  continue;
+	}
+
+      if (n_avail > 0)
+	{
+	  SetEvent (state->read_event);
+	  continue;
+	}
+
+      if (WaitForSingleObject (state->stop_select, 0) == WAIT_OBJECT_0)
+	{
+	  CloseHandle (state->stop_select);
+	  return 0;
+	}
+
+      Sleep (10);
+      goto retry;
+    }
+}
+
+static void
+ser_console_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except)
+{
+  struct ser_console_state *state = scb->state;
+
+  if (state == NULL)
+    {
+      DWORD threadId;
+      int is_tty;
+
+      is_tty = isatty (scb->fd);
+      if (!is_tty && !fd_is_pipe (scb->fd))
+	{
+	  *read = NULL;
+	  *except = NULL;
+	  return;
+	}
+
+      state = xmalloc (sizeof (struct ser_console_state));
+      memset (state, 0, sizeof (struct ser_console_state));
+      scb->state = state;
+
+      /* Create auto reset events to wake and terminate the select thread.  */
+      state->start_select = CreateEvent (0, FALSE, FALSE, 0);
+      state->stop_select = CreateEvent (0, FALSE, FALSE, 0);
+
+      /* Create our own events to report read and exceptions separately.
+	 The exception event is currently never used.  */
+      state->read_event = CreateEvent (0, FALSE, FALSE, 0);
+      state->except_event = CreateEvent (0, FALSE, FALSE, 0);
+
+      /* And finally start the select thread.  */
+      if (is_tty)
+	CreateThread (NULL, 0, console_select_thread, scb, 0, &threadId);
+      else
+	CreateThread (NULL, 0, pipe_select_thread, scb, 0, &threadId);
+    }
+
+  ResetEvent (state->read_event);
+  ResetEvent (state->except_event);
+
+  SetEvent (state->start_select);
+
+  *read = state->read_event;
+  *except = state->except_event;
+}
+
+static void
+ser_console_close (struct serial *scb)
+{
+  struct ser_console_state *state = scb->state;
+
+  if (scb->state)
+    {
+      SetEvent (state->stop_select);
+
+      CloseHandle (state->read_event);
+      CloseHandle (state->except_event);
+
+      xfree (scb->state);
+    }
+}
+
+struct ser_console_ttystate
+{
+  int is_a_tty;
+};
+
+static serial_ttystate
+ser_console_get_tty_state (struct serial *scb)
+{
+  if (isatty (scb->fd))
+    {
+      struct ser_console_ttystate *state;
+      state = (struct ser_console_ttystate *) xmalloc (sizeof *state);
+      state->is_a_tty = 1;
+      return state;
+    }
+  else
+    return NULL;
+}
+
+struct net_windows_state
+{
+  HANDLE read_event;
+  HANDLE except_event;
+
+  HANDLE start_select;
+  HANDLE stop_select;
+  HANDLE sock_event;
+};
+
+static DWORD WINAPI
+net_windows_select_thread (void *arg)
+{
+  struct serial *scb = arg;
+  struct net_windows_state *state, state_copy;
+  int event_index, fd;
+
+  /* Copy useful information out of the control block, to make sure
+     that we do not race with freeing it.  */
+  state_copy = *(struct net_windows_state *) scb->state;
+  state = &state_copy;
+  fd = scb->fd;
+
+  while (1)
+    {
+      HANDLE wait_events[2];
+      WSANETWORKEVENTS events;
+
+      wait_events[0] = state->start_select;
+      wait_events[1] = state->stop_select;
+
+      if (WaitForMultipleObjects (2, wait_events, FALSE, INFINITE) != WAIT_OBJECT_0)
+	{
+	  CloseHandle (state->stop_select);
+	  return 0;
+	}
+
+      wait_events[0] = state->stop_select;
+      wait_events[1] = state->sock_event;
+
+      event_index = WaitForMultipleObjects (2, wait_events, FALSE, INFINITE);
+
+      if (event_index == WAIT_OBJECT_0
+	  || WaitForSingleObject (state->stop_select, 0) == WAIT_OBJECT_0)
+	{
+	  CloseHandle (state->stop_select);
+	  return 0;
+	}
+
+      if (event_index != WAIT_OBJECT_0 + 1)
+	{
+	  /* Some error has occured.  Assume that this is an error
+	     condition.  */
+	  SetEvent (state->except_event);
+	  continue;
+	}
+
+      /* Enumerate the internal network events, and reset the object that
+	 signalled us to catch the next event.  */
+      WSAEnumNetworkEvents (fd, state->sock_event, &events);
+
+      if (events.lNetworkEvents & FD_READ)
+	SetEvent (state->read_event);
+
+      if (events.lNetworkEvents & FD_CLOSE)
+	SetEvent (state->except_event);
+    }
+}
+
+static void
+net_windows_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except)
+{
+  struct net_windows_state *state = scb->state;
+
+  ResetEvent (state->read_event);
+  ResetEvent (state->except_event);
+
+  SetEvent (state->start_select);
+
+  *read = state->read_event;
+  *except = state->except_event;
+}
+
+static int
+net_windows_open (struct serial *scb, const char *name)
+{
+  struct net_windows_state *state;
+  int ret;
+  DWORD threadId;
+
+  ret = net_open (scb, name);
+  if (ret != 0)
+    return ret;
+
+  state = xmalloc (sizeof (struct net_windows_state));
+  memset (state, 0, sizeof (struct net_windows_state));
+  scb->state = state;
+
+  /* Create auto reset events to wake and terminate the select thread.  */
+  state->start_select = CreateEvent (0, FALSE, FALSE, 0);
+  state->stop_select = CreateEvent (0, FALSE, FALSE, 0);
+
+  /* Associate an event with the socket.  */
+  state->sock_event = CreateEvent (0, TRUE, FALSE, 0);
+  WSAEventSelect (scb->fd, state->sock_event, FD_READ | FD_CLOSE);
+
+  /* Create our own events to report read and close separately.  */
+  state->read_event = CreateEvent (0, FALSE, FALSE, 0);
+  state->except_event = CreateEvent (0, FALSE, FALSE, 0);
+
+  /* And finally start the select thread.  */
+  CreateThread (NULL, 0, net_windows_select_thread, scb, 0, &threadId);
+
+  return 0;
+}
+
+
+static void
+net_windows_close (struct serial *scb)
+{
+  struct net_windows_state *state = scb->state;
+
+  SetEvent (state->stop_select);
+
+  CloseHandle (state->read_event);
+  CloseHandle (state->except_event);
+  CloseHandle (state->start_select);
+  CloseHandle (state->sock_event);
+
+  xfree (scb->state);
+
+  net_close (scb);
+}
+
+void
+_initialize_ser_windows (void)
+{
+  WSADATA wsa_data;
+  struct serial_ops *ops;
+
+  /* First register the serial port driver.  */
+
+  ops = XMALLOC (struct serial_ops);
+  memset (ops, 0, sizeof (struct serial_ops));
+  ops->name = "hardwire";
+  ops->next = 0;
+  ops->open = ser_windows_open;
+  ops->close = ser_windows_close;
+
+  ops->flush_output = ser_windows_flush_output;
+  ops->flush_input = ser_windows_flush_input;
+  ops->send_break = ser_windows_send_break;
+
+  /* These are only used for stdin; we do not need them for serial
+     ports, so supply the standard dummies.  */
+  ops->get_tty_state = ser_base_get_tty_state;
+  ops->set_tty_state = ser_base_set_tty_state;
+  ops->print_tty_state = ser_base_print_tty_state;
+  ops->noflush_set_tty_state = ser_base_noflush_set_tty_state;
+
+  ops->go_raw = ser_windows_raw;
+  ops->setbaudrate = ser_windows_setbaudrate;
+  ops->setstopbits = ser_windows_setstopbits;
+  ops->drain_output = ser_windows_drain_output;
+  ops->readchar = ser_base_readchar;
+  ops->write = ser_base_write;
+  ops->async = ser_base_async;
+  ops->read_prim = ser_windows_read_prim;
+  ops->write_prim = ser_windows_write_prim;
+  ops->wait_handle = ser_windows_wait_handle;
+
+  serial_add_interface (ops);
+
+  /* Next create the dummy serial driver used for terminals.  We only
+     provide the TTY-related methods.  */
+
+  ops = XMALLOC (struct serial_ops);
+  memset (ops, 0, sizeof (struct serial_ops));
+
+  ops->name = "terminal";
+  ops->next = 0;
+
+  ops->close = ser_console_close;
+  ops->get_tty_state = ser_console_get_tty_state;
+  ops->set_tty_state = ser_base_set_tty_state;
+  ops->print_tty_state = ser_base_print_tty_state;
+  ops->noflush_set_tty_state = ser_base_noflush_set_tty_state;
+  ops->drain_output = ser_base_drain_output;
+  ops->wait_handle = ser_console_wait_handle;
+
+  serial_add_interface (ops);
+
+  /* If WinSock works, register the TCP/UDP socket driver.  */
+
+  if (WSAStartup (MAKEWORD (1, 0), &wsa_data) != 0)
+    /* WinSock is unavailable.  */
+    return;
+
+  ops = XMALLOC (struct serial_ops);
+  memset (ops, 0, sizeof (struct serial_ops));
+  ops->name = "tcp";
+  ops->next = 0;
+  ops->open = net_windows_open;
+  ops->close = net_windows_close;
+  ops->readchar = ser_base_readchar;
+  ops->write = ser_base_write;
+  ops->flush_output = ser_base_flush_output;
+  ops->flush_input = ser_base_flush_input;
+  ops->send_break = ser_base_send_break;
+  ops->go_raw = ser_base_raw;
+  ops->get_tty_state = ser_base_get_tty_state;
+  ops->set_tty_state = ser_base_set_tty_state;
+  ops->print_tty_state = ser_base_print_tty_state;
+  ops->noflush_set_tty_state = ser_base_noflush_set_tty_state;
+  ops->setbaudrate = ser_base_setbaudrate;
+  ops->setstopbits = ser_base_setstopbits;
+  ops->drain_output = ser_base_drain_output;
+  ops->async = ser_base_async;
+  ops->read_prim = net_read_prim;
+  ops->write_prim = net_write_prim;
+  ops->wait_handle = net_windows_wait_handle;
+  serial_add_interface (ops);
+}