gdb/serial.c

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