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 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 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 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 serial_ttystate 497 serial_copy_tty_state (struct serial *scb, serial_ttystate ttystate) 498 { 499 return scb->ops->copy_tty_state (scb, ttystate); 500 } 501 502 int 503 serial_set_tty_state (struct serial *scb, serial_ttystate ttystate) 504 { 505 return scb->ops->set_tty_state (scb, ttystate); 506 } 507 508 void 509 serial_print_tty_state (struct serial *scb, 510 serial_ttystate ttystate, 511 struct ui_file *stream) 512 { 513 scb->ops->print_tty_state (scb, ttystate, stream); 514 } 515 516 int 517 serial_noflush_set_tty_state (struct serial *scb, 518 serial_ttystate new_ttystate, 519 serial_ttystate old_ttystate) 520 { 521 return scb->ops->noflush_set_tty_state (scb, new_ttystate, old_ttystate); 522 } 523 524 int 525 serial_setbaudrate (struct serial *scb, int rate) 526 { 527 return scb->ops->setbaudrate (scb, rate); 528 } 529 530 int 531 serial_setstopbits (struct serial *scb, int num) 532 { 533 return scb->ops->setstopbits (scb, num); 534 } 535 536 int 537 serial_can_async_p (struct serial *scb) 538 { 539 return (scb->ops->async != NULL); 540 } 541 542 int 543 serial_is_async_p (struct serial *scb) 544 { 545 return (scb->ops->async != NULL) && (scb->async_handler != NULL); 546 } 547 548 void 549 serial_async (struct serial *scb, 550 serial_event_ftype *handler, 551 void *context) 552 { 553 int changed = ((scb->async_handler == NULL) != (handler == NULL)); 554 555 scb->async_handler = handler; 556 scb->async_context = context; 557 /* Only change mode if there is a need. */ 558 if (changed) 559 scb->ops->async (scb, handler != NULL); 560 } 561 562 int 563 deprecated_serial_fd (struct serial *scb) 564 { 565 /* FIXME: should this output a warning that deprecated code is being 566 called? */ 567 if (scb->fd < 0) 568 { 569 internal_error (__FILE__, __LINE__, 570 _("serial: FD not valid")); 571 } 572 return scb->fd; /* sigh */ 573 } 574 575 void 576 serial_debug (struct serial *scb, int debug_p) 577 { 578 scb->debug_p = debug_p; 579 } 580 581 int 582 serial_debug_p (struct serial *scb) 583 { 584 return scb->debug_p || global_serial_debug_p; 585 } 586 587 #ifdef USE_WIN32API 588 void 589 serial_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except) 590 { 591 if (scb->ops->wait_handle) 592 scb->ops->wait_handle (scb, read, except); 593 else 594 { 595 *read = (HANDLE) _get_osfhandle (scb->fd); 596 *except = NULL; 597 } 598 } 599 600 void 601 serial_done_wait_handle (struct serial *scb) 602 { 603 if (scb->ops->done_wait_handle) 604 scb->ops->done_wait_handle (scb); 605 } 606 #endif 607 608 int 609 serial_pipe (struct serial *scbs[2]) 610 { 611 struct serial_ops *ops; 612 int fildes[2]; 613 614 ops = serial_interface_lookup ("pipe"); 615 if (!ops) 616 { 617 errno = ENOSYS; 618 return -1; 619 } 620 621 if (gdb_pipe (fildes) == -1) 622 return -1; 623 624 scbs[0] = serial_fdopen_ops (fildes[0], ops); 625 scbs[1] = serial_fdopen_ops (fildes[1], ops); 626 return 0; 627 } 628 629 #if 0 630 /* The connect command is #if 0 because I hadn't thought of an elegant 631 way to wait for I/O on two `struct serial *'s simultaneously. Two 632 solutions came to mind: 633 634 1) Fork, and have have one fork handle the to user direction, 635 and have the other hand the to target direction. This 636 obviously won't cut it for MSDOS. 637 638 2) Use something like select. This assumes that stdin and 639 the target side can both be waited on via the same 640 mechanism. This may not be true for DOS, if GDB is 641 talking to the target via a TCP socket. 642 -grossman, 8 Jun 93 */ 643 644 /* Connect the user directly to the remote system. This command acts just like 645 the 'cu' or 'tip' command. Use <CR>~. or <CR>~^D to break out. */ 646 647 static struct serial *tty_desc; /* Controlling terminal */ 648 649 static void 650 cleanup_tty (serial_ttystate ttystate) 651 { 652 printf_unfiltered ("\r\n[Exiting connect mode]\r\n"); 653 serial_set_tty_state (tty_desc, ttystate); 654 xfree (ttystate); 655 serial_close (tty_desc); 656 } 657 658 static void 659 connect_command (char *args, int fromtty) 660 { 661 int c; 662 char cur_esc = 0; 663 serial_ttystate ttystate; 664 struct serial *port_desc; /* TTY port */ 665 666 dont_repeat (); 667 668 if (args) 669 fprintf_unfiltered (gdb_stderr, 670 "This command takes no args. " 671 "They have been ignored.\n"); 672 673 printf_unfiltered ("[Entering connect mode. Use ~. or ~^D to escape]\n"); 674 675 tty_desc = serial_fdopen (0); 676 port_desc = last_serial_opened; 677 678 ttystate = serial_get_tty_state (tty_desc); 679 680 serial_raw (tty_desc); 681 serial_raw (port_desc); 682 683 make_cleanup (cleanup_tty, ttystate); 684 685 while (1) 686 { 687 int mask; 688 689 mask = serial_wait_2 (tty_desc, port_desc, -1); 690 691 if (mask & 2) 692 { /* tty input */ 693 char cx; 694 695 while (1) 696 { 697 c = serial_readchar (tty_desc, 0); 698 699 if (c == SERIAL_TIMEOUT) 700 break; 701 702 if (c < 0) 703 perror_with_name (_("connect")); 704 705 cx = c; 706 serial_write (port_desc, &cx, 1); 707 708 switch (cur_esc) 709 { 710 case 0: 711 if (c == '\r') 712 cur_esc = c; 713 break; 714 case '\r': 715 if (c == '~') 716 cur_esc = c; 717 else 718 cur_esc = 0; 719 break; 720 case '~': 721 if (c == '.' || c == '\004') 722 return; 723 else 724 cur_esc = 0; 725 } 726 } 727 } 728 729 if (mask & 1) 730 { /* Port input */ 731 char cx; 732 733 while (1) 734 { 735 c = serial_readchar (port_desc, 0); 736 737 if (c == SERIAL_TIMEOUT) 738 break; 739 740 if (c < 0) 741 perror_with_name (_("connect")); 742 743 cx = c; 744 745 serial_write (tty_desc, &cx, 1); 746 } 747 } 748 } 749 } 750 #endif /* 0 */ 751 752 /* Serial set/show framework. */ 753 754 static struct cmd_list_element *serial_set_cmdlist; 755 static struct cmd_list_element *serial_show_cmdlist; 756 757 static void 758 serial_set_cmd (char *args, int from_tty) 759 { 760 printf_unfiltered ("\"set serial\" must be followed " 761 "by the name of a command.\n"); 762 help_list (serial_set_cmdlist, "set serial ", -1, gdb_stdout); 763 } 764 765 static void 766 serial_show_cmd (char *args, int from_tty) 767 { 768 cmd_show_list (serial_show_cmdlist, from_tty, ""); 769 } 770 771 772 void 773 _initialize_serial (void) 774 { 775 #if 0 776 add_com ("connect", class_obscure, connect_command, _("\ 777 Connect the terminal directly up to the command monitor.\n\ 778 Use <CR>~. or <CR>~^D to break out.")); 779 #endif /* 0 */ 780 781 add_prefix_cmd ("serial", class_maintenance, serial_set_cmd, _("\ 782 Set default serial/parallel port configuration."), 783 &serial_set_cmdlist, "set serial ", 784 0/*allow-unknown*/, 785 &setlist); 786 787 add_prefix_cmd ("serial", class_maintenance, serial_show_cmd, _("\ 788 Show default serial/parallel port configuration."), 789 &serial_show_cmdlist, "show serial ", 790 0/*allow-unknown*/, 791 &showlist); 792 793 add_setshow_filename_cmd ("remotelogfile", no_class, &serial_logfile, _("\ 794 Set filename for remote session recording."), _("\ 795 Show filename for remote session recording."), _("\ 796 This file is used to record the remote session for future playback\n\ 797 by gdbserver."), 798 NULL, 799 NULL, /* FIXME: i18n: */ 800 &setlist, &showlist); 801 802 add_setshow_enum_cmd ("remotelogbase", no_class, logbase_enums, 803 &serial_logbase, _("\ 804 Set numerical base for remote session logging"), _("\ 805 Show numerical base for remote session logging"), NULL, 806 NULL, 807 NULL, /* FIXME: i18n: */ 808 &setlist, &showlist); 809 810 add_setshow_zinteger_cmd ("serial", class_maintenance, 811 &global_serial_debug_p, _("\ 812 Set serial debugging."), _("\ 813 Show serial debugging."), _("\ 814 When non-zero, serial port debugging is enabled."), 815 NULL, 816 NULL, /* FIXME: i18n: */ 817 &setdebuglist, &showdebuglist); 818 } 819