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 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA. */
27 #include <sys/ioctl.h>
31 #include <netinet/in.h>
34 #include <sys/socket.h>
39 #if HAVE_NETINET_TCP_H
40 #include <netinet/tcp.h>
43 #include <sys/ioctl.h>
50 #include <arpa/inet.h>
59 #ifndef HAVE_SOCKLEN_T
60 typedef int socklen_t
;
63 /* A cache entry for a successfully looked-up symbol. */
68 struct sym_cache
*next
;
71 /* The symbol cache. */
72 static struct sym_cache
*symbol_cache
;
74 /* If this flag has been set, assume cache misses are
76 int all_symbols_looked_up
;
79 struct ui_file
*gdb_stdlog
;
81 static int remote_desc
;
83 /* FIXME headerize? */
84 extern int using_threads
;
85 extern int debug_threads
;
88 # define read(fd, buf, len) recv (fd, buf, len, 0)
89 # define write(fd, buf, len) send (fd, buf, len, 0)
92 /* Open a connection to a remote debugger.
93 NAME is the filename used for communication. */
96 remote_open (char *name
)
98 #if defined(F_SETFL) && defined (FASYNC)
103 port_str
= strchr (name
, ':');
104 if (port_str
== NULL
)
107 error ("Only <host>:<port> is supported on this platform.");
111 if (stat (name
, &statbuf
) == 0
112 && (S_ISCHR (statbuf
.st_mode
) || S_ISFIFO (statbuf
.st_mode
)))
113 remote_desc
= open (name
, O_RDWR
);
121 perror_with_name ("Could not open remote device");
125 struct termios termios
;
126 tcgetattr (remote_desc
, &termios
);
131 termios
.c_cflag
&= ~(CSIZE
| PARENB
);
132 termios
.c_cflag
|= CLOCAL
| CS8
;
133 termios
.c_cc
[VMIN
] = 1;
134 termios
.c_cc
[VTIME
] = 0;
136 tcsetattr (remote_desc
, TCSANOW
, &termios
);
142 struct termio termio
;
143 ioctl (remote_desc
, TCGETA
, &termio
);
148 termio
.c_cflag
&= ~(CSIZE
| PARENB
);
149 termio
.c_cflag
|= CLOCAL
| CS8
;
150 termio
.c_cc
[VMIN
] = 1;
151 termio
.c_cc
[VTIME
] = 0;
153 ioctl (remote_desc
, TCSETA
, &termio
);
161 ioctl (remote_desc
, TIOCGETP
, &sg
);
163 ioctl (remote_desc
, TIOCSETP
, &sg
);
167 fprintf (stderr
, "Remote debugging using %s\n", name
);
168 #endif /* USE_WIN32API */
173 static int winsock_initialized
;
177 struct sockaddr_in sockaddr
;
181 port_str
= strchr (name
, ':');
183 port
= atoi (port_str
+ 1);
186 if (!winsock_initialized
)
190 WSAStartup (MAKEWORD (1, 0), &wsad
);
191 winsock_initialized
= 1;
195 tmp_desc
= socket (PF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
197 perror_with_name ("Can't open socket");
199 /* Allow rapid reuse of this port. */
201 setsockopt (tmp_desc
, SOL_SOCKET
, SO_REUSEADDR
, (char *) &tmp
,
204 sockaddr
.sin_family
= PF_INET
;
205 sockaddr
.sin_port
= htons (port
);
206 sockaddr
.sin_addr
.s_addr
= INADDR_ANY
;
208 if (bind (tmp_desc
, (struct sockaddr
*) &sockaddr
, sizeof (sockaddr
))
209 || listen (tmp_desc
, 1))
210 perror_with_name ("Can't bind address");
212 /* If port is zero, a random port will be selected, and the
213 fprintf below needs to know what port was selected. */
216 socklen_t len
= sizeof (sockaddr
);
217 if (getsockname (tmp_desc
, (struct sockaddr
*) &sockaddr
, &len
) < 0
218 || len
< sizeof (sockaddr
))
219 perror_with_name ("Can't determine port");
220 port
= ntohs (sockaddr
.sin_port
);
223 fprintf (stderr
, "Listening on port %d\n", port
);
226 tmp
= sizeof (sockaddr
);
227 remote_desc
= accept (tmp_desc
, (struct sockaddr
*) &sockaddr
, &tmp
);
228 if (remote_desc
== -1)
229 perror_with_name ("Accept failed");
231 /* Enable TCP keep alive process. */
233 setsockopt (tmp_desc
, SOL_SOCKET
, SO_KEEPALIVE
, (char *) &tmp
, sizeof (tmp
));
235 /* Tell TCP not to delay small packets. This greatly speeds up
236 interactive response. */
238 setsockopt (remote_desc
, IPPROTO_TCP
, TCP_NODELAY
,
239 (char *) &tmp
, sizeof (tmp
));
243 close (tmp_desc
); /* No longer need this */
245 signal (SIGPIPE
, SIG_IGN
); /* If we don't do this, then gdbserver simply
246 exits when the remote side dies. */
248 closesocket (tmp_desc
); /* No longer need this */
251 /* Convert IP address to string. */
252 fprintf (stderr
, "Remote debugging from host %s\n",
253 inet_ntoa (sockaddr
.sin_addr
));
256 #if defined(F_SETFL) && defined (FASYNC)
257 save_fcntl_flags
= fcntl (remote_desc
, F_GETFL
, 0);
258 fcntl (remote_desc
, F_SETFL
, save_fcntl_flags
| FASYNC
);
259 #if defined (F_SETOWN)
260 fcntl (remote_desc
, F_SETOWN
, getpid ());
270 closesocket (remote_desc
);
276 /* Convert hex digit A to a number. */
281 if (a
>= '0' && a
<= '9')
283 else if (a
>= 'a' && a
<= 'f')
286 error ("Reply contains invalid hex digit");
291 unhexify (char *bin
, const char *hex
, int count
)
295 for (i
= 0; i
< count
; i
++)
297 if (hex
[0] == 0 || hex
[1] == 0)
299 /* Hex string is short, or of uneven length.
300 Return the count that has been converted so far. */
303 *bin
++ = fromhex (hex
[0]) * 16 + fromhex (hex
[1]);
310 decode_address (CORE_ADDR
*addrp
, const char *start
, int len
)
317 for (i
= 0; i
< len
; i
++)
321 addr
= addr
| (fromhex (ch
) & 0x0f);
327 decode_address_to_semicolon (CORE_ADDR
*addrp
, const char *start
)
332 while (*end
!= '\0' && *end
!= ';')
335 decode_address (addrp
, start
, end
- start
);
342 /* Convert number NIB to a hex digit. */
350 return 'a' + nib
- 10;
354 hexify (char *hex
, const char *bin
, int count
)
358 /* May use a length, or a nul-terminated string as input. */
360 count
= strlen (bin
);
362 for (i
= 0; i
< count
; i
++)
364 *hex
++ = tohex ((*bin
>> 4) & 0xf);
365 *hex
++ = tohex (*bin
++ & 0xf);
371 /* Convert BUFFER, binary data at least LEN bytes long, into escaped
372 binary data in OUT_BUF. Set *OUT_LEN to the length of the data
373 encoded in OUT_BUF, and return the number of bytes in OUT_BUF
374 (which may be more than *OUT_LEN due to escape characters). The
375 total number of bytes in the output buffer will be at most
379 remote_escape_output (const gdb_byte
*buffer
, int len
,
380 gdb_byte
*out_buf
, int *out_len
,
383 int input_index
, output_index
;
386 for (input_index
= 0; input_index
< len
; input_index
++)
388 gdb_byte b
= buffer
[input_index
];
390 if (b
== '$' || b
== '#' || b
== '}' || b
== '*')
392 /* These must be escaped. */
393 if (output_index
+ 2 > out_maxlen
)
395 out_buf
[output_index
++] = '}';
396 out_buf
[output_index
++] = b
^ 0x20;
400 if (output_index
+ 1 > out_maxlen
)
402 out_buf
[output_index
++] = b
;
406 *out_len
= input_index
;
410 /* Convert BUFFER, escaped data LEN bytes long, into binary data
411 in OUT_BUF. Return the number of bytes written to OUT_BUF.
412 Raise an error if the total number of bytes exceeds OUT_MAXLEN.
414 This function reverses remote_escape_output. It allows more
415 escaped characters than that function does, in particular because
416 '*' must be escaped to avoid the run-length encoding processing
417 in reading packets. */
420 remote_unescape_input (const gdb_byte
*buffer
, int len
,
421 gdb_byte
*out_buf
, int out_maxlen
)
423 int input_index
, output_index
;
428 for (input_index
= 0; input_index
< len
; input_index
++)
430 gdb_byte b
= buffer
[input_index
];
432 if (output_index
+ 1 > out_maxlen
)
433 error ("Received too much data from the target.");
437 out_buf
[output_index
++] = b
^ 0x20;
443 out_buf
[output_index
++] = b
;
447 error ("Unmatched escape character in target response.");
452 /* Look for a sequence of characters which can be run-length encoded.
453 If there are any, update *CSUM and *P. Otherwise, output the
454 single character. Return the number of characters consumed. */
457 try_rle (char *buf
, int remaining
, unsigned char *csum
, char **p
)
461 /* Always output the character. */
465 /* Don't go past '~'. */
469 for (n
= 1; n
< remaining
; n
++)
470 if (buf
[n
] != buf
[0])
473 /* N is the index of the first character not the same as buf[0].
474 buf[0] is counted twice, so by decrementing N, we get the number
475 of characters the RLE sequence will replace. */
481 /* Skip the frame characters. The manual says to skip '+' and '-'
482 also, but there's no reason to. Unfortunately these two unusable
483 characters double the encoded length of a four byte zero
485 while (n
+ 29 == '$' || n
+ 29 == '#')
496 /* Send a packet to the remote machine, with error checking.
497 The data of the packet is in BUF, and the length of the
498 packet is in CNT. Returns >= 0 on success, -1 otherwise. */
501 putpkt_binary (char *buf
, int cnt
)
504 unsigned char csum
= 0;
509 buf2
= malloc (PBUFSIZ
);
511 /* Copy the packet into buffer BUF2, encapsulating it
512 and giving it a checksum. */
517 for (i
= 0; i
< cnt
;)
518 i
+= try_rle (buf
+ i
, cnt
- i
, &csum
, &p
);
521 *p
++ = tohex ((csum
>> 4) & 0xf);
522 *p
++ = tohex (csum
& 0xf);
526 /* Send it over and over until we get a positive ack. */
532 if (write (remote_desc
, buf2
, p
- buf2
) != p
- buf2
)
534 perror ("putpkt(write)");
540 fprintf (stderr
, "putpkt (\"%s\"); [looking for ack]\n", buf2
);
543 cc
= read (remote_desc
, buf3
, 1);
546 fprintf (stderr
, "[received '%c' (0x%x)]\n", buf3
[0], buf3
[0]);
553 fprintf (stderr
, "putpkt(read): Got EOF\n");
555 perror ("putpkt(read)");
561 /* Check for an input interrupt while we're here. */
562 if (buf3
[0] == '\003')
563 (*the_target
->request_interrupt
) ();
565 while (buf3
[0] != '+');
568 return 1; /* Success! */
571 /* Send a packet to the remote machine, with error checking. The data
572 of the packet is in BUF, and the packet should be a NUL-terminated
573 string. Returns >= 0 on success, -1 otherwise. */
578 return putpkt_binary (buf
, strlen (buf
));
583 /* Come here when we get an input interrupt from the remote side. This
584 interrupt should only be active while we are waiting for the child to do
585 something. About the only thing that should come through is a ^C, which
586 will cause us to request child interruption. */
589 input_interrupt (int unused
)
592 struct timeval immediate
= { 0, 0 };
594 /* Protect against spurious interrupts. This has been observed to
595 be a problem under NetBSD 1.4 and 1.5. */
598 FD_SET (remote_desc
, &readset
);
599 if (select (remote_desc
+ 1, &readset
, 0, 0, &immediate
) > 0)
604 cc
= read (remote_desc
, &c
, 1);
606 if (cc
!= 1 || c
!= '\003')
608 fprintf (stderr
, "input_interrupt, count = %d c = %d ('%c')\n",
613 (*the_target
->request_interrupt
) ();
618 /* Asynchronous I/O support. SIGIO must be enabled when waiting, in order to
619 accept Control-C from the client, and must be disabled when talking to
623 block_async_io (void)
627 sigemptyset (&sigio_set
);
628 sigaddset (&sigio_set
, SIGIO
);
629 sigprocmask (SIG_BLOCK
, &sigio_set
, NULL
);
634 unblock_async_io (void)
638 sigemptyset (&sigio_set
);
639 sigaddset (&sigio_set
, SIGIO
);
640 sigprocmask (SIG_UNBLOCK
, &sigio_set
, NULL
);
644 /* Current state of asynchronous I/O. */
645 static int async_io_enabled
;
647 /* Enable asynchronous I/O. */
649 enable_async_io (void)
651 if (async_io_enabled
)
655 signal (SIGIO
, input_interrupt
);
657 async_io_enabled
= 1;
660 /* Disable asynchronous I/O. */
662 disable_async_io (void)
664 if (!async_io_enabled
)
668 signal (SIGIO
, SIG_IGN
);
670 async_io_enabled
= 0;
673 /* Returns next char from remote GDB. -1 if error. */
678 static unsigned char buf
[BUFSIZ
];
679 static int bufcnt
= 0;
680 static unsigned char *bufp
;
685 bufcnt
= read (remote_desc
, buf
, sizeof (buf
));
690 fprintf (stderr
, "readchar: Got EOF\n");
699 return *bufp
++ & 0x7f;
702 /* Read a packet from the remote machine, with error checking,
703 and store it in BUF. Returns length of packet, or negative if error. */
709 unsigned char csum
, c1
, c2
;
723 fprintf (stderr
, "[getpkt: discarding char '%c']\n", c
);
744 c1
= fromhex (readchar ());
745 c2
= fromhex (readchar ());
747 if (csum
== (c1
<< 4) + c2
)
750 fprintf (stderr
, "Bad checksum, sentsum=0x%x, csum=0x%x, buf=%s\n",
751 (c1
<< 4) + c2
, csum
, buf
);
752 write (remote_desc
, "-", 1);
757 fprintf (stderr
, "getpkt (\"%s\"); [sending ack] \n", buf
);
761 write (remote_desc
, "+", 1);
765 fprintf (stderr
, "[sent ack]\n");
781 write_enn (char *buf
)
783 /* Some day, we should define the meanings of the error codes... */
791 convert_int_to_ascii (unsigned char *from
, char *to
, int n
)
798 nib
= ((ch
& 0xf0) >> 4) & 0x0f;
808 convert_ascii_to_int (char *from
, unsigned char *to
, int n
)
813 nib1
= fromhex (*from
++);
814 nib2
= fromhex (*from
++);
815 *to
++ = (((nib1
& 0x0f) << 4) & 0xf0) | (nib2
& 0x0f);
820 outreg (int regno
, char *buf
)
822 if ((regno
>> 12) != 0)
823 *buf
++ = tohex ((regno
>> 12) & 0xf);
824 if ((regno
>> 8) != 0)
825 *buf
++ = tohex ((regno
>> 8) & 0xf);
826 *buf
++ = tohex ((regno
>> 4) & 0xf);
827 *buf
++ = tohex (regno
& 0xf);
829 collect_register_as_string (regno
, buf
);
830 buf
+= 2 * register_size (regno
);
837 new_thread_notify (int id
)
841 /* The `n' response is not yet part of the remote protocol. Do nothing. */
845 if (server_waiting
== 0)
848 sprintf (own_buf
, "n%x", id
);
855 dead_thread_notify (int id
)
859 /* The `x' response is not yet part of the remote protocol. Do nothing. */
863 sprintf (own_buf
, "x%x", id
);
870 prepare_resume_reply (char *buf
, char status
, unsigned char sig
)
876 nib
= ((sig
& 0xf0) >> 4);
877 *buf
++ = tohex (nib
);
879 *buf
++ = tohex (nib
);
883 const char **regp
= gdbserver_expedite_regs
;
885 if (the_target
->stopped_by_watchpoint
!= NULL
886 && (*the_target
->stopped_by_watchpoint
) ())
891 strncpy (buf
, "watch:", 6);
894 addr
= (*the_target
->stopped_data_address
) ();
896 /* Convert each byte of the address into two hexadecimal chars.
897 Note that we take sizeof (void *) instead of sizeof (addr);
898 this is to avoid sending a 64-bit address to a 32-bit GDB. */
899 for (i
= sizeof (void *) * 2; i
> 0; i
--)
901 *buf
++ = tohex ((addr
>> (i
- 1) * 4) & 0xf);
908 buf
= outreg (find_regno (*regp
), buf
);
912 /* Formerly, if the debugger had not used any thread features we would not
913 burden it with a thread status response. This was for the benefit of
914 GDB 4.13 and older. However, in recent GDB versions the check
915 (``if (cont_thread != 0)'') does not have the desired effect because of
916 sillyness in the way that the remote protocol handles specifying a thread.
917 Since thread support relies on qSymbol support anyway, assume GDB can handle
922 unsigned int gdb_id_from_wait
;
924 /* FIXME right place to set this? */
925 thread_from_wait
= ((struct inferior_list_entry
*)current_inferior
)->id
;
926 gdb_id_from_wait
= thread_to_gdb_id (current_inferior
);
929 fprintf (stderr
, "Writing resume reply for %ld\n\n", thread_from_wait
);
930 /* This if (1) ought to be unnecessary. But remote_wait in GDB
931 will claim this event belongs to inferior_ptid if we do not
932 specify a thread, and there's no way for gdbserver to know
933 what inferior_ptid is. */
934 if (1 || old_thread_from_wait
!= thread_from_wait
)
936 general_thread
= thread_from_wait
;
937 sprintf (buf
, "thread:%x;", gdb_id_from_wait
);
939 old_thread_from_wait
= thread_from_wait
;
943 /* For W and X, we're done. */
948 decode_m_packet (char *from
, CORE_ADDR
*mem_addr_ptr
, unsigned int *len_ptr
)
952 *mem_addr_ptr
= *len_ptr
= 0;
954 while ((ch
= from
[i
++]) != ',')
956 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
957 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
960 for (j
= 0; j
< 4; j
++)
962 if ((ch
= from
[i
++]) == 0)
964 *len_ptr
= *len_ptr
<< 4;
965 *len_ptr
|= fromhex (ch
) & 0x0f;
970 decode_M_packet (char *from
, CORE_ADDR
*mem_addr_ptr
, unsigned int *len_ptr
,
975 *mem_addr_ptr
= *len_ptr
= 0;
977 while ((ch
= from
[i
++]) != ',')
979 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
980 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
983 while ((ch
= from
[i
++]) != ':')
985 *len_ptr
= *len_ptr
<< 4;
986 *len_ptr
|= fromhex (ch
) & 0x0f;
989 convert_ascii_to_int (&from
[i
++], to
, *len_ptr
);
993 decode_X_packet (char *from
, int packet_len
, CORE_ADDR
*mem_addr_ptr
,
994 unsigned int *len_ptr
, unsigned char *to
)
998 *mem_addr_ptr
= *len_ptr
= 0;
1000 while ((ch
= from
[i
++]) != ',')
1002 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
1003 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
1006 while ((ch
= from
[i
++]) != ':')
1008 *len_ptr
= *len_ptr
<< 4;
1009 *len_ptr
|= fromhex (ch
) & 0x0f;
1012 if (remote_unescape_input ((const gdb_byte
*) &from
[i
], packet_len
- i
,
1013 to
, *len_ptr
) != *len_ptr
)
1019 /* Ask GDB for the address of NAME, and return it in ADDRP if found.
1020 Returns 1 if the symbol is found, 0 if it is not, -1 on error. */
1023 look_up_one_symbol (const char *name
, CORE_ADDR
*addrp
)
1025 char own_buf
[266], *p
, *q
;
1027 struct sym_cache
*sym
;
1029 /* Check the cache first. */
1030 for (sym
= symbol_cache
; sym
; sym
= sym
->next
)
1031 if (strcmp (name
, sym
->name
) == 0)
1037 /* If we've passed the call to thread_db_look_up_symbols, then
1038 anything not in the cache must not exist; we're not interested
1039 in any libraries loaded after that point, only in symbols in
1040 libpthread.so. It might not be an appropriate time to look
1041 up a symbol, e.g. while we're trying to fetch registers. */
1042 if (all_symbols_looked_up
)
1045 /* Send the request. */
1046 strcpy (own_buf
, "qSymbol:");
1047 hexify (own_buf
+ strlen ("qSymbol:"), name
, strlen (name
));
1048 if (putpkt (own_buf
) < 0)
1051 /* FIXME: Eventually add buffer overflow checking (to getpkt?) */
1052 len
= getpkt (own_buf
);
1056 if (strncmp (own_buf
, "qSymbol:", strlen ("qSymbol:")) != 0)
1058 /* Malformed response. */
1061 fprintf (stderr
, "Malformed response to qSymbol, ignoring.\n");
1068 p
= own_buf
+ strlen ("qSymbol:");
1070 while (*q
&& *q
!= ':')
1073 /* Make sure we found a value for the symbol. */
1074 if (p
== q
|| *q
== '\0')
1077 decode_address (addrp
, p
, q
- p
);
1079 /* Save the symbol in our cache. */
1080 sym
= malloc (sizeof (*sym
));
1081 sym
->name
= strdup (name
);
1083 sym
->next
= symbol_cache
;
1090 monitor_output (char *msg
)
1092 char *buf
= malloc (strlen (msg
) * 2 + 2);
1095 hexify (buf
+ 1, msg
, 0);
This page took 0.080346 seconds and 4 git commands to generate.