gdb/ser-tcp.c

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