projects / deliverable / binutils-gdb.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Factor out "Detaching from program" message printing
[deliverable/binutils-gdb.git] / gdb / ser-mingw.c
diff --git a/gdb/ser-mingw.c b/gdb/ser-mingw.c
index 074687df618c6a6187b10889aef2d42ee12bf7c0..96ebd0eb7269d9e300fe0549498a8e624a7fe742 100644 (file)
--- a/gdb/ser-mingw.c
+++ b/gdb/ser-mingw.c
@@ -1,12 +1,12 @@
 /* Serial interface for local (hardwired) serial ports on Windows systems
 
 /* Serial interface for local (hardwired) serial ports on Windows systems
 
-   Copyright (C) 2006, 2007 Free Software Foundation, Inc.
+   Copyright (C) 2006-2016 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
 
    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,
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
@@ -15,9 +15,7 @@
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    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.  */
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include "defs.h"
 #include "serial.h"
 
 #include "defs.h"
 #include "serial.h"
@@ -31,8 +29,7 @@
 #include <unistd.h>
 #include <sys/types.h>
 
 #include <unistd.h>
 #include <sys/types.h>
 
-#include "gdb_assert.h"
-#include "gdb_string.h"
+#include "command.h"
 
 void _initialize_ser_windows (void);
 
 
 void _initialize_ser_windows (void);
 
@@ -44,6 +41,12 @@ struct ser_windows_state
   HANDLE except_event;
 };
 
   HANDLE except_event;
 };
 
+/* CancelIo is not available for Windows 95 OS, so we need to use
+   LoadLibrary/GetProcAddress to avoid a startup failure.  */
+#define CancelIo dyn_CancelIo
+typedef BOOL WINAPI (CancelIo_ftype) (HANDLE);
+static CancelIo_ftype *CancelIo;
+
 /* Open up a real live device for serial I/O.  */
 
 static int
 /* Open up a real live device for serial I/O.  */
 
 static int
@@ -53,13 +56,6 @@ ser_windows_open (struct serial *scb, const char *name)
   struct ser_windows_state *state;
   COMMTIMEOUTS timeouts;
 
   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)
   h = CreateFile (name, GENERIC_READ | GENERIC_WRITE, 0, NULL,
                  OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);
   if (h == INVALID_HANDLE_VALUE)
@@ -68,7 +64,7 @@ ser_windows_open (struct serial *scb, const char *name)
       return -1;
     }
 
       return -1;
     }
 
-  scb->fd = _open_osfhandle ((long) h, O_RDWR);
+  scb->fd = _open_osfhandle ((intptr_t) h, O_RDWR);
   if (scb->fd < 0)
     {
       errno = ENOENT;
   if (scb->fd < 0)
     {
       errno = ENOENT;
@@ -92,8 +88,7 @@ ser_windows_open (struct serial *scb, const char *name)
       return -1;
     }
 
       return -1;
     }
 
-  state = xmalloc (sizeof (struct ser_windows_state));
-  memset (state, 0, sizeof (struct ser_windows_state));
+  state = XCNEW (struct ser_windows_state);
   scb->state = state;
 
   /* Create a manual reset event to watch the input buffer.  */
   scb->state = state;
 
   /* Create a manual reset event to watch the input buffer.  */
@@ -158,7 +153,6 @@ ser_windows_raw (struct serial *scb)
   if (GetCommState (h, &state) == 0)
     return;
 
   if (GetCommState (h, &state) == 0)
     return;
 
-  state.fParity = FALSE;
   state.fOutxCtsFlow = FALSE;
   state.fOutxDsrFlow = FALSE;
   state.fDtrControl = DTR_CONTROL_ENABLE;
   state.fOutxCtsFlow = FALSE;
   state.fOutxDsrFlow = FALSE;
   state.fDtrControl = DTR_CONTROL_ENABLE;
@@ -168,12 +162,11 @@ ser_windows_raw (struct serial *scb)
   state.fNull = FALSE;
   state.fAbortOnError = FALSE;
   state.ByteSize = 8;
   state.fNull = FALSE;
   state.fAbortOnError = FALSE;
   state.ByteSize = 8;
-  state.Parity = NOPARITY;
 
   scb->current_timeout = 0;
 
   if (SetCommState (h, &state) == 0)
 
   scb->current_timeout = 0;
 
   if (SetCommState (h, &state) == 0)
-    warning (_("SetCommState failed\n"));
+    warning (_("SetCommState failed"));
 }
 
 static int
 }
 
 static int
@@ -203,6 +196,40 @@ ser_windows_setstopbits (struct serial *scb, int num)
   return (SetCommState (h, &state) != 0) ? 0 : -1;
 }
 
   return (SetCommState (h, &state) != 0) ? 0 : -1;
 }
 
