gdb/serial.c

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