1 /* Serial interface for local (hardwired) serial ports on Windows systems
3 Copyright (C) 2006, 2007 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 2 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, write to the Free Software
19 Foundation, Inc., 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA. */
32 #include <sys/types.h>
34 #include "gdb_assert.h"
35 #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 /* Only allow COM ports. */
57 if (strncmp (name
, "COM", 3) != 0)
63 h
= CreateFile (name
, GENERIC_READ
| GENERIC_WRITE
, 0, NULL
,
64 OPEN_EXISTING
, FILE_FLAG_OVERLAPPED
, NULL
);
65 if (h
== INVALID_HANDLE_VALUE
)
71 scb
->fd
= _open_osfhandle ((long) h
, O_RDWR
);
78 if (!SetCommMask (h
, EV_RXCHAR
))
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
))
95 state
= xmalloc (sizeof (struct ser_windows_state
));
96 memset (state
, 0, sizeof (struct ser_windows_state
));
99 /* Create a manual reset event to watch the input buffer. */
100 state
->ov
.hEvent
= CreateEvent (0, TRUE
, FALSE
, 0);
102 /* Create a (currently unused) handle to record exceptions. */
103 state
->except_event
= CreateEvent (0, TRUE
, FALSE
, 0);
108 /* Wait for the output to drain away, as opposed to flushing (discarding)
112 ser_windows_drain_output (struct serial
*scb
)
114 HANDLE h
= (HANDLE
) _get_osfhandle (scb
->fd
);
116 return (FlushFileBuffers (h
) != 0) ? 0 : -1;
120 ser_windows_flush_output (struct serial
*scb
)
122 HANDLE h
= (HANDLE
) _get_osfhandle (scb
->fd
);
124 return (PurgeComm (h
, PURGE_TXCLEAR
) != 0) ? 0 : -1;
128 ser_windows_flush_input (struct serial
*scb
)
130 HANDLE h
= (HANDLE
) _get_osfhandle (scb
->fd
);
132 return (PurgeComm (h
, PURGE_RXCLEAR
) != 0) ? 0 : -1;
136 ser_windows_send_break (struct serial
*scb
)
138 HANDLE h
= (HANDLE
) _get_osfhandle (scb
->fd
);
140 if (SetCommBreak (h
) == 0)
143 /* Delay for 250 milliseconds. */
146 if (ClearCommBreak (h
))
153 ser_windows_raw (struct serial
*scb
)
155 HANDLE h
= (HANDLE
) _get_osfhandle (scb
->fd
);
158 if (GetCommState (h
, &state
) == 0)
161 state
.fParity
= FALSE
;
162 state
.fOutxCtsFlow
= FALSE
;
163 state
.fOutxDsrFlow
= FALSE
;
164 state
.fDtrControl
= DTR_CONTROL_ENABLE
;
165 state
.fDsrSensitivity
= FALSE
;
169 state
.fAbortOnError
= FALSE
;
171 state
.Parity
= NOPARITY
;
173 scb
->current_timeout
= 0;
175 if (SetCommState (h
, &state
) == 0)
176 warning (_("SetCommState failed\n"));
180 ser_windows_setstopbits (struct serial
*scb
, int num
)
182 HANDLE h
= (HANDLE
) _get_osfhandle (scb
->fd
);
185 if (GetCommState (h
, &state
) == 0)
190 case SERIAL_1_STOPBITS
:
191 state
.StopBits
= ONESTOPBIT
;
193 case SERIAL_1_AND_A_HALF_STOPBITS
:
194 state
.StopBits
= ONE5STOPBITS
;
196 case SERIAL_2_STOPBITS
:
197 state
.StopBits
= TWOSTOPBITS
;
203 return (SetCommState (h
, &state
) != 0) ? 0 : -1;
207 ser_windows_setbaudrate (struct serial
*scb
, int rate
)
209 HANDLE h
= (HANDLE
) _get_osfhandle (scb
->fd
);
212 if (GetCommState (h
, &state
) == 0)
215 state
.BaudRate
= rate
;
217 return (SetCommState (h
, &state
) != 0) ? 0 : -1;
221 ser_windows_close (struct serial
*scb
)
223 struct ser_windows_state
*state
;
225 /* Stop any pending selects. */
226 CancelIo ((HANDLE
) _get_osfhandle (scb
->fd
));
228 CloseHandle (state
->ov
.hEvent
);
229 CloseHandle (state
->except_event
);
241 ser_windows_wait_handle (struct serial
*scb
, HANDLE
*read
, HANDLE
*except
)
243 struct ser_windows_state
*state
;
246 HANDLE h
= (HANDLE
) _get_osfhandle (scb
->fd
);
250 *except
= state
->except_event
;
251 *read
= state
->ov
.hEvent
;
253 if (state
->in_progress
)
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. */
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"));
267 if (!SetCommMask (h
, EV_RXCHAR
))
268 warning (_("ser_windows_wait_handle: reseting mask failed (2)"));
270 /* There's a potential race condition here; we must check cbInQue
271 and not wait if that's nonzero. */
273 ClearCommError (h
, &errors
, &status
);
274 if (status
.cbInQue
> 0)
276 SetEvent (state
->ov
.hEvent
);
280 state
->in_progress
= 1;
281 ResetEvent (state
->ov
.hEvent
);
282 state
->lastCommMask
= -2;
283 if (WaitCommEvent (h
, &state
->lastCommMask
, &state
->ov
))
285 gdb_assert (state
->lastCommMask
& EV_RXCHAR
);
286 SetEvent (state
->ov
.hEvent
);
289 gdb_assert (GetLastError () == ERROR_IO_PENDING
);
293 ser_windows_read_prim (struct serial
*scb
, size_t count
)
295 struct ser_windows_state
*state
;
297 DWORD bytes_read
, bytes_read_tmp
;
302 if (state
->in_progress
)
304 WaitForSingleObject (state
->ov
.hEvent
, INFINITE
);
305 state
->in_progress
= 0;
306 ResetEvent (state
->ov
.hEvent
);
309 memset (&ov
, 0, sizeof (OVERLAPPED
));
310 ov
.hEvent
= CreateEvent (0, FALSE
, FALSE
, 0);
311 h
= (HANDLE
) _get_osfhandle (scb
->fd
);
313 if (!ReadFile (h
, scb
->buf
, /* count */ 1, &bytes_read
, &ov
))
315 if (GetLastError () != ERROR_IO_PENDING
316 || !GetOverlappedResult (h
, &ov
, &bytes_read
, TRUE
))
320 CloseHandle (ov
.hEvent
);
325 ser_windows_write_prim (struct serial
*scb
, const void *buf
, size_t len
)
327 struct ser_windows_state
*state
;
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
))
337 if (GetLastError () != ERROR_IO_PENDING
338 || !GetOverlappedResult (h
, &ov
, &bytes_written
, TRUE
))
342 CloseHandle (ov
.hEvent
);
343 return bytes_written
;
346 struct ser_console_state
360 console_select_thread (void *arg
)
362 struct serial
*scb
= arg
;
363 struct ser_console_state
*state
;
368 h
= (HANDLE
) _get_osfhandle (scb
->fd
);
372 HANDLE wait_events
[2];
376 SetEvent (state
->have_stopped
);
378 wait_events
[0] = state
->start_select
;
379 wait_events
[1] = state
->exit_select
;
381 if (WaitForMultipleObjects (2, wait_events
, FALSE
, INFINITE
) != WAIT_OBJECT_0
)
384 ResetEvent (state
->have_stopped
);
387 wait_events
[0] = state
->stop_select
;
390 event_index
= WaitForMultipleObjects (2, wait_events
, FALSE
, INFINITE
);
392 if (event_index
== WAIT_OBJECT_0
393 || WaitForSingleObject (state
->stop_select
, 0) == WAIT_OBJECT_0
)
396 if (event_index
!= WAIT_OBJECT_0
+ 1)
398 /* Wait must have failed; assume an error has occured, e.g.
399 the handle has been closed. */
400 SetEvent (state
->except_event
);
404 /* We've got a pending event on the console. See if it's
406 if (!PeekConsoleInput (h
, &record
, 1, &n_records
) || n_records
!= 1)
408 /* Something went wrong. Maybe the console is gone. */
409 SetEvent (state
->except_event
);
413 if (record
.EventType
== KEY_EVENT
&& record
.Event
.KeyEvent
.bKeyDown
)
415 WORD keycode
= record
.Event
.KeyEvent
.wVirtualKeyCode
;
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. */
423 if (record
.Event
.KeyEvent
.uChar
.AsciiChar
!= 0
424 || keycode
== VK_PRIOR
425 || keycode
== VK_NEXT
427 || keycode
== VK_HOME
428 || keycode
== VK_LEFT
430 || keycode
== VK_RIGHT
431 || keycode
== VK_DOWN
432 || keycode
== VK_INSERT
433 || keycode
== VK_DELETE
)
435 /* This is really a keypress. */
436 SetEvent (state
->read_event
);
441 /* Otherwise discard it and wait again. */
442 ReadConsoleInput (h
, &record
, 1, &n_records
);
450 if (PeekNamedPipe ((HANDLE
) _get_osfhandle (fd
), NULL
, 0, NULL
, NULL
, NULL
))
457 pipe_select_thread (void *arg
)
459 struct serial
*scb
= arg
;
460 struct ser_console_state
*state
;
465 h
= (HANDLE
) _get_osfhandle (scb
->fd
);
469 HANDLE wait_events
[2];
472 SetEvent (state
->have_stopped
);
474 wait_events
[0] = state
->start_select
;
475 wait_events
[1] = state
->exit_select
;
477 if (WaitForMultipleObjects (2, wait_events
, FALSE
, INFINITE
) != WAIT_OBJECT_0
)
480 ResetEvent (state
->have_stopped
);
483 if (!PeekNamedPipe (h
, NULL
, 0, NULL
, &n_avail
, NULL
))
485 SetEvent (state
->except_event
);
491 SetEvent (state
->read_event
);
495 /* Delay 10ms before checking again, but allow the stop event
497 if (WaitForSingleObject (state
->stop_select
, 10) == WAIT_OBJECT_0
)
505 ser_console_wait_handle (struct serial
*scb
, HANDLE
*read
, HANDLE
*except
)
507 struct ser_console_state
*state
= scb
->state
;
514 is_tty
= isatty (scb
->fd
);
515 if (!is_tty
&& !fd_is_pipe (scb
->fd
))
522 state
= xmalloc (sizeof (struct ser_console_state
));
523 memset (state
, 0, sizeof (struct ser_console_state
));
526 /* Create auto reset events to wake, stop, and exit the select
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);
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);
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);
542 state
->thread
= CreateThread (NULL
, 0, console_select_thread
, scb
, 0,
545 state
->thread
= CreateThread (NULL
, 0, pipe_select_thread
, scb
, 0,
549 *read
= state
->read_event
;
550 *except
= state
->except_event
;
552 /* Start from a blank state. */
553 ResetEvent (state
->read_event
);
554 ResetEvent (state
->except_event
);
555 ResetEvent (state
->stop_select
);
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. */
564 SetEvent (state
->read_event
);
568 /* Otherwise, start the select thread. */
569 SetEvent (state
->start_select
);
573 ser_console_done_wait_handle (struct serial
*scb
)
575 struct ser_console_state
*state
= scb
->state
;
580 SetEvent (state
->stop_select
);
581 WaitForSingleObject (state
->have_stopped
, INFINITE
);
585 ser_console_close (struct serial
*scb
)
587 struct ser_console_state
*state
= scb
->state
;
591 SetEvent (state
->exit_select
);
593 WaitForSingleObject (state
->thread
, INFINITE
);
595 CloseHandle (state
->start_select
);
596 CloseHandle (state
->stop_select
);
597 CloseHandle (state
->exit_select
);
598 CloseHandle (state
->have_stopped
);
600 CloseHandle (state
->read_event
);
601 CloseHandle (state
->except_event
);
607 struct ser_console_ttystate
612 static serial_ttystate
613 ser_console_get_tty_state (struct serial
*scb
)
615 if (isatty (scb
->fd
))
617 struct ser_console_ttystate
*state
;
618 state
= (struct ser_console_ttystate
*) xmalloc (sizeof *state
);
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
631 struct ser_console_state wait
;
633 /* The pex obj for our (one-stage) pipeline. */
636 /* Streams for the pipeline's input and output. */
637 FILE *input
, *output
;
640 static struct pipe_state
*
641 make_pipe_state (void)
643 struct pipe_state
*ps
= XMALLOC (struct pipe_state
);
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
;
655 free_pipe_state (struct pipe_state
*ps
)
657 int saved_errno
= errno
;
659 if (ps
->wait
.read_event
!= INVALID_HANDLE_VALUE
)
661 SetEvent (ps
->wait
.exit_select
);
663 WaitForSingleObject (ps
->wait
.thread
, INFINITE
);
665 CloseHandle (ps
->wait
.start_select
);
666 CloseHandle (ps
->wait
.stop_select
);
667 CloseHandle (ps
->wait
.exit_select
);
668 CloseHandle (ps
->wait
.have_stopped
);
670 CloseHandle (ps
->wait
.read_event
);
671 CloseHandle (ps
->wait
.except_event
);
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. */
681 /* pex_free closes ps->output. */
689 cleanup_pipe_state (void *untyped
)
691 struct pipe_state
*ps
= untyped
;
693 free_pipe_state (ps
);
697 pipe_windows_open (struct serial
*scb
, const char *name
)
699 struct pipe_state
*ps
;
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");
707 ps
= make_pipe_state ();
708 make_cleanup (cleanup_pipe_state
, ps
);
710 ps
->pex
= pex_init (PEX_USE_PIPES
, "target remote pipe", NULL
);
713 ps
->input
= pex_input_pipe (ps
->pex
, 1);
720 = pex_run (ps
->pex
, PEX_SEARCH
| PEX_BINARY_INPUT
| PEX_BINARY_OUTPUT
,
721 argv
[0], argv
, NULL
, NULL
,
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. */
731 error ("error starting child process '%s': %s: %s",
732 name
, err_msg
, safe_strerror (err
));
734 error ("error starting child process '%s': %s",
739 ps
->output
= pex_read_output (ps
->pex
, 1);
743 scb
->fd
= fileno (ps
->output
);
744 scb
->state
= (void *) ps
;
746 discard_cleanups (back_to
);
750 do_cleanups (back_to
);
756 pipe_windows_close (struct serial
*scb
)
758 struct pipe_state
*ps
= scb
->state
;
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. */
764 free_pipe_state (ps
);
769 pipe_windows_read (struct serial
*scb
, size_t count
)
775 pipeline_out
= (HANDLE
) _get_osfhandle (scb
->fd
);
776 if (pipeline_out
== INVALID_HANDLE_VALUE
)
779 if (! PeekNamedPipe (pipeline_out
, NULL
, 0, NULL
, &available
, NULL
))
782 if (count
> available
)
785 if (! ReadFile (pipeline_out
, scb
->buf
, count
, &bytes_read
, NULL
))
793 pipe_windows_write (struct serial
*scb
, const void *buf
, size_t count
)
795 struct pipe_state
*ps
= scb
->state
;
799 int pipeline_in_fd
= fileno (ps
->input
);
800 if (pipeline_in_fd
< 0)
803 pipeline_in
= (HANDLE
) _get_osfhandle (pipeline_in_fd
);
804 if (pipeline_in
== INVALID_HANDLE_VALUE
)
807 if (! WriteFile (pipeline_in
, buf
, count
, &written
, NULL
))
815 pipe_wait_handle (struct serial
*scb
, HANDLE
*read
, HANDLE
*except
)
817 struct pipe_state
*ps
= scb
->state
;
819 /* Have we allocated our events yet? */
820 if (ps
->wait
.read_event
== INVALID_HANDLE_VALUE
)
824 /* Create auto reset events to wake, stop, and exit the select
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);
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);
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);
840 /* Start the select thread. */
841 CreateThread (NULL
, 0, pipe_select_thread
, scb
, 0, &threadId
);
844 *read
= ps
->wait
.read_event
;
845 *except
= ps
->wait
.except_event
;
847 /* Start from a blank state. */
848 ResetEvent (ps
->wait
.read_event
);
849 ResetEvent (ps
->wait
.except_event
);
850 ResetEvent (ps
->wait
.stop_select
);
852 /* Start the select thread. */
853 SetEvent (ps
->wait
.start_select
);
857 pipe_done_wait_handle (struct serial
*scb
)
859 struct pipe_state
*ps
= scb
->state
;
861 /* Have we allocated our events yet? */
862 if (ps
->wait
.read_event
== INVALID_HANDLE_VALUE
)
865 SetEvent (ps
->wait
.stop_select
);
866 WaitForSingleObject (ps
->wait
.have_stopped
, INFINITE
);
869 struct net_windows_state
885 net_windows_select_thread (void *arg
)
887 struct serial
*scb
= arg
;
888 struct net_windows_state
*state
, state_copy
;
895 HANDLE wait_events
[2];
896 WSANETWORKEVENTS events
;
898 SetEvent (state
->have_stopped
);
900 wait_events
[0] = state
->start_select
;
901 wait_events
[1] = state
->exit_select
;
903 if (WaitForMultipleObjects (2, wait_events
, FALSE
, INFINITE
) != WAIT_OBJECT_0
)
906 ResetEvent (state
->have_stopped
);
908 wait_events
[0] = state
->stop_select
;
909 wait_events
[1] = state
->sock_event
;
911 event_index
= WaitForMultipleObjects (2, wait_events
, FALSE
, INFINITE
);
913 if (event_index
== WAIT_OBJECT_0
914 || WaitForSingleObject (state
->stop_select
, 0) == WAIT_OBJECT_0
)
917 if (event_index
!= WAIT_OBJECT_0
+ 1)
919 /* Some error has occured. Assume that this is an error
921 SetEvent (state
->except_event
);
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
);
929 gdb_assert (events
.lNetworkEvents
& (FD_READ
| FD_CLOSE
));
931 if (events
.lNetworkEvents
& FD_READ
)
932 SetEvent (state
->read_event
);
934 if (events
.lNetworkEvents
& FD_CLOSE
)
935 SetEvent (state
->except_event
);
940 net_windows_wait_handle (struct serial
*scb
, HANDLE
*read
, HANDLE
*except
)
942 struct net_windows_state
*state
= scb
->state
;
944 /* Start from a clean slate. */
945 ResetEvent (state
->read_event
);
946 ResetEvent (state
->except_event
);
947 ResetEvent (state
->stop_select
);
949 *read
= state
->read_event
;
950 *except
= state
->except_event
;
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
)
956 WSANETWORKEVENTS events
;
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
);
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. */
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
)
977 unsigned long available
;
979 if (ioctlsocket (scb
->fd
, FIONREAD
, &available
) == 0
982 SetEvent (state
->read_event
);
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);
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
)
996 SetEvent (state
->except_event
);
1000 /* If we set either handle, there's no need to wake the thread. */
1005 /* Start the select thread. */
1006 SetEvent (state
->start_select
);
1010 net_windows_done_wait_handle (struct serial
*scb
)
1012 struct net_windows_state
*state
= scb
->state
;
1014 SetEvent (state
->stop_select
);
1015 WaitForSingleObject (state
->have_stopped
, INFINITE
);
1019 net_windows_open (struct serial
*scb
, const char *name
)
1021 struct net_windows_state
*state
;
1025 ret
= net_open (scb
, name
);
1029 state
= xmalloc (sizeof (struct net_windows_state
));
1030 memset (state
, 0, sizeof (struct net_windows_state
));
1033 /* Create auto reset events to wake, stop, and exit the select
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);
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);
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
);
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);
1052 /* And finally start the select thread. */
1053 state
->thread
= CreateThread (NULL
, 0, net_windows_select_thread
, scb
, 0,
1061 net_windows_close (struct serial
*scb
)
1063 struct net_windows_state
*state
= scb
->state
;
1065 SetEvent (state
->exit_select
);
1066 WaitForSingleObject (state
->thread
, INFINITE
);
1068 CloseHandle (state
->read_event
);
1069 CloseHandle (state
->except_event
);
1071 CloseHandle (state
->start_select
);
1072 CloseHandle (state
->stop_select
);
1073 CloseHandle (state
->exit_select
);
1074 CloseHandle (state
->have_stopped
);
1076 CloseHandle (state
->sock_event
);
1084 _initialize_ser_windows (void)
1087 struct serial_ops
*ops
;
1089 /* First register the serial port driver. */
1091 ops
= XMALLOC (struct serial_ops
);
1092 memset (ops
, 0, sizeof (struct serial_ops
));
1093 ops
->name
= "hardwire";
1095 ops
->open
= ser_windows_open
;
1096 ops
->close
= ser_windows_close
;
1098 ops
->flush_output
= ser_windows_flush_output
;
1099 ops
->flush_input
= ser_windows_flush_input
;
1100 ops
->send_break
= ser_windows_send_break
;
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
;
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
;
1120 serial_add_interface (ops
);
1122 /* Next create the dummy serial driver used for terminals. We only
1123 provide the TTY-related methods. */
1125 ops
= XMALLOC (struct serial_ops
);
1126 memset (ops
, 0, sizeof (struct serial_ops
));
1128 ops
->name
= "terminal";
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
;
1140 serial_add_interface (ops
);
1142 /* The pipe interface. */
1144 ops
= XMALLOC (struct serial_ops
);
1145 memset (ops
, 0, sizeof (struct serial_ops
));
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
;
1169 serial_add_interface (ops
);
1171 /* If WinSock works, register the TCP/UDP socket driver. */
1173 if (WSAStartup (MAKEWORD (1, 0), &wsa_data
) != 0)
1174 /* WinSock is unavailable. */
1177 ops
= XMALLOC (struct serial_ops
);
1178 memset (ops
, 0, sizeof (struct serial_ops
));
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
);