gdb/serial.c

   1 /* Generic serial interface routines
   2
   3    Copyright (C) 1992-2013 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include <ctype.h>
  22 #include "serial.h"
  23 #include <string.h>
  24 #include "gdbcmd.h"
  25 #include "cli/cli-utils.h"
  26
  27 extern void _initialize_serial (void);
  28
  29 /* Is serial being debugged?  */
  30
  31 static unsigned int global_serial_debug_p;
  32
  33 typedef const struct serial_ops *serial_ops_p;
  34 DEF_VEC_P (serial_ops_p);
  35
  36 /* Serial I/O handlers.  */
  37
  38 VEC (serial_ops_p) *serial_ops_list = NULL;
  39
  40 /* Pointer to list of scb's.  */
  41
  42 static struct serial *scb_base;
  43
  44 /* Non-NULL gives filename which contains a recording of the remote session,
  45    suitable for playback by gdbserver.  */
  46
  47 static char *serial_logfile = NULL;
  48 static struct ui_file *serial_logfp = NULL;
  49
  50 static const struct serial_ops *serial_interface_lookup (const char *);
  51 static void serial_logchar (struct ui_file *stream,
  52                             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 *const 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,
 126                                 isprint (ch) ? "%c" : "\\x%02x", ch & 0xFF);
 127             break;
 128           }
 129     }
 130 }
 131
 132 void
 133 serial_log_command (const char *cmd)
 134 {
 135   if (!serial_logfp)
 136     return;
 137
 138   serial_current_type = 'c';
 139
 140   fputs_unfiltered ("\nc ", serial_logfp);
 141   fputs_unfiltered (cmd, serial_logfp);
 142
 143   /* Make sure that the log file is as up-to-date as possible,
 144      in case we are getting ready to dump core or something.  */
 145   gdb_flush (serial_logfp);
 146 }
 147
 148 \f
 149 static const struct serial_ops *
 150 serial_interface_lookup (const char *name)
 151 {
 152   const struct serial_ops *ops;
 153   int i;
 154
 155   for (i = 0; VEC_iterate (serial_ops_p, serial_ops_list, i, ops); ++i)
 156     if (strcmp (name, ops->name) == 0)
 157       return ops;
 158
 159   return NULL;
 160 }
 161
 162 void
 163 serial_add_interface (const struct serial_ops *optable)
 164 {
 165   VEC_safe_push (serial_ops_p, serial_ops_list, optable);
 166 }
 167
 168 /* Return the open serial device for FD, if found, or NULL if FD is
 169    not already opened.  */
 170
 171 struct serial *
 172 serial_for_fd (int fd)
 173 {
 174   struct serial *scb;
 175
 176   for (scb = scb_base; scb; scb = scb->next)
 177     if (scb->fd == fd)
 178       return scb;
 179
 180   return NULL;
 181 }
 182
 183 /* Open up a device or a network socket, depending upon the syntax of NAME.  */
 184
 185 struct serial *
 186 serial_open (const char *name)
 187 {
 188   struct serial *scb;
 189   const struct serial_ops *ops;
 190   const char *open_name = name;
 191
 192   if (strcmp (name, "pc") == 0)
 193     ops = serial_interface_lookup ("pc");
 194   else if (strncmp (name, "lpt", 3) == 0)
 195     ops = serial_interface_lookup ("parallel");
 196   else if (strncmp (name, "|", 1) == 0)
 197     {
 198       ops = serial_interface_lookup ("pipe");
 199       /* Discard ``|'' and any space before the command itself.  */
 200       ++open_name;
 201       open_name = skip_spaces_const (open_name);
 202     }
 203   /* Check for a colon, suggesting an IP address/port pair.
 204      Do this *after* checking for all the interesting prefixes.  We
 205      don't want to constrain the syntax of what can follow them.  */
 206   else if (strchr (name, ':'))
 207     ops = serial_interface_lookup ("tcp");
 208   else
 209     ops = serial_interface_lookup ("hardwire");
 210
 211   if (!ops)
 212     return NULL;
 213
 214   scb = XMALLOC (struct serial);
 215
 216   scb->ops = ops;
 217
 218   scb->bufcnt = 0;
 219   scb->bufp = scb->buf;
 220   scb->error_fd = -1;
 221   scb->refcnt = 1;
 222
 223   /* `...->open (...)' would get expanded by the open(2) syscall macro.  */
 224   if ((*scb->ops->open) (scb, open_name))
 225     {
 226       xfree (scb);
 227       return NULL;
 228     }
 229
 230   scb->name = xstrdup (name);
 231   scb->next = scb_base;
 232   scb->debug_p = 0;
 233   scb->async_state = 0;
 234   scb->async_handler = NULL;
 235   scb->async_context = NULL;
 236   scb_base = scb;
 237
 238   if (serial_logfile != NULL)
 239     {
 240       serial_logfp = gdb_fopen (serial_logfile, "w");
 241       if (serial_logfp == NULL)
 242         perror_with_name (serial_logfile);
 243     }
 244
 245   return scb;
 246 }
 247
 248 /* Open a new serial stream using a file handle, using serial
 249    interface ops OPS.  */
 250
 251 static struct serial *
 252 serial_fdopen_ops (const int fd, const struct serial_ops *ops)
 253 {
 254   struct serial *scb;
 255
 256   if (!ops)
 257     {
 258       ops = serial_interface_lookup ("terminal");
 259       if (!ops)
 260         ops = serial_interface_lookup ("hardwire");
 261     }
 262
 263   if (!ops)
 264     return NULL;
 265
 266   scb = XCALLOC (1, struct serial);
 267
 268   scb->ops = ops;
 269
 270   scb->bufcnt = 0;
 271   scb->bufp = scb->buf;
 272   scb->error_fd = -1;
 273   scb->refcnt = 1;
 274
 275   scb->name = NULL;
 276   scb->next = scb_base;
 277   scb->debug_p = 0;
 278   scb->async_state = 0;
 279   scb->async_handler = NULL;
 280   scb->async_context = NULL;
 281   scb_base = scb;
 282
 283   if ((ops->fdopen) != NULL)
 284     (*ops->fdopen) (scb, fd);
 285   else
 286     scb->fd = fd;
 287
 288   return scb;
 289 }
 290
 291 struct serial *
 292 serial_fdopen (const int fd)
 293 {
 294   return serial_fdopen_ops (fd, NULL);
 295 }
 296
 297 static void
 298 do_serial_close (struct serial *scb, int really_close)
 299 {
 300   struct serial *tmp_scb;
 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   /* ensure that the FD has been taken out of async mode.  */
 313   if (scb->async_handler != NULL)
 314     serial_async (scb, NULL, NULL);
 315
 316   if (really_close)
 317     scb->ops->close (scb);
 318
 319   if (scb->name)
 320     xfree (scb->name);
 321
 322   /* For serial_is_open.  */
 323   scb->bufp = NULL;
 324
 325   if (scb_base == scb)
 326     scb_base = scb_base->next;
 327   else
 328     for (tmp_scb = scb_base; tmp_scb; tmp_scb = tmp_scb->next)
 329       {
 330         if (tmp_scb->next != scb)
 331           continue;
 332
 333         tmp_scb->next = tmp_scb->next->next;
 334         break;
 335       }
 336
 337   serial_unref (scb);
 338 }
 339
 340 void
 341 serial_close (struct serial *scb)
 342 {
 343   do_serial_close (scb, 1);
 344 }
 345
 346 void
 347 serial_un_fdopen (struct serial *scb)
 348 {
 349   do_serial_close (scb, 0);
 350 }
 351
 352 int
 353 serial_is_open (struct serial *scb)
 354 {
 355   return scb->bufp != NULL;
 356 }
 357
 358 void
 359 serial_ref (struct serial *scb)
 360 {
 361   scb->refcnt++;
 362 }
 363
 364 void
 365 serial_unref (struct serial *scb)
 366 {
 367   --scb->refcnt;
 368   if (scb->refcnt == 0)
 369     xfree (scb);
 370 }
 371
 372 int
 373 serial_readchar (struct serial *scb, int timeout)
 374 {
 375   int ch;
 376
 377   /* FIXME: cagney/1999-10-11: Don't enable this check until the ASYNC
 378      code is finished.  */
 379   if (0 && serial_is_async_p (scb) && timeout < 0)
 380     internal_error (__FILE__, __LINE__,
 381                     _("serial_readchar: blocking read in async mode"));
 382
 383   ch = scb->ops->readchar (scb, timeout);
 384   if (serial_logfp != NULL)
 385     {
 386       serial_logchar (serial_logfp, 'r', ch, timeout);
 387
 388       /* Make sure that the log file is as up-to-date as possible,
 389          in case we are getting ready to dump core or something.  */
 390       gdb_flush (serial_logfp);
 391     }
 392   if (serial_debug_p (scb))
 393     {
 394       fprintf_unfiltered (gdb_stdlog, "[");
 395       serial_logchar (gdb_stdlog, 'r', ch, timeout);
 396       fprintf_unfiltered (gdb_stdlog, "]");
 397       gdb_flush (gdb_stdlog);
 398     }
 399
 400   return (ch);
 401 }
 402
 403 int
 404 serial_write (struct serial *scb, const void *buf, size_t count)
 405 {
 406   if (serial_logfp != NULL)
 407     {
 408       const char *str = buf;
 409       size_t c;
 410
 411       for (c = 0; c < count; c++)
 412         serial_logchar (serial_logfp, 'w', str[c] & 0xff, 0);
 413
 414       /* Make sure that the log file is as up-to-date as possible,
 415          in case we are getting ready to dump core or something.  */
 416       gdb_flush (serial_logfp);
 417     }
 418   if (serial_debug_p (scb))
 419     {
 420       const char *str = buf;
 421       size_t c;
 422
 423       for (c = 0; c < count; c++)
 424         {
 425           fprintf_unfiltered (gdb_stdlog, "[");
 426           serial_logchar (gdb_stdlog, 'w', str[count] & 0xff, 0);
 427           fprintf_unfiltered (gdb_stdlog, "]");
 428         }
 429       gdb_flush (gdb_stdlog);
 430     }
 431
 432   return (scb->ops->write (scb, buf, count));
 433 }
 434
 435 void
 436 serial_printf (struct serial *desc, const char *format,...)
 437 {
 438   va_list args;
 439   char *buf;
 440   va_start (args, format);
 441
 442   buf = xstrvprintf (format, args);
 443   serial_write (desc, buf, strlen (buf));
 444
 445   xfree (buf);
 446   va_end (args);
 447 }
 448
 449 int
 450 serial_drain_output (struct serial *scb)
 451 {
 452   return scb->ops->drain_output (scb);
 453 }
 454
 455 int
 456 serial_flush_output (struct serial *scb)
 457 {
 458   return scb->ops->flush_output (scb);
 459 }
 460
 461 int
 462 serial_flush_input (struct serial *scb)
 463 {
 464   return scb->ops->flush_input (scb);
 465 }
 466
 467 int
 468 serial_send_break (struct serial *scb)
 469 {
 470   if (serial_logfp != NULL)
 471     serial_logchar (serial_logfp, 'w', SERIAL_BREAK, 0);
 472
 473   return (scb->ops->send_break (scb));
 474 }
 475
 476 void
 477 serial_raw (struct serial *scb)
 478 {
 479   scb->ops->go_raw (scb);
 480 }
 481
 482 serial_ttystate
 483 serial_get_tty_state (struct serial *scb)
 484 {
 485   return scb->ops->get_tty_state (scb);
 486 }
 487
 488 serial_ttystate
 489 serial_copy_tty_state (struct serial *scb, serial_ttystate ttystate)
 490 {
 491   return scb->ops->copy_tty_state (scb, ttystate);
 492 }
 493
 494 int
 495 serial_set_tty_state (struct serial *scb, serial_ttystate ttystate)
 496 {
 497   return scb->ops->set_tty_state (scb, ttystate);
 498 }
 499
 500 void
 501 serial_print_tty_state (struct serial *scb,
 502                         serial_ttystate ttystate,
 503                         struct ui_file *stream)
 504 {
 505   scb->ops->print_tty_state (scb, ttystate, stream);
 506 }
 507
 508 int
 509 serial_noflush_set_tty_state (struct serial *scb,
 510                               serial_ttystate new_ttystate,
 511                               serial_ttystate old_ttystate)
 512 {
 513   return scb->ops->noflush_set_tty_state (scb, new_ttystate, old_ttystate);
 514 }
 515
 516 int
 517 serial_setbaudrate (struct serial *scb, int rate)
 518 {
 519   return scb->ops->setbaudrate (scb, rate);
 520 }
 521
 522 int
 523 serial_setstopbits (struct serial *scb, int num)
 524 {
 525   return scb->ops->setstopbits (scb, num);
 526 }
 527
 528 int
 529 serial_can_async_p (struct serial *scb)
 530 {
 531   return (scb->ops->async != NULL);
 532 }
 533
 534 int
 535 serial_is_async_p (struct serial *scb)
 536 {
 537   return (scb->ops->async != NULL) && (scb->async_handler != NULL);
 538 }
 539
 540 void
 541 serial_async (struct serial *scb,
 542               serial_event_ftype *handler,
 543               void *context)
 544 {
 545   int changed = ((scb->async_handler == NULL) != (handler == NULL));
 546
 547   scb->async_handler = handler;
 548   scb->async_context = context;
 549   /* Only change mode if there is a need.  */
 550   if (changed)
 551     scb->ops->async (scb, handler != NULL);
 552 }
 553
 554 void
 555 serial_debug (struct serial *scb, int debug_p)
 556 {
 557   scb->debug_p = debug_p;
 558 }
 559
 560 int
 561 serial_debug_p (struct serial *scb)
 562 {
 563   return scb->debug_p || global_serial_debug_p;
 564 }
 565
 566 #ifdef USE_WIN32API
 567 void
 568 serial_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except)
 569 {
 570   if (scb->ops->wait_handle)
 571     scb->ops->wait_handle (scb, read, except);
 572   else
 573     {
 574       *read = (HANDLE) _get_osfhandle (scb->fd);
 575       *except = NULL;
 576     }
 577 }
 578
 579 void
 580 serial_done_wait_handle (struct serial *scb)
 581 {
 582   if (scb->ops->done_wait_handle)
 583     scb->ops->done_wait_handle (scb);
 584 }
 585 #endif
 586
 587 int
 588 serial_pipe (struct serial *scbs[2])
 589 {
 590   const struct serial_ops *ops;
 591   int fildes[2];
 592
 593   ops = serial_interface_lookup ("pipe");
 594   if (!ops)
 595     {
 596       errno = ENOSYS;
 597       return -1;
 598     }
 599
 600   if (gdb_pipe (fildes) == -1)
 601     return -1;
 602
 603   scbs[0] = serial_fdopen_ops (fildes[0], ops);
 604   scbs[1] = serial_fdopen_ops (fildes[1], ops);
 605   return 0;
 606 }
 607
 608 /* Serial set/show framework.  */
 609
 610 static struct cmd_list_element *serial_set_cmdlist;
 611 static struct cmd_list_element *serial_show_cmdlist;
 612
 613 static void
 614 serial_set_cmd (char *args, int from_tty)
 615 {
 616   printf_unfiltered ("\"set serial\" must be followed "
 617                      "by the name of a command.\n");
 618   help_list (serial_set_cmdlist, "set serial ", -1, gdb_stdout);
 619 }
 620
 621 static void
 622 serial_show_cmd (char *args, int from_tty)
 623 {
 624   cmd_show_list (serial_show_cmdlist, from_tty, "");
 625 }
 626
 627 /* Baud rate specified for talking to serial target systems.  Default
 628    is left as -1, so targets can choose their own defaults.  */
 629 /* FIXME: This means that "show serial baud" and gr_files_info can
 630    print -1 or (unsigned int)-1.  This is a Bad User Interface.  */
 631
 632 int baud_rate = -1;
 633
 634 static void
 635 serial_baud_show_cmd (struct ui_file *file, int from_tty,
 636                       struct cmd_list_element *c, const char *value)
 637 {
 638   fprintf_filtered (file, _("Baud rate for remote serial I/O is %s.\n"),
 639                     value);
 640 }
 641
 642 void
 643 _initialize_serial (void)
 644 {
 645 #if 0
 646   add_com ("connect", class_obscure, connect_command, _("\
 647 Connect the terminal directly up to the command monitor.\n\
 648 Use <CR>~. or <CR>~^D to break out."));
 649 #endif /* 0 */
 650
 651   add_prefix_cmd ("serial", class_maintenance, serial_set_cmd, _("\
 652 Set default serial/parallel port configuration."),
 653                   &serial_set_cmdlist, "set serial ",
 654                   0/*allow-unknown*/,
 655                   &setlist);
 656
 657   add_prefix_cmd ("serial", class_maintenance, serial_show_cmd, _("\
 658 Show default serial/parallel port configuration."),
 659                   &serial_show_cmdlist, "show serial ",
 660                   0/*allow-unknown*/,
 661                   &showlist);
 662
 663   /* If target is open when baud changes, it doesn't take effect until
 664      the next open (I think, not sure).  */
 665   add_setshow_zinteger_cmd ("baud", no_class, &baud_rate, _("\
 666 Set baud rate for remote serial I/O."), _("\
 667 Show baud rate for remote serial I/O."), _("\
 668 This value is used to set the speed of the serial port when debugging\n\
 669 using remote targets."),
 670                             NULL,
 671                             serial_baud_show_cmd,
 672                             &serial_set_cmdlist, &serial_show_cmdlist);
 673
 674   /* The commands "set/show serial baud" used to have a different name.
 675      Add aliases to those names to facilitate the transition, and mark
 676      them as deprecated, in order to make users aware of the fact that
 677      the command names have been changed.  */
 678     {
 679       const char *cmd_name;
 680       struct cmd_list_element *cmd;
 681
 682       /* FIXME: There is a limitation in the deprecation mechanism,
 683          and the warning ends up not being displayed for prefixed
 684          aliases.  So use a real command instead of an alias.  */
 685       add_setshow_zinteger_cmd ("remotebaud", class_alias, &baud_rate, _("\
 686 Set baud rate for remote serial I/O."), _("\
 687 Show baud rate for remote serial I/O."), _("\
 688 This value is used to set the speed of the serial port when debugging\n\
 689 using remote targets."),
 690                                 NULL,
 691                                 serial_baud_show_cmd,
 692                                 &setlist, &showlist);
 693       cmd_name = "remotebaud";
 694       cmd = lookup_cmd (&cmd_name, setlist, "", -1, 1);
 695       deprecate_cmd (cmd, "set serial baud");
 696       cmd_name
 697         = "remotebaud"; /* needed because lookup_cmd updates the pointer */
 698       cmd = lookup_cmd (&cmd_name, showlist, "", -1, 1);
 699       deprecate_cmd (cmd, "show serial baud");
 700     }
 701
 702   add_setshow_filename_cmd ("remotelogfile", no_class, &serial_logfile, _("\
 703 Set filename for remote session recording."), _("\
 704 Show filename for remote session recording."), _("\
 705 This file is used to record the remote session for future playback\n\
 706 by gdbserver."),
 707                             NULL,
 708                             NULL, /* FIXME: i18n: */
 709                             &setlist, &showlist);
 710
 711   add_setshow_enum_cmd ("remotelogbase", no_class, logbase_enums,
 712                         &serial_logbase, _("\
 713 Set numerical base for remote session logging"), _("\
 714 Show numerical base for remote session logging"), NULL,
 715                         NULL,
 716                         NULL, /* FIXME: i18n: */
 717                         &setlist, &showlist);
 718
 719   add_setshow_zuinteger_cmd ("serial", class_maintenance,
 720                              &global_serial_debug_p, _("\
 721 Set serial debugging."), _("\
 722 Show serial debugging."), _("\
 723 When non-zero, serial port debugging is enabled."),
 724                              NULL,
 725                              NULL, /* FIXME: i18n: */
 726                              &setdebuglist, &showdebuglist);
 727 }