+/* Implement the "setparity" serial_ops callback.  */
+
+static int
+ser_windows_setparity (struct serial *scb, int parity)
+{
+  HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
+  DCB state;
+
+  if (GetCommState (h, &state) == 0)
+    return -1;
+
+  switch (parity)
+    {
+    case GDBPARITY_NONE:
+      state.Parity = NOPARITY;
+      state.fParity = FALSE;
+      break;
+    case GDBPARITY_ODD:
+      state.Parity = ODDPARITY;
+      state.fParity = TRUE;
+      break;
+    case GDBPARITY_EVEN:
+      state.Parity = EVENPARITY;
+      state.fParity = TRUE;
+      break;
+    default:
+      internal_warning (__FILE__, __LINE__,
+                       "Incorrect parity value: %d", parity);
+      return -1;
+    }
+
+  return (SetCommState (h, &state) != 0) ? 0 : -1;
+}
+
 static int
 ser_windows_setbaudrate (struct serial *scb, int rate)
 {
 static int
 ser_windows_setbaudrate (struct serial *scb, int rate)
 {
@@ -222,9 +249,13 @@ ser_windows_close (struct serial *scb)
 {
   struct ser_windows_state *state;
 
 {
   struct ser_windows_state *state;
 
-  /* Stop any pending selects.  */
-  CancelIo ((HANDLE) _get_osfhandle (scb->fd));
-  state = scb->state;
+  /* Stop any pending selects.  On Windows 95 OS, CancelIo function does
+     not exist.  In that case, it can be replaced by a call to CloseHandle,
+     but this is not necessary here as we do close the Windows handle
+     by calling close (scb->fd) below.  */
+  if (CancelIo)
+    CancelIo ((HANDLE) _get_osfhandle (scb->fd));
+  state = (struct ser_windows_state *) scb->state;
   CloseHandle (state->ov.hEvent);
   CloseHandle (state->except_event);
 
   CloseHandle (state->ov.hEvent);
   CloseHandle (state->except_event);
 
@@ -245,7 +276,7 @@ ser_windows_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except)
   DWORD errors;
   HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
 
   DWORD errors;
   HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
 
-  state = scb->state;
+  state = (struct ser_windows_state *) scb->state;
 
   *except = state->except_event;
   *read = state->ov.hEvent;
 
   *except = state->except_event;
   *read = state->ov.hEvent;
@@ -298,7 +329,7 @@ ser_windows_read_prim (struct serial *scb, size_t count)
   HANDLE h;
   gdb_byte *p;
 
   HANDLE h;
   gdb_byte *p;
 
-  state = scb->state;
+  state = (struct ser_windows_state *) scb->state;
   if (state->in_progress)
     {
       WaitForSingleObject (state->ov.hEvent, INFINITE);
   if (state->in_progress)
     {
       WaitForSingleObject (state->ov.hEvent, INFINITE);
@@ -343,28 +374,171 @@ ser_windows_write_prim (struct serial *scb, const void *buf, size_t len)
   return bytes_written;
 }
 
   return bytes_written;
 }
 
+/* On Windows, gdb_select is implemented using WaitForMulpleObjects.
+   A "select thread" is created for each file descriptor.  These
+   threads looks for activity on the corresponding descriptor, using
+   whatever techniques are appropriate for the descriptor type.  When
+   that activity occurs, the thread signals an appropriate event,
+   which wakes up WaitForMultipleObjects.
+
+   Each select thread is in one of two states: stopped or started.
+   Select threads begin in the stopped state.  When gdb_select is
+   called, threads corresponding to the descriptors of interest are
+   started by calling a wait_handle function.  Each thread that
+   notices activity signals the appropriate event and then reenters
+   the stopped state.  Before gdb_select returns it calls the
+   wait_handle_done functions, which return the threads to the stopped
+   state.  */
+
+enum select_thread_state {
+  STS_STARTED,
+  STS_STOPPED
+};
+
 struct ser_console_state
 {
 struct ser_console_state
 {
+  /* Signaled by the select thread to indicate that data is available
+     on the file descriptor.  */
   HANDLE read_event;
   HANDLE read_event;
+  /* Signaled by the select thread to indicate that an exception has
+     occurred on the file descriptor.  */
   HANDLE except_event;
   HANDLE except_event;
+  /* Signaled by the select thread to indicate that it has entered the
+     started state.  HAVE_STARTED and HAVE_STOPPED are never signaled
+     simultaneously.  */
+  HANDLE have_started;
+  /* Signaled by the select thread to indicate that it has stopped,
+     either because data is available (and READ_EVENT is signaled),
+     because an exception has occurred (and EXCEPT_EVENT is signaled),
+     or because STOP_SELECT was signaled.  */
+  HANDLE have_stopped;
 
 
+  /* Signaled by the main program to tell the select thread to enter
+     the started state.  */
   HANDLE start_select;
   HANDLE start_select;
+  /* Signaled by the main program to tell the select thread to enter
+     the stopped state.  */
   HANDLE stop_select;
   HANDLE stop_select;
+  /* Signaled by the main program to tell the select thread to
+     exit.  */
   HANDLE exit_select;
   HANDLE exit_select;
-  HANDLE have_stopped;
 
 
+  /* The handle for the select thread.  */
   HANDLE thread;
   HANDLE thread;
+  /* The state of the select thread.  This field is only accessed in
+     the main program, never by the select thread itself.  */
+  enum select_thread_state thread_state;
 };
 
 };
 
+/* Called by a select thread to enter the stopped state.  This
+   function does not return until the thread has re-entered the
+   started state.  */
+static void
+select_thread_wait (struct ser_console_state *state)
+{
+  HANDLE wait_events[2];
+
+  /* There are two things that can wake us up: a request that we enter
+     the started state, or that we exit this thread.  */
+  wait_events[0] = state->start_select;
+  wait_events[1] = state->exit_select;
+  if (WaitForMultipleObjects (2, wait_events, FALSE, INFINITE) 
+      != WAIT_OBJECT_0)
+    /* Either the EXIT_SELECT event was signaled (requesting that the
+       thread exit) or an error has occurred.  In either case, we exit
+       the thread.  */
+    ExitThread (0);
+  
+  /* We are now in the started state.  */
+  SetEvent (state->have_started);
+}
+
+typedef DWORD WINAPI (*thread_fn_type)(void *);
+
+/* Create a new select thread for SCB executing THREAD_FN.  The STATE
+   will be filled in by this function before return.  */
+static void
+create_select_thread (thread_fn_type thread_fn,
+                     struct serial *scb,
+                     struct ser_console_state *state)
+{
+  DWORD threadId;
+
+  /* Create all of the events.  These are all auto-reset events.  */
+  state->read_event = CreateEvent (NULL, FALSE, FALSE, NULL);
+  state->except_event = CreateEvent (NULL, FALSE, FALSE, NULL);
+  state->have_started = CreateEvent (NULL, FALSE, FALSE, NULL);
+  state->have_stopped = CreateEvent (NULL, FALSE, FALSE, NULL);
+  state->start_select = CreateEvent (NULL, FALSE, FALSE, NULL);
+  state->stop_select = CreateEvent (NULL, FALSE, FALSE, NULL);
+  state->exit_select = CreateEvent (NULL, FALSE, FALSE, NULL);
+
+  state->thread = CreateThread (NULL, 0, thread_fn, scb, 0, &threadId);
+  /* The thread begins in the stopped state.  */
+  state->thread_state = STS_STOPPED;
+}
+
+/* Destroy the select thread indicated by STATE.  */
+static void
+destroy_select_thread (struct ser_console_state *state)
+{
+  /* Ask the thread to exit.  */
+  SetEvent (state->exit_select);
+  /* Wait until it does.  */
+  WaitForSingleObject (state->thread, INFINITE);
+
+  /* Destroy the events.  */
+  CloseHandle (state->read_event);
+  CloseHandle (state->except_event);
+  CloseHandle (state->have_started);
+  CloseHandle (state->have_stopped);
+  CloseHandle (state->start_select);
+  CloseHandle (state->stop_select);
+  CloseHandle (state->exit_select);
+}
+
+/* Called by gdb_select to start the select thread indicated by STATE.
+   This function does not return until the thread has started.  */
+static void
+start_select_thread (struct ser_console_state *state)
+{
+  /* Ask the thread to start.  */
+  SetEvent (state->start_select);
+  /* Wait until it does.  */
+  WaitForSingleObject (state->have_started, INFINITE);
+  /* The thread is now started.  */
+  state->thread_state = STS_STARTED;
+}
+
+/* Called by gdb_select to stop the select thread indicated by STATE.
+   This function does not return until the thread has stopped.  */
+static void
+stop_select_thread (struct ser_console_state *state)
+{
+  /* If the thread is already in the stopped state, we have nothing to
+     do.  Some of the wait_handle functions avoid calling
+     start_select_thread if they notice activity on the relevant file
+     descriptors.  The wait_handle_done functions still call
+     stop_select_thread -- but it is already stopped.  */
+  if (state->thread_state != STS_STARTED)
+    return;
+  /* Ask the thread to stop.  */
+  SetEvent (state->stop_select);
+  /* Wait until it does.  */
+  WaitForSingleObject (state->have_stopped, INFINITE);
+  /* The thread is now stopped.  */
+  state->thread_state = STS_STOPPED;
+}
+
 static DWORD WINAPI
 console_select_thread (void *arg)
 {
 static DWORD WINAPI
 console_select_thread (void *arg)
 {
-  struct serial *scb = arg;
+  struct serial *scb = (struct serial *) arg;
   struct ser_console_state *state;
   int event_index;
   HANDLE h;
 
   struct ser_console_state *state;
   int event_index;
   HANDLE h;
 
-  state = scb->state;
+  state = (struct ser_console_state *) scb->state;
   h = (HANDLE) _get_osfhandle (scb->fd);
 
   while (1)
   h = (HANDLE) _get_osfhandle (scb->fd);
 
   while (1)
@@ -373,75 +547,72 @@ console_select_thread (void *arg)
       INPUT_RECORD record;
       DWORD n_records;
 
       INPUT_RECORD record;
       DWORD n_records;
 
-      SetEvent (state->have_stopped);
-
-      wait_events[0] = state->start_select;
-      wait_events[1] = state->exit_select;
-
-      if (WaitForMultipleObjects (2, wait_events, FALSE, INFINITE) != WAIT_OBJECT_0)
-       return 0;
-
-      ResetEvent (state->have_stopped);
+      select_thread_wait (state);
 
 
-    retry:
-      wait_events[0] = state->stop_select;
-      wait_events[1] = h;
+      while (1)
+       {
+         wait_events[0] = state->stop_select;
+         wait_events[1] = h;
 
 
-      event_index = WaitForMultipleObjects (2, wait_events, FALSE, INFINITE);
+         event_index = WaitForMultipleObjects (2, wait_events,
+                                               FALSE, INFINITE);
 
 
-      if (event_index == WAIT_OBJECT_0
-         || WaitForSingleObject (state->stop_select, 0) == WAIT_OBJECT_0)
-       continue;
+         if (event_index == WAIT_OBJECT_0
+             || WaitForSingleObject (state->stop_select, 0) == WAIT_OBJECT_0)
+           break;
 
 
-      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;
-       }
+         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);
+             break;
+           }
 
 
-      /* 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;
-       }
+         /* 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);
+             break;
+           }
 
 
-      if (record.EventType == KEY_EVENT && record.Event.KeyEvent.bKeyDown)
-       {
-         WORD keycode = record.Event.KeyEvent.wVirtualKeyCode;
-
-         /* Ignore events containing only control keys.  We must
-            recognize "enhanced" keys which we are interested in
-            reading via getch, if they do not map to ASCII.  But we
-            do not want to report input available for e.g. the
-            control key alone.  */
-
-         if (record.Event.KeyEvent.uChar.AsciiChar != 0
-             || keycode == VK_PRIOR
-             || keycode == VK_NEXT
-             || keycode == VK_END
-             || keycode == VK_HOME
-             || keycode == VK_LEFT
-             || keycode == VK_UP
-             || keycode == VK_RIGHT
-             || keycode == VK_DOWN
-             || keycode == VK_INSERT
-             || keycode == VK_DELETE)
+         if (record.EventType == KEY_EVENT && record.Event.KeyEvent.bKeyDown)
            {
            {
-             /* This is really a keypress.  */
-             SetEvent (state->read_event);
-             continue;
+             WORD keycode = record.Event.KeyEvent.wVirtualKeyCode;
+
+             /* Ignore events containing only control keys.  We must
+                recognize "enhanced" keys which we are interested in
+                reading via getch, if they do not map to ASCII.  But we
+                do not want to report input available for e.g. the
+                control key alone.  */
+
+             if (record.Event.KeyEvent.uChar.AsciiChar != 0
+                 || keycode == VK_PRIOR
+                 || keycode == VK_NEXT
+                 || keycode == VK_END
+                 || keycode == VK_HOME
+                 || keycode == VK_LEFT
+                 || keycode == VK_UP
+                 || keycode == VK_RIGHT
+                 || keycode == VK_DOWN
+                 || keycode == VK_INSERT
+                 || keycode == VK_DELETE)
+               {
+                 /* This is really a keypress.  */
+                 SetEvent (state->read_event);
+                 break;
+               }
            }
            }
+
+         /* Otherwise discard it and wait again.  */
+         ReadConsoleInput (h, &record, 1, &n_records);
        }
 
        }
 
-      /* Otherwise discard it and wait again.  */
-      ReadConsoleInput (h, &record, 1, &n_records);
-      goto retry;
+      SetEvent(state->have_stopped);
     }
     }
