gdb/ser-tcp.c

   1 /* Serial interface for raw TCP connections on Un*x like systems.
   2
   3    Copyright (C) 1992-2022 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 "gdbsupport/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 = interruptible_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       gdb_printf (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 #ifndef USE_WIN32API
 428
 429 /* The TCP ops.  */
 430
 431 static const struct serial_ops tcp_ops =
 432 {
 433   "tcp",
 434   net_open,
 435   net_close,
 436   NULL,
 437   ser_base_readchar,
 438   ser_base_write,
 439   ser_base_flush_output,
 440   ser_base_flush_input,
 441   ser_tcp_send_break,
 442   ser_base_raw,
 443   ser_base_get_tty_state,
 444   ser_base_copy_tty_state,
 445   ser_base_set_tty_state,
 446   ser_base_print_tty_state,
 447   ser_base_setbaudrate,
 448   ser_base_setstopbits,
 449   ser_base_setparity,
 450   ser_base_drain_output,
 451   ser_base_async,
 452   net_read_prim,
 453   net_write_prim
 454 };
 455
 456 #endif /* USE_WIN32API */
 457
 458 void _initialize_ser_tcp ();
 459 void
 460 _initialize_ser_tcp ()
 461 {
 462 #ifdef USE_WIN32API
 463   /* Do nothing; the TCP serial operations will be initialized in
 464      ser-mingw.c.  */
 465 #else
 466   serial_add_interface (&tcp_ops);
 467 #endif /* USE_WIN32API */
 468
 469   add_setshow_prefix_cmd ("tcp", class_maintenance,
 470                           _("\
 471 TCP protocol specific variables.\n\
 472 Configure variables specific to remote TCP connections."),
 473                           _("\
 474 TCP protocol specific variables.\n\
 475 Configure variables specific to remote TCP connections."),
 476                           &tcp_set_cmdlist, &tcp_show_cmdlist,
 477                           &setlist, &showlist);
 478
 479   add_setshow_boolean_cmd ("auto-retry", class_obscure,
 480                            &tcp_auto_retry, _("\
 481 Set auto-retry on socket connect."), _("\
 482 Show auto-retry on socket connect."),
 483                            NULL, NULL, NULL,
 484                            &tcp_set_cmdlist, &tcp_show_cmdlist);
 485
 486   add_setshow_uinteger_cmd ("connect-timeout", class_obscure,
 487                             &tcp_retry_limit, _("\
 488 Set timeout limit in seconds for socket connection."), _("\
 489 Show timeout limit in seconds for socket connection."), _("\
 490 If set to \"unlimited\", GDB will keep attempting to establish a\n\
 491 connection forever, unless interrupted with Ctrl-c.\n\
 492 The default is 15 seconds."),
 493                             NULL, NULL,
 494                             &tcp_set_cmdlist, &tcp_show_cmdlist);
 495 }