1 /* Serial interface for raw TCP connections on Un*x like systems.
3 Copyright (C) 1992-2018 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
25 #include "cli/cli-decode.h"
26 #include "cli/cli-setshow.h"
27 #include "filestuff.h"
30 #include <sys/types.h>
32 #ifdef HAVE_SYS_FILIO_H
33 #include <sys/filio.h> /* For FIONBIO. */
35 #ifdef HAVE_SYS_IOCTL_H
36 #include <sys/ioctl.h> /* For FIONBIO. */
39 #include "gdb_sys_time.h"
45 #define ETIMEDOUT WSAETIMEDOUT
47 /* Gnulib defines close too, but gnulib's replacement
48 doesn't call closesocket unless we import the
51 #define close(fd) closesocket (fd)
52 #define ioctl ioctlsocket
54 #include <netinet/in.h>
55 #include <arpa/inet.h>
57 #include <sys/socket.h>
58 #include <netinet/tcp.h>
62 #include "gdb_select.h"
65 #ifndef HAVE_SOCKLEN_T
66 typedef int socklen_t;
69 /* For "set tcp" and "show tcp". */
71 static struct cmd_list_element *tcp_set_cmdlist;
72 static struct cmd_list_element *tcp_show_cmdlist;
74 /* Whether to auto-retry refused connections. */
76 static int tcp_auto_retry = 1;
78 /* Timeout period for connections, in seconds. */
80 static unsigned int tcp_retry_limit = 15;
82 /* How many times per second to poll deprecated_ui_loop_hook. */
84 #define POLL_INTERVAL 5
86 /* Helper function to wait a while. If SOCK is not -1, wait on its
87 file descriptor. Otherwise just wait on a timeout, updating
88 *POLLS. Returns -1 on timeout or interrupt, otherwise the value of
92 wait_for_connect (int sock, unsigned int *polls)
97 /* While we wait for the connect to complete,
98 poll the UI so it can update or the user can
100 if (deprecated_ui_loop_hook && deprecated_ui_loop_hook (0))
106 /* Check for timeout. */
107 if (*polls > tcp_retry_limit * POLL_INTERVAL)
113 /* Back off to polling once per second after the first POLL_INTERVAL
115 if (*polls < POLL_INTERVAL)
118 t.tv_usec = 1000000 / POLL_INTERVAL;
128 fd_set rset, wset, eset;
131 FD_SET (sock, &rset);
135 /* POSIX systems return connection success or failure by signalling
136 wset. Windows systems return success in wset and failure in
139 We must call select here, rather than gdb_select, because
140 the serial structure has not yet been initialized - the
141 MinGW select wrapper will not know that this FD refers
143 n = select (sock + 1, &rset, &wset, &eset, &t);
146 /* Use gdb_select here, since we have no file descriptors, and on
147 Windows, plain select doesn't work in that case. */
148 n = gdb_select (0, NULL, NULL, NULL, &t);
150 /* If we didn't time out, only count it as one poll. */
151 if (n > 0 || *polls < POLL_INTERVAL)
154 (*polls) += POLL_INTERVAL;
159 /* Try to connect to the host represented by AINFO. If the connection
160 succeeds, return its socket. Otherwise, return -1 and set ERRNO
161 accordingly. POLLS is used when 'connect' returns EINPROGRESS, and
162 we need to invoke 'wait_for_connect' to obtain the status. */
165 try_connect (const struct addrinfo *ainfo, unsigned int *polls)
167 int sock = gdb_socket_cloexec (ainfo->ai_family, ainfo->ai_socktype,
173 /* Set socket nonblocking. */
176 ioctl (sock, FIONBIO, &ioarg);
178 /* Use Non-blocking connect. connect() will return 0 if connected
180 if (connect (sock, ainfo->ai_addr, ainfo->ai_addrlen) < 0)
183 int err = WSAGetLastError();
188 /* If we've got a "connection refused" error, just return
189 -1. The caller will know what to do. */
192 err == WSAECONNREFUSED
204 /* Any other error (except EINPROGRESS) will be "swallowed"
205 here. We return without specifying a return value, and
206 set errno if the caller wants to inspect what
209 /* Under Windows, calling "connect" with a non-blocking socket
210 results in WSAEWOULDBLOCK, not WSAEINPROGRESS. */
211 err != WSAEWOULDBLOCK
222 /* Looks like we need to wait for the connect. */
226 n = wait_for_connect (sock, polls);
231 int saved_errno = errno;
233 /* A negative value here means that we either timed out or
234 got interrupted by the user. Just return. */
241 /* Got something. Is it an error? */
243 socklen_t len = sizeof (err);
245 /* On Windows, the fourth parameter to getsockopt is a "char *";
246 on UNIX systems it is generally "void *". The cast to "char *"
247 is OK everywhere, since in C++ any data pointer type can be
248 implicitly converted to "void *". */
249 int ret = getsockopt (sock, SOL_SOCKET, SO_ERROR, (char *) &err, &len);
253 int saved_errno = errno;
259 else if (ret == 0 && err != 0)
266 /* The connection succeeded. Return the socket. */
270 /* Open a tcp socket. */
273 net_open (struct serial *scb, const char *name)
275 struct addrinfo hint;
276 struct addrinfo *ainfo;
278 memset (&hint, 0, sizeof (hint));
279 /* Assume no prefix will be passed, therefore we should use
281 hint.ai_family = AF_UNSPEC;
282 hint.ai_socktype = SOCK_STREAM;
283 hint.ai_protocol = IPPROTO_TCP;
285 parsed_connection_spec parsed = parse_connection_spec (name, &hint);
287 if (parsed.port_str.empty ())
288 error (_("Missing port on hostname '%s'"), name);
290 int r = getaddrinfo (parsed.host_str.c_str (),
291 parsed.port_str.c_str (),
296 fprintf_unfiltered (gdb_stderr, _("%s: cannot resolve name: %s\n"),
297 name, gai_strerror (r));
302 scoped_free_addrinfo free_ainfo (ainfo);
304 /* Flag to indicate whether we've got a connection refused. It will
305 be true if any of the connections tried was refused. */
306 bool got_connrefused;
307 /* If a connection succeeeds, SUCCESS_AINFO will point to the
308 'struct addrinfo' that succeed. */
309 struct addrinfo *success_ainfo = NULL;
310 unsigned int polls = 0;
312 /* Assume the worst. */
317 got_connrefused = false;
319 for (struct addrinfo *iter = ainfo; iter != NULL; iter = iter->ai_next)
321 /* Iterate over the list of possible addresses to connect
322 to. For each, we'll try to connect and see if it
324 int sock = try_connect (iter, &polls);
328 /* We've gotten a successful connection. Save its
329 'struct addrinfo', the socket, and break. */
330 success_ainfo = iter;
336 errno == WSAECONNREFUSED
338 errno == ECONNREFUSED
341 got_connrefused = true;
346 - tcp_auto_retry is true, and
347 - We haven't gotten a connection yet, and
348 - Any of our connection attempts returned with ECONNREFUSED, and
349 - wait_for_connect signals that we can keep going. */
350 while (tcp_auto_retry
351 && success_ainfo == NULL
353 && wait_for_connect (-1, &polls) >= 0);
355 if (success_ainfo == NULL)
361 /* Turn off nonblocking. */
368 ioctl (scb->fd, FIONBIO, &ioarg);
370 if (success_ainfo->ai_socktype == IPPROTO_TCP)
372 /* Disable Nagle algorithm. Needed in some cases. */
375 setsockopt (scb->fd, IPPROTO_TCP, TCP_NODELAY,
376 (char *) &tmp, sizeof (tmp));
380 /* If we don't do this, then GDB simply exits
381 when the remote side dies. */
382 signal (SIGPIPE, SIG_IGN);
389 net_close (struct serial *scb)
399 net_read_prim (struct serial *scb, size_t count)
401 /* Need to cast to silence -Wpointer-sign on MinGW, as Winsock's
402 'recv' takes 'char *' as second argument, while 'scb->buf' is
403 'unsigned char *'. */
404 return recv (scb->fd, (char *) scb->buf, count, 0);
408 net_write_prim (struct serial *scb, const void *buf, size_t count)
410 /* On Windows, the second parameter to send is a "const char *"; on
411 UNIX systems it is generally "const void *". The cast to "const
412 char *" is OK everywhere, since in C++ any data pointer type can
413 be implicitly converted to "const void *". */
414 return send (scb->fd, (const char *) buf, count, 0);
418 ser_tcp_send_break (struct serial *scb)
420 /* Send telnet IAC and BREAK characters. */
421 return (serial_write (scb, "\377\363", 2));
424 /* Support for "set tcp" and "show tcp" commands. */
427 set_tcp_cmd (const char *args, int from_tty)
429 help_list (tcp_set_cmdlist, "set tcp ", all_commands, gdb_stdout);
433 show_tcp_cmd (const char *args, int from_tty)
435 help_list (tcp_show_cmdlist, "show tcp ", all_commands, gdb_stdout);
442 static const struct serial_ops tcp_ops =
450 ser_base_flush_output,
451 ser_base_flush_input,
454 ser_base_get_tty_state,
455 ser_base_copy_tty_state,
456 ser_base_set_tty_state,
457 ser_base_print_tty_state,
458 ser_base_setbaudrate,
459 ser_base_setstopbits,
461 ser_base_drain_output,
467 #endif /* USE_WIN32API */
470 _initialize_ser_tcp (void)
473 /* Do nothing; the TCP serial operations will be initialized in
476 serial_add_interface (&tcp_ops);
477 #endif /* USE_WIN32API */
479 add_prefix_cmd ("tcp", class_maintenance, set_tcp_cmd, _("\
480 TCP protocol specific variables\n\
481 Configure variables specific to remote TCP connections"),
482 &tcp_set_cmdlist, "set tcp ",
483 0 /* allow-unknown */, &setlist);
484 add_prefix_cmd ("tcp", class_maintenance, show_tcp_cmd, _("\
485 TCP protocol specific variables\n\
486 Configure variables specific to remote TCP connections"),
487 &tcp_show_cmdlist, "show tcp ",
488 0 /* allow-unknown */, &showlist);
490 add_setshow_boolean_cmd ("auto-retry", class_obscure,
491 &tcp_auto_retry, _("\
492 Set auto-retry on socket connect"), _("\
493 Show auto-retry on socket connect"),
495 &tcp_set_cmdlist, &tcp_show_cmdlist);
497 add_setshow_uinteger_cmd ("connect-timeout", class_obscure,
498 &tcp_retry_limit, _("\
499 Set timeout limit in seconds for socket connection"), _("\
500 Show timeout limit in seconds for socket connection"), _("\
501 If set to \"unlimited\", GDB will keep attempting to establish a\n\
502 connection forever, unless interrupted with Ctrl-c.\n\
503 The default is 15 seconds."),
505 &tcp_set_cmdlist, &tcp_show_cmdlist);