+  return 0;
 }
 
 static int
 }
 
 static int
@@ -453,97 +624,113 @@ fd_is_pipe (int fd)
     return 0;
 }
 
     return 0;
 }
 
+static int
+fd_is_file (int fd)
+{
+  if (GetFileType ((HANDLE) _get_osfhandle (fd)) == FILE_TYPE_DISK)
+    return 1;
+  else
+    return 0;
+}
+
 static DWORD WINAPI
 pipe_select_thread (void *arg)
 {
 static DWORD WINAPI
 pipe_select_thread (void *arg)
 {
-  struct serial *scb = arg;
+  struct serial *scb = (struct serial *) arg;
   struct ser_console_state *state;
   int event_index;
   HANDLE h;
 
   struct ser_console_state *state;
   int event_index;
   HANDLE h;
 
-  state = scb->state;
+  state = (struct ser_console_state *) scb->state;
   h = (HANDLE) _get_osfhandle (scb->fd);
 
   while (1)
     {
   h = (HANDLE) _get_osfhandle (scb->fd);
 
   while (1)
     {
-      HANDLE wait_events[2];
       DWORD n_avail;
 
       DWORD n_avail;
 
-      SetEvent (state->have_stopped);
-
-      wait_events[0] = state->start_select;
-      wait_events[1] = state->exit_select;
+      select_thread_wait (state);
 
 
-      if (WaitForMultipleObjects (2, wait_events, FALSE, INFINITE) != WAIT_OBJECT_0)
-       return 0;
+      /* Wait for something to happen on the pipe.  */
+      while (1)
+       {
+         if (!PeekNamedPipe (h, NULL, 0, NULL, &n_avail, NULL))
+           {
+             SetEvent (state->except_event);
+             break;
+           }
 
 
-      ResetEvent (state->have_stopped);
+         if (n_avail > 0)
+           {
+             SetEvent (state->read_event);
+             break;
+           }
 
 
-    retry:
-      if (!PeekNamedPipe (h, NULL, 0, NULL, &n_avail, NULL))
-       {
-         SetEvent (state->except_event);
-         continue;
+         /* Delay 10ms before checking again, but allow the stop
+            event to wake us.  */
+         if (WaitForSingleObject (state->stop_select, 10) == WAIT_OBJECT_0)
+           break;
        }
 
        }
 
-      if (n_avail > 0)
-       {
-         SetEvent (state->read_event);
-         continue;
-       }
+      SetEvent (state->have_stopped);
+    }
+  return 0;
+}
+
+static DWORD WINAPI
+file_select_thread (void *arg)
+{
+  struct serial *scb = (struct serial *) arg;
+  struct ser_console_state *state;
+  int event_index;
+  HANDLE h;
+
+  state = (struct ser_console_state *) scb->state;
+  h = (HANDLE) _get_osfhandle (scb->fd);
 
 
-      /* Delay 10ms before checking again, but allow the stop event
-        to wake us.  */
-      if (WaitForSingleObject (state->stop_select, 10) == WAIT_OBJECT_0)
-       continue;
+  while (1)
+    {
+      select_thread_wait (state);
 
 
-      goto retry;
+      if (SetFilePointer (h, 0, NULL, FILE_CURRENT)
+         == INVALID_SET_FILE_POINTER)
+       SetEvent (state->except_event);
+      else
+       SetEvent (state->read_event);
+
+      SetEvent (state->have_stopped);
     }
     }
+  return 0;
 }
 
 static void
 ser_console_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except)
 {
 }
 
 static void
 ser_console_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except)
 {
-  struct ser_console_state *state = scb->state;
+  struct ser_console_state *state = (struct ser_console_state *) scb->state;
 
   if (state == NULL)
     {
 
   if (state == NULL)
     {
-      DWORD threadId;
+      thread_fn_type thread_fn;
       int is_tty;
 
       is_tty = isatty (scb->fd);
       int is_tty;
 
       is_tty = isatty (scb->fd);
-      if (!is_tty && !fd_is_pipe (scb->fd))
+      if (!is_tty && !fd_is_file (scb->fd) && !fd_is_pipe (scb->fd))
        {
          *read = NULL;
          *except = NULL;
          return;
        }
 
        {
          *read = NULL;
          *except = NULL;
          return;
        }
 
-      state = xmalloc (sizeof (struct ser_console_state));
-      memset (state, 0, sizeof (struct ser_console_state));
+      state = XCNEW (struct ser_console_state);
       scb->state = state;
 
       scb->state = state;
 
-      /* Create auto reset events to wake, stop, and exit the select
-        thread.  */
-      state->start_select = CreateEvent (0, FALSE, FALSE, 0);
-      state->stop_select = CreateEvent (0, FALSE, FALSE, 0);
-      state->exit_select = CreateEvent (0, FALSE, FALSE, 0);
-
-      /* Create a manual reset event to signal whether the thread is
-        stopped.  This must be manual reset, because we may wait on
-        it multiple times without ever starting the thread.  */
-      state->have_stopped = CreateEvent (0, TRUE, FALSE, 0);
-
-      /* Create our own events to report read and exceptions separately.  */
-      state->read_event = CreateEvent (0, FALSE, FALSE, 0);
-      state->except_event = CreateEvent (0, FALSE, FALSE, 0);
-
       if (is_tty)
       if (is_tty)
-       state->thread = CreateThread (NULL, 0, console_select_thread, scb, 0,
-                                     &threadId);
+       thread_fn = console_select_thread;
+      else if (fd_is_pipe (scb->fd))
+       thread_fn = pipe_select_thread;
       else
       else
-       state->thread = CreateThread (NULL, 0, pipe_select_thread, scb, 0,
-                                     &threadId);
+       thread_fn = file_select_thread;
+
+      create_select_thread (thread_fn, scb, state);
     }
 
   *read = state->read_event;
     }
 
   *read = state->read_event;
@@ -566,40 +753,28 @@ ser_console_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except)
     }
 
   /* Otherwise, start the select thread.  */
     }
 
   /* Otherwise, start the select thread.  */
