-/* Serial interface for raw TCP connections on Un*x like systems
- Copyright 1992, 1993, 1998 Free Software Foundation, Inc.
+/* Serial interface for raw TCP connections on Un*x like systems.
+
+ Copyright (C) 1992-2014 Free Software Foundation, Inc.
This file is part of GDB.
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
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
#include "serial.h"
+#include "ser-base.h"
+#include "ser-tcp.h"
+#include "gdbcmd.h"
+#include "cli/cli-decode.h"
+#include "cli/cli-setshow.h"
+#include "filestuff.h"
+
#include <sys/types.h>
+
+#ifdef HAVE_SYS_FILIO_H
+#include <sys/filio.h> /* For FIONBIO. */
+#endif
+#ifdef HAVE_SYS_IOCTL_H
+#include <sys/ioctl.h> /* For FIONBIO. */
+#endif
+
#include <sys/time.h>
+
+#ifdef USE_WIN32API
+#include <winsock2.h>
+#ifndef ETIMEDOUT
+#define ETIMEDOUT WSAETIMEDOUT
+#endif
+#define close(fd) closesocket (fd)
+#define ioctl ioctlsocket
+#else
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <sys/socket.h>
-#ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-
-#ifndef __CYGWIN32__
#include <netinet/tcp.h>
#endif
-#include "signals.h"
-#include "gdb_string.h"
-
-extern int (*ui_loop_hook) PARAMS ((int));
-
-struct tcp_ttystate
- {
- int bogus;
- };
-
-static int tcp_open PARAMS ((serial_t scb, const char *name));
-static void tcp_raw PARAMS ((serial_t scb));
-static int wait_for PARAMS ((serial_t scb, int timeout));
-static int tcp_readchar PARAMS ((serial_t scb, int timeout));
-static int tcp_setbaudrate PARAMS ((serial_t scb, int rate));
-static int tcp_setstopbits PARAMS ((serial_t scb, int num));
-static int tcp_write PARAMS ((serial_t scb, const char *str, int len));
-/* FIXME: static void tcp_restore PARAMS ((serial_t scb)); */
-static void tcp_close PARAMS ((serial_t scb));
-static serial_ttystate tcp_get_tty_state PARAMS ((serial_t scb));
-static int tcp_set_tty_state PARAMS ((serial_t scb, serial_ttystate state));
-static int tcp_return_0 PARAMS ((serial_t));
-static int tcp_noflush_set_tty_state PARAMS ((serial_t, serial_ttystate,
- serial_ttystate));
-static void tcp_print_tty_state PARAMS ((serial_t, serial_ttystate));
-
-void _initialize_ser_tcp PARAMS ((void));
-
-/* Open up a raw tcp socket */
-
-static int
-tcp_open (scb, name)
- serial_t scb;
- const char *name;
-{
- char *port_str;
- int port;
- struct hostent *hostent;
- struct sockaddr_in sockaddr;
- int tmp;
- char hostname[100];
- struct protoent *protoent;
- int i;
-
- port_str = strchr (name, ':');
-
- if (!port_str)
- error ("tcp_open: No colon in host name!"); /* Shouldn't ever happen */
-
- tmp = min (port_str - name, (int) sizeof hostname - 1);
- strncpy (hostname, name, tmp); /* Don't want colon */
- hostname[tmp] = '\000'; /* Tie off host name */
- port = atoi (port_str + 1);
-
- hostent = gethostbyname (hostname);
-
- if (!hostent)
- {
- fprintf_unfiltered (gdb_stderr, "%s: unknown host\n", hostname);
- errno = ENOENT;
- return -1;
- }
-
- for (i = 1; i <= 15; i++)
- {
- scb->fd = socket (PF_INET, SOCK_STREAM, 0);
- if (scb->fd < 0)
- return -1;
-
- /* Allow rapid reuse of this port. */
- tmp = 1;
- setsockopt (scb->fd, SOL_SOCKET, SO_REUSEADDR, (char *) &tmp, sizeof (tmp));
-
- /* Enable TCP keep alive process. */
- tmp = 1;
- setsockopt (scb->fd, SOL_SOCKET, SO_KEEPALIVE, (char *) &tmp, sizeof (tmp));
-
- sockaddr.sin_family = PF_INET;
- sockaddr.sin_port = htons (port);
- memcpy (&sockaddr.sin_addr.s_addr, hostent->h_addr,
- sizeof (struct in_addr));
-
- if (!connect (scb->fd, (struct sockaddr *) &sockaddr, sizeof (sockaddr)))
- break;
+#include <signal.h>
+#include <string.h>
+#include "gdb_select.h"
- close (scb->fd);
- scb->fd = -1;
+#ifndef HAVE_SOCKLEN_T
+typedef int socklen_t;
+#endif
-/* We retry for ECONNREFUSED because that is often a temporary condition, which
- happens when the server is being restarted. */
+void _initialize_ser_tcp (void);
- if (errno != ECONNREFUSED)
- return -1;
+/* For "set tcp" and "show tcp". */
- sleep (1);
- }
+static struct cmd_list_element *tcp_set_cmdlist;
+static struct cmd_list_element *tcp_show_cmdlist;
- protoent = getprotobyname ("tcp");
- if (!protoent)
- return -1;
+/* Whether to auto-retry refused connections. */
- tmp = 1;
- if (setsockopt (scb->fd, protoent->p_proto, TCP_NODELAY,
- (char *) &tmp, sizeof (tmp)))
- return -1;
+static int tcp_auto_retry = 1;
- signal (SIGPIPE, SIG_IGN); /* If we don't do this, then GDB simply exits
- when the remote side dies. */
+/* Timeout period for connections, in seconds. */
- return 0;
-}
+static unsigned int tcp_retry_limit = 15;
-static serial_ttystate
-tcp_get_tty_state (scb)
- serial_t scb;
-{
- struct tcp_ttystate *state;
+/* How many times per second to poll deprecated_ui_loop_hook. */
- state = (struct tcp_ttystate *) xmalloc (sizeof *state);
+#define POLL_INTERVAL 5
- return (serial_ttystate) state;
-}
+/* Helper function to wait a while. If SCB is non-null, wait on its
+ file descriptor. Otherwise just wait on a timeout, updating *POLLS.
+ Returns -1 on timeout or interrupt, otherwise the value of select. */
static int
-tcp_set_tty_state (scb, ttystate)
- serial_t scb;
- serial_ttystate ttystate;
+wait_for_connect (struct serial *scb, unsigned int *polls)
{
- struct tcp_ttystate *state;
+ struct timeval t;
+ int n;
- state = (struct tcp_ttystate *) ttystate;
+ /* While we wait for the connect to complete,
+ poll the UI so it can update or the user can
+ interrupt. */
+ if (deprecated_ui_loop_hook && deprecated_ui_loop_hook (0))
+ {
+ errno = EINTR;
+ return -1;
+ }
- return 0;
-}
+ /* Check for timeout. */
+ if (*polls > tcp_retry_limit * POLL_INTERVAL)
+ {
+ errno = ETIMEDOUT;
+ return -1;
+ }
-static int
-tcp_return_0 (scb)
- serial_t scb;
-{
- return 0;
-}
+ /* Back off to polling once per second after the first POLL_INTERVAL
+ polls. */
+ if (*polls < POLL_INTERVAL)
+ {
+ t.tv_sec = 0;
+ t.tv_usec = 1000000 / POLL_INTERVAL;
+ }
+ else
+ {
+ t.tv_sec = 1;
+ t.tv_usec = 0;
+ }
-static void
-tcp_raw (scb)
- serial_t scb;
-{
- return; /* Always in raw mode */
+ if (scb)
+ {
+ fd_set rset, wset, eset;
+
+ FD_ZERO (&rset);
+ FD_SET (scb->fd, &rset);
+ wset = rset;
+ eset = rset;
+
+ /* POSIX systems return connection success or failure by signalling
+ wset. Windows systems return success in wset and failure in
+ eset.
+
+ We must call select here, rather than gdb_select, because
+ the serial structure has not yet been initialized - the
+ MinGW select wrapper will not know that this FD refers
+ to a socket. */
+ n = select (scb->fd + 1, &rset, &wset, &eset, &t);
+ }
+ else
+ /* Use gdb_select here, since we have no file descriptors, and on
+ Windows, plain select doesn't work in that case. */
+ n = gdb_select (0, NULL, NULL, NULL, &t);
+
+ /* If we didn't time out, only count it as one poll. */
+ if (n > 0 || *polls < POLL_INTERVAL)
+ (*polls)++;
+ else
+ (*polls) += POLL_INTERVAL;
+
+ return n;
}
-/* Wait for input on scb, with timeout seconds. Returns 0 on success,
- otherwise SERIAL_TIMEOUT or SERIAL_ERROR.
-
- For termio{s}, we actually just setup VTIME if necessary, and let the
- timeout occur in the read() in tcp_read().
- */
+/* Open a tcp socket. */
-static int
-wait_for (scb, timeout)
- serial_t scb;
- int timeout;
+int
+net_open (struct serial *scb, const char *name)
{
- int numfds;
- struct timeval tv;
- fd_set readfds, exceptfds;
+ char *port_str, hostname[100];
+ int n, port, tmp;
+ int use_udp;
+ struct hostent *hostent;
+ struct sockaddr_in sockaddr;
+#ifdef USE_WIN32API
+ u_long ioarg;
+#else
+ int ioarg;
+#endif
+ unsigned int polls = 0;
- FD_ZERO (&readfds);
- FD_ZERO (&exceptfds);
+ use_udp = 0;
+ if (strncmp (name, "udp:", 4) == 0)
+ {
+ use_udp = 1;
+ name = name + 4;
+ }
+ else if (strncmp (name, "tcp:", 4) == 0)
+ name = name + 4;
- tv.tv_sec = timeout;
- tv.tv_usec = 0;
+ port_str = strchr (name, ':');
- FD_SET (scb->fd, &readfds);
- FD_SET (scb->fd, &exceptfds);
+ if (!port_str)
+ error (_("net_open: No colon in host name!")); /* Shouldn't ever
+ happen. */
- while (1)
- {
- if (timeout >= 0)
- numfds = select (scb->fd + 1, &readfds, 0, &exceptfds, &tv);
- else
- numfds = select (scb->fd + 1, &readfds, 0, &exceptfds, 0);
+ tmp = min (port_str - name, (int) sizeof hostname - 1);
+ strncpy (hostname, name, tmp); /* Don't want colon. */
+ hostname[tmp] = '\000'; /* Tie off host name. */
+ port = atoi (port_str + 1);
- if (numfds <= 0)
- {
- if (numfds == 0)
- return SERIAL_TIMEOUT;
- else if (errno == EINTR)
- continue;
- else
- return SERIAL_ERROR; /* Got an error from select or poll */
- }
+ /* Default hostname is localhost. */
+ if (!hostname[0])
+ strcpy (hostname, "localhost");
- return 0;
+ hostent = gethostbyname (hostname);
+ if (!hostent)
+ {
+ fprintf_unfiltered (gdb_stderr, "%s: unknown host\n", hostname);
+ errno = ENOENT;
+ return -1;
}
-}
-/* Read a character with user-specified timeout. TIMEOUT is number of seconds
- to wait, or -1 to wait forever. Use timeout of 0 to effect a poll. Returns
- char if successful. Returns -2 if timeout expired, EOF if line dropped
- dead, or -3 for any other error (see errno in that case). */
+ sockaddr.sin_family = PF_INET;
+ sockaddr.sin_port = htons (port);
+ memcpy (&sockaddr.sin_addr.s_addr, hostent->h_addr,
+ sizeof (struct in_addr));
-static int
-tcp_readchar (scb, timeout)
- serial_t scb;
- int timeout;
-{
- int status;
- int delta;
+ retry:
- if (scb->bufcnt-- > 0)
- return *scb->bufp++;
+ if (use_udp)
+ scb->fd = gdb_socket_cloexec (PF_INET, SOCK_DGRAM, 0);
+ else
+ scb->fd = gdb_socket_cloexec (PF_INET, SOCK_STREAM, 0);
- /* We have to be able to keep the GUI alive here, so we break the original
- timeout into steps of 1 second, running the "keep the GUI alive" hook
- each time through the loop.
+ if (scb->fd == -1)
+ return -1;
+
+ /* Set socket nonblocking. */
+ ioarg = 1;
+ ioctl (scb->fd, FIONBIO, &ioarg);
- Also, timeout = 0 means to poll, so we just set the delta to 0, so we
- will only go through the loop once. */
+ /* Use Non-blocking connect. connect() will return 0 if connected
+ already. */
+ n = connect (scb->fd, (struct sockaddr *) &sockaddr, sizeof (sockaddr));
- delta = (timeout == 0 ? 0 : 1);
- while (1)
+ if (n < 0)
{
+#ifdef USE_WIN32API
+ int err = WSAGetLastError();
+#else
+ int err = errno;
+#endif
- /* N.B. The UI may destroy our world (for instance by calling
- remote_stop,) in which case we want to get out of here as
- quickly as possible. It is not safe to touch scb, since
- someone else might have freed it. The ui_loop_hook signals that
- we should exit by returning 1. */
-
- if (ui_loop_hook)
+ /* Maybe we're waiting for the remote target to become ready to
+ accept connections. */
+ if (tcp_auto_retry
+#ifdef USE_WIN32API
+ && err == WSAECONNREFUSED
+#else
+ && err == ECONNREFUSED
+#endif
+ && wait_for_connect (NULL, &polls) >= 0)
{
- if (ui_loop_hook (0))
- return SERIAL_TIMEOUT;
+ close (scb->fd);
+ goto retry;
}
- status = wait_for (scb, delta);
- timeout -= delta;
-
- /* If we got a character or an error back from wait_for, then we can
- break from the loop before the timeout is completed. */
-
- if (status != SERIAL_TIMEOUT)
+ if (
+#ifdef USE_WIN32API
+ /* Under Windows, calling "connect" with a non-blocking socket
+ results in WSAEWOULDBLOCK, not WSAEINPROGRESS. */
+ err != WSAEWOULDBLOCK
+#else
+ err != EINPROGRESS
+#endif
+ )
{
- break;
+ errno = err;
+ net_close (scb);
+ return -1;
}
- /* If we have exhausted the original timeout, then generate
- a SERIAL_TIMEOUT, and pass it out of the loop. */
-
- else if (timeout == 0)
+ /* Looks like we need to wait for the connect. */
+ do
+ {
+ n = wait_for_connect (scb, &polls);
+ }
+ while (n == 0);
+ if (n < 0)
{
- status == SERIAL_TIMEOUT;
- break;
+ net_close (scb);
+ return -1;
}
}
- if (status < 0)
- return status;
+ /* Got something. Is it an error? */
+ {
+ int res, err;
+ socklen_t len;
+
+ len = sizeof (err);
+ /* On Windows, the fourth parameter to getsockopt is a "char *";
+ on UNIX systems it is generally "void *". The cast to "void *"
+ is OK everywhere, since in C "void *" can be implicitly
+ converted to any pointer type. */
+ res = getsockopt (scb->fd, SOL_SOCKET, SO_ERROR, (void *) &err, &len);
+ if (res < 0 || err)
+ {
+ /* Maybe the target still isn't ready to accept the connection. */
+ if (tcp_auto_retry
+#ifdef USE_WIN32API
+ && err == WSAECONNREFUSED
+#else
+ && err == ECONNREFUSED
+#endif
+ && wait_for_connect (NULL, &polls) >= 0)
+ {
+ close (scb->fd);
+ goto retry;
+ }
+ if (err)
+ errno = err;
+ net_close (scb);
+ return -1;
+ }
+ }
- while (1)
- {
- scb->bufcnt = read (scb->fd, scb->buf, BUFSIZ);
- if (scb->bufcnt != -1 || errno != EINTR)
- break;
- }
+ /* Turn off nonblocking. */
+ ioarg = 0;
+ ioctl (scb->fd, FIONBIO, &ioarg);
- if (scb->bufcnt <= 0)
+ if (use_udp == 0)
{
- if (scb->bufcnt == 0)
- return SERIAL_TIMEOUT; /* 0 chars means timeout [may need to
- distinguish between EOF & timeouts
- someday] */
- else
- return SERIAL_ERROR; /* Got an error from read */
+ /* Disable Nagle algorithm. Needed in some cases. */
+ tmp = 1;
+ setsockopt (scb->fd, IPPROTO_TCP, TCP_NODELAY,
+ (char *)&tmp, sizeof (tmp));
}
- scb->bufcnt--;
- scb->bufp = scb->buf;
- return *scb->bufp++;
-}
+#ifdef SIGPIPE
+ /* If we don't do this, then GDB simply exits
+ when the remote side dies. */
+ signal (SIGPIPE, SIG_IGN);
+#endif
-static int
-tcp_noflush_set_tty_state (scb, new_ttystate, old_ttystate)
- serial_t scb;
- serial_ttystate new_ttystate;
- serial_ttystate old_ttystate;
-{
return 0;
}
-static void
-tcp_print_tty_state (scb, ttystate)
- serial_t scb;
- serial_ttystate ttystate;
+void
+net_close (struct serial *scb)
{
- /* Nothing to print. */
- return;
+ if (scb->fd == -1)
+ return;
+
+ close (scb->fd);
+ scb->fd = -1;
}
-static int
-tcp_setbaudrate (scb, rate)
- serial_t scb;
- int rate;
+int
+net_read_prim (struct serial *scb, size_t count)
{
- return 0; /* Never fails! */
+ /* Need to cast to silence -Wpointer-sign on MinGW, as Winsock's
+ 'recv' takes 'char *' as second argument, while 'scb->buf' is
+ 'unsigned char *'. */
+ return recv (scb->fd, (void *) scb->buf, count, 0);
}
-static int
-tcp_setstopbits (scb, num)
- serial_t scb;
- int num;
+int
+net_write_prim (struct serial *scb, const void *buf, size_t count)
{
- return 0; /* Never fails! */
+ return send (scb->fd, buf, count, 0);
}
-static int
-tcp_write (scb, str, len)
- serial_t scb;
- const char *str;
- int len;
+int
+ser_tcp_send_break (struct serial *scb)
{
- int cc;
+ /* Send telnet IAC and BREAK characters. */
+ return (serial_write (scb, "\377\363", 2));
+}
- while (len > 0)
- {
- cc = write (scb->fd, str, len);
+/* Support for "set tcp" and "show tcp" commands. */
- if (cc < 0)
- return 1;
- len -= cc;
- str += cc;
- }
- return 0;
+static void
+set_tcp_cmd (char *args, int from_tty)
+{
+ help_list (tcp_set_cmdlist, "set tcp ", -1, gdb_stdout);
}
static void
-tcp_close (scb)
- serial_t scb;
+show_tcp_cmd (char *args, int from_tty)
{
- if (scb->fd < 0)
- return;
-
- close (scb->fd);
- scb->fd = -1;
+ help_list (tcp_show_cmdlist, "show tcp ", -1, gdb_stdout);
}
-static struct serial_ops tcp_ops =
+#ifndef USE_WIN32API
+
+/* The TCP ops. */
+
+static const struct serial_ops tcp_ops =
{
"tcp",
- 0,
- tcp_open,
- tcp_close,
- tcp_readchar,
- tcp_write,
- tcp_return_0, /* flush output */
- tcp_return_0, /* flush input */
- tcp_return_0, /* send break */
- tcp_raw,
- tcp_get_tty_state,
- tcp_set_tty_state,
- tcp_print_tty_state,
- tcp_noflush_set_tty_state,
- tcp_setbaudrate,
- tcp_setstopbits,
- tcp_return_0, /* wait for output to drain */
+ net_open,
+ net_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
};
+#endif /* USE_WIN32API */
+
void
-_initialize_ser_tcp ()
+_initialize_ser_tcp (void)
{
+#ifdef USE_WIN32API
+ /* Do nothing; the TCP serial operations will be initialized in
+ ser-mingw.c. */
+#else
serial_add_interface (&tcp_ops);
+#endif /* USE_WIN32API */
+
+ add_prefix_cmd ("tcp", class_maintenance, set_tcp_cmd, _("\
+TCP protocol specific variables\n\
+Configure variables specific to remote TCP connections"),
+ &tcp_set_cmdlist, "set tcp ",
+ 0 /* allow-unknown */, &setlist);
+ add_prefix_cmd ("tcp", class_maintenance, show_tcp_cmd, _("\
+TCP protocol specific variables\n\
+Configure variables specific to remote TCP connections"),
+ &tcp_show_cmdlist, "show tcp ",
+ 0 /* allow-unknown */, &showlist);
+
+ add_setshow_boolean_cmd ("auto-retry", class_obscure,
+ &tcp_auto_retry, _("\
+Set auto-retry on socket connect"), _("\
+Show auto-retry on socket connect"),
+ NULL, NULL, NULL,
+ &tcp_set_cmdlist, &tcp_show_cmdlist);
+
+ add_setshow_uinteger_cmd ("connect-timeout", class_obscure,
+ &tcp_retry_limit, _("\
+Set timeout limit in seconds for socket connection"), _("\
+Show timeout limit in seconds for socket connection"), _("\
+If set to \"unlimited\", GDB will keep attempting to establish a\n\
+connection forever, unless interrupted with Ctrl-c.\n\
+The default is 15 seconds."),
+ NULL, NULL,
+ &tcp_set_cmdlist, &tcp_show_cmdlist);
}
projects / deliverable / binutils-gdb.git / blobdiff