gdb/ser-mingw.c

   1 /* Serial interface for local (hardwired) serial ports on Windows systems
   2
   3    Copyright (C) 2006-2018 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "serial.h"
  22 #include "ser-base.h"
  23 #include "ser-tcp.h"
  24
  25 #include <windows.h>
  26 #include <conio.h>
  27
  28 #include <fcntl.h>
  29 #include <unistd.h>
  30 #include <sys/types.h>
  31
  32 #include "command.h"
  33
  34 struct ser_windows_state
  35 {
  36   int in_progress;
  37   OVERLAPPED ov;
  38   DWORD lastCommMask;
  39   HANDLE except_event;
  40 };
  41
  42 /* CancelIo is not available for Windows 95 OS, so we need to use
  43    LoadLibrary/GetProcAddress to avoid a startup failure.  */
  44 #define CancelIo dyn_CancelIo
  45 typedef BOOL WINAPI (CancelIo_ftype) (HANDLE);
  46 static CancelIo_ftype *CancelIo;
  47
  48 /* Open up a real live device for serial I/O.  */
  49
  50 static int
  51 ser_windows_open (struct serial *scb, const char *name)
  52 {
  53   HANDLE h;
  54   struct ser_windows_state *state;
  55   COMMTIMEOUTS timeouts;
  56
  57   h = CreateFile (name, GENERIC_READ | GENERIC_WRITE, 0, NULL,
  58                   OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);
  59   if (h == INVALID_HANDLE_VALUE)
  60     {
  61       errno = ENOENT;
  62       return -1;
  63     }
  64
  65   scb->fd = _open_osfhandle ((intptr_t) h, O_RDWR);
  66   if (scb->fd < 0)
  67     {
  68       errno = ENOENT;
  69       return -1;
  70     }
  71
  72   if (!SetCommMask (h, EV_RXCHAR))
  73     {
  74       errno = EINVAL;
  75       return -1;
  76     }
  77
  78   timeouts.ReadIntervalTimeout = MAXDWORD;
  79   timeouts.ReadTotalTimeoutConstant = 0;
  80   timeouts.ReadTotalTimeoutMultiplier = 0;
  81   timeouts.WriteTotalTimeoutConstant = 0;
  82   timeouts.WriteTotalTimeoutMultiplier = 0;
  83   if (!SetCommTimeouts (h, &timeouts))
  84     {
  85       errno = EINVAL;
  86       return -1;
  87     }
  88
  89   state = XCNEW (struct ser_windows_state);
  90   scb->state = state;
  91
  92   /* Create a manual reset event to watch the input buffer.  */
  93   state->ov.hEvent = CreateEvent (0, TRUE, FALSE, 0);
  94
  95   /* Create a (currently unused) handle to record exceptions.  */
  96   state->except_event = CreateEvent (0, TRUE, FALSE, 0);
  97
  98   return 0;
  99 }
 100
 101 /* Wait for the output to drain away, as opposed to flushing (discarding)
 102    it.  */
 103
 104 static int
 105 ser_windows_drain_output (struct serial *scb)
 106 {
 107   HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
 108
 109   return (FlushFileBuffers (h) != 0) ? 0 : -1;
 110 }
 111
 112 static int
 113 ser_windows_flush_output (struct serial *scb)
 114 {
 115   HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
 116
 117   return (PurgeComm (h, PURGE_TXCLEAR) != 0) ? 0 : -1;
 118 }
 119
 120 static int
 121 ser_windows_flush_input (struct serial *scb)
 122 {
 123   HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
 124
 125   return (PurgeComm (h, PURGE_RXCLEAR) != 0) ? 0 : -1;
 126 }
 127
 128 static int
 129 ser_windows_send_break (struct serial *scb)
 130 {
 131   HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
 132
 133   if (SetCommBreak (h) == 0)
 134     return -1;
 135
 136   /* Delay for 250 milliseconds.  */
 137   Sleep (250);
 138
 139   if (ClearCommBreak (h))
 140     return -1;
 141
 142   return 0;
 143 }
 144
 145 static void
 146 ser_windows_raw (struct serial *scb)
 147 {
 148   HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
 149   DCB state;
 150
 151   if (GetCommState (h, &state) == 0)
 152     return;
 153
 154   state.fOutxCtsFlow = FALSE;
 155   state.fOutxDsrFlow = FALSE;
 156   state.fDtrControl = DTR_CONTROL_ENABLE;
 157   state.fDsrSensitivity = FALSE;
 158   state.fOutX = FALSE;
 159   state.fInX = FALSE;
 160   state.fNull = FALSE;
 161   state.fAbortOnError = FALSE;
 162   state.ByteSize = 8;
 163
 164   if (SetCommState (h, &state) == 0)
 165     warning (_("SetCommState failed"));
 166 }
 167
 168 static int
 169 ser_windows_setstopbits (struct serial *scb, int num)
 170 {
 171   HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
 172   DCB state;
 173
 174   if (GetCommState (h, &state) == 0)
 175     return -1;
 176
 177   switch (num)
 178     {
 179     case SERIAL_1_STOPBITS:
 180       state.StopBits = ONESTOPBIT;
 181       break;
 182     case SERIAL_1_AND_A_HALF_STOPBITS:
 183       state.StopBits = ONE5STOPBITS;
 184       break;
 185     case SERIAL_2_STOPBITS:
 186       state.StopBits = TWOSTOPBITS;
 187       break;
 188     default:
 189       return 1;
 190     }
 191
 192   return (SetCommState (h, &state) != 0) ? 0 : -1;
 193 }
 194
 195 /* Implement the "setparity" serial_ops callback.  */
 196
 197 static int
 198 ser_windows_setparity (struct serial *scb, int parity)
 199 {
 200   HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
 201   DCB state;
 202
 203   if (GetCommState (h, &state) == 0)
 204     return -1;
 205
 206   switch (parity)
 207     {
 208     case GDBPARITY_NONE:
 209       state.Parity = NOPARITY;
 210       state.fParity = FALSE;
 211       break;
 212     case GDBPARITY_ODD:
 213       state.Parity = ODDPARITY;
 214       state.fParity = TRUE;
 215       break;
 216     case GDBPARITY_EVEN:
 217       state.Parity = EVENPARITY;
 218       state.fParity = TRUE;
 219       break;
 220     default:
 221       internal_warning (__FILE__, __LINE__,
 222                         "Incorrect parity value: %d", parity);
 223       return -1;
 224     }
 225
 226   return (SetCommState (h, &state) != 0) ? 0 : -1;
 227 }
 228
 229 static int
 230 ser_windows_setbaudrate (struct serial *scb, int rate)
 231 {
 232   HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
 233   DCB state;
 234
 235   if (GetCommState (h, &state) == 0)
 236     return -1;
 237
 238   state.BaudRate = rate;
 239
 240   return (SetCommState (h, &state) != 0) ? 0 : -1;
 241 }
 242
 243 static void
 244 ser_windows_close (struct serial *scb)
 245 {
 246   struct ser_windows_state *state;
 247
 248   /* Stop any pending selects.  On Windows 95 OS, CancelIo function does
 249      not exist.  In that case, it can be replaced by a call to CloseHandle,
 250      but this is not necessary here as we do close the Windows handle
 251      by calling close (scb->fd) below.  */
 252   if (CancelIo)
 253     CancelIo ((HANDLE) _get_osfhandle (scb->fd));
 254   state = (struct ser_windows_state *) scb->state;
 255   CloseHandle (state->ov.hEvent);
 256   CloseHandle (state->except_event);
 257
 258   if (scb->fd < 0)
 259     return;
 260
 261   close (scb->fd);
 262   scb->fd = -1;
 263
 264   xfree (scb->state);
 265 }
 266
 267 static void
 268 ser_windows_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except)
 269 {
 270   struct ser_windows_state *state;
 271   COMSTAT status;
 272   DWORD errors;
 273   HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
 274
 275   state = (struct ser_windows_state *) scb->state;
 276
 277   *except = state->except_event;
 278   *read = state->ov.hEvent;
 279
 280   if (state->in_progress)
 281     return;
 282
 283   /* Reset the mask - we are only interested in any characters which
 284      arrive after this point, not characters which might have arrived
 285      and already been read.  */
 286
 287   /* This really, really shouldn't be necessary - just the second one.
 288      But otherwise an internal flag for EV_RXCHAR does not get
 289      cleared, and we get a duplicated event, if the last batch
 290      of characters included at least two arriving close together.  */
 291   if (!SetCommMask (h, 0))
 292     warning (_("ser_windows_wait_handle: reseting mask failed"));
 293
 294   if (!SetCommMask (h, EV_RXCHAR))
 295     warning (_("ser_windows_wait_handle: reseting mask failed (2)"));
 296
 297   /* There's a potential race condition here; we must check cbInQue
 298      and not wait if that's nonzero.  */
 299
 300   ClearCommError (h, &errors, &status);
 301   if (status.cbInQue > 0)
 302     {
 303       SetEvent (state->ov.hEvent);
 304       return;
 305     }
 306
 307   state->in_progress = 1;
 308   ResetEvent (state->ov.hEvent);
 309   state->lastCommMask = -2;
 310   if (WaitCommEvent (h, &state->lastCommMask, &state->ov))
 311     {
 312       gdb_assert (state->lastCommMask & EV_RXCHAR);
 313       SetEvent (state->ov.hEvent);
 314     }
 315   else
 316     gdb_assert (GetLastError () == ERROR_IO_PENDING);
 317 }
 318
 319 static int
 320 ser_windows_read_prim (struct serial *scb, size_t count)
 321 {
 322   struct ser_windows_state *state;
 323   OVERLAPPED ov;
 324   DWORD bytes_read, bytes_read_tmp;
 325   HANDLE h;
 326   gdb_byte *p;
 327
 328   state = (struct ser_windows_state *) scb->state;
 329   if (state->in_progress)
 330     {
 331       WaitForSingleObject (state->ov.hEvent, INFINITE);
 332       state->in_progress = 0;
 333       ResetEvent (state->ov.hEvent);
 334     }
 335
 336   memset (&ov, 0, sizeof (OVERLAPPED));
 337   ov.hEvent = CreateEvent (0, FALSE, FALSE, 0);
 338   h = (HANDLE) _get_osfhandle (scb->fd);
 339
 340   if (!ReadFile (h, scb->buf, /* count */ 1, &bytes_read, &ov))
 341     {
 342       if (GetLastError () != ERROR_IO_PENDING
 343           || !GetOverlappedResult (h, &ov, &bytes_read, TRUE))
 344         bytes_read = -1;
 345     }
 346
 347   CloseHandle (ov.hEvent);
 348   return bytes_read;
 349 }
 350
 351 static int
 352 ser_windows_write_prim (struct serial *scb, const void *buf, size_t len)
 353 {
 354   struct ser_windows_state *state;
 355   OVERLAPPED ov;
 356   DWORD bytes_written;
 357   HANDLE h;
 358
 359   memset (&ov, 0, sizeof (OVERLAPPED));
 360   ov.hEvent = CreateEvent (0, FALSE, FALSE, 0);
 361   h = (HANDLE) _get_osfhandle (scb->fd);
 362   if (!WriteFile (h, buf, len, &bytes_written, &ov))
 363     {
 364       if (GetLastError () != ERROR_IO_PENDING
 365           || !GetOverlappedResult (h, &ov, &bytes_written, TRUE))
 366         bytes_written = -1;
 367     }
 368
 369   CloseHandle (ov.hEvent);
 370   return bytes_written;
 371 }
 372
 373 /* On Windows, gdb_select is implemented using WaitForMulpleObjects.
 374    A "select thread" is created for each file descriptor.  These
 375    threads looks for activity on the corresponding descriptor, using
 376    whatever techniques are appropriate for the descriptor type.  When
 377    that activity occurs, the thread signals an appropriate event,
 378    which wakes up WaitForMultipleObjects.
 379
 380    Each select thread is in one of two states: stopped or started.
 381    Select threads begin in the stopped state.  When gdb_select is
 382    called, threads corresponding to the descriptors of interest are
 383    started by calling a wait_handle function.  Each thread that
 384    notices activity signals the appropriate event and then reenters
 385    the stopped state.  Before gdb_select returns it calls the
 386    wait_handle_done functions, which return the threads to the stopped
 387    state.  */
 388
 389 enum select_thread_state {
 390   STS_STARTED,
 391   STS_STOPPED
 392 };
 393
 394 struct ser_console_state
 395 {
 396   /* Signaled by the select thread to indicate that data is available
 397      on the file descriptor.  */
 398   HANDLE read_event;
 399   /* Signaled by the select thread to indicate that an exception has
 400      occurred on the file descriptor.  */
 401   HANDLE except_event;
 402   /* Signaled by the select thread to indicate that it has entered the
 403      started state.  HAVE_STARTED and HAVE_STOPPED are never signaled
 404      simultaneously.  */
 405   HANDLE have_started;
 406   /* Signaled by the select thread to indicate that it has stopped,
 407      either because data is available (and READ_EVENT is signaled),
 408      because an exception has occurred (and EXCEPT_EVENT is signaled),
 409      or because STOP_SELECT was signaled.  */
 410   HANDLE have_stopped;
 411
 412   /* Signaled by the main program to tell the select thread to enter
 413      the started state.  */
 414   HANDLE start_select;
 415   /* Signaled by the main program to tell the select thread to enter
 416      the stopped state.  */
 417   HANDLE stop_select;
 418   /* Signaled by the main program to tell the select thread to
 419      exit.  */
 420   HANDLE exit_select;
 421
 422   /* The handle for the select thread.  */
 423   HANDLE thread;
 424   /* The state of the select thread.  This field is only accessed in
 425      the main program, never by the select thread itself.  */
 426   enum select_thread_state thread_state;
 427 };
 428
 429 /* Called by a select thread to enter the stopped state.  This
 430    function does not return until the thread has re-entered the
 431    started state.  */
 432 static void
 433 select_thread_wait (struct ser_console_state *state)
 434 {
 435   HANDLE wait_events[2];
 436
 437   /* There are two things that can wake us up: a request that we enter
 438      the started state, or that we exit this thread.  */
 439   wait_events[0] = state->start_select;
 440   wait_events[1] = state->exit_select;
 441   if (WaitForMultipleObjects (2, wait_events, FALSE, INFINITE)
 442       != WAIT_OBJECT_0)
 443     /* Either the EXIT_SELECT event was signaled (requesting that the
 444        thread exit) or an error has occurred.  In either case, we exit
 445        the thread.  */
 446     ExitThread (0);
 447
 448   /* We are now in the started state.  */
 449   SetEvent (state->have_started);
 450 }
 451
 452 typedef DWORD WINAPI (*thread_fn_type)(void *);
 453
 454 /* Create a new select thread for SCB executing THREAD_FN.  The STATE
 455    will be filled in by this function before return.  */
 456 static void
 457 create_select_thread (thread_fn_type thread_fn,
 458                       struct serial *scb,
 459                       struct ser_console_state *state)
 460 {
 461   DWORD threadId;
 462
 463   /* Create all of the events.  These are all auto-reset events.  */
 464   state->read_event = CreateEvent (NULL, FALSE, FALSE, NULL);
 465   state->except_event = CreateEvent (NULL, FALSE, FALSE, NULL);
 466   state->have_started = CreateEvent (NULL, FALSE, FALSE, NULL);
 467   state->have_stopped = CreateEvent (NULL, FALSE, FALSE, NULL);
 468   state->start_select = CreateEvent (NULL, FALSE, FALSE, NULL);
 469   state->stop_select = CreateEvent (NULL, FALSE, FALSE, NULL);
 470   state->exit_select = CreateEvent (NULL, FALSE, FALSE, NULL);
 471
 472   state->thread = CreateThread (NULL, 0, thread_fn, scb, 0, &threadId);
 473   /* The thread begins in the stopped state.  */
 474   state->thread_state = STS_STOPPED;
 475 }
 476
 477 /* Destroy the select thread indicated by STATE.  */
 478 static void
 479 destroy_select_thread (struct ser_console_state *state)
 480 {
 481   /* Ask the thread to exit.  */
 482   SetEvent (state->exit_select);
 483   /* Wait until it does.  */
 484   WaitForSingleObject (state->thread, INFINITE);
 485
 486   /* Destroy the events.  */
 487   CloseHandle (state->read_event);
 488   CloseHandle (state->except_event);
 489   CloseHandle (state->have_started);
 490   CloseHandle (state->have_stopped);
 491   CloseHandle (state->start_select);
 492   CloseHandle (state->stop_select);
 493   CloseHandle (state->exit_select);
 494 }
 495
 496 /* Called by gdb_select to start the select thread indicated by STATE.
 497    This function does not return until the thread has started.  */
 498 static void
 499 start_select_thread (struct ser_console_state *state)
 500 {
 501   /* Ask the thread to start.  */
 502   SetEvent (state->start_select);
 503   /* Wait until it does.  */
 504   WaitForSingleObject (state->have_started, INFINITE);
 505   /* The thread is now started.  */
 506   state->thread_state = STS_STARTED;
 507 }
 508
 509 /* Called by gdb_select to stop the select thread indicated by STATE.
 510    This function does not return until the thread has stopped.  */
 511 static void
 512 stop_select_thread (struct ser_console_state *state)
 513 {
 514   /* If the thread is already in the stopped state, we have nothing to
 515      do.  Some of the wait_handle functions avoid calling
 516      start_select_thread if they notice activity on the relevant file
 517      descriptors.  The wait_handle_done functions still call
 518      stop_select_thread -- but it is already stopped.  */
 519   if (state->thread_state != STS_STARTED)
 520     return;
 521   /* Ask the thread to stop.  */
 522   SetEvent (state->stop_select);
 523   /* Wait until it does.  */
 524   WaitForSingleObject (state->have_stopped, INFINITE);
 525   /* The thread is now stopped.  */
 526   state->thread_state = STS_STOPPED;
 527 }
 528
 529 static DWORD WINAPI
 530 console_select_thread (void *arg)
 531 {
 532   struct serial *scb = (struct serial *) arg;
 533   struct ser_console_state *state;
 534   int event_index;
 535   HANDLE h;
 536
 537   state = (struct ser_console_state *) scb->state;
 538   h = (HANDLE) _get_osfhandle (scb->fd);
 539
 540   while (1)
 541     {
 542       HANDLE wait_events[2];
 543       INPUT_RECORD record;
 544       DWORD n_records;
 545
 546       select_thread_wait (state);
 547
 548       while (1)
 549         {
 550           wait_events[0] = state->stop_select;
 551           wait_events[1] = h;
 552
 553           event_index = WaitForMultipleObjects (2, wait_events,
 554                                                 FALSE, INFINITE);
 555
 556           if (event_index == WAIT_OBJECT_0
 557               || WaitForSingleObject (state->stop_select, 0) == WAIT_OBJECT_0)
 558             break;
 559
 560           if (event_index != WAIT_OBJECT_0 + 1)
 561             {
 562               /* Wait must have failed; assume an error has occured, e.g.
 563                  the handle has been closed.  */
 564               SetEvent (state->except_event);
 565               break;
 566             }
 567
 568           /* We've got a pending event on the console.  See if it's
 569              of interest.  */
 570           if (!PeekConsoleInput (h, &record, 1, &n_records) || n_records != 1)
 571             {
 572               /* Something went wrong.  Maybe the console is gone.  */
 573               SetEvent (state->except_event);
 574               break;
 575             }
 576
 577           if (record.EventType == KEY_EVENT && record.Event.KeyEvent.bKeyDown)
 578             {
 579               WORD keycode = record.Event.KeyEvent.wVirtualKeyCode;
 580
 581               /* Ignore events containing only control keys.  We must
 582                  recognize "enhanced" keys which we are interested in
 583                  reading via getch, if they do not map to ASCII.  But we
 584                  do not want to report input available for e.g. the
 585                  control key alone.  */
 586
 587               if (record.Event.KeyEvent.uChar.AsciiChar != 0
 588                   || keycode == VK_PRIOR
 589                   || keycode == VK_NEXT
 590                   || keycode == VK_END
 591                   || keycode == VK_HOME
 592                   || keycode == VK_LEFT
 593                   || keycode == VK_UP
 594                   || keycode == VK_RIGHT
 595                   || keycode == VK_DOWN
 596                   || keycode == VK_INSERT
 597                   || keycode == VK_DELETE)
 598                 {
 599                   /* This is really a keypress.  */
 600                   SetEvent (state->read_event);
 601                   break;
 602                 }
 603             }
 604
 605           /* Otherwise discard it and wait again.  */
 606           ReadConsoleInput (h, &record, 1, &n_records);
 607         }
 608
 609       SetEvent(state->have_stopped);
 610     }
 611   return 0;
 612 }
 613
 614 static int
 615 fd_is_pipe (int fd)
 616 {
 617   if (PeekNamedPipe ((HANDLE) _get_osfhandle (fd), NULL, 0, NULL, NULL, NULL))
 618     return 1;
 619   else
 620     return 0;
 621 }
 622
 623 static int
 624 fd_is_file (int fd)
 625 {
 626   if (GetFileType ((HANDLE) _get_osfhandle (fd)) == FILE_TYPE_DISK)
 627     return 1;
 628   else
 629     return 0;
 630 }
 631
 632 static DWORD WINAPI
 633 pipe_select_thread (void *arg)
 634 {
 635   struct serial *scb = (struct serial *) arg;
 636   struct ser_console_state *state;
 637   int event_index;
 638   HANDLE h;
 639
 640   state = (struct ser_console_state *) scb->state;
 641   h = (HANDLE) _get_osfhandle (scb->fd);
 642
 643   while (1)
 644     {
 645       DWORD n_avail;
 646
 647       select_thread_wait (state);
 648
 649       /* Wait for something to happen on the pipe.  */
 650       while (1)
 651         {
 652           if (!PeekNamedPipe (h, NULL, 0, NULL, &n_avail, NULL))
 653             {
 654               SetEvent (state->except_event);
 655               break;
 656             }
 657
 658           if (n_avail > 0)
 659             {
 660               SetEvent (state->read_event);
 661               break;
 662             }
 663
 664           /* Delay 10ms before checking again, but allow the stop
 665              event to wake us.  */
 666           if (WaitForSingleObject (state->stop_select, 10) == WAIT_OBJECT_0)
 667             break;
 668         }
 669
 670       SetEvent (state->have_stopped);
 671     }
 672   return 0;
 673 }
 674
 675 static DWORD WINAPI
 676 file_select_thread (void *arg)
 677 {
 678   struct serial *scb = (struct serial *) arg;
 679   struct ser_console_state *state;
 680   int event_index;
 681   HANDLE h;
 682
 683   state = (struct ser_console_state *) scb->state;
 684   h = (HANDLE) _get_osfhandle (scb->fd);
 685
 686   while (1)
 687     {
 688       select_thread_wait (state);
 689
 690       if (SetFilePointer (h, 0, NULL, FILE_CURRENT)
 691           == INVALID_SET_FILE_POINTER)
 692         SetEvent (state->except_event);
 693       else
 694         SetEvent (state->read_event);
 695
 696       SetEvent (state->have_stopped);
 697     }
 698   return 0;
 699 }
 700
 701 static void
 702 ser_console_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except)
 703 {
 704   struct ser_console_state *state = (struct ser_console_state *) scb->state;
 705
 706   if (state == NULL)
 707     {
 708       thread_fn_type thread_fn;
 709       int is_tty;
 710
 711       is_tty = isatty (scb->fd);
 712       if (!is_tty && !fd_is_file (scb->fd) && !fd_is_pipe (scb->fd))
 713         {
 714           *read = NULL;
 715           *except = NULL;
 716           return;
 717         }
 718
 719       state = XCNEW (struct ser_console_state);
 720       scb->state = state;
 721
 722       if (is_tty)
 723         thread_fn = console_select_thread;
 724       else if (fd_is_pipe (scb->fd))
 725         thread_fn = pipe_select_thread;
 726       else
 727         thread_fn = file_select_thread;
 728
 729       create_select_thread (thread_fn, scb, state);
 730     }
 731
 732   *read = state->read_event;
 733   *except = state->except_event;
 734
 735   /* Start from a blank state.  */
 736   ResetEvent (state->read_event);
 737   ResetEvent (state->except_event);
 738   ResetEvent (state->stop_select);
 739
 740   /* First check for a key already in the buffer.  If there is one,
 741      we don't need a thread.  This also catches the second key of
 742      multi-character returns from getch, for instance for arrow
 743      keys.  The second half is in a C library internal buffer,
 744      and PeekConsoleInput will not find it.  */
 745   if (_kbhit ())
 746     {
 747       SetEvent (state->read_event);
 748       return;
 749     }
 750
 751   /* Otherwise, start the select thread.  */
 752   start_select_thread (state);
 753 }
 754
 755 static void
 756 ser_console_done_wait_handle (struct serial *scb)
 757 {
 758   struct ser_console_state *state = (struct ser_console_state *) scb->state;
 759
 760   if (state == NULL)
 761     return;
 762
 763   stop_select_thread (state);
 764 }
 765
 766 static void
 767 ser_console_close (struct serial *scb)
 768 {
 769   struct ser_console_state *state = (struct ser_console_state *) scb->state;
 770
 771   if (scb->state)
 772     {
 773       destroy_select_thread (state);
 774       xfree (scb->state);
 775     }
 776 }
 777
 778 struct ser_console_ttystate
 779 {
 780   int is_a_tty;
 781 };
 782
 783 static serial_ttystate
 784 ser_console_get_tty_state (struct serial *scb)
 785 {
 786   if (isatty (scb->fd))
 787     {
 788       struct ser_console_ttystate *state;
 789
 790       state = XNEW (struct ser_console_ttystate);
 791       state->is_a_tty = 1;
 792       return state;
 793     }
 794   else
 795     return NULL;
 796 }
 797
 798 struct pipe_state
 799 {
 800   /* Since we use the pipe_select_thread for our select emulation,
 801      we need to place the state structure it requires at the front
 802      of our state.  */
 803   struct ser_console_state wait;
 804
 805   /* The pex obj for our (one-stage) pipeline.  */
 806   struct pex_obj *pex;
 807
 808   /* Streams for the pipeline's input and output.  */
 809   FILE *input, *output;
 810 };
 811
 812 static struct pipe_state *
 813 make_pipe_state (void)
 814 {
 815   struct pipe_state *ps = XCNEW (struct pipe_state);
 816
 817   ps->wait.read_event = INVALID_HANDLE_VALUE;
 818   ps->wait.except_event = INVALID_HANDLE_VALUE;
 819   ps->wait.start_select = INVALID_HANDLE_VALUE;
 820   ps->wait.stop_select = INVALID_HANDLE_VALUE;
 821
 822   return ps;
 823 }
 824
 825 static void
 826 free_pipe_state (struct pipe_state *ps)
 827 {
 828   int saved_errno = errno;
 829
 830   if (ps->wait.read_event != INVALID_HANDLE_VALUE)
 831     destroy_select_thread (&ps->wait);
 832
 833   /* Close the pipe to the child.  We must close the pipe before
 834      calling pex_free because pex_free will wait for the child to exit
 835      and the child will not exit until the pipe is closed.  */
 836   if (ps->input)
 837     fclose (ps->input);
 838   if (ps->pex)
 839     {
 840       pex_free (ps->pex);
 841       /* pex_free closes ps->output.  */
 842     }
 843   else if (ps->output)
 844     fclose (ps->output);
 845
 846   xfree (ps);
 847
 848   errno = saved_errno;
 849 }
 850
 851 struct pipe_state_destroyer
 852 {
 853   void operator() (pipe_state *ps) const
 854   {
 855     free_pipe_state (ps);
 856   }
 857 };
 858
 859 typedef std::unique_ptr<pipe_state, pipe_state_destroyer> pipe_state_up;
 860
 861 static int
 862 pipe_windows_open (struct serial *scb, const char *name)
 863 {
 864   FILE *pex_stderr;
 865
 866   if (name == NULL)
 867     error_no_arg (_("child command"));
 868
 869   gdb_argv argv (name);
 870
 871   if (! argv[0] || argv[0][0] == '\0')
 872     error (_("missing child command"));
 873
 874   pipe_state_up ps (make_pipe_state ());
 875
 876   ps->pex = pex_init (PEX_USE_PIPES, "target remote pipe", NULL);
 877   if (! ps->pex)
 878     return -1;
 879   ps->input = pex_input_pipe (ps->pex, 1);
 880   if (! ps->input)
 881     return -1;
 882
 883   {
 884     int err;
 885     const char *err_msg
 886       = pex_run (ps->pex, PEX_SEARCH | PEX_BINARY_INPUT | PEX_BINARY_OUTPUT
 887                  | PEX_STDERR_TO_PIPE,
 888                  argv[0], argv.get (), NULL, NULL,
 889                  &err);
 890
 891     if (err_msg)
 892       {
 893         /* Our caller expects us to return -1, but all they'll do with
 894            it generally is print the message based on errno.  We have
 895            all the same information here, plus err_msg provided by
 896            pex_run, so we just raise the error here.  */
 897         if (err)
 898           error (_("error starting child process '%s': %s: %s"),
 899                  name, err_msg, safe_strerror (err));
 900         else
 901           error (_("error starting child process '%s': %s"),
 902                  name, err_msg);
 903       }
 904   }
 905
 906   ps->output = pex_read_output (ps->pex, 1);
 907   if (! ps->output)
 908     return -1;
 909   scb->fd = fileno (ps->output);
 910
 911   pex_stderr = pex_read_err (ps->pex, 1);
 912   if (! pex_stderr)
 913     return -1;
 914   scb->error_fd = fileno (pex_stderr);
 915
 916   scb->state = ps.release ();
 917
 918   return 0;
 919 }
 920
 921 static int
 922 pipe_windows_fdopen (struct serial *scb, int fd)
 923 {
 924   struct pipe_state *ps;
 925
 926   ps = make_pipe_state ();
 927
 928   ps->input = fdopen (fd, "r+");
 929   if (! ps->input)
 930     goto fail;
 931
 932   ps->output = fdopen (fd, "r+");
 933   if (! ps->output)
 934     goto fail;
 935
 936   scb->fd = fd;
 937   scb->state = (void *) ps;
 938
 939   return 0;
 940
 941  fail:
 942   free_pipe_state (ps);
 943   return -1;
 944 }
 945
 946 static void
 947 pipe_windows_close (struct serial *scb)
 948 {
 949   struct pipe_state *ps = (struct pipe_state *) scb->state;
 950
 951   /* In theory, we should try to kill the subprocess here, but the pex
 952      interface doesn't give us enough information to do that.  Usually
 953      closing the input pipe will get the message across.  */
 954
 955   free_pipe_state (ps);
 956 }
 957
 958
 959 static int
 960 pipe_windows_read (struct serial *scb, size_t count)
 961 {
 962   HANDLE pipeline_out = (HANDLE) _get_osfhandle (scb->fd);
 963   DWORD available;
 964   DWORD bytes_read;
 965
 966   if (pipeline_out == INVALID_HANDLE_VALUE)
 967     return -1;
 968
 969   if (! PeekNamedPipe (pipeline_out, NULL, 0, NULL, &available, NULL))
 970     return -1;
 971
 972   if (count > available)
 973     count = available;
 974
 975   if (! ReadFile (pipeline_out, scb->buf, count, &bytes_read, NULL))
 976     return -1;
 977
 978   return bytes_read;
 979 }
 980
 981
 982 static int
 983 pipe_windows_write (struct serial *scb, const void *buf, size_t count)
 984 {
 985   struct pipe_state *ps = (struct pipe_state *) scb->state;
 986   HANDLE pipeline_in;
 987   DWORD written;
 988
 989   int pipeline_in_fd = fileno (ps->input);
 990   if (pipeline_in_fd < 0)
 991     return -1;
 992
 993   pipeline_in = (HANDLE) _get_osfhandle (pipeline_in_fd);
 994   if (pipeline_in == INVALID_HANDLE_VALUE)
 995     return -1;
 996
 997   if (! WriteFile (pipeline_in, buf, count, &written, NULL))
 998     return -1;
 999
1000   return written;
1001 }
1002
1003
1004 static void
1005 pipe_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except)
1006 {
1007   struct pipe_state *ps = (struct pipe_state *) scb->state;
1008
1009   /* Have we allocated our events yet?  */
1010   if (ps->wait.read_event == INVALID_HANDLE_VALUE)
1011     /* Start the thread.  */
1012     create_select_thread (pipe_select_thread, scb, &ps->wait);
1013
1014   *read = ps->wait.read_event;
1015   *except = ps->wait.except_event;
1016
1017   /* Start from a blank state.  */
1018   ResetEvent (ps->wait.read_event);
1019   ResetEvent (ps->wait.except_event);
1020   ResetEvent (ps->wait.stop_select);
1021
1022   start_select_thread (&ps->wait);
1023 }
1024
1025 static void
1026 pipe_done_wait_handle (struct serial *scb)
1027 {
1028   struct pipe_state *ps = (struct pipe_state *) scb->state;
1029
1030   /* Have we allocated our events yet?  */
1031   if (ps->wait.read_event == INVALID_HANDLE_VALUE)
1032     return;
1033
1034   stop_select_thread (&ps->wait);
1035 }
1036
1037 static int
1038 pipe_avail (struct serial *scb, int fd)
1039 {
1040   HANDLE h = (HANDLE) _get_osfhandle (fd);
1041   DWORD numBytes;
1042   BOOL r = PeekNamedPipe (h, NULL, 0, NULL, &numBytes, NULL);
1043
1044   if (r == FALSE)
1045     numBytes = 0;
1046   return numBytes;
1047 }
1048
1049 int
1050 gdb_pipe (int pdes[2])
1051 {
1052   if (_pipe (pdes, 512, _O_BINARY | _O_NOINHERIT) == -1)
1053     return -1;
1054   return 0;
1055 }
1056
1057 struct net_windows_state
1058 {
1059   struct ser_console_state base;
1060
1061   HANDLE sock_event;
1062 };
1063
1064 /* Check whether the socket has any pending data to be read.  If so,
1065    set the select thread's read event.  On error, set the select
1066    thread's except event.  If any event was set, return true,
1067    otherwise return false.  */
1068
1069 static int
1070 net_windows_socket_check_pending (struct serial *scb)
1071 {
1072   struct net_windows_state *state = (struct net_windows_state *) scb->state;
1073   unsigned long available;
1074
1075   if (ioctlsocket (scb->fd, FIONREAD, &available) != 0)
1076     {
1077       /* The socket closed, or some other error.  */
1078       SetEvent (state->base.except_event);
1079       return 1;
1080     }
1081   else if (available > 0)
1082     {
1083       SetEvent (state->base.read_event);
1084       return 1;
1085     }
1086
1087   return 0;
1088 }
1089
1090 static DWORD WINAPI
1091 net_windows_select_thread (void *arg)
1092 {
1093   struct serial *scb = (struct serial *) arg;
1094   struct net_windows_state *state;
1095   int event_index;
1096
1097   state = (struct net_windows_state *) scb->state;
1098
1099   while (1)
1100     {
1101       HANDLE wait_events[2];
1102       WSANETWORKEVENTS events;
1103
1104       select_thread_wait (&state->base);
1105
1106       wait_events[0] = state->base.stop_select;
1107       wait_events[1] = state->sock_event;
1108
1109       /* Wait for something to happen on the socket.  */
1110       while (1)
1111         {
1112           event_index = WaitForMultipleObjects (2, wait_events, FALSE, INFINITE);
1113
1114           if (event_index == WAIT_OBJECT_0
1115               || WaitForSingleObject (state->base.stop_select, 0) == WAIT_OBJECT_0)
1116             {
1117               /* We have been requested to stop.  */
1118               break;
1119             }
1120
1121           if (event_index != WAIT_OBJECT_0 + 1)
1122             {
1123               /* Some error has occured.  Assume that this is an error
1124                  condition.  */
1125               SetEvent (state->base.except_event);
1126               break;
1127             }
1128
1129           /* Enumerate the internal network events, and reset the
1130              object that signalled us to catch the next event.  */
1131           if (WSAEnumNetworkEvents (scb->fd, state->sock_event, &events) != 0)
1132             {
1133               /* Something went wrong.  Maybe the socket is gone.  */
1134               SetEvent (state->base.except_event);
1135               break;
1136             }
1137
1138           if (events.lNetworkEvents & FD_READ)
1139             {
1140               if (net_windows_socket_check_pending (scb))
1141                 break;
1142
1143               /* Spurious wakeup.  That is, the socket's event was
1144                  signalled before we last called recv.  */
1145             }
1146
1147           if (events.lNetworkEvents & FD_CLOSE)
1148             {
1149               SetEvent (state->base.except_event);
1150               break;
1151             }
1152         }
1153
1154       SetEvent (state->base.have_stopped);
1155     }
1156   return 0;
1157 }
1158
1159 static void
1160 net_windows_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except)
1161 {
1162   struct net_windows_state *state = (struct net_windows_state *) scb->state;
1163
1164   /* Start from a clean slate.  */
1165   ResetEvent (state->base.read_event);
1166   ResetEvent (state->base.except_event);
1167   ResetEvent (state->base.stop_select);
1168
1169   *read = state->base.read_event;
1170   *except = state->base.except_event;
1171
1172   /* Check any pending events.  Otherwise, start the select
1173      thread.  */
1174   if (!net_windows_socket_check_pending (scb))
1175     start_select_thread (&state->base);
1176 }
1177
1178 static void
1179 net_windows_done_wait_handle (struct serial *scb)
1180 {
1181   struct net_windows_state *state = (struct net_windows_state *) scb->state;
1182
1183   stop_select_thread (&state->base);
1184 }
1185
1186 static int
1187 net_windows_open (struct serial *scb, const char *name)
1188 {
1189   struct net_windows_state *state;
1190   int ret;
1191   DWORD threadId;
1192
1193   ret = net_open (scb, name);
1194   if (ret != 0)
1195     return ret;
1196
1197   state = XCNEW (struct net_windows_state);
1198   scb->state = state;
1199
1200   /* Associate an event with the socket.  */
1201   state->sock_event = CreateEvent (0, TRUE, FALSE, 0);
1202   WSAEventSelect (scb->fd, state->sock_event, FD_READ | FD_CLOSE);
1203
1204   /* Start the thread.  */
1205   create_select_thread (net_windows_select_thread, scb, &state->base);
1206
1207   return 0;
1208 }
1209
1210
1211 static void
1212 net_windows_close (struct serial *scb)
1213 {
1214   struct net_windows_state *state = (struct net_windows_state *) scb->state;
1215
1216   destroy_select_thread (&state->base);
1217   CloseHandle (state->sock_event);
1218
1219   xfree (scb->state);
1220
1221   net_close (scb);
1222 }
1223
1224 /* The serial port driver.  */
1225
1226 static const struct serial_ops hardwire_ops =
1227 {
1228   "hardwire",
1229   ser_windows_open,
1230   ser_windows_close,
1231   NULL,
1232   ser_base_readchar,
1233   ser_base_write,
1234   ser_windows_flush_output,
1235   ser_windows_flush_input,
1236   ser_windows_send_break,
1237   ser_windows_raw,
1238   /* These are only used for stdin; we do not need them for serial
1239      ports, so supply the standard dummies.  */
1240   ser_base_get_tty_state,
1241   ser_base_copy_tty_state,
1242   ser_base_set_tty_state,
1243   ser_base_print_tty_state,
1244   ser_windows_setbaudrate,
1245   ser_windows_setstopbits,
1246   ser_windows_setparity,
1247   ser_windows_drain_output,
1248   ser_base_async,
1249   ser_windows_read_prim,
1250   ser_windows_write_prim,
1251   NULL,
1252   ser_windows_wait_handle
1253 };
1254
1255 /* The dummy serial driver used for terminals.  We only provide the
1256    TTY-related methods.  */
1257
1258 static const struct serial_ops tty_ops =
1259 {
1260   "terminal",
1261   NULL,
1262   ser_console_close,
1263   NULL,
1264   NULL,
1265   NULL,
1266   NULL,
1267   NULL,
1268   NULL,
1269   NULL,
1270   ser_console_get_tty_state,
1271   ser_base_copy_tty_state,
1272   ser_base_set_tty_state,
1273   ser_base_print_tty_state,
1274   NULL,
1275   NULL,
1276   NULL,
1277   ser_base_drain_output,
1278   NULL,
1279   NULL,
1280   NULL,
1281   NULL,
1282   ser_console_wait_handle,
1283   ser_console_done_wait_handle
1284 };
1285
1286 /* The pipe interface.  */
1287
1288 static const struct serial_ops pipe_ops =
1289 {
1290   "pipe",
1291   pipe_windows_open,
1292   pipe_windows_close,
1293   pipe_windows_fdopen,
1294   ser_base_readchar,
1295   ser_base_write,
1296   ser_base_flush_output,
1297   ser_base_flush_input,
1298   ser_base_send_break,
1299   ser_base_raw,
1300   ser_base_get_tty_state,
1301   ser_base_copy_tty_state,
1302   ser_base_set_tty_state,
1303   ser_base_print_tty_state,
1304   ser_base_setbaudrate,
1305   ser_base_setstopbits,
1306   ser_base_setparity,
1307   ser_base_drain_output,
1308   ser_base_async,
1309   pipe_windows_read,
1310   pipe_windows_write,
1311   pipe_avail,
1312   pipe_wait_handle,
1313   pipe_done_wait_handle
1314 };
1315
1316 /* The TCP/UDP socket driver.  */
1317
1318 static const struct serial_ops tcp_ops =
1319 {
1320   "tcp",
1321   net_windows_open,
1322   net_windows_close,
1323   NULL,
1324   ser_base_readchar,
1325   ser_base_write,
1326   ser_base_flush_output,
1327   ser_base_flush_input,
1328   ser_tcp_send_break,
1329   ser_base_raw,
1330   ser_base_get_tty_state,
1331   ser_base_copy_tty_state,
1332   ser_base_set_tty_state,
1333   ser_base_print_tty_state,
1334   ser_base_setbaudrate,
1335   ser_base_setstopbits,
1336   ser_base_setparity,
1337   ser_base_drain_output,
1338   ser_base_async,
1339   net_read_prim,
1340   net_write_prim,
1341   NULL,
1342   net_windows_wait_handle,
1343   net_windows_done_wait_handle
1344 };
1345
1346 void
1347 _initialize_ser_windows (void)
1348 {
1349   WSADATA wsa_data;
1350   struct serial_ops *ops;
1351
1352   HMODULE hm = NULL;
1353
1354   /* First find out if kernel32 exports CancelIo function.  */
1355   hm = LoadLibrary ("kernel32.dll");
1356   if (hm)
1357     {
1358       CancelIo = (CancelIo_ftype *) GetProcAddress (hm, "CancelIo");
1359       FreeLibrary (hm);
1360     }
1361   else
1362     CancelIo = NULL;
1363
1364   serial_add_interface (&hardwire_ops);
1365   serial_add_interface (&tty_ops);
1366   serial_add_interface (&pipe_ops);
1367
1368   /* If WinSock works, register the TCP/UDP socket driver.  */
1369
1370   if (WSAStartup (MAKEWORD (1, 0), &wsa_data) != 0)
1371     /* WinSock is unavailable.  */
1372     return;
1373
1374   serial_add_interface (&tcp_ops);
1375 }