1 /* Serial interface for local (hardwired) serial ports on Windows systems
3 Copyright (C) 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
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.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
30 #include <sys/types.h>
32 #include "gdb_assert.h"
33 #include "gdb_string.h"
37 void _initialize_ser_windows (void);
39 struct ser_windows_state
47 /* Open up a real live device for serial I/O. */
50 ser_windows_open (struct serial *scb, const char *name)
53 struct ser_windows_state *state;
54 COMMTIMEOUTS timeouts;
56 h = CreateFile (name, GENERIC_READ | GENERIC_WRITE, 0, NULL,
57 OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);
58 if (h == INVALID_HANDLE_VALUE)
64 scb->fd = _open_osfhandle ((long) h, O_RDWR);
71 if (!SetCommMask (h, EV_RXCHAR))
77 timeouts.ReadIntervalTimeout = MAXDWORD;
78 timeouts.ReadTotalTimeoutConstant = 0;
79 timeouts.ReadTotalTimeoutMultiplier = 0;
80 timeouts.WriteTotalTimeoutConstant = 0;
81 timeouts.WriteTotalTimeoutMultiplier = 0;
82 if (!SetCommTimeouts (h, &timeouts))
88 state = xmalloc (sizeof (struct ser_windows_state));
89 memset (state, 0, sizeof (struct ser_windows_state));
92 /* Create a manual reset event to watch the input buffer. */
93 state->ov.hEvent = CreateEvent (0, TRUE, FALSE, 0);
95 /* Create a (currently unused) handle to record exceptions. */
96 state->except_event = CreateEvent (0, TRUE, FALSE, 0);
101 /* Wait for the output to drain away, as opposed to flushing (discarding)
105 ser_windows_drain_output (struct serial *scb)
107 HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
109 return (FlushFileBuffers (h) != 0) ? 0 : -1;
113 ser_windows_flush_output (struct serial *scb)
115 HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
117 return (PurgeComm (h, PURGE_TXCLEAR) != 0) ? 0 : -1;
121 ser_windows_flush_input (struct serial *scb)
123 HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
125 return (PurgeComm (h, PURGE_RXCLEAR) != 0) ? 0 : -1;
129 ser_windows_send_break (struct serial *scb)
131 HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
133 if (SetCommBreak (h) == 0)
136 /* Delay for 250 milliseconds. */
139 if (ClearCommBreak (h))
146 ser_windows_raw (struct serial *scb)
148 HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
151 if (GetCommState (h, &state) == 0)
154 state.fParity = FALSE;
155 state.fOutxCtsFlow = FALSE;
156 state.fOutxDsrFlow = FALSE;
157 state.fDtrControl = DTR_CONTROL_ENABLE;
158 state.fDsrSensitivity = FALSE;
162 state.fAbortOnError = FALSE;
164 state.Parity = NOPARITY;
166 scb->current_timeout = 0;
168 if (SetCommState (h, &state) == 0)
169 warning (_("SetCommState failed\n"));
173 ser_windows_setstopbits (struct serial *scb, int num)
175 HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
178 if (GetCommState (h, &state) == 0)
183 case SERIAL_1_STOPBITS:
184 state.StopBits = ONESTOPBIT;
186 case SERIAL_1_AND_A_HALF_STOPBITS:
187 state.StopBits = ONE5STOPBITS;
189 case SERIAL_2_STOPBITS:
190 state.StopBits = TWOSTOPBITS;
196 return (SetCommState (h, &state) != 0) ? 0 : -1;
200 ser_windows_setbaudrate (struct serial *scb, int rate)
202 HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
205 if (GetCommState (h, &state) == 0)
208 state.BaudRate = rate;
210 return (SetCommState (h, &state) != 0) ? 0 : -1;
214 ser_windows_close (struct serial *scb)
216 struct ser_windows_state *state;
218 /* Stop any pending selects. */
219 CancelIo ((HANDLE) _get_osfhandle (scb->fd));
221 CloseHandle (state->ov.hEvent);
222 CloseHandle (state->except_event);
234 ser_windows_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except)
236 struct ser_windows_state *state;
239 HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
243 *except = state->except_event;
244 *read = state->ov.hEvent;
246 if (state->in_progress)
249 /* Reset the mask - we are only interested in any characters which
250 arrive after this point, not characters which might have arrived
251 and already been read. */
253 /* This really, really shouldn't be necessary - just the second one.
254 But otherwise an internal flag for EV_RXCHAR does not get
255 cleared, and we get a duplicated event, if the last batch
256 of characters included at least two arriving close together. */
257 if (!SetCommMask (h, 0))
258 warning (_("ser_windows_wait_handle: reseting mask failed"));
260 if (!SetCommMask (h, EV_RXCHAR))
261 warning (_("ser_windows_wait_handle: reseting mask failed (2)"));
263 /* There's a potential race condition here; we must check cbInQue
264 and not wait if that's nonzero. */
266 ClearCommError (h, &errors, &status);
267 if (status.cbInQue > 0)
269 SetEvent (state->ov.hEvent);
273 state->in_progress = 1;
274 ResetEvent (state->ov.hEvent);
275 state->lastCommMask = -2;
276 if (WaitCommEvent (h, &state->lastCommMask, &state->ov))
278 gdb_assert (state->lastCommMask & EV_RXCHAR);
279 SetEvent (state->ov.hEvent);
282 gdb_assert (GetLastError () == ERROR_IO_PENDING);
286 ser_windows_read_prim (struct serial *scb, size_t count)
288 struct ser_windows_state *state;
290 DWORD bytes_read, bytes_read_tmp;
295 if (state->in_progress)
297 WaitForSingleObject (state->ov.hEvent, INFINITE);
298 state->in_progress = 0;
299 ResetEvent (state->ov.hEvent);
302 memset (&ov, 0, sizeof (OVERLAPPED));
303 ov.hEvent = CreateEvent (0, FALSE, FALSE, 0);
304 h = (HANDLE) _get_osfhandle (scb->fd);
306 if (!ReadFile (h, scb->buf, /* count */ 1, &bytes_read, &ov))
308 if (GetLastError () != ERROR_IO_PENDING
309 || !GetOverlappedResult (h, &ov, &bytes_read, TRUE))
313 CloseHandle (ov.hEvent);
318 ser_windows_write_prim (struct serial *scb, const void *buf, size_t len)
320 struct ser_windows_state *state;
325 memset (&ov, 0, sizeof (OVERLAPPED));
326 ov.hEvent = CreateEvent (0, FALSE, FALSE, 0);
327 h = (HANDLE) _get_osfhandle (scb->fd);
328 if (!WriteFile (h, buf, len, &bytes_written, &ov))
330 if (GetLastError () != ERROR_IO_PENDING
331 || !GetOverlappedResult (h, &ov, &bytes_written, TRUE))
335 CloseHandle (ov.hEvent);
336 return bytes_written;
339 /* On Windows, gdb_select is implemented using WaitForMulpleObjects.
340 A "select thread" is created for each file descriptor. These
341 threads looks for activity on the corresponding descriptor, using
342 whatever techniques are appropriate for the descriptor type. When
343 that activity occurs, the thread signals an appropriate event,
344 which wakes up WaitForMultipleObjects.
346 Each select thread is in one of two states: stopped or started.
347 Select threads begin in the stopped state. When gdb_select is
348 called, threads corresponding to the descriptors of interest are
349 started by calling a wait_handle function. Each thread that
350 notices activity signals the appropriate event and then reenters
351 the stopped state. Before gdb_select returns it calls the
352 wait_handle_done functions, which return the threads to the stopped
355 enum select_thread_state {
360 struct ser_console_state
362 /* Signaled by the select thread to indicate that data is available
363 on the file descriptor. */
365 /* Signaled by the select thread to indicate that an exception has
366 occurred on the file descriptor. */
368 /* Signaled by the select thread to indicate that it has entered the
369 started state. HAVE_STARTED and HAVE_STOPPED are never signaled
372 /* Signaled by the select thread to indicate that it has stopped,
373 either because data is available (and READ_EVENT is signaled),
374 because an exception has occurred (and EXCEPT_EVENT is signaled),
375 or because STOP_SELECT was signaled. */
378 /* Signaled by the main program to tell the select thread to enter
379 the started state. */
381 /* Signaled by the main program to tell the select thread to enter
382 the stopped state. */
384 /* Signaled by the main program to tell the select thread to
388 /* The handle for the select thread. */
390 /* The state of the select thread. This field is only accessed in
391 the main program, never by the select thread itself. */
392 enum select_thread_state thread_state;
395 /* Called by a select thread to enter the stopped state. This
396 function does not return until the thread has re-entered the
399 select_thread_wait (struct ser_console_state *state)
401 HANDLE wait_events[2];
403 /* There are two things that can wake us up: a request that we enter
404 the started state, or that we exit this thread. */
405 wait_events[0] = state->start_select;
406 wait_events[1] = state->exit_select;
407 if (WaitForMultipleObjects (2, wait_events, FALSE, INFINITE)
409 /* Either the EXIT_SELECT event was signaled (requesting that the
410 thread exit) or an error has occurred. In either case, we exit
414 /* We are now in the started state. */
415 SetEvent (state->have_started);
418 typedef DWORD WINAPI (*thread_fn_type)(void *);
420 /* Create a new select thread for SCB executing THREAD_FN. The STATE
421 will be filled in by this function before return. */
423 create_select_thread (thread_fn_type thread_fn,
425 struct ser_console_state *state)
429 /* Create all of the events. These are all auto-reset events. */
430 state->read_event = CreateEvent (NULL, FALSE, FALSE, NULL);
431 state->except_event = CreateEvent (NULL, FALSE, FALSE, NULL);
432 state->have_started = CreateEvent (NULL, FALSE, FALSE, NULL);
433 state->have_stopped = CreateEvent (NULL, FALSE, FALSE, NULL);
434 state->start_select = CreateEvent (NULL, FALSE, FALSE, NULL);
435 state->stop_select = CreateEvent (NULL, FALSE, FALSE, NULL);
436 state->exit_select = CreateEvent (NULL, FALSE, FALSE, NULL);
438 state->thread = CreateThread (NULL, 0, thread_fn, scb, 0, &threadId);
439 /* The thread begins in the stopped state. */
440 state->thread_state = STS_STOPPED;
443 /* Destroy the select thread indicated by STATE. */
445 destroy_select_thread (struct ser_console_state *state)
447 /* Ask the thread to exit. */
448 SetEvent (state->exit_select);
449 /* Wait until it does. */
450 WaitForSingleObject (state->thread, INFINITE);
452 /* Destroy the events. */
453 CloseHandle (state->read_event);
454 CloseHandle (state->except_event);
455 CloseHandle (state->have_started);
456 CloseHandle (state->have_stopped);
457 CloseHandle (state->start_select);
458 CloseHandle (state->stop_select);
459 CloseHandle (state->exit_select);
462 /* Called by gdb_select to start the select thread indicated by STATE.
463 This function does not return until the thread has started. */
465 start_select_thread (struct ser_console_state *state)
467 /* Ask the thread to start. */
468 SetEvent (state->start_select);
469 /* Wait until it does. */
470 WaitForSingleObject (state->have_started, INFINITE);
471 /* The thread is now started. */
472 state->thread_state = STS_STARTED;
475 /* Called by gdb_select to stop the select thread indicated by STATE.
476 This function does not return until the thread has stopped. */
478 stop_select_thread (struct ser_console_state *state)
480 /* If the thread is already in the stopped state, we have nothing to
481 do. Some of the wait_handle functions avoid calling
482 start_select_thread if they notice activity on the relevant file
483 descriptors. The wait_handle_done functions still call
484 stop_select_thread -- but it is already stopped. */
485 if (state->thread_state != STS_STARTED)
487 /* Ask the thread to stop. */
488 SetEvent (state->stop_select);
489 /* Wait until it does. */
490 WaitForSingleObject (state->have_stopped, INFINITE);
491 /* The thread is now stopped. */
492 state->thread_state = STS_STOPPED;
496 console_select_thread (void *arg)
498 struct serial *scb = arg;
499 struct ser_console_state *state;
504 h = (HANDLE) _get_osfhandle (scb->fd);
508 HANDLE wait_events[2];
512 select_thread_wait (state);
516 wait_events[0] = state->stop_select;
519 event_index = WaitForMultipleObjects (2, wait_events, FALSE, INFINITE);
521 if (event_index == WAIT_OBJECT_0
522 || WaitForSingleObject (state->stop_select, 0) == WAIT_OBJECT_0)
525 if (event_index != WAIT_OBJECT_0 + 1)
527 /* Wait must have failed; assume an error has occured, e.g.
528 the handle has been closed. */
529 SetEvent (state->except_event);
533 /* We've got a pending event on the console. See if it's
535 if (!PeekConsoleInput (h, &record, 1, &n_records) || n_records != 1)
537 /* Something went wrong. Maybe the console is gone. */
538 SetEvent (state->except_event);
542 if (record.EventType == KEY_EVENT && record.Event.KeyEvent.bKeyDown)
544 WORD keycode = record.Event.KeyEvent.wVirtualKeyCode;
546 /* Ignore events containing only control keys. We must
547 recognize "enhanced" keys which we are interested in
548 reading via getch, if they do not map to ASCII. But we
549 do not want to report input available for e.g. the
550 control key alone. */
552 if (record.Event.KeyEvent.uChar.AsciiChar != 0
553 || keycode == VK_PRIOR
554 || keycode == VK_NEXT
556 || keycode == VK_HOME
557 || keycode == VK_LEFT
559 || keycode == VK_RIGHT
560 || keycode == VK_DOWN
561 || keycode == VK_INSERT
562 || keycode == VK_DELETE)
564 /* This is really a keypress. */
565 SetEvent (state->read_event);
570 /* Otherwise discard it and wait again. */
571 ReadConsoleInput (h, &record, 1, &n_records);
574 SetEvent(state->have_stopped);
581 if (PeekNamedPipe ((HANDLE) _get_osfhandle (fd), NULL, 0, NULL, NULL, NULL))
590 if (GetFileType ((HANDLE) _get_osfhandle (fd)) == FILE_TYPE_DISK)
597 pipe_select_thread (void *arg)
599 struct serial *scb = arg;
600 struct ser_console_state *state;
605 h = (HANDLE) _get_osfhandle (scb->fd);
611 select_thread_wait (state);
613 /* Wait for something to happen on the pipe. */
616 if (!PeekNamedPipe (h, NULL, 0, NULL, &n_avail, NULL))
618 SetEvent (state->except_event);
624 SetEvent (state->read_event);
628 /* Delay 10ms before checking again, but allow the stop
630 if (WaitForSingleObject (state->stop_select, 10) == WAIT_OBJECT_0)
634 SetEvent (state->have_stopped);
639 file_select_thread (void *arg)
641 struct serial *scb = arg;
642 struct ser_console_state *state;
647 h = (HANDLE) _get_osfhandle (scb->fd);
651 select_thread_wait (state);
653 if (SetFilePointer (h, 0, NULL, FILE_CURRENT) == INVALID_SET_FILE_POINTER)
654 SetEvent (state->except_event);
656 SetEvent (state->read_event);
658 SetEvent (state->have_stopped);
663 ser_console_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except)
665 struct ser_console_state *state = scb->state;
669 thread_fn_type thread_fn;
672 is_tty = isatty (scb->fd);
673 if (!is_tty && !fd_is_file (scb->fd) && !fd_is_pipe (scb->fd))
680 state = xmalloc (sizeof (struct ser_console_state));
681 memset (state, 0, sizeof (struct ser_console_state));
685 thread_fn = console_select_thread;
686 else if (fd_is_pipe (scb->fd))
687 thread_fn = pipe_select_thread;
689 thread_fn = file_select_thread;
691 create_select_thread (thread_fn, scb, state);
694 *read = state->read_event;
695 *except = state->except_event;
697 /* Start from a blank state. */
698 ResetEvent (state->read_event);
699 ResetEvent (state->except_event);
700 ResetEvent (state->stop_select);
702 /* First check for a key already in the buffer. If there is one,
703 we don't need a thread. This also catches the second key of
704 multi-character returns from getch, for instance for arrow
705 keys. The second half is in a C library internal buffer,
706 and PeekConsoleInput will not find it. */
709 SetEvent (state->read_event);
713 /* Otherwise, start the select thread. */
714 start_select_thread (state);
718 ser_console_done_wait_handle (struct serial *scb)
720 struct ser_console_state *state = scb->state;
725 stop_select_thread (state);
729 ser_console_close (struct serial *scb)
731 struct ser_console_state *state = scb->state;
735 destroy_select_thread (state);
740 struct ser_console_ttystate
745 static serial_ttystate
746 ser_console_get_tty_state (struct serial *scb)
748 if (isatty (scb->fd))
750 struct ser_console_ttystate *state;
751 state = (struct ser_console_ttystate *) xmalloc (sizeof *state);
761 /* Since we use the pipe_select_thread for our select emulation,
762 we need to place the state structure it requires at the front
764 struct ser_console_state wait;
766 /* The pex obj for our (one-stage) pipeline. */
769 /* Streams for the pipeline's input and output. */
770 FILE *input, *output;
773 static struct pipe_state *
774 make_pipe_state (void)
776 struct pipe_state *ps = XMALLOC (struct pipe_state);
778 memset (ps, 0, sizeof (*ps));
779 ps->wait.read_event = INVALID_HANDLE_VALUE;
780 ps->wait.except_event = INVALID_HANDLE_VALUE;
781 ps->wait.start_select = INVALID_HANDLE_VALUE;
782 ps->wait.stop_select = INVALID_HANDLE_VALUE;
788 free_pipe_state (struct pipe_state *ps)
790 int saved_errno = errno;
792 if (ps->wait.read_event != INVALID_HANDLE_VALUE)
793 destroy_select_thread (&ps->wait);
795 /* Close the pipe to the child. We must close the pipe before
796 calling pex_free because pex_free will wait for the child to exit
797 and the child will not exit until the pipe is closed. */
802 /* pex_free closes ps->output. */
810 cleanup_pipe_state (void *untyped)
812 struct pipe_state *ps = untyped;
814 free_pipe_state (ps);
818 pipe_windows_open (struct serial *scb, const char *name)
820 struct pipe_state *ps;
823 struct cleanup *back_to;
826 error_no_arg (_("child command"));
828 argv = gdb_buildargv (name);
829 back_to = make_cleanup_freeargv (argv);
831 if (! argv[0] || argv[0][0] == '\0')
832 error ("missing child command");
834 ps = make_pipe_state ();
835 make_cleanup (cleanup_pipe_state, ps);
837 ps->pex = pex_init (PEX_USE_PIPES, "target remote pipe", NULL);
840 ps->input = pex_input_pipe (ps->pex, 1);
847 = pex_run (ps->pex, PEX_SEARCH | PEX_BINARY_INPUT | PEX_BINARY_OUTPUT
848 | PEX_STDERR_TO_PIPE,
849 argv[0], argv, NULL, NULL,
854 /* Our caller expects us to return -1, but all they'll do with
855 it generally is print the message based on errno. We have
856 all the same information here, plus err_msg provided by
857 pex_run, so we just raise the error here. */
859 error ("error starting child process '%s': %s: %s",
860 name, err_msg, safe_strerror (err));
862 error ("error starting child process '%s': %s",
867 ps->output = pex_read_output (ps->pex, 1);
870 scb->fd = fileno (ps->output);
872 pex_stderr = pex_read_err (ps->pex, 1);
875 scb->error_fd = fileno (pex_stderr);
877 scb->state = (void *) ps;
879 discard_cleanups (back_to);
883 do_cleanups (back_to);
889 pipe_windows_close (struct serial *scb)
891 struct pipe_state *ps = scb->state;
893 /* In theory, we should try to kill the subprocess here, but the pex
894 interface doesn't give us enough information to do that. Usually
895 closing the input pipe will get the message across. */
897 free_pipe_state (ps);
902 pipe_windows_read (struct serial *scb, size_t count)
904 HANDLE pipeline_out = (HANDLE) _get_osfhandle (scb->fd);
908 if (pipeline_out == INVALID_HANDLE_VALUE)
911 if (! PeekNamedPipe (pipeline_out, NULL, 0, NULL, &available, NULL))
914 if (count > available)
917 if (! ReadFile (pipeline_out, scb->buf, count, &bytes_read, NULL))
925 pipe_windows_write (struct serial *scb, const void *buf, size_t count)
927 struct pipe_state *ps = scb->state;
931 int pipeline_in_fd = fileno (ps->input);
932 if (pipeline_in_fd < 0)
935 pipeline_in = (HANDLE) _get_osfhandle (pipeline_in_fd);
936 if (pipeline_in == INVALID_HANDLE_VALUE)
939 if (! WriteFile (pipeline_in, buf, count, &written, NULL))
947 pipe_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except)
949 struct pipe_state *ps = scb->state;
951 /* Have we allocated our events yet? */
952 if (ps->wait.read_event == INVALID_HANDLE_VALUE)
953 /* Start the thread. */
954 create_select_thread (pipe_select_thread, scb, &ps->wait);
956 *read = ps->wait.read_event;
957 *except = ps->wait.except_event;
959 /* Start from a blank state. */
960 ResetEvent (ps->wait.read_event);
961 ResetEvent (ps->wait.except_event);
962 ResetEvent (ps->wait.stop_select);
964 start_select_thread (&ps->wait);
968 pipe_done_wait_handle (struct serial *scb)
970 struct pipe_state *ps = scb->state;
972 /* Have we allocated our events yet? */
973 if (ps->wait.read_event == INVALID_HANDLE_VALUE)
976 stop_select_thread (&ps->wait);
980 pipe_avail (struct serial *scb, int fd)
982 HANDLE h = (HANDLE) _get_osfhandle (fd);
984 BOOL r = PeekNamedPipe (h, NULL, 0, NULL, &numBytes, NULL);
990 struct net_windows_state
992 struct ser_console_state base;
998 net_windows_select_thread (void *arg)
1000 struct serial *scb = arg;
1001 struct net_windows_state *state;
1008 HANDLE wait_events[2];
1009 WSANETWORKEVENTS events;
1011 select_thread_wait (&state->base);
1013 wait_events[0] = state->base.stop_select;
1014 wait_events[1] = state->sock_event;
1016 event_index = WaitForMultipleObjects (2, wait_events, FALSE, INFINITE);
1018 if (event_index == WAIT_OBJECT_0
1019 || WaitForSingleObject (state->base.stop_select, 0) == WAIT_OBJECT_0)
1020 /* We have been requested to stop. */
1022 else if (event_index != WAIT_OBJECT_0 + 1)
1023 /* Some error has occured. Assume that this is an error
1025 SetEvent (state->base.except_event);
1028 /* Enumerate the internal network events, and reset the
1029 object that signalled us to catch the next event. */
1030 WSAEnumNetworkEvents (scb->fd, state->sock_event, &events);
1032 gdb_assert (events.lNetworkEvents & (FD_READ | FD_CLOSE));
1034 if (events.lNetworkEvents & FD_READ)
1035 SetEvent (state->base.read_event);
1037 if (events.lNetworkEvents & FD_CLOSE)
1038 SetEvent (state->base.except_event);
1041 SetEvent (state->base.have_stopped);
1046 net_windows_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except)
1048 struct net_windows_state *state = scb->state;
1050 /* Start from a clean slate. */
1051 ResetEvent (state->base.read_event);
1052 ResetEvent (state->base.except_event);
1053 ResetEvent (state->base.stop_select);
1055 *read = state->base.read_event;
1056 *except = state->base.except_event;
1058 /* Check any pending events. This both avoids starting the thread
1059 unnecessarily, and handles stray FD_READ events (see below). */
1060 if (WaitForSingleObject (state->sock_event, 0) == WAIT_OBJECT_0)
1062 WSANETWORKEVENTS events;
1065 /* Enumerate the internal network events, and reset the object that
1066 signalled us to catch the next event. */
1067 WSAEnumNetworkEvents (scb->fd, state->sock_event, &events);
1069 /* You'd think that FD_READ or FD_CLOSE would be set here. But,
1070 sometimes, neither is. I suspect that the FD_READ is set and
1071 the corresponding event signalled while recv is running, and
1072 the FD_READ is then lowered when recv consumes all the data,
1073 but there's no way to un-signal the event. This isn't a
1074 problem for the call in net_select_thread, since any new
1075 events after this point will not have been drained by recv.
1076 It just means that we can't have the obvious assert here. */
1078 /* If there is a read event, it might be still valid, or it might
1079 not be - it may have been signalled before we last called
1080 recv. Double-check that there is data. */
1081 if (events.lNetworkEvents & FD_READ)
1083 unsigned long available;
1085 if (ioctlsocket (scb->fd, FIONREAD, &available) == 0
1088 SetEvent (state->base.read_event);
1092 /* Oops, no data. This call to recv will cause future
1093 data to retrigger the event, e.g. while we are
1094 in net_select_thread. */
1095 recv (scb->fd, NULL, 0, 0);
1098 /* If there's a close event, then record it - it is obviously
1099 still valid, and it will not be resignalled. */
1100 if (events.lNetworkEvents & FD_CLOSE)
1102 SetEvent (state->base.except_event);
1106 /* If we set either handle, there's no need to wake the thread. */
1111 start_select_thread (&state->base);
1115 net_windows_done_wait_handle (struct serial *scb)
1117 struct net_windows_state *state = scb->state;
1119 stop_select_thread (&state->base);
1123 net_windows_open (struct serial *scb, const char *name)
1125 struct net_windows_state *state;
1129 ret = net_open (scb, name);
1133 state = xmalloc (sizeof (struct net_windows_state));
1134 memset (state, 0, sizeof (struct net_windows_state));
1137 /* Associate an event with the socket. */
1138 state->sock_event = CreateEvent (0, TRUE, FALSE, 0);
1139 WSAEventSelect (scb->fd, state->sock_event, FD_READ | FD_CLOSE);
1141 /* Start the thread. */
1142 create_select_thread (net_windows_select_thread, scb, &state->base);
1149 net_windows_close (struct serial *scb)
1151 struct net_windows_state *state = scb->state;
1153 destroy_select_thread (&state->base);
1154 CloseHandle (state->sock_event);
1162 _initialize_ser_windows (void)
1165 struct serial_ops *ops;
1167 /* First register the serial port driver. */
1169 ops = XMALLOC (struct serial_ops);
1170 memset (ops, 0, sizeof (struct serial_ops));
1171 ops->name = "hardwire";
1173 ops->open = ser_windows_open;
1174 ops->close = ser_windows_close;
1176 ops->flush_output = ser_windows_flush_output;
1177 ops->flush_input = ser_windows_flush_input;
1178 ops->send_break = ser_windows_send_break;
1180 /* These are only used for stdin; we do not need them for serial
1181 ports, so supply the standard dummies. */
1182 ops->get_tty_state = ser_base_get_tty_state;
1183 ops->set_tty_state = ser_base_set_tty_state;
1184 ops->print_tty_state = ser_base_print_tty_state;
1185 ops->noflush_set_tty_state = ser_base_noflush_set_tty_state;
1187 ops->go_raw = ser_windows_raw;
1188 ops->setbaudrate = ser_windows_setbaudrate;
1189 ops->setstopbits = ser_windows_setstopbits;
1190 ops->drain_output = ser_windows_drain_output;
1191 ops->readchar = ser_base_readchar;
1192 ops->write = ser_base_write;
1193 ops->async = ser_base_async;
1194 ops->read_prim = ser_windows_read_prim;
1195 ops->write_prim = ser_windows_write_prim;
1196 ops->wait_handle = ser_windows_wait_handle;
1198 serial_add_interface (ops);
1200 /* Next create the dummy serial driver used for terminals. We only
1201 provide the TTY-related methods. */
1203 ops = XMALLOC (struct serial_ops);
1204 memset (ops, 0, sizeof (struct serial_ops));
1206 ops->name = "terminal";
1209 ops->close = ser_console_close;
1210 ops->get_tty_state = ser_console_get_tty_state;
1211 ops->set_tty_state = ser_base_set_tty_state;
1212 ops->print_tty_state = ser_base_print_tty_state;
1213 ops->noflush_set_tty_state = ser_base_noflush_set_tty_state;
1214 ops->drain_output = ser_base_drain_output;
1215 ops->wait_handle = ser_console_wait_handle;
1216 ops->done_wait_handle = ser_console_done_wait_handle;
1218 serial_add_interface (ops);
1220 /* The pipe interface. */
1222 ops = XMALLOC (struct serial_ops);
1223 memset (ops, 0, sizeof (struct serial_ops));
1226 ops->open = pipe_windows_open;
1227 ops->close = pipe_windows_close;
1228 ops->readchar = ser_base_readchar;
1229 ops->write = ser_base_write;
1230 ops->flush_output = ser_base_flush_output;
1231 ops->flush_input = ser_base_flush_input;
1232 ops->send_break = ser_base_send_break;
1233 ops->go_raw = ser_base_raw;
1234 ops->get_tty_state = ser_base_get_tty_state;
1235 ops->set_tty_state = ser_base_set_tty_state;
1236 ops->print_tty_state = ser_base_print_tty_state;
1237 ops->noflush_set_tty_state = ser_base_noflush_set_tty_state;
1238 ops->setbaudrate = ser_base_setbaudrate;
1239 ops->setstopbits = ser_base_setstopbits;
1240 ops->drain_output = ser_base_drain_output;
1241 ops->async = ser_base_async;
1242 ops->read_prim = pipe_windows_read;
1243 ops->write_prim = pipe_windows_write;
1244 ops->wait_handle = pipe_wait_handle;
1245 ops->done_wait_handle = pipe_done_wait_handle;
1246 ops->avail = pipe_avail;
1248 serial_add_interface (ops);
1250 /* If WinSock works, register the TCP/UDP socket driver. */
1252 if (WSAStartup (MAKEWORD (1, 0), &wsa_data) != 0)
1253 /* WinSock is unavailable. */
1256 ops = XMALLOC (struct serial_ops);
1257 memset (ops, 0, sizeof (struct serial_ops));
1260 ops->open = net_windows_open;
1261 ops->close = net_windows_close;
1262 ops->readchar = ser_base_readchar;
1263 ops->write = ser_base_write;
1264 ops->flush_output = ser_base_flush_output;
1265 ops->flush_input = ser_base_flush_input;
1266 ops->send_break = ser_tcp_send_break;
1267 ops->go_raw = ser_base_raw;
1268 ops->get_tty_state = ser_base_get_tty_state;
1269 ops->set_tty_state = ser_base_set_tty_state;
1270 ops->print_tty_state = ser_base_print_tty_state;
1271 ops->noflush_set_tty_state = ser_base_noflush_set_tty_state;
1272 ops->setbaudrate = ser_base_setbaudrate;
1273 ops->setstopbits = ser_base_setstopbits;
1274 ops->drain_output = ser_base_drain_output;
1275 ops->async = ser_base_async;
1276 ops->read_prim = net_read_prim;
1277 ops->write_prim = net_write_prim;
1278 ops->wait_handle = net_windows_wait_handle;
1279 ops->done_wait_handle = net_windows_done_wait_handle;
1280 serial_add_interface (ops);