gdb/ser-tcp.c

   1 /* Serial interface for raw TCP connections on Un*x like systems
   2    Copyright 1992, 1993, 1998 Free Software Foundation, Inc.
   3
   4    This file is part of GDB.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 59 Temple Place - Suite 330,
  19    Boston, MA 02111-1307, USA.  */
  20
  21 #include "defs.h"
  22 #include "serial.h"
  23 #include <sys/types.h>
  24 #include <sys/time.h>
  25 #include <netinet/in.h>
  26 #include <arpa/inet.h>
  27 #include <netdb.h>
  28 #include <sys/socket.h>
  29 #ifdef HAVE_UNISTD_H
  30 #include <unistd.h>
  31 #endif
  32
  33 #ifndef __CYGWIN32__
  34 #include <netinet/tcp.h>
  35 #endif
  36
  37 #include "signals.h"
  38 #include "gdb_string.h"
  39
  40 extern int (*ui_loop_hook) PARAMS ((int));
  41
  42 struct tcp_ttystate
  43   {
  44     int bogus;
  45   };
  46
  47 static int tcp_open PARAMS ((serial_t scb, const char *name));
  48 static void tcp_raw PARAMS ((serial_t scb));
  49 static int wait_for PARAMS ((serial_t scb, int timeout));
  50 static int tcp_readchar PARAMS ((serial_t scb, int timeout));
  51 static int tcp_setbaudrate PARAMS ((serial_t scb, int rate));
  52 static int tcp_setstopbits PARAMS ((serial_t scb, int num));
  53 static int tcp_write PARAMS ((serial_t scb, const char *str, int len));
  54 /* FIXME: static void tcp_restore PARAMS ((serial_t scb)); */
  55 static void tcp_close PARAMS ((serial_t scb));
  56 static serial_ttystate tcp_get_tty_state PARAMS ((serial_t scb));
  57 static int tcp_set_tty_state PARAMS ((serial_t scb, serial_ttystate state));
  58 static int tcp_return_0 PARAMS ((serial_t));
  59 static int tcp_noflush_set_tty_state PARAMS ((serial_t, serial_ttystate,
  60                                               serial_ttystate));
  61 static void tcp_print_tty_state PARAMS ((serial_t, serial_ttystate));
  62
  63 void _initialize_ser_tcp PARAMS ((void));
  64
  65 /* Open up a raw tcp socket */
  66
  67 static int
  68 tcp_open (scb, name)
  69      serial_t scb;
  70      const char *name;
  71 {
  72   char *port_str;
  73   int port;
  74   struct hostent *hostent;
  75   struct sockaddr_in sockaddr;
  76   int tmp;
  77   char hostname[100];
  78   struct protoent *protoent;
  79   int i;
  80
  81   port_str = strchr (name, ':');
  82
  83   if (!port_str)
  84     error ("tcp_open: No colon in host name!");         /* Shouldn't ever happen */
  85
  86   tmp = min (port_str - name, (int) sizeof hostname - 1);
  87   strncpy (hostname, name, tmp);        /* Don't want colon */
  88   hostname[tmp] = '\000';       /* Tie off host name */
  89   port = atoi (port_str + 1);
  90
  91   hostent = gethostbyname (hostname);
  92
  93   if (!hostent)
  94     {
  95       fprintf_unfiltered (gdb_stderr, "%s: unknown host\n", hostname);
  96       errno = ENOENT;
  97       return -1;
  98     }
  99
 100   for (i = 1; i <= 15; i++)
 101     {
 102       scb->fd = socket (PF_INET, SOCK_STREAM, 0);
 103       if (scb->fd < 0)
 104         return -1;
 105
 106       /* Allow rapid reuse of this port. */
 107       tmp = 1;
 108       setsockopt (scb->fd, SOL_SOCKET, SO_REUSEADDR, (char *) &tmp, sizeof (tmp));
 109
 110       /* Enable TCP keep alive process. */
 111       tmp = 1;
 112       setsockopt (scb->fd, SOL_SOCKET, SO_KEEPALIVE, (char *) &tmp, sizeof (tmp));
 113
 114       sockaddr.sin_family = PF_INET;
 115       sockaddr.sin_port = htons (port);
 116       memcpy (&sockaddr.sin_addr.s_addr, hostent->h_addr,
 117               sizeof (struct in_addr));
 118
 119       if (!connect (scb->fd, (struct sockaddr *) &sockaddr, sizeof (sockaddr)))
 120         break;
 121
 122       close (scb->fd);
 123       scb->fd = -1;
 124
 125 /* We retry for ECONNREFUSED because that is often a temporary condition, which
 126    happens when the server is being restarted.  */
 127
 128       if (errno != ECONNREFUSED)
 129         return -1;
 130
 131       sleep (1);
 132     }
 133
 134   protoent = getprotobyname ("tcp");
 135   if (!protoent)
 136     return -1;
 137
 138   tmp = 1;
 139   if (setsockopt (scb->fd, protoent->p_proto, TCP_NODELAY,
 140                   (char *) &tmp, sizeof (tmp)))
 141     return -1;
 142
 143   signal (SIGPIPE, SIG_IGN);    /* If we don't do this, then GDB simply exits
 144                                    when the remote side dies.  */
 145
 146   return 0;
 147 }
 148
 149 static serial_ttystate
 150 tcp_get_tty_state (scb)
 151      serial_t scb;
 152 {
 153   struct tcp_ttystate *state;
 154
 155   state = (struct tcp_ttystate *) xmalloc (sizeof *state);
 156
 157   return (serial_ttystate) state;
 158 }
 159
 160 static int
 161 tcp_set_tty_state (scb, ttystate)
 162      serial_t scb;
 163      serial_ttystate ttystate;
 164 {
 165   struct tcp_ttystate *state;
 166
 167   state = (struct tcp_ttystate *) ttystate;
 168
 169   return 0;
 170 }
 171
 172 static int
 173 tcp_return_0 (scb)
 174      serial_t scb;
 175 {
 176   return 0;
 177 }
 178
 179 static void
 180 tcp_raw (scb)
 181      serial_t scb;
 182 {
 183   return;                       /* Always in raw mode */
 184 }
 185
 186 /* Wait for input on scb, with timeout seconds.  Returns 0 on success,
 187    otherwise SERIAL_TIMEOUT or SERIAL_ERROR.
 188
 189    For termio{s}, we actually just setup VTIME if necessary, and let the
 190    timeout occur in the read() in tcp_read().
 191  */
 192
 193 static int
 194 wait_for (scb, timeout)
 195      serial_t scb;
 196      int timeout;
 197 {
 198   int numfds;
 199   struct timeval tv;
 200   fd_set readfds, exceptfds;
 201
 202   FD_ZERO (&readfds);
 203   FD_ZERO (&exceptfds);
 204
 205   tv.tv_sec = timeout;
 206   tv.tv_usec = 0;
 207
 208   FD_SET (scb->fd, &readfds);
 209   FD_SET (scb->fd, &exceptfds);
 210
 211   while (1)
 212     {
 213       if (timeout >= 0)
 214         numfds = select (scb->fd + 1, &readfds, 0, &exceptfds, &tv);
 215       else
 216         numfds = select (scb->fd + 1, &readfds, 0, &exceptfds, 0);
 217
 218       if (numfds <= 0)
 219         {
 220           if (numfds == 0)
 221             return SERIAL_TIMEOUT;
 222           else if (errno == EINTR)
 223             continue;
 224           else
 225             return SERIAL_ERROR;        /* Got an error from select or poll */
 226         }
 227
 228       return 0;
 229     }
 230 }
 231
 232 /* Read a character with user-specified timeout.  TIMEOUT is number of seconds
 233    to wait, or -1 to wait forever.  Use timeout of 0 to effect a poll.  Returns
 234    char if successful.  Returns -2 if timeout expired, EOF if line dropped
 235    dead, or -3 for any other error (see errno in that case). */
 236
 237 static int
 238 tcp_readchar (scb, timeout)
 239      serial_t scb;
 240      int timeout;
 241 {
 242   int status;
 243   int delta;
 244
 245   if (scb->bufcnt-- > 0)
 246     return *scb->bufp++;
 247
 248   /* We have to be able to keep the GUI alive here, so we break the original
 249      timeout into steps of 1 second, running the "keep the GUI alive" hook
 250      each time through the loop.
 251
 252      Also, timeout = 0 means to poll, so we just set the delta to 0, so we
 253      will only go through the loop once. */
 254
 255   delta = (timeout == 0 ? 0 : 1);
 256   while (1)
 257     {
 258
 259       /* N.B. The UI may destroy our world (for instance by calling
 260          remote_stop,) in which case we want to get out of here as
 261          quickly as possible.  It is not safe to touch scb, since
 262          someone else might have freed it.  The ui_loop_hook signals that
 263          we should exit by returning 1. */
 264
 265       if (ui_loop_hook)
 266         {
 267           if (ui_loop_hook (0))
 268             return SERIAL_TIMEOUT;
 269         }
 270
 271       status = wait_for (scb, delta);
 272       timeout -= delta;
 273
 274       /* If we got a character or an error back from wait_for, then we can
 275          break from the loop before the timeout is completed. */
 276
 277       if (status != SERIAL_TIMEOUT)
 278         {
 279           break;
 280         }
 281
 282       /* If we have exhausted the original timeout, then generate
 283          a SERIAL_TIMEOUT, and pass it out of the loop. */
 284
 285       else if (timeout == 0)
 286         {
 287           status == SERIAL_TIMEOUT;
 288           break;
 289         }
 290     }
 291
 292   if (status < 0)
 293     return status;
 294
 295   while (1)
 296     {
 297       scb->bufcnt = read (scb->fd, scb->buf, BUFSIZ);
 298       if (scb->bufcnt != -1 || errno != EINTR)
 299         break;
 300     }
 301
 302   if (scb->bufcnt <= 0)
 303     {
 304       if (scb->bufcnt == 0)
 305         return SERIAL_TIMEOUT;  /* 0 chars means timeout [may need to
 306                                    distinguish between EOF & timeouts
 307                                    someday] */
 308       else
 309         return SERIAL_ERROR;    /* Got an error from read */
 310     }
 311
 312   scb->bufcnt--;
 313   scb->bufp = scb->buf;
 314   return *scb->bufp++;
 315 }
 316
 317 static int
 318 tcp_noflush_set_tty_state (scb, new_ttystate, old_ttystate)
 319      serial_t scb;
 320      serial_ttystate new_ttystate;
 321      serial_ttystate old_ttystate;
 322 {
 323   return 0;
 324 }
 325
 326 static void
 327 tcp_print_tty_state (scb, ttystate)
 328      serial_t scb;
 329      serial_ttystate ttystate;
 330 {
 331   /* Nothing to print.  */
 332   return;
 333 }
 334
 335 static int
 336 tcp_setbaudrate (scb, rate)
 337      serial_t scb;
 338      int rate;
 339 {
 340   return 0;                     /* Never fails! */
 341 }
 342
 343 static int
 344 tcp_setstopbits (scb, num)
 345      serial_t scb;
 346      int num;
 347 {
 348   return 0;                     /* Never fails! */
 349 }
 350
 351 static int
 352 tcp_write (scb, str, len)
 353      serial_t scb;
 354      const char *str;
 355      int len;
 356 {
 357   int cc;
 358
 359   while (len > 0)
 360     {
 361       cc = write (scb->fd, str, len);
 362
 363       if (cc < 0)
 364         return 1;
 365       len -= cc;
 366       str += cc;
 367     }
 368   return 0;
 369 }
 370
 371 static void
 372 tcp_close (scb)
 373      serial_t scb;
 374 {
 375   if (scb->fd < 0)
 376     return;
 377
 378   close (scb->fd);
 379   scb->fd = -1;
 380 }
 381
 382 static struct serial_ops tcp_ops =
 383 {
 384   "tcp",
 385   0,
 386   tcp_open,
 387   tcp_close,
 388   tcp_readchar,
 389   tcp_write,
 390   tcp_return_0,                 /* flush output */
 391   tcp_return_0,                 /* flush input */
 392   tcp_return_0,                 /* send break */
 393   tcp_raw,
 394   tcp_get_tty_state,
 395   tcp_set_tty_state,
 396   tcp_print_tty_state,
 397   tcp_noflush_set_tty_state,
 398   tcp_setbaudrate,
 399   tcp_setstopbits,
 400   tcp_return_0,                 /* wait for output to drain */
 401 };
 402
 403 void
 404 _initialize_ser_tcp ()
 405 {
 406   serial_add_interface (&tcp_ops);
 407 }