gdb/ser-tcp.c

   1 /* Serial interface for raw TCP connections on Un*x like systems.
   2
   3    Copyright (C) 1992-2019 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   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.
  11
  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.
  16
  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/>.  */
  19
  20 #include "defs.h"
  21 #include "serial.h"
  22 #include "ser-base.h"
  23 #include "ser-tcp.h"
  24 #include "gdbcmd.h"
  25 #include "cli/cli-decode.h"
  26 #include "cli/cli-setshow.h"
  27 #include "gdbsupport/filestuff.h"
  28 #include "gdbsupport/netstuff.h"
  29
  30 #include <sys/types.h>
  31
  32 #ifdef HAVE_SYS_FILIO_H
  33 #include <sys/filio.h>  /* For FIONBIO.  */
  34 #endif
  35 #ifdef HAVE_SYS_IOCTL_H
  36 #include <sys/ioctl.h>  /* For FIONBIO.  */
  37 #endif
  38
  39 #include "gdbsupport/gdb_sys_time.h"
  40
  41 #ifdef USE_WIN32API
  42 #include <ws2tcpip.h>
  43 #ifndef ETIMEDOUT
  44 #define ETIMEDOUT WSAETIMEDOUT
  45 #endif
  46 /* Gnulib defines close too, but gnulib's replacement
  47    doesn't call closesocket unless we import the
  48    socketlib module.  */
  49 #undef close
  50 #define close(fd) closesocket (fd)
  51 #define ioctl ioctlsocket
  52 #else
  53 #include <netinet/in.h>
  54 #include <arpa/inet.h>
  55 #include <netdb.h>
  56 #include <sys/socket.h>
  57 #include <netinet/tcp.h>
  58 #endif
  59
  60 #include <signal.h>
  61 #include "gdb_select.h"
  62 #include <algorithm>
  63
  64 #ifndef HAVE_SOCKLEN_T
  65 typedef int socklen_t;
  66 #endif
  67
  68 /* For "set tcp" and "show tcp".  */
  69
  70 static struct cmd_list_element *tcp_set_cmdlist;
  71 static struct cmd_list_element *tcp_show_cmdlist;
  72
  73 /* Whether to auto-retry refused connections.  */
  74
  75 static bool tcp_auto_retry = true;
  76
  77 /* Timeout period for connections, in seconds.  */
  78
  79 static unsigned int tcp_retry_limit = 15;
  80
  81 /* How many times per second to poll deprecated_ui_loop_hook.  */
  82
  83 #define POLL_INTERVAL 5
  84
  85 /* Helper function to wait a while.  If SOCK is not -1, wait on its
  86    file descriptor.  Otherwise just wait on a timeout, updating
  87    *POLLS.  Returns -1 on timeout or interrupt, otherwise the value of
  88    select.  */
  89
  90 static int
  91 wait_for_connect (int sock, unsigned int *polls)
  92 {
  93   struct timeval t;
  94   int n;
  95
  96   /* While we wait for the connect to complete,
  97      poll the UI so it can update or the user can
  98      interrupt.  */
  99   if (deprecated_ui_loop_hook && deprecated_ui_loop_hook (0))
 100     {
 101       errno = EINTR;
 102       return -1;
 103     }
 104
 105   /* Check for timeout.  */
 106   if (*polls > tcp_retry_limit * POLL_INTERVAL)
 107     {
 108       errno = ETIMEDOUT;
 109       return -1;
 110     }
 111
 112   /* Back off to polling once per second after the first POLL_INTERVAL
 113      polls.  */
 114   if (*polls < POLL_INTERVAL)
 115     {
 116       t.tv_sec = 0;
 117       t.tv_usec = 1000000 / POLL_INTERVAL;
 118     }
 119   else
 120     {
 121       t.tv_sec = 1;
 122       t.tv_usec = 0;
 123     }
 124
 125   if (sock >= 0)
 126     {
 127       fd_set rset, wset, eset;
 128
 129       FD_ZERO (&rset);
 130       FD_SET (sock, &rset);
 131       wset = rset;
 132       eset = rset;
 133
 134       /* POSIX systems return connection success or failure by signalling
 135          wset.  Windows systems return success in wset and failure in
 136          eset.
 137
 138          We must call select here, rather than gdb_select, because
 139          the serial structure has not yet been initialized - the
 140          MinGW select wrapper will not know that this FD refers
 141          to a socket.  */
 142       n = select (sock + 1, &rset, &wset, &eset, &t);
 143     }
 144   else
 145     /* Use gdb_select here, since we have no file descriptors, and on
 146        Windows, plain select doesn't work in that case.  */
 147     n = gdb_select (0, NULL, NULL, NULL, &t);
 148
 149   /* If we didn't time out, only count it as one poll.  */
 150   if (n > 0 || *polls < POLL_INTERVAL)
 151     (*polls)++;
 152   else
 153     (*polls) += POLL_INTERVAL;
 154
 155   return n;
 156 }
 157
 158 /* Try to connect to the host represented by AINFO.  If the connection
 159    succeeds, return its socket.  Otherwise, return -1 and set ERRNO
 160    accordingly.  POLLS is used when 'connect' returns EINPROGRESS, and
 161    we need to invoke 'wait_for_connect' to obtain the status.  */
 162
 163 static int
 164 try_connect (const struct addrinfo *ainfo, unsigned int *polls)
 165 {
 166   int sock = gdb_socket_cloexec (ainfo->ai_family, ainfo->ai_socktype,
 167                                  ainfo->ai_protocol);
 168
 169   if (sock < 0)
 170     return -1;
 171
 172   /* Set socket nonblocking.  */
 173 #ifdef USE_WIN32API
 174   u_long ioarg = 1;
 175 #else
 176   int ioarg = 1;
 177 #endif
 178
 179   ioctl (sock, FIONBIO, &ioarg);
 180
 181   /* Use Non-blocking connect.  connect() will return 0 if connected
 182      already.  */
 183   if (connect (sock, ainfo->ai_addr, ainfo->ai_addrlen) < 0)
 184     {
 185 #ifdef USE_WIN32API
 186       int err = WSAGetLastError();
 187 #else
 188       int err = errno;
 189 #endif
 190
 191       /* If we've got a "connection refused" error, just return
 192          -1.  The caller will know what to do.  */
 193       if (
 194 #ifdef USE_WIN32API
 195           err == WSAECONNREFUSED
 196 #else
 197           err == ECONNREFUSED
 198 #endif
 199           )
 200         {
 201           close (sock);
 202           errno = err;
 203           return -1;
 204         }
 205
 206       if (
 207           /* Any other error (except EINPROGRESS) will be "swallowed"
 208              here.  We return without specifying a return value, and
 209              set errno if the caller wants to inspect what
 210              happened.  */
 211 #ifdef USE_WIN32API
 212           /* Under Windows, calling "connect" with a non-blocking socket
 213              results in WSAEWOULDBLOCK, not WSAEINPROGRESS.  */
 214           err != WSAEWOULDBLOCK
 215 #else
 216           err != EINPROGRESS
 217 #endif
 218           )
 219         {
 220           close (sock);
 221           errno = err;
 222           return -1;
 223         }
 224
 225       /* Looks like we need to wait for the connect.  */
 226       int n;
 227
 228       do
 229         n = wait_for_connect (sock, polls);
 230       while (n == 0);
 231
 232       if (n < 0)
 233         {
 234           int saved_errno = errno;
 235
 236           /* A negative value here means that we either timed out or
 237              got interrupted by the user.  Just return.  */
 238           close (sock);
 239           errno = saved_errno;
 240           return -1;
 241         }
 242     }
 243
 244   /* Got something.  Is it an error?  */
 245   int err;
 246   socklen_t len = sizeof (err);
 247
 248   /* On Windows, the fourth parameter to getsockopt is a "char *";
 249      on UNIX systems it is generally "void *".  The cast to "char *"
 250      is OK everywhere, since in C++ any data pointer type can be
 251      implicitly converted to "void *".  */
 252   int ret = getsockopt (sock, SOL_SOCKET, SO_ERROR, (char *) &err, &len);
 253
 254   if (ret < 0)
 255     {
 256       int saved_errno = errno;
 257
 258       close (sock);
 259       errno = saved_errno;
 260       return -1;
 261     }
 262   else if (ret == 0 && err != 0)
 263     {
 264       close (sock);
 265       errno = err;
 266       return -1;
 267     }
 268
 269   /* The connection succeeded.  Return the socket.  */
 270   return sock;
 271 }
 272
 273 /* Open a tcp socket.  */
 274
 275 int
 276 net_open (struct serial *scb, const char *name)
 277 {
 278   struct addrinfo hint;
 279   struct addrinfo *ainfo;
 280
 281   memset (&hint, 0, sizeof (hint));
 282   /* Assume no prefix will be passed, therefore we should use
 283      AF_UNSPEC.  */
 284   hint.ai_family = AF_UNSPEC;
 285   hint.ai_socktype = SOCK_STREAM;
 286   hint.ai_protocol = IPPROTO_TCP;
 287
 288   parsed_connection_spec parsed = parse_connection_spec (name, &hint);
 289
 290   if (parsed.port_str.empty ())
 291     error (_("Missing port on hostname '%s'"), name);
 292
 293   int r = getaddrinfo (parsed.host_str.c_str (),
 294                        parsed.port_str.c_str (),
 295                        &hint, &ainfo);
 296
 297   if (r != 0)
 298     {
 299       fprintf_unfiltered (gdb_stderr, _("%s: cannot resolve name: %s\n"),
 300                           name, gai_strerror (r));
 301       errno = ENOENT;
 302       return -1;
 303     }
 304
 305   scoped_free_addrinfo free_ainfo (ainfo);
 306
 307   /* Flag to indicate whether we've got a connection refused.  It will
 308      be true if any of the connections tried was refused.  */
 309   bool got_connrefused;
 310   /* If a connection succeeds, SUCCESS_AINFO will point to the
 311      'struct addrinfo' that succeed.  */
 312   struct addrinfo *success_ainfo = NULL;
 313   unsigned int polls = 0;
 314
 315   /* Assume the worst.  */
 316   scb->fd = -1;
 317
 318   do
 319     {
 320       got_connrefused = false;
 321
 322       for (addrinfo *iter = ainfo; iter != NULL; iter = iter->ai_next)
 323         {
 324           /* Iterate over the list of possible addresses to connect
 325              to.  For each, we'll try to connect and see if it
 326              succeeds.  */
 327           int sock = try_connect (iter, &polls);
 328
 329           if (sock >= 0)
 330             {
 331               /* We've gotten a successful connection.  Save its
 332                  'struct addrinfo', the socket, and break.  */
 333               success_ainfo = iter;
 334               scb->fd = sock;
 335               break;
 336             }
 337           else if (
 338 #ifdef USE_WIN32API
 339           errno == WSAECONNREFUSED
 340 #else
 341           errno == ECONNREFUSED
 342 #endif
 343                    )
 344             got_connrefused = true;
 345         }
 346     }
 347   /* Just retry if:
 348
 349      - tcp_auto_retry is true, and
 350      - We haven't gotten a connection yet, and
 351      - Any of our connection attempts returned with ECONNREFUSED, and
 352      - wait_for_connect signals that we can keep going.  */
 353   while (tcp_auto_retry
 354          && success_ainfo == NULL
 355          && got_connrefused
 356          && wait_for_connect (-1, &polls) >= 0);
 357
 358   if (success_ainfo == NULL)
 359     {
 360       net_close (scb);
 361       return -1;
 362     }
 363
 364   /* Turn off nonblocking.  */
 365 #ifdef USE_WIN32API
 366   u_long ioarg = 0;
 367 #else
 368   int ioarg = 0;
 369 #endif
 370
 371   ioctl (scb->fd, FIONBIO, &ioarg);
 372
 373   if (success_ainfo->ai_protocol == IPPROTO_TCP)
 374     {
 375       /* Disable Nagle algorithm.  Needed in some cases.  */
 376       int tmp = 1;
 377
 378       setsockopt (scb->fd, IPPROTO_TCP, TCP_NODELAY,
 379                   (char *) &tmp, sizeof (tmp));
 380     }
 381
 382 #ifdef SIGPIPE
 383   /* If we don't do this, then GDB simply exits
 384      when the remote side dies.  */
 385   signal (SIGPIPE, SIG_IGN);
 386 #endif
 387
 388   return 0;
 389 }
 390
 391 void
 392 net_close (struct serial *scb)
 393 {
 394   if (scb->fd == -1)
 395     return;
 396
 397   close (scb->fd);
 398   scb->fd = -1;
 399 }
 400
 401 int
 402 net_read_prim (struct serial *scb, size_t count)
 403 {
 404   /* Need to cast to silence -Wpointer-sign on MinGW, as Winsock's
 405      'recv' takes 'char *' as second argument, while 'scb->buf' is
 406      'unsigned char *'.  */
 407   return recv (scb->fd, (char *) scb->buf, count, 0);
 408 }
 409
 410 int
 411 net_write_prim (struct serial *scb, const void *buf, size_t count)
 412 {
 413   /* On Windows, the second parameter to send is a "const char *"; on
 414      UNIX systems it is generally "const void *".  The cast to "const
 415      char *" is OK everywhere, since in C++ any data pointer type can
 416      be implicitly converted to "const void *".  */
 417   return send (scb->fd, (const char *) buf, count, 0);
 418 }
 419
 420 int
 421 ser_tcp_send_break (struct serial *scb)
 422 {
 423   /* Send telnet IAC and BREAK characters.  */
 424   return (serial_write (scb, "\377\363", 2));
 425 }
 426
 427 /* Support for "set tcp" and "show tcp" commands.  */
 428
 429 static void
 430 set_tcp_cmd (const char *args, int from_tty)
 431 {
 432   help_list (tcp_set_cmdlist, "set tcp ", all_commands, gdb_stdout);
 433 }
 434
 435 static void
 436 show_tcp_cmd (const char *args, int from_tty)
 437 {
 438   help_list (tcp_show_cmdlist, "show tcp ", all_commands, gdb_stdout);
 439 }
 440
 441 #ifndef USE_WIN32API
 442
 443 /* The TCP ops.  */
 444
 445 static const struct serial_ops tcp_ops =
 446 {
 447   "tcp",
 448   net_open,
 449   net_close,
 450   NULL,
 451   ser_base_readchar,
 452   ser_base_write,
 453   ser_base_flush_output,
 454   ser_base_flush_input,
 455   ser_tcp_send_break,
 456   ser_base_raw,
 457   ser_base_get_tty_state,
 458   ser_base_copy_tty_state,
 459   ser_base_set_tty_state,
 460   ser_base_print_tty_state,
 461   ser_base_setbaudrate,
 462   ser_base_setstopbits,
 463   ser_base_setparity,
 464   ser_base_drain_output,
 465   ser_base_async,
 466   net_read_prim,
 467   net_write_prim
 468 };
 469
 470 #endif /* USE_WIN32API */
 471
 472 void
 473 _initialize_ser_tcp (void)
 474 {
 475 #ifdef USE_WIN32API
 476   /* Do nothing; the TCP serial operations will be initialized in
 477      ser-mingw.c.  */
 478 #else
 479   serial_add_interface (&tcp_ops);
 480 #endif /* USE_WIN32API */
 481
 482   add_prefix_cmd ("tcp", class_maintenance, set_tcp_cmd, _("\
 483 TCP protocol specific variables.\n\
 484 Configure variables specific to remote TCP connections."),
 485                   &tcp_set_cmdlist, "set tcp ",
 486                   0 /* allow-unknown */, &setlist);
 487   add_prefix_cmd ("tcp", class_maintenance, show_tcp_cmd, _("\
 488 TCP protocol specific variables.\n\
 489 Configure variables specific to remote TCP connections."),
 490                   &tcp_show_cmdlist, "show tcp ",
 491                   0 /* allow-unknown */, &showlist);
 492
 493   add_setshow_boolean_cmd ("auto-retry", class_obscure,
 494                            &tcp_auto_retry, _("\
 495 Set auto-retry on socket connect."), _("\
 496 Show auto-retry on socket connect."),
 497                            NULL, NULL, NULL,
 498                            &tcp_set_cmdlist, &tcp_show_cmdlist);
 499
 500   add_setshow_uinteger_cmd ("connect-timeout", class_obscure,
 501                             &tcp_retry_limit, _("\
 502 Set timeout limit in seconds for socket connection."), _("\
 503 Show timeout limit in seconds for socket connection."), _("\
 504 If set to \"unlimited\", GDB will keep attempting to establish a\n\
 505 connection forever, unless interrupted with Ctrl-c.\n\
 506 The default is 15 seconds."),
 507                             NULL, NULL,
 508                             &tcp_set_cmdlist, &tcp_show_cmdlist);
 509 }