X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fser-tcp.c;h=cecdfb2626bb735442bcc1be72e4e5230f55b7de;hb=57d87c09a33acdce280f4c9ae4f55b885a5cee99;hp=de8c4283744afbc89bf687f7be09d2b0e07eb825;hpb=98bbd631ccdf061b430ff2699ed82b92933ae937;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/ser-tcp.c b/gdb/ser-tcp.c index de8c428374..cecdfb2626 100644 --- a/gdb/ser-tcp.c +++ b/gdb/ser-tcp.c @@ -1,12 +1,12 @@ -/* Serial interface for raw TCP connections on Un*x like systems - Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2001 - Free Software Foundation, Inc. +/* Serial interface for raw TCP connections on Un*x like systems. + + Copyright (C) 1992-2020 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, @@ -15,216 +15,495 @@ 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 . */ #include "defs.h" #include "serial.h" -#include "ser-unix.h" +#include "ser-base.h" +#include "ser-tcp.h" +#include "gdbcmd.h" +#include "cli/cli-decode.h" +#include "cli/cli-setshow.h" +#include "gdbsupport/filestuff.h" +#include "gdbsupport/netstuff.h" #include #ifdef HAVE_SYS_FILIO_H -#include /* For FIONBIO. */ +#include /* For FIONBIO. */ #endif #ifdef HAVE_SYS_IOCTL_H -#include /* For FIONBIO. */ +#include /* For FIONBIO. */ #endif -#include +#include "gdbsupport/gdb_sys_time.h" + +#ifdef USE_WIN32API +#include +#ifndef ETIMEDOUT +#define ETIMEDOUT WSAETIMEDOUT +#endif +/* Gnulib defines close too, but gnulib's replacement + doesn't call closesocket unless we import the + socketlib module. */ +#undef close +#define close(fd) closesocket (fd) +#define ioctl ioctlsocket +#else #include #include #include #include #include +#endif #include -#include "gdb_string.h" +#include "gdb_select.h" +#include + +#ifndef HAVE_SOCKLEN_T +typedef int socklen_t; +#endif + +/* For "set tcp" and "show tcp". */ + +static struct cmd_list_element *tcp_set_cmdlist; +static struct cmd_list_element *tcp_show_cmdlist; -static int net_open (struct serial *scb, const char *name); -static void net_close (struct serial *scb); -void _initialize_ser_tcp (void); +/* Whether to auto-retry refused connections. */ -/* seconds to wait for connect */ -#define TIMEOUT 15 -/* how many times per second to poll deprecated_ui_loop_hook */ -#define POLL_INTERVAL 2 +static bool tcp_auto_retry = true; -/* Open a tcp socket */ +/* Timeout period for connections, in seconds. */ + +static unsigned int tcp_retry_limit = 15; + +/* How many times per second to poll deprecated_ui_loop_hook. */ + +#define POLL_INTERVAL 5 + +/* Helper function to wait a while. If SOCK is not -1, 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 -net_open (struct serial *scb, const char *name) +wait_for_connect (int sock, unsigned int *polls) { - char *port_str, hostname[100]; - int n, port, tmp; - int use_udp; - struct hostent *hostent; - struct sockaddr_in sockaddr; - - use_udp = 0; - if (strncmp (name, "udp:", 4) == 0) + struct timeval t; + int n; + + /* 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)) { - use_udp = 1; - name = name + 4; + errno = EINTR; + return -1; } - else if (strncmp (name, "tcp:", 4) == 0) - name = name + 4; - port_str = strchr (name, ':'); + /* Check for timeout. */ + if (*polls > tcp_retry_limit * POLL_INTERVAL) + { + errno = ETIMEDOUT; + return -1; + } - if (!port_str) - error ("net_open: No colon in host name!"); /* Shouldn't ever happen */ + /* 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; + } - 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 (sock >= 0) + { + fd_set rset, wset, eset; - /* default hostname is localhost */ - if (!hostname[0]) - strcpy (hostname, "localhost"); + FD_ZERO (&rset); + FD_SET (sock, &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 (sock + 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; +} - hostent = gethostbyname (hostname); - if (!hostent) +/* Try to connect to the host represented by AINFO. If the connection + succeeds, return its socket. Otherwise, return -1 and set ERRNO + accordingly. POLLS is used when 'connect' returns EINPROGRESS, and + we need to invoke 'wait_for_connect' to obtain the status. */ + +static int +try_connect (const struct addrinfo *ainfo, unsigned int *polls) +{ + int sock = gdb_socket_cloexec (ainfo->ai_family, ainfo->ai_socktype, + ainfo->ai_protocol); + + if (sock < 0) + return -1; + + /* Set socket nonblocking. */ +#ifdef USE_WIN32API + u_long ioarg = 1; +#else + int ioarg = 1; +#endif + + ioctl (sock, FIONBIO, &ioarg); + + /* Use Non-blocking connect. connect() will return 0 if connected + already. */ + if (connect (sock, ainfo->ai_addr, ainfo->ai_addrlen) < 0) { - fprintf_unfiltered (gdb_stderr, "%s: unknown host\n", hostname); - errno = ENOENT; +#ifdef USE_WIN32API + int err = WSAGetLastError(); +#else + int err = errno; +#endif + + /* If we've got a "connection refused" error, just return + -1. The caller will know what to do. */ + if ( +#ifdef USE_WIN32API + err == WSAECONNREFUSED +#else + err == ECONNREFUSED +#endif + ) + { + close (sock); + errno = err; + return -1; + } + + if ( + /* Any other error (except EINPROGRESS) will be "swallowed" + here. We return without specifying a return value, and + set errno if the caller wants to inspect what + happened. */ +#ifdef USE_WIN32API + /* Under Windows, calling "connect" with a non-blocking socket + results in WSAEWOULDBLOCK, not WSAEINPROGRESS. */ + err != WSAEWOULDBLOCK +#else + err != EINPROGRESS +#endif + ) + { + close (sock); + errno = err; + return -1; + } + + /* Looks like we need to wait for the connect. */ + int n; + + do + n = wait_for_connect (sock, polls); + while (n == 0); + + if (n < 0) + { + int saved_errno = errno; + + /* A negative value here means that we either timed out or + got interrupted by the user. Just return. */ + close (sock); + errno = saved_errno; + return -1; + } + } + + /* Got something. Is it an error? */ + int err; + socklen_t len = sizeof (err); + + /* On Windows, the fourth parameter to getsockopt is a "char *"; + on UNIX systems it is generally "void *". The cast to "char *" + is OK everywhere, since in C++ any data pointer type can be + implicitly converted to "void *". */ + int ret = getsockopt (sock, SOL_SOCKET, SO_ERROR, (char *) &err, &len); + + if (ret < 0) + { + int saved_errno = errno; + + close (sock); + errno = saved_errno; + return -1; + } + else if (ret == 0 && err != 0) + { + close (sock); + errno = err; return -1; } - if (use_udp) - scb->fd = socket (PF_INET, SOCK_DGRAM, 0); - else - scb->fd = socket (PF_INET, SOCK_STREAM, 0); + /* The connection succeeded. Return the socket. */ + return sock; +} - if (scb->fd < 0) - return -1; - - sockaddr.sin_family = PF_INET; - sockaddr.sin_port = htons (port); - memcpy (&sockaddr.sin_addr.s_addr, hostent->h_addr, - sizeof (struct in_addr)); +/* Open a tcp socket. */ + +int +net_open (struct serial *scb, const char *name) +{ + struct addrinfo hint; + struct addrinfo *ainfo; - /* set socket nonblocking */ - tmp = 1; - ioctl (scb->fd, FIONBIO, &tmp); + memset (&hint, 0, sizeof (hint)); + /* Assume no prefix will be passed, therefore we should use + AF_UNSPEC. */ + hint.ai_family = AF_UNSPEC; + hint.ai_socktype = SOCK_STREAM; + hint.ai_protocol = IPPROTO_TCP; - /* Use Non-blocking connect. connect() will return 0 if connected already. */ - n = connect (scb->fd, (struct sockaddr *) &sockaddr, sizeof (sockaddr)); + parsed_connection_spec parsed = parse_connection_spec (name, &hint); - if (n < 0 && errno != EINPROGRESS) + if (parsed.port_str.empty ()) + error (_("Missing port on hostname '%s'"), name); + + int r = getaddrinfo (parsed.host_str.c_str (), + parsed.port_str.c_str (), + &hint, &ainfo); + + if (r != 0) { - net_close (scb); + fprintf_unfiltered (gdb_stderr, _("%s: cannot resolve name: %s\n"), + name, gai_strerror (r)); + errno = ENOENT; return -1; } - if (n) + scoped_free_addrinfo free_ainfo (ainfo); + + /* Flag to indicate whether we've got a connection refused. It will + be true if any of the connections tried was refused. */ + bool got_connrefused; + /* If a connection succeeds, SUCCESS_AINFO will point to the + 'struct addrinfo' that succeed. */ + struct addrinfo *success_ainfo = NULL; + unsigned int polls = 0; + + /* Assume the worst. */ + scb->fd = -1; + + do { - /* looks like we need to wait for the connect */ - struct timeval t; - fd_set rset, wset; - int polls = 0; - FD_ZERO (&rset); + got_connrefused = false; - do + for (addrinfo *iter = ainfo; iter != NULL; iter = iter->ai_next) { - /* 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) + /* Iterate over the list of possible addresses to connect + to. For each, we'll try to connect and see if it + succeeds. */ + int sock = try_connect (iter, &polls); + + if (sock >= 0) { - if (deprecated_ui_loop_hook (0)) - { - errno = EINTR; - net_close (scb); - return -1; - } + /* We've gotten a successful connection. Save its + 'struct addrinfo', the socket, and break. */ + success_ainfo = iter; + scb->fd = sock; + break; } - - FD_SET (scb->fd, &rset); - wset = rset; - t.tv_sec = 0; - t.tv_usec = 1000000 / POLL_INTERVAL; - - n = select (scb->fd + 1, &rset, &wset, NULL, &t); - polls++; - } - while (n == 0 && polls <= TIMEOUT * POLL_INTERVAL); - if (n < 0 || polls > TIMEOUT * POLL_INTERVAL) - { - if (polls > TIMEOUT * POLL_INTERVAL) - errno = ETIMEDOUT; - net_close (scb); - return -1; + else if ( +#ifdef USE_WIN32API + errno == WSAECONNREFUSED +#else + errno == ECONNREFUSED +#endif + ) + got_connrefused = true; } } + /* Just retry if: + + - tcp_auto_retry is true, and + - We haven't gotten a connection yet, and + - Any of our connection attempts returned with ECONNREFUSED, and + - wait_for_connect signals that we can keep going. */ + while (tcp_auto_retry + && success_ainfo == NULL + && got_connrefused + && wait_for_connect (-1, &polls) >= 0); + + if (success_ainfo == NULL) + { + net_close (scb); + return -1; + } - /* Got something. Is it an error? */ - { - int res, err, len; - len = sizeof(err); - res = getsockopt (scb->fd, SOL_SOCKET, SO_ERROR, &err, &len); - if (res < 0 || err) - { - if (err) - errno = err; - net_close (scb); - return -1; - } - } + /* Turn off nonblocking. */ +#ifdef USE_WIN32API + u_long ioarg = 0; +#else + int ioarg = 0; +#endif - /* turn off nonblocking */ - tmp = 0; - ioctl (scb->fd, FIONBIO, &tmp); + ioctl (scb->fd, FIONBIO, &ioarg); - if (use_udp == 0) + if (success_ainfo->ai_protocol == IPPROTO_TCP) { - /* Disable Nagle algorithm. Needed in some cases. */ - tmp = 1; + /* Disable Nagle algorithm. Needed in some cases. */ + int tmp = 1; + setsockopt (scb->fd, IPPROTO_TCP, TCP_NODELAY, - (char *)&tmp, sizeof (tmp)); + (char *) &tmp, sizeof (tmp)); } +#ifdef SIGPIPE /* If we don't do this, then GDB simply exits when the remote side dies. */ signal (SIGPIPE, SIG_IGN); +#endif return 0; } -static void +void net_close (struct serial *scb) { - if (scb->fd < 0) + if (scb->fd == -1) return; close (scb->fd); scb->fd = -1; } +int +net_read_prim (struct serial *scb, size_t count) +{ + /* 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, (char *) scb->buf, count, 0); +} + +int +net_write_prim (struct serial *scb, const void *buf, size_t count) +{ + /* On Windows, the second parameter to send is a "const char *"; on + UNIX systems it is generally "const void *". The cast to "const + char *" is OK everywhere, since in C++ any data pointer type can + be implicitly converted to "const void *". */ + return send (scb->fd, (const char *) buf, count, 0); +} + +int +ser_tcp_send_break (struct serial *scb) +{ + /* Send telnet IAC and BREAK characters. */ + return (serial_write (scb, "\377\363", 2)); +} + +/* Support for "set tcp" and "show tcp" commands. */ + +static void +set_tcp_cmd (const char *args, int from_tty) +{ + help_list (tcp_set_cmdlist, "set tcp ", all_commands, gdb_stdout); +} + +static void +show_tcp_cmd (const char *args, int from_tty) +{ + help_list (tcp_show_cmdlist, "show tcp ", all_commands, gdb_stdout); +} + +#ifndef USE_WIN32API + +/* The TCP ops. */ + +static const struct serial_ops tcp_ops = +{ + "tcp", + 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_setbaudrate, + ser_base_setstopbits, + ser_base_setparity, + ser_base_drain_output, + ser_base_async, + net_read_prim, + net_write_prim +}; + +#endif /* USE_WIN32API */ + void _initialize_ser_tcp (void) { - struct serial_ops *ops = XMALLOC (struct serial_ops); - memset (ops, 0, sizeof (struct serial_ops)); - ops->name = "tcp"; - ops->next = 0; - ops->open = net_open; - ops->close = net_close; - ops->readchar = ser_unix_readchar; - ops->write = ser_unix_write; - ops->flush_output = ser_unix_nop_flush_output; - ops->flush_input = ser_unix_flush_input; - ops->send_break = ser_unix_nop_send_break; - ops->go_raw = ser_unix_nop_raw; - ops->get_tty_state = ser_unix_nop_get_tty_state; - ops->set_tty_state = ser_unix_nop_set_tty_state; - ops->print_tty_state = ser_unix_nop_print_tty_state; - ops->noflush_set_tty_state = ser_unix_nop_noflush_set_tty_state; - ops->setbaudrate = ser_unix_nop_setbaudrate; - ops->setstopbits = ser_unix_nop_setstopbits; - ops->drain_output = ser_unix_nop_drain_output; - ops->async = ser_unix_async; - serial_add_interface (ops); +#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); }