1 /* Remote utility routines for the remote server for GDB. 2 Copyright 1986, 1989, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 3 2002, 2003, 2004 4 Free Software Foundation, Inc. 5 6 This file is part of GDB. 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 2 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program; if not, write to the Free Software 20 Foundation, Inc., 59 Temple Place - Suite 330, 21 Boston, MA 02111-1307, USA. */ 22 23 #include "server.h" 24 #include "terminal.h" 25 #include <stdio.h> 26 #include <string.h> 27 #include <sys/ioctl.h> 28 #include <sys/file.h> 29 #include <netinet/in.h> 30 #include <sys/socket.h> 31 #include <netdb.h> 32 #include <netinet/tcp.h> 33 #include <sys/ioctl.h> 34 #include <signal.h> 35 #include <fcntl.h> 36 #include <sys/time.h> 37 #include <unistd.h> 38 #include <arpa/inet.h> 39 40 /* A cache entry for a successfully looked-up symbol. */ 41 struct sym_cache 42 { 43 const char *name; 44 CORE_ADDR addr; 45 struct sym_cache *next; 46 }; 47 48 /* The symbol cache. */ 49 static struct sym_cache *symbol_cache; 50 51 int remote_debug = 0; 52 struct ui_file *gdb_stdlog; 53 54 static int remote_desc; 55 56 /* FIXME headerize? */ 57 extern int using_threads; 58 extern int debug_threads; 59 60 /* Open a connection to a remote debugger. 61 NAME is the filename used for communication. */ 62 63 void 64 remote_open (char *name) 65 { 66 int save_fcntl_flags; 67 68 if (!strchr (name, ':')) 69 { 70 remote_desc = open (name, O_RDWR); 71 if (remote_desc < 0) 72 perror_with_name ("Could not open remote device"); 73 74 #ifdef HAVE_TERMIOS 75 { 76 struct termios termios; 77 tcgetattr (remote_desc, &termios); 78 79 termios.c_iflag = 0; 80 termios.c_oflag = 0; 81 termios.c_lflag = 0; 82 termios.c_cflag &= ~(CSIZE | PARENB); 83 termios.c_cflag |= CLOCAL | CS8; 84 termios.c_cc[VMIN] = 1; 85 termios.c_cc[VTIME] = 0; 86 87 tcsetattr (remote_desc, TCSANOW, &termios); 88 } 89 #endif 90 91 #ifdef HAVE_TERMIO 92 { 93 struct termio termio; 94 ioctl (remote_desc, TCGETA, &termio); 95 96 termio.c_iflag = 0; 97 termio.c_oflag = 0; 98 termio.c_lflag = 0; 99 termio.c_cflag &= ~(CSIZE | PARENB); 100 termio.c_cflag |= CLOCAL | CS8; 101 termio.c_cc[VMIN] = 1; 102 termio.c_cc[VTIME] = 0; 103 104 ioctl (remote_desc, TCSETA, &termio); 105 } 106 #endif 107 108 #ifdef HAVE_SGTTY 109 { 110 struct sgttyb sg; 111 112 ioctl (remote_desc, TIOCGETP, &sg); 113 sg.sg_flags = RAW; 114 ioctl (remote_desc, TIOCSETP, &sg); 115 } 116 #endif 117 118 fprintf (stderr, "Remote debugging using %s\n", name); 119 } 120 else 121 { 122 char *port_str; 123 int port; 124 struct sockaddr_in sockaddr; 125 int tmp; 126 int tmp_desc; 127 128 port_str = strchr (name, ':'); 129 130 port = atoi (port_str + 1); 131 132 tmp_desc = socket (PF_INET, SOCK_STREAM, 0); 133 if (tmp_desc < 0) 134 perror_with_name ("Can't open socket"); 135 136 /* Allow rapid reuse of this port. */ 137 tmp = 1; 138 setsockopt (tmp_desc, SOL_SOCKET, SO_REUSEADDR, (char *) &tmp, 139 sizeof (tmp)); 140 141 sockaddr.sin_family = PF_INET; 142 sockaddr.sin_port = htons (port); 143 sockaddr.sin_addr.s_addr = INADDR_ANY; 144 145 if (bind (tmp_desc, (struct sockaddr *) &sockaddr, sizeof (sockaddr)) 146 || listen (tmp_desc, 1)) 147 perror_with_name ("Can't bind address"); 148 149 fprintf (stderr, "Listening on port %d\n", port); 150 151 tmp = sizeof (sockaddr); 152 remote_desc = accept (tmp_desc, (struct sockaddr *) &sockaddr, &tmp); 153 if (remote_desc == -1) 154 perror_with_name ("Accept failed"); 155 156 /* Enable TCP keep alive process. */ 157 tmp = 1; 158 setsockopt (tmp_desc, SOL_SOCKET, SO_KEEPALIVE, (char *) &tmp, sizeof (tmp)); 159 160 /* Tell TCP not to delay small packets. This greatly speeds up 161 interactive response. */ 162 tmp = 1; 163 setsockopt (remote_desc, IPPROTO_TCP, TCP_NODELAY, 164 (char *) &tmp, sizeof (tmp)); 165 166 close (tmp_desc); /* No longer need this */ 167 168 signal (SIGPIPE, SIG_IGN); /* If we don't do this, then gdbserver simply 169 exits when the remote side dies. */ 170 171 /* Convert IP address to string. */ 172 fprintf (stderr, "Remote debugging from host %s\n", 173 inet_ntoa (sockaddr.sin_addr)); 174 } 175 176 #if defined(F_SETFL) && defined (FASYNC) 177 save_fcntl_flags = fcntl (remote_desc, F_GETFL, 0); 178 fcntl (remote_desc, F_SETFL, save_fcntl_flags | FASYNC); 179 #if defined (F_SETOWN) 180 fcntl (remote_desc, F_SETOWN, getpid ()); 181 #endif 182 #endif 183 disable_async_io (); 184 } 185 186 void 187 remote_close (void) 188 { 189 close (remote_desc); 190 } 191 192 /* Convert hex digit A to a number. */ 193 194 static int 195 fromhex (int a) 196 { 197 if (a >= '0' && a <= '9') 198 return a - '0'; 199 else if (a >= 'a' && a <= 'f') 200 return a - 'a' + 10; 201 else 202 error ("Reply contains invalid hex digit"); 203 return 0; 204 } 205 206 int 207 unhexify (char *bin, const char *hex, int count) 208 { 209 int i; 210 211 for (i = 0; i < count; i++) 212 { 213 if (hex[0] == 0 || hex[1] == 0) 214 { 215 /* Hex string is short, or of uneven length. 216 Return the count that has been converted so far. */ 217 return i; 218 } 219 *bin++ = fromhex (hex[0]) * 16 + fromhex (hex[1]); 220 hex += 2; 221 } 222 return i; 223 } 224 225 static void 226 decode_address (CORE_ADDR *addrp, const char *start, int len) 227 { 228 CORE_ADDR addr; 229 char ch; 230 int i; 231 232 addr = 0; 233 for (i = 0; i < len; i++) 234 { 235 ch = start[i]; 236 addr = addr << 4; 237 addr = addr | (fromhex (ch) & 0x0f); 238 } 239 *addrp = addr; 240 } 241 242 /* Convert number NIB to a hex digit. */ 243 244 static int 245 tohex (int nib) 246 { 247 if (nib < 10) 248 return '0' + nib; 249 else 250 return 'a' + nib - 10; 251 } 252 253 int 254 hexify (char *hex, const char *bin, int count) 255 { 256 int i; 257 258 /* May use a length, or a nul-terminated string as input. */ 259 if (count == 0) 260 count = strlen (bin); 261 262 for (i = 0; i < count; i++) 263 { 264 *hex++ = tohex ((*bin >> 4) & 0xf); 265 *hex++ = tohex (*bin++ & 0xf); 266 } 267 *hex = 0; 268 return i; 269 } 270 271 /* Send a packet to the remote machine, with error checking. 272 The data of the packet is in BUF. Returns >= 0 on success, -1 otherwise. */ 273 274 int 275 putpkt (char *buf) 276 { 277 int i; 278 unsigned char csum = 0; 279 char *buf2; 280 char buf3[1]; 281 int cnt = strlen (buf); 282 char *p; 283 284 buf2 = malloc (PBUFSIZ); 285 286 /* Copy the packet into buffer BUF2, encapsulating it 287 and giving it a checksum. */ 288 289 p = buf2; 290 *p++ = '$'; 291 292 for (i = 0; i < cnt; i++) 293 { 294 csum += buf[i]; 295 *p++ = buf[i]; 296 } 297 *p++ = '#'; 298 *p++ = tohex ((csum >> 4) & 0xf); 299 *p++ = tohex (csum & 0xf); 300 301 *p = '\0'; 302 303 /* Send it over and over until we get a positive ack. */ 304 305 do 306 { 307 int cc; 308 309 if (write (remote_desc, buf2, p - buf2) != p - buf2) 310 { 311 perror ("putpkt(write)"); 312 return -1; 313 } 314 315 if (remote_debug) 316 { 317 fprintf (stderr, "putpkt (\"%s\"); [looking for ack]\n", buf2); 318 fflush (stderr); 319 } 320 cc = read (remote_desc, buf3, 1); 321 if (remote_debug) 322 { 323 fprintf (stderr, "[received '%c' (0x%x)]\n", buf3[0], buf3[0]); 324 fflush (stderr); 325 } 326 327 if (cc <= 0) 328 { 329 if (cc == 0) 330 fprintf (stderr, "putpkt(read): Got EOF\n"); 331 else 332 perror ("putpkt(read)"); 333 334 free (buf2); 335 return -1; 336 } 337 338 /* Check for an input interrupt while we're here. */ 339 if (buf3[0] == '\003') 340 (*the_target->send_signal) (SIGINT); 341 } 342 while (buf3[0] != '+'); 343 344 free (buf2); 345 return 1; /* Success! */ 346 } 347 348 /* Come here when we get an input interrupt from the remote side. This 349 interrupt should only be active while we are waiting for the child to do 350 something. About the only thing that should come through is a ^C, which 351 will cause us to send a SIGINT to the child. */ 352 353 static void 354 input_interrupt (int unused) 355 { 356 fd_set readset; 357 struct timeval immediate = { 0, 0 }; 358 359 /* Protect against spurious interrupts. This has been observed to 360 be a problem under NetBSD 1.4 and 1.5. */ 361 362 FD_ZERO (&readset); 363 FD_SET (remote_desc, &readset); 364 if (select (remote_desc + 1, &readset, 0, 0, &immediate) > 0) 365 { 366 int cc; 367 char c = 0; 368 369 cc = read (remote_desc, &c, 1); 370 371 if (cc != 1 || c != '\003') 372 { 373 fprintf (stderr, "input_interrupt, count = %d c = %d ('%c')\n", 374 cc, c, c); 375 return; 376 } 377 378 (*the_target->send_signal) (SIGINT); 379 } 380 } 381 382 void 383 block_async_io (void) 384 { 385 sigset_t sigio_set; 386 sigemptyset (&sigio_set); 387 sigaddset (&sigio_set, SIGIO); 388 sigprocmask (SIG_BLOCK, &sigio_set, NULL); 389 } 390 391 void 392 unblock_async_io (void) 393 { 394 sigset_t sigio_set; 395 sigemptyset (&sigio_set); 396 sigaddset (&sigio_set, SIGIO); 397 sigprocmask (SIG_UNBLOCK, &sigio_set, NULL); 398 } 399 400 /* Asynchronous I/O support. SIGIO must be enabled when waiting, in order to 401 accept Control-C from the client, and must be disabled when talking to 402 the client. */ 403 404 /* Current state of asynchronous I/O. */ 405 static int async_io_enabled; 406 407 /* Enable asynchronous I/O. */ 408 void 409 enable_async_io (void) 410 { 411 if (async_io_enabled) 412 return; 413 414 signal (SIGIO, input_interrupt); 415 async_io_enabled = 1; 416 } 417 418 /* Disable asynchronous I/O. */ 419 void 420 disable_async_io (void) 421 { 422 if (!async_io_enabled) 423 return; 424 425 signal (SIGIO, SIG_IGN); 426 async_io_enabled = 0; 427 } 428 429 /* Returns next char from remote GDB. -1 if error. */ 430 431 static int 432 readchar (void) 433 { 434 static char buf[BUFSIZ]; 435 static int bufcnt = 0; 436 static char *bufp; 437 438 if (bufcnt-- > 0) 439 return *bufp++ & 0x7f; 440 441 bufcnt = read (remote_desc, buf, sizeof (buf)); 442 443 if (bufcnt <= 0) 444 { 445 if (bufcnt == 0) 446 fprintf (stderr, "readchar: Got EOF\n"); 447 else 448 perror ("readchar"); 449 450 return -1; 451 } 452 453 bufp = buf; 454 bufcnt--; 455 return *bufp++ & 0x7f; 456 } 457 458 /* Read a packet from the remote machine, with error checking, 459 and store it in BUF. Returns length of packet, or negative if error. */ 460 461 int 462 getpkt (char *buf) 463 { 464 char *bp; 465 unsigned char csum, c1, c2; 466 int c; 467 468 while (1) 469 { 470 csum = 0; 471 472 while (1) 473 { 474 c = readchar (); 475 if (c == '$') 476 break; 477 if (remote_debug) 478 { 479 fprintf (stderr, "[getpkt: discarding char '%c']\n", c); 480 fflush (stderr); 481 } 482 483 if (c < 0) 484 return -1; 485 } 486 487 bp = buf; 488 while (1) 489 { 490 c = readchar (); 491 if (c < 0) 492 return -1; 493 if (c == '#') 494 break; 495 *bp++ = c; 496 csum += c; 497 } 498 *bp = 0; 499 500 c1 = fromhex (readchar ()); 501 c2 = fromhex (readchar ()); 502 503 if (csum == (c1 << 4) + c2) 504 break; 505 506 fprintf (stderr, "Bad checksum, sentsum=0x%x, csum=0x%x, buf=%s\n", 507 (c1 << 4) + c2, csum, buf); 508 write (remote_desc, "-", 1); 509 } 510 511 if (remote_debug) 512 { 513 fprintf (stderr, "getpkt (\"%s\"); [sending ack] \n", buf); 514 fflush (stderr); 515 } 516 517 write (remote_desc, "+", 1); 518 519 if (remote_debug) 520 { 521 fprintf (stderr, "[sent ack]\n"); 522 fflush (stderr); 523 } 524 525 return bp - buf; 526 } 527 528 void 529 write_ok (char *buf) 530 { 531 buf[0] = 'O'; 532 buf[1] = 'K'; 533 buf[2] = '\0'; 534 } 535 536 void 537 write_enn (char *buf) 538 { 539 /* Some day, we should define the meanings of the error codes... */ 540 buf[0] = 'E'; 541 buf[1] = '0'; 542 buf[2] = '1'; 543 buf[3] = '\0'; 544 } 545 546 void 547 convert_int_to_ascii (char *from, char *to, int n) 548 { 549 int nib; 550 char ch; 551 while (n--) 552 { 553 ch = *from++; 554 nib = ((ch & 0xf0) >> 4) & 0x0f; 555 *to++ = tohex (nib); 556 nib = ch & 0x0f; 557 *to++ = tohex (nib); 558 } 559 *to++ = 0; 560 } 561 562 563 void 564 convert_ascii_to_int (char *from, char *to, int n) 565 { 566 int nib1, nib2; 567 while (n--) 568 { 569 nib1 = fromhex (*from++); 570 nib2 = fromhex (*from++); 571 *to++ = (((nib1 & 0x0f) << 4) & 0xf0) | (nib2 & 0x0f); 572 } 573 } 574 575 static char * 576 outreg (int regno, char *buf) 577 { 578 if ((regno >> 12) != 0) 579 *buf++ = tohex ((regno >> 12) & 0xf); 580 if ((regno >> 8) != 0) 581 *buf++ = tohex ((regno >> 8) & 0xf); 582 *buf++ = tohex ((regno >> 4) & 0xf); 583 *buf++ = tohex (regno & 0xf); 584 *buf++ = ':'; 585 collect_register_as_string (regno, buf); 586 buf += 2 * register_size (regno); 587 *buf++ = ';'; 588 589 return buf; 590 } 591 592 void 593 new_thread_notify (int id) 594 { 595 char own_buf[256]; 596 597 /* The `n' response is not yet part of the remote protocol. Do nothing. */ 598 if (1) 599 return; 600 601 if (server_waiting == 0) 602 return; 603 604 sprintf (own_buf, "n%x", id); 605 disable_async_io (); 606 putpkt (own_buf); 607 enable_async_io (); 608 } 609 610 void 611 dead_thread_notify (int id) 612 { 613 char own_buf[256]; 614 615 /* The `x' response is not yet part of the remote protocol. Do nothing. */ 616 if (1) 617 return; 618 619 sprintf (own_buf, "x%x", id); 620 disable_async_io (); 621 putpkt (own_buf); 622 enable_async_io (); 623 } 624 625 void 626 prepare_resume_reply (char *buf, char status, unsigned char signo) 627 { 628 int nib, sig; 629 630 *buf++ = status; 631 632 sig = (int)target_signal_from_host (signo); 633 634 nib = ((sig & 0xf0) >> 4); 635 *buf++ = tohex (nib); 636 nib = sig & 0x0f; 637 *buf++ = tohex (nib); 638 639 if (status == 'T') 640 { 641 const char **regp = gdbserver_expedite_regs; 642 while (*regp) 643 { 644 buf = outreg (find_regno (*regp), buf); 645 regp ++; 646 } 647 648 /* Formerly, if the debugger had not used any thread features we would not 649 burden it with a thread status response. This was for the benefit of 650 GDB 4.13 and older. However, in recent GDB versions the check 651 (``if (cont_thread != 0)'') does not have the desired effect because of 652 sillyness in the way that the remote protocol handles specifying a thread. 653 Since thread support relies on qSymbol support anyway, assume GDB can handle 654 threads. */ 655 656 if (using_threads) 657 { 658 /* FIXME right place to set this? */ 659 thread_from_wait = ((struct inferior_list_entry *)current_inferior)->id; 660 if (debug_threads) 661 fprintf (stderr, "Writing resume reply for %d\n\n", thread_from_wait); 662 /* This if (1) ought to be unnecessary. But remote_wait in GDB 663 will claim this event belongs to inferior_ptid if we do not 664 specify a thread, and there's no way for gdbserver to know 665 what inferior_ptid is. */ 666 if (1 || old_thread_from_wait != thread_from_wait) 667 { 668 general_thread = thread_from_wait; 669 sprintf (buf, "thread:%x;", thread_from_wait); 670 buf += strlen (buf); 671 old_thread_from_wait = thread_from_wait; 672 } 673 } 674 } 675 /* For W and X, we're done. */ 676 *buf++ = 0; 677 } 678 679 void 680 decode_m_packet (char *from, CORE_ADDR *mem_addr_ptr, unsigned int *len_ptr) 681 { 682 int i = 0, j = 0; 683 char ch; 684 *mem_addr_ptr = *len_ptr = 0; 685 686 while ((ch = from[i++]) != ',') 687 { 688 *mem_addr_ptr = *mem_addr_ptr << 4; 689 *mem_addr_ptr |= fromhex (ch) & 0x0f; 690 } 691 692 for (j = 0; j < 4; j++) 693 { 694 if ((ch = from[i++]) == 0) 695 break; 696 *len_ptr = *len_ptr << 4; 697 *len_ptr |= fromhex (ch) & 0x0f; 698 } 699 } 700 701 void 702 decode_M_packet (char *from, CORE_ADDR *mem_addr_ptr, unsigned int *len_ptr, 703 char *to) 704 { 705 int i = 0; 706 char ch; 707 *mem_addr_ptr = *len_ptr = 0; 708 709 while ((ch = from[i++]) != ',') 710 { 711 *mem_addr_ptr = *mem_addr_ptr << 4; 712 *mem_addr_ptr |= fromhex (ch) & 0x0f; 713 } 714 715 while ((ch = from[i++]) != ':') 716 { 717 *len_ptr = *len_ptr << 4; 718 *len_ptr |= fromhex (ch) & 0x0f; 719 } 720 721 convert_ascii_to_int (&from[i++], to, *len_ptr); 722 } 723 724 /* Ask GDB for the address of NAME, and return it in ADDRP if found. 725 Returns 1 if the symbol is found, 0 if it is not, -1 on error. */ 726 727 int 728 look_up_one_symbol (const char *name, CORE_ADDR *addrp) 729 { 730 char own_buf[266], *p, *q; 731 int len; 732 struct sym_cache *sym; 733 734 /* Check the cache first. */ 735 for (sym = symbol_cache; sym; sym = sym->next) 736 if (strcmp (name, sym->name) == 0) 737 { 738 *addrp = sym->addr; 739 return 1; 740 } 741 742 /* Send the request. */ 743 strcpy (own_buf, "qSymbol:"); 744 hexify (own_buf + strlen ("qSymbol:"), name, strlen (name)); 745 if (putpkt (own_buf) < 0) 746 return -1; 747 748 /* FIXME: Eventually add buffer overflow checking (to getpkt?) */ 749 len = getpkt (own_buf); 750 if (len < 0) 751 return -1; 752 753 if (strncmp (own_buf, "qSymbol:", strlen ("qSymbol:")) != 0) 754 { 755 /* Malformed response. */ 756 if (remote_debug) 757 { 758 fprintf (stderr, "Malformed response to qSymbol, ignoring.\n"); 759 fflush (stderr); 760 } 761 762 return -1; 763 } 764 765 p = own_buf + strlen ("qSymbol:"); 766 q = p; 767 while (*q && *q != ':') 768 q++; 769 770 /* Make sure we found a value for the symbol. */ 771 if (p == q || *q == '\0') 772 return 0; 773 774 decode_address (addrp, p, q - p); 775 776 /* Save the symbol in our cache. */ 777 sym = malloc (sizeof (*sym)); 778 sym->name = strdup (name); 779 sym->addr = *addrp; 780 sym->next = symbol_cache; 781 symbol_cache = sym; 782 783 return 1; 784 } 785