-  SetEvent (state->start_select);
+  start_select_thread (state);
 }
 
 static void
 ser_console_done_wait_handle (struct serial *scb)
 {
 }
 
 static void
 ser_console_done_wait_handle (struct serial *scb)
 {
-  struct ser_console_state *state = scb->state;
+  struct ser_console_state *state = (struct ser_console_state *) scb->state;
 
   if (state == NULL)
     return;
 
 
   if (state == NULL)
     return;
 
-  SetEvent (state->stop_select);
-  WaitForSingleObject (state->have_stopped, INFINITE);
+  stop_select_thread (state);
 }
 
 static void
 ser_console_close (struct serial *scb)
 {
 }
 
 static void
 ser_console_close (struct serial *scb)
 {
-  struct ser_console_state *state = scb->state;
+  struct ser_console_state *state = (struct ser_console_state *) scb->state;
 
   if (scb->state)
     {
 
   if (scb->state)
     {
-      SetEvent (state->exit_select);
-
-      WaitForSingleObject (state->thread, INFINITE);
-
-      CloseHandle (state->start_select);
-      CloseHandle (state->stop_select);
-      CloseHandle (state->exit_select);
-      CloseHandle (state->have_stopped);
-
-      CloseHandle (state->read_event);
-      CloseHandle (state->except_event);
-
+      destroy_select_thread (state);
       xfree (scb->state);
     }
 }
       xfree (scb->state);
     }
 }
@@ -615,7 +790,8 @@ ser_console_get_tty_state (struct serial *scb)
   if (isatty (scb->fd))
     {
       struct ser_console_ttystate *state;
   if (isatty (scb->fd))
     {
       struct ser_console_ttystate *state;
-      state = (struct ser_console_ttystate *) xmalloc (sizeof *state);
+
+      state = XNEW (struct ser_console_ttystate);
       state->is_a_tty = 1;
       return state;
     }
       state->is_a_tty = 1;
       return state;
     }
