gdb/serial.c

   1 /* Generic serial interface routines
   2
   3    Copyright 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
   4    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 2 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, write to the Free Software
  20    Foundation, Inc., 59 Temple Place - Suite 330,
  21    Boston, MA 02111-1307, USA.  */
  22
  23 #include "defs.h"
  24 #include <ctype.h>
  25 #include "serial.h"
  26 #include "gdb_string.h"
  27 #include "gdbcmd.h"
  28
  29 extern void _initialize_serial (void);
  30
  31 /* Is serial being debugged? */
  32
  33 static int global_serial_debug_p;
  34
  35 /* Linked list of serial I/O handlers */
  36
  37 static struct serial_ops *serial_ops_list = NULL;
  38
  39 /* This is the last serial stream opened.  Used by connect command. */
  40
  41 static struct serial *last_serial_opened = NULL;
  42
  43 /* Pointer to list of scb's. */
  44
  45 static struct serial *scb_base;
  46
  47 /* Non-NULL gives filename which contains a recording of the remote session,
  48    suitable for playback by gdbserver. */
  49
  50 static char *serial_logfile = NULL;
  51 static struct ui_file *serial_logfp = NULL;
  52
  53 static struct serial_ops *serial_interface_lookup (char *);
  54 static void serial_logchar (struct ui_file *stream, int ch_type, int ch, int timeout);
  55 static const char logbase_hex[] = "hex";
  56 static const char logbase_octal[] = "octal";
  57 static const char logbase_ascii[] = "ascii";
  58 static const char *logbase_enums[] =
  59 {logbase_hex, logbase_octal, logbase_ascii, NULL};
  60 static const char *serial_logbase = logbase_ascii;
  61
  62 #undef XMALLOC
  63 #define XMALLOC(TYPE) ((TYPE*) xmalloc (sizeof (TYPE)))
  64 \f
  65
  66 static int serial_current_type = 0;
  67
  68 /* Log char CH of type CHTYPE, with TIMEOUT */
  69
  70 /* Define bogus char to represent a BREAK.  Should be careful to choose a value
  71    that can't be confused with a normal char, or an error code.  */
  72 #define SERIAL_BREAK 1235
  73
  74 static void
  75 serial_logchar (struct ui_file *stream, int ch_type, int ch, int timeout)
  76 {
  77   if (ch_type != serial_current_type)
  78     {
  79       fprintf_unfiltered (stream, "\n%c ", ch_type);
  80       serial_current_type = ch_type;
  81     }
  82
  83   if (serial_logbase != logbase_ascii)
  84     fputc_unfiltered (' ', stream);
  85
  86   switch (ch)
  87     {
  88     case SERIAL_TIMEOUT:
  89       fprintf_unfiltered (stream, "<Timeout: %d seconds>", timeout);
  90       return;
  91     case SERIAL_ERROR:
  92       fprintf_unfiltered (stream, "<Error: %s>", safe_strerror (errno));
  93       return;
  94     case SERIAL_EOF:
  95       fputs_unfiltered ("<Eof>", stream);
  96       return;
  97     case SERIAL_BREAK:
  98       fputs_unfiltered ("<Break>", stream);
  99       return;
 100     default:
 101       if (serial_logbase == logbase_hex)
 102         fprintf_unfiltered (stream, "%02x", ch & 0xff);
 103       else if (serial_logbase == logbase_octal)
 104         fprintf_unfiltered (stream, "%03o", ch & 0xff);
 105       else
 106         switch (ch)
 107           {
 108           case '\\':
 109             fputs_unfiltered ("\\\\", stream);
 110             break;
 111           case '\b':
 112             fputs_unfiltered ("\\b", stream);
 113             break;
 114           case '\f':
 115             fputs_unfiltered ("\\f", stream);
 116             break;
 117           case '\n':
 118             fputs_unfiltered ("\\n", stream);
 119             break;
 120           case '\r':
 121             fputs_unfiltered ("\\r", stream);
 122             break;
 123           case '\t':
 124             fputs_unfiltered ("\\t", stream);
 125             break;
 126           case '\v':
 127             fputs_unfiltered ("\\v", stream);
 128             break;
 129           default:
 130             fprintf_unfiltered (stream, isprint (ch) ? "%c" : "\\x%02x", ch & 0xFF);
 131             break;
 132           }
 133     }
 134 }
 135
 136 void
 137 serial_log_command (const char *cmd)
 138 {
 139   if (!serial_logfp)
 140     return;
 141
 142   serial_current_type = 'c';
 143
 144   fputs_unfiltered ("\nc ", serial_logfp);
 145   fputs_unfiltered (cmd, serial_logfp);
 146
 147   /* Make sure that the log file is as up-to-date as possible,
 148      in case we are getting ready to dump core or something. */
 149   gdb_flush (serial_logfp);
 150 }
 151
 152 \f
 153 static struct serial_ops *
 154 serial_interface_lookup (char *name)
 155 {
 156   struct serial_ops *ops;
 157
 158   for (ops = serial_ops_list; ops; ops = ops->next)
 159     if (strcmp (name, ops->name) == 0)
 160       return ops;
 161
 162   return NULL;
 163 }
 164
 165 void
 166 serial_add_interface (struct serial_ops *optable)
 167 {
 168   optable->next = serial_ops_list;
 169   serial_ops_list = optable;
 170 }
 171
 172 /* Open up a device or a network socket, depending upon the syntax of NAME. */
 173
 174 struct serial *
 175 serial_open (const char *name)
 176 {
 177   struct serial *scb;
 178   struct serial_ops *ops;
 179   const char *open_name = name;
 180
 181   for (scb = scb_base; scb; scb = scb->next)
 182     if (scb->name && strcmp (scb->name, name) == 0)
 183       {
 184         scb->refcnt++;
 185         return scb;
 186       }
 187
 188   if (strcmp (name, "pc") == 0)
 189     ops = serial_interface_lookup ("pc");
 190   else if (strchr (name, ':'))
 191     ops = serial_interface_lookup ("tcp");
 192   else if (strncmp (name, "lpt", 3) == 0)
 193     ops = serial_interface_lookup ("parallel");
 194   else if (strncmp (name, "|", 1) == 0)
 195     {
 196       ops = serial_interface_lookup ("pipe");
 197       open_name = name + 1; /* discard ``|'' */
 198     }
 199   else
 200     ops = serial_interface_lookup ("hardwire");
 201
 202   if (!ops)
 203     return NULL;
 204
 205   scb = XMALLOC (struct serial);
 206
 207   scb->ops = ops;
 208
 209   scb->bufcnt = 0;
 210   scb->bufp = scb->buf;
 211
 212   if (scb->ops->open (scb, open_name))
 213     {
 214       xfree (scb);
 215       return NULL;
 216     }
 217
 218   scb->name = xstrdup (name);
 219   scb->next = scb_base;
 220   scb->refcnt = 1;
 221   scb->debug_p = 0;
 222   scb->async_state = 0;
 223   scb->async_handler = NULL;
 224   scb->async_context = NULL;
 225   scb_base = scb;
 226
 227   last_serial_opened = scb;
 228
 229   if (serial_logfile != NULL)
 230     {
 231       serial_logfp = gdb_fopen (serial_logfile, "w");
 232       if (serial_logfp == NULL)
 233         perror_with_name (serial_logfile);
 234     }
 235
 236   return scb;
 237 }
 238
 239 struct serial *
 240 serial_fdopen (const int fd)
 241 {
 242   struct serial *scb;
 243   struct serial_ops *ops;
 244
 245   for (scb = scb_base; scb; scb = scb->next)
 246     if (scb->fd == fd)
 247       {
 248         scb->refcnt++;
 249         return scb;
 250       }
 251
 252   ops = serial_interface_lookup ("hardwire");
 253
 254   if (!ops)
 255     return NULL;
 256
 257   scb = XMALLOC (struct serial);
 258
 259   scb->ops = ops;
 260
 261   scb->bufcnt = 0;
 262   scb->bufp = scb->buf;
 263
 264   scb->fd = fd;
 265
 266   scb->name = NULL;
 267   scb->next = scb_base;
 268   scb->refcnt = 1;
 269   scb->debug_p = 0;
 270   scb->async_state = 0;
 271   scb->async_handler = NULL;
 272   scb->async_context = NULL;
 273   scb_base = scb;
 274
 275   last_serial_opened = scb;
 276
 277   return scb;
 278 }
 279
 280 static void
 281 do_serial_close (struct serial *scb, int really_close)
 282 {
 283   struct serial *tmp_scb;
 284
 285   last_serial_opened = NULL;
 286
 287   if (serial_logfp)
 288     {
 289       fputs_unfiltered ("\nEnd of log\n", serial_logfp);
 290       serial_current_type = 0;
 291
 292       /* XXX - What if serial_logfp == gdb_stdout or gdb_stderr? */
 293       ui_file_delete (serial_logfp);
 294       serial_logfp = NULL;
 295     }
 296
 297 /* This is bogus.  It's not our fault if you pass us a bad scb...!  Rob, you
 298    should fix your code instead.  */
 299
 300   if (!scb)
 301     return;
 302
 303   scb->refcnt--;
 304   if (scb->refcnt > 0)
 305     return;
 306
 307   /* ensure that the FD has been taken out of async mode */
 308   if (scb->async_handler != NULL)
 309     serial_async (scb, NULL, NULL);
 310
 311   if (really_close)
 312     scb->ops->close (scb);
 313
 314   if (scb->name)
 315     xfree (scb->name);
 316
 317   if (scb_base == scb)
 318     scb_base = scb_base->next;
 319   else
 320     for (tmp_scb = scb_base; tmp_scb; tmp_scb = tmp_scb->next)
 321       {
 322         if (tmp_scb->next != scb)
 323           continue;
 324
 325         tmp_scb->next = tmp_scb->next->next;
 326         break;
 327       }
 328
 329   xfree (scb);
 330 }
 331
 332 void
 333 serial_close (struct serial *scb)
 334 {
 335   do_serial_close (scb, 1);
 336 }
 337
 338 void
 339 serial_un_fdopen (struct serial *scb)
 340 {
 341   do_serial_close (scb, 0);
 342 }
 343
 344 int
 345 serial_readchar (struct serial *scb, int timeout)
 346 {
 347   int ch;
 348
 349   /* FIXME: cagney/1999-10-11: Don't enable this check until the ASYNC
 350      code is finished. */
 351   if (0 && serial_is_async_p (scb) && timeout < 0)
 352     internal_error (__FILE__, __LINE__,
 353                     "serial_readchar: blocking read in async mode");
 354
 355   ch = scb->ops->readchar (scb, timeout);
 356   if (serial_logfp != NULL)
 357     {
 358       serial_logchar (serial_logfp, 'r', ch, timeout);
 359
 360       /* Make sure that the log file is as up-to-date as possible,
 361          in case we are getting ready to dump core or something. */
 362       gdb_flush (serial_logfp);
 363     }
 364   if (serial_debug_p (scb))
 365     {
 366       fprintf_unfiltered (gdb_stdlog, "[");
 367       serial_logchar (gdb_stdlog, 'r', ch, timeout);
 368       fprintf_unfiltered (gdb_stdlog, "]");
 369       gdb_flush (gdb_stdlog);
 370     }
 371
 372   return (ch);
 373 }
 374
 375 int
 376 serial_write (struct serial *scb, const char *str, int len)
 377 {
 378   if (serial_logfp != NULL)
 379     {
 380       int count;
 381
 382       for (count = 0; count < len; count++)
 383         serial_logchar (serial_logfp, 'w', str[count] & 0xff, 0);
 384
 385       /* Make sure that the log file is as up-to-date as possible,
 386          in case we are getting ready to dump core or something. */
 387       gdb_flush (serial_logfp);
 388     }
 389
 390   return (scb->ops->write (scb, str, len));
 391 }
 392
 393 void
 394 serial_printf (struct serial *desc, const char *format,...)
 395 {
 396   va_list args;
 397   char *buf;
 398   va_start (args, format);
 399
 400   xvasprintf (&buf, format, args);
 401   serial_write (desc, buf, strlen (buf));
 402
 403   xfree (buf);
 404   va_end (args);
 405 }
 406
 407 int
 408 serial_drain_output (struct serial *scb)
 409 {
 410   return scb->ops->drain_output (scb);
 411 }
 412
 413 int
 414 serial_flush_output (struct serial *scb)
 415 {
 416   return scb->ops->flush_output (scb);
 417 }
 418
 419 int
 420 serial_flush_input (struct serial *scb)
 421 {
 422   return scb->ops->flush_input (scb);
 423 }
 424
 425 int
 426 serial_send_break (struct serial *scb)
 427 {
 428   if (serial_logfp != NULL)
 429     serial_logchar (serial_logfp, 'w', SERIAL_BREAK, 0);
 430
 431   return (scb->ops->send_break (scb));
 432 }
 433
 434 void
 435 serial_raw (struct serial *scb)
 436 {
 437   scb->ops->go_raw (scb);
 438 }
 439
 440 serial_ttystate
 441 serial_get_tty_state (struct serial *scb)
 442 {
 443   return scb->ops->get_tty_state (scb);
 444 }
 445
 446 int
 447 serial_set_tty_state (struct serial *scb, serial_ttystate ttystate)
 448 {
 449   return scb->ops->set_tty_state (scb, ttystate);
 450 }
 451
 452 void
 453 serial_print_tty_state (struct serial *scb,
 454                         serial_ttystate ttystate,
 455                         struct ui_file *stream)
 456 {
 457   scb->ops->print_tty_state (scb, ttystate, stream);
 458 }
 459
 460 int
 461 serial_noflush_set_tty_state (struct serial *scb,
 462                               serial_ttystate new_ttystate,
 463                               serial_ttystate old_ttystate)
 464 {
 465   return scb->ops->noflush_set_tty_state (scb, new_ttystate, old_ttystate);
 466 }
 467
 468 int
 469 serial_setbaudrate (struct serial *scb, int rate)
 470 {
 471   return scb->ops->setbaudrate (scb, rate);
 472 }
 473
 474 int
 475 serial_setstopbits (struct serial *scb, int num)
 476 {
 477   return scb->ops->setstopbits (scb, num);
 478 }
 479
 480 int
 481 serial_can_async_p (struct serial *scb)
 482 {
 483   return (scb->ops->async != NULL);
 484 }
 485
 486 int
 487 serial_is_async_p (struct serial *scb)
 488 {
 489   return (scb->ops->async != NULL) && (scb->async_handler != NULL);
 490 }
 491
 492 void
 493 serial_async (struct serial *scb,
 494               serial_event_ftype *handler,
 495               void *context)
 496 {
 497   /* Only change mode if there is a need. */
 498   if ((scb->async_handler == NULL)
 499       != (handler == NULL))
 500     scb->ops->async (scb, handler != NULL);
 501   scb->async_handler = handler;
 502   scb->async_context = context;
 503 }
 504
 505 int
 506 deprecated_serial_fd (struct serial *scb)
 507 {
 508   /* FIXME: should this output a warning that deprecated code is being
 509      called? */
 510   if (scb->fd < 0)
 511     {
 512       internal_error (__FILE__, __LINE__,
 513                       "serial: FD not valid");
 514     }
 515   return scb->fd; /* sigh */
 516 }
 517
 518 void
 519 serial_debug (struct serial *scb, int debug_p)
 520 {
 521   scb->debug_p = debug_p;
 522 }
 523
 524 int
 525 serial_debug_p (struct serial *scb)
 526 {
 527   return scb->debug_p || global_serial_debug_p;
 528 }
 529
 530
 531 #if 0
 532 /* The connect command is #if 0 because I hadn't thought of an elegant
 533    way to wait for I/O on two `struct serial *'s simultaneously.  Two
 534    solutions came to mind:
 535
 536    1) Fork, and have have one fork handle the to user direction,
 537    and have the other hand the to target direction.  This
 538    obviously won't cut it for MSDOS.
 539
 540    2) Use something like select.  This assumes that stdin and
 541    the target side can both be waited on via the same
 542    mechanism.  This may not be true for DOS, if GDB is
 543    talking to the target via a TCP socket.
 544    -grossman, 8 Jun 93 */
 545
 546 /* Connect the user directly to the remote system.  This command acts just like
 547    the 'cu' or 'tip' command.  Use <CR>~. or <CR>~^D to break out.  */
 548
 549 static struct serial *tty_desc; /* Controlling terminal */
 550
 551 static void
 552 cleanup_tty (serial_ttystate ttystate)
 553 {
 554   printf_unfiltered ("\r\n[Exiting connect mode]\r\n");
 555   serial_set_tty_state (tty_desc, ttystate);
 556   xfree (ttystate);
 557   serial_close (tty_desc);
 558 }
 559
 560 static void
 561 connect_command (char *args, int fromtty)
 562 {
 563   int c;
 564   char cur_esc = 0;
 565   serial_ttystate ttystate;
 566   struct serial *port_desc;             /* TTY port */
 567
 568   dont_repeat ();
 569
 570   if (args)
 571     fprintf_unfiltered (gdb_stderr, "This command takes no args.  They have been ignored.\n");
 572
 573   printf_unfiltered ("[Entering connect mode.  Use ~. or ~^D to escape]\n");
 574
 575   tty_desc = serial_fdopen (0);
 576   port_desc = last_serial_opened;
 577
 578   ttystate = serial_get_tty_state (tty_desc);
 579
 580   serial_raw (tty_desc);
 581   serial_raw (port_desc);
 582
 583   make_cleanup (cleanup_tty, ttystate);
 584
 585   while (1)
 586     {
 587       int mask;
 588
 589       mask = serial_wait_2 (tty_desc, port_desc, -1);
 590
 591       if (mask & 2)
 592         {                       /* tty input */
 593           char cx;
 594
 595           while (1)
 596             {
 597               c = serial_readchar (tty_desc, 0);
 598
 599               if (c == SERIAL_TIMEOUT)
 600                 break;
 601
 602               if (c < 0)
 603                 perror_with_name ("connect");
 604
 605               cx = c;
 606               serial_write (port_desc, &cx, 1);
 607
 608               switch (cur_esc)
 609                 {
 610                 case 0:
 611                   if (c == '\r')
 612                     cur_esc = c;
 613                   break;
 614                 case '\r':
 615                   if (c == '~')
 616                     cur_esc = c;
 617                   else
 618                     cur_esc = 0;
 619                   break;
 620                 case '~':
 621                   if (c == '.' || c == '\004')
 622                     return;
 623                   else
 624                     cur_esc = 0;
 625                 }
 626             }
 627         }
 628
 629       if (mask & 1)
 630         {                       /* Port input */
 631           char cx;
 632
 633           while (1)
 634             {
 635               c = serial_readchar (port_desc, 0);
 636
 637               if (c == SERIAL_TIMEOUT)
 638                 break;
 639
 640               if (c < 0)
 641                 perror_with_name ("connect");
 642
 643               cx = c;
 644
 645               serial_write (tty_desc, &cx, 1);
 646             }
 647         }
 648     }
 649 }
 650 #endif /* 0 */
 651
 652 /* Serial set/show framework.  */
 653
 654 static struct cmd_list_element *serial_set_cmdlist;
 655 static struct cmd_list_element *serial_show_cmdlist;
 656
 657 static void
 658 serial_set_cmd (char *args, int from_tty)
 659 {
 660   printf_unfiltered ("\"set serial\" must be followed by the name of a command.\n");
 661   help_list (serial_set_cmdlist, "set serial ", -1, gdb_stdout);
 662 }
 663
 664 static void
 665 serial_show_cmd (char *args, int from_tty)
 666 {
 667   cmd_show_list (serial_show_cmdlist, from_tty, "");
 668 }
 669
 670
 671 void
 672 _initialize_serial (void)
 673 {
 674 #if 0
 675   add_com ("connect", class_obscure, connect_command,
 676            "Connect the terminal directly up to the command monitor.\n\
 677 Use <CR>~. or <CR>~^D to break out.");
 678 #endif /* 0 */
 679
 680   add_prefix_cmd ("serial", class_maintenance, serial_set_cmd, "\
 681 Set default serial/parallel port configuration.",
 682                   &serial_set_cmdlist, "set serial ",
 683                   0/*allow-unknown*/,
 684                   &setlist);
 685
 686   add_prefix_cmd ("serial", class_maintenance, serial_show_cmd, "\
 687 Show default serial/parallel port configuration.",
 688                   &serial_show_cmdlist, "show serial ",
 689                   0/*allow-unknown*/,
 690                   &showlist);
 691
 692   add_show_from_set
 693     (add_set_cmd ("remotelogfile", no_class,
 694                   var_filename, (char *) &serial_logfile,
 695                   "Set filename for remote session recording.\n\
 696 This file is used to record the remote session for future playback\n\
 697 by gdbserver.",
 698                   &setlist),
 699      &showlist);
 700
 701   add_show_from_set
 702     (add_set_enum_cmd ("remotelogbase", no_class,
 703                        logbase_enums, &serial_logbase,
 704                        "Set numerical base for remote session logging",
 705                        &setlist),
 706      &showlist);
 707
 708   add_show_from_set (add_set_cmd ("serial",
 709                                   class_maintenance,
 710                                   var_zinteger,
 711                                   (char *)&global_serial_debug_p,
 712                                   "Set serial debugging.\n\
 713 When non-zero, serial port debugging is enabled.", &setdebuglist),
 714                      &showdebuglist);
 715 }