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 = (HANDLE) _get_osfhandle (scb->fd);
 772   DWORD available;
 773   DWORD bytes_read;
 774
 775   if (pipeline_out == INVALID_HANDLE_VALUE)
 776     return -1;
 777
 778   if (! PeekNamedPipe (pipeline_out, NULL, 0, NULL, &available, NULL))
 779     return -1;
 780
 781   if (count > available)
 782     count = available;
 783
 784   if (! ReadFile (pipeline_out, scb->buf, count, &bytes_read, NULL))
 785     return -1;
 786
 787   return bytes_read;
 788 }
 789
 790
 791 static int
 792 pipe_windows_write (struct serial *scb, const void *buf, size_t count)
 793 {
 794   struct pipe_state *ps = scb->state;
 795   HANDLE pipeline_in;
 796   DWORD written;
 797
 798   int pipeline_in_fd = fileno (ps->input);
 799   if (pipeline_in_fd < 0)
 800     return -1;
 801
 802   pipeline_in = (HANDLE) _get_osfhandle (pipeline_in_fd);
 803   if (pipeline_in == INVALID_HANDLE_VALUE)
 804     return -1;
 805
 806   if (! WriteFile (pipeline_in, buf, count, &written, NULL))
 807     return -1;
 808
 809   return written;
 810 }
 811
 812
 813 static void
 814 pipe_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except)
 815 {
 816   struct pipe_state *ps = scb->state;
 817
 818   /* Have we allocated our events yet?  */
 819   if (ps->wait.read_event == INVALID_HANDLE_VALUE)
 820     {
 821       DWORD threadId;
 822
 823       /* Create auto reset events to wake, stop, and exit the select
 824          thread.  */
 825       ps->wait.start_select = CreateEvent (0, FALSE, FALSE, 0);
 826       ps->wait.stop_select = CreateEvent (0, FALSE, FALSE, 0);
 827       ps->wait.exit_select = CreateEvent (0, FALSE, FALSE, 0);
 828
 829       /* Create a manual reset event to signal whether the thread is
 830          stopped.  This must be manual reset, because we may wait on
 831          it multiple times without ever starting the thread.  */
 832       ps->wait.have_stopped = CreateEvent (0, TRUE, FALSE, 0);
 833
 834       /* Create our own events to report read and exceptions separately.
 835          The exception event is currently never used.  */
 836       ps->wait.read_event = CreateEvent (0, FALSE, FALSE, 0);
 837       ps->wait.except_event = CreateEvent (0, FALSE, FALSE, 0);
 838
 839       /* Start the select thread.  */
 840       CreateThread (NULL, 0, pipe_select_thread, scb, 0, &threadId);
 841     }
 842
 843   *read = ps->wait.read_event;
 844   *except = ps->wait.except_event;
 845
 846   /* Start from a blank state.  */
 847   ResetEvent (ps->wait.read_event);
 848   ResetEvent (ps->wait.except_event);
 849   ResetEvent (ps->wait.stop_select);
 850
 851   /* Start the select thread.  */
 852   SetEvent (ps->wait.start_select);
 853 }
 854
 855 static void
 856 pipe_done_wait_handle (struct serial *scb)
 857 {
 858   struct pipe_state *ps = scb->state;
 859
 860   /* Have we allocated our events yet?  */
 861   if (ps->wait.read_event == INVALID_HANDLE_VALUE)
 862     return;
 863
 864   SetEvent (ps->wait.stop_select);
 865   WaitForSingleObject (ps->wait.have_stopped, INFINITE);
 866 }
 867
 868 struct net_windows_state
 869 {
 870   HANDLE read_event;
 871   HANDLE except_event;
 872
 873   HANDLE start_select;
 874   HANDLE stop_select;
 875   HANDLE exit_select;
 876   HANDLE have_stopped;
 877
 878   HANDLE sock_event;
 879
 880   HANDLE thread;
 881 };
 882
 883 static DWORD WINAPI
 884 net_windows_select_thread (void *arg)
 885 {
 886   struct serial *scb = arg;
 887   struct net_windows_state *state, state_copy;
 888   int event_index;
 889
 890   state = scb->state;
 891
 892   while (1)
 893     {
 894       HANDLE wait_events[2];
 895       WSANETWORKEVENTS events;
 896
 897       SetEvent (state->have_stopped);
 898
 899       wait_events[0] = state->start_select;
 900       wait_events[1] = state->exit_select;
 901
 902       if (WaitForMultipleObjects (2, wait_events, FALSE, INFINITE) != WAIT_OBJECT_0)
 903         return 0;
 904
 905       ResetEvent (state->have_stopped);
 906
 907       wait_events[0] = state->stop_select;
 908       wait_events[1] = state->sock_event;
 909
 910       event_index = WaitForMultipleObjects (2, wait_events, FALSE, INFINITE);
 911
 912       if (event_index == WAIT_OBJECT_0
 913           || WaitForSingleObject (state->stop_select, 0) == WAIT_OBJECT_0)
 914         continue;
 915
 916       if (event_index != WAIT_OBJECT_0 + 1)
 917         {
 918           /* Some error has occured.  Assume that this is an error
 919              condition.  */
 920           SetEvent (state->except_event);
 921           continue;
 922         }
 923
 924       /* Enumerate the internal network events, and reset the object that
 925          signalled us to catch the next event.  */
 926       WSAEnumNetworkEvents (scb->fd, state->sock_event, &events);
 927
 928       gdb_assert (events.lNetworkEvents & (FD_READ | FD_CLOSE));
 929
 930       if (events.lNetworkEvents & FD_READ)
 931         SetEvent (state->read_event);
 932
 933       if (events.lNetworkEvents & FD_CLOSE)
 934         SetEvent (state->except_event);
 935     }
 936 }
 937
 938 static void
 939 net_windows_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except)
 940 {
 941   struct net_windows_state *state = scb->state;
 942
 943   /* Start from a clean slate.  */
 944   ResetEvent (state->read_event);
 945   ResetEvent (state->except_event);
 946   ResetEvent (state->stop_select);
 947
 948   *read = state->read_event;
 949   *except = state->except_event;
 950
 951   /* Check any pending events.  This both avoids starting the thread
 952      unnecessarily, and handles stray FD_READ events (see below).  */
 953   if (WaitForSingleObject (state->sock_event, 0) == WAIT_OBJECT_0)
 954     {
 955       WSANETWORKEVENTS events;
 956       int any = 0;
 957
 958       /* Enumerate the internal network events, and reset the object that
 959          signalled us to catch the next event.  */
 960       WSAEnumNetworkEvents (scb->fd, state->sock_event, &events);
 961
 962       /* You'd think that FD_READ or FD_CLOSE would be set here.  But,
 963          sometimes, neither is.  I suspect that the FD_READ is set and
 964          the corresponding event signalled while recv is running, and
 965          the FD_READ is then lowered when recv consumes all the data,
 966          but there's no way to un-signal the event.  This isn't a
 967          problem for the call in net_select_thread, since any new
 968          events after this point will not have been drained by recv.
 969          It just means that we can't have the obvious assert here.  */
 970
 971       /* If there is a read event, it might be still valid, or it might
 972          not be - it may have been signalled before we last called
 973          recv.  Double-check that there is data.  */
 974       if (events.lNetworkEvents & FD_READ)
 975         {
 976           unsigned long available;
 977
 978           if (ioctlsocket (scb->fd, FIONREAD, &available) == 0
 979               && available > 0)
 980             {
 981               SetEvent (state->read_event);
 982               any = 1;
 983             }
 984           else
 985             /* Oops, no data.  This call to recv will cause future
 986                data to retrigger the event, e.g. while we are
 987                in net_select_thread.  */
 988             recv (scb->fd, NULL, 0, 0);
 989         }
 990
 991       /* If there's a close event, then record it - it is obviously
 992          still valid, and it will not be resignalled.  */
 993       if (events.lNetworkEvents & FD_CLOSE)
 994         {
 995           SetEvent (state->except_event);
 996           any = 1;
 997         }
 998
 999       /* If we set either handle, there's no need to wake the thread.  */
1000       if (any)
1001         return;
1002     }
1003
1004   /* Start the select thread.  */
1005   SetEvent (state->start_select);
1006 }
1007
1008 static void
1009 net_windows_done_wait_handle (struct serial *scb)
1010 {
1011   struct net_windows_state *state = scb->state;
1012
1013   SetEvent (state->stop_select);
1014   WaitForSingleObject (state->have_stopped, INFINITE);
1015 }
1016
1017 static int
1018 net_windows_open (struct serial *scb, const char *name)
1019 {
1020   struct net_windows_state *state;
1021   int ret;
1022   DWORD threadId;
1023
1024   ret = net_open (scb, name);
1025   if (ret != 0)
1026     return ret;
1027
1028   state = xmalloc (sizeof (struct net_windows_state));
1029   memset (state, 0, sizeof (struct net_windows_state));
1030   scb->state = state;
1031
1032   /* Create auto reset events to wake, stop, and exit the select
1033      thread.  */
1034   state->start_select = CreateEvent (0, FALSE, FALSE, 0);
1035   state->stop_select = CreateEvent (0, FALSE, FALSE, 0);
1036   state->exit_select = CreateEvent (0, FALSE, FALSE, 0);
1037
1038   /* Create a manual reset event to signal whether the thread is
1039      stopped.  This must be manual reset, because we may wait on
1040      it multiple times without ever starting the thread.  */
1041   state->have_stopped = CreateEvent (0, TRUE, FALSE, 0);
1042
1043   /* Associate an event with the socket.  */
1044   state->sock_event = CreateEvent (0, TRUE, FALSE, 0);
1045   WSAEventSelect (scb->fd, state->sock_event, FD_READ | FD_CLOSE);
1046
1047   /* Create our own events to report read and close separately.  */
1048   state->read_event = CreateEvent (0, FALSE, FALSE, 0);
1049   state->except_event = CreateEvent (0, FALSE, FALSE, 0);
1050
1051   /* And finally start the select thread.  */
1052   state->thread = CreateThread (NULL, 0, net_windows_select_thread, scb, 0,
1053                                 &threadId);
1054
1055   return 0;
1056 }
1057
1058
1059 static void
1060 net_windows_close (struct serial *scb)
1061 {
1062   struct net_windows_state *state = scb->state;
1063
1064   SetEvent (state->exit_select);
1065   WaitForSingleObject (state->thread, INFINITE);
1066
1067   CloseHandle (state->read_event);
1068   CloseHandle (state->except_event);
1069
1070   CloseHandle (state->start_select);
1071   CloseHandle (state->stop_select);
1072   CloseHandle (state->exit_select);
1073   CloseHandle (state->have_stopped);
1074
1075   CloseHandle (state->sock_event);
1076
1077   xfree (scb->state);
1078
1079   net_close (scb);
1080 }
1081
1082 void
1083 _initialize_ser_windows (void)
1084 {
1085   WSADATA wsa_data;
1086   struct serial_ops *ops;
1087
1088   /* First register the serial port driver.  */
1089
1090   ops = XMALLOC (struct serial_ops);
1091   memset (ops, 0, sizeof (struct serial_ops));
1092   ops->name = "hardwire";
1093   ops->next = 0;
1094   ops->open = ser_windows_open;
1095   ops->close = ser_windows_close;
1096
1097   ops->flush_output = ser_windows_flush_output;
1098   ops->flush_input = ser_windows_flush_input;
1099   ops->send_break = ser_windows_send_break;
1100
1101   /* These are only used for stdin; we do not need them for serial
1102      ports, so supply the standard dummies.  */
1103   ops->get_tty_state = ser_base_get_tty_state;
1104   ops->set_tty_state = ser_base_set_tty_state;
1105   ops->print_tty_state = ser_base_print_tty_state;
1106   ops->noflush_set_tty_state = ser_base_noflush_set_tty_state;
1107
1108   ops->go_raw = ser_windows_raw;
1109   ops->setbaudrate = ser_windows_setbaudrate;
1110   ops->setstopbits = ser_windows_setstopbits;
1111   ops->drain_output = ser_windows_drain_output;
1112   ops->readchar = ser_base_readchar;
1113   ops->write = ser_base_write;
1114   ops->async = ser_base_async;
1115   ops->read_prim = ser_windows_read_prim;
1116   ops->write_prim = ser_windows_write_prim;
1117   ops->wait_handle = ser_windows_wait_handle;
1118
1119   serial_add_interface (ops);
1120
1121   /* Next create the dummy serial driver used for terminals.  We only
1122      provide the TTY-related methods.  */
1123
1124   ops = XMALLOC (struct serial_ops);
1125   memset (ops, 0, sizeof (struct serial_ops));
1126
1127   ops->name = "terminal";
1128   ops->next = 0;
1129
1130   ops->close = ser_console_close;
1131   ops->get_tty_state = ser_console_get_tty_state;
1132   ops->set_tty_state = ser_base_set_tty_state;
1133   ops->print_tty_state = ser_base_print_tty_state;
1134   ops->noflush_set_tty_state = ser_base_noflush_set_tty_state;
1135   ops->drain_output = ser_base_drain_output;
1136   ops->wait_handle = ser_console_wait_handle;
1137   ops->done_wait_handle = ser_console_done_wait_handle;
1138
1139   serial_add_interface (ops);
1140
1141   /* The pipe interface.  */
1142
1143   ops = XMALLOC (struct serial_ops);
1144   memset (ops, 0, sizeof (struct serial_ops));
1145   ops->name = "pipe";
1146   ops->next = 0;
1147   ops->open = pipe_windows_open;
1148   ops->close = pipe_windows_close;
1149   ops->readchar = ser_base_readchar;
1150   ops->write = ser_base_write;
1151   ops->flush_output = ser_base_flush_output;
1152   ops->flush_input = ser_base_flush_input;
1153   ops->send_break = ser_base_send_break;
1154   ops->go_raw = ser_base_raw;
1155   ops->get_tty_state = ser_base_get_tty_state;
1156   ops->set_tty_state = ser_base_set_tty_state;
1157   ops->print_tty_state = ser_base_print_tty_state;
1158   ops->noflush_set_tty_state = ser_base_noflush_set_tty_state;
1159   ops->setbaudrate = ser_base_setbaudrate;
1160   ops->setstopbits = ser_base_setstopbits;
1161   ops->drain_output = ser_base_drain_output;
1162   ops->async = ser_base_async;
1163   ops->read_prim = pipe_windows_read;
1164   ops->write_prim = pipe_windows_write;
1165   ops->wait_handle = pipe_wait_handle;
1166   ops->done_wait_handle = pipe_done_wait_handle;
1167
1168   serial_add_interface (ops);
1169
1170   /* If WinSock works, register the TCP/UDP socket driver.  */
1171
1172   if (WSAStartup (MAKEWORD (1, 0), &wsa_data) != 0)
1173     /* WinSock is unavailable.  */
1174     return;
1175
1176   ops = XMALLOC (struct serial_ops);
1177   memset (ops, 0, sizeof (struct serial_ops));
1178   ops->name = "tcp";
1179   ops->next = 0;
1180   ops->open = net_windows_open;
1181   ops->close = net_windows_close;
1182   ops->readchar = ser_base_readchar;
1183   ops->write = ser_base_write;
1184   ops->flush_output = ser_base_flush_output;
1185   ops->flush_input = ser_base_flush_input;
1186   ops->send_break = ser_base_send_break;
1187   ops->go_raw = ser_base_raw;
1188   ops->get_tty_state = ser_base_get_tty_state;
1189   ops->set_tty_state = ser_base_set_tty_state;
1190   ops->print_tty_state = ser_base_print_tty_state;
1191   ops->noflush_set_tty_state = ser_base_noflush_set_tty_state;
1192   ops->setbaudrate = ser_base_setbaudrate;
1193   ops->setstopbits = ser_base_setstopbits;
1194   ops->drain_output = ser_base_drain_output;
1195   ops->async = ser_base_async;
1196   ops->read_prim = net_read_prim;
1197   ops->write_prim = net_write_prim;
1198   ops->wait_handle = net_windows_wait_handle;
1199   ops->done_wait_handle = net_windows_done_wait_handle;
1200   serial_add_interface (ops);
1201 }