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