From f046eb982627f344fc0eeff6be82028318862e67 Mon Sep 17 00:00:00 2001 From: David Robillard Date: Tue, 15 Mar 2016 23:21:34 -0400 Subject: Use SerdBuffer for mutable buffers This avoids const violations from abusing SerdChunk as a mutable buffer for string sinks. --- NEWS | 14 ++++++++++++++ serd/serd.h | 20 ++++++++++++++------ src/node.c | 17 +++++++++-------- src/uri.c | 10 +++++----- src/writer.c | 14 +++++++------- tests/serd_test.c | 10 +++++----- wscript | 4 ++-- 7 files changed, 56 insertions(+), 33 deletions(-) diff --git a/NEWS b/NEWS index a630680e..44bb1688 100644 --- a/NEWS +++ b/NEWS @@ -1,3 +1,17 @@ +serd (1.0.0) unstable; + + * Use SerdBuffer for mutable buffers instead of abusing SerdChunk + * Add serd_node_new_relative_uri() + * Fix construction and comparison of URIs with UTF-8 characters + * Report I/O errors with message and return appropriate status code + * Report missing statement separator errors + * Fix potential out of bounds read + * Fix unaligned memory access, undefined behaviour which breaks on ARM + * Fix documentation generation + * Update serdi man page + + -- David Robillard Mon, 10 Jul 2017 11:28:59 +0200 + serd (0.30.1) unstable; * Fix GCC 4 build diff --git a/serd/serd.h b/serd/serd.h index 49a516fa..105b80a9 100644 --- a/serd/serd.h +++ b/serd/serd.h @@ -230,6 +230,14 @@ typedef struct { size_t len; /**< Length of chunk in bytes */ } SerdChunk; +/** + A mutable buffer in memory. +*/ +typedef struct { + void* buf; /**< Buffer */ + size_t len; /**< Size of buffer in bytes */ +} SerdBuffer; + /** An error description. */ @@ -972,24 +980,24 @@ serd_file_sink(const void* buf, size_t len, void* stream); /** A convenience sink function for writing to a string. - This function can be used as a SerdSink to write to a SerdChunk which is + This function can be used as a SerdSink to write to a SerdBuffer which is resized as necessary with realloc(). The `stream` parameter must point to - an initialized SerdChunk. When the write is finished, the string should be - retrieved with serd_chunk_sink_finish(). + an initialized SerdBuffer. When the write is finished, the string should be + retrieved with serd_buffer_sink_finish(). */ SERD_API size_t -serd_chunk_sink(const void* buf, size_t len, void* stream); +serd_buffer_sink(const void* buf, size_t len, void* stream); /** - Finish a serialisation to a chunk with serd_chunk_sink(). + Finish a serialisation to a chunk with serd_buffer_sink(). The returned string is the result of the serialisation, which is NULL terminated (by this function) and owned by the caller. */ SERD_API uint8_t* -serd_chunk_sink_finish(SerdChunk* stream); +serd_buffer_sink_finish(SerdBuffer* stream); /** Set a function to be called when errors occur during writing. diff --git a/src/node.c b/src/node.c index 92bf3bde..20f67fda 100644 --- a/src/node.c +++ b/src/node.c @@ -176,27 +176,28 @@ serd_node_new_file_uri(const uint8_t* path, evil ? "/" : ""); } - SerdChunk chunk = { uri, uri_len }; + SerdBuffer buffer = { uri, uri_len }; for (size_t i = 0; i < path_len; ++i) { if (evil && path[i] == '\\') { - serd_chunk_sink("/", 1, &chunk); + serd_buffer_sink("/", 1, &buffer); } else if (path[i] == '%') { - serd_chunk_sink("%%", 2, &chunk); + serd_buffer_sink("%%", 2, &buffer); } else if (!escape || is_uri_path_char(path[i])) { - serd_chunk_sink(path + i, 1, &chunk); + serd_buffer_sink(path + i, 1, &buffer); } else { char escape_str[4] = { '%', 0, 0, 0 }; snprintf(escape_str + 1, sizeof(escape_str) - 1, "%X", path[i]); - serd_chunk_sink(escape_str, 3, &chunk); + serd_buffer_sink(escape_str, 3, &buffer); } } - serd_chunk_sink_finish(&chunk); + serd_buffer_sink_finish(&buffer); if (out) { - serd_uri_parse(chunk.buf, out); + serd_uri_parse((const uint8_t*)buffer.buf, out); } - return serd_node_from_substring(SERD_URI, chunk.buf, chunk.len); + return serd_node_from_substring( + SERD_URI, (const uint8_t*)buffer.buf, buffer.len); } SerdNode diff --git a/src/uri.c b/src/uri.c index 70b13717..f4f8580e 100644 --- a/src/uri.c +++ b/src/uri.c @@ -70,25 +70,25 @@ serd_file_uri_parse(const uint8_t* uri, uint8_t** hostname) ++path; } - SerdChunk chunk = { NULL, 0 }; + SerdBuffer buffer = { NULL, 0 }; for (const uint8_t* s = path; *s; ++s) { if (*s == '%') { if (*(s + 1) == '%') { - serd_chunk_sink("%", 1, &chunk); + serd_buffer_sink("%", 1, &buffer); ++s; } else if (is_hexdig(*(s + 1)) && is_hexdig(*(s + 2))) { const uint8_t code[3] = {*(s + 1), *(s + 2), 0}; const uint8_t c = (uint8_t)strtoul((const char*)code, NULL, 16); - serd_chunk_sink(&c, 1, &chunk); + serd_buffer_sink(&c, 1, &buffer); s += 2; } else { s += 2; // Junk escape, ignore } } else { - serd_chunk_sink(s, 1, &chunk); + serd_buffer_sink(s, 1, &buffer); } } - return serd_chunk_sink_finish(&chunk); + return serd_buffer_sink_finish(&buffer); } bool diff --git a/src/writer.c b/src/writer.c index 69a00d82..00e5bf57 100644 --- a/src/writer.c +++ b/src/writer.c @@ -977,18 +977,18 @@ serd_file_sink(const void* buf, size_t len, void* stream) } size_t -serd_chunk_sink(const void* buf, size_t len, void* stream) +serd_buffer_sink(const void* buf, size_t len, void* stream) { - SerdChunk* chunk = (SerdChunk*)stream; - chunk->buf = (uint8_t*)realloc((uint8_t*)chunk->buf, chunk->len + len); - memcpy((uint8_t*)chunk->buf + chunk->len, buf, len); - chunk->len += len; + SerdBuffer* buffer = (SerdBuffer*)stream; + buffer->buf = (char*)realloc(buffer->buf, buffer->len + len); + memcpy((uint8_t*)buffer->buf + buffer->len, buf, len); + buffer->len += len; return len; } uint8_t* -serd_chunk_sink_finish(SerdChunk* stream) +serd_buffer_sink_finish(SerdBuffer* stream) { - serd_chunk_sink("", 1, stream); + serd_buffer_sink("", 1, stream); return (uint8_t*)stream->buf; } diff --git a/tests/serd_test.c b/tests/serd_test.c index 4997629f..0ffcdf51 100644 --- a/tests/serd_test.c +++ b/tests/serd_test.c @@ -602,10 +602,10 @@ main(void) serd_writer_free(writer); - // Test chunk sink - SerdChunk chunk = { NULL, 0 }; + // Test buffer sink + SerdBuffer buffer = { NULL, 0 }; writer = serd_writer_new( - SERD_TURTLE, (SerdStyle)0, env, NULL, serd_chunk_sink, &chunk); + SERD_TURTLE, (SerdStyle)0, env, NULL, serd_buffer_sink, &buffer); o = serd_node_from_string(SERD_URI, USTR("http://example.org/base")); if (serd_writer_set_base_uri(writer, &o)) { @@ -613,10 +613,10 @@ main(void) } serd_writer_free(writer); - uint8_t* out = serd_chunk_sink_finish(&chunk); + uint8_t* out = serd_buffer_sink_finish(&buffer); if (strcmp((const char*)out, "@base .\n")) { - FAILF("Incorrect chunk output:\n%s\n", chunk.buf); + FAILF("Incorrect buffer output:\n%s\n", buffer.buf); } serd_free(out); diff --git a/wscript b/wscript index 03a86172..5cbffae0 100644 --- a/wscript +++ b/wscript @@ -10,8 +10,8 @@ from waflib.extras import autowaf # major increment <=> incompatible changes # minor increment <=> compatible changes (additions) # micro increment <=> no interface changes -SERD_VERSION = '0.30.1' -SERD_MAJOR_VERSION = '0' +SERD_VERSION = '1.0.0' +SERD_MAJOR_VERSION = '1' # Mandatory waf variables APPNAME = 'serd' # Package name for waf dist -- cgit v1.2.1