@@ -640,9 +816,8 @@ struct pipe_state
 static struct pipe_state *
 make_pipe_state (void)
 {
 static struct pipe_state *
 make_pipe_state (void)
 {
-  struct pipe_state *ps = XMALLOC (struct pipe_state);
+  struct pipe_state *ps = XCNEW (struct pipe_state);
 
 
-  memset (ps, 0, sizeof (*ps));
   ps->wait.read_event = INVALID_HANDLE_VALUE;
   ps->wait.except_event = INVALID_HANDLE_VALUE;
   ps->wait.start_select = INVALID_HANDLE_VALUE;
   ps->wait.read_event = INVALID_HANDLE_VALUE;
   ps->wait.except_event = INVALID_HANDLE_VALUE;
   ps->wait.start_select = INVALID_HANDLE_VALUE;
@@ -657,19 +832,7 @@ free_pipe_state (struct pipe_state *ps)
   int saved_errno = errno;
 
   if (ps->wait.read_event != INVALID_HANDLE_VALUE)
   int saved_errno = errno;
 
   if (ps->wait.read_event != INVALID_HANDLE_VALUE)
-    {
-      SetEvent (ps->wait.exit_select);
-
-      WaitForSingleObject (ps->wait.thread, INFINITE);
-
-      CloseHandle (ps->wait.start_select);
-      CloseHandle (ps->wait.stop_select);
-      CloseHandle (ps->wait.exit_select);
-      CloseHandle (ps->wait.have_stopped);
-
-      CloseHandle (ps->wait.read_event);
-      CloseHandle (ps->wait.except_event);
-    }
+    destroy_select_thread (&ps->wait);
 
   /* Close the pipe to the child.  We must close the pipe before
      calling pex_free because pex_free will wait for the child to exit
 
   /* Close the pipe to the child.  We must close the pipe before
      calling pex_free because pex_free will wait for the child to exit
@@ -677,8 +840,12 @@ free_pipe_state (struct pipe_state *ps)
   if (ps->input)
     fclose (ps->input);
   if (ps->pex)
   if (ps->input)
     fclose (ps->input);
   if (ps->pex)
-    pex_free (ps->pex);
-  /* pex_free closes ps->output.  */
+    {
+      pex_free (ps->pex);
+      /* pex_free closes ps->output.  */
+    }
+  else if (ps->output)
+    fclose (ps->output);
 
   xfree (ps);
 
 
   xfree (ps);
 
@@ -688,7 +855,7 @@ free_pipe_state (struct pipe_state *ps)
 static void
 cleanup_pipe_state (void *untyped)
 {
 static void
 cleanup_pipe_state (void *untyped)
 {
-  struct pipe_state *ps = untyped;
+  struct pipe_state *ps = (struct pipe_state *) untyped;
 
   free_pipe_state (ps);
 }
 
   free_pipe_state (ps);
 }
@@ -698,12 +865,17 @@ pipe_windows_open (struct serial *scb, const char *name)
 {
   struct pipe_state *ps;
   FILE *pex_stderr;
 {
   struct pipe_state *ps;
   FILE *pex_stderr;
+  char **argv;
+  struct cleanup *back_to;
 
 
-  char **argv = buildargv (name);
-  struct cleanup *back_to = make_cleanup_freeargv (argv);
-  if (! argv[0] || argv[0][0] == '\0')
-    error ("missing child command");
+  if (name == NULL)
+    error_no_arg (_("child command"));
 
 
+  argv = gdb_buildargv (name);
+  back_to = make_cleanup_freeargv (argv);
+
+  if (! argv[0] || argv[0][0] == '\0')
+    error (_("missing child command"));
 
   ps = make_pipe_state ();
   make_cleanup (cleanup_pipe_state, ps);
 
   ps = make_pipe_state ();
   make_cleanup (cleanup_pipe_state, ps);
@@ -730,10 +902,10 @@ pipe_windows_open (struct serial *scb, const char *name)
            all the same information here, plus err_msg provided by
            pex_run, so we just raise the error here.  */
         if (err)
            all the same information here, plus err_msg provided by
            pex_run, so we just raise the error here.  */
         if (err)
-          error ("error starting child process '%s': %s: %s",
+          error (_("error starting child process '%s': %s: %s"),
                  name, err_msg, safe_strerror (err));
         else
                  name, err_msg, safe_strerror (err));
         else
-          error ("error starting child process '%s': %s",
+          error (_("error starting child process '%s': %s"),
                  name, err_msg);
       }
   }
                  name, err_msg);
       }
   }
@@ -758,11 +930,35 @@ pipe_windows_open (struct serial *scb, const char *name)
   return -1;
 }
 
   return -1;
 }
 
