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