1/* Remote utility routines for the remote server for GDB. 2 Copyright (C) 1986-2020 Free Software Foundation, Inc. 3 4 This file is part of GDB. 5 6 This program is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 3 of the License, or 9 (at your option) any later version. 10 11 This program is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 18 19#include "server.h" 20#if HAVE_TERMIOS_H 21#include <termios.h> 22#endif 23#include "target.h" 24#include "gdbthread.h" 25#include "tdesc.h" 26#include "debug.h" 27#include "dll.h" 28#include "gdbsupport/rsp-low.h" 29#include "gdbsupport/netstuff.h" 30#include "gdbsupport/filestuff.h" 31#include "gdbsupport/gdb-sigmask.h" 32#include <ctype.h> 33#if HAVE_SYS_IOCTL_H 34#include <sys/ioctl.h> 35#endif 36#if HAVE_SYS_FILE_H 37#include <sys/file.h> 38#endif 39#if HAVE_NETINET_IN_H 40#include <netinet/in.h> 41#endif 42#if HAVE_SYS_SOCKET_H 43#include <sys/socket.h> 44#endif 45#if HAVE_NETDB_H 46#include <netdb.h> 47#endif 48#if HAVE_NETINET_TCP_H 49#include <netinet/tcp.h> 50#endif 51#if HAVE_SYS_IOCTL_H 52#include <sys/ioctl.h> 53#endif 54#if HAVE_SIGNAL_H 55#include <signal.h> 56#endif 57#if HAVE_FCNTL_H 58#include <fcntl.h> 59#endif 60#include "gdbsupport/gdb_sys_time.h" 61#include <unistd.h> 62#if HAVE_ARPA_INET_H 63#include <arpa/inet.h> 64#endif 65#include <sys/stat.h> 66 67#if USE_WIN32API 68#include <ws2tcpip.h> 69#endif 70 71#ifndef HAVE_SOCKLEN_T 72typedef int socklen_t; 73#endif 74 75#ifndef IN_PROCESS_AGENT 76 77/* Extra value for readchar_callback. */ 78enum { 79 /* The callback is currently not scheduled. */ 80 NOT_SCHEDULED = -1 81}; 82 83/* Status of the readchar callback. 84 Either NOT_SCHEDULED or the callback id. */ 85static int readchar_callback = NOT_SCHEDULED; 86 87static int readchar (void); 88static void reset_readchar (void); 89static void reschedule (void); 90 91/* A cache entry for a successfully looked-up symbol. */ 92struct sym_cache 93{ 94 char *name; 95 CORE_ADDR addr; 96 struct sym_cache *next; 97}; 98 99static int remote_is_stdio = 0; 100 101static int remote_desc = -1; 102static int listen_desc = -1; 103 104#ifdef USE_WIN32API 105# define read(fd, buf, len) recv (fd, (char *) buf, len, 0) 106# define write(fd, buf, len) send (fd, (char *) buf, len, 0) 107#endif 108 109int 110gdb_connected (void) 111{ 112 return remote_desc != -1; 113} 114 115/* Return true if the remote connection is over stdio. */ 116 117int 118remote_connection_is_stdio (void) 119{ 120 return remote_is_stdio; 121} 122 123static void 124enable_async_notification (int fd) 125{ 126#if defined(F_SETFL) && defined (FASYNC) 127 int save_fcntl_flags; 128 129 save_fcntl_flags = fcntl (fd, F_GETFL, 0); 130 fcntl (fd, F_SETFL, save_fcntl_flags | FASYNC); 131#if defined (F_SETOWN) 132 fcntl (fd, F_SETOWN, getpid ()); 133#endif 134#endif 135} 136 137static void 138handle_accept_event (int err, gdb_client_data client_data) 139{ 140 struct sockaddr_storage sockaddr; 141 socklen_t len = sizeof (sockaddr); 142 143 if (debug_threads) 144 debug_printf ("handling possible accept event\n"); 145 146 remote_desc = accept (listen_desc, (struct sockaddr *) &sockaddr, &len); 147 if (remote_desc == -1) 148 perror_with_name ("Accept failed"); 149 150 /* Enable TCP keep alive process. */ 151 socklen_t tmp = 1; 152 setsockopt (remote_desc, SOL_SOCKET, SO_KEEPALIVE, 153 (char *) &tmp, sizeof (tmp)); 154 155 /* Tell TCP not to delay small packets. This greatly speeds up 156 interactive response. */ 157 tmp = 1; 158 setsockopt (remote_desc, IPPROTO_TCP, TCP_NODELAY, 159 (char *) &tmp, sizeof (tmp)); 160 161#ifndef USE_WIN32API 162 signal (SIGPIPE, SIG_IGN); /* If we don't do this, then gdbserver simply 163 exits when the remote side dies. */ 164#endif 165 166 if (run_once) 167 { 168#ifndef USE_WIN32API 169 close (listen_desc); /* No longer need this */ 170#else 171 closesocket (listen_desc); /* No longer need this */ 172#endif 173 } 174 175 /* Even if !RUN_ONCE no longer notice new connections. Still keep the 176 descriptor open for add_file_handler to wait for a new connection. */ 177 delete_file_handler (listen_desc); 178 179 /* Convert IP address to string. */ 180 char orig_host[GDB_NI_MAX_ADDR], orig_port[GDB_NI_MAX_PORT]; 181 182 int r = getnameinfo ((struct sockaddr *) &sockaddr, len, 183 orig_host, sizeof (orig_host), 184 orig_port, sizeof (orig_port), 185 NI_NUMERICHOST | NI_NUMERICSERV); 186 187 if (r != 0) 188 fprintf (stderr, _("Could not obtain remote address: %s\n"), 189 gai_strerror (r)); 190 else 191 fprintf (stderr, _("Remote debugging from host %s, port %s\n"), 192 orig_host, orig_port); 193 194 enable_async_notification (remote_desc); 195 196 /* Register the event loop handler. */ 197 add_file_handler (remote_desc, handle_serial_event, NULL); 198 199 /* We have a new GDB connection now. If we were disconnected 200 tracing, there's a window where the target could report a stop 201 event to the event loop, and since we have a connection now, we'd 202 try to send vStopped notifications to GDB. But, don't do that 203 until GDB as selected all-stop/non-stop, and has queried the 204 threads' status ('?'). */ 205 target_async (0); 206} 207 208/* Prepare for a later connection to a remote debugger. 209 NAME is the filename used for communication. */ 210 211void 212remote_prepare (const char *name) 213{ 214 client_state &cs = get_client_state (); 215#ifdef USE_WIN32API 216 static int winsock_initialized; 217#endif 218 socklen_t tmp; 219 220 remote_is_stdio = 0; 221 if (strcmp (name, STDIO_CONNECTION_NAME) == 0) 222 { 223 /* We need to record fact that we're using stdio sooner than the 224 call to remote_open so start_inferior knows the connection is 225 via stdio. */ 226 remote_is_stdio = 1; 227 cs.transport_is_reliable = 1; 228 return; 229 } 230 231 struct addrinfo hint; 232 struct addrinfo *ainfo; 233 234 memset (&hint, 0, sizeof (hint)); 235 /* Assume no prefix will be passed, therefore we should use 236 AF_UNSPEC. */ 237 hint.ai_family = AF_UNSPEC; 238 hint.ai_socktype = SOCK_STREAM; 239 hint.ai_protocol = IPPROTO_TCP; 240 241 parsed_connection_spec parsed 242 = parse_connection_spec_without_prefix (name, &hint); 243 244 if (parsed.port_str.empty ()) 245 { 246 cs.transport_is_reliable = 0; 247 return; 248 } 249 250#ifdef USE_WIN32API 251 if (!winsock_initialized) 252 { 253 WSADATA wsad; 254 255 WSAStartup (MAKEWORD (1, 0), &wsad); 256 winsock_initialized = 1; 257 } 258#endif 259 260 int r = getaddrinfo (parsed.host_str.c_str (), parsed.port_str.c_str (), 261 &hint, &ainfo); 262 263 if (r != 0) 264 error (_("%s: cannot resolve name: %s"), name, gai_strerror (r)); 265 266 scoped_free_addrinfo freeaddrinfo (ainfo); 267 268 struct addrinfo *iter; 269 270 for (iter = ainfo; iter != NULL; iter = iter->ai_next) 271 { 272 listen_desc = gdb_socket_cloexec (iter->ai_family, iter->ai_socktype, 273 iter->ai_protocol); 274 275 if (listen_desc >= 0) 276 break; 277 } 278 279 if (iter == NULL) 280 perror_with_name ("Can't open socket"); 281 282 /* Allow rapid reuse of this port. */ 283 tmp = 1; 284 setsockopt (listen_desc, SOL_SOCKET, SO_REUSEADDR, (char *) &tmp, 285 sizeof (tmp)); 286 287 switch (iter->ai_family) 288 { 289 case AF_INET: 290 ((struct sockaddr_in *) iter->ai_addr)->sin_addr.s_addr = INADDR_ANY; 291 break; 292 case AF_INET6: 293 ((struct sockaddr_in6 *) iter->ai_addr)->sin6_addr = in6addr_any; 294 break; 295 default: 296 internal_error (__FILE__, __LINE__, 297 _("Invalid 'ai_family' %d\n"), iter->ai_family); 298 } 299 300 if (bind (listen_desc, iter->ai_addr, iter->ai_addrlen) != 0) 301 perror_with_name ("Can't bind address"); 302 303 if (listen (listen_desc, 1) != 0) 304 perror_with_name ("Can't listen on socket"); 305 306 cs.transport_is_reliable = 1; 307} 308 309/* Open a connection to a remote debugger. 310 NAME is the filename used for communication. */ 311 312void 313remote_open (const char *name) 314{ 315 const char *port_str; 316 317 port_str = strchr (name, ':'); 318#ifdef USE_WIN32API 319 if (port_str == NULL) 320 error ("Only HOST:PORT is supported on this platform."); 321#endif 322 323 if (strcmp (name, STDIO_CONNECTION_NAME) == 0) 324 { 325 fprintf (stderr, "Remote debugging using stdio\n"); 326 327 /* Use stdin as the handle of the connection. 328 We only select on reads, for example. */ 329 remote_desc = fileno (stdin); 330 331 enable_async_notification (remote_desc); 332 333 /* Register the event loop handler. */ 334 add_file_handler (remote_desc, handle_serial_event, NULL); 335 } 336#ifndef USE_WIN32API 337 else if (port_str == NULL) 338 { 339 struct stat statbuf; 340 341 if (stat (name, &statbuf) == 0 342 && (S_ISCHR (statbuf.st_mode) || S_ISFIFO (statbuf.st_mode))) 343 remote_desc = open (name, O_RDWR); 344 else 345 { 346 errno = EINVAL; 347 remote_desc = -1; 348 } 349 350 if (remote_desc < 0) 351 perror_with_name ("Could not open remote device"); 352 353#if HAVE_TERMIOS_H 354 { 355 struct termios termios; 356 tcgetattr (remote_desc, &termios); 357 358 termios.c_iflag = 0; 359 termios.c_oflag = 0; 360 termios.c_lflag = 0; 361 termios.c_cflag &= ~(CSIZE | PARENB); 362 termios.c_cflag |= CLOCAL | CS8; 363 termios.c_cc[VMIN] = 1; 364 termios.c_cc[VTIME] = 0; 365 366 tcsetattr (remote_desc, TCSANOW, &termios); 367 } 368#endif 369 370 fprintf (stderr, "Remote debugging using %s\n", name); 371 372 enable_async_notification (remote_desc); 373 374 /* Register the event loop handler. */ 375 add_file_handler (remote_desc, handle_serial_event, NULL); 376 } 377#endif /* USE_WIN32API */ 378 else 379 { 380 char listen_port[GDB_NI_MAX_PORT]; 381 struct sockaddr_storage sockaddr; 382 socklen_t len = sizeof (sockaddr); 383 384 if (getsockname (listen_desc, (struct sockaddr *) &sockaddr, &len) < 0) 385 perror_with_name ("Can't determine port"); 386 387 int r = getnameinfo ((struct sockaddr *) &sockaddr, len, 388 NULL, 0, 389 listen_port, sizeof (listen_port), 390 NI_NUMERICSERV); 391 392 if (r != 0) 393 fprintf (stderr, _("Can't obtain port where we are listening: %s"), 394 gai_strerror (r)); 395 else 396 fprintf (stderr, _("Listening on port %s\n"), listen_port); 397 398 fflush (stderr); 399 400 /* Register the event loop handler. */ 401 add_file_handler (listen_desc, handle_accept_event, NULL); 402 } 403} 404 405void 406remote_close (void) 407{ 408 delete_file_handler (remote_desc); 409 410 disable_async_io (); 411 412#ifdef USE_WIN32API 413 closesocket (remote_desc); 414#else 415 if (! remote_connection_is_stdio ()) 416 close (remote_desc); 417#endif 418 remote_desc = -1; 419 420 reset_readchar (); 421} 422 423#endif 424 425#ifndef IN_PROCESS_AGENT 426 427void 428decode_address (CORE_ADDR *addrp, const char *start, int len) 429{ 430 CORE_ADDR addr; 431 char ch; 432 int i; 433 434 addr = 0; 435 for (i = 0; i < len; i++) 436 { 437 ch = start[i]; 438 addr = addr << 4; 439 addr = addr | (fromhex (ch) & 0x0f); 440 } 441 *addrp = addr; 442} 443 444const char * 445decode_address_to_semicolon (CORE_ADDR *addrp, const char *start) 446{ 447 const char *end; 448 449 end = start; 450 while (*end != '\0' && *end != ';') 451 end++; 452 453 decode_address (addrp, start, end - start); 454 455 if (*end == ';') 456 end++; 457 return end; 458} 459 460#endif 461 462#ifndef IN_PROCESS_AGENT 463 464/* Look for a sequence of characters which can be run-length encoded. 465 If there are any, update *CSUM and *P. Otherwise, output the 466 single character. Return the number of characters consumed. */ 467 468static int 469try_rle (char *buf, int remaining, unsigned char *csum, char **p) 470{ 471 int n; 472 473 /* Always output the character. */ 474 *csum += buf[0]; 475 *(*p)++ = buf[0]; 476 477 /* Don't go past '~'. */ 478 if (remaining > 97) 479 remaining = 97; 480 481 for (n = 1; n < remaining; n++) 482 if (buf[n] != buf[0]) 483 break; 484 485 /* N is the index of the first character not the same as buf[0]. 486 buf[0] is counted twice, so by decrementing N, we get the number 487 of characters the RLE sequence will replace. */ 488 n--; 489 490 if (n < 3) 491 return 1; 492 493 /* Skip the frame characters. The manual says to skip '+' and '-' 494 also, but there's no reason to. Unfortunately these two unusable 495 characters double the encoded length of a four byte zero 496 value. */ 497 while (n + 29 == '$' || n + 29 == '#') 498 n--; 499 500 *csum += '*'; 501 *(*p)++ = '*'; 502 *csum += n + 29; 503 *(*p)++ = n + 29; 504 505 return n + 1; 506} 507 508#endif 509 510#ifndef IN_PROCESS_AGENT 511 512/* Write a PTID to BUF. Returns BUF+CHARACTERS_WRITTEN. */ 513 514char * 515write_ptid (char *buf, ptid_t ptid) 516{ 517 client_state &cs = get_client_state (); 518 int pid, tid; 519 520 if (cs.multi_process) 521 { 522 pid = ptid.pid (); 523 if (pid < 0) 524 buf += sprintf (buf, "p-%x.", -pid); 525 else 526 buf += sprintf (buf, "p%x.", pid); 527 } 528 tid = ptid.lwp (); 529 if (tid < 0) 530 buf += sprintf (buf, "-%x", -tid); 531 else 532 buf += sprintf (buf, "%x", tid); 533 534 return buf; 535} 536 537static ULONGEST 538hex_or_minus_one (const char *buf, const char **obuf) 539{ 540 ULONGEST ret; 541 542 if (startswith (buf, "-1")) 543 { 544 ret = (ULONGEST) -1; 545 buf += 2; 546 } 547 else 548 buf = unpack_varlen_hex (buf, &ret); 549 550 if (obuf) 551 *obuf = buf; 552 553 return ret; 554} 555 556/* Extract a PTID from BUF. If non-null, OBUF is set to the to one 557 passed the last parsed char. Returns null_ptid on error. */ 558ptid_t 559read_ptid (const char *buf, const char **obuf) 560{ 561 const char *p = buf; 562 const char *pp; 563 ULONGEST pid = 0, tid = 0; 564 565 if (*p == 'p') 566 { 567 /* Multi-process ptid. */ 568 pp = unpack_varlen_hex (p + 1, &pid); 569 if (*pp != '.') 570 error ("invalid remote ptid: %s\n", p); 571 572 p = pp + 1; 573 574 tid = hex_or_minus_one (p, &pp); 575 576 if (obuf) 577 *obuf = pp; 578 return ptid_t (pid, tid, 0); 579 } 580 581 /* No multi-process. Just a tid. */ 582 tid = hex_or_minus_one (p, &pp); 583 584 /* Since GDB is not sending a process id (multi-process extensions 585 are off), then there's only one process. Default to the first in 586 the list. */ 587 pid = pid_of (get_first_process ()); 588 589 if (obuf) 590 *obuf = pp; 591 return ptid_t (pid, tid, 0); 592} 593 594/* Write COUNT bytes in BUF to the client. 595 The result is the number of bytes written or -1 if error. 596 This may return less than COUNT. */ 597 598static int 599write_prim (const void *buf, int count) 600{ 601 if (remote_connection_is_stdio ()) 602 return write (fileno (stdout), buf, count); 603 else 604 return write (remote_desc, buf, count); 605} 606 607/* Read COUNT bytes from the client and store in BUF. 608 The result is the number of bytes read or -1 if error. 609 This may return less than COUNT. */ 610 611static int 612read_prim (void *buf, int count) 613{ 614 if (remote_connection_is_stdio ()) 615 return read (fileno (stdin), buf, count); 616 else 617 return read (remote_desc, buf, count); 618} 619 620/* Send a packet to the remote machine, with error checking. 621 The data of the packet is in BUF, and the length of the 622 packet is in CNT. Returns >= 0 on success, -1 otherwise. */ 623 624static int 625putpkt_binary_1 (char *buf, int cnt, int is_notif) 626{ 627 client_state &cs = get_client_state (); 628 int i; 629 unsigned char csum = 0; 630 char *buf2; 631 char *p; 632 int cc; 633 634 buf2 = (char *) xmalloc (strlen ("$") + cnt + strlen ("#nn") + 1); 635 636 /* Copy the packet into buffer BUF2, encapsulating it 637 and giving it a checksum. */ 638 639 p = buf2; 640 if (is_notif) 641 *p++ = '%'; 642 else 643 *p++ = '$'; 644 645 for (i = 0; i < cnt;) 646 i += try_rle (buf + i, cnt - i, &csum, &p); 647 648 *p++ = '#'; 649 *p++ = tohex ((csum >> 4) & 0xf); 650 *p++ = tohex (csum & 0xf); 651 652 *p = '\0'; 653 654 /* Send it over and over until we get a positive ack. */ 655 656 do 657 { 658 if (write_prim (buf2, p - buf2) != p - buf2) 659 { 660 perror ("putpkt(write)"); 661 free (buf2); 662 return -1; 663 } 664 665 if (cs.noack_mode || is_notif) 666 { 667 /* Don't expect an ack then. */ 668 if (remote_debug) 669 { 670 if (is_notif) 671 debug_printf ("putpkt (\"%s\"); [notif]\n", buf2); 672 else 673 debug_printf ("putpkt (\"%s\"); [noack mode]\n", buf2); 674 debug_flush (); 675 } 676 break; 677 } 678 679 if (remote_debug) 680 { 681 debug_printf ("putpkt (\"%s\"); [looking for ack]\n", buf2); 682 debug_flush (); 683 } 684 685 cc = readchar (); 686 687 if (cc < 0) 688 { 689 free (buf2); 690 return -1; 691 } 692 693 if (remote_debug) 694 { 695 debug_printf ("[received '%c' (0x%x)]\n", cc, cc); 696 debug_flush (); 697 } 698 699 /* Check for an input interrupt while we're here. */ 700 if (cc == '\003' && current_thread != NULL) 701 the_target->request_interrupt (); 702 } 703 while (cc != '+'); 704 705 free (buf2); 706 return 1; /* Success! */ 707} 708 709int 710putpkt_binary (char *buf, int cnt) 711{ 712 return putpkt_binary_1 (buf, cnt, 0); 713} 714 715/* Send a packet to the remote machine, with error checking. The data 716 of the packet is in BUF, and the packet should be a NUL-terminated 717 string. Returns >= 0 on success, -1 otherwise. */ 718 719int 720putpkt (char *buf) 721{ 722 return putpkt_binary (buf, strlen (buf)); 723} 724 725int 726putpkt_notif (char *buf) 727{ 728 return putpkt_binary_1 (buf, strlen (buf), 1); 729} 730 731/* Come here when we get an input interrupt from the remote side. This 732 interrupt should only be active while we are waiting for the child to do 733 something. Thus this assumes readchar:bufcnt is 0. 734 About the only thing that should come through is a ^C, which 735 will cause us to request child interruption. */ 736 737static void 738input_interrupt (int unused) 739{ 740 fd_set readset; 741 struct timeval immediate = { 0, 0 }; 742 743 /* Protect against spurious interrupts. This has been observed to 744 be a problem under NetBSD 1.4 and 1.5. */ 745 746 FD_ZERO (&readset); 747 FD_SET (remote_desc, &readset); 748 if (select (remote_desc + 1, &readset, 0, 0, &immediate) > 0) 749 { 750 int cc; 751 char c = 0; 752 753 cc = read_prim (&c, 1); 754 755 if (cc == 0) 756 { 757 fprintf (stderr, "client connection closed\n"); 758 return; 759 } 760 else if (cc != 1 || c != '\003') 761 { 762 fprintf (stderr, "input_interrupt, count = %d c = %d ", cc, c); 763 if (isprint (c)) 764 fprintf (stderr, "('%c')\n", c); 765 else 766 fprintf (stderr, "('\\x%02x')\n", c & 0xff); 767 return; 768 } 769 770 the_target->request_interrupt (); 771 } 772} 773 774/* Check if the remote side sent us an interrupt request (^C). */ 775void 776check_remote_input_interrupt_request (void) 777{ 778 /* This function may be called before establishing communications, 779 therefore we need to validate the remote descriptor. */ 780 781 if (remote_desc == -1) 782 return; 783 784 input_interrupt (0); 785} 786 787/* Asynchronous I/O support. SIGIO must be unblocked when waiting, 788 in order to accept Control-C from the client, and must be blocked 789 when talking to the client. */ 790 791static void 792block_unblock_async_io (int block) 793{ 794#ifndef USE_WIN32API 795 sigset_t sigio_set; 796 797 sigemptyset (&sigio_set); 798 sigaddset (&sigio_set, SIGIO); 799 gdb_sigmask (block ? SIG_BLOCK : SIG_UNBLOCK, &sigio_set, NULL); 800#endif 801} 802 803/* Current state of asynchronous I/O. */ 804static int async_io_enabled; 805 806/* Enable asynchronous I/O. */ 807void 808enable_async_io (void) 809{ 810 if (async_io_enabled) 811 return; 812 813 block_unblock_async_io (0); 814 815 async_io_enabled = 1; 816} 817 818/* Disable asynchronous I/O. */ 819void 820disable_async_io (void) 821{ 822 if (!async_io_enabled) 823 return; 824 825 block_unblock_async_io (1); 826 827 async_io_enabled = 0; 828} 829 830void 831initialize_async_io (void) 832{ 833 /* Make sure that async I/O starts blocked. */ 834 async_io_enabled = 1; 835 disable_async_io (); 836 837 /* Install the signal handler. */ 838#ifndef USE_WIN32API 839 signal (SIGIO, input_interrupt); 840#endif 841} 842 843/* Internal buffer used by readchar. 844 These are global to readchar because reschedule_remote needs to be 845 able to tell whether the buffer is empty. */ 846 847static unsigned char readchar_buf[BUFSIZ]; 848static int readchar_bufcnt = 0; 849static unsigned char *readchar_bufp; 850 851/* Returns next char from remote GDB. -1 if error. */ 852 853static int 854readchar (void) 855{ 856 int ch; 857 858 if (readchar_bufcnt == 0) 859 { 860 readchar_bufcnt = read_prim (readchar_buf, sizeof (readchar_buf)); 861 862 if (readchar_bufcnt <= 0) 863 { 864 if (readchar_bufcnt == 0) 865 { 866 if (remote_debug) 867 debug_printf ("readchar: Got EOF\n"); 868 } 869 else 870 perror ("readchar"); 871 872 return -1; 873 } 874 875 readchar_bufp = readchar_buf; 876 } 877 878 readchar_bufcnt--; 879 ch = *readchar_bufp++; 880 reschedule (); 881 return ch; 882} 883 884/* Reset the readchar state machine. */ 885 886static void 887reset_readchar (void) 888{ 889 readchar_bufcnt = 0; 890 if (readchar_callback != NOT_SCHEDULED) 891 { 892 delete_timer (readchar_callback); 893 readchar_callback = NOT_SCHEDULED; 894 } 895} 896 897/* Process remaining data in readchar_buf. */ 898 899static void 900process_remaining (void *context) 901{ 902 /* This is a one-shot event. */ 903 readchar_callback = NOT_SCHEDULED; 904 905 if (readchar_bufcnt > 0) 906 handle_serial_event (0, NULL); 907} 908 909/* If there is still data in the buffer, queue another event to process it, 910 we can't sleep in select yet. */ 911 912static void 913reschedule (void) 914{ 915 if (readchar_bufcnt > 0 && readchar_callback == NOT_SCHEDULED) 916 readchar_callback = create_timer (0, process_remaining, NULL); 917} 918 919/* Read a packet from the remote machine, with error checking, 920 and store it in BUF. Returns length of packet, or negative if error. */ 921 922int 923getpkt (char *buf) 924{ 925 client_state &cs = get_client_state (); 926 char *bp; 927 unsigned char csum, c1, c2; 928 int c; 929 930 while (1) 931 { 932 csum = 0; 933 934 while (1) 935 { 936 c = readchar (); 937 938 /* The '\003' may appear before or after each packet, so 939 check for an input interrupt. */ 940 if (c == '\003') 941 { 942 the_target->request_interrupt (); 943 continue; 944 } 945 946 if (c == '$') 947 break; 948 if (remote_debug) 949 { 950 debug_printf ("[getpkt: discarding char '%c']\n", c); 951 debug_flush (); 952 } 953 954 if (c < 0) 955 return -1; 956 } 957 958 bp = buf; 959 while (1) 960 { 961 c = readchar (); 962 if (c < 0) 963 return -1; 964 if (c == '#') 965 break; 966 *bp++ = c; 967 csum += c; 968 } 969 *bp = 0; 970 971 c1 = fromhex (readchar ()); 972 c2 = fromhex (readchar ()); 973 974 if (csum == (c1 << 4) + c2) 975 break; 976 977 if (cs.noack_mode) 978 { 979 fprintf (stderr, 980 "Bad checksum, sentsum=0x%x, csum=0x%x, " 981 "buf=%s [no-ack-mode, Bad medium?]\n", 982 (c1 << 4) + c2, csum, buf); 983 /* Not much we can do, GDB wasn't expecting an ack/nac. */ 984 break; 985 } 986 987 fprintf (stderr, "Bad checksum, sentsum=0x%x, csum=0x%x, buf=%s\n", 988 (c1 << 4) + c2, csum, buf); 989 if (write_prim ("-", 1) != 1) 990 return -1; 991 } 992 993 if (!cs.noack_mode) 994 { 995 if (remote_debug) 996 { 997 debug_printf ("getpkt (\"%s\"); [sending ack] \n", buf); 998 debug_flush (); 999 } 1000 1001 if (write_prim ("+", 1) != 1) 1002 return -1; 1003 1004 if (remote_debug) 1005 { 1006 debug_printf ("[sent ack]\n"); 1007 debug_flush (); 1008 } 1009 } 1010 else 1011 { 1012 if (remote_debug) 1013 { 1014 debug_printf ("getpkt (\"%s\"); [no ack sent] \n", buf); 1015 debug_flush (); 1016 } 1017 } 1018 1019 /* The readchar above may have already read a '\003' out of the socket 1020 and moved it to the local buffer. For example, when GDB sends 1021 vCont;c immediately followed by interrupt (see 1022 gdb.base/interrupt-noterm.exp). As soon as we see the vCont;c, we'll 1023 resume the inferior and wait. Since we've already moved the '\003' 1024 to the local buffer, SIGIO won't help. In that case, if we don't 1025 check for interrupt after the vCont;c packet, the interrupt character 1026 would stay in the buffer unattended until after the next (unrelated) 1027 stop. */ 1028 while (readchar_bufcnt > 0 && *readchar_bufp == '\003') 1029 { 1030 /* Consume the interrupt character in the buffer. */ 1031 readchar (); 1032 the_target->request_interrupt (); 1033 } 1034 1035 return bp - buf; 1036} 1037 1038void 1039write_ok (char *buf) 1040{ 1041 buf[0] = 'O'; 1042 buf[1] = 'K'; 1043 buf[2] = '\0'; 1044} 1045 1046void 1047write_enn (char *buf) 1048{ 1049 /* Some day, we should define the meanings of the error codes... */ 1050 buf[0] = 'E'; 1051 buf[1] = '0'; 1052 buf[2] = '1'; 1053 buf[3] = '\0'; 1054} 1055 1056#endif 1057 1058#ifndef IN_PROCESS_AGENT 1059 1060static char * 1061outreg (struct regcache *regcache, int regno, char *buf) 1062{ 1063 if ((regno >> 12) != 0) 1064 *buf++ = tohex ((regno >> 12) & 0xf); 1065 if ((regno >> 8) != 0) 1066 *buf++ = tohex ((regno >> 8) & 0xf); 1067 *buf++ = tohex ((regno >> 4) & 0xf); 1068 *buf++ = tohex (regno & 0xf); 1069 *buf++ = ':'; 1070 collect_register_as_string (regcache, regno, buf); 1071 buf += 2 * register_size (regcache->tdesc, regno); 1072 *buf++ = ';'; 1073 1074 return buf; 1075} 1076 1077void 1078prepare_resume_reply (char *buf, ptid_t ptid, 1079 struct target_waitstatus *status) 1080{ 1081 client_state &cs = get_client_state (); 1082 if (debug_threads) 1083 debug_printf ("Writing resume reply for %s:%d\n", 1084 target_pid_to_str (ptid), status->kind); 1085 1086 switch (status->kind) 1087 { 1088 case TARGET_WAITKIND_STOPPED: 1089 case TARGET_WAITKIND_FORKED: 1090 case TARGET_WAITKIND_VFORKED: 1091 case TARGET_WAITKIND_VFORK_DONE: 1092 case TARGET_WAITKIND_EXECD: 1093 case TARGET_WAITKIND_THREAD_CREATED: 1094 case TARGET_WAITKIND_SYSCALL_ENTRY: 1095 case TARGET_WAITKIND_SYSCALL_RETURN: 1096 { 1097 struct thread_info *saved_thread; 1098 const char **regp; 1099 struct regcache *regcache; 1100 1101 if ((status->kind == TARGET_WAITKIND_FORKED && cs.report_fork_events) 1102 || (status->kind == TARGET_WAITKIND_VFORKED 1103 && cs.report_vfork_events)) 1104 { 1105 enum gdb_signal signal = GDB_SIGNAL_TRAP; 1106 const char *event = (status->kind == TARGET_WAITKIND_FORKED 1107 ? "fork" : "vfork"); 1108 1109 sprintf (buf, "T%02x%s:", signal, event); 1110 buf += strlen (buf); 1111 buf = write_ptid (buf, status->value.related_pid); 1112 strcat (buf, ";"); 1113 } 1114 else if (status->kind == TARGET_WAITKIND_VFORK_DONE 1115 && cs.report_vfork_events) 1116 { 1117 enum gdb_signal signal = GDB_SIGNAL_TRAP; 1118 1119 sprintf (buf, "T%02xvforkdone:;", signal); 1120 } 1121 else if (status->kind == TARGET_WAITKIND_EXECD && cs.report_exec_events) 1122 { 1123 enum gdb_signal signal = GDB_SIGNAL_TRAP; 1124 const char *event = "exec"; 1125 char hexified_pathname[PATH_MAX * 2]; 1126 1127 sprintf (buf, "T%02x%s:", signal, event); 1128 buf += strlen (buf); 1129 1130 /* Encode pathname to hexified format. */ 1131 bin2hex ((const gdb_byte *) status->value.execd_pathname, 1132 hexified_pathname, 1133 strlen (status->value.execd_pathname)); 1134 1135 sprintf (buf, "%s;", hexified_pathname); 1136 xfree (status->value.execd_pathname); 1137 status->value.execd_pathname = NULL; 1138 buf += strlen (buf); 1139 } 1140 else if (status->kind == TARGET_WAITKIND_THREAD_CREATED 1141 && cs.report_thread_events) 1142 { 1143 enum gdb_signal signal = GDB_SIGNAL_TRAP; 1144 1145 sprintf (buf, "T%02xcreate:;", signal); 1146 } 1147 else if (status->kind == TARGET_WAITKIND_SYSCALL_ENTRY 1148 || status->kind == TARGET_WAITKIND_SYSCALL_RETURN) 1149 { 1150 enum gdb_signal signal = GDB_SIGNAL_TRAP; 1151 const char *event = (status->kind == TARGET_WAITKIND_SYSCALL_ENTRY 1152 ? "syscall_entry" : "syscall_return"); 1153 1154 sprintf (buf, "T%02x%s:%x;", signal, event, 1155 status->value.syscall_number); 1156 } 1157 else 1158 sprintf (buf, "T%02x", status->value.sig); 1159 1160 if (disable_packet_T) 1161 { 1162 /* This is a bit (OK, a lot) of a kludge, however, this isn't 1163 really a user feature, but exists only so GDB can use the 1164 gdbserver to test handling of the 'S' stop reply packet, so 1165 we would rather this code be as simple as possible. 1166 1167 By this point we've started to build the 'T' stop packet, 1168 and it should look like 'Txx....' where 'x' is a hex digit. 1169 An 'S' stop packet always looks like 'Sxx', so all we do 1170 here is convert the buffer from a T packet to an S packet 1171 and the avoid adding any extra content by breaking out. */ 1172 gdb_assert (*buf == 'T'); 1173 gdb_assert (isxdigit (*(buf + 1))); 1174 gdb_assert (isxdigit (*(buf + 2))); 1175 *buf = 'S'; 1176 *(buf + 3) = '\0'; 1177 break; 1178 } 1179 1180 buf += strlen (buf); 1181 1182 saved_thread = current_thread; 1183 1184 switch_to_thread (the_target, ptid); 1185 1186 regp = current_target_desc ()->expedite_regs; 1187 1188 regcache = get_thread_regcache (current_thread, 1); 1189 1190 if (the_target->stopped_by_watchpoint ()) 1191 { 1192 CORE_ADDR addr; 1193 int i; 1194 1195 memcpy (buf, "watch:", 6); 1196 buf += 6; 1197 1198 addr = the_target->stopped_data_address (); 1199 1200 /* Convert each byte of the address into two hexadecimal 1201 chars. Note that we take sizeof (void *) instead of 1202 sizeof (addr); this is to avoid sending a 64-bit 1203 address to a 32-bit GDB. */ 1204 for (i = sizeof (void *) * 2; i > 0; i--) 1205 *buf++ = tohex ((addr >> (i - 1) * 4) & 0xf); 1206 *buf++ = ';'; 1207 } 1208 else if (cs.swbreak_feature && target_stopped_by_sw_breakpoint ()) 1209 { 1210 sprintf (buf, "swbreak:;"); 1211 buf += strlen (buf); 1212 } 1213 else if (cs.hwbreak_feature && target_stopped_by_hw_breakpoint ()) 1214 { 1215 sprintf (buf, "hwbreak:;"); 1216 buf += strlen (buf); 1217 } 1218 1219 while (*regp) 1220 { 1221 buf = outreg (regcache, find_regno (regcache->tdesc, *regp), buf); 1222 regp ++; 1223 } 1224 *buf = '\0'; 1225 1226 /* Formerly, if the debugger had not used any thread features 1227 we would not burden it with a thread status response. This 1228 was for the benefit of GDB 4.13 and older. However, in 1229 recent GDB versions the check (``if (cont_thread != 0)'') 1230 does not have the desired effect because of sillyness in 1231 the way that the remote protocol handles specifying a 1232 thread. Since thread support relies on qSymbol support 1233 anyway, assume GDB can handle threads. */ 1234 1235 if (using_threads && !disable_packet_Tthread) 1236 { 1237 /* This if (1) ought to be unnecessary. But remote_wait 1238 in GDB will claim this event belongs to inferior_ptid 1239 if we do not specify a thread, and there's no way for 1240 gdbserver to know what inferior_ptid is. */ 1241 if (1 || cs.general_thread != ptid) 1242 { 1243 int core = -1; 1244 /* In non-stop, don't change the general thread behind 1245 GDB's back. */ 1246 if (!non_stop) 1247 cs.general_thread = ptid; 1248 sprintf (buf, "thread:"); 1249 buf += strlen (buf); 1250 buf = write_ptid (buf, ptid); 1251 strcat (buf, ";"); 1252 buf += strlen (buf); 1253 1254 core = target_core_of_thread (ptid); 1255 1256 if (core != -1) 1257 { 1258 sprintf (buf, "core:"); 1259 buf += strlen (buf); 1260 sprintf (buf, "%x", core); 1261 strcat (buf, ";"); 1262 buf += strlen (buf); 1263 } 1264 } 1265 } 1266 1267 if (dlls_changed) 1268 { 1269 strcpy (buf, "library:;"); 1270 buf += strlen (buf); 1271 dlls_changed = 0; 1272 } 1273 1274 current_thread = saved_thread; 1275 } 1276 break; 1277 case TARGET_WAITKIND_EXITED: 1278 if (cs.multi_process) 1279 sprintf (buf, "W%x;process:%x", 1280 status->value.integer, ptid.pid ()); 1281 else 1282 sprintf (buf, "W%02x", status->value.integer); 1283 break; 1284 case TARGET_WAITKIND_SIGNALLED: 1285 if (cs.multi_process) 1286 sprintf (buf, "X%x;process:%x", 1287 status->value.sig, ptid.pid ()); 1288 else 1289 sprintf (buf, "X%02x", status->value.sig); 1290 break; 1291 case TARGET_WAITKIND_THREAD_EXITED: 1292 sprintf (buf, "w%x;", status->value.integer); 1293 buf += strlen (buf); 1294 buf = write_ptid (buf, ptid); 1295 break; 1296 case TARGET_WAITKIND_NO_RESUMED: 1297 sprintf (buf, "N"); 1298 break; 1299 default: 1300 error ("unhandled waitkind"); 1301 break; 1302 } 1303} 1304 1305void 1306decode_m_packet (char *from, CORE_ADDR *mem_addr_ptr, unsigned int *len_ptr) 1307{ 1308 int i = 0, j = 0; 1309 char ch; 1310 *mem_addr_ptr = *len_ptr = 0; 1311 1312 while ((ch = from[i++]) != ',') 1313 { 1314 *mem_addr_ptr = *mem_addr_ptr << 4; 1315 *mem_addr_ptr |= fromhex (ch) & 0x0f; 1316 } 1317 1318 for (j = 0; j < 4; j++) 1319 { 1320 if ((ch = from[i++]) == 0) 1321 break; 1322 *len_ptr = *len_ptr << 4; 1323 *len_ptr |= fromhex (ch) & 0x0f; 1324 } 1325} 1326 1327void 1328decode_M_packet (char *from, CORE_ADDR *mem_addr_ptr, unsigned int *len_ptr, 1329 unsigned char **to_p) 1330{ 1331 int i = 0; 1332 char ch; 1333 *mem_addr_ptr = *len_ptr = 0; 1334 1335 while ((ch = from[i++]) != ',') 1336 { 1337 *mem_addr_ptr = *mem_addr_ptr << 4; 1338 *mem_addr_ptr |= fromhex (ch) & 0x0f; 1339 } 1340 1341 while ((ch = from[i++]) != ':') 1342 { 1343 *len_ptr = *len_ptr << 4; 1344 *len_ptr |= fromhex (ch) & 0x0f; 1345 } 1346 1347 if (*to_p == NULL) 1348 *to_p = (unsigned char *) xmalloc (*len_ptr); 1349 1350 hex2bin (&from[i++], *to_p, *len_ptr); 1351} 1352 1353int 1354decode_X_packet (char *from, int packet_len, CORE_ADDR *mem_addr_ptr, 1355 unsigned int *len_ptr, unsigned char **to_p) 1356{ 1357 int i = 0; 1358 char ch; 1359 *mem_addr_ptr = *len_ptr = 0; 1360 1361 while ((ch = from[i++]) != ',') 1362 { 1363 *mem_addr_ptr = *mem_addr_ptr << 4; 1364 *mem_addr_ptr |= fromhex (ch) & 0x0f; 1365 } 1366 1367 while ((ch = from[i++]) != ':') 1368 { 1369 *len_ptr = *len_ptr << 4; 1370 *len_ptr |= fromhex (ch) & 0x0f; 1371 } 1372 1373 if (*to_p == NULL) 1374 *to_p = (unsigned char *) xmalloc (*len_ptr); 1375 1376 if (remote_unescape_input ((const gdb_byte *) &from[i], packet_len - i, 1377 *to_p, *len_ptr) != *len_ptr) 1378 return -1; 1379 1380 return 0; 1381} 1382 1383/* Decode a qXfer write request. */ 1384 1385int 1386decode_xfer_write (char *buf, int packet_len, CORE_ADDR *offset, 1387 unsigned int *len, unsigned char *data) 1388{ 1389 char ch; 1390 char *b = buf; 1391 1392 /* Extract the offset. */ 1393 *offset = 0; 1394 while ((ch = *buf++) != ':') 1395 { 1396 *offset = *offset << 4; 1397 *offset |= fromhex (ch) & 0x0f; 1398 } 1399 1400 /* Get encoded data. */ 1401 packet_len -= buf - b; 1402 *len = remote_unescape_input ((const gdb_byte *) buf, packet_len, 1403 data, packet_len); 1404 return 0; 1405} 1406 1407/* Decode the parameters of a qSearch:memory packet. */ 1408 1409int 1410decode_search_memory_packet (const char *buf, int packet_len, 1411 CORE_ADDR *start_addrp, 1412 CORE_ADDR *search_space_lenp, 1413 gdb_byte *pattern, unsigned int *pattern_lenp) 1414{ 1415 const char *p = buf; 1416 1417 p = decode_address_to_semicolon (start_addrp, p); 1418 p = decode_address_to_semicolon (search_space_lenp, p); 1419 packet_len -= p - buf; 1420 *pattern_lenp = remote_unescape_input ((const gdb_byte *) p, packet_len, 1421 pattern, packet_len); 1422 return 0; 1423} 1424 1425static void 1426free_sym_cache (struct sym_cache *sym) 1427{ 1428 if (sym != NULL) 1429 { 1430 free (sym->name); 1431 free (sym); 1432 } 1433} 1434 1435void 1436clear_symbol_cache (struct sym_cache **symcache_p) 1437{ 1438 struct sym_cache *sym, *next; 1439 1440 /* Check the cache first. */ 1441 for (sym = *symcache_p; sym; sym = next) 1442 { 1443 next = sym->next; 1444 free_sym_cache (sym); 1445 } 1446 1447 *symcache_p = NULL; 1448} 1449 1450/* Get the address of NAME, and return it in ADDRP if found. if 1451 MAY_ASK_GDB is false, assume symbol cache misses are failures. 1452 Returns 1 if the symbol is found, 0 if it is not, -1 on error. */ 1453 1454int 1455look_up_one_symbol (const char *name, CORE_ADDR *addrp, int may_ask_gdb) 1456{ 1457 client_state &cs = get_client_state (); 1458 char *p, *q; 1459 int len; 1460 struct sym_cache *sym; 1461 struct process_info *proc; 1462 1463 proc = current_process (); 1464 1465 /* Check the cache first. */ 1466 for (sym = proc->symbol_cache; sym; sym = sym->next) 1467 if (strcmp (name, sym->name) == 0) 1468 { 1469 *addrp = sym->addr; 1470 return 1; 1471 } 1472 1473 /* It might not be an appropriate time to look up a symbol, 1474 e.g. while we're trying to fetch registers. */ 1475 if (!may_ask_gdb) 1476 return 0; 1477 1478 /* Send the request. */ 1479 strcpy (cs.own_buf, "qSymbol:"); 1480 bin2hex ((const gdb_byte *) name, cs.own_buf + strlen ("qSymbol:"), 1481 strlen (name)); 1482 if (putpkt (cs.own_buf) < 0) 1483 return -1; 1484 1485 /* FIXME: Eventually add buffer overflow checking (to getpkt?) */ 1486 len = getpkt (cs.own_buf); 1487 if (len < 0) 1488 return -1; 1489 1490 /* We ought to handle pretty much any packet at this point while we 1491 wait for the qSymbol "response". That requires re-entering the 1492 main loop. For now, this is an adequate approximation; allow 1493 GDB to read from memory and handle 'v' packets (for vFile transfers) 1494 while it figures out the address of the symbol. */ 1495 while (1) 1496 { 1497 if (cs.own_buf[0] == 'm') 1498 { 1499 CORE_ADDR mem_addr; 1500 unsigned char *mem_buf; 1501 unsigned int mem_len; 1502 1503 decode_m_packet (&cs.own_buf[1], &mem_addr, &mem_len); 1504 mem_buf = (unsigned char *) xmalloc (mem_len); 1505 if (read_inferior_memory (mem_addr, mem_buf, mem_len) == 0) 1506 bin2hex (mem_buf, cs.own_buf, mem_len); 1507 else 1508 write_enn (cs.own_buf); 1509 free (mem_buf); 1510 if (putpkt (cs.own_buf) < 0) 1511 return -1; 1512 } 1513 else if (cs.own_buf[0] == 'v') 1514 { 1515 int new_len = -1; 1516 handle_v_requests (cs.own_buf, len, &new_len); 1517 if (new_len != -1) 1518 putpkt_binary (cs.own_buf, new_len); 1519 else 1520 putpkt (cs.own_buf); 1521 } 1522 else 1523 break; 1524 len = getpkt (cs.own_buf); 1525 if (len < 0) 1526 return -1; 1527 } 1528 1529 if (!startswith (cs.own_buf, "qSymbol:")) 1530 { 1531 warning ("Malformed response to qSymbol, ignoring: %s", cs.own_buf); 1532 return -1; 1533 } 1534 1535 p = cs.own_buf + strlen ("qSymbol:"); 1536 q = p; 1537 while (*q && *q != ':') 1538 q++; 1539 1540 /* Make sure we found a value for the symbol. */ 1541 if (p == q || *q == '\0') 1542 return 0; 1543 1544 decode_address (addrp, p, q - p); 1545 1546 /* Save the symbol in our cache. */ 1547 sym = XNEW (struct sym_cache); 1548 sym->name = xstrdup (name); 1549 sym->addr = *addrp; 1550 sym->next = proc->symbol_cache; 1551 proc->symbol_cache = sym; 1552 1553 return 1; 1554} 1555 1556/* Relocate an instruction to execute at a different address. OLDLOC 1557 is the address in the inferior memory where the instruction to 1558 relocate is currently at. On input, TO points to the destination 1559 where we want the instruction to be copied (and possibly adjusted) 1560 to. On output, it points to one past the end of the resulting 1561 instruction(s). The effect of executing the instruction at TO 1562 shall be the same as if executing it at OLDLOC. For example, call 1563 instructions that implicitly push the return address on the stack 1564 should be adjusted to return to the instruction after OLDLOC; 1565 relative branches, and other PC-relative instructions need the 1566 offset adjusted; etc. Returns 0 on success, -1 on failure. */ 1567 1568int 1569relocate_instruction (CORE_ADDR *to, CORE_ADDR oldloc) 1570{ 1571 client_state &cs = get_client_state (); 1572 int len; 1573 ULONGEST written = 0; 1574 1575 /* Send the request. */ 1576 sprintf (cs.own_buf, "qRelocInsn:%s;%s", paddress (oldloc), 1577 paddress (*to)); 1578 if (putpkt (cs.own_buf) < 0) 1579 return -1; 1580 1581 /* FIXME: Eventually add buffer overflow checking (to getpkt?) */ 1582 len = getpkt (cs.own_buf); 1583 if (len < 0) 1584 return -1; 1585 1586 /* We ought to handle pretty much any packet at this point while we 1587 wait for the qRelocInsn "response". That requires re-entering 1588 the main loop. For now, this is an adequate approximation; allow 1589 GDB to access memory. */ 1590 while (cs.own_buf[0] == 'm' || cs.own_buf[0] == 'M' || cs.own_buf[0] == 'X') 1591 { 1592 CORE_ADDR mem_addr; 1593 unsigned char *mem_buf = NULL; 1594 unsigned int mem_len; 1595 1596 if (cs.own_buf[0] == 'm') 1597 { 1598 decode_m_packet (&cs.own_buf[1], &mem_addr, &mem_len); 1599 mem_buf = (unsigned char *) xmalloc (mem_len); 1600 if (read_inferior_memory (mem_addr, mem_buf, mem_len) == 0) 1601 bin2hex (mem_buf, cs.own_buf, mem_len); 1602 else 1603 write_enn (cs.own_buf); 1604 } 1605 else if (cs.own_buf[0] == 'X') 1606 { 1607 if (decode_X_packet (&cs.own_buf[1], len - 1, &mem_addr, 1608 &mem_len, &mem_buf) < 0 1609 || target_write_memory (mem_addr, mem_buf, mem_len) != 0) 1610 write_enn (cs.own_buf); 1611 else 1612 write_ok (cs.own_buf); 1613 } 1614 else 1615 { 1616 decode_M_packet (&cs.own_buf[1], &mem_addr, &mem_len, &mem_buf); 1617 if (target_write_memory (mem_addr, mem_buf, mem_len) == 0) 1618 write_ok (cs.own_buf); 1619 else 1620 write_enn (cs.own_buf); 1621 } 1622 free (mem_buf); 1623 if (putpkt (cs.own_buf) < 0) 1624 return -1; 1625 len = getpkt (cs.own_buf); 1626 if (len < 0) 1627 return -1; 1628 } 1629 1630 if (cs.own_buf[0] == 'E') 1631 { 1632 warning ("An error occurred while relocating an instruction: %s", 1633 cs.own_buf); 1634 return -1; 1635 } 1636 1637 if (!startswith (cs.own_buf, "qRelocInsn:")) 1638 { 1639 warning ("Malformed response to qRelocInsn, ignoring: %s", 1640 cs.own_buf); 1641 return -1; 1642 } 1643 1644 unpack_varlen_hex (cs.own_buf + strlen ("qRelocInsn:"), &written); 1645 1646 *to += written; 1647 return 0; 1648} 1649 1650void 1651monitor_output (const char *msg) 1652{ 1653 int len = strlen (msg); 1654 char *buf = (char *) xmalloc (len * 2 + 2); 1655 1656 buf[0] = 'O'; 1657 bin2hex ((const gdb_byte *) msg, buf + 1, len); 1658 1659 putpkt (buf); 1660 free (buf); 1661} 1662 1663#endif 1664