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 *logbase_enums[] = 57 {logbase_hex, logbase_octal, logbase_ascii, NULL}; 58 static const char *serial_logbase = logbase_ascii; 59 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 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 } 817