+static int
+pipe_windows_fdopen (struct serial *scb, int fd)
+{
+  struct pipe_state *ps;
+
+  ps = make_pipe_state ();
+
+  ps->input = fdopen (fd, "r+");
+  if (! ps->input)
+    goto fail;
+
+  ps->output = fdopen (fd, "r+");
+  if (! ps->output)
+    goto fail;
+
+  scb->fd = fd;
+  scb->state = (void *) ps;
+
+  return 0;
+
+ fail:
+  free_pipe_state (ps);
+  return -1;
+}
 
 static void
 pipe_windows_close (struct serial *scb)
 {
 
 static void
 pipe_windows_close (struct serial *scb)
 {
-  struct pipe_state *ps = scb->state;
+  struct pipe_state *ps = (struct pipe_state *) scb->state;
 
   /* In theory, we should try to kill the subprocess here, but the pex
      interface doesn't give us enough information to do that.  Usually
 
   /* In theory, we should try to kill the subprocess here, but the pex
      interface doesn't give us enough information to do that.  Usually
@@ -798,7 +994,7 @@ pipe_windows_read (struct serial *scb, size_t count)
 static int
 pipe_windows_write (struct serial *scb, const void *buf, size_t count)
 {
 static int
 pipe_windows_write (struct serial *scb, const void *buf, size_t count)
 {
-  struct pipe_state *ps = scb->state;
+  struct pipe_state *ps = (struct pipe_state *) scb->state;
   HANDLE pipeline_in;
   DWORD written;
 
   HANDLE pipeline_in;
   DWORD written;
 
@@ -820,32 +1016,12 @@ pipe_windows_write (struct serial *scb, const void *buf, size_t count)
 static void
 pipe_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except)
 {
 static void
 pipe_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except)
 {
-  struct pipe_state *ps = scb->state;
+  struct pipe_state *ps = (struct pipe_state *) scb->state;
 
   /* Have we allocated our events yet?  */
   if (ps->wait.read_event == INVALID_HANDLE_VALUE)
 
   /* Have we allocated our events yet?  */
   if (ps->wait.read_event == INVALID_HANDLE_VALUE)
-    {
-      DWORD threadId;
-
-      /* Create auto reset events to wake, stop, and exit the select
-        thread.  */
-      ps->wait.start_select = CreateEvent (0, FALSE, FALSE, 0);
-      ps->wait.stop_select = CreateEvent (0, FALSE, FALSE, 0);
-      ps->wait.exit_select = CreateEvent (0, FALSE, FALSE, 0);
-
-      /* Create a manual reset event to signal whether the thread is
-        stopped.  This must be manual reset, because we may wait on
-        it multiple times without ever starting the thread.  */
-      ps->wait.have_stopped = CreateEvent (0, TRUE, FALSE, 0);
-
-      /* Create our own events to report read and exceptions separately.
-        The exception event is currently never used.  */
-      ps->wait.read_event = CreateEvent (0, FALSE, FALSE, 0);
-      ps->wait.except_event = CreateEvent (0, FALSE, FALSE, 0);
-
-      /* Start the select thread.  */
-      CreateThread (NULL, 0, pipe_select_thread, scb, 0, &threadId);
-    }
+    /* Start the thread.  */
+    create_select_thread (pipe_select_thread, scb, &ps->wait);
 
   *read = ps->wait.read_event;
   *except = ps->wait.except_event;
 
   *read = ps->wait.read_event;
   *except = ps->wait.except_event;
@@ -855,21 +1031,19 @@ pipe_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except)
   ResetEvent (ps->wait.except_event);
   ResetEvent (ps->wait.stop_select);
 
   ResetEvent (ps->wait.except_event);
   ResetEvent (ps->wait.stop_select);
 
-  /* Start the select thread.  */
-  SetEvent (ps->wait.start_select);
+  start_select_thread (&ps->wait);
 }
 
 static void
 pipe_done_wait_handle (struct serial *scb)
 {
 }
 
 static void
 pipe_done_wait_handle (struct serial *scb)
 {
-  struct pipe_state *ps = scb->state;
+  struct pipe_state *ps = (struct pipe_state *) scb->state;
 
   /* Have we allocated our events yet?  */
   if (ps->wait.read_event == INVALID_HANDLE_VALUE)
     return;
 
 
   /* Have we allocated our events yet?  */
   if (ps->wait.read_event == INVALID_HANDLE_VALUE)
     return;
 
-  SetEvent (ps->wait.stop_select);
-  WaitForSingleObject (ps->wait.have_stopped, INFINITE);
+  stop_select_thread (&ps->wait);
 }
 
 static int
 }
 
 static int
@@ -878,158 +1052,147 @@ pipe_avail (struct serial *scb, int fd)
   HANDLE h = (HANDLE) _get_osfhandle (fd);
   DWORD numBytes;
   BOOL r = PeekNamedPipe (h, NULL, 0, NULL, &numBytes, NULL);
   HANDLE h = (HANDLE) _get_osfhandle (fd);
   DWORD numBytes;
   BOOL r = PeekNamedPipe (h, NULL, 0, NULL, &numBytes, NULL);
+
   if (r == FALSE)
     numBytes = 0;
   return numBytes;
 }
 
   if (r == FALSE)
     numBytes = 0;
   return numBytes;
 }
 
