gdb/ser-tcp.c

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