/* Serial interface for local (hardwired) serial ports on Windows systems
- Copyright (C) 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+ Copyright (C) 2006-2014 Free Software Foundation, Inc.
This file is part of GDB.
#include <sys/types.h>
#include "gdb_assert.h"
-#include "gdb_string.h"
+#include <string.h>
#include "command.h"
HANDLE except_event;
};
+/* CancelIo is not available for Windows 95 OS, so we need to use
+ LoadLibrary/GetProcAddress to avoid a startup failure. */
+#define CancelIo dyn_CancelIo
+static BOOL WINAPI (*CancelIo) (HANDLE);
+
/* Open up a real live device for serial I/O. */
static int
scb->current_timeout = 0;
if (SetCommState (h, &state) == 0)
- warning (_("SetCommState failed\n"));
+ warning (_("SetCommState failed"));
}
static int
{
struct ser_windows_state *state;
- /* Stop any pending selects. */
- CancelIo ((HANDLE) _get_osfhandle (scb->fd));
+ /* Stop any pending selects. On Windows 95 OS, CancelIo function does
+ not exist. In that case, it can be replaced by a call to CloseHandle,
+ but this is not necessary here as we do close the Windows handle
+ by calling close (scb->fd) below. */
+ if (CancelIo)
+ CancelIo ((HANDLE) _get_osfhandle (scb->fd));
state = scb->state;
CloseHandle (state->ov.hEvent);
CloseHandle (state->except_event);
the started state. */
HANDLE start_select;
/* Signaled by the main program to tell the select thread to enter
- the stopped state. */
+ the stopped state. */
HANDLE stop_select;
/* Signaled by the main program to tell the select thread to
exit. */
/* Create a new select thread for SCB executing THREAD_FN. The STATE
will be filled in by this function before return. */
-void
+static void
create_select_thread (thread_fn_type thread_fn,
struct serial *scb,
struct ser_console_state *state)
wait_events[0] = state->stop_select;
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
|| WaitForSingleObject (state->stop_select, 0) == WAIT_OBJECT_0)
{
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);
else
SetEvent (state->read_event);
if (isatty (scb->fd))
{
struct ser_console_ttystate *state;
+
state = (struct ser_console_ttystate *) xmalloc (sizeof *state);
state->is_a_tty = 1;
return state;
static struct pipe_state *
make_pipe_state (void)
{
- struct pipe_state *ps = XMALLOC (struct pipe_state);
+ struct pipe_state *ps = XNEW (struct pipe_state);
memset (ps, 0, sizeof (*ps));
ps->wait.read_event = INVALID_HANDLE_VALUE;
if (ps->input)
fclose (ps->input);
if (ps->pex)
- pex_free (ps->pex);
- /* pex_free closes ps->output. */
+ {
+ pex_free (ps->pex);
+ /* pex_free closes ps->output. */
+ }
+ else if (ps->output)
+ fclose (ps->output);
xfree (ps);
back_to = make_cleanup_freeargv (argv);
if (! argv[0] || argv[0][0] == '\0')
- error ("missing child command");
+ error (_("missing child command"));
ps = make_pipe_state ();
make_cleanup (cleanup_pipe_state, ps);
all the same information here, plus err_msg provided by
pex_run, so we just raise the error here. */
if (err)
- error ("error starting child process '%s': %s: %s",
+ error (_("error starting child process '%s': %s: %s"),
name, err_msg, safe_strerror (err));
else
- error ("error starting child process '%s': %s",
+ error (_("error starting child process '%s': %s"),
name, err_msg);
}
}
return -1;
}
+static int
+pipe_windows_fdopen (struct serial *scb, int fd)
+{
+ struct pipe_state *ps;
+
+ ps = make_pipe_state ();
+
+ ps->input = fdopen (fd, "r+");
+ if (! ps->input)
+ goto fail;
+
+ ps->output = fdopen (fd, "r+");
+ if (! ps->output)
+ goto fail;
+
+ scb->fd = fd;
+ scb->state = (void *) ps;
+
+ return 0;
+
+ fail:
+ free_pipe_state (ps);
+ return -1;
+}
static void
pipe_windows_close (struct serial *scb)
HANDLE h = (HANDLE) _get_osfhandle (fd);
DWORD numBytes;
BOOL r = PeekNamedPipe (h, NULL, 0, NULL, &numBytes, NULL);
+
if (r == FALSE)
numBytes = 0;
return numBytes;
}
+int
+gdb_pipe (int pdes[2])
+{
+ if (_pipe (pdes, 512, _O_BINARY | _O_NOINHERIT) == -1)
+ return -1;
+ return 0;
+}
+
struct net_windows_state
{
struct ser_console_state base;
net_close (scb);
}
+/* The serial port driver. */
+
+static const struct serial_ops hardwire_ops =
+{
+ "hardwire",
+ ser_windows_open,
+ ser_windows_close,
+ NULL,
+ ser_base_readchar,
+ ser_base_write,
+ ser_windows_flush_output,
+ ser_windows_flush_input,
+ ser_windows_send_break,
+ ser_windows_raw,
+ /* These are only used for stdin; we do not need them for serial
+ ports, so supply the standard dummies. */
+ ser_base_get_tty_state,
+ ser_base_copy_tty_state,
+ ser_base_set_tty_state,
+ ser_base_print_tty_state,
+ ser_base_noflush_set_tty_state,
+ ser_windows_setbaudrate,
+ ser_windows_setstopbits,
+ ser_windows_drain_output,
+ ser_base_async,
+ ser_windows_read_prim,
+ ser_windows_write_prim,
+ NULL,
+ ser_windows_wait_handle
+};
+
+/* The dummy serial driver used for terminals. We only provide the
+ TTY-related methods. */
+
+static const struct serial_ops tty_ops =
+{
+ "terminal",
+ NULL,
+ ser_console_close,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ ser_console_get_tty_state,
+ ser_base_copy_tty_state,
+ ser_base_set_tty_state,
+ ser_base_print_tty_state,
+ ser_base_noflush_set_tty_state,
+ NULL,
+ NULL,
+ ser_base_drain_output,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ ser_console_wait_handle,
+ ser_console_done_wait_handle
+};
+
+/* The pipe interface. */
+
+static const struct serial_ops pipe_ops =
+{
+ "pipe",
+ pipe_windows_open,
+ pipe_windows_close,
+ pipe_windows_fdopen,
+ ser_base_readchar,
+ ser_base_write,
+ ser_base_flush_output,
+ ser_base_flush_input,
+ ser_base_send_break,
+ ser_base_raw,
+ ser_base_get_tty_state,
+ ser_base_copy_tty_state,
+ ser_base_set_tty_state,
+ ser_base_print_tty_state,
+ ser_base_noflush_set_tty_state,
+ ser_base_setbaudrate,
+ ser_base_setstopbits,
+ ser_base_drain_output,
+ ser_base_async,
+ pipe_windows_read,
+ pipe_windows_write,
+ pipe_avail,
+ pipe_wait_handle,
+ pipe_done_wait_handle
+};
+
+/* The TCP/UDP socket driver. */
+
+static const struct serial_ops tcp_ops =
+{
+ "tcp",
+ net_windows_open,
+ net_windows_close,
+ NULL,
+ ser_base_readchar,
+ ser_base_write,
+ ser_base_flush_output,
+ ser_base_flush_input,
+ ser_tcp_send_break,
+ ser_base_raw,
+ ser_base_get_tty_state,
+ ser_base_copy_tty_state,
+ ser_base_set_tty_state,
+ ser_base_print_tty_state,
+ ser_base_noflush_set_tty_state,
+ ser_base_setbaudrate,
+ ser_base_setstopbits,
+ ser_base_drain_output,
+ ser_base_async,
+ net_read_prim,
+ net_write_prim,
+ NULL,
+ net_windows_wait_handle,
+ net_windows_done_wait_handle
+};
+
void
_initialize_ser_windows (void)
{
WSADATA wsa_data;
struct serial_ops *ops;
- /* First register the serial port driver. */
-
- ops = XMALLOC (struct serial_ops);
- memset (ops, 0, sizeof (struct serial_ops));
- ops->name = "hardwire";
- ops->next = 0;
- ops->open = ser_windows_open;
- ops->close = ser_windows_close;
+ HMODULE hm = NULL;
- ops->flush_output = ser_windows_flush_output;
- ops->flush_input = ser_windows_flush_input;
- ops->send_break = ser_windows_send_break;
+ /* First find out if kernel32 exports CancelIo function. */
+ hm = LoadLibrary ("kernel32.dll");
+ if (hm)
+ {
+ CancelIo = (void *) GetProcAddress (hm, "CancelIo");
+ FreeLibrary (hm);
+ }
+ else
+ CancelIo = NULL;
- /* These are only used for stdin; we do not need them for serial
- ports, so supply the standard dummies. */
- ops->get_tty_state = ser_base_get_tty_state;
- ops->set_tty_state = ser_base_set_tty_state;
- ops->print_tty_state = ser_base_print_tty_state;
- ops->noflush_set_tty_state = ser_base_noflush_set_tty_state;
-
- ops->go_raw = ser_windows_raw;
- ops->setbaudrate = ser_windows_setbaudrate;
- ops->setstopbits = ser_windows_setstopbits;
- ops->drain_output = ser_windows_drain_output;
- ops->readchar = ser_base_readchar;
- ops->write = ser_base_write;
- ops->async = ser_base_async;
- ops->read_prim = ser_windows_read_prim;
- ops->write_prim = ser_windows_write_prim;
- ops->wait_handle = ser_windows_wait_handle;
-
- serial_add_interface (ops);
-
- /* Next create the dummy serial driver used for terminals. We only
- provide the TTY-related methods. */
-
- ops = XMALLOC (struct serial_ops);
- memset (ops, 0, sizeof (struct serial_ops));
-
- ops->name = "terminal";
- ops->next = 0;
-
- ops->close = ser_console_close;
- ops->get_tty_state = ser_console_get_tty_state;
- ops->set_tty_state = ser_base_set_tty_state;
- ops->print_tty_state = ser_base_print_tty_state;
- ops->noflush_set_tty_state = ser_base_noflush_set_tty_state;
- ops->drain_output = ser_base_drain_output;
- ops->wait_handle = ser_console_wait_handle;
- ops->done_wait_handle = ser_console_done_wait_handle;
-
- serial_add_interface (ops);
-
- /* The pipe interface. */
-
- ops = XMALLOC (struct serial_ops);
- memset (ops, 0, sizeof (struct serial_ops));
- ops->name = "pipe";
- ops->next = 0;
- ops->open = pipe_windows_open;
- ops->close = pipe_windows_close;
- ops->readchar = ser_base_readchar;
- ops->write = ser_base_write;
- ops->flush_output = ser_base_flush_output;
- ops->flush_input = ser_base_flush_input;
- ops->send_break = ser_base_send_break;
- ops->go_raw = ser_base_raw;
- ops->get_tty_state = ser_base_get_tty_state;
- ops->set_tty_state = ser_base_set_tty_state;
- ops->print_tty_state = ser_base_print_tty_state;
- ops->noflush_set_tty_state = ser_base_noflush_set_tty_state;
- ops->setbaudrate = ser_base_setbaudrate;
- ops->setstopbits = ser_base_setstopbits;
- ops->drain_output = ser_base_drain_output;
- ops->async = ser_base_async;
- ops->read_prim = pipe_windows_read;
- ops->write_prim = pipe_windows_write;
- ops->wait_handle = pipe_wait_handle;
- ops->done_wait_handle = pipe_done_wait_handle;
- ops->avail = pipe_avail;
-
- serial_add_interface (ops);
+ serial_add_interface (&hardwire_ops);
+ serial_add_interface (&tty_ops);
+ serial_add_interface (&pipe_ops);
/* If WinSock works, register the TCP/UDP socket driver. */
/* WinSock is unavailable. */
return;
- ops = XMALLOC (struct serial_ops);
- memset (ops, 0, sizeof (struct serial_ops));
- ops->name = "tcp";
- ops->next = 0;
- ops->open = net_windows_open;
- ops->close = net_windows_close;
- ops->readchar = ser_base_readchar;
- ops->write = ser_base_write;
- ops->flush_output = ser_base_flush_output;
- ops->flush_input = ser_base_flush_input;
- ops->send_break = ser_tcp_send_break;
- ops->go_raw = ser_base_raw;
- ops->get_tty_state = ser_base_get_tty_state;
- ops->set_tty_state = ser_base_set_tty_state;
- ops->print_tty_state = ser_base_print_tty_state;
- ops->noflush_set_tty_state = ser_base_noflush_set_tty_state;
- ops->setbaudrate = ser_base_setbaudrate;
- ops->setstopbits = ser_base_setstopbits;
- ops->drain_output = ser_base_drain_output;
- ops->async = ser_base_async;
- ops->read_prim = net_read_prim;
- ops->write_prim = net_write_prim;
- ops->wait_handle = net_windows_wait_handle;
- ops->done_wait_handle = net_windows_done_wait_handle;
- serial_add_interface (ops);
+ serial_add_interface (&tcp_ops);
}
projects / deliverable / binutils-gdb.git / blobdiff