gdb/ser-mingw.c

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