+int
+gdb_pipe (int pdes[2])
+{
+  if (_pipe (pdes, 512, _O_BINARY | _O_NOINHERIT) == -1)
+    return -1;
+  return 0;
+}
+
 struct net_windows_state
 {
 struct net_windows_state
 {
-  HANDLE read_event;
-  HANDLE except_event;
+  struct ser_console_state base;
+  
+  HANDLE sock_event;
+};
 
 
-  HANDLE start_select;
-  HANDLE stop_select;
-  HANDLE exit_select;
-  HANDLE have_stopped;
+/* Check whether the socket has any pending data to be read.  If so,
+   set the select thread's read event.  On error, set the select
+   thread's except event.  If any event was set, return true,
+   otherwise return false.  */
 
 
-  HANDLE sock_event;
+static int
+net_windows_socket_check_pending (struct serial *scb)
+{
+  struct net_windows_state *state = (struct net_windows_state *) scb->state;
+  unsigned long available;
 
 
-  HANDLE thread;
-};
+  if (ioctlsocket (scb->fd, FIONREAD, &available) != 0)
+    {
+      /* The socket closed, or some other error.  */
+      SetEvent (state->base.except_event);
+      return 1;
+    }
+  else if (available > 0)
+    {
+      SetEvent (state->base.read_event);
+      return 1;
+    }
+
+  return 0;
+}
 
 static DWORD WINAPI
 net_windows_select_thread (void *arg)
 {
 
 static DWORD WINAPI
 net_windows_select_thread (void *arg)
 {
-  struct serial *scb = arg;
-  struct net_windows_state *state, state_copy;
+  struct serial *scb = (struct serial *) arg;
+  struct net_windows_state *state;
   int event_index;
 
   int event_index;
 
-  state = scb->state;
+  state = (struct net_windows_state *) scb->state;
 
   while (1)
     {
       HANDLE wait_events[2];
       WSANETWORKEVENTS events;
 
 
   while (1)
     {
       HANDLE wait_events[2];
       WSANETWORKEVENTS events;
 
-      SetEvent (state->have_stopped);
-
-      wait_events[0] = state->start_select;
-      wait_events[1] = state->exit_select;
-
-      if (WaitForMultipleObjects (2, wait_events, FALSE, INFINITE) != WAIT_OBJECT_0)
-       return 0;
+      select_thread_wait (&state->base);
 
 
-      ResetEvent (state->have_stopped);
-
-      wait_events[0] = state->stop_select;
+      wait_events[0] = state->base.stop_select;
       wait_events[1] = state->sock_event;
 
       wait_events[1] = state->sock_event;
 
-      event_index = WaitForMultipleObjects (2, wait_events, FALSE, INFINITE);
+      /* Wait for something to happen on the socket.  */
+      while (1)
+       {
+         event_index = WaitForMultipleObjects (2, wait_events, FALSE, INFINITE);
 
 
-      if (event_index == WAIT_OBJECT_0
-         || WaitForSingleObject (state->stop_select, 0) == WAIT_OBJECT_0)
-       continue;
+         if (event_index == WAIT_OBJECT_0
+             || WaitForSingleObject (state->base.stop_select, 0) == WAIT_OBJECT_0)
+           {
+             /* We have been requested to stop.  */
+             break;
+           }
 
 
-      if (event_index != WAIT_OBJECT_0 + 1)
-       {
-         /* Some error has occured.  Assume that this is an error
-            condition.  */
-         SetEvent (state->except_event);
-         continue;
-       }
+         if (event_index != WAIT_OBJECT_0 + 1)
+           {
+             /* Some error has occured.  Assume that this is an error
+                condition.  */
+             SetEvent (state->base.except_event);
+             break;
+           }
 
 
-      /* Enumerate the internal network events, and reset the object that
-        signalled us to catch the next event.  */
-      WSAEnumNetworkEvents (scb->fd, state->sock_event, &events);
+         /* Enumerate the internal network events, and reset the
+            object that signalled us to catch the next event.  */
+         if (WSAEnumNetworkEvents (scb->fd, state->sock_event, &events) != 0)
+           {
+             /* Something went wrong.  Maybe the socket is gone.  */
+             SetEvent (state->base.except_event);
+             break;
+           }
 
 
-      gdb_assert (events.lNetworkEvents & (FD_READ | FD_CLOSE));
+         if (events.lNetworkEvents & FD_READ)
+           {
+             if (net_windows_socket_check_pending (scb))
+               break;
 
 
-      if (events.lNetworkEvents & FD_READ)
-       SetEvent (state->read_event);
+             /* Spurious wakeup.  That is, the socket's event was
+                signalled before we last called recv.  */
+           }
 
 
-      if (events.lNetworkEvents & FD_CLOSE)
-       SetEvent (state->except_event);
+         if (events.lNetworkEvents & FD_CLOSE)
+           {
+             SetEvent (state->base.except_event);
+             break;
+           }
+       }
+
+      SetEvent (state->base.have_stopped);
     }
     }
+  return 0;
 }
 
 static void
 net_windows_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except)
 {
 }
 
 static void
 net_windows_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except)
 {
-  struct net_windows_state *state = scb->state;
+  struct net_windows_state *state = (struct net_windows_state *) scb->state;
 
   /* Start from a clean slate.  */
 
   /* Start from a clean slate.  */
-  ResetEvent (state->read_event);
-  ResetEvent (state->except_event);
-  ResetEvent (state->stop_select);
+  ResetEvent (state->base.read_event);
+  ResetEvent (state->base.except_event);
+  ResetEvent (state->base.stop_select);
 
 
-  *read = state->read_event;
-  *except = state->except_event;
+  *read = state->base.read_event;
+  *except = state->base.except_event;
 
 
-  /* Check any pending events.  This both avoids starting the thread
-     unnecessarily, and handles stray FD_READ events (see below).  */
-  if (WaitForSingleObject (state->sock_event, 0) == WAIT_OBJECT_0)
-    {
-      WSANETWORKEVENTS events;
-      int any = 0;
-
-      /* Enumerate the internal network events, and reset the object that
-        signalled us to catch the next event.  */
-      WSAEnumNetworkEvents (scb->fd, state->sock_event, &events);
-
-      /* You'd think that FD_READ or FD_CLOSE would be set here.  But,
-        sometimes, neither is.  I suspect that the FD_READ is set and
-        the corresponding event signalled while recv is running, and
-        the FD_READ is then lowered when recv consumes all the data,
-        but there's no way to un-signal the event.  This isn't a
-        problem for the call in net_select_thread, since any new
-        events after this point will not have been drained by recv.
-        It just means that we can't have the obvious assert here.  */
-
-      /* If there is a read event, it might be still valid, or it might
-        not be - it may have been signalled before we last called
-        recv.  Double-check that there is data.  */
-      if (events.lNetworkEvents & FD_READ)
-       {
-         unsigned long available;
-
-         if (ioctlsocket (scb->fd, FIONREAD, &available) == 0
-             && available > 0)
-           {
-             SetEvent (state->read_event);
-             any = 1;
-           }
-         else
-           /* Oops, no data.  This call to recv will cause future
-              data to retrigger the event, e.g. while we are
-              in net_select_thread.  */
-           recv (scb->fd, NULL, 0, 0);
-       }
-
-      /* If there's a close event, then record it - it is obviously
-        still valid, and it will not be resignalled.  */
-      if (events.lNetworkEvents & FD_CLOSE)
-       {
-         SetEvent (state->except_event);
-         any = 1;
-       }
-
-      /* If we set either handle, there's no need to wake the thread.  */
-      if (any)
-       return;
-    }
-
-  /* Start the select thread.  */
-  SetEvent (state->start_select);
+  /* Check any pending events.  Otherwise, start the select
+     thread.  */
+  if (!net_windows_socket_check_pending (scb))
+    start_select_thread (&state->base);
 }
 
 static void
 net_windows_done_wait_handle (struct serial *scb)
 {
 }
 
 static void
 net_windows_done_wait_handle (struct serial *scb)
 {
-  struct net_windows_state *state = scb->state;
+  struct net_windows_state *state = (struct net_windows_state *) scb->state;
 
 
-  SetEvent (state->stop_select);
-  WaitForSingleObject (state->have_stopped, INFINITE);
+  stop_select_thread (&state->base);
 }
 
 static int
 }
 
 static int
@@ -1043,32 +1206,15 @@ net_windows_open (struct serial *scb, const char *name)
   if (ret != 0)
     return ret;
 
   if (ret != 0)
     return ret;
 
-  state = xmalloc (sizeof (struct net_windows_state));
-  memset (state, 0, sizeof (struct net_windows_state));
+  state = XCNEW (struct net_windows_state);
   scb->state = state;
 
   scb->state = state;
 
-  /* Create auto reset events to wake, stop, and exit the select
-     thread.  */
-  state->start_select = CreateEvent (0, FALSE, FALSE, 0);
-  state->stop_select = CreateEvent (0, FALSE, FALSE, 0);
-  state->exit_select = CreateEvent (0, FALSE, FALSE, 0);
-
-  /* Create a manual reset event to signal whether the thread is
-     stopped.  This must be manual reset, because we may wait on
-     it multiple times without ever starting the thread.  */
-  state->have_stopped = CreateEvent (0, TRUE, 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);
 
   /* 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.  */
-  state->thread = CreateThread (NULL, 0, net_windows_select_thread, scb, 0,
-                               &threadId);
+  /* Start the thread.  */
+  create_select_thread (net_windows_select_thread, scb, &state->base);
 
   return 0;
 }
 
   return 0;
 }
