*** empty log message ***

[deliverable/binutils-gdb.git] / gdb / gdbserver / remote-utils.c

diff --git a/gdb/gdbserver/remote-utils.c b/gdb/gdbserver/remote-utils.c
index 505e37c907d2f1847815de25f320cf967558c683..667ac2d8d77829b78cc49b0b1a9624b9ccd6a7e1 100644 (file)
--- a/gdb/gdbserver/remote-utils.c
+++ b/gdb/gdbserver/remote-utils.c
@@ -6,7 +6,7 @@
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2 of the License, or
+   the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
@@ -15,9 +15,7 @@
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 51 Franklin Street, Fifth Floor,
-   Boston, MA 02110-1301, USA.  */
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include "server.h"
 #include "terminal.h"
@@ -246,7 +244,8 @@ remote_open (char *name)
 
       /* Enable TCP keep alive process. */
       tmp = 1;
-      setsockopt (tmp_desc, SOL_SOCKET, SO_KEEPALIVE, (char *) &tmp, sizeof (tmp));
+      setsockopt (remote_desc, SOL_SOCKET, SO_KEEPALIVE,
+                 (char *) &tmp, sizeof (tmp));
 
       /* Tell TCP not to delay small packets.  This greatly speeds up
          interactive response. */
@@ -548,6 +547,7 @@ putpkt_binary (char *buf, int cnt)
       if (write (remote_desc, buf2, p - buf2) != p - buf2)
        {
          perror ("putpkt(write)");
+         free (buf2);
          return -1;
        }
 
@@ -965,6 +965,13 @@ prepare_resume_reply (char *buf, char status, unsigned char sig)
              old_thread_from_wait = thread_from_wait;
            }
        }
+
+      if (dlls_changed)
+       {
+         strcpy (buf, "library:;");
+         buf += strlen (buf);
+         dlls_changed = 0;
+       }
     }
   /* For W and X, we're done.  */
   *buf++ = 0;
@@ -1042,6 +1049,36 @@ decode_X_packet (char *from, int packet_len, CORE_ADDR *mem_addr_ptr,
   return 0;
 }
 
+/* Decode a qXfer write request.  */
+int
+decode_xfer_write (char *buf, int packet_len, char **annex, CORE_ADDR *offset,
+                  unsigned int *len, unsigned char *data)
+{
+  char ch;
+
+  /* Extract and NUL-terminate the annex.  */
+  *annex = buf;
+  while (*buf && *buf != ':')
+    buf++;
+  if (*buf == '\0')
+    return -1;
+  *buf++ = 0;
+
+  /* Extract the offset.  */
+  *offset = 0;
+  while ((ch = *buf++) != ':')
+    {
+      *offset = *offset << 4;
+      *offset |= fromhex (ch) & 0x0f;
+    }
+
+  /* Get encoded data.  */
+  packet_len -= buf - *annex;
+  *len = remote_unescape_input ((const gdb_byte *) buf, packet_len,
+                               data, packet_len);
+  return 0;
+}
+
 /* Ask GDB for the address of NAME, and return it in ADDRP if found.
    Returns 1 if the symbol is found, 0 if it is not, -1 on error.  */
 
@@ -1079,15 +1116,34 @@ look_up_one_symbol (const char *name, CORE_ADDR *addrp)
   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')
+    {
+      CORE_ADDR mem_addr;
+      unsigned char *mem_buf;
+      unsigned int mem_len;
+
+      decode_m_packet (&own_buf[1], &mem_addr, &mem_len);
+      mem_buf = malloc (mem_len);
+      if (read_inferior_memory (mem_addr, mem_buf, mem_len) == 0)
+       convert_int_to_ascii (mem_buf, own_buf, mem_len);
+      else
+       write_enn (own_buf);
+      free (mem_buf);
+      if (putpkt (own_buf) < 0)
+       return -1;
+      len = getpkt (own_buf);
+      if (len < 0)
+       return -1;
+    }
+  
   if (strncmp (own_buf, "qSymbol:", strlen ("qSymbol:")) != 0)
     {
-      /* Malformed response.  */
-      if (remote_debug)
-       {
-         fprintf (stderr, "Malformed response to qSymbol, ignoring.\n");
-         fflush (stderr);
-       }
-
+      warning ("Malformed response to qSymbol, ignoring: %s\n", own_buf);
       return -1;
     }
 
@@ -1123,3 +1179,65 @@ monitor_output (const char *msg)
   putpkt (buf);
   free (buf);
 }
+
+/* Return a malloc allocated string with special characters from TEXT
+   replaced by entity references.  */
+
+char *
+xml_escape_text (const char *text)
+{
+  char *result;
+  int i, special;
+
+  /* Compute the length of the result.  */
+  for (i = 0, special = 0; text[i] != '\0'; i++)
+    switch (text[i])
+      {
+      case '\'':
+      case '\"':
+       special += 5;
+       break;
+      case '&':
+       special += 4;
+       break;
+      case '<':
+      case '>':
+       special += 3;
+       break;
+      default:
+       break;
+      }
+
+  /* Expand the result.  */
+  result = malloc (i + special + 1);
+  for (i = 0, special = 0; text[i] != '\0'; i++)
+    switch (text[i])
+      {
+      case '\'':
+       strcpy (result + i + special, "&apos;");
+       special += 5;
+       break;
+      case '\"':
+       strcpy (result + i + special, "&quot;");
+       special += 5;
+       break;
+      case '&':
+       strcpy (result + i + special, "&amp;");
+       special += 4;
+       break;
+      case '<':
+       strcpy (result + i + special, "&lt;");
+       special += 3;
+       break;
+      case '>':
+       strcpy (result + i + special, "&gt;");
+       special += 3;
+       break;
+      default:
+       result[i + special] = text[i];
+       break;
+      }
+  result[i + special] = '\0';
+
+  return result;
+}