gdb/serial.c

   1 /* Generic serial interface routines
   2    Copyright 1992, 1993 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., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20 #include "defs.h"
  21 #include "serial.h"
  22
  23 /* Linked list of serial I/O handlers */
  24
  25 static struct serial_ops *serial_ops_list = NULL;
  26
  27 /* This is the last serial stream opened.  Used by connect command. */
  28
  29 static serial_t last_serial_opened = NULL;
  30
  31 static struct serial_ops *
  32 serial_interface_lookup (name)
  33      char *name;
  34 {
  35   struct serial_ops *ops;
  36
  37   for (ops = serial_ops_list; ops; ops = ops->next)
  38     if (strcmp (name, ops->name) == 0)
  39       return ops;
  40
  41   return NULL;
  42 }
  43
  44 void
  45 serial_add_interface(optable)
  46      struct serial_ops *optable;
  47 {
  48   optable->next = serial_ops_list;
  49   serial_ops_list = optable;
  50 }
  51
  52 /* Open up a device or a network socket, depending upon the syntax of NAME. */
  53
  54 serial_t
  55 serial_open(name)
  56      const char *name;
  57 {
  58   serial_t scb;
  59   struct serial_ops *ops;
  60
  61   if (strchr (name, ':'))
  62     ops = serial_interface_lookup ("tcp");
  63   else
  64     ops = serial_interface_lookup ("hardwire");
  65
  66   if (!ops)
  67     return NULL;
  68
  69   scb = (serial_t)xmalloc (sizeof (struct _serial_t));
  70
  71   scb->ops = ops;
  72
  73   scb->bufcnt = 0;
  74   scb->bufp = scb->buf;
  75
  76   if (scb->ops->open(scb, name))
  77     {
  78       free (scb);
  79       return NULL;
  80     }
  81
  82   last_serial_opened = scb;
  83
  84   return scb;
  85 }
  86
  87 serial_t
  88 serial_fdopen(fd)
  89      const int fd;
  90 {
  91   serial_t scb;
  92   struct serial_ops *ops;
  93
  94   ops = serial_interface_lookup ("hardwire");
  95
  96   if (!ops)
  97     return NULL;
  98
  99   scb = (serial_t)xmalloc (sizeof (struct _serial_t));
 100
 101   scb->ops = ops;
 102
 103   scb->bufcnt = 0;
 104   scb->bufp = scb->buf;
 105
 106   scb->fd = fd;
 107
 108   last_serial_opened = scb;
 109
 110   return scb;
 111 }
 112
 113 void
 114 serial_close(scb)
 115      serial_t scb;
 116 {
 117   last_serial_opened = NULL;
 118
 119   if (scb != NULL)
 120     {
 121       scb->ops->close(scb);
 122       free(scb);
 123     }
 124 }
 125
 126 #if 0
 127 /*
 128 The connect command is #if 0 because I hadn't thought of an elegant
 129 way to wait for I/O on two serial_t's simultaneously.  Two solutions
 130 came to mind:
 131
 132         1) Fork, and have have one fork handle the to user direction,
 133            and have the other hand the to target direction.  This
 134            obviously won't cut it for MSDOS.
 135
 136         2) Use something like select.  This assumes that stdin and
 137            the target side can both be waited on via the same
 138            mechanism.  This may not be true for DOS, if GDB is
 139            talking to the target via a TCP socket.
 140 -grossman, 8 Jun 93
 141 */
 142
 143 /* Connect the user directly to the remote system.  This command acts just like
 144    the 'cu' or 'tip' command.  Use <CR>~. or <CR>~^D to break out.  */
 145
 146 static serial_t tty_desc;               /* Controlling terminal */
 147
 148 static void
 149 cleanup_tty(ttystate)
 150      serial_ttystate ttystate;
 151 {
 152   printf ("\r\n[Exiting connect mode]\r\n");
 153   SERIAL_SET_TTY_STATE (tty_desc, ttystate);
 154   free (ttystate);
 155   SERIAL_CLOSE (tty_desc);
 156 }
 157
 158 static void
 159 connect_command (args, fromtty)
 160      char       *args;
 161      int        fromtty;
 162 {
 163   int c;
 164   char cur_esc = 0;
 165   serial_ttystate ttystate;
 166   serial_t port_desc;           /* TTY port */
 167
 168   dont_repeat();
 169
 170   if (args)
 171     fprintf(stderr, "This command takes no args.  They have been ignored.\n");
 172
 173   printf("[Entering connect mode.  Use ~. or ~^D to escape]\n");
 174
 175   tty_desc = SERIAL_FDOPEN (0);
 176   port_desc = last_serial_opened;
 177
 178   ttystate = SERIAL_GET_TTY_STATE (tty_desc);
 179
 180   SERIAL_RAW (tty_desc);
 181   SERIAL_RAW (port_desc);
 182
 183   make_cleanup (cleanup_tty, ttystate);
 184
 185   while (1)
 186     {
 187       int mask;
 188
 189       mask = SERIAL_WAIT_2 (tty_desc, port_desc, -1);
 190
 191       if (mask & 2)
 192         {                       /* tty input */
 193           char cx;
 194
 195           while (1)
 196             {
 197               c = SERIAL_READCHAR(tty_desc, 0);
 198
 199               if (c == SERIAL_TIMEOUT)
 200                   break;
 201
 202               if (c < 0)
 203                 perror_with_name("connect");
 204
 205               cx = c;
 206               SERIAL_WRITE(port_desc, &cx, 1);
 207
 208               switch (cur_esc)
 209                 {
 210                 case 0:
 211                   if (c == '\r')
 212                     cur_esc = c;
 213                   break;
 214                 case '\r':
 215                   if (c == '~')
 216                     cur_esc = c;
 217                   else
 218                     cur_esc = 0;
 219                   break;
 220                 case '~':
 221                   if (c == '.' || c == '\004')
 222                     return;
 223                   else
 224                     cur_esc = 0;
 225                 }
 226             }
 227         }
 228
 229       if (mask & 1)
 230         {                       /* Port input */
 231           char cx;
 232
 233           while (1)
 234             {
 235               c = SERIAL_READCHAR(port_desc, 0);
 236
 237               if (c == SERIAL_TIMEOUT)
 238                   break;
 239
 240               if (c < 0)
 241                 perror_with_name("connect");
 242
 243               cx = c;
 244
 245               SERIAL_WRITE(tty_desc, &cx, 1);
 246             }
 247         }
 248     }
 249 }
 250
 251 void
 252 _initialize_serial ()
 253 {
 254   add_com ("connect", class_obscure, connect_command,
 255            "Connect the terminal directly up to the command monitor.\n\
 256 Use <CR>~. or <CR>~^D to break out.");
 257 }
 258 #endif /* 0 */