1234287Sdim/* Remote utility routines for the remote server for GDB. 2234287Sdim Copyright (C) 1986, 1989, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 3234287Sdim 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 4234287Sdim Free Software Foundation, Inc. 5234287Sdim 6234287Sdim This file is part of GDB. 7234287Sdim 8234287Sdim This program is free software; you can redistribute it and/or modify 9234287Sdim it under the terms of the GNU General Public License as published by 10234287Sdim the Free Software Foundation; either version 3 of the License, or 11243830Sdim (at your option) any later version. 12234287Sdim 13234287Sdim This program is distributed in the hope that it will be useful, 14249423Sdim but WITHOUT ANY WARRANTY; without even the implied warranty of 15234287Sdim MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16234287Sdim GNU General Public License for more details. 17249423Sdim 18249423Sdim You should have received a copy of the GNU General Public License 19249423Sdim along with this program. If not, see <http://www.gnu.org/licenses/>. */ 20249423Sdim 21234287Sdim#include "server.h" 22234287Sdim#include "terminal.h" 23234287Sdim#include "target.h" 24234287Sdim#include <stdio.h> 25234287Sdim#include <string.h> 26234287Sdim#if HAVE_SYS_IOCTL_H 27234287Sdim#include <sys/ioctl.h> 28234287Sdim#endif 29234287Sdim#if HAVE_SYS_FILE_H 30234287Sdim#include <sys/file.h> 31234287Sdim#endif 32234287Sdim#if HAVE_NETINET_IN_H 33234287Sdim#include <netinet/in.h> 34234287Sdim#endif 35234287Sdim#if HAVE_SYS_SOCKET_H 36234287Sdim#include <sys/socket.h> 37234287Sdim#endif 38234287Sdim#if HAVE_NETDB_H 39234287Sdim#include <netdb.h> 40234287Sdim#endif 41234287Sdim#if HAVE_NETINET_TCP_H 42234287Sdim#include <netinet/tcp.h> 43234287Sdim#endif 44234287Sdim#if HAVE_SYS_IOCTL_H 45234287Sdim#include <sys/ioctl.h> 46234287Sdim#endif 47234287Sdim#if HAVE_SIGNAL_H 48234287Sdim#include <signal.h> 49234287Sdim#endif 50249423Sdim#if HAVE_FCNTL_H 51249423Sdim#include <fcntl.h> 52249423Sdim#endif 53249423Sdim#include <sys/time.h> 54249423Sdim#if HAVE_UNISTD_H 55234287Sdim#include <unistd.h> 56234287Sdim#endif 57234287Sdim#if HAVE_ARPA_INET_H 58234287Sdim#include <arpa/inet.h> 59234287Sdim#endif 60234287Sdim#include <sys/stat.h> 61234287Sdim#if HAVE_ERRNO_H 62234287Sdim#include <errno.h> 63234287Sdim#endif 64234287Sdim 65234287Sdim#if USE_WIN32API 66234287Sdim#include <winsock2.h> 67234287Sdim#endif 68239462Sdim 69243830Sdim#if __QNX__ 70243830Sdim#include <sys/iomgr.h> 71234287Sdim#endif /* __QNX__ */ 72234287Sdim 73234287Sdim#ifndef HAVE_SOCKLEN_T 74234287Sdimtypedef int socklen_t; 75234287Sdim#endif 76234287Sdim 77234287Sdim#ifndef IN_PROCESS_AGENT 78234287Sdim 79234287Sdim#if USE_WIN32API 80234287Sdim# define INVALID_DESCRIPTOR INVALID_SOCKET 81234287Sdim#else 82234287Sdim# define INVALID_DESCRIPTOR -1 83234287Sdim#endif 84234287Sdim 85234287Sdim/* Extra value for readchar_callback. */ 86234287Sdimenum { 87234287Sdim /* The callback is currently not scheduled. */ 88234287Sdim NOT_SCHEDULED = -1 89234287Sdim}; 90234287Sdim 91234287Sdim/* Status of the readchar callback. 92234287Sdim Either NOT_SCHEDULED or the callback id. */ 93234287Sdimstatic int readchar_callback = NOT_SCHEDULED; 94234287Sdim 95234287Sdimstatic int readchar (void); 96234287Sdimstatic void reset_readchar (void); 97234287Sdimstatic void reschedule (void); 98234287Sdim 99234287Sdim/* A cache entry for a successfully looked-up symbol. */ 100234287Sdimstruct sym_cache 101234287Sdim{ 102234287Sdim char *name; 103234287Sdim CORE_ADDR addr; 104234287Sdim struct sym_cache *next; 105234287Sdim}; 106234287Sdim 107234287Sdimint remote_debug = 0; 108234287Sdimstruct ui_file *gdb_stdlog; 109234287Sdim 110234287Sdimstatic gdb_fildes_t remote_desc = INVALID_DESCRIPTOR; 111234287Sdimstatic gdb_fildes_t listen_desc = INVALID_DESCRIPTOR; 112234287Sdim 113234287Sdim/* FIXME headerize? */ 114234287Sdimextern int using_threads; 115234287Sdimextern int debug_threads; 116234287Sdim 117234287Sdim/* If true, then GDB has requested noack mode. */ 118234287Sdimint noack_mode = 0; 119234287Sdim/* If true, then we tell GDB to use noack mode by default. */ 120234287Sdimint transport_is_reliable = 0; 121234287Sdim 122234287Sdim#ifdef USE_WIN32API 123234287Sdim# define read(fd, buf, len) recv (fd, (char *) buf, len, 0) 124234287Sdim# define write(fd, buf, len) send (fd, (char *) buf, len, 0) 125234287Sdim#endif 126234287Sdim 127234287Sdimint 128239462Sdimgdb_connected (void) 129234287Sdim{ 130239462Sdim return remote_desc != INVALID_DESCRIPTOR; 131249423Sdim} 132234287Sdim 133249423Sdimstatic void 134249423Sdimenable_async_notification (int fd) 135249423Sdim{ 136249423Sdim#if defined(F_SETFL) && defined (FASYNC) 137249423Sdim int save_fcntl_flags; 138234287Sdim 139234287Sdim save_fcntl_flags = fcntl (fd, F_GETFL, 0); 140234287Sdim fcntl (fd, F_SETFL, save_fcntl_flags | FASYNC); 141249423Sdim#if defined (F_SETOWN) 142249423Sdim fcntl (fd, F_SETOWN, getpid ()); 143234287Sdim#endif 144239462Sdim#endif 145234287Sdim} 146234287Sdim 147234287Sdimstatic int 148234287Sdimhandle_accept_event (int err, gdb_client_data client_data) 149234287Sdim{ 150234287Sdim struct sockaddr_in sockaddr; 151234287Sdim socklen_t tmp; 152234287Sdim 153249423Sdim if (debug_threads) 154249423Sdim fprintf (stderr, "handling possible accept event\n"); 155249423Sdim 156249423Sdim tmp = sizeof (sockaddr); 157249423Sdim remote_desc = accept (listen_desc, (struct sockaddr *) &sockaddr, &tmp); 158249423Sdim if (remote_desc == -1) 159249423Sdim perror_with_name ("Accept failed"); 160249423Sdim 161249423Sdim /* Enable TCP keep alive process. */ 162249423Sdim tmp = 1; 163249423Sdim setsockopt (remote_desc, SOL_SOCKET, SO_KEEPALIVE, 164249423Sdim (char *) &tmp, sizeof (tmp)); 165249423Sdim 166249423Sdim /* Tell TCP not to delay small packets. This greatly speeds up 167249423Sdim interactive response. */ 168249423Sdim tmp = 1; 169249423Sdim setsockopt (remote_desc, IPPROTO_TCP, TCP_NODELAY, 170249423Sdim (char *) &tmp, sizeof (tmp)); 171249423Sdim 172249423Sdim#ifndef USE_WIN32API 173249423Sdim close (listen_desc); /* No longer need this */ 174249423Sdim 175249423Sdim signal (SIGPIPE, SIG_IGN); /* If we don't do this, then gdbserver simply 176234287Sdim exits when the remote side dies. */ 177249423Sdim#else 178234287Sdim closesocket (listen_desc); /* No longer need this */ 179234287Sdim#endif 180249423Sdim 181234287Sdim delete_file_handler (listen_desc); 182234287Sdim 183234287Sdim /* Convert IP address to string. */ 184234287Sdim fprintf (stderr, "Remote debugging from host %s\n", 185234287Sdim inet_ntoa (sockaddr.sin_addr)); 186234287Sdim 187234287Sdim enable_async_notification (remote_desc); 188239462Sdim 189239462Sdim /* Register the event loop handler. */ 190234287Sdim add_file_handler (remote_desc, handle_serial_event, NULL); 191234287Sdim 192234287Sdim /* We have a new GDB connection now. If we were disconnected 193234287Sdim tracing, there's a window where the target could report a stop 194234287Sdim event to the event loop, and since we have a connection now, we'd 195234287Sdim try to send vStopped notifications to GDB. But, don't do that 196234287Sdim until GDB as selected all-stop/non-stop, and has queried the 197234287Sdim threads' status ('?'). */ 198234287Sdim target_async (0); 199234287Sdim 200234287Sdim return 0; 201249423Sdim} 202249423Sdim 203234287Sdim/* Open a connection to a remote debugger. 204234287Sdim NAME is the filename used for communication. */ 205249423Sdim 206239462Sdimvoid 207239462Sdimremote_open (char *name) 208249423Sdim{ 209249423Sdim char *port_str; 210234287Sdim 211249423Sdim port_str = strchr (name, ':'); 212234287Sdim if (port_str == NULL) 213234287Sdim { 214249423Sdim#ifdef USE_WIN32API 215249423Sdim error ("Only <host>:<port> is supported on this platform."); 216243830Sdim#else 217234287Sdim struct stat statbuf; 218249423Sdim 219249423Sdim if (stat (name, &statbuf) == 0 220249423Sdim && (S_ISCHR (statbuf.st_mode) || S_ISFIFO (statbuf.st_mode))) 221249423Sdim remote_desc = open (name, O_RDWR); 222249423Sdim else 223249423Sdim { 224249423Sdim errno = EINVAL; 225234287Sdim remote_desc = -1; 226234287Sdim } 227234287Sdim 228234287Sdim if (remote_desc < 0) 229239462Sdim perror_with_name ("Could not open remote device"); 230239462Sdim 231249423Sdim#ifdef HAVE_TERMIOS 232249423Sdim { 233234287Sdim struct termios termios; 234249423Sdim tcgetattr (remote_desc, &termios); 235234287Sdim 236249423Sdim termios.c_iflag = 0; 237234287Sdim termios.c_oflag = 0; 238234287Sdim termios.c_lflag = 0; 239249423Sdim termios.c_cflag &= ~(CSIZE | PARENB); 240249423Sdim termios.c_cflag |= CLOCAL | CS8; 241249423Sdim termios.c_cc[VMIN] = 1; 242249423Sdim termios.c_cc[VTIME] = 0; 243249423Sdim 244249423Sdim tcsetattr (remote_desc, TCSANOW, &termios); 245249423Sdim } 246249423Sdim#endif 247249423Sdim 248249423Sdim#ifdef HAVE_TERMIO 249249423Sdim { 250234287Sdim struct termio termio; 251239462Sdim ioctl (remote_desc, TCGETA, &termio); 252234287Sdim 253234287Sdim termio.c_iflag = 0; 254239462Sdim termio.c_oflag = 0; 255234287Sdim termio.c_lflag = 0; 256234287Sdim termio.c_cflag &= ~(CSIZE | PARENB); 257249423Sdim termio.c_cflag |= CLOCAL | CS8; 258249423Sdim termio.c_cc[VMIN] = 1; 259249423Sdim termio.c_cc[VTIME] = 0; 260249423Sdim 261249423Sdim ioctl (remote_desc, TCSETA, &termio); 262249423Sdim } 263249423Sdim#endif 264249423Sdim 265249423Sdim#ifdef HAVE_SGTTY 266249423Sdim { 267249423Sdim struct sgttyb sg; 268249423Sdim 269249423Sdim ioctl (remote_desc, TIOCGETP, &sg); 270249423Sdim sg.sg_flags = RAW; 271249423Sdim ioctl (remote_desc, TIOCSETP, &sg); 272249423Sdim } 273249423Sdim#endif 274249423Sdim 275249423Sdim fprintf (stderr, "Remote debugging using %s\n", name); 276249423Sdim 277249423Sdim transport_is_reliable = 0; 278249423Sdim 279249423Sdim enable_async_notification (remote_desc); 280249423Sdim 281249423Sdim /* Register the event loop handler. */ 282249423Sdim add_file_handler (remote_desc, handle_serial_event, NULL); 283249423Sdim#endif /* USE_WIN32API */ 284249423Sdim } 285249423Sdim else 286249423Sdim { 287249423Sdim#ifdef USE_WIN32API 288249423Sdim static int winsock_initialized; 289249423Sdim#endif 290249423Sdim int port; 291249423Sdim struct sockaddr_in sockaddr; 292249423Sdim socklen_t tmp; 293249423Sdim char *port_end; 294249423Sdim 295249423Sdim port = strtoul (port_str + 1, &port_end, 10); 296249423Sdim if (port_str[1] == '\0' || *port_end != '\0') 297249423Sdim fatal ("Bad port argument: %s", name); 298249423Sdim 299249423Sdim#ifdef USE_WIN32API 300249423Sdim if (!winsock_initialized) 301249423Sdim { 302249423Sdim WSADATA wsad; 303249423Sdim 304249423Sdim WSAStartup (MAKEWORD (1, 0), &wsad); 305249423Sdim winsock_initialized = 1; 306249423Sdim } 307243830Sdim#endif 308243830Sdim 309243830Sdim listen_desc = socket (PF_INET, SOCK_STREAM, IPPROTO_TCP); 310243830Sdim if (listen_desc == -1) 311243830Sdim perror_with_name ("Can't open socket"); 312243830Sdim 313243830Sdim /* Allow rapid reuse of this port. */ 314243830Sdim tmp = 1; 315243830Sdim setsockopt (listen_desc, SOL_SOCKET, SO_REUSEADDR, (char *) &tmp, 316243830Sdim sizeof (tmp)); 317243830Sdim 318243830Sdim sockaddr.sin_family = PF_INET; 319249423Sdim sockaddr.sin_port = htons (port); 320249423Sdim sockaddr.sin_addr.s_addr = INADDR_ANY; 321243830Sdim 322243830Sdim if (bind (listen_desc, (struct sockaddr *) &sockaddr, sizeof (sockaddr)) 323243830Sdim || listen (listen_desc, 1)) 324249423Sdim perror_with_name ("Can't bind address"); 325243830Sdim 326243830Sdim /* If port is zero, a random port will be selected, and the 327243830Sdim fprintf below needs to know what port was selected. */ 328243830Sdim if (port == 0) 329243830Sdim { 330249423Sdim socklen_t len = sizeof (sockaddr); 331249423Sdim if (getsockname (listen_desc, 332243830Sdim (struct sockaddr *) &sockaddr, &len) < 0 333249423Sdim || len < sizeof (sockaddr)) 334249423Sdim perror_with_name ("Can't determine port"); 335249423Sdim port = ntohs (sockaddr.sin_port); 336249423Sdim } 337249423Sdim 338249423Sdim fprintf (stderr, "Listening on port %d\n", port); 339249423Sdim fflush (stderr); 340249423Sdim 341249423Sdim /* Register the event loop handler. */ 342249423Sdim add_file_handler (listen_desc, handle_accept_event, NULL); 343249423Sdim 344249423Sdim transport_is_reliable = 1; 345249423Sdim } 346249423Sdim} 347249423Sdim 348249423Sdimvoid 349249423Sdimremote_close (void) 350249423Sdim{ 351249423Sdim delete_file_handler (remote_desc); 352249423Sdim 353249423Sdim#ifdef USE_WIN32API 354249423Sdim closesocket (remote_desc); 355249423Sdim#else 356249423Sdim close (remote_desc); 357249423Sdim#endif 358243830Sdim remote_desc = INVALID_DESCRIPTOR; 359243830Sdim 360249423Sdim reset_readchar (); 361243830Sdim} 362243830Sdim 363249423Sdim/* Convert hex digit A to a number. */ 364249423Sdim 365249423Sdimstatic int 366249423Sdimfromhex (int a) 367249423Sdim{ 368249423Sdim if (a >= '0' && a <= '9') 369249423Sdim return a - '0'; 370249423Sdim else if (a >= 'a' && a <= 'f') 371243830Sdim return a - 'a' + 10; 372243830Sdim else 373243830Sdim error ("Reply contains invalid hex digit"); 374243830Sdim return 0; 375243830Sdim} 376243830Sdim 377243830Sdim#endif 378243830Sdim 379243830Sdimstatic const char hexchars[] = "0123456789abcdef"; 380243830Sdim 381249423Sdimstatic int 382249423Sdimishex (int ch, int *val) 383249423Sdim{ 384249423Sdim if ((ch >= 'a') && (ch <= 'f')) 385249423Sdim { 386249423Sdim *val = ch - 'a' + 10; 387249423Sdim return 1; 388249423Sdim } 389249423Sdim if ((ch >= 'A') && (ch <= 'F')) 390249423Sdim { 391234287Sdim *val = ch - 'A' + 10; 392234287Sdim return 1; 393234287Sdim } 394234287Sdim if ((ch >= '0') && (ch <= '9')) 395234287Sdim { 396234287Sdim *val = ch - '0'; 397234287Sdim return 1; 398234287Sdim } 399234287Sdim return 0; 400234287Sdim} 401234287Sdim 402234287Sdim#ifndef IN_PROCESS_AGENT 403249423Sdim 404249423Sdimint 405249423Sdimunhexify (char *bin, const char *hex, int count) 406249423Sdim{ 407249423Sdim int i; 408249423Sdim 409249423Sdim for (i = 0; i < count; i++) 410234287Sdim { 411243830Sdim if (hex[0] == 0 || hex[1] == 0) 412249423Sdim { 413239462Sdim /* Hex string is short, or of uneven length. 414249423Sdim Return the count that has been converted so far. */ 415249423Sdim return i; 416249423Sdim } 417249423Sdim *bin++ = fromhex (hex[0]) * 16 + fromhex (hex[1]); 418249423Sdim hex += 2; 419243830Sdim } 420234287Sdim return i; 421243830Sdim} 422243830Sdim 423243830Sdimvoid 424243830Sdimdecode_address (CORE_ADDR *addrp, const char *start, int len) 425243830Sdim{ 426234287Sdim CORE_ADDR addr; 427249423Sdim char ch; 428234287Sdim int i; 429234287Sdim 430234287Sdim addr = 0; 431249423Sdim for (i = 0; i < len; i++) 432234287Sdim { 433234287Sdim ch = start[i]; 434234287Sdim addr = addr << 4; 435234287Sdim addr = addr | (fromhex (ch) & 0x0f); 436234287Sdim } 437234287Sdim *addrp = addr; 438234287Sdim} 439234287Sdim 440234287Sdimconst char * 441234287Sdimdecode_address_to_semicolon (CORE_ADDR *addrp, const char *start) 442234287Sdim{ 443234287Sdim const char *end; 444243830Sdim 445249423Sdim end = start; 446249423Sdim while (*end != '\0' && *end != ';') 447249423Sdim end++; 448249423Sdim 449249423Sdim decode_address (addrp, start, end - start); 450249423Sdim 451249423Sdim if (*end == ';') 452249423Sdim end++; 453249423Sdim return end; 454249423Sdim} 455243830Sdim 456249423Sdim#endif 457243830Sdim 458234287Sdim/* Convert number NIB to a hex digit. */ 459234287Sdim 460249423Sdimstatic int 461249423Sdimtohex (int nib) 462249423Sdim{ 463249423Sdim if (nib < 10) 464249423Sdim return '0' + nib; 465251662Sdim else 466251662Sdim return 'a' + nib - 10; 467234287Sdim} 468234287Sdim 469234287Sdim#ifndef IN_PROCESS_AGENT 470234287Sdim 471234287Sdimint 472239462Sdimhexify (char *hex, const char *bin, int count) 473239462Sdim{ 474234287Sdim int i; 475234287Sdim 476234287Sdim /* May use a length, or a nul-terminated string as input. */ 477234287Sdim if (count == 0) 478234287Sdim count = strlen (bin); 479239462Sdim 480234287Sdim for (i = 0; i < count; i++) 481234287Sdim { 482249423Sdim *hex++ = tohex ((*bin >> 4) & 0xf); 483249423Sdim *hex++ = tohex (*bin++ & 0xf); 484249423Sdim } 485249423Sdim *hex = 0; 486249423Sdim return i; 487249423Sdim} 488249423Sdim 489249423Sdim/* Convert BUFFER, binary data at least LEN bytes long, into escaped 490249423Sdim binary data in OUT_BUF. Set *OUT_LEN to the length of the data 491249423Sdim encoded in OUT_BUF, and return the number of bytes in OUT_BUF 492249423Sdim (which may be more than *OUT_LEN due to escape characters). The 493249423Sdim total number of bytes in the output buffer will be at most 494249423Sdim OUT_MAXLEN. */ 495249423Sdim 496249423Sdimint 497249423Sdimremote_escape_output (const gdb_byte *buffer, int len, 498249423Sdim gdb_byte *out_buf, int *out_len, 499249423Sdim int out_maxlen) 500249423Sdim{ 501249423Sdim int input_index, output_index; 502249423Sdim 503249423Sdim output_index = 0; 504249423Sdim for (input_index = 0; input_index < len; input_index++) 505249423Sdim { 506249423Sdim gdb_byte b = buffer[input_index]; 507249423Sdim 508234287Sdim if (b == '$' || b == '#' || b == '}' || b == '*') 509239462Sdim { 510234287Sdim /* These must be escaped. */ 511 if (output_index + 2 > out_maxlen) 512 break; 513 out_buf[output_index++] = '}'; 514 out_buf[output_index++] = b ^ 0x20; 515 } 516 else 517 { 518 if (output_index + 1 > out_maxlen) 519 break; 520 out_buf[output_index++] = b; 521 } 522 } 523 524 *out_len = input_index; 525 return output_index; 526} 527 528/* Convert BUFFER, escaped data LEN bytes long, into binary data 529 in OUT_BUF. Return the number of bytes written to OUT_BUF. 530 Raise an error if the total number of bytes exceeds OUT_MAXLEN. 531 532 This function reverses remote_escape_output. It allows more 533 escaped characters than that function does, in particular because 534 '*' must be escaped to avoid the run-length encoding processing 535 in reading packets. */ 536 537static int 538remote_unescape_input (const gdb_byte *buffer, int len, 539 gdb_byte *out_buf, int out_maxlen) 540{ 541 int input_index, output_index; 542 int escaped; 543 544 output_index = 0; 545 escaped = 0; 546 for (input_index = 0; input_index < len; input_index++) 547 { 548 gdb_byte b = buffer[input_index]; 549 550 if (output_index + 1 > out_maxlen) 551 error ("Received too much data from the target."); 552 553 if (escaped) 554 { 555 out_buf[output_index++] = b ^ 0x20; 556 escaped = 0; 557 } 558 else if (b == '}') 559 escaped = 1; 560 else 561 out_buf[output_index++] = b; 562 } 563 564 if (escaped) 565 error ("Unmatched escape character in target response."); 566 567 return output_index; 568} 569 570/* Look for a sequence of characters which can be run-length encoded. 571 If there are any, update *CSUM and *P. Otherwise, output the 572 single character. Return the number of characters consumed. */ 573 574static int 575try_rle (char *buf, int remaining, unsigned char *csum, char **p) 576{ 577 int n; 578 579 /* Always output the character. */ 580 *csum += buf[0]; 581 *(*p)++ = buf[0]; 582 583 /* Don't go past '~'. */ 584 if (remaining > 97) 585 remaining = 97; 586 587 for (n = 1; n < remaining; n++) 588 if (buf[n] != buf[0]) 589 break; 590 591 /* N is the index of the first character not the same as buf[0]. 592 buf[0] is counted twice, so by decrementing N, we get the number 593 of characters the RLE sequence will replace. */ 594 n--; 595 596 if (n < 3) 597 return 1; 598 599 /* Skip the frame characters. The manual says to skip '+' and '-' 600 also, but there's no reason to. Unfortunately these two unusable 601 characters double the encoded length of a four byte zero 602 value. */ 603 while (n + 29 == '$' || n + 29 == '#') 604 n--; 605 606 *csum += '*'; 607 *(*p)++ = '*'; 608 *csum += n + 29; 609 *(*p)++ = n + 29; 610 611 return n + 1; 612} 613 614#endif 615 616char * 617unpack_varlen_hex (char *buff, /* packet to parse */ 618 ULONGEST *result) 619{ 620 int nibble; 621 ULONGEST retval = 0; 622 623 while (ishex (*buff, &nibble)) 624 { 625 buff++; 626 retval = retval << 4; 627 retval |= nibble & 0x0f; 628 } 629 *result = retval; 630 return buff; 631} 632 633#ifndef IN_PROCESS_AGENT 634 635/* Write a PTID to BUF. Returns BUF+CHARACTERS_WRITTEN. */ 636 637char * 638write_ptid (char *buf, ptid_t ptid) 639{ 640 int pid, tid; 641 642 if (multi_process) 643 { 644 pid = ptid_get_pid (ptid); 645 if (pid < 0) 646 buf += sprintf (buf, "p-%x.", -pid); 647 else 648 buf += sprintf (buf, "p%x.", pid); 649 } 650 tid = ptid_get_lwp (ptid); 651 if (tid < 0) 652 buf += sprintf (buf, "-%x", -tid); 653 else 654 buf += sprintf (buf, "%x", tid); 655 656 return buf; 657} 658 659ULONGEST 660hex_or_minus_one (char *buf, char **obuf) 661{ 662 ULONGEST ret; 663 664 if (strncmp (buf, "-1", 2) == 0) 665 { 666 ret = (ULONGEST) -1; 667 buf += 2; 668 } 669 else 670 buf = unpack_varlen_hex (buf, &ret); 671 672 if (obuf) 673 *obuf = buf; 674 675 return ret; 676} 677 678/* Extract a PTID from BUF. If non-null, OBUF is set to the to one 679 passed the last parsed char. Returns null_ptid on error. */ 680ptid_t 681read_ptid (char *buf, char **obuf) 682{ 683 char *p = buf; 684 char *pp; 685 ULONGEST pid = 0, tid = 0; 686 687 if (*p == 'p') 688 { 689 /* Multi-process ptid. */ 690 pp = unpack_varlen_hex (p + 1, &pid); 691 if (*pp != '.') 692 error ("invalid remote ptid: %s\n", p); 693 694 p = pp + 1; 695 696 tid = hex_or_minus_one (p, &pp); 697 698 if (obuf) 699 *obuf = pp; 700 return ptid_build (pid, tid, 0); 701 } 702 703 /* No multi-process. Just a tid. */ 704 tid = hex_or_minus_one (p, &pp); 705 706 /* Since the stub is not sending a process id, then default to 707 what's in the current inferior. */ 708 pid = ptid_get_pid (((struct inferior_list_entry *) current_inferior)->id); 709 710 if (obuf) 711 *obuf = pp; 712 return ptid_build (pid, tid, 0); 713} 714 715/* Send a packet to the remote machine, with error checking. 716 The data of the packet is in BUF, and the length of the 717 packet is in CNT. Returns >= 0 on success, -1 otherwise. */ 718 719static int 720putpkt_binary_1 (char *buf, int cnt, int is_notif) 721{ 722 int i; 723 unsigned char csum = 0; 724 char *buf2; 725 char *p; 726 int cc; 727 728 buf2 = xmalloc (strlen ("$") + cnt + strlen ("#nn") + 1); 729 730 /* Copy the packet into buffer BUF2, encapsulating it 731 and giving it a checksum. */ 732 733 p = buf2; 734 if (is_notif) 735 *p++ = '%'; 736 else 737 *p++ = '$'; 738 739 for (i = 0; i < cnt;) 740 i += try_rle (buf + i, cnt - i, &csum, &p); 741 742 *p++ = '#'; 743 *p++ = tohex ((csum >> 4) & 0xf); 744 *p++ = tohex (csum & 0xf); 745 746 *p = '\0'; 747 748 /* Send it over and over until we get a positive ack. */ 749 750 do 751 { 752 if (write (remote_desc, buf2, p - buf2) != p - buf2) 753 { 754 perror ("putpkt(write)"); 755 free (buf2); 756 return -1; 757 } 758 759 if (noack_mode || is_notif) 760 { 761 /* Don't expect an ack then. */ 762 if (remote_debug) 763 { 764 if (is_notif) 765 fprintf (stderr, "putpkt (\"%s\"); [notif]\n", buf2); 766 else 767 fprintf (stderr, "putpkt (\"%s\"); [noack mode]\n", buf2); 768 fflush (stderr); 769 } 770 break; 771 } 772 773 if (remote_debug) 774 { 775 fprintf (stderr, "putpkt (\"%s\"); [looking for ack]\n", buf2); 776 fflush (stderr); 777 } 778 779 cc = readchar (); 780 781 if (cc < 0) 782 { 783 free (buf2); 784 return -1; 785 } 786 787 if (remote_debug) 788 { 789 fprintf (stderr, "[received '%c' (0x%x)]\n", cc, cc); 790 fflush (stderr); 791 } 792 793 /* Check for an input interrupt while we're here. */ 794 if (cc == '\003' && current_inferior != NULL) 795 (*the_target->request_interrupt) (); 796 } 797 while (cc != '+'); 798 799 free (buf2); 800 return 1; /* Success! */ 801} 802 803int 804putpkt_binary (char *buf, int cnt) 805{ 806 return putpkt_binary_1 (buf, cnt, 0); 807} 808 809/* Send a packet to the remote machine, with error checking. The data 810 of the packet is in BUF, and the packet should be a NUL-terminated 811 string. Returns >= 0 on success, -1 otherwise. */ 812 813int 814putpkt (char *buf) 815{ 816 return putpkt_binary (buf, strlen (buf)); 817} 818 819int 820putpkt_notif (char *buf) 821{ 822 return putpkt_binary_1 (buf, strlen (buf), 1); 823} 824 825/* Come here when we get an input interrupt from the remote side. This 826 interrupt should only be active while we are waiting for the child to do 827 something. Thus this assumes readchar:bufcnt is 0. 828 About the only thing that should come through is a ^C, which 829 will cause us to request child interruption. */ 830 831static void 832input_interrupt (int unused) 833{ 834 fd_set readset; 835 struct timeval immediate = { 0, 0 }; 836 837 /* Protect against spurious interrupts. This has been observed to 838 be a problem under NetBSD 1.4 and 1.5. */ 839 840 FD_ZERO (&readset); 841 FD_SET (remote_desc, &readset); 842 if (select (remote_desc + 1, &readset, 0, 0, &immediate) > 0) 843 { 844 int cc; 845 char c = 0; 846 847 cc = read (remote_desc, &c, 1); 848 849 if (cc != 1 || c != '\003' || current_inferior == NULL) 850 { 851 fprintf (stderr, "input_interrupt, count = %d c = %d ('%c')\n", 852 cc, c, c); 853 return; 854 } 855 856 (*the_target->request_interrupt) (); 857 } 858} 859 860/* Check if the remote side sent us an interrupt request (^C). */ 861void 862check_remote_input_interrupt_request (void) 863{ 864 /* This function may be called before establishing communications, 865 therefore we need to validate the remote descriptor. */ 866 867 if (remote_desc == INVALID_DESCRIPTOR) 868 return; 869 870 input_interrupt (0); 871} 872 873/* Asynchronous I/O support. SIGIO must be enabled when waiting, in order to 874 accept Control-C from the client, and must be disabled when talking to 875 the client. */ 876 877static void 878unblock_async_io (void) 879{ 880#ifndef USE_WIN32API 881 sigset_t sigio_set; 882 883 sigemptyset (&sigio_set); 884 sigaddset (&sigio_set, SIGIO); 885 sigprocmask (SIG_UNBLOCK, &sigio_set, NULL); 886#endif 887} 888 889#ifdef __QNX__ 890static void 891nto_comctrl (int enable) 892{ 893 struct sigevent event; 894 895 if (enable) 896 { 897 event.sigev_notify = SIGEV_SIGNAL_THREAD; 898 event.sigev_signo = SIGIO; 899 event.sigev_code = 0; 900 event.sigev_value.sival_ptr = NULL; 901 event.sigev_priority = -1; 902 ionotify (remote_desc, _NOTIFY_ACTION_POLLARM, _NOTIFY_COND_INPUT, 903 &event); 904 } 905 else 906 ionotify (remote_desc, _NOTIFY_ACTION_POLL, _NOTIFY_COND_INPUT, NULL); 907} 908#endif /* __QNX__ */ 909 910 911/* Current state of asynchronous I/O. */ 912static int async_io_enabled; 913 914/* Enable asynchronous I/O. */ 915void 916enable_async_io (void) 917{ 918 if (async_io_enabled) 919 return; 920 921#ifndef USE_WIN32API 922 signal (SIGIO, input_interrupt); 923#endif 924 async_io_enabled = 1; 925#ifdef __QNX__ 926 nto_comctrl (1); 927#endif /* __QNX__ */ 928} 929 930/* Disable asynchronous I/O. */ 931void 932disable_async_io (void) 933{ 934 if (!async_io_enabled) 935 return; 936 937#ifndef USE_WIN32API 938 signal (SIGIO, SIG_IGN); 939#endif 940 async_io_enabled = 0; 941#ifdef __QNX__ 942 nto_comctrl (0); 943#endif /* __QNX__ */ 944 945} 946 947void 948initialize_async_io (void) 949{ 950 /* Make sure that async I/O starts disabled. */ 951 async_io_enabled = 1; 952 disable_async_io (); 953 954 /* Make sure the signal is unblocked. */ 955 unblock_async_io (); 956} 957 958/* Internal buffer used by readchar. 959 These are global to readchar because reschedule_remote needs to be 960 able to tell whether the buffer is empty. */ 961 962static unsigned char readchar_buf[BUFSIZ]; 963static int readchar_bufcnt = 0; 964static unsigned char *readchar_bufp; 965 966/* Returns next char from remote GDB. -1 if error. */ 967 968static int 969readchar (void) 970{ 971 int ch; 972 973 if (readchar_bufcnt == 0) 974 { 975 readchar_bufcnt = read (remote_desc, readchar_buf, 976 sizeof (readchar_buf)); 977 978 if (readchar_bufcnt <= 0) 979 { 980 if (readchar_bufcnt == 0) 981 fprintf (stderr, "readchar: Got EOF\n"); 982 else 983 perror ("readchar"); 984 985 return -1; 986 } 987 988 readchar_bufp = readchar_buf; 989 } 990 991 readchar_bufcnt--; 992 ch = *readchar_bufp++; 993 reschedule (); 994 return ch; 995} 996 997/* Reset the readchar state machine. */ 998 999static void 1000reset_readchar (void) 1001{ 1002 readchar_bufcnt = 0; 1003 if (readchar_callback != NOT_SCHEDULED) 1004 { 1005 delete_callback_event (readchar_callback); 1006 readchar_callback = NOT_SCHEDULED; 1007 } 1008} 1009 1010/* Process remaining data in readchar_buf. */ 1011 1012static int 1013process_remaining (void *context) 1014{ 1015 int res; 1016 1017 /* This is a one-shot event. */ 1018 readchar_callback = NOT_SCHEDULED; 1019 1020 if (readchar_bufcnt > 0) 1021 res = handle_serial_event (0, NULL); 1022 else 1023 res = 0; 1024 1025 return res; 1026} 1027 1028/* If there is still data in the buffer, queue another event to process it, 1029 we can't sleep in select yet. */ 1030 1031static void 1032reschedule (void) 1033{ 1034 if (readchar_bufcnt > 0 && readchar_callback == NOT_SCHEDULED) 1035 readchar_callback = append_callback_event (process_remaining, NULL); 1036} 1037 1038/* Read a packet from the remote machine, with error checking, 1039 and store it in BUF. Returns length of packet, or negative if error. */ 1040 1041int 1042getpkt (char *buf) 1043{ 1044 char *bp; 1045 unsigned char csum, c1, c2; 1046 int c; 1047 1048 while (1) 1049 { 1050 csum = 0; 1051 1052 while (1) 1053 { 1054 c = readchar (); 1055 if (c == '$') 1056 break; 1057 if (remote_debug) 1058 { 1059 fprintf (stderr, "[getpkt: discarding char '%c']\n", c); 1060 fflush (stderr); 1061 } 1062 1063 if (c < 0) 1064 return -1; 1065 } 1066 1067 bp = buf; 1068 while (1) 1069 { 1070 c = readchar (); 1071 if (c < 0) 1072 return -1; 1073 if (c == '#') 1074 break; 1075 *bp++ = c; 1076 csum += c; 1077 } 1078 *bp = 0; 1079 1080 c1 = fromhex (readchar ()); 1081 c2 = fromhex (readchar ()); 1082 1083 if (csum == (c1 << 4) + c2) 1084 break; 1085 1086 if (noack_mode) 1087 { 1088 fprintf (stderr, 1089 "Bad checksum, sentsum=0x%x, csum=0x%x, " 1090 "buf=%s [no-ack-mode, Bad medium?]\n", 1091 (c1 << 4) + c2, csum, buf); 1092 /* Not much we can do, GDB wasn't expecting an ack/nac. */ 1093 break; 1094 } 1095 1096 fprintf (stderr, "Bad checksum, sentsum=0x%x, csum=0x%x, buf=%s\n", 1097 (c1 << 4) + c2, csum, buf); 1098 if (write (remote_desc, "-", 1) != 1) 1099 return -1; 1100 } 1101 1102 if (!noack_mode) 1103 { 1104 if (remote_debug) 1105 { 1106 fprintf (stderr, "getpkt (\"%s\"); [sending ack] \n", buf); 1107 fflush (stderr); 1108 } 1109 1110 if (write (remote_desc, "+", 1) != 1) 1111 return -1; 1112 1113 if (remote_debug) 1114 { 1115 fprintf (stderr, "[sent ack]\n"); 1116 fflush (stderr); 1117 } 1118 } 1119 else 1120 { 1121 if (remote_debug) 1122 { 1123 fprintf (stderr, "getpkt (\"%s\"); [no ack sent] \n", buf); 1124 fflush (stderr); 1125 } 1126 } 1127 1128 return bp - buf; 1129} 1130 1131void 1132write_ok (char *buf) 1133{ 1134 buf[0] = 'O'; 1135 buf[1] = 'K'; 1136 buf[2] = '\0'; 1137} 1138 1139void 1140write_enn (char *buf) 1141{ 1142 /* Some day, we should define the meanings of the error codes... */ 1143 buf[0] = 'E'; 1144 buf[1] = '0'; 1145 buf[2] = '1'; 1146 buf[3] = '\0'; 1147} 1148 1149#endif 1150 1151void 1152convert_int_to_ascii (const unsigned char *from, char *to, int n) 1153{ 1154 int nib; 1155 int ch; 1156 while (n--) 1157 { 1158 ch = *from++; 1159 nib = ((ch & 0xf0) >> 4) & 0x0f; 1160 *to++ = tohex (nib); 1161 nib = ch & 0x0f; 1162 *to++ = tohex (nib); 1163 } 1164 *to++ = 0; 1165} 1166 1167#ifndef IN_PROCESS_AGENT 1168 1169void 1170convert_ascii_to_int (const char *from, unsigned char *to, int n) 1171{ 1172 int nib1, nib2; 1173 while (n--) 1174 { 1175 nib1 = fromhex (*from++); 1176 nib2 = fromhex (*from++); 1177 *to++ = (((nib1 & 0x0f) << 4) & 0xf0) | (nib2 & 0x0f); 1178 } 1179} 1180 1181static char * 1182outreg (struct regcache *regcache, int regno, char *buf) 1183{ 1184 if ((regno >> 12) != 0) 1185 *buf++ = tohex ((regno >> 12) & 0xf); 1186 if ((regno >> 8) != 0) 1187 *buf++ = tohex ((regno >> 8) & 0xf); 1188 *buf++ = tohex ((regno >> 4) & 0xf); 1189 *buf++ = tohex (regno & 0xf); 1190 *buf++ = ':'; 1191 collect_register_as_string (regcache, regno, buf); 1192 buf += 2 * register_size (regno); 1193 *buf++ = ';'; 1194 1195 return buf; 1196} 1197 1198void 1199new_thread_notify (int id) 1200{ 1201 char own_buf[256]; 1202 1203 /* The `n' response is not yet part of the remote protocol. Do nothing. */ 1204 if (1) 1205 return; 1206 1207 if (server_waiting == 0) 1208 return; 1209 1210 sprintf (own_buf, "n%x", id); 1211 disable_async_io (); 1212 putpkt (own_buf); 1213 enable_async_io (); 1214} 1215 1216void 1217dead_thread_notify (int id) 1218{ 1219 char own_buf[256]; 1220 1221 /* The `x' response is not yet part of the remote protocol. Do nothing. */ 1222 if (1) 1223 return; 1224 1225 sprintf (own_buf, "x%x", id); 1226 disable_async_io (); 1227 putpkt (own_buf); 1228 enable_async_io (); 1229} 1230 1231void 1232prepare_resume_reply (char *buf, ptid_t ptid, 1233 struct target_waitstatus *status) 1234{ 1235 if (debug_threads) 1236 fprintf (stderr, "Writing resume reply for %s:%d\n\n", 1237 target_pid_to_str (ptid), status->kind); 1238 1239 switch (status->kind) 1240 { 1241 case TARGET_WAITKIND_STOPPED: 1242 { 1243 struct thread_info *saved_inferior; 1244 const char **regp; 1245 struct regcache *regcache; 1246 1247 sprintf (buf, "T%02x", status->value.sig); 1248 buf += strlen (buf); 1249 1250 regp = gdbserver_expedite_regs; 1251 1252 saved_inferior = current_inferior; 1253 1254 current_inferior = find_thread_ptid (ptid); 1255 1256 regcache = get_thread_regcache (current_inferior, 1); 1257 1258 if (the_target->stopped_by_watchpoint != NULL 1259 && (*the_target->stopped_by_watchpoint) ()) 1260 { 1261 CORE_ADDR addr; 1262 int i; 1263 1264 strncpy (buf, "watch:", 6); 1265 buf += 6; 1266 1267 addr = (*the_target->stopped_data_address) (); 1268 1269 /* Convert each byte of the address into two hexadecimal 1270 chars. Note that we take sizeof (void *) instead of 1271 sizeof (addr); this is to avoid sending a 64-bit 1272 address to a 32-bit GDB. */ 1273 for (i = sizeof (void *) * 2; i > 0; i--) 1274 *buf++ = tohex ((addr >> (i - 1) * 4) & 0xf); 1275 *buf++ = ';'; 1276 } 1277 1278 while (*regp) 1279 { 1280 buf = outreg (regcache, find_regno (*regp), buf); 1281 regp ++; 1282 } 1283 *buf = '\0'; 1284 1285 /* Formerly, if the debugger had not used any thread features 1286 we would not burden it with a thread status response. This 1287 was for the benefit of GDB 4.13 and older. However, in 1288 recent GDB versions the check (``if (cont_thread != 0)'') 1289 does not have the desired effect because of sillyness in 1290 the way that the remote protocol handles specifying a 1291 thread. Since thread support relies on qSymbol support 1292 anyway, assume GDB can handle threads. */ 1293 1294 if (using_threads && !disable_packet_Tthread) 1295 { 1296 /* This if (1) ought to be unnecessary. But remote_wait 1297 in GDB will claim this event belongs to inferior_ptid 1298 if we do not specify a thread, and there's no way for 1299 gdbserver to know what inferior_ptid is. */ 1300 if (1 || !ptid_equal (general_thread, ptid)) 1301 { 1302 int core = -1; 1303 /* In non-stop, don't change the general thread behind 1304 GDB's back. */ 1305 if (!non_stop) 1306 general_thread = ptid; 1307 sprintf (buf, "thread:"); 1308 buf += strlen (buf); 1309 buf = write_ptid (buf, ptid); 1310 strcat (buf, ";"); 1311 buf += strlen (buf); 1312 1313 if (the_target->core_of_thread) 1314 core = (*the_target->core_of_thread) (ptid); 1315 if (core != -1) 1316 { 1317 sprintf (buf, "core:"); 1318 buf += strlen (buf); 1319 sprintf (buf, "%x", core); 1320 strcat (buf, ";"); 1321 buf += strlen (buf); 1322 } 1323 } 1324 } 1325 1326 if (dlls_changed) 1327 { 1328 strcpy (buf, "library:;"); 1329 buf += strlen (buf); 1330 dlls_changed = 0; 1331 } 1332 1333 current_inferior = saved_inferior; 1334 } 1335 break; 1336 case TARGET_WAITKIND_EXITED: 1337 if (multi_process) 1338 sprintf (buf, "W%x;process:%x", 1339 status->value.integer, ptid_get_pid (ptid)); 1340 else 1341 sprintf (buf, "W%02x", status->value.integer); 1342 break; 1343 case TARGET_WAITKIND_SIGNALLED: 1344 if (multi_process) 1345 sprintf (buf, "X%x;process:%x", 1346 status->value.sig, ptid_get_pid (ptid)); 1347 else 1348 sprintf (buf, "X%02x", status->value.sig); 1349 break; 1350 default: 1351 error ("unhandled waitkind"); 1352 break; 1353 } 1354} 1355 1356void 1357decode_m_packet (char *from, CORE_ADDR *mem_addr_ptr, unsigned int *len_ptr) 1358{ 1359 int i = 0, j = 0; 1360 char ch; 1361 *mem_addr_ptr = *len_ptr = 0; 1362 1363 while ((ch = from[i++]) != ',') 1364 { 1365 *mem_addr_ptr = *mem_addr_ptr << 4; 1366 *mem_addr_ptr |= fromhex (ch) & 0x0f; 1367 } 1368 1369 for (j = 0; j < 4; j++) 1370 { 1371 if ((ch = from[i++]) == 0) 1372 break; 1373 *len_ptr = *len_ptr << 4; 1374 *len_ptr |= fromhex (ch) & 0x0f; 1375 } 1376} 1377 1378void 1379decode_M_packet (char *from, CORE_ADDR *mem_addr_ptr, unsigned int *len_ptr, 1380 unsigned char **to_p) 1381{ 1382 int i = 0; 1383 char ch; 1384 *mem_addr_ptr = *len_ptr = 0; 1385 1386 while ((ch = from[i++]) != ',') 1387 { 1388 *mem_addr_ptr = *mem_addr_ptr << 4; 1389 *mem_addr_ptr |= fromhex (ch) & 0x0f; 1390 } 1391 1392 while ((ch = from[i++]) != ':') 1393 { 1394 *len_ptr = *len_ptr << 4; 1395 *len_ptr |= fromhex (ch) & 0x0f; 1396 } 1397 1398 if (*to_p == NULL) 1399 *to_p = xmalloc (*len_ptr); 1400 1401 convert_ascii_to_int (&from[i++], *to_p, *len_ptr); 1402} 1403 1404int 1405decode_X_packet (char *from, int packet_len, CORE_ADDR *mem_addr_ptr, 1406 unsigned int *len_ptr, unsigned char **to_p) 1407{ 1408 int i = 0; 1409 char ch; 1410 *mem_addr_ptr = *len_ptr = 0; 1411 1412 while ((ch = from[i++]) != ',') 1413 { 1414 *mem_addr_ptr = *mem_addr_ptr << 4; 1415 *mem_addr_ptr |= fromhex (ch) & 0x0f; 1416 } 1417 1418 while ((ch = from[i++]) != ':') 1419 { 1420 *len_ptr = *len_ptr << 4; 1421 *len_ptr |= fromhex (ch) & 0x0f; 1422 } 1423 1424 if (*to_p == NULL) 1425 *to_p = xmalloc (*len_ptr); 1426 1427 if (remote_unescape_input ((const gdb_byte *) &from[i], packet_len - i, 1428 *to_p, *len_ptr) != *len_ptr) 1429 return -1; 1430 1431 return 0; 1432} 1433 1434/* Decode a qXfer write request. */ 1435 1436int 1437decode_xfer_write (char *buf, int packet_len, CORE_ADDR *offset, 1438 unsigned int *len, unsigned char *data) 1439{ 1440 char ch; 1441 char *b = buf; 1442 1443 /* Extract the offset. */ 1444 *offset = 0; 1445 while ((ch = *buf++) != ':') 1446 { 1447 *offset = *offset << 4; 1448 *offset |= fromhex (ch) & 0x0f; 1449 } 1450 1451 /* Get encoded data. */ 1452 packet_len -= buf - b; 1453 *len = remote_unescape_input ((const gdb_byte *) buf, packet_len, 1454 data, packet_len); 1455 return 0; 1456} 1457 1458/* Decode the parameters of a qSearch:memory packet. */ 1459 1460int 1461decode_search_memory_packet (const char *buf, int packet_len, 1462 CORE_ADDR *start_addrp, 1463 CORE_ADDR *search_space_lenp, 1464 gdb_byte *pattern, unsigned int *pattern_lenp) 1465{ 1466 const char *p = buf; 1467 1468 p = decode_address_to_semicolon (start_addrp, p); 1469 p = decode_address_to_semicolon (search_space_lenp, p); 1470 packet_len -= p - buf; 1471 *pattern_lenp = remote_unescape_input ((const gdb_byte *) p, packet_len, 1472 pattern, packet_len); 1473 return 0; 1474} 1475 1476static void 1477free_sym_cache (struct sym_cache *sym) 1478{ 1479 if (sym != NULL) 1480 { 1481 free (sym->name); 1482 free (sym); 1483 } 1484} 1485 1486void 1487clear_symbol_cache (struct sym_cache **symcache_p) 1488{ 1489 struct sym_cache *sym, *next; 1490 1491 /* Check the cache first. */ 1492 for (sym = *symcache_p; sym; sym = next) 1493 { 1494 next = sym->next; 1495 free_sym_cache (sym); 1496 } 1497 1498 *symcache_p = NULL; 1499} 1500 1501/* Get the address of NAME, and return it in ADDRP if found. if 1502 MAY_ASK_GDB is false, assume symbol cache misses are failures. 1503 Returns 1 if the symbol is found, 0 if it is not, -1 on error. */ 1504 1505int 1506look_up_one_symbol (const char *name, CORE_ADDR *addrp, int may_ask_gdb) 1507{ 1508 char own_buf[266], *p, *q; 1509 int len; 1510 struct sym_cache *sym; 1511 struct process_info *proc; 1512 1513 proc = current_process (); 1514 1515 /* Check the cache first. */ 1516 for (sym = proc->symbol_cache; sym; sym = sym->next) 1517 if (strcmp (name, sym->name) == 0) 1518 { 1519 *addrp = sym->addr; 1520 return 1; 1521 } 1522 1523 /* It might not be an appropriate time to look up a symbol, 1524 e.g. while we're trying to fetch registers. */ 1525 if (!may_ask_gdb) 1526 return 0; 1527 1528 /* Send the request. */ 1529 strcpy (own_buf, "qSymbol:"); 1530 hexify (own_buf + strlen ("qSymbol:"), name, strlen (name)); 1531 if (putpkt (own_buf) < 0) 1532 return -1; 1533 1534 /* FIXME: Eventually add buffer overflow checking (to getpkt?) */ 1535 len = getpkt (own_buf); 1536 if (len < 0) 1537 return -1; 1538 1539 /* We ought to handle pretty much any packet at this point while we 1540 wait for the qSymbol "response". That requires re-entering the 1541 main loop. For now, this is an adequate approximation; allow 1542 GDB to read from memory while it figures out the address of the 1543 symbol. */ 1544 while (own_buf[0] == 'm') 1545 { 1546 CORE_ADDR mem_addr; 1547 unsigned char *mem_buf; 1548 unsigned int mem_len; 1549 1550 decode_m_packet (&own_buf[1], &mem_addr, &mem_len); 1551 mem_buf = xmalloc (mem_len); 1552 if (read_inferior_memory (mem_addr, mem_buf, mem_len) == 0) 1553 convert_int_to_ascii (mem_buf, own_buf, mem_len); 1554 else 1555 write_enn (own_buf); 1556 free (mem_buf); 1557 if (putpkt (own_buf) < 0) 1558 return -1; 1559 len = getpkt (own_buf); 1560 if (len < 0) 1561 return -1; 1562 } 1563 1564 if (strncmp (own_buf, "qSymbol:", strlen ("qSymbol:")) != 0) 1565 { 1566 warning ("Malformed response to qSymbol, ignoring: %s\n", own_buf); 1567 return -1; 1568 } 1569 1570 p = own_buf + strlen ("qSymbol:"); 1571 q = p; 1572 while (*q && *q != ':') 1573 q++; 1574 1575 /* Make sure we found a value for the symbol. */ 1576 if (p == q || *q == '\0') 1577 return 0; 1578 1579 decode_address (addrp, p, q - p); 1580 1581 /* Save the symbol in our cache. */ 1582 sym = xmalloc (sizeof (*sym)); 1583 sym->name = xstrdup (name); 1584 sym->addr = *addrp; 1585 sym->next = proc->symbol_cache; 1586 proc->symbol_cache = sym; 1587 1588 return 1; 1589} 1590 1591/* Relocate an instruction to execute at a different address. OLDLOC 1592 is the address in the inferior memory where the instruction to 1593 relocate is currently at. On input, TO points to the destination 1594 where we want the instruction to be copied (and possibly adjusted) 1595 to. On output, it points to one past the end of the resulting 1596 instruction(s). The effect of executing the instruction at TO 1597 shall be the same as if executing it at FROM. For example, call 1598 instructions that implicitly push the return address on the stack 1599 should be adjusted to return to the instruction after OLDLOC; 1600 relative branches, and other PC-relative instructions need the 1601 offset adjusted; etc. Returns 0 on success, -1 on failure. */ 1602 1603int 1604relocate_instruction (CORE_ADDR *to, CORE_ADDR oldloc) 1605{ 1606 char own_buf[266]; 1607 int len; 1608 ULONGEST written = 0; 1609 1610 /* Send the request. */ 1611 strcpy (own_buf, "qRelocInsn:"); 1612 sprintf (own_buf, "qRelocInsn:%s;%s", paddress (oldloc), 1613 paddress (*to)); 1614 if (putpkt (own_buf) < 0) 1615 return -1; 1616 1617 /* FIXME: Eventually add buffer overflow checking (to getpkt?) */ 1618 len = getpkt (own_buf); 1619 if (len < 0) 1620 return -1; 1621 1622 /* We ought to handle pretty much any packet at this point while we 1623 wait for the qRelocInsn "response". That requires re-entering 1624 the main loop. For now, this is an adequate approximation; allow 1625 GDB to access memory. */ 1626 while (own_buf[0] == 'm' || own_buf[0] == 'M' || own_buf[0] == 'X') 1627 { 1628 CORE_ADDR mem_addr; 1629 unsigned char *mem_buf = NULL; 1630 unsigned int mem_len; 1631 1632 if (own_buf[0] == 'm') 1633 { 1634 decode_m_packet (&own_buf[1], &mem_addr, &mem_len); 1635 mem_buf = xmalloc (mem_len); 1636 if (read_inferior_memory (mem_addr, mem_buf, mem_len) == 0) 1637 convert_int_to_ascii (mem_buf, own_buf, mem_len); 1638 else 1639 write_enn (own_buf); 1640 } 1641 else if (own_buf[0] == 'X') 1642 { 1643 if (decode_X_packet (&own_buf[1], len - 1, &mem_addr, 1644 &mem_len, &mem_buf) < 0 1645 || write_inferior_memory (mem_addr, mem_buf, mem_len) != 0) 1646 write_enn (own_buf); 1647 else 1648 write_ok (own_buf); 1649 } 1650 else 1651 { 1652 decode_M_packet (&own_buf[1], &mem_addr, &mem_len, &mem_buf); 1653 if (write_inferior_memory (mem_addr, mem_buf, mem_len) == 0) 1654 write_ok (own_buf); 1655 else 1656 write_enn (own_buf); 1657 } 1658 free (mem_buf); 1659 if (putpkt (own_buf) < 0) 1660 return -1; 1661 len = getpkt (own_buf); 1662 if (len < 0) 1663 return -1; 1664 } 1665 1666 if (own_buf[0] == 'E') 1667 { 1668 warning ("An error occurred while relocating an instruction: %s\n", 1669 own_buf); 1670 return -1; 1671 } 1672 1673 if (strncmp (own_buf, "qRelocInsn:", strlen ("qRelocInsn:")) != 0) 1674 { 1675 warning ("Malformed response to qRelocInsn, ignoring: %s\n", 1676 own_buf); 1677 return -1; 1678 } 1679 1680 unpack_varlen_hex (own_buf + strlen ("qRelocInsn:"), &written); 1681 1682 *to += written; 1683 return 0; 1684} 1685 1686void 1687monitor_output (const char *msg) 1688{ 1689 char *buf = xmalloc (strlen (msg) * 2 + 2); 1690 1691 buf[0] = 'O'; 1692 hexify (buf + 1, msg, 0); 1693 1694 putpkt (buf); 1695 free (buf); 1696} 1697 1698/* Return a malloc allocated string with special characters from TEXT 1699 replaced by entity references. */ 1700 1701char * 1702xml_escape_text (const char *text) 1703{ 1704 char *result; 1705 int i, special; 1706 1707 /* Compute the length of the result. */ 1708 for (i = 0, special = 0; text[i] != '\0'; i++) 1709 switch (text[i]) 1710 { 1711 case '\'': 1712 case '\"': 1713 special += 5; 1714 break; 1715 case '&': 1716 special += 4; 1717 break; 1718 case '<': 1719 case '>': 1720 special += 3; 1721 break; 1722 default: 1723 break; 1724 } 1725 1726 /* Expand the result. */ 1727 result = xmalloc (i + special + 1); 1728 for (i = 0, special = 0; text[i] != '\0'; i++) 1729 switch (text[i]) 1730 { 1731 case '\'': 1732 strcpy (result + i + special, "'"); 1733 special += 5; 1734 break; 1735 case '\"': 1736 strcpy (result + i + special, """); 1737 special += 5; 1738 break; 1739 case '&': 1740 strcpy (result + i + special, "&"); 1741 special += 4; 1742 break; 1743 case '<': 1744 strcpy (result + i + special, "<"); 1745 special += 3; 1746 break; 1747 case '>': 1748 strcpy (result + i + special, ">"); 1749 special += 3; 1750 break; 1751 default: 1752 result[i + special] = text[i]; 1753 break; 1754 } 1755 result[i + special] = '\0'; 1756 1757 return result; 1758} 1759 1760void 1761buffer_grow (struct buffer *buffer, const char *data, size_t size) 1762{ 1763 char *new_buffer; 1764 size_t new_buffer_size; 1765 1766 if (size == 0) 1767 return; 1768 1769 new_buffer_size = buffer->buffer_size; 1770 1771 if (new_buffer_size == 0) 1772 new_buffer_size = 1; 1773 1774 while (buffer->used_size + size > new_buffer_size) 1775 new_buffer_size *= 2; 1776 new_buffer = realloc (buffer->buffer, new_buffer_size); 1777 if (!new_buffer) 1778 abort (); 1779 memcpy (new_buffer + buffer->used_size, data, size); 1780 buffer->buffer = new_buffer; 1781 buffer->buffer_size = new_buffer_size; 1782 buffer->used_size += size; 1783} 1784 1785void 1786buffer_free (struct buffer *buffer) 1787{ 1788 if (!buffer) 1789 return; 1790 1791 free (buffer->buffer); 1792 buffer->buffer = NULL; 1793 buffer->buffer_size = 0; 1794 buffer->used_size = 0; 1795} 1796 1797void 1798buffer_init (struct buffer *buffer) 1799{ 1800 memset (buffer, 0, sizeof (*buffer)); 1801} 1802 1803char* 1804buffer_finish (struct buffer *buffer) 1805{ 1806 char *ret = buffer->buffer; 1807 buffer->buffer = NULL; 1808 buffer->buffer_size = 0; 1809 buffer->used_size = 0; 1810 return ret; 1811} 1812 1813void 1814buffer_xml_printf (struct buffer *buffer, const char *format, ...) 1815{ 1816 va_list ap; 1817 const char *f; 1818 const char *prev; 1819 int percent = 0; 1820 1821 va_start (ap, format); 1822 1823 prev = format; 1824 for (f = format; *f; f++) 1825 { 1826 if (percent) 1827 { 1828 switch (*f) 1829 { 1830 case 's': 1831 { 1832 char *p; 1833 char *a = va_arg (ap, char *); 1834 buffer_grow (buffer, prev, f - prev - 1); 1835 p = xml_escape_text (a); 1836 buffer_grow_str (buffer, p); 1837 free (p); 1838 prev = f + 1; 1839 } 1840 break; 1841 case 'd': 1842 { 1843 int i = va_arg (ap, int); 1844 char b[sizeof ("4294967295")]; 1845 1846 buffer_grow (buffer, prev, f - prev - 1); 1847 sprintf (b, "%d", i); 1848 buffer_grow_str (buffer, b); 1849 prev = f + 1; 1850 } 1851 } 1852 percent = 0; 1853 } 1854 else if (*f == '%') 1855 percent = 1; 1856 } 1857 1858 buffer_grow_str (buffer, prev); 1859 va_end (ap); 1860} 1861 1862#endif 1863