gdb/ser-mingw.c

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