This is the mail archive of the
gdb-patches@sourceware.org
mailing list for the GDB project.
[PATCH v2] Implement IPv6 support for GDB/gdbserver
- From: Sergio Durigan Junior <sergiodj at redhat dot com>
- To: GDB Patches <gdb-patches at sourceware dot org>
- Cc: Pedro Alves <palves at redhat dot com>, Eli Zaretskii <eliz at gnu dot org>, Jan Kratochvil <jan dot kratochvil at redhat dot com>, Paul Fertser <fercerpav at gmail dot com>, Tsutomu Seki <sekiriki at gmail dot com>, Armand Scholtes <armandsmailings at home dot nl>, Sergio Durigan Junior <sergiodj at redhat dot com>
- Date: Thu, 14 Jun 2018 20:24:27 -0400
- Subject: [PATCH v2] Implement IPv6 support for GDB/gdbserver
- References: <20180523185719.22832-1-sergiodj@redhat.com>
Changes from v1:
- s/hostnames/addresses/ on NEWS.
- Simplify functions on netstuff.c. Add new defines for
GDB_NI_MAX_ADDR and GDB_NI_MAX_PORT. Make
parse_hostname_without_prefix return a struct parsed_hostname.
- Use AF_UNSPEC instead of AF_INET by default on unprefixed
connections.
- Simplify and modernize things on gdbreplay.c.
- Implement new GDB_TEST_SOCKETHOST mechanism for testing things with
any type of hostname/address.
- Simplify things on boards/*.exp because of the above.
- Rewrite net_open to support multiple sockets/connections with
timeout/retry.
- Improve IPv6 example on documentation.
This patch implements IPv6 support for both GDB and gdbserver. Based
on my research, it is the fourth attempt to do that since 2006. Since
I used ideas from all of the previous patches, I also added their
authors's names on the ChangeLogs as a way to recognize their
efforts. For reference sake, you can find the previous attempts at:
https://sourceware.org/ml/gdb-patches/2006-09/msg00192.html
https://sourceware.org/ml/gdb-patches/2014-02/msg00248.html
https://sourceware.org/ml/gdb-patches/2016-02/msg00226.html
The basic idea behind the patch is to start using the new
'getaddrinfo'/'getnameinfo' calls, which are responsible for
translating names and addresses in a protocol-independent way. This
means that if we ever have a new version of the IP protocol, we won't
need to change the code again.
The function 'getaddrinfo' returns a linked list of possible addresses
to connect to. Dealing with multiple addresses proved to be a hard
task with the current TCP auto-retry mechanism implemented on
ser-tcp:net_open. For example, when gdbserver listened only on an
IPv4 socket:
$ ./gdbserver --once 127.0.0.1:1234 ./a.out
and GDB was instructed to try to connect to both IPv6 and IPv4
sockets:
$ ./gdb -ex 'target extended-remote localhost:1234' ./a.out
the user would notice a somewhat big delay before GDB was able to
connect to the IPv4 socket. This happened because GDB was trying to
connect to the IPv6 socket first, and had to wait until the connection
timed out before it tried to connect to the IPv4 socket.
For that reason, I had to rewrite the main loop and implement a new
method for handling multiple connections. The main idea is:
1) We open sockets and perform 'connect's for all of the possible
addresses returned by 'getaddrinfo'.
2) If we have a successful 'connect', we just use that connection.
3) If we don't have a successfull 'connect', but if we've got a
EINPROGRESS (meaning that the connection is in progress), we add the
socket to a poll of sockets that are going to be handled later.
4) Once we finish iterating over the possible addresses, we perform
a 'select' on the poll of sockets that did not connect
successfully. We do that until we have a timeout/interrupt (in
which case we just bail out), or until 'select' gives us a set of
sockets that are ready to be handled.
5) We take the set of sockets returned by 'select' and check which
one doesn't have an error associated with it. If we find one, it
means a connection has succeeded and we just use it.
6) If we don't find any successful connections, we wait for a while,
check to see if there was a timeout/interruption (in which case we
bail out), and then go back to (1).
After multiple tests, I was able to connect without delay on the
scenario described above, and was also able to connect in all other
types of scenarios.
I also implemented some hostname parsing functions which are used to
help GDB and gdbserver to parse hostname strings provided by the user.
These new functions are living inside common/netstuff.[ch]. I've had
to do that since IPv6 introduces a new URL scheme, which defines that
square brackets can be used to enclose the host part and differentiate
it from the port (e.g., "[::1]:1234" means "host ::1, port 1234"). I
spent some time thinking about a reasonable way to interpret what the
user wants, and I came up with the following:
- If the user has provided a prefix that doesn't specify the protocol
version (i.e., "tcp:" or "udp:"), or if the user has not provided
any prefix, don't make any assumptions (i.e., assume AF_UNSPEC when
dealing with 'getaddrinfo') *unless* the host starts with "[" (in
which case, assume it's an IPv6 host).
- If the user has provided a prefix that does specify the protocol
version (i.e., "tcp4:", "tcp6:", "udp4:" or "udp6:"), then respect
that.
This method doesn't follow strictly what RFC 2732 proposes (that
literal IPv6 addresses should be provided enclosed in "[" and "]")
because IPv6 addresses still can be provided without square brackets
in our case, but since we have prefixes to specify protocol versions I
think this is not an issue.
Another thing worth mentioning is the new 'GDB_TEST_SOCKETHOST'
testcase parameter, which makes it possible to specify the
hostname (without the port) to be used when testing GDB and
gdbserver. For example, to run IPv6 tests:
$ make check-gdb RUNTESTFLAGS='GDB_TEST_SOCKETHOST=tcp6:[::1]'
Or, to run IPv4 tests:
$ make check-gdb RUNTESTFLAGS='GDB_TEST_SOCKETHOST=tcp4:127.0.0.1'
This required a few changes on the gdbserver-base.exp, and also a
minimal adjustment on gdb.server/run-without-local-binary.exp.
This patch has been regression-tested on BuildBot and locally, and
also built using a x86_64-w64-mingw32 GCC, and no problems were found.
gdb/ChangeLog:
yyyy-mm-dd Sergio Durigan Junior <sergiodj@redhat.com>
Jan Kratochvil <jan.kratochvil@redhat.com>
Paul Fertser <fercerpav@gmail.com>
Tsutomu Seki <sekiriki@gmail.com>
* Makefile.in (COMMON_SFILES): Add 'common/netstuff.c'.
(HFILES_NO_SRCDIR): Add 'common/netstuff.h'.
* NEWS (Changes since GDB 8.1): Mention IPv6 support.
* common/netstuff.c: New file.
* common/netstuff.h: New file.
* ser-tcp.c: Include 'netstuff.h' and 'wspiapi.h'.
(gdb_socket): New class.
(wait_for_connect): New parameters 'socket_poll' and
'sockets_ready'. Perform 'select' on sockets from
'socket_poll'.
(socket_error_p): New function.
(gdb_connect): New function, with code from 'net_open'.
(net_open): Rewrite main loop to deal with multiple
sockets/addresses. Handle IPv6-style hostnames; implement
support for IPv6 connections.
gdb/gdbserver/ChangeLog:
yyyy-mm-dd Sergio Durigan Junior <sergiodj@redhat.com>
Jan Kratochvil <jan.kratochvil@redhat.com>
Paul Fertser <fercerpav@gmail.com>
Tsutomu Seki <sekiriki@gmail.com>
* Makefile.in (SFILES): Add '$(srcdir)/common/netstuff.c'.
(OBS): Add 'common/netstuff.o'.
(GDBREPLAY_OBS): Likewise.
* gdbreplay.c: Include 'wspiapi.h' and 'netstuff.h'.
(remote_open): Implement support for IPv6
connections.
* remote-utils.c: Include 'netstuff.h', 'filestuff.h'
and 'wspiapi.h'.
(handle_accept_event): Accept connections from IPv6 sources.
(remote_prepare): Handle IPv6-style hostnames; implement
support for IPv6 connections.
(remote_open): Implement support for printing connections from
IPv6 sources.
gdb/testsuite/ChangeLog:
yyyy-mm-dd Sergio Durigan Junior <sergiodj@redhat.com>
Jan Kratochvil <jan.kratochvil@redhat.com>
Paul Fertser <fercerpav@gmail.com>
Tsutomu Seki <sekiriki@gmail.com>
* README (Testsuite Parameters): Mention new 'GDB_TEST_SOCKETHOST'
parameter.
* boards/native-extended-gdbserver.exp: Do not set 'sockethost'
by default.
* boards/native-gdbserver.exp: Likewise.
* gdb.server/run-without-local-binary.exp: Improve regexp used
for detecting when a remote debugging connection succeeds.
* lib/gdbserver-support.exp (gdbserver_default_get_comm_port):
Do not prefix the port number with ":".
(gdbserver_start): New global GDB_TEST_SOCKETHOST. Implement
support for detecting and using it. Add '$debughost_gdbserver'
to the list of arguments used to start gdbserver.
gdb/doc/ChangeLog:
yyyy-mm-dd Sergio Durigan Junior <sergiodj@redhat.com>
Jan Kratochvil <jan.kratochvil@redhat.com>
Paul Fertser <fercerpav@gmail.com>
Tsutomu Seki <sekiriki@gmail.com>
* gdb.texinfo (Remote Connection Commands): Add explanation
about new IPv6 support. Add new connection prefixes.
---
gdb/Makefile.in | 2 +
gdb/NEWS | 4 +
gdb/common/netstuff.c | 126 ++++++
gdb/common/netstuff.h | 76 ++++
gdb/doc/gdb.texinfo | 49 ++-
gdb/gdbserver/Makefile.in | 3 +
gdb/gdbserver/gdbreplay.c | 129 ++++--
gdb/gdbserver/remote-utils.c | 118 ++++--
gdb/ser-tcp.c | 446 ++++++++++++++-------
gdb/testsuite/README | 14 +
gdb/testsuite/boards/native-extended-gdbserver.exp | 2 -
gdb/testsuite/boards/native-gdbserver.exp | 1 -
.../gdb.server/run-without-local-binary.exp | 2 +-
gdb/testsuite/lib/gdbserver-support.exp | 25 +-
14 files changed, 784 insertions(+), 213 deletions(-)
create mode 100644 gdb/common/netstuff.c
create mode 100644 gdb/common/netstuff.h
diff --git a/gdb/Makefile.in b/gdb/Makefile.in
index 354a6361b7..81042c1988 100644
--- a/gdb/Makefile.in
+++ b/gdb/Makefile.in
@@ -963,6 +963,7 @@ COMMON_SFILES = \
common/job-control.c \
common/gdb_tilde_expand.c \
common/gdb_vecs.c \
+ common/netstuff.c \
common/new-op.c \
common/pathstuff.c \
common/print-utils.c \
@@ -1444,6 +1445,7 @@ HFILES_NO_SRCDIR = \
common/gdb_vecs.h \
common/gdb_wait.h \
common/common-inferior.h \
+ common/netstuff.h \
common/host-defs.h \
common/pathstuff.h \
common/print-utils.h \
diff --git a/gdb/NEWS b/gdb/NEWS
index 13da2f1d4e..9d4aecc01a 100644
--- a/gdb/NEWS
+++ b/gdb/NEWS
@@ -3,6 +3,10 @@
*** Changes since GDB 8.1
+* GDB and GDBserver now support IPv6 connections. IPv6 addresses
+ can be passed using the '[ADDRESS]:PORT' notation, or the regular
+ 'ADDRESS:PORT' method.
+
* The endianness used with the 'set endian auto' mode in the absence of
an executable selected for debugging is now the last endianness chosen
either by one of the 'set endian big' and 'set endian little' commands
diff --git a/gdb/common/netstuff.c b/gdb/common/netstuff.c
new file mode 100644
index 0000000000..0f392ea599
--- /dev/null
+++ b/gdb/common/netstuff.c
@@ -0,0 +1,126 @@
+/* Operations on network stuff.
+ Copyright (C) 2018 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 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ 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, see <http://www.gnu.org/licenses/>. */
+
+#include "common-defs.h"
+#include "netstuff.h"
+
+#ifdef USE_WIN32API
+#include <winsock2.h>
+#include <wspiapi.h>
+#else
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <sys/socket.h>
+#include <netinet/tcp.h>
+#endif
+
+/* See common/netstuff.h. */
+
+scoped_free_addrinfo::~scoped_free_addrinfo ()
+{
+ freeaddrinfo (m_res);
+}
+
+/* See common/netstuff.h. */
+
+parsed_hostname
+parse_hostname_without_prefix (std::string hostname, struct addrinfo *hint)
+{
+ parsed_hostname ret;
+
+ if (hint->ai_family != AF_INET && hostname[0] == '[')
+ {
+ /* IPv6 addresses can be written as '[ADDR]:PORT', and we
+ support this notation. */
+ size_t close_bracket_pos = hostname.find_first_of (']');
+
+ if (close_bracket_pos == std::string::npos)
+ error (_("Missing close bracket in hostname '%s'"),
+ hostname.c_str ());
+
+ /* Erase both '[' and ']'. */
+ hostname.erase (0, 1);
+ hostname.erase (close_bracket_pos - 1, 1);
+
+ hint->ai_family = AF_INET6;
+ }
+
+ /* The length of the hostname part. */
+ size_t host_len;
+ size_t last_colon_pos = hostname.find_last_of (':');
+
+ if (last_colon_pos != std::string::npos)
+ {
+ /* The user has provided a port. */
+ host_len = last_colon_pos;
+ ret.port_str = hostname.substr (last_colon_pos + 1);
+ }
+ else
+ host_len = hostname.size ();
+
+ ret.host_str = hostname.substr (0, host_len);
+
+ /* Default hostname is localhost. */
+ if (ret.host_str.empty ())
+ ret.host_str = "localhost";
+
+ return ret;
+}
+
+/* See common/netstuff.h. */
+
+parsed_hostname
+parse_hostname (const char *hostname, struct addrinfo *hint)
+{
+ /* Struct to hold the association between valid prefixes, their
+ family and socktype. */
+ struct host_prefix
+ {
+ /* The prefix. */
+ const char *prefix;
+
+ /* The 'ai_family'. */
+ int family;
+
+ /* The 'ai_socktype'. */
+ int socktype;
+ };
+ static const struct host_prefix prefixes[] =
+ {
+ { "udp:", AF_UNSPEC, SOCK_DGRAM },
+ { "tcp:", AF_UNSPEC, SOCK_STREAM },
+ { "udp4:", AF_INET, SOCK_DGRAM },
+ { "tcp4:", AF_INET, SOCK_STREAM },
+ { "udp6:", AF_INET6, SOCK_DGRAM },
+ { "tcp6:", AF_INET6, SOCK_STREAM },
+ };
+
+ for (const struct host_prefix prefix : prefixes)
+ if (startswith (hostname, prefix.prefix))
+ {
+ hostname += strlen (prefix.prefix);
+ hint->ai_family = prefix.family;
+ hint->ai_socktype = prefix.socktype;
+ hint->ai_protocol
+ = hint->ai_socktype == SOCK_DGRAM ? IPPROTO_UDP : IPPROTO_TCP;
+ break;
+ }
+
+ return parse_hostname_without_prefix (hostname, hint);
+}
diff --git a/gdb/common/netstuff.h b/gdb/common/netstuff.h
new file mode 100644
index 0000000000..687ff532b8
--- /dev/null
+++ b/gdb/common/netstuff.h
@@ -0,0 +1,76 @@
+/* Operations on network stuff.
+ Copyright (C) 2018 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 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ 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, see <http://www.gnu.org/licenses/>. */
+
+#ifndef NETSTUFF_H
+#define NETSTUFF_H
+
+#include <string>
+#include "common/gdb_string_view.h"
+
+/* Like NI_MAXHOST/NI_MAXSERV, but enough for numeric forms. */
+#define GDB_NI_MAX_ADDR 64
+#define GDB_NI_MAX_PORT 16
+
+/* Helper class to guarantee that we always call 'freeaddrinfo'. */
+
+class scoped_free_addrinfo
+{
+public:
+ /* Default constructor. */
+ scoped_free_addrinfo (struct addrinfo *ainfo)
+ : m_res (ainfo)
+ {
+ }
+
+ /* Destructor responsible for free'ing M_RES by calling
+ 'freeaddrinfo'. */
+ ~scoped_free_addrinfo ();
+
+ DISABLE_COPY_AND_ASSIGN (scoped_free_addrinfo);
+
+private:
+ /* The addrinfo resource. */
+ struct addrinfo *m_res;
+};
+
+/* The struct we return after parsing the hostname. */
+
+struct parsed_hostname
+{
+ /* The hostname. */
+ std::string host_str;
+
+ /* The port, if any. */
+ std::string port_str;
+};
+
+
+/* Parse HOSTNAME (which is a string in the form of "ADDR:PORT") and
+ return a 'parsed_hostname' structure with the proper fields filled
+ in. Also adjust HINT accordingly. */
+extern parsed_hostname parse_hostname_without_prefix (std::string hostname,
+ struct addrinfo *hint);
+
+/* Parse HOSTNAME (which is a string in the form of
+ "[tcp[6]:|udp[6]:]ADDR:PORT") and return a 'parsed_hostname'
+ structure with the proper fields filled in. Also adjust HINT
+ accordingly. */
+extern parsed_hostname parse_hostname (const char *hostname,
+ struct addrinfo *hint);
+
+#endif /* ! NETSTUFF_H */
diff --git a/gdb/doc/gdb.texinfo b/gdb/doc/gdb.texinfo
index a6bad13d9d..55b48309a8 100644
--- a/gdb/doc/gdb.texinfo
+++ b/gdb/doc/gdb.texinfo
@@ -20509,16 +20509,27 @@ If you're using a serial line, you may want to give @value{GDBN} the
@code{target} command.
@item target remote @code{@var{host}:@var{port}}
+@itemx target remote @code{@var{[host]}:@var{port}}
@itemx target remote @code{tcp:@var{host}:@var{port}}
+@itemx target remote @code{tcp:@var{[host]}:@var{port}}
+@itemx target remote @code{tcp4:@var{host}:@var{port}}
+@itemx target remote @code{tcp6:@var{host}:@var{port}}
+@itemx target remote @code{tcp6:@var{[host]}:@var{port}}
@itemx target extended-remote @code{@var{host}:@var{port}}
+@itemx target extended-remote @code{@var{[host]}:@var{port}}
@itemx target extended-remote @code{tcp:@var{host}:@var{port}}
+@itemx target extended-remote @code{tcp:@var{[host]}:@var{port}}
+@itemx target extended-remote @code{tcp4:@var{host}:@var{port}}
+@itemx target extended-remote @code{tcp6:@var{host}:@var{port}}
+@itemx target extended-remote @code{tcp6:@var{[host]}:@var{port}}
@cindex @acronym{TCP} port, @code{target remote}
Debug using a @acronym{TCP} connection to @var{port} on @var{host}.
-The @var{host} may be either a host name or a numeric @acronym{IP}
-address; @var{port} must be a decimal number. The @var{host} could be
-the target machine itself, if it is directly connected to the net, or
-it might be a terminal server which in turn has a serial line to the
-target.
+The @var{host} may be either a host name, a numeric @acronym{IPv4}
+address, or a numeric @acronym{IPv6} address (with or without the
+square brackets to separate the address from the port); @var{port}
+must be a decimal number. The @var{host} could be the target machine
+itself, if it is directly connected to the net, or it might be a
+terminal server which in turn has a serial line to the target.
For example, to connect to port 2828 on a terminal server named
@code{manyfarms}:
@@ -20527,6 +20538,26 @@ For example, to connect to port 2828 on a terminal server named
target remote manyfarms:2828
@end smallexample
+To connect to port 2828 on a terminal server whose address is
+@code{2001:0db8:85a3:0000:0000:8a2e:0370:7334}, you can either use the
+square bracket syntax:
+
+@smallexample
+target remote [2001:0db8:85a3:0000:0000:8a2e:0370:7334]:2828
+@end smallexample
+
+@noindent
+or explicitly specify the @acronym{IPv6} protocol:
+
+@smallexample
+target remote tcp6:2001:0db8:85a3:0000:0000:8a2e:0370:7334:2828
+@end smallexample
+
+This last example may be confusing to the reader, because there is no
+visible separation between the hostname and the port number.
+Therefore, we recommend the user to provide @acronym{IPv6} addresses
+using square brackets for clarity.
+
If your remote target is actually running on the same machine as your
debugger session (e.g.@: a simulator for your target running on the
same host), you can omit the hostname. For example, to connect to
@@ -20540,7 +20571,15 @@ target remote :1234
Note that the colon is still required here.
@item target remote @code{udp:@var{host}:@var{port}}
+@itemx target remote @code{udp:@var{[host]}:@var{port}}
+@itemx target remote @code{udp4:@var{host}:@var{port}}
+@itemx target remote @code{udp6:@var{[host]}:@var{port}}
+@itemx target extended-remote @code{udp:@var{host}:@var{port}}
@itemx target extended-remote @code{udp:@var{host}:@var{port}}
+@itemx target extended-remote @code{udp:@var{[host]}:@var{port}}
+@itemx target extended-remote @code{udp4:@var{host}:@var{port}}
+@itemx target extended-remote @code{udp6:@var{host}:@var{port}}
+@itemx target extended-remote @code{udp6:@var{[host]}:@var{port}}
@cindex @acronym{UDP} port, @code{target remote}
Debug using @acronym{UDP} packets to @var{port} on @var{host}. For example, to
connect to @acronym{UDP} port 2828 on a terminal server named @code{manyfarms}:
diff --git a/gdb/gdbserver/Makefile.in b/gdb/gdbserver/Makefile.in
index cf04b7d7b5..2ae5e6ec00 100644
--- a/gdb/gdbserver/Makefile.in
+++ b/gdb/gdbserver/Makefile.in
@@ -211,6 +211,7 @@ SFILES = \
$(srcdir)/common/job-control.c \
$(srcdir)/common/gdb_tilde_expand.c \
$(srcdir)/common/gdb_vecs.c \
+ $(srcdir)/common/netstuff.c \
$(srcdir)/common/new-op.c \
$(srcdir)/common/pathstuff.c \
$(srcdir)/common/print-utils.c \
@@ -253,6 +254,7 @@ OBS = \
common/format.o \
common/gdb_tilde_expand.o \
common/gdb_vecs.o \
+ common/netstuff.o \
common/new-op.o \
common/pathstuff.o \
common/print-utils.o \
@@ -289,6 +291,7 @@ GDBREPLAY_OBS = \
common/common-exceptions.o \
common/common-utils.o \
common/errors.o \
+ common/netstuff.o \
common/print-utils.o \
gdbreplay.o \
utils.o \
diff --git a/gdb/gdbserver/gdbreplay.c b/gdb/gdbserver/gdbreplay.c
index a4bc892462..8afd46b31a 100644
--- a/gdb/gdbserver/gdbreplay.c
+++ b/gdb/gdbserver/gdbreplay.c
@@ -46,8 +46,11 @@
#if USE_WIN32API
#include <winsock2.h>
+#include <wspiapi.h>
#endif
+#include "netstuff.h"
+
#ifndef HAVE_SOCKLEN_T
typedef int socklen_t;
#endif
@@ -142,56 +145,108 @@ remote_close (void)
static void
remote_open (char *name)
{
- if (!strchr (name, ':'))
+ char *last_colon = strrchr (name, ':');
+
+ if (last_colon == NULL)
{
fprintf (stderr, "%s: Must specify tcp connection as host:addr\n", name);
fflush (stderr);
exit (1);
}
- else
- {
+
#ifdef USE_WIN32API
- static int winsock_initialized;
+ static int winsock_initialized;
#endif
- char *port_str;
- int port;
- struct sockaddr_in sockaddr;
- socklen_t tmp;
- int tmp_desc;
+ char *port_str;
+ int tmp;
+ int tmp_desc;
+ struct addrinfo hint;
+ struct addrinfo *ainfo;
- port_str = strchr (name, ':');
+ 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;
- port = atoi (port_str + 1);
+ parsed_hostname parsed = parse_hostname (name, &hint);
+
+ if (parsed.port_str.empty ())
+ error (_("Missing port on hostname '%s'"), name);
#ifdef USE_WIN32API
- if (!winsock_initialized)
- {
- WSADATA wsad;
+ if (!winsock_initialized)
+ {
+ WSADATA wsad;
- WSAStartup (MAKEWORD (1, 0), &wsad);
- winsock_initialized = 1;
- }
+ WSAStartup (MAKEWORD (1, 0), &wsad);
+ winsock_initialized = 1;
+ }
#endif
- tmp_desc = socket (PF_INET, SOCK_STREAM, 0);
- if (tmp_desc == -1)
- perror_with_name ("Can't open socket");
+ int r = getaddrinfo (parsed.host_str.c_str (), parsed.port_str.c_str (),
+ &hint, &ainfo);
- /* Allow rapid reuse of this port. */
- tmp = 1;
- setsockopt (tmp_desc, SOL_SOCKET, SO_REUSEADDR, (char *) &tmp,
- sizeof (tmp));
+ if (r != 0)
+ {
+ fprintf (stderr, "%s:%s: cannot resolve name: %s\n",
+ parsed.host_str.c_str (), parsed.port_str.c_str (),
+ gai_strerror (r));
+ fflush (stderr);
+ exit (1);
+ }
+
+ scoped_free_addrinfo free_ainfo (ainfo);
+
+ struct addrinfo *p;
+
+ for (p = ainfo; p != NULL; p = p->ai_next)
+ {
+ tmp_desc = socket (p->ai_family, p->ai_socktype, p->ai_protocol);
- sockaddr.sin_family = PF_INET;
- sockaddr.sin_port = htons (port);
- sockaddr.sin_addr.s_addr = INADDR_ANY;
+ if (tmp_desc >= 0)
+ break;
+ }
+
+ if (p == NULL)
+ perror_with_name ("Cannot open socket");
- if (bind (tmp_desc, (struct sockaddr *) &sockaddr, sizeof (sockaddr))
- || listen (tmp_desc, 1))
- perror_with_name ("Can't bind address");
+ /* Allow rapid reuse of this port. */
+ tmp = 1;
+ setsockopt (tmp_desc, SOL_SOCKET, SO_REUSEADDR, (char *) &tmp,
+ sizeof (tmp));
+
+ switch (p->ai_family)
+ {
+ case AF_INET:
+ ((struct sockaddr_in *) p->ai_addr)->sin_addr.s_addr = INADDR_ANY;
+ break;
+ case AF_INET6:
+ ((struct sockaddr_in6 *) p->ai_addr)->sin6_addr = in6addr_any;
+ break;
+ default:
+ fprintf (stderr, "Invalid 'ai_family' %d\n", p->ai_family);
+ exit (1);
+ }
+
+ if (bind (tmp_desc, p->ai_addr, p->ai_addrlen) != 0)
+ perror_with_name ("Can't bind address");
+
+ if (p->ai_socktype == SOCK_DGRAM)
+ remote_desc = tmp_desc;
+ else
+ {
+ struct sockaddr_storage sockaddr;
+ socklen_t sockaddrsize = sizeof (sockaddr);
+ char orig_host[GDB_NI_MAX_ADDR], orig_port[GDB_NI_MAX_PORT];
+
+ if (listen (tmp_desc, 1) != 0)
+ perror_with_name ("Can't listen on socket");
+
+ remote_desc = accept (tmp_desc, (struct sockaddr *) &sockaddr,
+ &sockaddrsize);
- tmp = sizeof (sockaddr);
- remote_desc = accept (tmp_desc, (struct sockaddr *) &sockaddr, &tmp);
if (remote_desc == -1)
perror_with_name ("Accept failed");
@@ -206,6 +261,16 @@ remote_open (char *name)
setsockopt (remote_desc, IPPROTO_TCP, TCP_NODELAY,
(char *) &tmp, sizeof (tmp));
+ if (getnameinfo ((struct sockaddr *) &sockaddr, sockaddrsize,
+ orig_host, sizeof (orig_host),
+ orig_port, sizeof (orig_port),
+ NI_NUMERICHOST | NI_NUMERICSERV) == 0)
+ {
+ fprintf (stderr, "Remote debugging from host %s, port %s\n",
+ orig_host, orig_port);
+ fflush (stderr);
+ }
+
#ifndef USE_WIN32API
close (tmp_desc); /* No longer need this */
diff --git a/gdb/gdbserver/remote-utils.c b/gdb/gdbserver/remote-utils.c
index 967b2f0ebb..0388c67fba 100644
--- a/gdb/gdbserver/remote-utils.c
+++ b/gdb/gdbserver/remote-utils.c
@@ -26,6 +26,8 @@
#include "dll.h"
#include "rsp-low.h"
#include "gdbthread.h"
+#include "netstuff.h"
+#include "filestuff.h"
#include <ctype.h>
#if HAVE_SYS_IOCTL_H
#include <sys/ioctl.h>
@@ -63,6 +65,7 @@
#if USE_WIN32API
#include <winsock2.h>
+#include <wspiapi.h>
#endif
#if __QNX__
@@ -151,19 +154,18 @@ enable_async_notification (int fd)
static int
handle_accept_event (int err, gdb_client_data client_data)
{
- struct sockaddr_in sockaddr;
- socklen_t tmp;
+ struct sockaddr_storage sockaddr;
+ socklen_t len = sizeof (sockaddr);
if (debug_threads)
debug_printf ("handling possible accept event\n");
- tmp = sizeof (sockaddr);
- remote_desc = accept (listen_desc, (struct sockaddr *) &sockaddr, &tmp);
+ remote_desc = accept (listen_desc, (struct sockaddr *) &sockaddr, &len);
if (remote_desc == -1)
perror_with_name ("Accept failed");
/* Enable TCP keep alive process. */
- tmp = 1;
+ socklen_t tmp = 1;
setsockopt (remote_desc, SOL_SOCKET, SO_KEEPALIVE,
(char *) &tmp, sizeof (tmp));
@@ -192,8 +194,19 @@ handle_accept_event (int err, gdb_client_data client_data)
delete_file_handler (listen_desc);
/* Convert IP address to string. */
- fprintf (stderr, "Remote debugging from host %s\n",
- inet_ntoa (sockaddr.sin_addr));
+ char orig_host[GDB_NI_MAX_ADDR], orig_port[GDB_NI_MAX_PORT];
+
+ int r = getnameinfo ((struct sockaddr *) &sockaddr, len,
+ orig_host, sizeof (orig_host),
+ orig_port, sizeof (orig_port),
+ NI_NUMERICHOST | NI_NUMERICSERV);
+
+ if (r != 0)
+ fprintf (stderr, _("Could not obtain remote address: %s\n"),
+ gai_strerror (r));
+ else
+ fprintf (stderr, _("Remote debugging from host %s, port %s\n"),
+ orig_host, orig_port);
enable_async_notification (remote_desc);
@@ -222,10 +235,7 @@ remote_prepare (const char *name)
#ifdef USE_WIN32API
static int winsock_initialized;
#endif
- int port;
- struct sockaddr_in sockaddr;
socklen_t tmp;
- char *port_end;
remote_is_stdio = 0;
if (strcmp (name, STDIO_CONNECTION_NAME) == 0)
@@ -238,17 +248,24 @@ remote_prepare (const char *name)
return;
}
- port_str = strchr (name, ':');
- if (port_str == NULL)
+ struct addrinfo hint;
+ struct addrinfo *ainfo;
+
+ 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;
+
+ parsed_hostname parsed = parse_hostname_without_prefix (name, &hint);
+
+ if (parsed.port_str.empty ())
{
cs.transport_is_reliable = 0;
return;
}
- port = strtoul (port_str + 1, &port_end, 10);
- if (port_str[1] == '\0' || *port_end != '\0')
- error ("Bad port argument: %s", name);
-
#ifdef USE_WIN32API
if (!winsock_initialized)
{
@@ -259,8 +276,26 @@ remote_prepare (const char *name)
}
#endif
- listen_desc = socket (PF_INET, SOCK_STREAM, IPPROTO_TCP);
- if (listen_desc == -1)
+ int r = getaddrinfo (parsed.host_str.c_str (), parsed.port_str.c_str (),
+ &hint, &ainfo);
+
+ if (r != 0)
+ error (_("%s: cannot resolve name: %s"), name, gai_strerror (r));
+
+ scoped_free_addrinfo freeaddrinfo (ainfo);
+
+ struct addrinfo *iter;
+
+ for (iter = ainfo; iter != NULL; iter = iter->ai_next)
+ {
+ listen_desc = gdb_socket_cloexec (iter->ai_family, iter->ai_socktype,
+ iter->ai_protocol);
+
+ if (listen_desc >= 0)
+ break;
+ }
+
+ if (iter == NULL)
perror_with_name ("Can't open socket");
/* Allow rapid reuse of this port. */
@@ -268,14 +303,25 @@ remote_prepare (const char *name)
setsockopt (listen_desc, SOL_SOCKET, SO_REUSEADDR, (char *) &tmp,
sizeof (tmp));
- sockaddr.sin_family = PF_INET;
- sockaddr.sin_port = htons (port);
- sockaddr.sin_addr.s_addr = INADDR_ANY;
+ switch (iter->ai_family)
+ {
+ case AF_INET:
+ ((struct sockaddr_in *) iter->ai_addr)->sin_addr.s_addr = INADDR_ANY;
+ break;
+ case AF_INET6:
+ ((struct sockaddr_in6 *) iter->ai_addr)->sin6_addr = in6addr_any;
+ break;
+ default:
+ internal_error (__FILE__, __LINE__,
+ _("Invalid 'ai_family' %d\n"), iter->ai_family);
+ }
- if (bind (listen_desc, (struct sockaddr *) &sockaddr, sizeof (sockaddr))
- || listen (listen_desc, 1))
+ if (bind (listen_desc, iter->ai_addr, iter->ai_addrlen) != 0)
perror_with_name ("Can't bind address");
+ if (listen (listen_desc, 1) != 0)
+ perror_with_name ("Can't listen on socket");
+
cs.transport_is_reliable = 1;
}
@@ -350,18 +396,24 @@ remote_open (const char *name)
#endif /* USE_WIN32API */
else
{
- int port;
- socklen_t len;
- struct sockaddr_in sockaddr;
-
- len = sizeof (sockaddr);
- if (getsockname (listen_desc,
- (struct sockaddr *) &sockaddr, &len) < 0
- || len < sizeof (sockaddr))
+ char listen_port[16];
+ struct sockaddr_storage sockaddr;
+ socklen_t len = sizeof (sockaddr);
+
+ if (getsockname (listen_desc, (struct sockaddr *) &sockaddr, &len) < 0)
perror_with_name ("Can't determine port");
- port = ntohs (sockaddr.sin_port);
- fprintf (stderr, "Listening on port %d\n", port);
+ int r = getnameinfo ((struct sockaddr *) &sockaddr, len,
+ NULL, 0,
+ listen_port, sizeof (listen_port),
+ NI_NUMERICSERV);
+
+ if (r != 0)
+ fprintf (stderr, _("Can't obtain port where we are listening: %s"),
+ gai_strerror (r));
+ else
+ fprintf (stderr, _("Listening on port %s\n"), listen_port);
+
fflush (stderr);
/* Register the event loop handler. */
diff --git a/gdb/ser-tcp.c b/gdb/ser-tcp.c
index 23ef3b04b8..44b6d89cda 100644
--- a/gdb/ser-tcp.c
+++ b/gdb/ser-tcp.c
@@ -25,6 +25,7 @@
#include "cli/cli-decode.h"
#include "cli/cli-setshow.h"
#include "filestuff.h"
+#include "netstuff.h"
#include <sys/types.h>
@@ -39,6 +40,7 @@
#ifdef USE_WIN32API
#include <winsock2.h>
+#include <wspiapi.h>
#ifndef ETIMEDOUT
#define ETIMEDOUT WSAETIMEDOUT
#endif
@@ -81,12 +83,69 @@ static unsigned int tcp_retry_limit = 15;
#define POLL_INTERVAL 5
-/* 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. */
+/* An abstraction of a socket, useful when we want to close the socket
+ fd automatically when exiting a context. */
+
+class gdb_socket
+{
+public:
+ /* Default constructor. */
+ gdb_socket (int sock, const struct addrinfo *ainfo)
+ : m_socket (sock),
+ m_released (false),
+ m_ainfo (ainfo)
+ {
+ }
+
+ /* Release a socket, i.e., make sure it doesn't get closed when our
+ destructor is called. */
+ void release ()
+ {
+ m_released = true;
+ }
+
+ /* Return the socket associated with this object. */
+ int get_socket () const
+ {
+ return m_socket;
+ }
+
+ /* Return the addrinfo structure associated with this object. */
+ const struct addrinfo *get_addrinfo () const
+ {
+ return m_ainfo;
+ }
+
+ /* Destructor. Make sure we close the socket if it hasn't been
+ released. */
+ ~gdb_socket ()
+ {
+ if (!m_released)
+ close (m_socket);
+ }
+
+private:
+ /* The socket. */
+ int m_socket;
+
+ /* Whether the socket has been released or not. If it has, then we
+ don't close it when our destructor is called. */
+ bool m_released;
+
+ /* The addrinfo structure associated with the socket. */
+ const struct addrinfo *m_ainfo;
+};
+
+/* Helper function to wait a while. If SOCKET_POLL is non-null, wait
+ on its file descriptors. Otherwise just wait on a timeout, updating
+ *POLLS. If SOCKET_POLL and SOCKETS_READY are both non-NULL, update
+ SOCKETS_READY with the value of the 'write' fd_set upon successful
+ completion of the 'select' call. Return -1 on timeout or
+ interrupt, otherwise return the value of the 'select' call. */
static int
-wait_for_connect (struct serial *scb, unsigned int *polls)
+wait_for_connect (const std::vector<std::unique_ptr<gdb_socket>> *socket_poll,
+ unsigned int *polls, fd_set *sockets_ready)
{
struct timeval t;
int n;
@@ -120,24 +179,39 @@ wait_for_connect (struct serial *scb, unsigned int *polls)
t.tv_usec = 0;
}
- if (scb)
+ if (socket_poll != NULL)
{
- fd_set rset, wset, eset;
+ fd_set wset, eset;
+ int maxfd = 0;
+
+ FD_ZERO (&wset);
+ FD_ZERO (&eset);
+ for (const std::unique_ptr<gdb_socket> &ptr : *socket_poll)
+ {
+ const gdb_socket *sock = ptr.get ();
+ int s = sock->get_socket ();
+
+ FD_SET (s, &wset);
+ FD_SET (s, &eset);
+ maxfd = std::max (maxfd, s);
+ }
- 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);
+ n = select (maxfd + 1, NULL, &wset, &eset, &t);
+
+ if (n > 0 && sockets_ready != NULL)
+ {
+ /* We're just interested in possible successes, so we just
+ copy wset here. */
+ *sockets_ready = wset;
+ }
}
else
/* Use gdb_select here, since we have no file descriptors, and on
@@ -153,171 +227,271 @@ wait_for_connect (struct serial *scb, unsigned int *polls)
return n;
}
-/* Open a tcp socket. */
+/* Return TRUE if there is an error associated with socket SOCK, or
+ FALSE otherwise. If there's an error, set ERRNO accordingly. */
-int
-net_open (struct serial *scb, const char *name)
+static bool
+socket_error_p (int sock)
{
- char hostname[100];
- const char *port_str;
- 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;
+ int res, err;
+ socklen_t len = sizeof (err);
- use_udp = 0;
- if (startswith (name, "udp:"))
- {
- use_udp = 1;
- name = name + 4;
- }
- else if (startswith (name, "tcp:"))
- name = name + 4;
+ /* 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 *". */
+ res = getsockopt (sock, SOL_SOCKET, SO_ERROR, (char *) &err, &len);
- port_str = strchr (name, ':');
+ if (err != 0)
+ errno = err;
- if (!port_str)
- error (_("net_open: No colon in host name!")); /* Shouldn't ever
- happen. */
+ return (res < 0 || err != 0) ? true : false;
+}
- tmp = std::min (port_str - name, (ptrdiff_t) sizeof hostname - 1);
- strncpy (hostname, name, tmp); /* Don't want colon. */
- hostname[tmp] = '\000'; /* Tie off host name. */
- port = atoi (port_str + 1);
+/* Helper structure containing a pair of socket and addrinfo. */
- /* Default hostname is localhost. */
- if (!hostname[0])
- strcpy (hostname, "localhost");
+struct gdb_connect_info
+{
+ int socket;
- hostent = gethostbyname (hostname);
- if (!hostent)
- {
- fprintf_unfiltered (gdb_stderr, "%s: unknown host\n", hostname);
- errno = ENOENT;
- return -1;
- }
+ const struct addrinfo *ainfo;
+};
- sockaddr.sin_family = PF_INET;
- sockaddr.sin_port = htons (port);
- memcpy (&sockaddr.sin_addr.s_addr, hostent->h_addr,
- sizeof (struct in_addr));
+/* Iterate over the entries of AINFO and try to open a socket and
+ perform a 'connect' on each one. If there's a success, return the
+ socket and the associated 'struct addrinfo' that succeeded.
+ Otherwise, return a special instance of gdb_connect_info whose
+ SOCKET is -1 and AINFO is NULL.
+
+ Sockets that are opened are marked as non-blocking. When a socket
+ fails to connect (i.e., when 'connect' returns -1 and ERRNO is set
+ to EINPROGRESS), we add this socket (along with its associated
+ 'struct addrinfo') into SOCKET_POLL. The caller can then use
+ SOCKET_POLL to perform a 'select' on the sockets and check if any
+ of them succeeded. */
+
+static gdb_connect_info
+gdb_connect (const struct addrinfo *ainfo,
+ std::vector<std::unique_ptr<gdb_socket>> &socket_poll)
+{
+ gdb_connect_info ret;
+#ifdef USE_WIN32API
+ u_long ioarg;
+#else
+ int ioarg;
+#endif
- retry:
+ ret.socket = -1;
+ ret.ainfo = NULL;
- if (use_udp)
- scb->fd = gdb_socket_cloexec (PF_INET, SOCK_DGRAM, 0);
- else
- scb->fd = gdb_socket_cloexec (PF_INET, SOCK_STREAM, 0);
+ for (const struct addrinfo *cur_ainfo = ainfo;
+ cur_ainfo != NULL;
+ cur_ainfo = cur_ainfo->ai_next)
+ {
+ int sock = gdb_socket_cloexec (cur_ainfo->ai_family,
+ cur_ainfo->ai_socktype,
+ cur_ainfo->ai_protocol);
- if (scb->fd == -1)
- return -1;
-
- /* Set socket nonblocking. */
- ioarg = 1;
- ioctl (scb->fd, FIONBIO, &ioarg);
+ if (sock < 0)
+ continue;
- /* Use Non-blocking connect. connect() will return 0 if connected
- already. */
- n = connect (scb->fd, (struct sockaddr *) &sockaddr, sizeof (sockaddr));
+ /* Set socket nonblocking. */
+ ioarg = 1;
+ ioctl (sock, FIONBIO, &ioarg);
- if (n < 0)
- {
+ /* Use Non-blocking connect. connect() will return 0 if
+ connected already. */
+ if (connect (sock, cur_ainfo->ai_addr, cur_ainfo->ai_addrlen) == 0)
+ {
+ if (!socket_error_p (sock))
+ {
+ /* Connection succeeded, we can stop trying. */
+ ret.socket = sock;
+ ret.ainfo = cur_ainfo;
+ break;
+ }
+ else
+ {
+ /* There was an error with the socket. Just try the
+ next one. */
+ close (sock);
+ continue;
+ }
+ }
+ else
+ {
#ifdef USE_WIN32API
- int err = WSAGetLastError();
+ int err = WSAGetLastError();
#else
- int err = errno;
+ int err = errno;
#endif
- /* Maybe we're waiting for the remote target to become ready to
- accept connections. */
- if (tcp_auto_retry
+ if (tcp_auto_retry
#ifdef USE_WIN32API
- && err == WSAECONNREFUSED
+ /* Under Windows, calling "connect" with a
+ non-blocking socket results in WSAEWOULDBLOCK,
+ not WSAEINPROGRESS. */
+ && err == WSAEWOULDBLOCK
#else
- && err == ECONNREFUSED
+ && err == EINPROGRESS
#endif
- && wait_for_connect (NULL, &polls) >= 0)
- {
- close (scb->fd);
- goto retry;
+ )
+ {
+ /* If we have an "INPROGRESS" error, add the socket
+ to the poll of sockets we have to perform a
+ 'select' on. */
+ socket_poll.push_back
+ (std::unique_ptr<gdb_socket>
+ (new gdb_socket (sock, cur_ainfo)));
+ }
}
+ }
+ return ret;
+}
- if (
+/* Open a tcp socket. */
+
+int
+net_open (struct serial *scb, const char *name)
+{
+ bool use_udp;
#ifdef USE_WIN32API
- /* Under Windows, calling "connect" with a non-blocking socket
- results in WSAEWOULDBLOCK, not WSAEINPROGRESS. */
- err != WSAEWOULDBLOCK
+ u_long ioarg;
#else
- err != EINPROGRESS
+ int ioarg;
#endif
- )
+ struct addrinfo hint;
+ struct addrinfo *ainfo;
+
+ 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;
+
+ parsed_hostname parsed = parse_hostname (name, &hint);
+
+ 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)
+ {
+ fprintf_unfiltered (gdb_stderr, _("%s: cannot resolve name: %s\n"),
+ name, gai_strerror (r));
+ errno = ENOENT;
+ return -1;
+ }
+
+ scoped_free_addrinfo free_ainfo (ainfo);
+
+ const struct addrinfo *cur_ainfo;
+ bool got_connection = false;
+ unsigned int polls = 0;
+
+ /* Assume the worst. */
+ scb->fd = -1;
+
+ while (!got_connection)
+ {
+ /* A poll of sockets. This poll will store the sockets that
+ "error'd" with EINPROGRESS, meaning that we will perform a
+ 'select' on them. */
+ std::vector<std::unique_ptr<gdb_socket>> socket_poll;
+ /* Try to connect. This function will return a pair of socket
+ and addrinfo. If the connection succeeded, the socket will
+ have a positive value and the addrinfo will not be NULL. */
+ gdb_connect_info gci = gdb_connect (ainfo, socket_poll);
+
+ if (gci.socket > -1)
{
- errno = err;
- net_close (scb);
- return -1;
+ /* It seems we've got a successful connection in our loop,
+ so let's just stop. */
+ gdb_assert (gci.ainfo != NULL);
+ scb->fd = gci.socket;
+ cur_ainfo = gci.ainfo;
+ got_connection = true;
+ break;
}
- /* Looks like we need to wait for the connect. */
- do
+ if (!socket_poll.empty ())
{
- n = wait_for_connect (scb, &polls);
- }
- while (n == 0);
- if (n < 0)
+ /* Perform 'select' on the poll of sockets. */
+ fd_set sockets_ready;
+ int n;
+
+ /* Wait until some of the sockets are ready (or until we
+ have a timeout/interruption, whatever comes first). */
+ do
+ {
+ n = wait_for_connect (&socket_poll, &polls, &sockets_ready);
+ }
+ while (n == 0);
+
+ if (n < 0)
+ {
+ /* We probably got a timeout/interruption, or maybe
+ 'select' error'd out on us. Either way, we should
+ bail out. */
+ break;
+ }
+
+ for (const std::unique_ptr<gdb_socket> &ptr : socket_poll)
+ {
+ /* Here we iterate over our list of sockets. For each
+ one, we check if it's marked as "ready" (by
+ 'select'), and if there's no error associated with
+ it. If everything is OK, it means we've got a
+ successful connection. */
+ gdb_socket *sock = ptr.get ();
+ int s = sock->get_socket ();
+
+ if (FD_ISSET (s, &sockets_ready) && !socket_error_p (s))
+ {
+ /* We got a connection. */
+ scb->fd = s;
+ cur_ainfo = sock->get_addrinfo ();
+ /* Release it so that it doesn't get closed when the
+ destructor is called. */
+ sock->release ();
+ got_connection = true;
+ break;
+ }
+ }
+ }
+
+ if (got_connection)
{
- net_close (scb);
- return -1;
+ /* Maybe we've been able to establish a connection. If so,
+ just break. */
+ break;
}
+
+ /* Let's wait a bit. */
+ if (wait_for_connect (NULL, &polls, NULL) < 0)
+ break;
}
- /* 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 "char *"
- is OK everywhere, since in C++ any data pointer type can be
- implicitly converted to "void *". */
- res = getsockopt (scb->fd, SOL_SOCKET, SO_ERROR, (char *) &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;
- }
- }
+ if (!got_connection)
+ {
+ net_close (scb);
+ return -1;
+ }
/* Turn off nonblocking. */
ioarg = 0;
ioctl (scb->fd, FIONBIO, &ioarg);
- if (use_udp == 0)
+ if (cur_ainfo->ai_socktype == IPPROTO_TCP)
{
/* Disable Nagle algorithm. Needed in some cases. */
- tmp = 1;
+ int tmp = 1;
+
setsockopt (scb->fd, IPPROTO_TCP, TCP_NODELAY,
- (char *)&tmp, sizeof (tmp));
+ (char *) &tmp, sizeof (tmp));
}
#ifdef SIGPIPE
diff --git a/gdb/testsuite/README b/gdb/testsuite/README
index 4475ac21a9..55abfb3254 100644
--- a/gdb/testsuite/README
+++ b/gdb/testsuite/README
@@ -259,6 +259,20 @@ This make (not runtest) variable is used to specify whether the
testsuite preloads the read1.so library into expect. Any non-empty
value means true. See "Race detection" below.
+GDB_TEST_SOCKETHOST
+
+This variable can provide the hostname/address that should be used
+when performing GDBserver-related tests. This is useful in some
+situations, e.g., when you want to test the IPv6 connectivity of GDB
+and GDBserver, or when using a different hostname/address is needed.
+For example, to make GDB and GDBserver use IPv6-only connections, you
+can do:
+
+ make check TESTS="gdb.server/*.exp" RUNTESTFLAGS='GDB_TEST_SOCKETHOST=tcp6:[::1]'
+
+Note that only a hostname/address can be provided, without a port
+number.
+
Race detection
**************
diff --git a/gdb/testsuite/boards/native-extended-gdbserver.exp b/gdb/testsuite/boards/native-extended-gdbserver.exp
index df949994fd..482e4e3c14 100644
--- a/gdb/testsuite/boards/native-extended-gdbserver.exp
+++ b/gdb/testsuite/boards/native-extended-gdbserver.exp
@@ -24,8 +24,6 @@ load_generic_config "extended-gdbserver"
load_board_description "gdbserver-base"
load_board_description "local-board"
-set_board_info sockethost "localhost:"
-
# We will be using the extended GDB remote protocol.
set_board_info gdb_protocol "extended-remote"
diff --git a/gdb/testsuite/boards/native-gdbserver.exp b/gdb/testsuite/boards/native-gdbserver.exp
index ef9316007e..1dee3df4f1 100644
--- a/gdb/testsuite/boards/native-gdbserver.exp
+++ b/gdb/testsuite/boards/native-gdbserver.exp
@@ -30,7 +30,6 @@ set_board_info gdb,do_reload_on_run 1
# There's no support for argument-passing (yet).
set_board_info noargs 1
-set_board_info sockethost "localhost:"
set_board_info use_gdb_stub 1
set_board_info exit_is_reliable 1
diff --git a/gdb/testsuite/gdb.server/run-without-local-binary.exp b/gdb/testsuite/gdb.server/run-without-local-binary.exp
index 1665ca9912..6ba3e711d9 100644
--- a/gdb/testsuite/gdb.server/run-without-local-binary.exp
+++ b/gdb/testsuite/gdb.server/run-without-local-binary.exp
@@ -53,7 +53,7 @@ save_vars { GDBFLAGS } {
set use_gdb_stub 0
gdb_test "target ${gdbserver_protocol} ${gdbserver_gdbport}" \
- "Remote debugging using $gdbserver_gdbport" \
+ "Remote debugging using [string_to_regexp $gdbserver_gdbport]" \
"connect to gdbserver"
gdb_test "run" \
diff --git a/gdb/testsuite/lib/gdbserver-support.exp b/gdb/testsuite/lib/gdbserver-support.exp
index 46e4f77922..91e3a98543 100644
--- a/gdb/testsuite/lib/gdbserver-support.exp
+++ b/gdb/testsuite/lib/gdbserver-support.exp
@@ -211,7 +211,7 @@ proc gdbserver_default_get_remote_address { host port } {
# Default routine to compute the "comm" argument for gdbserver.
proc gdbserver_default_get_comm_port { port } {
- return ":$port"
+ return "$port"
}
# Start a gdbserver process with initial OPTIONS and trailing ARGUMENTS.
@@ -221,6 +221,7 @@ proc gdbserver_default_get_comm_port { port } {
proc gdbserver_start { options arguments } {
global portnum
+ global GDB_TEST_SOCKETHOST
# Port id -- either specified in baseboard file, or managed here.
if [target_info exists gdb,socketport] {
@@ -231,10 +232,22 @@ proc gdbserver_start { options arguments } {
}
# Extract the local and remote host ids from the target board struct.
- if [target_info exists sockethost] {
+ if { [info exists GDB_TEST_SOCKETHOST] } {
+ # The user is not supposed to provide a port number, just a
+ # hostname/address, therefore we add the trailing ":" here.
+ set debughost "${GDB_TEST_SOCKETHOST}:"
+ # Espace open and close square brackets.
+ set debughost_tmp [string map { [ \\[ ] \\] } $debughost]
+ # We need a "gdbserver" version of the debughost, which will
+ # have the possible connection prefix stripped. This is
+ # because gdbserver currently doesn't recognize the prefixes.
+ regsub -all "^\(tcp:|udp:|tcp4:|udp4:|tcp6:|udp6:\)" $debughost_tmp "" debughost_gdbserver
+ } elseif [target_info exists sockethost] {
set debughost [target_info sockethost]
+ set debughost_gdbserver $debughost
} else {
set debughost "localhost:"
+ set debughost_gdbserver $debughost
}
# Some boards use a different value for the port that is passed to
@@ -277,8 +290,14 @@ proc gdbserver_start { options arguments } {
if { $options != "" } {
append gdbserver_command " $options"
}
+ if { $debughost_gdbserver != "" } {
+ append gdbserver_command " $debughost_gdbserver"
+ }
if { $portnum != "" } {
- append gdbserver_command " [$get_comm_port $portnum]"
+ if { $debughost_gdbserver == "" } {
+ append gdbserver_command " "
+ }
+ append gdbserver_command "[$get_comm_port $portnum]"
}
if { $arguments != "" } {
append gdbserver_command " $arguments"
--
2.14.3