@@ -1077,19 +1223,9 @@ net_windows_open (struct serial *scb, const char *name)
 static void
 net_windows_close (struct serial *scb)
 {
 static void
 net_windows_close (struct serial *scb)
 {
-  struct net_windows_state *state = scb->state;
-
-  SetEvent (state->exit_select);
-  WaitForSingleObject (state->thread, INFINITE);
-
-  CloseHandle (state->read_event);
-  CloseHandle (state->except_event);
-
-  CloseHandle (state->start_select);
-  CloseHandle (state->stop_select);
-  CloseHandle (state->exit_select);
-  CloseHandle (state->have_stopped);
+  struct net_windows_state *state = (struct net_windows_state *) scb->state;
 
 
+  destroy_select_thread (&state->base);
   CloseHandle (state->sock_event);
 
   xfree (scb->state);
   CloseHandle (state->sock_event);
 
   xfree (scb->state);
@@ -1097,94 +1233,153 @@ net_windows_close (struct serial *scb)
   net_close (scb);
 }
 
   net_close (scb);
 }
 
+/* The serial port driver.  */
+
+static const struct serial_ops hardwire_ops =
+{
+  "hardwire",
+  ser_windows_open,
+  ser_windows_close,
+  NULL,
+  ser_base_readchar,
+  ser_base_write,
+  ser_windows_flush_output,
+  ser_windows_flush_input,
+  ser_windows_send_break,
+  ser_windows_raw,
+  /* These are only used for stdin; we do not need them for serial
+     ports, so supply the standard dummies.  */
+  ser_base_get_tty_state,
+  ser_base_copy_tty_state,
+  ser_base_set_tty_state,
+  ser_base_print_tty_state,
+  ser_base_noflush_set_tty_state,
+  ser_windows_setbaudrate,
+  ser_windows_setstopbits,
+  ser_windows_setparity,
+  ser_windows_drain_output,
+  ser_base_async,
+  ser_windows_read_prim,
+  ser_windows_write_prim,
+  NULL,
+  ser_windows_wait_handle
+};
+
+/* The dummy serial driver used for terminals.  We only provide the
+   TTY-related methods.  */
+
+static const struct serial_ops tty_ops =
+{
+  "terminal",
+  NULL,
+  ser_console_close,
+  NULL,
+  NULL,
+  NULL,
+  NULL,
+  NULL,
+  NULL,
+  NULL,
+  ser_console_get_tty_state,
+  ser_base_copy_tty_state,
+  ser_base_set_tty_state,
+  ser_base_print_tty_state,
+  ser_base_noflush_set_tty_state,
+  NULL,
+  NULL,
+  NULL,
+  ser_base_drain_output,
+  NULL,
+  NULL,
+  NULL,
+  NULL,
+  ser_console_wait_handle,
+  ser_console_done_wait_handle
+};
+
+/* The pipe interface.  */
+
+static const struct serial_ops pipe_ops =
+{
+  "pipe",
+  pipe_windows_open,
+  pipe_windows_close,
+  pipe_windows_fdopen,
+  ser_base_readchar,
+  ser_base_write,
+  ser_base_flush_output,
+  ser_base_flush_input,
+  ser_base_send_break,
+  ser_base_raw,
+  ser_base_get_tty_state,
+  ser_base_copy_tty_state,
+  ser_base_set_tty_state,
+  ser_base_print_tty_state,
+  ser_base_noflush_set_tty_state,
+  ser_base_setbaudrate,
+  ser_base_setstopbits,
+  ser_base_setparity,
+  ser_base_drain_output,
+  ser_base_async,
+  pipe_windows_read,
+  pipe_windows_write,
+  pipe_avail,
+  pipe_wait_handle,
+  pipe_done_wait_handle
+};
+
+/* The TCP/UDP socket driver.  */
+
+static const struct serial_ops tcp_ops =
+{
+  "tcp",
+  net_windows_open,
+  net_windows_close,
+  NULL,
+  ser_base_readchar,
+  ser_base_write,
+  ser_base_flush_output,
+  ser_base_flush_input,
+  ser_tcp_send_break,
+  ser_base_raw,
+  ser_base_get_tty_state,
+  ser_base_copy_tty_state,
+  ser_base_set_tty_state,
+  ser_base_print_tty_state,
+  ser_base_noflush_set_tty_state,
+  ser_base_setbaudrate,
+  ser_base_setstopbits,
+  ser_base_setparity,
+  ser_base_drain_output,
+  ser_base_async,
+  net_read_prim,
+  net_write_prim,
+  NULL,
+  net_windows_wait_handle,
+  net_windows_done_wait_handle
+};
+
 void
 _initialize_ser_windows (void)
 {
   WSADATA wsa_data;
   struct serial_ops *ops;
 
 void
 _initialize_ser_windows (void)
 {
   WSADATA wsa_data;
   struct serial_ops *ops;
 
-  /* First register the serial port driver.  */
+  HMODULE hm = NULL;
 
 
-  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;
+  /* First find out if kernel32 exports CancelIo function.  */
+  hm = LoadLibrary ("kernel32.dll");
+  if (hm)
+    {
+      CancelIo = (CancelIo_ftype *) GetProcAddress (hm, "CancelIo");
+      FreeLibrary (hm);
+    }
+  else
+    CancelIo = NULL;
 
 
-  /* 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;
-  ops->done_wait_handle = ser_console_done_wait_handle;
-
-  serial_add_interface (ops);
-
-  /* The pipe interface.  */
-
-  ops = XMALLOC (struct serial_ops);
-  memset (ops, 0, sizeof (struct serial_ops));
-  ops->name = "pipe";
-  ops->next = 0;
-  ops->open = pipe_windows_open;
-  ops->close = pipe_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 = pipe_windows_read;
-  ops->write_prim = pipe_windows_write;
-  ops->wait_handle = pipe_wait_handle;
-  ops->done_wait_handle = pipe_done_wait_handle;
-  ops->avail = pipe_avail;
-
-  serial_add_interface (ops);
+  serial_add_interface (&hardwire_ops);
+  serial_add_interface (&tty_ops);
+  serial_add_interface (&pipe_ops);
 
   /* If WinSock works, register the TCP/UDP socket driver.  */
 
 
   /* If WinSock works, register the TCP/UDP socket driver.  */
 
@@ -1192,29 +1387,5 @@ _initialize_ser_windows (void)
     /* WinSock is unavailable.  */
     return;
 
     /* 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;
-  ops->done_wait_handle = net_windows_done_wait_handle;
-  serial_add_interface (ops);
+  serial_add_interface (&tcp_ops);
 }
 }
GDB Binutils - Deliverables
This page took 0.03978 seconds and 4 git commands to generate.