gdb/ser-tcp.c

   1 /* Serial interface for raw TCP connections on Un*x like systems.
   2
   3    Copyright (C) 1992-2017 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 "filestuff.h"
  28
  29 #include <sys/types.h>
  30
  31 #ifdef HAVE_SYS_FILIO_H
  32 #include <sys/filio.h>  /* For FIONBIO.  */
  33 #endif
  34 #ifdef HAVE_SYS_IOCTL_H
  35 #include <sys/ioctl.h>  /* For FIONBIO.  */
  36 #endif
  37
  38 #include "gdb_sys_time.h"
  39
  40 #ifdef USE_WIN32API
  41 #include <winsock2.h>
  42 #ifndef ETIMEDOUT
  43 #define ETIMEDOUT WSAETIMEDOUT
  44 #endif
  45 #define close(fd) closesocket (fd)
  46 #define ioctl ioctlsocket
  47 #else
  48 #include <netinet/in.h>
  49 #include <arpa/inet.h>
  50 #include <netdb.h>
  51 #include <sys/socket.h>
  52 #include <netinet/tcp.h>
  53 #endif
  54
  55 #include <signal.h>
  56 #include "gdb_select.h"
  57 #include <algorithm>
  58
  59 #ifndef HAVE_SOCKLEN_T
  60 typedef int socklen_t;
  61 #endif
  62
  63 void _initialize_ser_tcp (void);
  64
  65 /* For "set tcp" and "show tcp".  */
  66
  67 static struct cmd_list_element *tcp_set_cmdlist;
  68 static struct cmd_list_element *tcp_show_cmdlist;
  69
  70 /* Whether to auto-retry refused connections.  */
  71
  72 static int tcp_auto_retry = 1;
  73
  74 /* Timeout period for connections, in seconds.  */
  75
  76 static unsigned int tcp_retry_limit = 15;
  77
  78 /* How many times per second to poll deprecated_ui_loop_hook.  */
  79
  80 #define POLL_INTERVAL 5
  81
  82 /* Helper function to wait a while.  If SCB is non-null, wait on its
  83    file descriptor.  Otherwise just wait on a timeout, updating *POLLS.
  84    Returns -1 on timeout or interrupt, otherwise the value of select.  */
  85
  86 static int
  87 wait_for_connect (struct serial *scb, unsigned int *polls)
  88 {
  89   struct timeval t;
  90   int n;
  91
  92   /* While we wait for the connect to complete,
  93      poll the UI so it can update or the user can
  94      interrupt.  */
  95   if (deprecated_ui_loop_hook && deprecated_ui_loop_hook (0))
  96     {
  97       errno = EINTR;
  98       return -1;
  99     }
 100
 101   /* Check for timeout.  */
 102   if (*polls > tcp_retry_limit * POLL_INTERVAL)
 103     {
 104       errno = ETIMEDOUT;
 105       return -1;
 106     }
 107
 108   /* Back off to polling once per second after the first POLL_INTERVAL
 109      polls.  */
 110   if (*polls < POLL_INTERVAL)
 111     {
 112       t.tv_sec = 0;
 113       t.tv_usec = 1000000 / POLL_INTERVAL;
 114     }
 115   else
 116     {
 117       t.tv_sec = 1;
 118       t.tv_usec = 0;
 119     }
 120
 121   if (scb)
 122     {
 123       fd_set rset, wset, eset;
 124
 125       FD_ZERO (&rset);
 126       FD_SET (scb->fd, &rset);
 127       wset = rset;
 128       eset = rset;
 129
 130       /* POSIX systems return connection success or failure by signalling
 131          wset.  Windows systems return success in wset and failure in
 132          eset.
 133
 134          We must call select here, rather than gdb_select, because
 135          the serial structure has not yet been initialized - the
 136          MinGW select wrapper will not know that this FD refers
 137          to a socket.  */
 138       n = select (scb->fd + 1, &rset, &wset, &eset, &t);
 139     }
 140   else
 141     /* Use gdb_select here, since we have no file descriptors, and on
 142        Windows, plain select doesn't work in that case.  */
 143     n = gdb_select (0, NULL, NULL, NULL, &t);
 144
 145   /* If we didn't time out, only count it as one poll.  */
 146   if (n > 0 || *polls < POLL_INTERVAL)
 147     (*polls)++;
 148   else
 149     (*polls) += POLL_INTERVAL;
 150
 151   return n;
 152 }
 153
 154 /* Open a tcp socket.  */
 155
 156 int
 157 net_open (struct serial *scb, const char *name)
 158 {
 159   char hostname[100];
 160   const char *port_str;
 161   int n, port, tmp;
 162   int use_udp;
 163   struct hostent *hostent;
 164   struct sockaddr_in sockaddr;
 165 #ifdef USE_WIN32API
 166   u_long ioarg;
 167 #else
 168   int ioarg;
 169 #endif
 170   unsigned int polls = 0;
 171
 172   use_udp = 0;
 173   if (startswith (name, "udp:"))
 174     {
 175       use_udp = 1;
 176       name = name + 4;
 177     }
 178   else if (startswith (name, "tcp:"))
 179     name = name + 4;
 180
 181   port_str = strchr (name, ':');
 182
 183   if (!port_str)
 184     error (_("net_open: No colon in host name!"));  /* Shouldn't ever
 185                                                        happen.  */
 186
 187   tmp = std::min (port_str - name, (ptrdiff_t) sizeof hostname - 1);
 188   strncpy (hostname, name, tmp);        /* Don't want colon.  */
 189   hostname[tmp] = '\000';       /* Tie off host name.  */
 190   port = atoi (port_str + 1);
 191
 192   /* Default hostname is localhost.  */
 193   if (!hostname[0])
 194     strcpy (hostname, "localhost");
 195
 196   hostent = gethostbyname (hostname);
 197   if (!hostent)
 198     {
 199       fprintf_unfiltered (gdb_stderr, "%s: unknown host\n", hostname);
 200       errno = ENOENT;
 201       return -1;
 202     }
 203
 204   sockaddr.sin_family = PF_INET;
 205   sockaddr.sin_port = htons (port);
 206   memcpy (&sockaddr.sin_addr.s_addr, hostent->h_addr,
 207           sizeof (struct in_addr));
 208
 209  retry:
 210
 211   if (use_udp)
 212     scb->fd = gdb_socket_cloexec (PF_INET, SOCK_DGRAM, 0);
 213   else
 214     scb->fd = gdb_socket_cloexec (PF_INET, SOCK_STREAM, 0);
 215
 216   if (scb->fd == -1)
 217     return -1;
 218
 219   /* Set socket nonblocking.  */
 220   ioarg = 1;
 221   ioctl (scb->fd, FIONBIO, &ioarg);
 222
 223   /* Use Non-blocking connect.  connect() will return 0 if connected
 224      already.  */
 225   n = connect (scb->fd, (struct sockaddr *) &sockaddr, sizeof (sockaddr));
 226
 227   if (n < 0)
 228     {
 229 #ifdef USE_WIN32API
 230       int err = WSAGetLastError();
 231 #else
 232       int err = errno;
 233 #endif
 234
 235       /* Maybe we're waiting for the remote target to become ready to
 236          accept connections.  */
 237       if (tcp_auto_retry
 238 #ifdef USE_WIN32API
 239           && err == WSAECONNREFUSED
 240 #else
 241           && err == ECONNREFUSED
 242 #endif
 243           && wait_for_connect (NULL, &polls) >= 0)
 244         {
 245           close (scb->fd);
 246           goto retry;
 247         }
 248
 249       if (
 250 #ifdef USE_WIN32API
 251           /* Under Windows, calling "connect" with a non-blocking socket
 252              results in WSAEWOULDBLOCK, not WSAEINPROGRESS.  */
 253           err != WSAEWOULDBLOCK
 254 #else
 255           err != EINPROGRESS
 256 #endif
 257           )
 258         {
 259           errno = err;
 260           net_close (scb);
 261           return -1;
 262         }
 263
 264       /* Looks like we need to wait for the connect.  */
 265       do
 266         {
 267           n = wait_for_connect (scb, &polls);
 268         }
 269       while (n == 0);
 270       if (n < 0)
 271         {
 272           net_close (scb);
 273           return -1;
 274         }
 275     }
 276
 277   /* Got something.  Is it an error?  */
 278   {
 279     int res, err;
 280     socklen_t len;
 281
 282     len = sizeof (err);
 283     /* On Windows, the fourth parameter to getsockopt is a "char *";
 284        on UNIX systems it is generally "void *".  The cast to "char *"
 285        is OK everywhere, since in C++ any data pointer type can be
 286        implicitly converted to "void *".  */
 287     res = getsockopt (scb->fd, SOL_SOCKET, SO_ERROR, (char *) &err, &len);
 288     if (res < 0 || err)
 289       {
 290         /* Maybe the target still isn't ready to accept the connection.  */
 291         if (tcp_auto_retry
 292 #ifdef USE_WIN32API
 293             && err == WSAECONNREFUSED
 294 #else
 295             && err == ECONNREFUSED
 296 #endif
 297             && wait_for_connect (NULL, &polls) >= 0)
 298           {
 299             close (scb->fd);
 300             goto retry;
 301           }
 302         if (err)
 303           errno = err;
 304         net_close (scb);
 305         return -1;
 306       }
 307   }
 308
 309   /* Turn off nonblocking.  */
 310   ioarg = 0;
 311   ioctl (scb->fd, FIONBIO, &ioarg);
 312
 313   if (use_udp == 0)
 314     {
 315       /* Disable Nagle algorithm.  Needed in some cases.  */
 316       tmp = 1;
 317       setsockopt (scb->fd, IPPROTO_TCP, TCP_NODELAY,
 318                   (char *)&tmp, sizeof (tmp));
 319     }
 320
 321 #ifdef SIGPIPE
 322   /* If we don't do this, then GDB simply exits
 323      when the remote side dies.  */
 324   signal (SIGPIPE, SIG_IGN);
 325 #endif
 326
 327   return 0;
 328 }
 329
 330 void
 331 net_close (struct serial *scb)
 332 {
 333   if (scb->fd == -1)
 334     return;
 335
 336   close (scb->fd);
 337   scb->fd = -1;
 338 }
 339
 340 int
 341 net_read_prim (struct serial *scb, size_t count)
 342 {
 343   /* Need to cast to silence -Wpointer-sign on MinGW, as Winsock's
 344      'recv' takes 'char *' as second argument, while 'scb->buf' is
 345      'unsigned char *'.  */
 346   return recv (scb->fd, (char *) scb->buf, count, 0);
 347 }
 348
 349 int
 350 net_write_prim (struct serial *scb, const void *buf, size_t count)
 351 {
 352   /* On Windows, the second parameter to send is a "const char *"; on
 353      UNIX systems it is generally "const void *".  The cast to "const
 354      char *" is OK everywhere, since in C++ any data pointer type can
 355      be implicitly converted to "const void *".  */
 356   return send (scb->fd, (const char *) buf, count, 0);
 357 }
 358
 359 int
 360 ser_tcp_send_break (struct serial *scb)
 361 {
 362   /* Send telnet IAC and BREAK characters.  */
 363   return (serial_write (scb, "\377\363", 2));
 364 }
 365
 366 /* Support for "set tcp" and "show tcp" commands.  */
 367
 368 static void
 369 set_tcp_cmd (char *args, int from_tty)
 370 {
 371   help_list (tcp_set_cmdlist, "set tcp ", all_commands, gdb_stdout);
 372 }
 373
 374 static void
 375 show_tcp_cmd (char *args, int from_tty)
 376 {
 377   help_list (tcp_show_cmdlist, "show tcp ", all_commands, gdb_stdout);
 378 }
 379
 380 #ifndef USE_WIN32API
 381
 382 /* The TCP ops.  */
 383
 384 static const struct serial_ops tcp_ops =
 385 {
 386   "tcp",
 387   net_open,
 388   net_close,
 389   NULL,
 390   ser_base_readchar,
 391   ser_base_write,
 392   ser_base_flush_output,
 393   ser_base_flush_input,
 394   ser_tcp_send_break,
 395   ser_base_raw,
 396   ser_base_get_tty_state,
 397   ser_base_copy_tty_state,
 398   ser_base_set_tty_state,
 399   ser_base_print_tty_state,
 400   ser_base_noflush_set_tty_state,
 401   ser_base_setbaudrate,
 402   ser_base_setstopbits,
 403   ser_base_setparity,
 404   ser_base_drain_output,
 405   ser_base_async,
 406   net_read_prim,
 407   net_write_prim
 408 };
 409
 410 #endif /* USE_WIN32API */
 411
 412 void
 413 _initialize_ser_tcp (void)
 414 {
 415 #ifdef USE_WIN32API
 416   /* Do nothing; the TCP serial operations will be initialized in
 417      ser-mingw.c.  */
 418 #else
 419   serial_add_interface (&tcp_ops);
 420 #endif /* USE_WIN32API */
 421
 422   add_prefix_cmd ("tcp", class_maintenance, set_tcp_cmd, _("\
 423 TCP protocol specific variables\n\
 424 Configure variables specific to remote TCP connections"),
 425                   &tcp_set_cmdlist, "set tcp ",
 426                   0 /* allow-unknown */, &setlist);
 427   add_prefix_cmd ("tcp", class_maintenance, show_tcp_cmd, _("\
 428 TCP protocol specific variables\n\
 429 Configure variables specific to remote TCP connections"),
 430                   &tcp_show_cmdlist, "show tcp ",
 431                   0 /* allow-unknown */, &showlist);
 432
 433   add_setshow_boolean_cmd ("auto-retry", class_obscure,
 434                            &tcp_auto_retry, _("\
 435 Set auto-retry on socket connect"), _("\
 436 Show auto-retry on socket connect"),
 437                            NULL, NULL, NULL,
 438                            &tcp_set_cmdlist, &tcp_show_cmdlist);
 439
 440   add_setshow_uinteger_cmd ("connect-timeout", class_obscure,
 441                             &tcp_retry_limit, _("\
 442 Set timeout limit in seconds for socket connection"), _("\
 443 Show timeout limit in seconds for socket connection"), _("\
 444 If set to \"unlimited\", GDB will keep attempting to establish a\n\
 445 connection forever, unless interrupted with Ctrl-c.\n\
 446 The default is 15 seconds."),
 447                             NULL, NULL,
 448                             &tcp_set_cmdlist, &tcp_show_cmdlist);
 449 }