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