/* Serial interface for local (hardwired) serial ports on Windows systems
|
/* Serial interface for local (hardwired) serial ports on Windows systems
|
|
|
Copyright (C) 2006, 2007, 2008 Free Software Foundation, Inc.
|
Copyright (C) 2006, 2007, 2008 Free Software Foundation, Inc.
|
|
|
This file is part of GDB.
|
This file is part of GDB.
|
|
|
This program is free software; you can redistribute it and/or modify
|
This program is free software; you can redistribute it and/or modify
|
it under the terms of the GNU General Public License as published by
|
it under the terms of the GNU General Public License as published by
|
the Free Software Foundation; either version 3 of the License, or
|
the Free Software Foundation; either version 3 of the License, or
|
(at your option) any later version.
|
(at your option) any later version.
|
|
|
This program is distributed in the hope that it will be useful,
|
This program is distributed in the hope that it will be useful,
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
GNU General Public License for more details.
|
GNU General Public License for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
|
|
#include "defs.h"
|
#include "defs.h"
|
#include "serial.h"
|
#include "serial.h"
|
#include "ser-base.h"
|
#include "ser-base.h"
|
#include "ser-tcp.h"
|
#include "ser-tcp.h"
|
|
|
#include <windows.h>
|
#include <windows.h>
|
#include <conio.h>
|
#include <conio.h>
|
|
|
#include <fcntl.h>
|
#include <fcntl.h>
|
#include <unistd.h>
|
#include <unistd.h>
|
#include <sys/types.h>
|
#include <sys/types.h>
|
|
|
#include "gdb_assert.h"
|
#include "gdb_assert.h"
|
#include "gdb_string.h"
|
#include "gdb_string.h"
|
|
|
void _initialize_ser_windows (void);
|
void _initialize_ser_windows (void);
|
|
|
struct ser_windows_state
|
struct ser_windows_state
|
{
|
{
|
int in_progress;
|
int in_progress;
|
OVERLAPPED ov;
|
OVERLAPPED ov;
|
DWORD lastCommMask;
|
DWORD lastCommMask;
|
HANDLE except_event;
|
HANDLE except_event;
|
};
|
};
|
|
|
/* Open up a real live device for serial I/O. */
|
/* Open up a real live device for serial I/O. */
|
|
|
static int
|
static int
|
ser_windows_open (struct serial *scb, const char *name)
|
ser_windows_open (struct serial *scb, const char *name)
|
{
|
{
|
HANDLE h;
|
HANDLE h;
|
struct ser_windows_state *state;
|
struct ser_windows_state *state;
|
COMMTIMEOUTS timeouts;
|
COMMTIMEOUTS timeouts;
|
|
|
/* Only allow COM ports. */
|
/* Only allow COM ports. */
|
if (strncmp (name, "COM", 3) != 0)
|
if (strncmp (name, "COM", 3) != 0)
|
{
|
{
|
errno = ENOENT;
|
errno = ENOENT;
|
return -1;
|
return -1;
|
}
|
}
|
|
|
h = CreateFile (name, GENERIC_READ | GENERIC_WRITE, 0, NULL,
|
h = CreateFile (name, GENERIC_READ | GENERIC_WRITE, 0, NULL,
|
OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);
|
OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);
|
if (h == INVALID_HANDLE_VALUE)
|
if (h == INVALID_HANDLE_VALUE)
|
{
|
{
|
errno = ENOENT;
|
errno = ENOENT;
|
return -1;
|
return -1;
|
}
|
}
|
|
|
scb->fd = _open_osfhandle ((long) h, O_RDWR);
|
scb->fd = _open_osfhandle ((long) h, O_RDWR);
|
if (scb->fd < 0)
|
if (scb->fd < 0)
|
{
|
{
|
errno = ENOENT;
|
errno = ENOENT;
|
return -1;
|
return -1;
|
}
|
}
|
|
|
if (!SetCommMask (h, EV_RXCHAR))
|
if (!SetCommMask (h, EV_RXCHAR))
|
{
|
{
|
errno = EINVAL;
|
errno = EINVAL;
|
return -1;
|
return -1;
|
}
|
}
|
|
|
timeouts.ReadIntervalTimeout = MAXDWORD;
|
timeouts.ReadIntervalTimeout = MAXDWORD;
|
timeouts.ReadTotalTimeoutConstant = 0;
|
timeouts.ReadTotalTimeoutConstant = 0;
|
timeouts.ReadTotalTimeoutMultiplier = 0;
|
timeouts.ReadTotalTimeoutMultiplier = 0;
|
timeouts.WriteTotalTimeoutConstant = 0;
|
timeouts.WriteTotalTimeoutConstant = 0;
|
timeouts.WriteTotalTimeoutMultiplier = 0;
|
timeouts.WriteTotalTimeoutMultiplier = 0;
|
if (!SetCommTimeouts (h, &timeouts))
|
if (!SetCommTimeouts (h, &timeouts))
|
{
|
{
|
errno = EINVAL;
|
errno = EINVAL;
|
return -1;
|
return -1;
|
}
|
}
|
|
|
state = xmalloc (sizeof (struct ser_windows_state));
|
state = xmalloc (sizeof (struct ser_windows_state));
|
memset (state, 0, sizeof (struct ser_windows_state));
|
memset (state, 0, sizeof (struct ser_windows_state));
|
scb->state = state;
|
scb->state = state;
|
|
|
/* Create a manual reset event to watch the input buffer. */
|
/* Create a manual reset event to watch the input buffer. */
|
state->ov.hEvent = CreateEvent (0, TRUE, FALSE, 0);
|
state->ov.hEvent = CreateEvent (0, TRUE, FALSE, 0);
|
|
|
/* Create a (currently unused) handle to record exceptions. */
|
/* Create a (currently unused) handle to record exceptions. */
|
state->except_event = CreateEvent (0, TRUE, FALSE, 0);
|
state->except_event = CreateEvent (0, TRUE, FALSE, 0);
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Wait for the output to drain away, as opposed to flushing (discarding)
|
/* Wait for the output to drain away, as opposed to flushing (discarding)
|
it. */
|
it. */
|
|
|
static int
|
static int
|
ser_windows_drain_output (struct serial *scb)
|
ser_windows_drain_output (struct serial *scb)
|
{
|
{
|
HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
|
HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
|
|
|
return (FlushFileBuffers (h) != 0) ? 0 : -1;
|
return (FlushFileBuffers (h) != 0) ? 0 : -1;
|
}
|
}
|
|
|
static int
|
static int
|
ser_windows_flush_output (struct serial *scb)
|
ser_windows_flush_output (struct serial *scb)
|
{
|
{
|
HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
|
HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
|
|
|
return (PurgeComm (h, PURGE_TXCLEAR) != 0) ? 0 : -1;
|
return (PurgeComm (h, PURGE_TXCLEAR) != 0) ? 0 : -1;
|
}
|
}
|
|
|
static int
|
static int
|
ser_windows_flush_input (struct serial *scb)
|
ser_windows_flush_input (struct serial *scb)
|
{
|
{
|
HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
|
HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
|
|
|
return (PurgeComm (h, PURGE_RXCLEAR) != 0) ? 0 : -1;
|
return (PurgeComm (h, PURGE_RXCLEAR) != 0) ? 0 : -1;
|
}
|
}
|
|
|
static int
|
static int
|
ser_windows_send_break (struct serial *scb)
|
ser_windows_send_break (struct serial *scb)
|
{
|
{
|
HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
|
HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
|
|
|
if (SetCommBreak (h) == 0)
|
if (SetCommBreak (h) == 0)
|
return -1;
|
return -1;
|
|
|
/* Delay for 250 milliseconds. */
|
/* Delay for 250 milliseconds. */
|
Sleep (250);
|
Sleep (250);
|
|
|
if (ClearCommBreak (h))
|
if (ClearCommBreak (h))
|
return -1;
|
return -1;
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
static void
|
static void
|
ser_windows_raw (struct serial *scb)
|
ser_windows_raw (struct serial *scb)
|
{
|
{
|
HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
|
HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
|
DCB state;
|
DCB state;
|
|
|
if (GetCommState (h, &state) == 0)
|
if (GetCommState (h, &state) == 0)
|
return;
|
return;
|
|
|
state.fParity = FALSE;
|
state.fParity = FALSE;
|
state.fOutxCtsFlow = FALSE;
|
state.fOutxCtsFlow = FALSE;
|
state.fOutxDsrFlow = FALSE;
|
state.fOutxDsrFlow = FALSE;
|
state.fDtrControl = DTR_CONTROL_ENABLE;
|
state.fDtrControl = DTR_CONTROL_ENABLE;
|
state.fDsrSensitivity = FALSE;
|
state.fDsrSensitivity = FALSE;
|
state.fOutX = FALSE;
|
state.fOutX = FALSE;
|
state.fInX = FALSE;
|
state.fInX = FALSE;
|
state.fNull = FALSE;
|
state.fNull = FALSE;
|
state.fAbortOnError = FALSE;
|
state.fAbortOnError = FALSE;
|
state.ByteSize = 8;
|
state.ByteSize = 8;
|
state.Parity = NOPARITY;
|
state.Parity = NOPARITY;
|
|
|
scb->current_timeout = 0;
|
scb->current_timeout = 0;
|
|
|
if (SetCommState (h, &state) == 0)
|
if (SetCommState (h, &state) == 0)
|
warning (_("SetCommState failed\n"));
|
warning (_("SetCommState failed\n"));
|
}
|
}
|
|
|
static int
|
static int
|
ser_windows_setstopbits (struct serial *scb, int num)
|
ser_windows_setstopbits (struct serial *scb, int num)
|
{
|
{
|
HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
|
HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
|
DCB state;
|
DCB state;
|
|
|
if (GetCommState (h, &state) == 0)
|
if (GetCommState (h, &state) == 0)
|
return -1;
|
return -1;
|
|
|
switch (num)
|
switch (num)
|
{
|
{
|
case SERIAL_1_STOPBITS:
|
case SERIAL_1_STOPBITS:
|
state.StopBits = ONESTOPBIT;
|
state.StopBits = ONESTOPBIT;
|
break;
|
break;
|
case SERIAL_1_AND_A_HALF_STOPBITS:
|
case SERIAL_1_AND_A_HALF_STOPBITS:
|
state.StopBits = ONE5STOPBITS;
|
state.StopBits = ONE5STOPBITS;
|
break;
|
break;
|
case SERIAL_2_STOPBITS:
|
case SERIAL_2_STOPBITS:
|
state.StopBits = TWOSTOPBITS;
|
state.StopBits = TWOSTOPBITS;
|
break;
|
break;
|
default:
|
default:
|
return 1;
|
return 1;
|
}
|
}
|
|
|
return (SetCommState (h, &state) != 0) ? 0 : -1;
|
return (SetCommState (h, &state) != 0) ? 0 : -1;
|
}
|
}
|
|
|
static int
|
static int
|
ser_windows_setbaudrate (struct serial *scb, int rate)
|
ser_windows_setbaudrate (struct serial *scb, int rate)
|
{
|
{
|
HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
|
HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
|
DCB state;
|
DCB state;
|
|
|
if (GetCommState (h, &state) == 0)
|
if (GetCommState (h, &state) == 0)
|
return -1;
|
return -1;
|
|
|
state.BaudRate = rate;
|
state.BaudRate = rate;
|
|
|
return (SetCommState (h, &state) != 0) ? 0 : -1;
|
return (SetCommState (h, &state) != 0) ? 0 : -1;
|
}
|
}
|
|
|
static void
|
static void
|
ser_windows_close (struct serial *scb)
|
ser_windows_close (struct serial *scb)
|
{
|
{
|
struct ser_windows_state *state;
|
struct ser_windows_state *state;
|
|
|
/* Stop any pending selects. */
|
/* Stop any pending selects. */
|
CancelIo ((HANDLE) _get_osfhandle (scb->fd));
|
CancelIo ((HANDLE) _get_osfhandle (scb->fd));
|
state = scb->state;
|
state = scb->state;
|
CloseHandle (state->ov.hEvent);
|
CloseHandle (state->ov.hEvent);
|
CloseHandle (state->except_event);
|
CloseHandle (state->except_event);
|
|
|
if (scb->fd < 0)
|
if (scb->fd < 0)
|
return;
|
return;
|
|
|
close (scb->fd);
|
close (scb->fd);
|
scb->fd = -1;
|
scb->fd = -1;
|
|
|
xfree (scb->state);
|
xfree (scb->state);
|
}
|
}
|
|
|
static void
|
static void
|
ser_windows_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except)
|
ser_windows_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except)
|
{
|
{
|
struct ser_windows_state *state;
|
struct ser_windows_state *state;
|
COMSTAT status;
|
COMSTAT status;
|
DWORD errors;
|
DWORD errors;
|
HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
|
HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
|
|
|
state = scb->state;
|
state = scb->state;
|
|
|
*except = state->except_event;
|
*except = state->except_event;
|
*read = state->ov.hEvent;
|
*read = state->ov.hEvent;
|
|
|
if (state->in_progress)
|
if (state->in_progress)
|
return;
|
return;
|
|
|
/* Reset the mask - we are only interested in any characters which
|
/* Reset the mask - we are only interested in any characters which
|
arrive after this point, not characters which might have arrived
|
arrive after this point, not characters which might have arrived
|
and already been read. */
|
and already been read. */
|
|
|
/* This really, really shouldn't be necessary - just the second one.
|
/* This really, really shouldn't be necessary - just the second one.
|
But otherwise an internal flag for EV_RXCHAR does not get
|
But otherwise an internal flag for EV_RXCHAR does not get
|
cleared, and we get a duplicated event, if the last batch
|
cleared, and we get a duplicated event, if the last batch
|
of characters included at least two arriving close together. */
|
of characters included at least two arriving close together. */
|
if (!SetCommMask (h, 0))
|
if (!SetCommMask (h, 0))
|
warning (_("ser_windows_wait_handle: reseting mask failed"));
|
warning (_("ser_windows_wait_handle: reseting mask failed"));
|
|
|
if (!SetCommMask (h, EV_RXCHAR))
|
if (!SetCommMask (h, EV_RXCHAR))
|
warning (_("ser_windows_wait_handle: reseting mask failed (2)"));
|
warning (_("ser_windows_wait_handle: reseting mask failed (2)"));
|
|
|
/* There's a potential race condition here; we must check cbInQue
|
/* There's a potential race condition here; we must check cbInQue
|
and not wait if that's nonzero. */
|
and not wait if that's nonzero. */
|
|
|
ClearCommError (h, &errors, &status);
|
ClearCommError (h, &errors, &status);
|
if (status.cbInQue > 0)
|
if (status.cbInQue > 0)
|
{
|
{
|
SetEvent (state->ov.hEvent);
|
SetEvent (state->ov.hEvent);
|
return;
|
return;
|
}
|
}
|
|
|
state->in_progress = 1;
|
state->in_progress = 1;
|
ResetEvent (state->ov.hEvent);
|
ResetEvent (state->ov.hEvent);
|
state->lastCommMask = -2;
|
state->lastCommMask = -2;
|
if (WaitCommEvent (h, &state->lastCommMask, &state->ov))
|
if (WaitCommEvent (h, &state->lastCommMask, &state->ov))
|
{
|
{
|
gdb_assert (state->lastCommMask & EV_RXCHAR);
|
gdb_assert (state->lastCommMask & EV_RXCHAR);
|
SetEvent (state->ov.hEvent);
|
SetEvent (state->ov.hEvent);
|
}
|
}
|
else
|
else
|
gdb_assert (GetLastError () == ERROR_IO_PENDING);
|
gdb_assert (GetLastError () == ERROR_IO_PENDING);
|
}
|
}
|
|
|
static int
|
static int
|
ser_windows_read_prim (struct serial *scb, size_t count)
|
ser_windows_read_prim (struct serial *scb, size_t count)
|
{
|
{
|
struct ser_windows_state *state;
|
struct ser_windows_state *state;
|
OVERLAPPED ov;
|
OVERLAPPED ov;
|
DWORD bytes_read, bytes_read_tmp;
|
DWORD bytes_read, bytes_read_tmp;
|
HANDLE h;
|
HANDLE h;
|
gdb_byte *p;
|
gdb_byte *p;
|
|
|
state = scb->state;
|
state = scb->state;
|
if (state->in_progress)
|
if (state->in_progress)
|
{
|
{
|
WaitForSingleObject (state->ov.hEvent, INFINITE);
|
WaitForSingleObject (state->ov.hEvent, INFINITE);
|
state->in_progress = 0;
|
state->in_progress = 0;
|
ResetEvent (state->ov.hEvent);
|
ResetEvent (state->ov.hEvent);
|
}
|
}
|
|
|
memset (&ov, 0, sizeof (OVERLAPPED));
|
memset (&ov, 0, sizeof (OVERLAPPED));
|
ov.hEvent = CreateEvent (0, FALSE, FALSE, 0);
|
ov.hEvent = CreateEvent (0, FALSE, FALSE, 0);
|
h = (HANDLE) _get_osfhandle (scb->fd);
|
h = (HANDLE) _get_osfhandle (scb->fd);
|
|
|
if (!ReadFile (h, scb->buf, /* count */ 1, &bytes_read, &ov))
|
if (!ReadFile (h, scb->buf, /* count */ 1, &bytes_read, &ov))
|
{
|
{
|
if (GetLastError () != ERROR_IO_PENDING
|
if (GetLastError () != ERROR_IO_PENDING
|
|| !GetOverlappedResult (h, &ov, &bytes_read, TRUE))
|
|| !GetOverlappedResult (h, &ov, &bytes_read, TRUE))
|
bytes_read = -1;
|
bytes_read = -1;
|
}
|
}
|
|
|
CloseHandle (ov.hEvent);
|
CloseHandle (ov.hEvent);
|
return bytes_read;
|
return bytes_read;
|
}
|
}
|
|
|
static int
|
static int
|
ser_windows_write_prim (struct serial *scb, const void *buf, size_t len)
|
ser_windows_write_prim (struct serial *scb, const void *buf, size_t len)
|
{
|
{
|
struct ser_windows_state *state;
|
struct ser_windows_state *state;
|
OVERLAPPED ov;
|
OVERLAPPED ov;
|
DWORD bytes_written;
|
DWORD bytes_written;
|
HANDLE h;
|
HANDLE h;
|
|
|
memset (&ov, 0, sizeof (OVERLAPPED));
|
memset (&ov, 0, sizeof (OVERLAPPED));
|
ov.hEvent = CreateEvent (0, FALSE, FALSE, 0);
|
ov.hEvent = CreateEvent (0, FALSE, FALSE, 0);
|
h = (HANDLE) _get_osfhandle (scb->fd);
|
h = (HANDLE) _get_osfhandle (scb->fd);
|
if (!WriteFile (h, buf, len, &bytes_written, &ov))
|
if (!WriteFile (h, buf, len, &bytes_written, &ov))
|
{
|
{
|
if (GetLastError () != ERROR_IO_PENDING
|
if (GetLastError () != ERROR_IO_PENDING
|
|| !GetOverlappedResult (h, &ov, &bytes_written, TRUE))
|
|| !GetOverlappedResult (h, &ov, &bytes_written, TRUE))
|
bytes_written = -1;
|
bytes_written = -1;
|
}
|
}
|
|
|
CloseHandle (ov.hEvent);
|
CloseHandle (ov.hEvent);
|
return bytes_written;
|
return bytes_written;
|
}
|
}
|
|
|
/* On Windows, gdb_select is implemented using WaitForMulpleObjects.
|
/* On Windows, gdb_select is implemented using WaitForMulpleObjects.
|
A "select thread" is created for each file descriptor. These
|
A "select thread" is created for each file descriptor. These
|
threads looks for activity on the corresponding descriptor, using
|
threads looks for activity on the corresponding descriptor, using
|
whatever techniques are appropriate for the descriptor type. When
|
whatever techniques are appropriate for the descriptor type. When
|
that activity occurs, the thread signals an appropriate event,
|
that activity occurs, the thread signals an appropriate event,
|
which wakes up WaitForMultipleObjects.
|
which wakes up WaitForMultipleObjects.
|
|
|
Each select thread is in one of two states: stopped or started.
|
Each select thread is in one of two states: stopped or started.
|
Select threads begin in the stopped state. When gdb_select is
|
Select threads begin in the stopped state. When gdb_select is
|
called, threads corresponding to the descriptors of interest are
|
called, threads corresponding to the descriptors of interest are
|
started by calling a wait_handle function. Each thread that
|
started by calling a wait_handle function. Each thread that
|
notices activity signals the appropriate event and then reenters
|
notices activity signals the appropriate event and then reenters
|
the stopped state. Before gdb_select returns it calls the
|
the stopped state. Before gdb_select returns it calls the
|
wait_handle_done functions, which return the threads to the stopped
|
wait_handle_done functions, which return the threads to the stopped
|
state. */
|
state. */
|
|
|
enum select_thread_state {
|
enum select_thread_state {
|
STS_STARTED,
|
STS_STARTED,
|
STS_STOPPED
|
STS_STOPPED
|
};
|
};
|
|
|
struct ser_console_state
|
struct ser_console_state
|
{
|
{
|
/* Signaled by the select thread to indicate that data is available
|
/* Signaled by the select thread to indicate that data is available
|
on the file descriptor. */
|
on the file descriptor. */
|
HANDLE read_event;
|
HANDLE read_event;
|
/* Signaled by the select thread to indicate that an exception has
|
/* Signaled by the select thread to indicate that an exception has
|
occurred on the file descriptor. */
|
occurred on the file descriptor. */
|
HANDLE except_event;
|
HANDLE except_event;
|
/* Signaled by the select thread to indicate that it has entered the
|
/* Signaled by the select thread to indicate that it has entered the
|
started state. HAVE_STARTED and HAVE_STOPPED are never signaled
|
started state. HAVE_STARTED and HAVE_STOPPED are never signaled
|
simultaneously. */
|
simultaneously. */
|
HANDLE have_started;
|
HANDLE have_started;
|
/* Signaled by the select thread to indicate that it has stopped,
|
/* Signaled by the select thread to indicate that it has stopped,
|
either because data is available (and READ_EVENT is signaled),
|
either because data is available (and READ_EVENT is signaled),
|
because an exception has occurred (and EXCEPT_EVENT is signaled),
|
because an exception has occurred (and EXCEPT_EVENT is signaled),
|
or because STOP_SELECT was signaled. */
|
or because STOP_SELECT was signaled. */
|
HANDLE have_stopped;
|
HANDLE have_stopped;
|
|
|
/* Signaled by the main program to tell the select thread to enter
|
/* Signaled by the main program to tell the select thread to enter
|
the started state. */
|
the started state. */
|
HANDLE start_select;
|
HANDLE start_select;
|
/* Signaled by the main program to tell the select thread to enter
|
/* Signaled by the main program to tell the select thread to enter
|
the stopped state. */
|
the stopped state. */
|
HANDLE stop_select;
|
HANDLE stop_select;
|
/* Signaled by the main program to tell the select thread to
|
/* Signaled by the main program to tell the select thread to
|
exit. */
|
exit. */
|
HANDLE exit_select;
|
HANDLE exit_select;
|
|
|
/* The handle for the select thread. */
|
/* The handle for the select thread. */
|
HANDLE thread;
|
HANDLE thread;
|
/* The state of the select thread. This field is only accessed in
|
/* The state of the select thread. This field is only accessed in
|
the main program, never by the select thread itself. */
|
the main program, never by the select thread itself. */
|
enum select_thread_state thread_state;
|
enum select_thread_state thread_state;
|
};
|
};
|
|
|
/* Called by a select thread to enter the stopped state. This
|
/* Called by a select thread to enter the stopped state. This
|
function does not return until the thread has re-entered the
|
function does not return until the thread has re-entered the
|
started state. */
|
started state. */
|
static void
|
static void
|
select_thread_wait (struct ser_console_state *state)
|
select_thread_wait (struct ser_console_state *state)
|
{
|
{
|
HANDLE wait_events[2];
|
HANDLE wait_events[2];
|
|
|
/* There are two things that can wake us up: a request that we enter
|
/* There are two things that can wake us up: a request that we enter
|
the started state, or that we exit this thread. */
|
the started state, or that we exit this thread. */
|
wait_events[0] = state->start_select;
|
wait_events[0] = state->start_select;
|
wait_events[1] = state->exit_select;
|
wait_events[1] = state->exit_select;
|
if (WaitForMultipleObjects (2, wait_events, FALSE, INFINITE)
|
if (WaitForMultipleObjects (2, wait_events, FALSE, INFINITE)
|
!= WAIT_OBJECT_0)
|
!= WAIT_OBJECT_0)
|
/* Either the EXIT_SELECT event was signaled (requesting that the
|
/* Either the EXIT_SELECT event was signaled (requesting that the
|
thread exit) or an error has occurred. In either case, we exit
|
thread exit) or an error has occurred. In either case, we exit
|
the thread. */
|
the thread. */
|
ExitThread (0);
|
ExitThread (0);
|
|
|
/* We are now in the started state. */
|
/* We are now in the started state. */
|
SetEvent (state->have_started);
|
SetEvent (state->have_started);
|
}
|
}
|
|
|
typedef DWORD WINAPI (*thread_fn_type)(void *);
|
typedef DWORD WINAPI (*thread_fn_type)(void *);
|
|
|
/* Create a new select thread for SCB executing THREAD_FN. The STATE
|
/* Create a new select thread for SCB executing THREAD_FN. The STATE
|
will be filled in by this function before return. */
|
will be filled in by this function before return. */
|
void
|
void
|
create_select_thread (thread_fn_type thread_fn,
|
create_select_thread (thread_fn_type thread_fn,
|
struct serial *scb,
|
struct serial *scb,
|
struct ser_console_state *state)
|
struct ser_console_state *state)
|
{
|
{
|
DWORD threadId;
|
DWORD threadId;
|
|
|
/* Create all of the events. These are all auto-reset events. */
|
/* Create all of the events. These are all auto-reset events. */
|
state->read_event = CreateEvent (NULL, FALSE, FALSE, NULL);
|
state->read_event = CreateEvent (NULL, FALSE, FALSE, NULL);
|
state->except_event = CreateEvent (NULL, FALSE, FALSE, NULL);
|
state->except_event = CreateEvent (NULL, FALSE, FALSE, NULL);
|
state->have_started = CreateEvent (NULL, FALSE, FALSE, NULL);
|
state->have_started = CreateEvent (NULL, FALSE, FALSE, NULL);
|
state->have_stopped = CreateEvent (NULL, FALSE, FALSE, NULL);
|
state->have_stopped = CreateEvent (NULL, FALSE, FALSE, NULL);
|
state->start_select = CreateEvent (NULL, FALSE, FALSE, NULL);
|
state->start_select = CreateEvent (NULL, FALSE, FALSE, NULL);
|
state->stop_select = CreateEvent (NULL, FALSE, FALSE, NULL);
|
state->stop_select = CreateEvent (NULL, FALSE, FALSE, NULL);
|
state->exit_select = CreateEvent (NULL, FALSE, FALSE, NULL);
|
state->exit_select = CreateEvent (NULL, FALSE, FALSE, NULL);
|
|
|
state->thread = CreateThread (NULL, 0, thread_fn, scb, 0, &threadId);
|
state->thread = CreateThread (NULL, 0, thread_fn, scb, 0, &threadId);
|
/* The thread begins in the stopped state. */
|
/* The thread begins in the stopped state. */
|
state->thread_state = STS_STOPPED;
|
state->thread_state = STS_STOPPED;
|
}
|
}
|
|
|
/* Destroy the select thread indicated by STATE. */
|
/* Destroy the select thread indicated by STATE. */
|
static void
|
static void
|
destroy_select_thread (struct ser_console_state *state)
|
destroy_select_thread (struct ser_console_state *state)
|
{
|
{
|
/* Ask the thread to exit. */
|
/* Ask the thread to exit. */
|
SetEvent (state->exit_select);
|
SetEvent (state->exit_select);
|
/* Wait until it does. */
|
/* Wait until it does. */
|
WaitForSingleObject (state->thread, INFINITE);
|
WaitForSingleObject (state->thread, INFINITE);
|
|
|
/* Destroy the events. */
|
/* Destroy the events. */
|
CloseHandle (state->read_event);
|
CloseHandle (state->read_event);
|
CloseHandle (state->except_event);
|
CloseHandle (state->except_event);
|
CloseHandle (state->have_started);
|
CloseHandle (state->have_started);
|
CloseHandle (state->have_stopped);
|
CloseHandle (state->have_stopped);
|
CloseHandle (state->start_select);
|
CloseHandle (state->start_select);
|
CloseHandle (state->stop_select);
|
CloseHandle (state->stop_select);
|
CloseHandle (state->exit_select);
|
CloseHandle (state->exit_select);
|
}
|
}
|
|
|
/* Called by gdb_select to start the select thread indicated by STATE.
|
/* Called by gdb_select to start the select thread indicated by STATE.
|
This function does not return until the thread has started. */
|
This function does not return until the thread has started. */
|
static void
|
static void
|
start_select_thread (struct ser_console_state *state)
|
start_select_thread (struct ser_console_state *state)
|
{
|
{
|
/* Ask the thread to start. */
|
/* Ask the thread to start. */
|
SetEvent (state->start_select);
|
SetEvent (state->start_select);
|
/* Wait until it does. */
|
/* Wait until it does. */
|
WaitForSingleObject (state->have_started, INFINITE);
|
WaitForSingleObject (state->have_started, INFINITE);
|
/* The thread is now started. */
|
/* The thread is now started. */
|
state->thread_state = STS_STARTED;
|
state->thread_state = STS_STARTED;
|
}
|
}
|
|
|
/* Called by gdb_select to stop the select thread indicated by STATE.
|
/* Called by gdb_select to stop the select thread indicated by STATE.
|
This function does not return until the thread has stopped. */
|
This function does not return until the thread has stopped. */
|
static void
|
static void
|
stop_select_thread (struct ser_console_state *state)
|
stop_select_thread (struct ser_console_state *state)
|
{
|
{
|
/* If the thread is already in the stopped state, we have nothing to
|
/* If the thread is already in the stopped state, we have nothing to
|
do. Some of the wait_handle functions avoid calling
|
do. Some of the wait_handle functions avoid calling
|
start_select_thread if they notice activity on the relevant file
|
start_select_thread if they notice activity on the relevant file
|
descriptors. The wait_handle_done functions still call
|
descriptors. The wait_handle_done functions still call
|
stop_select_thread -- but it is already stopped. */
|
stop_select_thread -- but it is already stopped. */
|
if (state->thread_state != STS_STARTED)
|
if (state->thread_state != STS_STARTED)
|
return;
|
return;
|
/* Ask the thread to stop. */
|
/* Ask the thread to stop. */
|
SetEvent (state->stop_select);
|
SetEvent (state->stop_select);
|
/* Wait until it does. */
|
/* Wait until it does. */
|
WaitForSingleObject (state->have_stopped, INFINITE);
|
WaitForSingleObject (state->have_stopped, INFINITE);
|
/* The thread is now stopped. */
|
/* The thread is now stopped. */
|
state->thread_state = STS_STOPPED;
|
state->thread_state = STS_STOPPED;
|
}
|
}
|
|
|
static DWORD WINAPI
|
static DWORD WINAPI
|
console_select_thread (void *arg)
|
console_select_thread (void *arg)
|
{
|
{
|
struct serial *scb = arg;
|
struct serial *scb = arg;
|
struct ser_console_state *state;
|
struct ser_console_state *state;
|
int event_index;
|
int event_index;
|
HANDLE h;
|
HANDLE h;
|
|
|
state = scb->state;
|
state = scb->state;
|
h = (HANDLE) _get_osfhandle (scb->fd);
|
h = (HANDLE) _get_osfhandle (scb->fd);
|
|
|
while (1)
|
while (1)
|
{
|
{
|
HANDLE wait_events[2];
|
HANDLE wait_events[2];
|
INPUT_RECORD record;
|
INPUT_RECORD record;
|
DWORD n_records;
|
DWORD n_records;
|
|
|
select_thread_wait (state);
|
select_thread_wait (state);
|
|
|
while (1)
|
while (1)
|
{
|
{
|
wait_events[0] = state->stop_select;
|
wait_events[0] = state->stop_select;
|
wait_events[1] = h;
|
wait_events[1] = h;
|
|
|
event_index = WaitForMultipleObjects (2, wait_events, FALSE, INFINITE);
|
event_index = WaitForMultipleObjects (2, wait_events, FALSE, INFINITE);
|
|
|
if (event_index == WAIT_OBJECT_0
|
if (event_index == WAIT_OBJECT_0
|
|| WaitForSingleObject (state->stop_select, 0) == WAIT_OBJECT_0)
|
|| WaitForSingleObject (state->stop_select, 0) == WAIT_OBJECT_0)
|
break;
|
break;
|
|
|
if (event_index != WAIT_OBJECT_0 + 1)
|
if (event_index != WAIT_OBJECT_0 + 1)
|
{
|
{
|
/* Wait must have failed; assume an error has occured, e.g.
|
/* Wait must have failed; assume an error has occured, e.g.
|
the handle has been closed. */
|
the handle has been closed. */
|
SetEvent (state->except_event);
|
SetEvent (state->except_event);
|
break;
|
break;
|
}
|
}
|
|
|
/* We've got a pending event on the console. See if it's
|
/* We've got a pending event on the console. See if it's
|
of interest. */
|
of interest. */
|
if (!PeekConsoleInput (h, &record, 1, &n_records) || n_records != 1)
|
if (!PeekConsoleInput (h, &record, 1, &n_records) || n_records != 1)
|
{
|
{
|
/* Something went wrong. Maybe the console is gone. */
|
/* Something went wrong. Maybe the console is gone. */
|
SetEvent (state->except_event);
|
SetEvent (state->except_event);
|
break;
|
break;
|
}
|
}
|
|
|
if (record.EventType == KEY_EVENT && record.Event.KeyEvent.bKeyDown)
|
if (record.EventType == KEY_EVENT && record.Event.KeyEvent.bKeyDown)
|
{
|
{
|
WORD keycode = record.Event.KeyEvent.wVirtualKeyCode;
|
WORD keycode = record.Event.KeyEvent.wVirtualKeyCode;
|
|
|
/* Ignore events containing only control keys. We must
|
/* Ignore events containing only control keys. We must
|
recognize "enhanced" keys which we are interested in
|
recognize "enhanced" keys which we are interested in
|
reading via getch, if they do not map to ASCII. But we
|
reading via getch, if they do not map to ASCII. But we
|
do not want to report input available for e.g. the
|
do not want to report input available for e.g. the
|
control key alone. */
|
control key alone. */
|
|
|
if (record.Event.KeyEvent.uChar.AsciiChar != 0
|
if (record.Event.KeyEvent.uChar.AsciiChar != 0
|
|| keycode == VK_PRIOR
|
|| keycode == VK_PRIOR
|
|| keycode == VK_NEXT
|
|| keycode == VK_NEXT
|
|| keycode == VK_END
|
|| keycode == VK_END
|
|| keycode == VK_HOME
|
|| keycode == VK_HOME
|
|| keycode == VK_LEFT
|
|| keycode == VK_LEFT
|
|| keycode == VK_UP
|
|| keycode == VK_UP
|
|| keycode == VK_RIGHT
|
|| keycode == VK_RIGHT
|
|| keycode == VK_DOWN
|
|| keycode == VK_DOWN
|
|| keycode == VK_INSERT
|
|| keycode == VK_INSERT
|
|| keycode == VK_DELETE)
|
|| keycode == VK_DELETE)
|
{
|
{
|
/* This is really a keypress. */
|
/* This is really a keypress. */
|
SetEvent (state->read_event);
|
SetEvent (state->read_event);
|
break;
|
break;
|
}
|
}
|
}
|
}
|
|
|
/* Otherwise discard it and wait again. */
|
/* Otherwise discard it and wait again. */
|
ReadConsoleInput (h, &record, 1, &n_records);
|
ReadConsoleInput (h, &record, 1, &n_records);
|
}
|
}
|
|
|
SetEvent(state->have_stopped);
|
SetEvent(state->have_stopped);
|
}
|
}
|
}
|
}
|
|
|
static int
|
static int
|
fd_is_pipe (int fd)
|
fd_is_pipe (int fd)
|
{
|
{
|
if (PeekNamedPipe ((HANDLE) _get_osfhandle (fd), NULL, 0, NULL, NULL, NULL))
|
if (PeekNamedPipe ((HANDLE) _get_osfhandle (fd), NULL, 0, NULL, NULL, NULL))
|
return 1;
|
return 1;
|
else
|
else
|
return 0;
|
return 0;
|
}
|
}
|
|
|
static int
|
static int
|
fd_is_file (int fd)
|
fd_is_file (int fd)
|
{
|
{
|
if (GetFileType ((HANDLE) _get_osfhandle (fd)) == FILE_TYPE_DISK)
|
if (GetFileType ((HANDLE) _get_osfhandle (fd)) == FILE_TYPE_DISK)
|
return 1;
|
return 1;
|
else
|
else
|
return 0;
|
return 0;
|
}
|
}
|
|
|
static DWORD WINAPI
|
static DWORD WINAPI
|
pipe_select_thread (void *arg)
|
pipe_select_thread (void *arg)
|
{
|
{
|
struct serial *scb = arg;
|
struct serial *scb = arg;
|
struct ser_console_state *state;
|
struct ser_console_state *state;
|
int event_index;
|
int event_index;
|
HANDLE h;
|
HANDLE h;
|
|
|
state = scb->state;
|
state = scb->state;
|
h = (HANDLE) _get_osfhandle (scb->fd);
|
h = (HANDLE) _get_osfhandle (scb->fd);
|
|
|
while (1)
|
while (1)
|
{
|
{
|
DWORD n_avail;
|
DWORD n_avail;
|
|
|
select_thread_wait (state);
|
select_thread_wait (state);
|
|
|
/* Wait for something to happen on the pipe. */
|
/* Wait for something to happen on the pipe. */
|
while (1)
|
while (1)
|
{
|
{
|
if (!PeekNamedPipe (h, NULL, 0, NULL, &n_avail, NULL))
|
if (!PeekNamedPipe (h, NULL, 0, NULL, &n_avail, NULL))
|
{
|
{
|
SetEvent (state->except_event);
|
SetEvent (state->except_event);
|
break;
|
break;
|
}
|
}
|
|
|
if (n_avail > 0)
|
if (n_avail > 0)
|
{
|
{
|
SetEvent (state->read_event);
|
SetEvent (state->read_event);
|
break;
|
break;
|
}
|
}
|
|
|
/* Delay 10ms before checking again, but allow the stop
|
/* Delay 10ms before checking again, but allow the stop
|
event to wake us. */
|
event to wake us. */
|
if (WaitForSingleObject (state->stop_select, 10) == WAIT_OBJECT_0)
|
if (WaitForSingleObject (state->stop_select, 10) == WAIT_OBJECT_0)
|
break;
|
break;
|
}
|
}
|
|
|
SetEvent (state->have_stopped);
|
SetEvent (state->have_stopped);
|
}
|
}
|
}
|
}
|
|
|
static DWORD WINAPI
|
static DWORD WINAPI
|
file_select_thread (void *arg)
|
file_select_thread (void *arg)
|
{
|
{
|
struct serial *scb = arg;
|
struct serial *scb = arg;
|
struct ser_console_state *state;
|
struct ser_console_state *state;
|
int event_index;
|
int event_index;
|
HANDLE h;
|
HANDLE h;
|
|
|
state = scb->state;
|
state = scb->state;
|
h = (HANDLE) _get_osfhandle (scb->fd);
|
h = (HANDLE) _get_osfhandle (scb->fd);
|
|
|
while (1)
|
while (1)
|
{
|
{
|
select_thread_wait (state);
|
select_thread_wait (state);
|
|
|
if (SetFilePointer (h, 0, NULL, FILE_CURRENT) == INVALID_SET_FILE_POINTER)
|
if (SetFilePointer (h, 0, NULL, FILE_CURRENT) == INVALID_SET_FILE_POINTER)
|
SetEvent (state->except_event);
|
SetEvent (state->except_event);
|
else
|
else
|
SetEvent (state->read_event);
|
SetEvent (state->read_event);
|
|
|
SetEvent (state->have_stopped);
|
SetEvent (state->have_stopped);
|
}
|
}
|
}
|
}
|
|
|
static void
|
static void
|
ser_console_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except)
|
ser_console_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except)
|
{
|
{
|
struct ser_console_state *state = scb->state;
|
struct ser_console_state *state = scb->state;
|
|
|
if (state == NULL)
|
if (state == NULL)
|
{
|
{
|
thread_fn_type thread_fn;
|
thread_fn_type thread_fn;
|
int is_tty;
|
int is_tty;
|
|
|
is_tty = isatty (scb->fd);
|
is_tty = isatty (scb->fd);
|
if (!is_tty && !fd_is_file (scb->fd) && !fd_is_pipe (scb->fd))
|
if (!is_tty && !fd_is_file (scb->fd) && !fd_is_pipe (scb->fd))
|
{
|
{
|
*read = NULL;
|
*read = NULL;
|
*except = NULL;
|
*except = NULL;
|
return;
|
return;
|
}
|
}
|
|
|
state = xmalloc (sizeof (struct ser_console_state));
|
state = xmalloc (sizeof (struct ser_console_state));
|
memset (state, 0, sizeof (struct ser_console_state));
|
memset (state, 0, sizeof (struct ser_console_state));
|
scb->state = state;
|
scb->state = state;
|
|
|
if (is_tty)
|
if (is_tty)
|
thread_fn = console_select_thread;
|
thread_fn = console_select_thread;
|
else if (fd_is_pipe (scb->fd))
|
else if (fd_is_pipe (scb->fd))
|
thread_fn = pipe_select_thread;
|
thread_fn = pipe_select_thread;
|
else
|
else
|
thread_fn = file_select_thread;
|
thread_fn = file_select_thread;
|
|
|
create_select_thread (thread_fn, scb, state);
|
create_select_thread (thread_fn, scb, state);
|
}
|
}
|
|
|
*read = state->read_event;
|
*read = state->read_event;
|
*except = state->except_event;
|
*except = state->except_event;
|
|
|
/* Start from a blank state. */
|
/* Start from a blank state. */
|
ResetEvent (state->read_event);
|
ResetEvent (state->read_event);
|
ResetEvent (state->except_event);
|
ResetEvent (state->except_event);
|
ResetEvent (state->stop_select);
|
ResetEvent (state->stop_select);
|
|
|
/* First check for a key already in the buffer. If there is one,
|
/* First check for a key already in the buffer. If there is one,
|
we don't need a thread. This also catches the second key of
|
we don't need a thread. This also catches the second key of
|
multi-character returns from getch, for instance for arrow
|
multi-character returns from getch, for instance for arrow
|
keys. The second half is in a C library internal buffer,
|
keys. The second half is in a C library internal buffer,
|
and PeekConsoleInput will not find it. */
|
and PeekConsoleInput will not find it. */
|
if (_kbhit ())
|
if (_kbhit ())
|
{
|
{
|
SetEvent (state->read_event);
|
SetEvent (state->read_event);
|
return;
|
return;
|
}
|
}
|
|
|
/* Otherwise, start the select thread. */
|
/* Otherwise, start the select thread. */
|
start_select_thread (state);
|
start_select_thread (state);
|
}
|
}
|
|
|
static void
|
static void
|
ser_console_done_wait_handle (struct serial *scb)
|
ser_console_done_wait_handle (struct serial *scb)
|
{
|
{
|
struct ser_console_state *state = scb->state;
|
struct ser_console_state *state = scb->state;
|
|
|
if (state == NULL)
|
if (state == NULL)
|
return;
|
return;
|
|
|
stop_select_thread (state);
|
stop_select_thread (state);
|
}
|
}
|
|
|
static void
|
static void
|
ser_console_close (struct serial *scb)
|
ser_console_close (struct serial *scb)
|
{
|
{
|
struct ser_console_state *state = scb->state;
|
struct ser_console_state *state = scb->state;
|
|
|
if (scb->state)
|
if (scb->state)
|
{
|
{
|
destroy_select_thread (state);
|
destroy_select_thread (state);
|
xfree (scb->state);
|
xfree (scb->state);
|
}
|
}
|
}
|
}
|
|
|
struct ser_console_ttystate
|
struct ser_console_ttystate
|
{
|
{
|
int is_a_tty;
|
int is_a_tty;
|
};
|
};
|
|
|
static serial_ttystate
|
static serial_ttystate
|
ser_console_get_tty_state (struct serial *scb)
|
ser_console_get_tty_state (struct serial *scb)
|
{
|
{
|
if (isatty (scb->fd))
|
if (isatty (scb->fd))
|
{
|
{
|
struct ser_console_ttystate *state;
|
struct ser_console_ttystate *state;
|
state = (struct ser_console_ttystate *) xmalloc (sizeof *state);
|
state = (struct ser_console_ttystate *) xmalloc (sizeof *state);
|
state->is_a_tty = 1;
|
state->is_a_tty = 1;
|
return state;
|
return state;
|
}
|
}
|
else
|
else
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
struct pipe_state
|
struct pipe_state
|
{
|
{
|
/* Since we use the pipe_select_thread for our select emulation,
|
/* Since we use the pipe_select_thread for our select emulation,
|
we need to place the state structure it requires at the front
|
we need to place the state structure it requires at the front
|
of our state. */
|
of our state. */
|
struct ser_console_state wait;
|
struct ser_console_state wait;
|
|
|
/* The pex obj for our (one-stage) pipeline. */
|
/* The pex obj for our (one-stage) pipeline. */
|
struct pex_obj *pex;
|
struct pex_obj *pex;
|
|
|
/* Streams for the pipeline's input and output. */
|
/* Streams for the pipeline's input and output. */
|
FILE *input, *output;
|
FILE *input, *output;
|
};
|
};
|
|
|
static struct pipe_state *
|
static struct pipe_state *
|
make_pipe_state (void)
|
make_pipe_state (void)
|
{
|
{
|
struct pipe_state *ps = XMALLOC (struct pipe_state);
|
struct pipe_state *ps = XMALLOC (struct pipe_state);
|
|
|
memset (ps, 0, sizeof (*ps));
|
memset (ps, 0, sizeof (*ps));
|
ps->wait.read_event = INVALID_HANDLE_VALUE;
|
ps->wait.read_event = INVALID_HANDLE_VALUE;
|
ps->wait.except_event = INVALID_HANDLE_VALUE;
|
ps->wait.except_event = INVALID_HANDLE_VALUE;
|
ps->wait.start_select = INVALID_HANDLE_VALUE;
|
ps->wait.start_select = INVALID_HANDLE_VALUE;
|
ps->wait.stop_select = INVALID_HANDLE_VALUE;
|
ps->wait.stop_select = INVALID_HANDLE_VALUE;
|
|
|
return ps;
|
return ps;
|
}
|
}
|
|
|
static void
|
static void
|
free_pipe_state (struct pipe_state *ps)
|
free_pipe_state (struct pipe_state *ps)
|
{
|
{
|
int saved_errno = errno;
|
int saved_errno = errno;
|
|
|
if (ps->wait.read_event != INVALID_HANDLE_VALUE)
|
if (ps->wait.read_event != INVALID_HANDLE_VALUE)
|
destroy_select_thread (&ps->wait);
|
destroy_select_thread (&ps->wait);
|
|
|
/* Close the pipe to the child. We must close the pipe before
|
/* Close the pipe to the child. We must close the pipe before
|
calling pex_free because pex_free will wait for the child to exit
|
calling pex_free because pex_free will wait for the child to exit
|
and the child will not exit until the pipe is closed. */
|
and the child will not exit until the pipe is closed. */
|
if (ps->input)
|
if (ps->input)
|
fclose (ps->input);
|
fclose (ps->input);
|
if (ps->pex)
|
if (ps->pex)
|
pex_free (ps->pex);
|
pex_free (ps->pex);
|
/* pex_free closes ps->output. */
|
/* pex_free closes ps->output. */
|
|
|
xfree (ps);
|
xfree (ps);
|
|
|
errno = saved_errno;
|
errno = saved_errno;
|
}
|
}
|
|
|
static void
|
static void
|
cleanup_pipe_state (void *untyped)
|
cleanup_pipe_state (void *untyped)
|
{
|
{
|
struct pipe_state *ps = untyped;
|
struct pipe_state *ps = untyped;
|
|
|
free_pipe_state (ps);
|
free_pipe_state (ps);
|
}
|
}
|
|
|
static int
|
static int
|
pipe_windows_open (struct serial *scb, const char *name)
|
pipe_windows_open (struct serial *scb, const char *name)
|
{
|
{
|
struct pipe_state *ps;
|
struct pipe_state *ps;
|
FILE *pex_stderr;
|
FILE *pex_stderr;
|
|
|
char **argv = buildargv (name);
|
char **argv = buildargv (name);
|
struct cleanup *back_to = make_cleanup_freeargv (argv);
|
struct cleanup *back_to = make_cleanup_freeargv (argv);
|
if (! argv[0] || argv[0][0] == '\0')
|
if (! argv[0] || argv[0][0] == '\0')
|
error ("missing child command");
|
error ("missing child command");
|
|
|
|
|
ps = make_pipe_state ();
|
ps = make_pipe_state ();
|
make_cleanup (cleanup_pipe_state, ps);
|
make_cleanup (cleanup_pipe_state, ps);
|
|
|
ps->pex = pex_init (PEX_USE_PIPES, "target remote pipe", NULL);
|
ps->pex = pex_init (PEX_USE_PIPES, "target remote pipe", NULL);
|
if (! ps->pex)
|
if (! ps->pex)
|
goto fail;
|
goto fail;
|
ps->input = pex_input_pipe (ps->pex, 1);
|
ps->input = pex_input_pipe (ps->pex, 1);
|
if (! ps->input)
|
if (! ps->input)
|
goto fail;
|
goto fail;
|
|
|
{
|
{
|
int err;
|
int err;
|
const char *err_msg
|
const char *err_msg
|
= pex_run (ps->pex, PEX_SEARCH | PEX_BINARY_INPUT | PEX_BINARY_OUTPUT
|
= pex_run (ps->pex, PEX_SEARCH | PEX_BINARY_INPUT | PEX_BINARY_OUTPUT
|
| PEX_STDERR_TO_PIPE,
|
| PEX_STDERR_TO_PIPE,
|
argv[0], argv, NULL, NULL,
|
argv[0], argv, NULL, NULL,
|
&err);
|
&err);
|
|
|
if (err_msg)
|
if (err_msg)
|
{
|
{
|
/* Our caller expects us to return -1, but all they'll do with
|
/* Our caller expects us to return -1, but all they'll do with
|
it generally is print the message based on errno. We have
|
it generally is print the message based on errno. We have
|
all the same information here, plus err_msg provided by
|
all the same information here, plus err_msg provided by
|
pex_run, so we just raise the error here. */
|
pex_run, so we just raise the error here. */
|
if (err)
|
if (err)
|
error ("error starting child process '%s': %s: %s",
|
error ("error starting child process '%s': %s: %s",
|
name, err_msg, safe_strerror (err));
|
name, err_msg, safe_strerror (err));
|
else
|
else
|
error ("error starting child process '%s': %s",
|
error ("error starting child process '%s': %s",
|
name, err_msg);
|
name, err_msg);
|
}
|
}
|
}
|
}
|
|
|
ps->output = pex_read_output (ps->pex, 1);
|
ps->output = pex_read_output (ps->pex, 1);
|
if (! ps->output)
|
if (! ps->output)
|
goto fail;
|
goto fail;
|
scb->fd = fileno (ps->output);
|
scb->fd = fileno (ps->output);
|
|
|
pex_stderr = pex_read_err (ps->pex, 1);
|
pex_stderr = pex_read_err (ps->pex, 1);
|
if (! pex_stderr)
|
if (! pex_stderr)
|
goto fail;
|
goto fail;
|
scb->error_fd = fileno (pex_stderr);
|
scb->error_fd = fileno (pex_stderr);
|
|
|
scb->state = (void *) ps;
|
scb->state = (void *) ps;
|
|
|
discard_cleanups (back_to);
|
discard_cleanups (back_to);
|
return 0;
|
return 0;
|
|
|
fail:
|
fail:
|
do_cleanups (back_to);
|
do_cleanups (back_to);
|
return -1;
|
return -1;
|
}
|
}
|
|
|
|
|
static void
|
static void
|
pipe_windows_close (struct serial *scb)
|
pipe_windows_close (struct serial *scb)
|
{
|
{
|
struct pipe_state *ps = scb->state;
|
struct pipe_state *ps = scb->state;
|
|
|
/* In theory, we should try to kill the subprocess here, but the pex
|
/* In theory, we should try to kill the subprocess here, but the pex
|
interface doesn't give us enough information to do that. Usually
|
interface doesn't give us enough information to do that. Usually
|
closing the input pipe will get the message across. */
|
closing the input pipe will get the message across. */
|
|
|
free_pipe_state (ps);
|
free_pipe_state (ps);
|
}
|
}
|
|
|
|
|
static int
|
static int
|
pipe_windows_read (struct serial *scb, size_t count)
|
pipe_windows_read (struct serial *scb, size_t count)
|
{
|
{
|
HANDLE pipeline_out = (HANDLE) _get_osfhandle (scb->fd);
|
HANDLE pipeline_out = (HANDLE) _get_osfhandle (scb->fd);
|
DWORD available;
|
DWORD available;
|
DWORD bytes_read;
|
DWORD bytes_read;
|
|
|
if (pipeline_out == INVALID_HANDLE_VALUE)
|
if (pipeline_out == INVALID_HANDLE_VALUE)
|
return -1;
|
return -1;
|
|
|
if (! PeekNamedPipe (pipeline_out, NULL, 0, NULL, &available, NULL))
|
if (! PeekNamedPipe (pipeline_out, NULL, 0, NULL, &available, NULL))
|
return -1;
|
return -1;
|
|
|
if (count > available)
|
if (count > available)
|
count = available;
|
count = available;
|
|
|
if (! ReadFile (pipeline_out, scb->buf, count, &bytes_read, NULL))
|
if (! ReadFile (pipeline_out, scb->buf, count, &bytes_read, NULL))
|
return -1;
|
return -1;
|
|
|
return bytes_read;
|
return bytes_read;
|
}
|
}
|
|
|
|
|
static int
|
static int
|
pipe_windows_write (struct serial *scb, const void *buf, size_t count)
|
pipe_windows_write (struct serial *scb, const void *buf, size_t count)
|
{
|
{
|
struct pipe_state *ps = scb->state;
|
struct pipe_state *ps = scb->state;
|
HANDLE pipeline_in;
|
HANDLE pipeline_in;
|
DWORD written;
|
DWORD written;
|
|
|
int pipeline_in_fd = fileno (ps->input);
|
int pipeline_in_fd = fileno (ps->input);
|
if (pipeline_in_fd < 0)
|
if (pipeline_in_fd < 0)
|
return -1;
|
return -1;
|
|
|
pipeline_in = (HANDLE) _get_osfhandle (pipeline_in_fd);
|
pipeline_in = (HANDLE) _get_osfhandle (pipeline_in_fd);
|
if (pipeline_in == INVALID_HANDLE_VALUE)
|
if (pipeline_in == INVALID_HANDLE_VALUE)
|
return -1;
|
return -1;
|
|
|
if (! WriteFile (pipeline_in, buf, count, &written, NULL))
|
if (! WriteFile (pipeline_in, buf, count, &written, NULL))
|
return -1;
|
return -1;
|
|
|
return written;
|
return written;
|
}
|
}
|
|
|
|
|
static void
|
static void
|
pipe_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except)
|
pipe_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except)
|
{
|
{
|
struct pipe_state *ps = scb->state;
|
struct pipe_state *ps = scb->state;
|
|
|
/* Have we allocated our events yet? */
|
/* Have we allocated our events yet? */
|
if (ps->wait.read_event == INVALID_HANDLE_VALUE)
|
if (ps->wait.read_event == INVALID_HANDLE_VALUE)
|
/* Start the thread. */
|
/* Start the thread. */
|
create_select_thread (pipe_select_thread, scb, &ps->wait);
|
create_select_thread (pipe_select_thread, scb, &ps->wait);
|
|
|
*read = ps->wait.read_event;
|
*read = ps->wait.read_event;
|
*except = ps->wait.except_event;
|
*except = ps->wait.except_event;
|
|
|
/* Start from a blank state. */
|
/* Start from a blank state. */
|
ResetEvent (ps->wait.read_event);
|
ResetEvent (ps->wait.read_event);
|
ResetEvent (ps->wait.except_event);
|
ResetEvent (ps->wait.except_event);
|
ResetEvent (ps->wait.stop_select);
|
ResetEvent (ps->wait.stop_select);
|
|
|
start_select_thread (&ps->wait);
|
start_select_thread (&ps->wait);
|
}
|
}
|
|
|
static void
|
static void
|
pipe_done_wait_handle (struct serial *scb)
|
pipe_done_wait_handle (struct serial *scb)
|
{
|
{
|
struct pipe_state *ps = scb->state;
|
struct pipe_state *ps = scb->state;
|
|
|
/* Have we allocated our events yet? */
|
/* Have we allocated our events yet? */
|
if (ps->wait.read_event == INVALID_HANDLE_VALUE)
|
if (ps->wait.read_event == INVALID_HANDLE_VALUE)
|
return;
|
return;
|
|
|
stop_select_thread (&ps->wait);
|
stop_select_thread (&ps->wait);
|
}
|
}
|
|
|
static int
|
static int
|
pipe_avail (struct serial *scb, int fd)
|
pipe_avail (struct serial *scb, int fd)
|
{
|
{
|
HANDLE h = (HANDLE) _get_osfhandle (fd);
|
HANDLE h = (HANDLE) _get_osfhandle (fd);
|
DWORD numBytes;
|
DWORD numBytes;
|
BOOL r = PeekNamedPipe (h, NULL, 0, NULL, &numBytes, NULL);
|
BOOL r = PeekNamedPipe (h, NULL, 0, NULL, &numBytes, NULL);
|
if (r == FALSE)
|
if (r == FALSE)
|
numBytes = 0;
|
numBytes = 0;
|
return numBytes;
|
return numBytes;
|
}
|
}
|
|
|
struct net_windows_state
|
struct net_windows_state
|
{
|
{
|
struct ser_console_state base;
|
struct ser_console_state base;
|
|
|
HANDLE sock_event;
|
HANDLE sock_event;
|
};
|
};
|
|
|
static DWORD WINAPI
|
static DWORD WINAPI
|
net_windows_select_thread (void *arg)
|
net_windows_select_thread (void *arg)
|
{
|
{
|
struct serial *scb = arg;
|
struct serial *scb = arg;
|
struct net_windows_state *state;
|
struct net_windows_state *state;
|
int event_index;
|
int event_index;
|
|
|
state = scb->state;
|
state = scb->state;
|
|
|
while (1)
|
while (1)
|
{
|
{
|
HANDLE wait_events[2];
|
HANDLE wait_events[2];
|
WSANETWORKEVENTS events;
|
WSANETWORKEVENTS events;
|
|
|
select_thread_wait (&state->base);
|
select_thread_wait (&state->base);
|
|
|
wait_events[0] = state->base.stop_select;
|
wait_events[0] = state->base.stop_select;
|
wait_events[1] = state->sock_event;
|
wait_events[1] = state->sock_event;
|
|
|
event_index = WaitForMultipleObjects (2, wait_events, FALSE, INFINITE);
|
event_index = WaitForMultipleObjects (2, wait_events, FALSE, INFINITE);
|
|
|
if (event_index == WAIT_OBJECT_0
|
if (event_index == WAIT_OBJECT_0
|
|| WaitForSingleObject (state->base.stop_select, 0) == WAIT_OBJECT_0)
|
|| WaitForSingleObject (state->base.stop_select, 0) == WAIT_OBJECT_0)
|
/* We have been requested to stop. */
|
/* We have been requested to stop. */
|
;
|
;
|
else if (event_index != WAIT_OBJECT_0 + 1)
|
else if (event_index != WAIT_OBJECT_0 + 1)
|
/* Some error has occured. Assume that this is an error
|
/* Some error has occured. Assume that this is an error
|
condition. */
|
condition. */
|
SetEvent (state->base.except_event);
|
SetEvent (state->base.except_event);
|
else
|
else
|
{
|
{
|
/* Enumerate the internal network events, and reset the
|
/* Enumerate the internal network events, and reset the
|
object that signalled us to catch the next event. */
|
object that signalled us to catch the next event. */
|
WSAEnumNetworkEvents (scb->fd, state->sock_event, &events);
|
WSAEnumNetworkEvents (scb->fd, state->sock_event, &events);
|
|
|
gdb_assert (events.lNetworkEvents & (FD_READ | FD_CLOSE));
|
gdb_assert (events.lNetworkEvents & (FD_READ | FD_CLOSE));
|
|
|
if (events.lNetworkEvents & FD_READ)
|
if (events.lNetworkEvents & FD_READ)
|
SetEvent (state->base.read_event);
|
SetEvent (state->base.read_event);
|
|
|
if (events.lNetworkEvents & FD_CLOSE)
|
if (events.lNetworkEvents & FD_CLOSE)
|
SetEvent (state->base.except_event);
|
SetEvent (state->base.except_event);
|
}
|
}
|
|
|
SetEvent (state->base.have_stopped);
|
SetEvent (state->base.have_stopped);
|
}
|
}
|
}
|
}
|
|
|
static void
|
static void
|
net_windows_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except)
|
net_windows_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except)
|
{
|
{
|
struct net_windows_state *state = scb->state;
|
struct net_windows_state *state = scb->state;
|
|
|
/* Start from a clean slate. */
|
/* Start from a clean slate. */
|
ResetEvent (state->base.read_event);
|
ResetEvent (state->base.read_event);
|
ResetEvent (state->base.except_event);
|
ResetEvent (state->base.except_event);
|
ResetEvent (state->base.stop_select);
|
ResetEvent (state->base.stop_select);
|
|
|
*read = state->base.read_event;
|
*read = state->base.read_event;
|
*except = state->base.except_event;
|
*except = state->base.except_event;
|
|
|
/* Check any pending events. This both avoids starting the thread
|
/* Check any pending events. This both avoids starting the thread
|
unnecessarily, and handles stray FD_READ events (see below). */
|
unnecessarily, and handles stray FD_READ events (see below). */
|
if (WaitForSingleObject (state->sock_event, 0) == WAIT_OBJECT_0)
|
if (WaitForSingleObject (state->sock_event, 0) == WAIT_OBJECT_0)
|
{
|
{
|
WSANETWORKEVENTS events;
|
WSANETWORKEVENTS events;
|
int any = 0;
|
int any = 0;
|
|
|
/* Enumerate the internal network events, and reset the object that
|
/* Enumerate the internal network events, and reset the object that
|
signalled us to catch the next event. */
|
signalled us to catch the next event. */
|
WSAEnumNetworkEvents (scb->fd, state->sock_event, &events);
|
WSAEnumNetworkEvents (scb->fd, state->sock_event, &events);
|
|
|
/* You'd think that FD_READ or FD_CLOSE would be set here. But,
|
/* You'd think that FD_READ or FD_CLOSE would be set here. But,
|
sometimes, neither is. I suspect that the FD_READ is set and
|
sometimes, neither is. I suspect that the FD_READ is set and
|
the corresponding event signalled while recv is running, and
|
the corresponding event signalled while recv is running, and
|
the FD_READ is then lowered when recv consumes all the data,
|
the FD_READ is then lowered when recv consumes all the data,
|
but there's no way to un-signal the event. This isn't a
|
but there's no way to un-signal the event. This isn't a
|
problem for the call in net_select_thread, since any new
|
problem for the call in net_select_thread, since any new
|
events after this point will not have been drained by recv.
|
events after this point will not have been drained by recv.
|
It just means that we can't have the obvious assert here. */
|
It just means that we can't have the obvious assert here. */
|
|
|
/* If there is a read event, it might be still valid, or it might
|
/* If there is a read event, it might be still valid, or it might
|
not be - it may have been signalled before we last called
|
not be - it may have been signalled before we last called
|
recv. Double-check that there is data. */
|
recv. Double-check that there is data. */
|
if (events.lNetworkEvents & FD_READ)
|
if (events.lNetworkEvents & FD_READ)
|
{
|
{
|
unsigned long available;
|
unsigned long available;
|
|
|
if (ioctlsocket (scb->fd, FIONREAD, &available) == 0
|
if (ioctlsocket (scb->fd, FIONREAD, &available) == 0
|
&& available > 0)
|
&& available > 0)
|
{
|
{
|
SetEvent (state->base.read_event);
|
SetEvent (state->base.read_event);
|
any = 1;
|
any = 1;
|
}
|
}
|
else
|
else
|
/* Oops, no data. This call to recv will cause future
|
/* Oops, no data. This call to recv will cause future
|
data to retrigger the event, e.g. while we are
|
data to retrigger the event, e.g. while we are
|
in net_select_thread. */
|
in net_select_thread. */
|
recv (scb->fd, NULL, 0, 0);
|
recv (scb->fd, NULL, 0, 0);
|
}
|
}
|
|
|
/* If there's a close event, then record it - it is obviously
|
/* If there's a close event, then record it - it is obviously
|
still valid, and it will not be resignalled. */
|
still valid, and it will not be resignalled. */
|
if (events.lNetworkEvents & FD_CLOSE)
|
if (events.lNetworkEvents & FD_CLOSE)
|
{
|
{
|
SetEvent (state->base.except_event);
|
SetEvent (state->base.except_event);
|
any = 1;
|
any = 1;
|
}
|
}
|
|
|
/* If we set either handle, there's no need to wake the thread. */
|
/* If we set either handle, there's no need to wake the thread. */
|
if (any)
|
if (any)
|
return;
|
return;
|
}
|
}
|
|
|
start_select_thread (&state->base);
|
start_select_thread (&state->base);
|
}
|
}
|
|
|
static void
|
static void
|
net_windows_done_wait_handle (struct serial *scb)
|
net_windows_done_wait_handle (struct serial *scb)
|
{
|
{
|
struct net_windows_state *state = scb->state;
|
struct net_windows_state *state = scb->state;
|
|
|
stop_select_thread (&state->base);
|
stop_select_thread (&state->base);
|
}
|
}
|
|
|
static int
|
static int
|
net_windows_open (struct serial *scb, const char *name)
|
net_windows_open (struct serial *scb, const char *name)
|
{
|
{
|
struct net_windows_state *state;
|
struct net_windows_state *state;
|
int ret;
|
int ret;
|
DWORD threadId;
|
DWORD threadId;
|
|
|
ret = net_open (scb, name);
|
ret = net_open (scb, name);
|
if (ret != 0)
|
if (ret != 0)
|
return ret;
|
return ret;
|
|
|
state = xmalloc (sizeof (struct net_windows_state));
|
state = xmalloc (sizeof (struct net_windows_state));
|
memset (state, 0, sizeof (struct net_windows_state));
|
memset (state, 0, sizeof (struct net_windows_state));
|
scb->state = state;
|
scb->state = state;
|
|
|
/* Associate an event with the socket. */
|
/* Associate an event with the socket. */
|
state->sock_event = CreateEvent (0, TRUE, FALSE, 0);
|
state->sock_event = CreateEvent (0, TRUE, FALSE, 0);
|
WSAEventSelect (scb->fd, state->sock_event, FD_READ | FD_CLOSE);
|
WSAEventSelect (scb->fd, state->sock_event, FD_READ | FD_CLOSE);
|
|
|
/* Start the thread. */
|
/* Start the thread. */
|
create_select_thread (net_windows_select_thread, scb, &state->base);
|
create_select_thread (net_windows_select_thread, scb, &state->base);
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
|
|
static void
|
static void
|
net_windows_close (struct serial *scb)
|
net_windows_close (struct serial *scb)
|
{
|
{
|
struct net_windows_state *state = scb->state;
|
struct net_windows_state *state = scb->state;
|
|
|
destroy_select_thread (&state->base);
|
destroy_select_thread (&state->base);
|
CloseHandle (state->sock_event);
|
CloseHandle (state->sock_event);
|
|
|
xfree (scb->state);
|
xfree (scb->state);
|
|
|
net_close (scb);
|
net_close (scb);
|
}
|
}
|
|
|
void
|
void
|
_initialize_ser_windows (void)
|
_initialize_ser_windows (void)
|
{
|
{
|
WSADATA wsa_data;
|
WSADATA wsa_data;
|
struct serial_ops *ops;
|
struct serial_ops *ops;
|
|
|
/* First register the serial port driver. */
|
/* First register the serial port driver. */
|
|
|
ops = XMALLOC (struct serial_ops);
|
ops = XMALLOC (struct serial_ops);
|
memset (ops, 0, sizeof (struct serial_ops));
|
memset (ops, 0, sizeof (struct serial_ops));
|
ops->name = "hardwire";
|
ops->name = "hardwire";
|
ops->next = 0;
|
ops->next = 0;
|
ops->open = ser_windows_open;
|
ops->open = ser_windows_open;
|
ops->close = ser_windows_close;
|
ops->close = ser_windows_close;
|
|
|
ops->flush_output = ser_windows_flush_output;
|
ops->flush_output = ser_windows_flush_output;
|
ops->flush_input = ser_windows_flush_input;
|
ops->flush_input = ser_windows_flush_input;
|
ops->send_break = ser_windows_send_break;
|
ops->send_break = ser_windows_send_break;
|
|
|
/* These are only used for stdin; we do not need them for serial
|
/* These are only used for stdin; we do not need them for serial
|
ports, so supply the standard dummies. */
|
ports, so supply the standard dummies. */
|
ops->get_tty_state = ser_base_get_tty_state;
|
ops->get_tty_state = ser_base_get_tty_state;
|
ops->set_tty_state = ser_base_set_tty_state;
|
ops->set_tty_state = ser_base_set_tty_state;
|
ops->print_tty_state = ser_base_print_tty_state;
|
ops->print_tty_state = ser_base_print_tty_state;
|
ops->noflush_set_tty_state = ser_base_noflush_set_tty_state;
|
ops->noflush_set_tty_state = ser_base_noflush_set_tty_state;
|
|
|
ops->go_raw = ser_windows_raw;
|
ops->go_raw = ser_windows_raw;
|
ops->setbaudrate = ser_windows_setbaudrate;
|
ops->setbaudrate = ser_windows_setbaudrate;
|
ops->setstopbits = ser_windows_setstopbits;
|
ops->setstopbits = ser_windows_setstopbits;
|
ops->drain_output = ser_windows_drain_output;
|
ops->drain_output = ser_windows_drain_output;
|
ops->readchar = ser_base_readchar;
|
ops->readchar = ser_base_readchar;
|
ops->write = ser_base_write;
|
ops->write = ser_base_write;
|
ops->async = ser_base_async;
|
ops->async = ser_base_async;
|
ops->read_prim = ser_windows_read_prim;
|
ops->read_prim = ser_windows_read_prim;
|
ops->write_prim = ser_windows_write_prim;
|
ops->write_prim = ser_windows_write_prim;
|
ops->wait_handle = ser_windows_wait_handle;
|
ops->wait_handle = ser_windows_wait_handle;
|
|
|
serial_add_interface (ops);
|
serial_add_interface (ops);
|
|
|
/* Next create the dummy serial driver used for terminals. We only
|
/* Next create the dummy serial driver used for terminals. We only
|
provide the TTY-related methods. */
|
provide the TTY-related methods. */
|
|
|
ops = XMALLOC (struct serial_ops);
|
ops = XMALLOC (struct serial_ops);
|
memset (ops, 0, sizeof (struct serial_ops));
|
memset (ops, 0, sizeof (struct serial_ops));
|
|
|
ops->name = "terminal";
|
ops->name = "terminal";
|
ops->next = 0;
|
ops->next = 0;
|
|
|
ops->close = ser_console_close;
|
ops->close = ser_console_close;
|
ops->get_tty_state = ser_console_get_tty_state;
|
ops->get_tty_state = ser_console_get_tty_state;
|
ops->set_tty_state = ser_base_set_tty_state;
|
ops->set_tty_state = ser_base_set_tty_state;
|
ops->print_tty_state = ser_base_print_tty_state;
|
ops->print_tty_state = ser_base_print_tty_state;
|
ops->noflush_set_tty_state = ser_base_noflush_set_tty_state;
|
ops->noflush_set_tty_state = ser_base_noflush_set_tty_state;
|
ops->drain_output = ser_base_drain_output;
|
ops->drain_output = ser_base_drain_output;
|
ops->wait_handle = ser_console_wait_handle;
|
ops->wait_handle = ser_console_wait_handle;
|
ops->done_wait_handle = ser_console_done_wait_handle;
|
ops->done_wait_handle = ser_console_done_wait_handle;
|
|
|
serial_add_interface (ops);
|
serial_add_interface (ops);
|
|
|
/* The pipe interface. */
|
/* The pipe interface. */
|
|
|
ops = XMALLOC (struct serial_ops);
|
ops = XMALLOC (struct serial_ops);
|
memset (ops, 0, sizeof (struct serial_ops));
|
memset (ops, 0, sizeof (struct serial_ops));
|
ops->name = "pipe";
|
ops->name = "pipe";
|
ops->next = 0;
|
ops->next = 0;
|
ops->open = pipe_windows_open;
|
ops->open = pipe_windows_open;
|
ops->close = pipe_windows_close;
|
ops->close = pipe_windows_close;
|
ops->readchar = ser_base_readchar;
|
ops->readchar = ser_base_readchar;
|
ops->write = ser_base_write;
|
ops->write = ser_base_write;
|
ops->flush_output = ser_base_flush_output;
|
ops->flush_output = ser_base_flush_output;
|
ops->flush_input = ser_base_flush_input;
|
ops->flush_input = ser_base_flush_input;
|
ops->send_break = ser_base_send_break;
|
ops->send_break = ser_base_send_break;
|
ops->go_raw = ser_base_raw;
|
ops->go_raw = ser_base_raw;
|
ops->get_tty_state = ser_base_get_tty_state;
|
ops->get_tty_state = ser_base_get_tty_state;
|
ops->set_tty_state = ser_base_set_tty_state;
|
ops->set_tty_state = ser_base_set_tty_state;
|
ops->print_tty_state = ser_base_print_tty_state;
|
ops->print_tty_state = ser_base_print_tty_state;
|
ops->noflush_set_tty_state = ser_base_noflush_set_tty_state;
|
ops->noflush_set_tty_state = ser_base_noflush_set_tty_state;
|
ops->setbaudrate = ser_base_setbaudrate;
|
ops->setbaudrate = ser_base_setbaudrate;
|
ops->setstopbits = ser_base_setstopbits;
|
ops->setstopbits = ser_base_setstopbits;
|
ops->drain_output = ser_base_drain_output;
|
ops->drain_output = ser_base_drain_output;
|
ops->async = ser_base_async;
|
ops->async = ser_base_async;
|
ops->read_prim = pipe_windows_read;
|
ops->read_prim = pipe_windows_read;
|
ops->write_prim = pipe_windows_write;
|
ops->write_prim = pipe_windows_write;
|
ops->wait_handle = pipe_wait_handle;
|
ops->wait_handle = pipe_wait_handle;
|
ops->done_wait_handle = pipe_done_wait_handle;
|
ops->done_wait_handle = pipe_done_wait_handle;
|
ops->avail = pipe_avail;
|
ops->avail = pipe_avail;
|
|
|
serial_add_interface (ops);
|
serial_add_interface (ops);
|
|
|
/* If WinSock works, register the TCP/UDP socket driver. */
|
/* If WinSock works, register the TCP/UDP socket driver. */
|
|
|
if (WSAStartup (MAKEWORD (1, 0), &wsa_data) != 0)
|
if (WSAStartup (MAKEWORD (1, 0), &wsa_data) != 0)
|
/* WinSock is unavailable. */
|
/* WinSock is unavailable. */
|
return;
|
return;
|
|
|
ops = XMALLOC (struct serial_ops);
|
ops = XMALLOC (struct serial_ops);
|
memset (ops, 0, sizeof (struct serial_ops));
|
memset (ops, 0, sizeof (struct serial_ops));
|
ops->name = "tcp";
|
ops->name = "tcp";
|
ops->next = 0;
|
ops->next = 0;
|
ops->open = net_windows_open;
|
ops->open = net_windows_open;
|
ops->close = net_windows_close;
|
ops->close = net_windows_close;
|
ops->readchar = ser_base_readchar;
|
ops->readchar = ser_base_readchar;
|
ops->write = ser_base_write;
|
ops->write = ser_base_write;
|
ops->flush_output = ser_base_flush_output;
|
ops->flush_output = ser_base_flush_output;
|
ops->flush_input = ser_base_flush_input;
|
ops->flush_input = ser_base_flush_input;
|
ops->send_break = ser_base_send_break;
|
ops->send_break = ser_base_send_break;
|
ops->go_raw = ser_base_raw;
|
ops->go_raw = ser_base_raw;
|
ops->get_tty_state = ser_base_get_tty_state;
|
ops->get_tty_state = ser_base_get_tty_state;
|
ops->set_tty_state = ser_base_set_tty_state;
|
ops->set_tty_state = ser_base_set_tty_state;
|
ops->print_tty_state = ser_base_print_tty_state;
|
ops->print_tty_state = ser_base_print_tty_state;
|
ops->noflush_set_tty_state = ser_base_noflush_set_tty_state;
|
ops->noflush_set_tty_state = ser_base_noflush_set_tty_state;
|
ops->setbaudrate = ser_base_setbaudrate;
|
ops->setbaudrate = ser_base_setbaudrate;
|
ops->setstopbits = ser_base_setstopbits;
|
ops->setstopbits = ser_base_setstopbits;
|
ops->drain_output = ser_base_drain_output;
|
ops->drain_output = ser_base_drain_output;
|
ops->async = ser_base_async;
|
ops->async = ser_base_async;
|
ops->read_prim = net_read_prim;
|
ops->read_prim = net_read_prim;
|
ops->write_prim = net_write_prim;
|
ops->write_prim = net_write_prim;
|
ops->wait_handle = net_windows_wait_handle;
|
ops->wait_handle = net_windows_wait_handle;
|
ops->done_wait_handle = net_windows_done_wait_handle;
|
ops->done_wait_handle = net_windows_done_wait_handle;
|
serial_add_interface (ops);
|
serial_add_interface (ops);
|
}
|
}
|
|
|
