X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fgdbserver%2Fremote-utils.c;h=b8a8c6576f974b57264d1f6f8c18de79a5b72cb8;hb=5b6d1e4fa4fc6827c7b3f0e99ff120dfa14d65d2;hp=5cd6fa14c2ddf467d4b584ed87dbc3afeb772b88;hpb=bc7dea8de974648cd4e38d154abcca6879e630cc;p=deliverable%2Fbinutils-gdb.git
diff --git a/gdb/gdbserver/remote-utils.c b/gdb/gdbserver/remote-utils.c
index 5cd6fa14c2..b8a8c6576f 100644
--- a/gdb/gdbserver/remote-utils.c
+++ b/gdb/gdbserver/remote-utils.c
@@ -1,5 +1,5 @@
/* Remote utility routines for the remote server for GDB.
- Copyright (C) 1986-2013 Free Software Foundation, Inc.
+ Copyright (C) 1986-2020 Free Software Foundation, Inc.
This file is part of GDB.
@@ -17,12 +17,19 @@
along with this program. If not, see . */
#include "server.h"
-#include "terminal.h"
+#if HAVE_TERMIOS_H
+#include
+#endif
#include "target.h"
#include "gdbthread.h"
#include "tdesc.h"
-#include
-#include
+#include "debug.h"
+#include "dll.h"
+#include "gdbsupport/rsp-low.h"
+#include "gdbsupport/netstuff.h"
+#include "gdbsupport/filestuff.h"
+#include "gdbsupport/gdb-sigmask.h"
+#include
#if HAVE_SYS_IOCTL_H
#include
#endif
@@ -50,18 +57,15 @@
#if HAVE_FCNTL_H
#include
#endif
-#include
+#include "gdbsupport/gdb_sys_time.h"
#include
#if HAVE_ARPA_INET_H
#include
#endif
-#include "gdb_stat.h"
-#if HAVE_ERRNO_H
-#include
-#endif
+#include
#if USE_WIN32API
-#include
+#include
#endif
#if __QNX__
@@ -102,23 +106,11 @@ struct sym_cache
struct sym_cache *next;
};
-int remote_debug = 0;
-struct ui_file *gdb_stdlog;
-
static int remote_is_stdio = 0;
static gdb_fildes_t remote_desc = INVALID_DESCRIPTOR;
static gdb_fildes_t listen_desc = INVALID_DESCRIPTOR;
-/* FIXME headerize? */
-extern int using_threads;
-extern int debug_threads;
-
-/* If true, then GDB has requested noack mode. */
-int noack_mode = 0;
-/* If true, then we tell GDB to use noack mode by default. */
-int transport_is_reliable = 0;
-
#ifdef USE_WIN32API
# define read(fd, buf, len) recv (fd, (char *) buf, len, 0)
# define write(fd, buf, len) send (fd, (char *) buf, len, 0)
@@ -155,19 +147,18 @@ enable_async_notification (int fd)
static int
handle_accept_event (int err, gdb_client_data client_data)
{
- struct sockaddr_in sockaddr;
- socklen_t tmp;
+ struct sockaddr_storage sockaddr;
+ socklen_t len = sizeof (sockaddr);
if (debug_threads)
- fprintf (stderr, "handling possible accept event\n");
+ debug_printf ("handling possible accept event\n");
- tmp = sizeof (sockaddr);
- remote_desc = accept (listen_desc, (struct sockaddr *) &sockaddr, &tmp);
+ remote_desc = accept (listen_desc, (struct sockaddr *) &sockaddr, &len);
if (remote_desc == -1)
perror_with_name ("Accept failed");
/* Enable TCP keep alive process. */
- tmp = 1;
+ socklen_t tmp = 1;
setsockopt (remote_desc, SOL_SOCKET, SO_KEEPALIVE,
(char *) &tmp, sizeof (tmp));
@@ -196,8 +187,19 @@ handle_accept_event (int err, gdb_client_data client_data)
delete_file_handler (listen_desc);
/* Convert IP address to string. */
- fprintf (stderr, "Remote debugging from host %s\n",
- inet_ntoa (sockaddr.sin_addr));
+ char orig_host[GDB_NI_MAX_ADDR], orig_port[GDB_NI_MAX_PORT];
+
+ int r = getnameinfo ((struct sockaddr *) &sockaddr, len,
+ orig_host, sizeof (orig_host),
+ orig_port, sizeof (orig_port),
+ NI_NUMERICHOST | NI_NUMERICSERV);
+
+ if (r != 0)
+ fprintf (stderr, _("Could not obtain remote address: %s\n"),
+ gai_strerror (r));
+ else
+ fprintf (stderr, _("Remote debugging from host %s, port %s\n"),
+ orig_host, orig_port);
enable_async_notification (remote_desc);
@@ -219,16 +221,13 @@ handle_accept_event (int err, gdb_client_data client_data)
NAME is the filename used for communication. */
void
-remote_prepare (char *name)
+remote_prepare (const char *name)
{
- char *port_str;
+ client_state &cs = get_client_state ();
#ifdef USE_WIN32API
static int winsock_initialized;
#endif
- int port;
- struct sockaddr_in sockaddr;
socklen_t tmp;
- char *port_end;
remote_is_stdio = 0;
if (strcmp (name, STDIO_CONNECTION_NAME) == 0)
@@ -237,21 +236,29 @@ remote_prepare (char *name)
call to remote_open so start_inferior knows the connection is
via stdio. */
remote_is_stdio = 1;
- transport_is_reliable = 1;
+ cs.transport_is_reliable = 1;
return;
}
- port_str = strchr (name, ':');
- if (port_str == NULL)
+ struct addrinfo hint;
+ struct addrinfo *ainfo;
+
+ memset (&hint, 0, sizeof (hint));
+ /* Assume no prefix will be passed, therefore we should use
+ AF_UNSPEC. */
+ hint.ai_family = AF_UNSPEC;
+ hint.ai_socktype = SOCK_STREAM;
+ hint.ai_protocol = IPPROTO_TCP;
+
+ parsed_connection_spec parsed
+ = parse_connection_spec_without_prefix (name, &hint);
+
+ if (parsed.port_str.empty ())
{
- transport_is_reliable = 0;
+ cs.transport_is_reliable = 0;
return;
}
- port = strtoul (port_str + 1, &port_end, 10);
- if (port_str[1] == '\0' || *port_end != '\0')
- fatal ("Bad port argument: %s", name);
-
#ifdef USE_WIN32API
if (!winsock_initialized)
{
@@ -262,8 +269,26 @@ remote_prepare (char *name)
}
#endif
- listen_desc = socket (PF_INET, SOCK_STREAM, IPPROTO_TCP);
- if (listen_desc == -1)
+ int r = getaddrinfo (parsed.host_str.c_str (), parsed.port_str.c_str (),
+ &hint, &ainfo);
+
+ if (r != 0)
+ error (_("%s: cannot resolve name: %s"), name, gai_strerror (r));
+
+ scoped_free_addrinfo freeaddrinfo (ainfo);
+
+ struct addrinfo *iter;
+
+ for (iter = ainfo; iter != NULL; iter = iter->ai_next)
+ {
+ listen_desc = gdb_socket_cloexec (iter->ai_family, iter->ai_socktype,
+ iter->ai_protocol);
+
+ if (listen_desc >= 0)
+ break;
+ }
+
+ if (iter == NULL)
perror_with_name ("Can't open socket");
/* Allow rapid reuse of this port. */
@@ -271,29 +296,40 @@ remote_prepare (char *name)
setsockopt (listen_desc, SOL_SOCKET, SO_REUSEADDR, (char *) &tmp,
sizeof (tmp));
- sockaddr.sin_family = PF_INET;
- sockaddr.sin_port = htons (port);
- sockaddr.sin_addr.s_addr = INADDR_ANY;
+ switch (iter->ai_family)
+ {
+ case AF_INET:
+ ((struct sockaddr_in *) iter->ai_addr)->sin_addr.s_addr = INADDR_ANY;
+ break;
+ case AF_INET6:
+ ((struct sockaddr_in6 *) iter->ai_addr)->sin6_addr = in6addr_any;
+ break;
+ default:
+ internal_error (__FILE__, __LINE__,
+ _("Invalid 'ai_family' %d\n"), iter->ai_family);
+ }
- if (bind (listen_desc, (struct sockaddr *) &sockaddr, sizeof (sockaddr))
- || listen (listen_desc, 1))
+ if (bind (listen_desc, iter->ai_addr, iter->ai_addrlen) != 0)
perror_with_name ("Can't bind address");
- transport_is_reliable = 1;
+ if (listen (listen_desc, 1) != 0)
+ perror_with_name ("Can't listen on socket");
+
+ cs.transport_is_reliable = 1;
}
/* Open a connection to a remote debugger.
NAME is the filename used for communication. */
void
-remote_open (char *name)
+remote_open (const char *name)
{
- char *port_str;
+ const char *port_str;
port_str = strchr (name, ':');
#ifdef USE_WIN32API
if (port_str == NULL)
- error ("Only : is supported on this platform.");
+ error ("Only HOST:PORT is supported on this platform.");
#endif
if (strcmp (name, STDIO_CONNECTION_NAME) == 0)
@@ -326,7 +362,7 @@ remote_open (char *name)
if (remote_desc < 0)
perror_with_name ("Could not open remote device");
-#ifdef HAVE_TERMIOS
+#if HAVE_TERMIOS_H
{
struct termios termios;
tcgetattr (remote_desc, &termios);
@@ -343,33 +379,6 @@ remote_open (char *name)
}
#endif
-#ifdef HAVE_TERMIO
- {
- struct termio termio;
- ioctl (remote_desc, TCGETA, &termio);
-
- termio.c_iflag = 0;
- termio.c_oflag = 0;
- termio.c_lflag = 0;
- termio.c_cflag &= ~(CSIZE | PARENB);
- termio.c_cflag |= CLOCAL | CS8;
- termio.c_cc[VMIN] = 1;
- termio.c_cc[VTIME] = 0;
-
- ioctl (remote_desc, TCSETA, &termio);
- }
-#endif
-
-#ifdef HAVE_SGTTY
- {
- struct sgttyb sg;
-
- ioctl (remote_desc, TIOCGETP, &sg);
- sg.sg_flags = RAW;
- ioctl (remote_desc, TIOCSETP, &sg);
- }
-#endif
-
fprintf (stderr, "Remote debugging using %s\n", name);
enable_async_notification (remote_desc);
@@ -380,18 +389,24 @@ remote_open (char *name)
#endif /* USE_WIN32API */
else
{
- int port;
- socklen_t len;
- struct sockaddr_in sockaddr;
-
- len = sizeof (sockaddr);
- if (getsockname (listen_desc,
- (struct sockaddr *) &sockaddr, &len) < 0
- || len < sizeof (sockaddr))
+ char listen_port[GDB_NI_MAX_PORT];
+ struct sockaddr_storage sockaddr;
+ socklen_t len = sizeof (sockaddr);
+
+ if (getsockname (listen_desc, (struct sockaddr *) &sockaddr, &len) < 0)
perror_with_name ("Can't determine port");
- port = ntohs (sockaddr.sin_port);
- fprintf (stderr, "Listening on port %d\n", port);
+ int r = getnameinfo ((struct sockaddr *) &sockaddr, len,
+ NULL, 0,
+ listen_port, sizeof (listen_port),
+ NI_NUMERICSERV);
+
+ if (r != 0)
+ fprintf (stderr, _("Can't obtain port where we are listening: %s"),
+ gai_strerror (r));
+ else
+ fprintf (stderr, _("Listening on port %s\n"), listen_port);
+
fflush (stderr);
/* Register the event loop handler. */
@@ -404,6 +419,8 @@ remote_close (void)
{
delete_file_handler (remote_desc);
+ disable_async_io ();
+
#ifdef USE_WIN32API
closesocket (remote_desc);
#else
@@ -415,66 +432,10 @@ remote_close (void)
reset_readchar ();
}
-/* Convert hex digit A to a number. */
-
-static int
-fromhex (int a)
-{
- if (a >= '0' && a <= '9')
- return a - '0';
- else if (a >= 'a' && a <= 'f')
- return a - 'a' + 10;
- else
- error ("Reply contains invalid hex digit");
- return 0;
-}
-
#endif
-static const char hexchars[] = "0123456789abcdef";
-
-static int
-ishex (int ch, int *val)
-{
- if ((ch >= 'a') && (ch <= 'f'))
- {
- *val = ch - 'a' + 10;
- return 1;
- }
- if ((ch >= 'A') && (ch <= 'F'))
- {
- *val = ch - 'A' + 10;
- return 1;
- }
- if ((ch >= '0') && (ch <= '9'))
- {
- *val = ch - '0';
- return 1;
- }
- return 0;
-}
-
#ifndef IN_PROCESS_AGENT
-int
-unhexify (char *bin, const char *hex, int count)
-{
- int i;
-
- for (i = 0; i < count; i++)
- {
- if (hex[0] == 0 || hex[1] == 0)
- {
- /* Hex string is short, or of uneven length.
- Return the count that has been converted so far. */
- return i;
- }
- *bin++ = fromhex (hex[0]) * 16 + fromhex (hex[1]);
- hex += 2;
- }
- return i;
-}
-
void
decode_address (CORE_ADDR *addrp, const char *start, int len)
{
@@ -510,118 +471,8 @@ decode_address_to_semicolon (CORE_ADDR *addrp, const char *start)
#endif
-/* Convert number NIB to a hex digit. */
-
-static int
-tohex (int nib)
-{
- if (nib < 10)
- return '0' + nib;
- else
- return 'a' + nib - 10;
-}
-
#ifndef IN_PROCESS_AGENT
-int
-hexify (char *hex, const char *bin, int count)
-{
- int i;
-
- /* May use a length, or a nul-terminated string as input. */
- if (count == 0)
- count = strlen (bin);
-
- for (i = 0; i < count; i++)
- {
- *hex++ = tohex ((*bin >> 4) & 0xf);
- *hex++ = tohex (*bin++ & 0xf);
- }
- *hex = 0;
- return i;
-}
-
-/* Convert BUFFER, binary data at least LEN bytes long, into escaped
- binary data in OUT_BUF. Set *OUT_LEN to the length of the data
- encoded in OUT_BUF, and return the number of bytes in OUT_BUF
- (which may be more than *OUT_LEN due to escape characters). The
- total number of bytes in the output buffer will be at most
- OUT_MAXLEN. */
-
-int
-remote_escape_output (const gdb_byte *buffer, int len,
- gdb_byte *out_buf, int *out_len,
- int out_maxlen)
-{
- int input_index, output_index;
-
- output_index = 0;
- for (input_index = 0; input_index < len; input_index++)
- {
- gdb_byte b = buffer[input_index];
-
- if (b == '$' || b == '#' || b == '}' || b == '*')
- {
- /* These must be escaped. */
- if (output_index + 2 > out_maxlen)
- break;
- out_buf[output_index++] = '}';
- out_buf[output_index++] = b ^ 0x20;
- }
- else
- {
- if (output_index + 1 > out_maxlen)
- break;
- out_buf[output_index++] = b;
- }
- }
-
- *out_len = input_index;
- return output_index;
-}
-
-/* Convert BUFFER, escaped data LEN bytes long, into binary data
- in OUT_BUF. Return the number of bytes written to OUT_BUF.
- Raise an error if the total number of bytes exceeds OUT_MAXLEN.
-
- This function reverses remote_escape_output. It allows more
- escaped characters than that function does, in particular because
- '*' must be escaped to avoid the run-length encoding processing
- in reading packets. */
-
-static int
-remote_unescape_input (const gdb_byte *buffer, int len,
- gdb_byte *out_buf, int out_maxlen)
-{
- int input_index, output_index;
- int escaped;
-
- output_index = 0;
- escaped = 0;
- for (input_index = 0; input_index < len; input_index++)
- {
- gdb_byte b = buffer[input_index];
-
- if (output_index + 1 > out_maxlen)
- error ("Received too much data from the target.");
-
- if (escaped)
- {
- out_buf[output_index++] = b ^ 0x20;
- escaped = 0;
- }
- else if (b == '}')
- escaped = 1;
- else
- out_buf[output_index++] = b;
- }
-
- if (escaped)
- error ("Unmatched escape character in target response.");
-
- return output_index;
-}
-
/* Look for a sequence of characters which can be run-length encoded.
If there are any, update *CSUM and *P. Otherwise, output the
single character. Return the number of characters consumed. */
@@ -668,23 +519,6 @@ try_rle (char *buf, int remaining, unsigned char *csum, char **p)
#endif
-char *
-unpack_varlen_hex (char *buff, /* packet to parse */
- ULONGEST *result)
-{
- int nibble;
- ULONGEST retval = 0;
-
- while (ishex (*buff, &nibble))
- {
- buff++;
- retval = retval << 4;
- retval |= nibble & 0x0f;
- }
- *result = retval;
- return buff;
-}
-
#ifndef IN_PROCESS_AGENT
/* Write a PTID to BUF. Returns BUF+CHARACTERS_WRITTEN. */
@@ -692,17 +526,18 @@ unpack_varlen_hex (char *buff, /* packet to parse */
char *
write_ptid (char *buf, ptid_t ptid)
{
+ client_state &cs = get_client_state ();
int pid, tid;
- if (multi_process)
+ if (cs.multi_process)
{
- pid = ptid_get_pid (ptid);
+ pid = ptid.pid ();
if (pid < 0)
buf += sprintf (buf, "p-%x.", -pid);
else
buf += sprintf (buf, "p%x.", pid);
}
- tid = ptid_get_lwp (ptid);
+ tid = ptid.lwp ();
if (tid < 0)
buf += sprintf (buf, "-%x", -tid);
else
@@ -711,12 +546,12 @@ write_ptid (char *buf, ptid_t ptid)
return buf;
}
-ULONGEST
-hex_or_minus_one (char *buf, char **obuf)
+static ULONGEST
+hex_or_minus_one (const char *buf, const char **obuf)
{
ULONGEST ret;
- if (strncmp (buf, "-1", 2) == 0)
+ if (startswith (buf, "-1"))
{
ret = (ULONGEST) -1;
buf += 2;
@@ -733,10 +568,10 @@ hex_or_minus_one (char *buf, char **obuf)
/* Extract a PTID from BUF. If non-null, OBUF is set to the to one
passed the last parsed char. Returns null_ptid on error. */
ptid_t
-read_ptid (char *buf, char **obuf)
+read_ptid (const char *buf, const char **obuf)
{
- char *p = buf;
- char *pp;
+ const char *p = buf;
+ const char *pp;
ULONGEST pid = 0, tid = 0;
if (*p == 'p')
@@ -752,19 +587,20 @@ read_ptid (char *buf, char **obuf)
if (obuf)
*obuf = pp;
- return ptid_build (pid, tid, 0);
+ return ptid_t (pid, tid, 0);
}
/* No multi-process. Just a tid. */
tid = hex_or_minus_one (p, &pp);
- /* Since the stub is not sending a process id, then default to
- what's in the current inferior. */
- pid = ptid_get_pid (current_ptid);
+ /* Since GDB is not sending a process id (multi-process extensions
+ are off), then there's only one process. Default to the first in
+ the list. */
+ pid = pid_of (get_first_process ());
if (obuf)
*obuf = pp;
- return ptid_build (pid, tid, 0);
+ return ptid_t (pid, tid, 0);
}
/* Write COUNT bytes in BUF to the client.
@@ -800,13 +636,14 @@ read_prim (void *buf, int count)
static int
putpkt_binary_1 (char *buf, int cnt, int is_notif)
{
+ client_state &cs = get_client_state ();
int i;
unsigned char csum = 0;
char *buf2;
char *p;
int cc;
- buf2 = xmalloc (strlen ("$") + cnt + strlen ("#nn") + 1);
+ buf2 = (char *) xmalloc (strlen ("$") + cnt + strlen ("#nn") + 1);
/* Copy the packet into buffer BUF2, encapsulating it
and giving it a checksum. */
@@ -837,24 +674,24 @@ putpkt_binary_1 (char *buf, int cnt, int is_notif)
return -1;
}
- if (noack_mode || is_notif)
+ if (cs.noack_mode || is_notif)
{
/* Don't expect an ack then. */
if (remote_debug)
{
if (is_notif)
- fprintf (stderr, "putpkt (\"%s\"); [notif]\n", buf2);
+ debug_printf ("putpkt (\"%s\"); [notif]\n", buf2);
else
- fprintf (stderr, "putpkt (\"%s\"); [noack mode]\n", buf2);
- fflush (stderr);
+ debug_printf ("putpkt (\"%s\"); [noack mode]\n", buf2);
+ debug_flush ();
}
break;
}
if (remote_debug)
{
- fprintf (stderr, "putpkt (\"%s\"); [looking for ack]\n", buf2);
- fflush (stderr);
+ debug_printf ("putpkt (\"%s\"); [looking for ack]\n", buf2);
+ debug_flush ();
}
cc = readchar ();
@@ -867,12 +704,12 @@ putpkt_binary_1 (char *buf, int cnt, int is_notif)
if (remote_debug)
{
- fprintf (stderr, "[received '%c' (0x%x)]\n", cc, cc);
- fflush (stderr);
+ debug_printf ("[received '%c' (0x%x)]\n", cc, cc);
+ debug_flush ();
}
/* Check for an input interrupt while we're here. */
- if (cc == '\003' && current_inferior != NULL)
+ if (cc == '\003' && current_thread != NULL)
(*the_target->request_interrupt) ();
}
while (cc != '+');
@@ -927,10 +764,18 @@ input_interrupt (int unused)
cc = read_prim (&c, 1);
- if (cc != 1 || c != '\003' || current_inferior == NULL)
+ if (cc == 0)
{
- fprintf (stderr, "input_interrupt, count = %d c = %d ('%c')\n",
- cc, c, c);
+ fprintf (stderr, "client connection closed\n");
+ return;
+ }
+ else if (cc != 1 || c != '\003')
+ {
+ fprintf (stderr, "input_interrupt, count = %d c = %d ", cc, c);
+ if (isprint (c))
+ fprintf (stderr, "('%c')\n", c);
+ else
+ fprintf (stderr, "('\\x%02x')\n", c & 0xff);
return;
}
@@ -951,19 +796,19 @@ check_remote_input_interrupt_request (void)
input_interrupt (0);
}
-/* Asynchronous I/O support. SIGIO must be enabled when waiting, in order to
- accept Control-C from the client, and must be disabled when talking to
- the client. */
+/* Asynchronous I/O support. SIGIO must be unblocked when waiting,
+ in order to accept Control-C from the client, and must be blocked
+ when talking to the client. */
static void
-unblock_async_io (void)
+block_unblock_async_io (int block)
{
#ifndef USE_WIN32API
sigset_t sigio_set;
sigemptyset (&sigio_set);
sigaddset (&sigio_set, SIGIO);
- sigprocmask (SIG_UNBLOCK, &sigio_set, NULL);
+ gdb_sigmask (block ? SIG_BLOCK : SIG_UNBLOCK, &sigio_set, NULL);
#endif
}
@@ -999,9 +844,8 @@ enable_async_io (void)
if (async_io_enabled)
return;
-#ifndef USE_WIN32API
- signal (SIGIO, input_interrupt);
-#endif
+ block_unblock_async_io (0);
+
async_io_enabled = 1;
#ifdef __QNX__
nto_comctrl (1);
@@ -1015,9 +859,8 @@ disable_async_io (void)
if (!async_io_enabled)
return;
-#ifndef USE_WIN32API
- signal (SIGIO, SIG_IGN);
-#endif
+ block_unblock_async_io (1);
+
async_io_enabled = 0;
#ifdef __QNX__
nto_comctrl (0);
@@ -1028,12 +871,14 @@ disable_async_io (void)
void
initialize_async_io (void)
{
- /* Make sure that async I/O starts disabled. */
+ /* Make sure that async I/O starts blocked. */
async_io_enabled = 1;
disable_async_io ();
- /* Make sure the signal is unblocked. */
- unblock_async_io ();
+ /* Install the signal handler. */
+#ifndef USE_WIN32API
+ signal (SIGIO, input_interrupt);
+#endif
}
/* Internal buffer used by readchar.
@@ -1058,7 +903,10 @@ readchar (void)
if (readchar_bufcnt <= 0)
{
if (readchar_bufcnt == 0)
- fprintf (stderr, "readchar: Got EOF\n");
+ {
+ if (remote_debug)
+ debug_printf ("readchar: Got EOF\n");
+ }
else
perror ("readchar");
@@ -1121,6 +969,7 @@ reschedule (void)
int
getpkt (char *buf)
{
+ client_state &cs = get_client_state ();
char *bp;
unsigned char csum, c1, c2;
int c;
@@ -1132,12 +981,21 @@ getpkt (char *buf)
while (1)
{
c = readchar ();
+
+ /* The '\003' may appear before or after each packet, so
+ check for an input interrupt. */
+ if (c == '\003')
+ {
+ (*the_target->request_interrupt) ();
+ continue;
+ }
+
if (c == '$')
break;
if (remote_debug)
{
- fprintf (stderr, "[getpkt: discarding char '%c']\n", c);
- fflush (stderr);
+ debug_printf ("[getpkt: discarding char '%c']\n", c);
+ debug_flush ();
}
if (c < 0)
@@ -1163,7 +1021,7 @@ getpkt (char *buf)
if (csum == (c1 << 4) + c2)
break;
- if (noack_mode)
+ if (cs.noack_mode)
{
fprintf (stderr,
"Bad checksum, sentsum=0x%x, csum=0x%x, "
@@ -1179,12 +1037,12 @@ getpkt (char *buf)
return -1;
}
- if (!noack_mode)
+ if (!cs.noack_mode)
{
if (remote_debug)
{
- fprintf (stderr, "getpkt (\"%s\"); [sending ack] \n", buf);
- fflush (stderr);
+ debug_printf ("getpkt (\"%s\"); [sending ack] \n", buf);
+ debug_flush ();
}
if (write_prim ("+", 1) != 1)
@@ -1192,19 +1050,35 @@ getpkt (char *buf)
if (remote_debug)
{
- fprintf (stderr, "[sent ack]\n");
- fflush (stderr);
+ debug_printf ("[sent ack]\n");
+ debug_flush ();
}
}
else
{
if (remote_debug)
{
- fprintf (stderr, "getpkt (\"%s\"); [no ack sent] \n", buf);
- fflush (stderr);
+ debug_printf ("getpkt (\"%s\"); [no ack sent] \n", buf);
+ debug_flush ();
}
}
+ /* The readchar above may have already read a '\003' out of the socket
+ and moved it to the local buffer. For example, when GDB sends
+ vCont;c immediately followed by interrupt (see
+ gdb.base/interrupt-noterm.exp). As soon as we see the vCont;c, we'll
+ resume the inferior and wait. Since we've already moved the '\003'
+ to the local buffer, SIGIO won't help. In that case, if we don't
+ check for interrupt after the vCont;c packet, the interrupt character
+ would stay in the buffer unattended until after the next (unrelated)
+ stop. */
+ while (readchar_bufcnt > 0 && *readchar_bufp == '\003')
+ {
+ /* Consume the interrupt character in the buffer. */
+ readchar ();
+ (*the_target->request_interrupt) ();
+ }
+
return bp - buf;
}
@@ -1228,36 +1102,8 @@ write_enn (char *buf)
#endif
-void
-convert_int_to_ascii (const unsigned char *from, char *to, int n)
-{
- int nib;
- int ch;
- while (n--)
- {
- ch = *from++;
- nib = ((ch & 0xf0) >> 4) & 0x0f;
- *to++ = tohex (nib);
- nib = ch & 0x0f;
- *to++ = tohex (nib);
- }
- *to++ = 0;
-}
-
#ifndef IN_PROCESS_AGENT
-void
-convert_ascii_to_int (const char *from, unsigned char *to, int n)
-{
- int nib1, nib2;
- while (n--)
- {
- nib1 = fromhex (*from++);
- nib2 = fromhex (*from++);
- *to++ = (((nib1 & 0x0f) << 4) & 0xf0) | (nib2 & 0x0f);
- }
-}
-
static char *
outreg (struct regcache *regcache, int regno, char *buf)
{
@@ -1275,65 +1121,98 @@ outreg (struct regcache *regcache, int regno, char *buf)
return buf;
}
-void
-new_thread_notify (int id)
-{
- char own_buf[256];
-
- /* The `n' response is not yet part of the remote protocol. Do nothing. */
- if (1)
- return;
-
- if (server_waiting == 0)
- return;
-
- sprintf (own_buf, "n%x", id);
- disable_async_io ();
- putpkt (own_buf);
- enable_async_io ();
-}
-
-void
-dead_thread_notify (int id)
-{
- char own_buf[256];
-
- /* The `x' response is not yet part of the remote protocol. Do nothing. */
- if (1)
- return;
-
- sprintf (own_buf, "x%x", id);
- disable_async_io ();
- putpkt (own_buf);
- enable_async_io ();
-}
-
void
prepare_resume_reply (char *buf, ptid_t ptid,
struct target_waitstatus *status)
{
+ client_state &cs = get_client_state ();
if (debug_threads)
- fprintf (stderr, "Writing resume reply for %s:%d\n",
- target_pid_to_str (ptid), status->kind);
+ debug_printf ("Writing resume reply for %s:%d\n",
+ target_pid_to_str (ptid), status->kind);
switch (status->kind)
{
case TARGET_WAITKIND_STOPPED:
+ case TARGET_WAITKIND_FORKED:
+ case TARGET_WAITKIND_VFORKED:
+ case TARGET_WAITKIND_VFORK_DONE:
+ case TARGET_WAITKIND_EXECD:
+ case TARGET_WAITKIND_THREAD_CREATED:
+ case TARGET_WAITKIND_SYSCALL_ENTRY:
+ case TARGET_WAITKIND_SYSCALL_RETURN:
{
- struct thread_info *saved_inferior;
+ struct thread_info *saved_thread;
const char **regp;
struct regcache *regcache;
- sprintf (buf, "T%02x", status->value.sig);
+ if ((status->kind == TARGET_WAITKIND_FORKED && cs.report_fork_events)
+ || (status->kind == TARGET_WAITKIND_VFORKED
+ && cs.report_vfork_events))
+ {
+ enum gdb_signal signal = GDB_SIGNAL_TRAP;
+ const char *event = (status->kind == TARGET_WAITKIND_FORKED
+ ? "fork" : "vfork");
+
+ sprintf (buf, "T%02x%s:", signal, event);
+ buf += strlen (buf);
+ buf = write_ptid (buf, status->value.related_pid);
+ strcat (buf, ";");
+ }
+ else if (status->kind == TARGET_WAITKIND_VFORK_DONE
+ && cs.report_vfork_events)
+ {
+ enum gdb_signal signal = GDB_SIGNAL_TRAP;
+
+ sprintf (buf, "T%02xvforkdone:;", signal);
+ }
+ else if (status->kind == TARGET_WAITKIND_EXECD && cs.report_exec_events)
+ {
+ enum gdb_signal signal = GDB_SIGNAL_TRAP;
+ const char *event = "exec";
+ char hexified_pathname[PATH_MAX * 2];
+
+ sprintf (buf, "T%02x%s:", signal, event);
+ buf += strlen (buf);
+
+ /* Encode pathname to hexified format. */
+ bin2hex ((const gdb_byte *) status->value.execd_pathname,
+ hexified_pathname,
+ strlen (status->value.execd_pathname));
+
+ sprintf (buf, "%s;", hexified_pathname);
+ xfree (status->value.execd_pathname);
+ status->value.execd_pathname = NULL;
+ buf += strlen (buf);
+ }
+ else if (status->kind == TARGET_WAITKIND_THREAD_CREATED
+ && cs.report_thread_events)
+ {
+ enum gdb_signal signal = GDB_SIGNAL_TRAP;
+
+ sprintf (buf, "T%02xcreate:;", signal);
+ }
+ else if (status->kind == TARGET_WAITKIND_SYSCALL_ENTRY
+ || status->kind == TARGET_WAITKIND_SYSCALL_RETURN)
+ {
+ enum gdb_signal signal = GDB_SIGNAL_TRAP;
+ const char *event = (status->kind == TARGET_WAITKIND_SYSCALL_ENTRY
+ ? "syscall_entry" : "syscall_return");
+
+ sprintf (buf, "T%02x%s:%x;", signal, event,
+ status->value.syscall_number);
+ }
+ else
+ sprintf (buf, "T%02x", status->value.sig);
+
buf += strlen (buf);
- saved_inferior = current_inferior;
+ saved_thread = current_thread;
- current_inferior = find_thread_ptid (ptid);
+ switch_to_thread (the_target, ptid);
regp = current_target_desc ()->expedite_regs;
- regcache = get_thread_regcache (current_inferior, 1);
+ regcache = get_thread_regcache (current_thread, 1);
if (the_target->stopped_by_watchpoint != NULL
&& (*the_target->stopped_by_watchpoint) ())
@@ -1341,7 +1220,7 @@ prepare_resume_reply (char *buf, ptid_t ptid,
CORE_ADDR addr;
int i;
- strncpy (buf, "watch:", 6);
+ memcpy (buf, "watch:", 6);
buf += 6;
addr = (*the_target->stopped_data_address) ();
@@ -1354,6 +1233,16 @@ prepare_resume_reply (char *buf, ptid_t ptid,
*buf++ = tohex ((addr >> (i - 1) * 4) & 0xf);
*buf++ = ';';
}
+ else if (cs.swbreak_feature && target_stopped_by_sw_breakpoint ())
+ {
+ sprintf (buf, "swbreak:;");
+ buf += strlen (buf);
+ }
+ else if (cs.hwbreak_feature && target_stopped_by_hw_breakpoint ())
+ {
+ sprintf (buf, "hwbreak:;");
+ buf += strlen (buf);
+ }
while (*regp)
{
@@ -1377,13 +1266,13 @@ prepare_resume_reply (char *buf, ptid_t ptid,
in GDB will claim this event belongs to inferior_ptid
if we do not specify a thread, and there's no way for
gdbserver to know what inferior_ptid is. */
- if (1 || !ptid_equal (general_thread, ptid))
+ if (1 || cs.general_thread != ptid)
{
int core = -1;
/* In non-stop, don't change the general thread behind
GDB's back. */
if (!non_stop)
- general_thread = ptid;
+ cs.general_thread = ptid;
sprintf (buf, "thread:");
buf += strlen (buf);
buf = write_ptid (buf, ptid);
@@ -1410,23 +1299,31 @@ prepare_resume_reply (char *buf, ptid_t ptid,
dlls_changed = 0;
}
- current_inferior = saved_inferior;
+ current_thread = saved_thread;
}
break;
case TARGET_WAITKIND_EXITED:
- if (multi_process)
+ if (cs.multi_process)
sprintf (buf, "W%x;process:%x",
- status->value.integer, ptid_get_pid (ptid));
+ status->value.integer, ptid.pid ());
else
sprintf (buf, "W%02x", status->value.integer);
break;
case TARGET_WAITKIND_SIGNALLED:
- if (multi_process)
+ if (cs.multi_process)
sprintf (buf, "X%x;process:%x",
- status->value.sig, ptid_get_pid (ptid));
+ status->value.sig, ptid.pid ());
else
sprintf (buf, "X%02x", status->value.sig);
break;
+ case TARGET_WAITKIND_THREAD_EXITED:
+ sprintf (buf, "w%x;", status->value.integer);
+ buf += strlen (buf);
+ buf = write_ptid (buf, ptid);
+ break;
+ case TARGET_WAITKIND_NO_RESUMED:
+ sprintf (buf, "N");
+ break;
default:
error ("unhandled waitkind");
break;
@@ -1476,9 +1373,9 @@ decode_M_packet (char *from, CORE_ADDR *mem_addr_ptr, unsigned int *len_ptr,
}
if (*to_p == NULL)
- *to_p = xmalloc (*len_ptr);
+ *to_p = (unsigned char *) xmalloc (*len_ptr);
- convert_ascii_to_int (&from[i++], *to_p, *len_ptr);
+ hex2bin (&from[i++], *to_p, *len_ptr);
}
int
@@ -1502,7 +1399,7 @@ decode_X_packet (char *from, int packet_len, CORE_ADDR *mem_addr_ptr,
}
if (*to_p == NULL)
- *to_p = xmalloc (*len_ptr);
+ *to_p = (unsigned char *) xmalloc (*len_ptr);
if (remote_unescape_input ((const gdb_byte *) &from[i], packet_len - i,
*to_p, *len_ptr) != *len_ptr)
@@ -1585,7 +1482,8 @@ clear_symbol_cache (struct sym_cache **symcache_p)
int
look_up_one_symbol (const char *name, CORE_ADDR *addrp, int may_ask_gdb)
{
- char own_buf[266], *p, *q;
+ client_state &cs = get_client_state ();
+ char *p, *q;
int len;
struct sym_cache *sym;
struct process_info *proc;
@@ -1606,48 +1504,63 @@ look_up_one_symbol (const char *name, CORE_ADDR *addrp, int may_ask_gdb)
return 0;
/* Send the request. */
- strcpy (own_buf, "qSymbol:");
- hexify (own_buf + strlen ("qSymbol:"), name, strlen (name));
- if (putpkt (own_buf) < 0)
+ strcpy (cs.own_buf, "qSymbol:");
+ bin2hex ((const gdb_byte *) name, cs.own_buf + strlen ("qSymbol:"),
+ strlen (name));
+ if (putpkt (cs.own_buf) < 0)
return -1;
/* FIXME: Eventually add buffer overflow checking (to getpkt?) */
- len = getpkt (own_buf);
+ len = getpkt (cs.own_buf);
if (len < 0)
return -1;
/* We ought to handle pretty much any packet at this point while we
wait for the qSymbol "response". That requires re-entering the
main loop. For now, this is an adequate approximation; allow
- GDB to read from memory while it figures out the address of the
- symbol. */
- while (own_buf[0] == 'm')
+ GDB to read from memory and handle 'v' packets (for vFile transfers)
+ while it figures out the address of the symbol. */
+ while (1)
{
- CORE_ADDR mem_addr;
- unsigned char *mem_buf;
- unsigned int mem_len;
+ if (cs.own_buf[0] == 'm')
+ {
+ CORE_ADDR mem_addr;
+ unsigned char *mem_buf;
+ unsigned int mem_len;
- decode_m_packet (&own_buf[1], &mem_addr, &mem_len);
- mem_buf = xmalloc (mem_len);
- if (read_inferior_memory (mem_addr, mem_buf, mem_len) == 0)
- convert_int_to_ascii (mem_buf, own_buf, mem_len);
+ decode_m_packet (&cs.own_buf[1], &mem_addr, &mem_len);
+ mem_buf = (unsigned char *) xmalloc (mem_len);
+ if (read_inferior_memory (mem_addr, mem_buf, mem_len) == 0)
+ bin2hex (mem_buf, cs.own_buf, mem_len);
+ else
+ write_enn (cs.own_buf);
+ free (mem_buf);
+ if (putpkt (cs.own_buf) < 0)
+ return -1;
+ }
+ else if (cs.own_buf[0] == 'v')
+ {
+ int new_len = -1;
+ handle_v_requests (cs.own_buf, len, &new_len);
+ if (new_len != -1)
+ putpkt_binary (cs.own_buf, new_len);
+ else
+ putpkt (cs.own_buf);
+ }
else
- write_enn (own_buf);
- free (mem_buf);
- if (putpkt (own_buf) < 0)
- return -1;
- len = getpkt (own_buf);
+ break;
+ len = getpkt (cs.own_buf);
if (len < 0)
return -1;
}
- if (strncmp (own_buf, "qSymbol:", strlen ("qSymbol:")) != 0)
+ if (!startswith (cs.own_buf, "qSymbol:"))
{
- warning ("Malformed response to qSymbol, ignoring: %s\n", own_buf);
+ warning ("Malformed response to qSymbol, ignoring: %s", cs.own_buf);
return -1;
}
- p = own_buf + strlen ("qSymbol:");
+ p = cs.own_buf + strlen ("qSymbol:");
q = p;
while (*q && *q != ':')
q++;
@@ -1659,7 +1572,7 @@ look_up_one_symbol (const char *name, CORE_ADDR *addrp, int may_ask_gdb)
decode_address (addrp, p, q - p);
/* Save the symbol in our cache. */
- sym = xmalloc (sizeof (*sym));
+ sym = XNEW (struct sym_cache);
sym->name = xstrdup (name);
sym->addr = *addrp;
sym->next = proc->symbol_cache;
@@ -1683,19 +1596,18 @@ look_up_one_symbol (const char *name, CORE_ADDR *addrp, int may_ask_gdb)
int
relocate_instruction (CORE_ADDR *to, CORE_ADDR oldloc)
{
- char own_buf[266];
+ client_state &cs = get_client_state ();
int len;
ULONGEST written = 0;
/* Send the request. */
- strcpy (own_buf, "qRelocInsn:");
- sprintf (own_buf, "qRelocInsn:%s;%s", paddress (oldloc),
+ sprintf (cs.own_buf, "qRelocInsn:%s;%s", paddress (oldloc),
paddress (*to));
- if (putpkt (own_buf) < 0)
+ if (putpkt (cs.own_buf) < 0)
return -1;
/* FIXME: Eventually add buffer overflow checking (to getpkt?) */
- len = getpkt (own_buf);
+ len = getpkt (cs.own_buf);
if (len < 0)
return -1;
@@ -1703,61 +1615,61 @@ relocate_instruction (CORE_ADDR *to, CORE_ADDR oldloc)
wait for the qRelocInsn "response". That requires re-entering
the main loop. For now, this is an adequate approximation; allow
GDB to access memory. */
- while (own_buf[0] == 'm' || own_buf[0] == 'M' || own_buf[0] == 'X')
+ while (cs.own_buf[0] == 'm' || cs.own_buf[0] == 'M' || cs.own_buf[0] == 'X')
{
CORE_ADDR mem_addr;
unsigned char *mem_buf = NULL;
unsigned int mem_len;
- if (own_buf[0] == 'm')
+ if (cs.own_buf[0] == 'm')
{
- decode_m_packet (&own_buf[1], &mem_addr, &mem_len);
- mem_buf = xmalloc (mem_len);
+ decode_m_packet (&cs.own_buf[1], &mem_addr, &mem_len);
+ mem_buf = (unsigned char *) xmalloc (mem_len);
if (read_inferior_memory (mem_addr, mem_buf, mem_len) == 0)
- convert_int_to_ascii (mem_buf, own_buf, mem_len);
+ bin2hex (mem_buf, cs.own_buf, mem_len);
else
- write_enn (own_buf);
+ write_enn (cs.own_buf);
}
- else if (own_buf[0] == 'X')
+ else if (cs.own_buf[0] == 'X')
{
- if (decode_X_packet (&own_buf[1], len - 1, &mem_addr,
+ if (decode_X_packet (&cs.own_buf[1], len - 1, &mem_addr,
&mem_len, &mem_buf) < 0
- || write_inferior_memory (mem_addr, mem_buf, mem_len) != 0)
- write_enn (own_buf);
+ || target_write_memory (mem_addr, mem_buf, mem_len) != 0)
+ write_enn (cs.own_buf);
else
- write_ok (own_buf);
+ write_ok (cs.own_buf);
}
else
{
- decode_M_packet (&own_buf[1], &mem_addr, &mem_len, &mem_buf);
- if (write_inferior_memory (mem_addr, mem_buf, mem_len) == 0)
- write_ok (own_buf);
+ decode_M_packet (&cs.own_buf[1], &mem_addr, &mem_len, &mem_buf);
+ if (target_write_memory (mem_addr, mem_buf, mem_len) == 0)
+ write_ok (cs.own_buf);
else
- write_enn (own_buf);
+ write_enn (cs.own_buf);
}
free (mem_buf);
- if (putpkt (own_buf) < 0)
+ if (putpkt (cs.own_buf) < 0)
return -1;
- len = getpkt (own_buf);
+ len = getpkt (cs.own_buf);
if (len < 0)
return -1;
}
- if (own_buf[0] == 'E')
+ if (cs.own_buf[0] == 'E')
{
- warning ("An error occurred while relocating an instruction: %s\n",
- own_buf);
+ warning ("An error occurred while relocating an instruction: %s",
+ cs.own_buf);
return -1;
}
- if (strncmp (own_buf, "qRelocInsn:", strlen ("qRelocInsn:")) != 0)
+ if (!startswith (cs.own_buf, "qRelocInsn:"))
{
- warning ("Malformed response to qRelocInsn, ignoring: %s\n",
- own_buf);
+ warning ("Malformed response to qRelocInsn, ignoring: %s",
+ cs.own_buf);
return -1;
}
- unpack_varlen_hex (own_buf + strlen ("qRelocInsn:"), &written);
+ unpack_varlen_hex (cs.own_buf + strlen ("qRelocInsn:"), &written);
*to += written;
return 0;
@@ -1766,10 +1678,11 @@ relocate_instruction (CORE_ADDR *to, CORE_ADDR oldloc)
void
monitor_output (const char *msg)
{
- char *buf = xmalloc (strlen (msg) * 2 + 2);
+ int len = strlen (msg);
+ char *buf = (char *) xmalloc (len * 2 + 2);
buf[0] = 'O';
- hexify (buf + 1, msg, 0);
+ bin2hex ((const gdb_byte *) msg, buf + 1, len);
putpkt (buf);
free (buf);