Re: [PATCH] zero-terminate result of target_read_alloc

Daniel Jacobowitz
2006-07-27T21:25:49Z

On Thu, Jul 27, 2006 at 12:34:06AM +0200, Mark Kettenis wrote:
> Sure

Checked in as so.

--
Daniel Jacobowitz
CodeSourcery

2006-07-27 Daniel Jacobowitz <dan@codesourcery.com>

* target.h (target_read_stralloc): New prototype.
* target.c (target_read_alloc_1): Renamed from target_read_alloc.
Take new PADDING argument.
(target_read_alloc): Use it.
(target_read_stralloc): New function.

Index: target.c
===================================================================
RCS file: /cvs/src/src/gdb/target.c,v
retrieving revision 1.121
diff -u -p -r1.121 target.c
--- target.c 18 Jul 2006 12:44:48 -0000 1.121
+++ target.c 27 Jul 2006 21:23:13 -0000
@@ -1406,22 +1406,15 @@ target_write (struct target_ops *ops,
return len;
}

-/* Wrapper to perform a full read of unknown size. OBJECT/ANNEX will
- be read using OPS. The return value will be -1 if the transfer
- fails or is not supported; 0 if the object is empty; or the length
- of the object otherwise. If a positive value is returned, a
- sufficiently large buffer will be allocated using xmalloc and
- returned in *BUF_P containing the contents of the object.
-
- This method should be used for objects sufficiently small to store
- in a single xmalloc'd buffer, when no fixed bound on the object's
- size is known in advance. Don't try to read TARGET_OBJECT_MEMORY
- through this function. */
-
-LONGEST
-target_read_alloc (struct target_ops *ops,
- enum target_object object,
- const char *annex, gdb_byte **buf_p)
+/* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
+ the size of the transferred data. PADDING additional bytes are
+ available in *BUF_P. This is a helper function for
+ target_read_alloc; see the declaration of that function for more
+ information. */
+
+static LONGEST
+target_read_alloc_1 (struct target_ops *ops, enum target_object object,
+ const char *annex, gdb_byte **buf_p, int padding)
{
size_t buf_alloc, buf_pos;
gdb_byte *buf;
@@ -1442,7 +1435,7 @@ target_read_alloc (struct target_ops *op
while (1)
{
n = target_read_partial (ops, object, annex, &buf[buf_pos],
- buf_pos, buf_alloc - buf_pos);
+ buf_pos, buf_alloc - buf_pos - padding);
if (n < 0)
{
/* An error occurred. */
@@ -1472,6 +1465,47 @@ target_read_alloc (struct target_ops *op
}
}

+/* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
+ the size of the transferred data. See the declaration in "target.h"
+ function for more information about the return value. */
+
+LONGEST
+target_read_alloc (struct target_ops *ops, enum target_object object,
+ const char *annex, gdb_byte **buf_p)
+{
+ return target_read_alloc_1 (ops, object, annex, buf_p, 0);
+}
+
+/* Read OBJECT/ANNEX using OPS. The result is NUL-terminated and
+ returned as a string, allocated using xmalloc. If an error occurs
+ or the transfer is unsupported, NULL is returned. Empty objects
+ are returned as allocated but empty strings. A warning is issued
+ if the result contains any embedded NUL bytes. */
+
+char *
+target_read_stralloc (struct target_ops *ops, enum target_object object,
+ const char *annex)
+{
+ gdb_byte *buffer;
+ LONGEST transferred;
+
+ transferred = target_read_alloc_1 (ops, object, annex, &buffer, 1);
+
+ if (transferred < 0)
+ return NULL;
+
+ if (transferred == 0)
+ return xstrdup ("");
+
+ buffer[transferred] = 0;
+ if (strlen (buffer) < transferred)
+ warning (_("target object %d, annex %s, "
+ "contained unexpected null characters"),
+ (int) object, annex ? annex : "(none)");
+
+ return (char *) buffer;
+}
+
/* Memory transfer methods. */

void
Index: target.h
===================================================================
RCS file: /cvs/src/src/gdb/target.h,v
retrieving revision 1.85
diff -u -p -r1.85 target.h
--- target.h 12 Jul 2006 18:13:45 -0000 1.85
+++ target.h 27 Jul 2006 21:23:13 -0000
@@ -236,6 +236,16 @@ extern LONGEST target_read_alloc (struct
enum target_object object,
const char *annex, gdb_byte **buf_p);

+/* Read OBJECT/ANNEX using OPS. The result is NUL-terminated and
+ returned as a string, allocated using xmalloc. If an error occurs
+ or the transfer is unsupported, NULL is returned. Empty objects
+ are returned as allocated but empty strings. A warning is issued
+ if the result contains any embedded NUL bytes. */
+
+extern char *target_read_stralloc (struct target_ops *ops,
+ enum target_object object,
+ const char *annex);
+
/* Wrappers to target read/write that perform memory transfers. They
throw an error if the memory transfer fails.