gdb/serial.c

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