1 /* Remote utility routines for the remote server for GDB.
2 Copyright (C) 1986, 1989, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
4 Free Software Foundation, Inc.
6 This file is part of GDB.
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 3 of the License, or
11 (at your option) any later version.
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.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
27 #include <sys/ioctl.h>
33 #include <netinet/in.h>
36 #include <sys/socket.h>
41 #if HAVE_NETINET_TCP_H
42 #include <netinet/tcp.h>
45 #include <sys/ioctl.h>
58 #include <arpa/inet.h>
69 #ifndef HAVE_SOCKLEN_T
70 typedef int socklen_t
;
74 # define INVALID_DESCRIPTOR INVALID_SOCKET
76 # define INVALID_DESCRIPTOR -1
79 /* A cache entry for a successfully looked-up symbol. */
84 struct sym_cache
*next
;
87 /* The symbol cache. */
88 static struct sym_cache
*symbol_cache
;
90 /* If this flag has been set, assume cache misses are
92 int all_symbols_looked_up
;
95 struct ui_file
*gdb_stdlog
;
97 static int remote_desc
= INVALID_DESCRIPTOR
;
99 /* FIXME headerize? */
100 extern int using_threads
;
101 extern int debug_threads
;
103 /* If true, then GDB has requested noack mode. */
105 /* If true, then we tell GDB to use noack mode by default. */
106 int transport_is_reliable
= 0;
109 # define read(fd, buf, len) recv (fd, (char *) buf, len, 0)
110 # define write(fd, buf, len) send (fd, (char *) buf, len, 0)
113 /* Open a connection to a remote debugger.
114 NAME is the filename used for communication. */
117 remote_open (char *name
)
119 #if defined(F_SETFL) && defined (FASYNC)
120 int save_fcntl_flags
;
124 port_str
= strchr (name
, ':');
125 if (port_str
== NULL
)
128 error ("Only <host>:<port> is supported on this platform.");
132 if (stat (name
, &statbuf
) == 0
133 && (S_ISCHR (statbuf
.st_mode
) || S_ISFIFO (statbuf
.st_mode
)))
134 remote_desc
= open (name
, O_RDWR
);
142 perror_with_name ("Could not open remote device");
146 struct termios termios
;
147 tcgetattr (remote_desc
, &termios
);
152 termios
.c_cflag
&= ~(CSIZE
| PARENB
);
153 termios
.c_cflag
|= CLOCAL
| CS8
;
154 termios
.c_cc
[VMIN
] = 1;
155 termios
.c_cc
[VTIME
] = 0;
157 tcsetattr (remote_desc
, TCSANOW
, &termios
);
163 struct termio termio
;
164 ioctl (remote_desc
, TCGETA
, &termio
);
169 termio
.c_cflag
&= ~(CSIZE
| PARENB
);
170 termio
.c_cflag
|= CLOCAL
| CS8
;
171 termio
.c_cc
[VMIN
] = 1;
172 termio
.c_cc
[VTIME
] = 0;
174 ioctl (remote_desc
, TCSETA
, &termio
);
182 ioctl (remote_desc
, TIOCGETP
, &sg
);
184 ioctl (remote_desc
, TIOCSETP
, &sg
);
188 fprintf (stderr
, "Remote debugging using %s\n", name
);
189 #endif /* USE_WIN32API */
191 transport_is_reliable
= 0;
196 static int winsock_initialized
;
199 struct sockaddr_in sockaddr
;
204 port
= strtoul (port_str
+ 1, &port_end
, 10);
205 if (port_str
[1] == '\0' || *port_end
!= '\0')
206 fatal ("Bad port argument: %s", name
);
209 if (!winsock_initialized
)
213 WSAStartup (MAKEWORD (1, 0), &wsad
);
214 winsock_initialized
= 1;
218 tmp_desc
= socket (PF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
220 perror_with_name ("Can't open socket");
222 /* Allow rapid reuse of this port. */
224 setsockopt (tmp_desc
, SOL_SOCKET
, SO_REUSEADDR
, (char *) &tmp
,
227 sockaddr
.sin_family
= PF_INET
;
228 sockaddr
.sin_port
= htons (port
);
229 sockaddr
.sin_addr
.s_addr
= INADDR_ANY
;
231 if (bind (tmp_desc
, (struct sockaddr
*) &sockaddr
, sizeof (sockaddr
))
232 || listen (tmp_desc
, 1))
233 perror_with_name ("Can't bind address");
235 /* If port is zero, a random port will be selected, and the
236 fprintf below needs to know what port was selected. */
239 socklen_t len
= sizeof (sockaddr
);
240 if (getsockname (tmp_desc
, (struct sockaddr
*) &sockaddr
, &len
) < 0
241 || len
< sizeof (sockaddr
))
242 perror_with_name ("Can't determine port");
243 port
= ntohs (sockaddr
.sin_port
);
246 fprintf (stderr
, "Listening on port %d\n", port
);
249 tmp
= sizeof (sockaddr
);
250 remote_desc
= accept (tmp_desc
, (struct sockaddr
*) &sockaddr
, &tmp
);
251 if (remote_desc
== -1)
252 perror_with_name ("Accept failed");
254 /* Enable TCP keep alive process. */
256 setsockopt (remote_desc
, SOL_SOCKET
, SO_KEEPALIVE
,
257 (char *) &tmp
, sizeof (tmp
));
259 /* Tell TCP not to delay small packets. This greatly speeds up
260 interactive response. */
262 setsockopt (remote_desc
, IPPROTO_TCP
, TCP_NODELAY
,
263 (char *) &tmp
, sizeof (tmp
));
267 close (tmp_desc
); /* No longer need this */
269 signal (SIGPIPE
, SIG_IGN
); /* If we don't do this, then gdbserver simply
270 exits when the remote side dies. */
272 closesocket (tmp_desc
); /* No longer need this */
275 /* Convert IP address to string. */
276 fprintf (stderr
, "Remote debugging from host %s\n",
277 inet_ntoa (sockaddr
.sin_addr
));
279 transport_is_reliable
= 1;
282 #if defined(F_SETFL) && defined (FASYNC)
283 save_fcntl_flags
= fcntl (remote_desc
, F_GETFL
, 0);
284 fcntl (remote_desc
, F_SETFL
, save_fcntl_flags
| FASYNC
);
285 #if defined (F_SETOWN)
286 fcntl (remote_desc
, F_SETOWN
, getpid ());
295 closesocket (remote_desc
);
301 /* Convert hex digit A to a number. */
306 if (a
>= '0' && a
<= '9')
308 else if (a
>= 'a' && a
<= 'f')
311 error ("Reply contains invalid hex digit");
316 unhexify (char *bin
, const char *hex
, int count
)
320 for (i
= 0; i
< count
; i
++)
322 if (hex
[0] == 0 || hex
[1] == 0)
324 /* Hex string is short, or of uneven length.
325 Return the count that has been converted so far. */
328 *bin
++ = fromhex (hex
[0]) * 16 + fromhex (hex
[1]);
335 decode_address (CORE_ADDR
*addrp
, const char *start
, int len
)
342 for (i
= 0; i
< len
; i
++)
346 addr
= addr
| (fromhex (ch
) & 0x0f);
352 decode_address_to_semicolon (CORE_ADDR
*addrp
, const char *start
)
357 while (*end
!= '\0' && *end
!= ';')
360 decode_address (addrp
, start
, end
- start
);
367 /* Convert number NIB to a hex digit. */
375 return 'a' + nib
- 10;
379 hexify (char *hex
, const char *bin
, int count
)
383 /* May use a length, or a nul-terminated string as input. */
385 count
= strlen (bin
);
387 for (i
= 0; i
< count
; i
++)
389 *hex
++ = tohex ((*bin
>> 4) & 0xf);
390 *hex
++ = tohex (*bin
++ & 0xf);
396 /* Convert BUFFER, binary data at least LEN bytes long, into escaped
397 binary data in OUT_BUF. Set *OUT_LEN to the length of the data
398 encoded in OUT_BUF, and return the number of bytes in OUT_BUF
399 (which may be more than *OUT_LEN due to escape characters). The
400 total number of bytes in the output buffer will be at most
404 remote_escape_output (const gdb_byte
*buffer
, int len
,
405 gdb_byte
*out_buf
, int *out_len
,
408 int input_index
, output_index
;
411 for (input_index
= 0; input_index
< len
; input_index
++)
413 gdb_byte b
= buffer
[input_index
];
415 if (b
== '$' || b
== '#' || b
== '}' || b
== '*')
417 /* These must be escaped. */
418 if (output_index
+ 2 > out_maxlen
)
420 out_buf
[output_index
++] = '}';
421 out_buf
[output_index
++] = b
^ 0x20;
425 if (output_index
+ 1 > out_maxlen
)
427 out_buf
[output_index
++] = b
;
431 *out_len
= input_index
;
435 /* Convert BUFFER, escaped data LEN bytes long, into binary data
436 in OUT_BUF. Return the number of bytes written to OUT_BUF.
437 Raise an error if the total number of bytes exceeds OUT_MAXLEN.
439 This function reverses remote_escape_output. It allows more
440 escaped characters than that function does, in particular because
441 '*' must be escaped to avoid the run-length encoding processing
442 in reading packets. */
445 remote_unescape_input (const gdb_byte
*buffer
, int len
,
446 gdb_byte
*out_buf
, int out_maxlen
)
448 int input_index
, output_index
;
453 for (input_index
= 0; input_index
< len
; input_index
++)
455 gdb_byte b
= buffer
[input_index
];
457 if (output_index
+ 1 > out_maxlen
)
458 error ("Received too much data from the target.");
462 out_buf
[output_index
++] = b
^ 0x20;
468 out_buf
[output_index
++] = b
;
472 error ("Unmatched escape character in target response.");
477 /* Look for a sequence of characters which can be run-length encoded.
478 If there are any, update *CSUM and *P. Otherwise, output the
479 single character. Return the number of characters consumed. */
482 try_rle (char *buf
, int remaining
, unsigned char *csum
, char **p
)
486 /* Always output the character. */
490 /* Don't go past '~'. */
494 for (n
= 1; n
< remaining
; n
++)
495 if (buf
[n
] != buf
[0])
498 /* N is the index of the first character not the same as buf[0].
499 buf[0] is counted twice, so by decrementing N, we get the number
500 of characters the RLE sequence will replace. */
506 /* Skip the frame characters. The manual says to skip '+' and '-'
507 also, but there's no reason to. Unfortunately these two unusable
508 characters double the encoded length of a four byte zero
510 while (n
+ 29 == '$' || n
+ 29 == '#')
521 /* Send a packet to the remote machine, with error checking.
522 The data of the packet is in BUF, and the length of the
523 packet is in CNT. Returns >= 0 on success, -1 otherwise. */
526 putpkt_binary (char *buf
, int cnt
)
529 unsigned char csum
= 0;
534 buf2
= xmalloc (PBUFSIZ
);
536 /* Copy the packet into buffer BUF2, encapsulating it
537 and giving it a checksum. */
542 for (i
= 0; i
< cnt
;)
543 i
+= try_rle (buf
+ i
, cnt
- i
, &csum
, &p
);
546 *p
++ = tohex ((csum
>> 4) & 0xf);
547 *p
++ = tohex (csum
& 0xf);
551 /* Send it over and over until we get a positive ack. */
557 if (write (remote_desc
, buf2
, p
- buf2
) != p
- buf2
)
559 perror ("putpkt(write)");
566 /* Don't expect an ack then. */
569 fprintf (stderr
, "putpkt (\"%s\"); [noack mode]\n", buf2
);
577 fprintf (stderr
, "putpkt (\"%s\"); [looking for ack]\n", buf2
);
580 cc
= read (remote_desc
, buf3
, 1);
583 fprintf (stderr
, "[received '%c' (0x%x)]\n", buf3
[0], buf3
[0]);
590 fprintf (stderr
, "putpkt(read): Got EOF\n");
592 perror ("putpkt(read)");
598 /* Check for an input interrupt while we're here. */
599 if (buf3
[0] == '\003' && current_inferior
!= NULL
)
600 (*the_target
->request_interrupt
) ();
602 while (buf3
[0] != '+');
605 return 1; /* Success! */
608 /* Send a packet to the remote machine, with error checking. The data
609 of the packet is in BUF, and the packet should be a NUL-terminated
610 string. Returns >= 0 on success, -1 otherwise. */
615 return putpkt_binary (buf
, strlen (buf
));
618 /* Come here when we get an input interrupt from the remote side. This
619 interrupt should only be active while we are waiting for the child to do
620 something. About the only thing that should come through is a ^C, which
621 will cause us to request child interruption. */
624 input_interrupt (int unused
)
627 struct timeval immediate
= { 0, 0 };
629 /* Protect against spurious interrupts. This has been observed to
630 be a problem under NetBSD 1.4 and 1.5. */
633 FD_SET (remote_desc
, &readset
);
634 if (select (remote_desc
+ 1, &readset
, 0, 0, &immediate
) > 0)
639 cc
= read (remote_desc
, &c
, 1);
641 if (cc
!= 1 || c
!= '\003' || current_inferior
== NULL
)
643 fprintf (stderr
, "input_interrupt, count = %d c = %d ('%c')\n",
648 (*the_target
->request_interrupt
) ();
652 /* Check if the remote side sent us an interrupt request (^C). */
654 check_remote_input_interrupt_request (void)
656 /* This function may be called before establishing communications,
657 therefore we need to validate the remote descriptor. */
659 if (remote_desc
== INVALID_DESCRIPTOR
)
665 /* Asynchronous I/O support. SIGIO must be enabled when waiting, in order to
666 accept Control-C from the client, and must be disabled when talking to
670 unblock_async_io (void)
675 sigemptyset (&sigio_set
);
676 sigaddset (&sigio_set
, SIGIO
);
677 sigprocmask (SIG_UNBLOCK
, &sigio_set
, NULL
);
681 /* Current state of asynchronous I/O. */
682 static int async_io_enabled
;
684 /* Enable asynchronous I/O. */
686 enable_async_io (void)
688 if (async_io_enabled
)
692 signal (SIGIO
, input_interrupt
);
694 async_io_enabled
= 1;
697 /* Disable asynchronous I/O. */
699 disable_async_io (void)
701 if (!async_io_enabled
)
705 signal (SIGIO
, SIG_IGN
);
707 async_io_enabled
= 0;
711 initialize_async_io (void)
713 /* Make sure that async I/O starts disabled. */
714 async_io_enabled
= 1;
717 /* Make sure the signal is unblocked. */
721 /* Returns next char from remote GDB. -1 if error. */
726 static unsigned char buf
[BUFSIZ
];
727 static int bufcnt
= 0;
728 static unsigned char *bufp
;
733 bufcnt
= read (remote_desc
, buf
, sizeof (buf
));
738 fprintf (stderr
, "readchar: Got EOF\n");
750 /* Read a packet from the remote machine, with error checking,
751 and store it in BUF. Returns length of packet, or negative if error. */
757 unsigned char csum
, c1
, c2
;
771 fprintf (stderr
, "[getpkt: discarding char '%c']\n", c
);
792 c1
= fromhex (readchar ());
793 c2
= fromhex (readchar ());
795 if (csum
== (c1
<< 4) + c2
)
800 fprintf (stderr
, "Bad checksum, sentsum=0x%x, csum=0x%x, buf=%s [no-ack-mode, Bad medium?]\n",
801 (c1
<< 4) + c2
, csum
, buf
);
802 /* Not much we can do, GDB wasn't expecting an ack/nac. */
806 fprintf (stderr
, "Bad checksum, sentsum=0x%x, csum=0x%x, buf=%s\n",
807 (c1
<< 4) + c2
, csum
, buf
);
808 write (remote_desc
, "-", 1);
815 fprintf (stderr
, "getpkt (\"%s\"); [sending ack] \n", buf
);
819 write (remote_desc
, "+", 1);
823 fprintf (stderr
, "[sent ack]\n");
831 fprintf (stderr
, "getpkt (\"%s\"); [no ack sent] \n", buf
);
848 write_enn (char *buf
)
850 /* Some day, we should define the meanings of the error codes... */
858 convert_int_to_ascii (unsigned char *from
, char *to
, int n
)
865 nib
= ((ch
& 0xf0) >> 4) & 0x0f;
875 convert_ascii_to_int (char *from
, unsigned char *to
, int n
)
880 nib1
= fromhex (*from
++);
881 nib2
= fromhex (*from
++);
882 *to
++ = (((nib1
& 0x0f) << 4) & 0xf0) | (nib2
& 0x0f);
887 outreg (int regno
, char *buf
)
889 if ((regno
>> 12) != 0)
890 *buf
++ = tohex ((regno
>> 12) & 0xf);
891 if ((regno
>> 8) != 0)
892 *buf
++ = tohex ((regno
>> 8) & 0xf);
893 *buf
++ = tohex ((regno
>> 4) & 0xf);
894 *buf
++ = tohex (regno
& 0xf);
896 collect_register_as_string (regno
, buf
);
897 buf
+= 2 * register_size (regno
);
904 new_thread_notify (int id
)
908 /* The `n' response is not yet part of the remote protocol. Do nothing. */
912 if (server_waiting
== 0)
915 sprintf (own_buf
, "n%x", id
);
922 dead_thread_notify (int id
)
926 /* The `x' response is not yet part of the remote protocol. Do nothing. */
930 sprintf (own_buf
, "x%x", id
);
937 prepare_resume_reply (char *buf
, unsigned long ptid
,
938 struct target_waitstatus
*status
)
941 fprintf (stderr
, "Writing resume reply for %lu:%d\n\n",
944 switch (status
->kind
)
946 case TARGET_WAITKIND_STOPPED
:
948 struct thread_info
*saved_inferior
;
951 sprintf (buf
, "T%02x", status
->value
.sig
);
954 regp
= gdbserver_expedite_regs
;
956 saved_inferior
= current_inferior
;
958 current_inferior
= gdb_id_to_thread (ptid
);
960 if (the_target
->stopped_by_watchpoint
!= NULL
961 && (*the_target
->stopped_by_watchpoint
) ())
966 strncpy (buf
, "watch:", 6);
969 addr
= (*the_target
->stopped_data_address
) ();
971 /* Convert each byte of the address into two hexadecimal
972 chars. Note that we take sizeof (void *) instead of
973 sizeof (addr); this is to avoid sending a 64-bit
974 address to a 32-bit GDB. */
975 for (i
= sizeof (void *) * 2; i
> 0; i
--)
976 *buf
++ = tohex ((addr
>> (i
- 1) * 4) & 0xf);
982 buf
= outreg (find_regno (*regp
), buf
);
986 /* Formerly, if the debugger had not used any thread features
987 we would not burden it with a thread status response. This
988 was for the benefit of GDB 4.13 and older. However, in
989 recent GDB versions the check (``if (cont_thread != 0)'')
990 does not have the desired effect because of sillyness in
991 the way that the remote protocol handles specifying a
992 thread. Since thread support relies on qSymbol support
993 anyway, assume GDB can handle threads. */
995 if (using_threads
&& !disable_packet_Tthread
)
997 /* This if (1) ought to be unnecessary. But remote_wait
998 in GDB will claim this event belongs to inferior_ptid
999 if we do not specify a thread, and there's no way for
1000 gdbserver to know what inferior_ptid is. */
1001 if (1 || general_thread
!= ptid
)
1003 general_thread
= ptid
;
1004 sprintf (buf
, "thread:%lx;", ptid
);
1005 buf
+= strlen (buf
);
1011 strcpy (buf
, "library:;");
1012 buf
+= strlen (buf
);
1016 current_inferior
= saved_inferior
;
1019 case TARGET_WAITKIND_EXITED
:
1020 sprintf (buf
, "W%02x", status
->value
.integer
);
1022 case TARGET_WAITKIND_SIGNALLED
:
1023 sprintf (buf
, "X%02x", status
->value
.sig
);
1026 error ("unhandled waitkind");
1032 decode_m_packet (char *from
, CORE_ADDR
*mem_addr_ptr
, unsigned int *len_ptr
)
1036 *mem_addr_ptr
= *len_ptr
= 0;
1038 while ((ch
= from
[i
++]) != ',')
1040 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
1041 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
1044 for (j
= 0; j
< 4; j
++)
1046 if ((ch
= from
[i
++]) == 0)
1048 *len_ptr
= *len_ptr
<< 4;
1049 *len_ptr
|= fromhex (ch
) & 0x0f;
1054 decode_M_packet (char *from
, CORE_ADDR
*mem_addr_ptr
, unsigned int *len_ptr
,
1059 *mem_addr_ptr
= *len_ptr
= 0;
1061 while ((ch
= from
[i
++]) != ',')
1063 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
1064 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
1067 while ((ch
= from
[i
++]) != ':')
1069 *len_ptr
= *len_ptr
<< 4;
1070 *len_ptr
|= fromhex (ch
) & 0x0f;
1073 convert_ascii_to_int (&from
[i
++], to
, *len_ptr
);
1077 decode_X_packet (char *from
, int packet_len
, CORE_ADDR
*mem_addr_ptr
,
1078 unsigned int *len_ptr
, unsigned char *to
)
1082 *mem_addr_ptr
= *len_ptr
= 0;
1084 while ((ch
= from
[i
++]) != ',')
1086 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
1087 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
1090 while ((ch
= from
[i
++]) != ':')
1092 *len_ptr
= *len_ptr
<< 4;
1093 *len_ptr
|= fromhex (ch
) & 0x0f;
1096 if (remote_unescape_input ((const gdb_byte
*) &from
[i
], packet_len
- i
,
1097 to
, *len_ptr
) != *len_ptr
)
1103 /* Decode a qXfer write request. */
1105 decode_xfer_write (char *buf
, int packet_len
, char **annex
, CORE_ADDR
*offset
,
1106 unsigned int *len
, unsigned char *data
)
1110 /* Extract and NUL-terminate the annex. */
1112 while (*buf
&& *buf
!= ':')
1118 /* Extract the offset. */
1120 while ((ch
= *buf
++) != ':')
1122 *offset
= *offset
<< 4;
1123 *offset
|= fromhex (ch
) & 0x0f;
1126 /* Get encoded data. */
1127 packet_len
-= buf
- *annex
;
1128 *len
= remote_unescape_input ((const gdb_byte
*) buf
, packet_len
,
1133 /* Decode the parameters of a qSearch:memory packet. */
1136 decode_search_memory_packet (const char *buf
, int packet_len
,
1137 CORE_ADDR
*start_addrp
,
1138 CORE_ADDR
*search_space_lenp
,
1139 gdb_byte
*pattern
, unsigned int *pattern_lenp
)
1141 const char *p
= buf
;
1143 p
= decode_address_to_semicolon (start_addrp
, p
);
1144 p
= decode_address_to_semicolon (search_space_lenp
, p
);
1145 packet_len
-= p
- buf
;
1146 *pattern_lenp
= remote_unescape_input ((const gdb_byte
*) p
, packet_len
,
1147 pattern
, packet_len
);
1151 /* Ask GDB for the address of NAME, and return it in ADDRP if found.
1152 Returns 1 if the symbol is found, 0 if it is not, -1 on error. */
1155 look_up_one_symbol (const char *name
, CORE_ADDR
*addrp
)
1157 char own_buf
[266], *p
, *q
;
1159 struct sym_cache
*sym
;
1161 /* Check the cache first. */
1162 for (sym
= symbol_cache
; sym
; sym
= sym
->next
)
1163 if (strcmp (name
, sym
->name
) == 0)
1169 /* If we've passed the call to thread_db_look_up_symbols, then
1170 anything not in the cache must not exist; we're not interested
1171 in any libraries loaded after that point, only in symbols in
1172 libpthread.so. It might not be an appropriate time to look
1173 up a symbol, e.g. while we're trying to fetch registers. */
1174 if (all_symbols_looked_up
)
1177 /* Send the request. */
1178 strcpy (own_buf
, "qSymbol:");
1179 hexify (own_buf
+ strlen ("qSymbol:"), name
, strlen (name
));
1180 if (putpkt (own_buf
) < 0)
1183 /* FIXME: Eventually add buffer overflow checking (to getpkt?) */
1184 len
= getpkt (own_buf
);
1188 /* We ought to handle pretty much any packet at this point while we
1189 wait for the qSymbol "response". That requires re-entering the
1190 main loop. For now, this is an adequate approximation; allow
1191 GDB to read from memory while it figures out the address of the
1193 while (own_buf
[0] == 'm')
1196 unsigned char *mem_buf
;
1197 unsigned int mem_len
;
1199 decode_m_packet (&own_buf
[1], &mem_addr
, &mem_len
);
1200 mem_buf
= xmalloc (mem_len
);
1201 if (read_inferior_memory (mem_addr
, mem_buf
, mem_len
) == 0)
1202 convert_int_to_ascii (mem_buf
, own_buf
, mem_len
);
1204 write_enn (own_buf
);
1206 if (putpkt (own_buf
) < 0)
1208 len
= getpkt (own_buf
);
1213 if (strncmp (own_buf
, "qSymbol:", strlen ("qSymbol:")) != 0)
1215 warning ("Malformed response to qSymbol, ignoring: %s\n", own_buf
);
1219 p
= own_buf
+ strlen ("qSymbol:");
1221 while (*q
&& *q
!= ':')
1224 /* Make sure we found a value for the symbol. */
1225 if (p
== q
|| *q
== '\0')
1228 decode_address (addrp
, p
, q
- p
);
1230 /* Save the symbol in our cache. */
1231 sym
= xmalloc (sizeof (*sym
));
1232 sym
->name
= xstrdup (name
);
1234 sym
->next
= symbol_cache
;
1241 monitor_output (const char *msg
)
1243 char *buf
= xmalloc (strlen (msg
) * 2 + 2);
1246 hexify (buf
+ 1, msg
, 0);
1252 /* Return a malloc allocated string with special characters from TEXT
1253 replaced by entity references. */
1256 xml_escape_text (const char *text
)
1261 /* Compute the length of the result. */
1262 for (i
= 0, special
= 0; text
[i
] != '\0'; i
++)
1280 /* Expand the result. */
1281 result
= xmalloc (i
+ special
+ 1);
1282 for (i
= 0, special
= 0; text
[i
] != '\0'; i
++)
1286 strcpy (result
+ i
+ special
, "'");
1290 strcpy (result
+ i
+ special
, """);
1294 strcpy (result
+ i
+ special
, "&");
1298 strcpy (result
+ i
+ special
, "<");
1302 strcpy (result
+ i
+ special
, ">");
1306 result
[i
+ special
] = text
[i
];
1309 result
[i
+ special
] = '\0';
1315 buffer_grow (struct buffer
*buffer
, const char *data
, size_t size
)
1318 size_t new_buffer_size
;
1323 new_buffer_size
= buffer
->buffer_size
;
1325 if (new_buffer_size
== 0)
1326 new_buffer_size
= 1;
1328 while (buffer
->used_size
+ size
> new_buffer_size
)
1329 new_buffer_size
*= 2;
1330 new_buffer
= realloc (buffer
->buffer
, new_buffer_size
);
1333 memcpy (new_buffer
+ buffer
->used_size
, data
, size
);
1334 buffer
->buffer
= new_buffer
;
1335 buffer
->buffer_size
= new_buffer_size
;
1336 buffer
->used_size
+= size
;
1340 buffer_free (struct buffer
*buffer
)
1345 free (buffer
->buffer
);
1346 buffer
->buffer
= NULL
;
1347 buffer
->buffer_size
= 0;
1348 buffer
->used_size
= 0;
1352 buffer_init (struct buffer
*buffer
)
1354 memset (buffer
, 0, sizeof (*buffer
));
1358 buffer_finish (struct buffer
*buffer
)
1360 char *ret
= buffer
->buffer
;
1361 buffer
->buffer
= NULL
;
1362 buffer
->buffer_size
= 0;
1363 buffer
->used_size
= 0;
1368 buffer_xml_printf (struct buffer
*buffer
, const char *format
, ...)
1375 va_start (ap
, format
);
1378 for (f
= format
; *f
; f
++)
1387 char *a
= va_arg (ap
, char *);
1388 buffer_grow (buffer
, prev
, f
- prev
- 1);
1389 p
= xml_escape_text (a
);
1390 buffer_grow_str (buffer
, p
);
1402 buffer_grow_str (buffer
, prev
);