gdb/ser-mingw.c

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