+++ /dev/null
-/*
- * Copyright (C) Internet Systems Consortium, Inc. ("ISC")
- *
- * SPDX-License-Identifier: MPL-2.0
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, you can obtain one at https://mozilla.org/MPL/2.0/.
- *
- * See the COPYRIGHT file distributed with this work for additional
- * information regarding copyright ownership.
- */
-
-#pragma once
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <string.h>
-
-#include <isc/buffer.h>
-#include <isc/mem.h>
-#include <isc/region.h>
-#include <isc/util.h>
-
-#define ISC_DNSBUFFER_STATIC_BUFFER_SIZE (512)
-#define ISC_DNSBUFFER_INITIAL_DYNAMIC_BUFFER_SIZE (ISC_BUFFER_INCR * 2)
-
-typedef struct isc_dnsbuffer {
- isc_buffer_t *current; /* pointer to the currently used buffer */
- isc_buffer_t stbuf; /* static memory buffer */
- uint8_t buf[ISC_DNSBUFFER_STATIC_BUFFER_SIZE]; /* storage for the static
- buffer */
- isc_buffer_t *dynbuf; /* resizeable dynamic memory buffer */
- isc_mem_t *mctx;
-} isc_dnsbuffer_t;
-/*
- * The 'isc_dnsbuffer_t' object implementation is a thin wrapper on
- * top of 'isc_buffer_t' which has the following characteristics:
- *
- * - provides interface specifically atuned for handling/generating
- * DNS messages, especially in the format used for DNS messages over
- * TCP;
- *
- * - avoids allocating dynamic memory when handling small DNS
- * messages, while transparently switching to using dynamic memory
- * when handling larger messages. This approach significantly
- * reduces pressure on the memory allocator, as most of the DNS
- * messages are small.
- */
-
-static inline void
-isc_dnsbuffer_init(isc_dnsbuffer_t *restrict dnsbuf, isc_mem_t *memctx);
-/*!<
- * \brief Initialise the 'isc_dnsbuffer_t' object, keep a reference to
- * 'memctx' inside the object.
- *
- * Requires:
- *\li 'dnsbuf' is not NULL;
- *\li 'memctx' is not NULL.
- */
-
-static inline void
-isc_dnsbuffer_uninit(isc_dnsbuffer_t *restrict dnsbuf);
-/*!<
- * \brief Un-initialise the 'isc_dnsbuffer_t' object, de-allocate any
- *dynamically allocated memory, detach from an internal memory context
- * reference.
- *
- * Requires:
- *\li 'dnsbuf' is not NULL.
- */
-
-static inline isc_dnsbuffer_t *
-isc_dnsbuffer_new(isc_mem_t *memctx);
-/*!<
- * \brief Allocate and initialise a new 'isc_dnsbuffer_t' object, keep a
- * reference to 'memctx' inside the object.
- *
- * Requires:
- *\li 'dnsbuf' is not NULL;
- *\li 'memctx' is not NULL.
- */
-
-static inline void
-isc_dnsbuffer_free(isc_dnsbuffer_t **restrict pdnsbuf);
-/*!<
- * \brief Un-initialise and de-allocate the given 'isc_dnsbuffer_t' object.
- *
- * Requires:
- *\li 'pdnsbuf' is not NULL;
- *\li 'pdnsbuf' does not point to NULL.
- */
-
-static inline void
-isc_dnsbuffer_clear(isc_dnsbuffer_t *restrict dnsbuf);
-/*!<
- * \brief Clear the given 'isc_dnsbuffer_t' object (make it empty).
- *
- * Requires:
- *\li 'dnsbuf' is not NULL.
- */
-
-static inline unsigned int
-isc_dnsbuffer_length(const isc_dnsbuffer_t *restrict dnsbuf);
-/*!<
- * \brief Return the total length of the internal memory buffer of
- * the given 'isc_dnsbuffer_t' object.
- *
- * Requires:
- *\li 'dnsbuf' is not NULL.
- */
-
-static inline unsigned int
-isc_dnsbuffer_usedlength(const isc_dnsbuffer_t *restrict dnsbuf);
-/*!<
- * \brief Return the total number of used bytes from the internal
- * memory buffer of the given 'isc_dnsbuffer_t' object.
- *
- * Requires:
- *\li 'dnsbuf' is not NULL.
- */
-
-static inline unsigned int
-isc_dnsbuffer_remaininglength(const isc_dnsbuffer_t *restrict dnsbuf);
-/*!<
- * \brief Return the total number of remaining (unprocessed data)
- * bytes from the internal memory buffer of the given
- * 'isc_dnsbuffer_t' object.
- *
- * Requires:
- *\li 'dnsbuf' is not NULL.
- */
-
-static inline void
-isc_dnsbuffer_remainingregion(const isc_dnsbuffer_t *restrict dnsbuf,
- isc_region_t *region);
-/*!<
- * \brief Make the given 'isc_region_t' object reference remaining
- * (unprocessed) data from the internal memory buffer of the given
- * 'isc_dnsbuffer_t' object.
- *
- * Requires:
- *\li 'dnsbuf' is not NULL.
- */
-
-static inline void
-isc_dnsbuffer_compact(const isc_dnsbuffer_t *restrict dnsbuf);
-/*!<
- * \brief Compact the internal used memory region of the internal
- * memory buffer of the given 'isc_dnsbuffer_t' object so that it
- * occurs at the start of the memory buffer. Then used region is
- * shrunk by the size of the processed (consumed) region, and the
- * consumed region is then made empty. This way the previously
- * processed (consumed) amount of memory can be used again without
- * resizing/reallocating the buffer.
- *
- * Requires:
- *\li 'dnsbuf' is not NULL.
- */
-
-static inline bool
-isc_dnsbuffer_trycompact(const isc_dnsbuffer_t *restrict dnsbuf);
-/*!<
- * \brief Compact the internal used memory region of the internal
- * memory buffer of the given 'isc_dnsbuffer_t' object in the case
- * when the processed (consumed) region is larger or equal in size to
- * the unprocessed one.
- *
- * Requires:
- *\li 'dnsbuf' is not NULL.
- */
-
-static inline void
-isc_dnsbuffer_consume(isc_dnsbuffer_t *restrict dnsbuf, const unsigned int n);
-/*!<
- * \brief Consume the given number of bytes from the beginning of
- * the unprocessed data region of the given 'isc_dnsbuffer_t' object.
- * The call moves the 'current' unprocessed data region pointer by the
- * given number of bytes.
- *
- * Requires:
- *\li 'dnsbuf' is not NULL.
- */
-
-static inline void
-isc_dnsbuffer_putmem(isc_dnsbuffer_t *restrict dnsbuf, void *buf,
- const unsigned int buf_size);
-/*!<
- * \brief Copy 'buf_size' bytes from the location pointed to by
- * 'buf' pointer to the end of the unprocessed data region of the
- * given 'isc_dnsbuffer_t' object. Resize/reallocate the internal
- * memory buffer if it is too small.
- *
- * Requires:
- *\li 'dnsbuf' is not NULL;
- *\li 'buf' is not NULL;
- *\li 'buf_size' is greater than '0'.
- */
-
-static inline uint8_t *
-isc_dnsbuffer_current(const isc_dnsbuffer_t *restrict dnsbuf);
-/*!<
- * \brief Return the pointer to the beginning of unprocessed data
- * region of the given 'isc_dnsbuffer_t' object ("current pointer").
- *
- * Requires:
- *\li 'dnsbuf' is not NULL.
- */
-
-static inline uint16_t
-isc_dnsbuffer_peek_uint16be(const isc_dnsbuffer_t *restrict dnsbuf);
-/*!<
- * \brief Lookup an unsigned short (16-bit) value in
- * big-endian/network byte order at the beginning of unprocessed data
- * region of the given 'isc_dnsbuffer_t' object.
- *
- * If there is not enough data available in the region, '0' will be
- * returned.
- *
- * Requires:
- *\li 'dnsbuf' is not NULL.
- */
-
-static inline uint16_t
-isc_dnsbuffer_consume_uint16be(isc_dnsbuffer_t *restrict dnsbuf);
-/*!<
- * \brief Read an unsigned short (16-bit) value in
- * big-endian/network byte order at the beginning of unprocessed data
- * region of the given 'isc_dnsbuffer_t' object.
- *
- * If there is not enough data available in the region, '0' will be
- * returned.
- *
- * In the case, when the data has been read successfully, the start of
- * the unprocessed data region is advanced by two bytes.
- *
- * Requires:
- *\li 'dnsbuf' is not NULL.
- */
-
-static inline void
-isc_dnsbuffer_putmem_uint16be(isc_dnsbuffer_t *restrict dnsbuf,
- const uint16_t v);
-/*!<
- * \brief Append a given unsigned short (16-bit) value 'v' converted
- * into big-endian/network byte order at the end of unprocessed data
- * region of the given 'isc_dnsbuffer_t' object. Resize/reallocate the
- * internal memory buffer if it is too small to hold the appended data.
- *
- * Requires:
- *\li 'dnsbuf' is not NULL.
- */
-
-static inline void
-isc_dnsbuffer_init(isc_dnsbuffer_t *restrict dnsbuf, isc_mem_t *memctx) {
- REQUIRE(dnsbuf != NULL);
- REQUIRE(memctx != NULL);
- *dnsbuf = (isc_dnsbuffer_t){ .current = &dnsbuf->stbuf };
- isc_buffer_init(&dnsbuf->stbuf, &dnsbuf->buf[0], sizeof(dnsbuf->buf));
- isc_mem_attach(memctx, &dnsbuf->mctx);
-}
-
-static inline void
-isc_dnsbuffer_uninit(isc_dnsbuffer_t *restrict dnsbuf) {
- REQUIRE(dnsbuf != NULL);
- isc_buffer_clear(&dnsbuf->stbuf);
- if (dnsbuf->dynbuf != NULL) {
- isc_buffer_free(&dnsbuf->dynbuf);
- }
-
- if (dnsbuf->mctx != NULL) {
- isc_mem_detach(&dnsbuf->mctx);
- }
-}
-
-static inline isc_dnsbuffer_t *
-isc_dnsbuffer_new(isc_mem_t *memctx) {
- isc_dnsbuffer_t *newbuf;
-
- REQUIRE(memctx != NULL);
-
- newbuf = isc_mem_get(memctx, sizeof(*newbuf));
- isc_dnsbuffer_init(newbuf, memctx);
-
- return (newbuf);
-}
-
-static inline void
-isc_dnsbuffer_free(isc_dnsbuffer_t **restrict pdnsbuf) {
- isc_dnsbuffer_t *restrict buf = NULL;
- isc_mem_t *memctx = NULL;
- REQUIRE(pdnsbuf != NULL && *pdnsbuf != NULL);
-
- buf = *pdnsbuf;
-
- isc_mem_attach(buf->mctx, &memctx);
- isc_dnsbuffer_uninit(buf);
- isc_mem_putanddetach(&memctx, buf, sizeof(*buf));
-
- *pdnsbuf = NULL;
-}
-
-static inline void
-isc_dnsbuffer_clear(isc_dnsbuffer_t *restrict dnsbuf) {
- REQUIRE(dnsbuf != NULL);
- isc_buffer_clear(dnsbuf->current);
-}
-
-static inline unsigned int
-isc_dnsbuffer_length(const isc_dnsbuffer_t *restrict dnsbuf) {
- REQUIRE(dnsbuf != NULL);
- return (isc_buffer_length(dnsbuf->current));
-}
-
-static inline unsigned int
-isc_dnsbuffer_usedlength(const isc_dnsbuffer_t *restrict dnsbuf) {
- REQUIRE(dnsbuf != NULL);
- return (isc_buffer_usedlength(dnsbuf->current));
-}
-
-static inline unsigned int
-isc_dnsbuffer_remaininglength(const isc_dnsbuffer_t *restrict dnsbuf) {
- REQUIRE(dnsbuf != NULL);
- return (isc_buffer_remaininglength(dnsbuf->current));
-}
-
-static inline void
-isc_dnsbuffer_remainingregion(const isc_dnsbuffer_t *restrict dnsbuf,
- isc_region_t *region) {
- REQUIRE(dnsbuf != NULL);
- REQUIRE(region != NULL);
- isc_buffer_remainingregion(dnsbuf->current, region);
-}
-
-static inline void
-isc_dnsbuffer_compact(const isc_dnsbuffer_t *restrict dnsbuf) {
- REQUIRE(dnsbuf != NULL);
- isc_buffer_compact(dnsbuf->current);
-}
-
-static inline bool
-isc_dnsbuffer_trycompact(const isc_dnsbuffer_t *restrict dnsbuf) {
- REQUIRE(dnsbuf != NULL);
- if (isc_buffer_consumedlength(dnsbuf->current) >=
- isc_dnsbuffer_remaininglength(dnsbuf))
- {
- isc_dnsbuffer_compact(dnsbuf);
- return (true);
- }
-
- return (false);
-}
-
-static inline void
-isc_dnsbuffer_consume(isc_dnsbuffer_t *restrict dnsbuf, const unsigned int n) {
- REQUIRE(dnsbuf != NULL);
- isc_buffer_forward(dnsbuf->current, n);
-}
-
-static inline void
-isc_dnsbuffer_putmem(isc_dnsbuffer_t *restrict dnsbuf, void *buf,
- const unsigned int buf_size) {
- REQUIRE(dnsbuf != NULL);
- REQUIRE(buf != NULL);
- REQUIRE(buf_size > 0);
- if (!(dnsbuf->current == &dnsbuf->stbuf &&
- isc_buffer_availablelength(dnsbuf->current) >= buf_size) &&
- dnsbuf->dynbuf == NULL)
- {
- isc_region_t remaining = { 0 };
- unsigned int total_size = 0;
-
- isc_buffer_remainingregion(&dnsbuf->stbuf, &remaining);
- total_size = remaining.length + buf_size;
- if (total_size < ISC_DNSBUFFER_INITIAL_DYNAMIC_BUFFER_SIZE) {
- total_size = ISC_DNSBUFFER_INITIAL_DYNAMIC_BUFFER_SIZE;
- }
- isc_buffer_allocate(dnsbuf->mctx, &dnsbuf->dynbuf, total_size);
- isc_buffer_setautorealloc(dnsbuf->dynbuf, true);
- if (remaining.length > 0) {
- isc_buffer_putmem(dnsbuf->dynbuf, remaining.base,
- remaining.length);
- }
-
- dnsbuf->current = dnsbuf->dynbuf;
- }
-
- isc_buffer_putmem(dnsbuf->current, buf, buf_size);
-}
-
-static inline uint8_t *
-isc_dnsbuffer_current(const isc_dnsbuffer_t *restrict dnsbuf) {
- REQUIRE(dnsbuf != NULL);
- return (isc_buffer_current(dnsbuf->current));
-}
-
-static inline uint16_t
-isc__dnsbuffer_peek_uint16be(const isc_dnsbuffer_t *restrict dnsbuf) {
- uint16_t v;
- uint8_t *p = (uint8_t *)isc_dnsbuffer_current(dnsbuf);
-
- v = p[0] << 8;
- v |= p[1] & 0xFF;
-
- return (v);
-}
-
-static inline uint16_t
-isc_dnsbuffer_peek_uint16be(const isc_dnsbuffer_t *restrict dnsbuf) {
- REQUIRE(dnsbuf != NULL);
- if (isc_dnsbuffer_remaininglength(dnsbuf) < sizeof(uint16_t)) {
- return (0);
- }
-
- return (isc__dnsbuffer_peek_uint16be(dnsbuf));
-}
-
-static inline uint16_t
-isc_dnsbuffer_consume_uint16be(isc_dnsbuffer_t *restrict dnsbuf) {
- uint16_t v;
-
- REQUIRE(dnsbuf != NULL);
-
- if (isc_dnsbuffer_remaininglength(dnsbuf) < sizeof(uint16_t)) {
- return (0);
- }
-
- v = isc__dnsbuffer_peek_uint16be(dnsbuf);
-
- isc_dnsbuffer_consume(dnsbuf, sizeof(uint16_t));
-
- return (v);
-}
-
-static inline void
-isc_dnsbuffer_putmem_uint16be(isc_dnsbuffer_t *restrict dnsbuf,
- const uint16_t v) {
- uint8_t b[2] = { 0 };
-
- REQUIRE(dnsbuf != NULL);
-
- b[0] = v >> 8;
- b[1] = v & 0xFF;
-
- isc_dnsbuffer_putmem(dnsbuf, b, sizeof(b));
-}
*/
#pragma once
-#include <isc/dnsbuffer.h>
+#include <isc/buffer.h>
+#include <isc/mem.h>
typedef struct isc_dnsstream_assembler isc_dnsstream_assembler_t;
/*!<
* \brief The 'isc_dnsstream_assembler_t' object is built on top of
- * 'isc_dnsbuffer_t' and intended to encapsulate the state machine
+ * 'isc_buffer_t' and intended to encapsulate the state machine
* used for handling DNS messages received in the format used for
* messages transmitted over TCP.
*
* itself makes it trivial to write unit tests for it, leading to
* better verification of its correctness. Another important aspect
* of its functioning is directly related to the fact that it is built
- * on top of 'isc_dnsbuffer_t', which tries to manage memory in a
+ * on top of 'isc_buffer_t', which tries to manage memory in a
* smart way. In particular:
*
*\li It tries to use a static buffer for smaller messages, reducing
message (i.e. someone attempts to send us junk data).
*/
+#define ISC_DNSSTREAM_STATIC_BUFFER_SIZE (512)
+
struct isc_dnsstream_assembler {
- isc_dnsbuffer_t dnsbuf; /*!< Internal buffer for assembling DNS
+ isc_buffer_t dnsbuf; /*!< Internal buffer for assembling DNS
messages. */
+ uint8_t buf[ISC_DNSSTREAM_STATIC_BUFFER_SIZE];
isc_dnsstream_assembler_cb_t onmsg_cb; /*!< Data processing callback. */
void *cbarg; /*!< Callback argument. */
bool calling_cb; /*<! Callback calling marker. Used to detect recursive
*dnsasm = (isc_dnsstream_assembler_t){ .result = ISC_R_UNSET };
isc_dnsstream_assembler_setcb(dnsasm, cb, cbarg);
isc_mem_attach(memctx, &dnsasm->mctx);
- isc_dnsbuffer_init(&dnsasm->dnsbuf, memctx);
+
+ isc_buffer_init(&dnsasm->dnsbuf, dnsasm->buf, sizeof(dnsasm->buf));
+ isc_buffer_setmctx(&dnsasm->dnsbuf, dnsasm->mctx);
}
static inline void
* make any sense.
*/
INSIST(dnsasm->calling_cb == false);
- isc_dnsbuffer_uninit(&dnsasm->dnsbuf);
+ isc_buffer_clearmctx(&dnsasm->dnsbuf);
+ isc_buffer_invalidate(&dnsasm->dnsbuf);
if (dnsasm->mctx != NULL) {
isc_mem_detach(&dnsasm->mctx);
}
isc_dnsstream_assembler_t *restrict dnsasm, void *userarg) {
bool cont = false;
isc_region_t region = { 0 };
+ uint16_t dnslen = 0;
isc_result_t result;
- uint16_t dnslen = isc_dnsbuffer_peek_uint16be(&dnsasm->dnsbuf);
INSIST(dnsasm->calling_cb == false);
- if (isc_dnsbuffer_remaininglength(&dnsasm->dnsbuf) < sizeof(uint16_t)) {
- result = ISC_R_NOMORE;
- } else if (isc_dnsbuffer_remaininglength(&dnsasm->dnsbuf) >=
- sizeof(uint16_t) &&
- dnslen == 0)
- {
- /*
- * Someone seems to send us binary junk or output from /dev/zero
- */
- result = ISC_R_RANGE;
- isc_dnsbuffer_clear(&dnsasm->dnsbuf);
- } else if (dnslen <= (isc_dnsbuffer_remaininglength(&dnsasm->dnsbuf) -
+ result = isc_buffer_peekuint16(&dnsasm->dnsbuf, &dnslen);
+
+ switch (result) {
+ case ISC_R_SUCCESS:
+ if (dnslen == 0) {
+ /* This didn't make much sense to me: */
+ /* isc_buffer_remaininglength(&dnsasm->dnsbuf) >=
+ * sizeof(uint16_t) && */
+
+ /*
+ * Someone seems to send us binary junk or output from
+ * /dev/zero
+ */
+ result = ISC_R_RANGE;
+ isc_buffer_clear(&dnsasm->dnsbuf);
+ break;
+ }
+
+ if (dnslen > (isc_buffer_remaininglength(&dnsasm->dnsbuf) -
sizeof(uint16_t)))
- {
- result = ISC_R_SUCCESS;
- } else {
- result = ISC_R_NOMORE;
+ {
+ result = ISC_R_NOMORE;
+ break;
+ }
+ break;
+ case ISC_R_NOMORE:
+ break;
+ default:
+ UNREACHABLE();
}
dnsasm->result = result;
dnsasm->calling_cb = true;
if (result == ISC_R_SUCCESS) {
- (void)isc_dnsbuffer_consume_uint16be(&dnsasm->dnsbuf);
- isc_dnsbuffer_remainingregion(&dnsasm->dnsbuf, ®ion);
+ (void)isc_buffer_getuint16(&dnsasm->dnsbuf);
+ isc_buffer_remainingregion(&dnsasm->dnsbuf, ®ion);
region.length = dnslen;
cont = dnsasm->onmsg_cb(dnsasm, ISC_R_SUCCESS, ®ion,
dnsasm->cbarg, userarg);
- if (isc_dnsbuffer_remaininglength(&dnsasm->dnsbuf) >= dnslen) {
- isc_dnsbuffer_consume(&dnsasm->dnsbuf, dnslen);
+ if (isc_buffer_remaininglength(&dnsasm->dnsbuf) >= dnslen) {
+ isc_buffer_forward(&dnsasm->dnsbuf, dnslen);
}
} else {
cont = false;
INSIST(buf == NULL);
} else {
INSIST(buf != NULL);
- isc_dnsbuffer_putmem(&dnsasm->dnsbuf, buf, buf_size);
+ isc_buffer_putmem(&dnsasm->dnsbuf, buf, buf_size);
}
while (isc__dnsstream_assembler_handle_message(dnsasm, userarg)) {
- if (isc_dnsbuffer_remaininglength(&dnsasm->dnsbuf) == 0) {
+ if (isc_buffer_remaininglength(&dnsasm->dnsbuf) == 0) {
break;
}
}
- isc_dnsbuffer_trycompact(&dnsasm->dnsbuf);
+ isc_buffer_trycompact(&dnsasm->dnsbuf);
}
static inline isc_result_t
const isc_dnsstream_assembler_t *restrict dnsasm) {
REQUIRE(dnsasm != NULL);
- return (isc_dnsbuffer_remaininglength(&dnsasm->dnsbuf));
+ return (isc_buffer_remaininglength(&dnsasm->dnsbuf));
}
static inline void
isc_dnsstream_assembler_clear(isc_dnsstream_assembler_t *restrict dnsasm) {
REQUIRE(dnsasm != NULL);
- isc_dnsbuffer_clear(&dnsasm->dnsbuf);
+ isc_buffer_clear(&dnsasm->dnsbuf);
dnsasm->result = ISC_R_UNSET;
}
#define UNIT_TESTING
#include <cmocka.h>
+#include <isc/buffer.h>
#include <isc/dnsstream.h>
#include <isc/mem.h>
#include <isc/os.h>
#include <tests/isc.h>
+#define STATIC_BUFFER_SIZE (512)
+#define DYNAMIC_BUFFER_SIZE (STATIC_BUFFER_SIZE + ISC_BUFFER_INCR)
+
static int
setup_test_dnsbuf(void **state) {
- isc_dnsbuffer_t **pdnsbuf = (isc_dnsbuffer_t **)state;
- *pdnsbuf = isc_dnsbuffer_new(mctx);
+ isc_buffer_t **pdnsbuf = (isc_buffer_t **)state;
+ isc_buffer_allocate(mctx, pdnsbuf, STATIC_BUFFER_SIZE);
return (0);
}
static int
teardown_test_dnsbuf(void **state) {
- isc_dnsbuffer_free((isc_dnsbuffer_t **)state);
+ isc_buffer_free((isc_buffer_t **)state);
return (0);
}
}
ISC_RUN_TEST_IMPL(dnsbuffer_generic_test) {
- uint8_t buf[ISC_DNSBUFFER_STATIC_BUFFER_SIZE / 2] = { 0 };
- isc_dnsbuffer_t *dnsbuf = (isc_dnsbuffer_t *)*state;
+ uint8_t buf[STATIC_BUFFER_SIZE / 2] = { 0 };
+ isc_buffer_t *dnsbuf = (isc_buffer_t *)*state;
isc_region_t reg = { 0 };
size_t n = 0;
}
/* sanity checks */
- assert_true(isc_dnsbuffer_length(dnsbuf) ==
- ISC_DNSBUFFER_STATIC_BUFFER_SIZE);
- assert_true(isc_dnsbuffer_usedlength(dnsbuf) == 0);
- assert_true(isc_dnsbuffer_remaininglength(dnsbuf) == 0);
-
- isc_dnsbuffer_putmem(dnsbuf, buf, sizeof(buf));
+ assert_true(isc_buffer_length(dnsbuf) == STATIC_BUFFER_SIZE);
+ assert_true(isc_buffer_usedlength(dnsbuf) == 0);
+ assert_true(isc_buffer_remaininglength(dnsbuf) == 0);
- assert_true(isc_dnsbuffer_usedlength(dnsbuf) == sizeof(buf));
- assert_true(isc_dnsbuffer_remaininglength(dnsbuf) == sizeof(buf));
+ isc_buffer_putmem(dnsbuf, buf, sizeof(buf));
- assert_true(isc_dnsbuffer_current(dnsbuf) == dnsbuf->buf);
- assert_true(dnsbuf->current == &dnsbuf->stbuf);
+ assert_true(isc_buffer_usedlength(dnsbuf) == sizeof(buf));
+ assert_true(isc_buffer_remaininglength(dnsbuf) == sizeof(buf));
- isc_dnsbuffer_clear(dnsbuf);
+ assert_true(isc_buffer_current(dnsbuf) == dnsbuf->base);
- assert_true(isc_dnsbuffer_length(dnsbuf) ==
- ISC_DNSBUFFER_STATIC_BUFFER_SIZE);
- assert_true(isc_dnsbuffer_usedlength(dnsbuf) == 0);
- assert_true(isc_dnsbuffer_remaininglength(dnsbuf) == 0);
+ isc_buffer_clear(dnsbuf);
- assert_true(dnsbuf->current == &dnsbuf->stbuf);
+ assert_true(isc_buffer_length(dnsbuf) == STATIC_BUFFER_SIZE);
+ assert_true(isc_buffer_usedlength(dnsbuf) == 0);
+ assert_true(isc_buffer_remaininglength(dnsbuf) == 0);
- isc_dnsbuffer_putmem(dnsbuf, buf, sizeof(buf));
+ isc_buffer_putmem(dnsbuf, buf, sizeof(buf));
- assert_true(isc_dnsbuffer_usedlength(dnsbuf) == sizeof(buf));
- assert_true(isc_dnsbuffer_remaininglength(dnsbuf) == sizeof(buf));
+ assert_true(isc_buffer_usedlength(dnsbuf) == sizeof(buf));
+ assert_true(isc_buffer_remaininglength(dnsbuf) == sizeof(buf));
- assert_true(isc_dnsbuffer_current(dnsbuf) == dnsbuf->buf);
- assert_true(dnsbuf->current == &dnsbuf->stbuf);
+ assert_true(isc_buffer_current(dnsbuf) == dnsbuf->base);
- for (size_t i = 0; i < sizeof(buf);
- i++, isc_dnsbuffer_consume(dnsbuf, 1))
+ for (size_t i = 0; i < sizeof(buf); i++, isc_buffer_forward(dnsbuf, 1))
{
- uint8_t *p = isc_dnsbuffer_current(dnsbuf);
+ uint8_t *p = isc_buffer_current(dnsbuf);
assert_true(*p == i);
}
- assert_true(isc_dnsbuffer_remaininglength(dnsbuf) == 0);
- assert_true(isc_dnsbuffer_usedlength(dnsbuf) == sizeof(buf));
-
- isc_dnsbuffer_putmem(dnsbuf, buf, sizeof(buf));
+ assert_true(isc_buffer_remaininglength(dnsbuf) == 0);
+ assert_true(isc_buffer_usedlength(dnsbuf) == sizeof(buf));
- assert_true(isc_dnsbuffer_remaininglength(dnsbuf) == sizeof(buf));
- assert_true(isc_dnsbuffer_usedlength(dnsbuf) == sizeof(buf) * 2);
+ isc_buffer_putmem(dnsbuf, buf, sizeof(buf));
- assert_true(isc_dnsbuffer_length(dnsbuf) ==
- ISC_DNSBUFFER_STATIC_BUFFER_SIZE);
+ assert_true(isc_buffer_remaininglength(dnsbuf) == sizeof(buf));
+ assert_true(isc_buffer_usedlength(dnsbuf) == sizeof(buf) * 2);
- assert_true(dnsbuf->current == &dnsbuf->stbuf);
+ assert_true(isc_buffer_length(dnsbuf) == STATIC_BUFFER_SIZE);
- for (size_t i = 0; i < sizeof(buf);
- i++, isc_dnsbuffer_consume(dnsbuf, 1))
+ for (size_t i = 0; i < sizeof(buf); i++, isc_buffer_forward(dnsbuf, 1))
{
- uint8_t *p = isc_dnsbuffer_current(dnsbuf);
+ uint8_t *p = isc_buffer_current(dnsbuf);
assert_true(*p == i);
}
- isc_dnsbuffer_putmem(dnsbuf, buf, sizeof(buf));
+ isc_buffer_putmem(dnsbuf, buf, sizeof(buf));
- assert_true(isc_dnsbuffer_length(dnsbuf) ==
- ISC_DNSBUFFER_INITIAL_DYNAMIC_BUFFER_SIZE);
+ assert_true(isc_buffer_length(dnsbuf) == DYNAMIC_BUFFER_SIZE);
- for (size_t i = 0; i < sizeof(buf);
- i++, isc_dnsbuffer_consume(dnsbuf, 1))
+ for (size_t i = 0; i < sizeof(buf); i++, isc_buffer_forward(dnsbuf, 1))
{
- uint8_t *p = isc_dnsbuffer_current(dnsbuf);
+ uint8_t *p = isc_buffer_current(dnsbuf);
assert_true(*p == i);
}
- assert_true(isc_dnsbuffer_remaininglength(dnsbuf) == 0);
- assert_true(isc_dnsbuffer_trycompact(dnsbuf));
+ assert_true(isc_buffer_remaininglength(dnsbuf) == 0);
+ isc_buffer_trycompact(dnsbuf);
- assert_true(isc_dnsbuffer_length(dnsbuf) ==
- ISC_DNSBUFFER_INITIAL_DYNAMIC_BUFFER_SIZE);
+ assert_true(isc_buffer_length(dnsbuf) == DYNAMIC_BUFFER_SIZE);
- isc_dnsbuffer_putmem(dnsbuf, buf, sizeof(buf));
+ isc_buffer_putmem(dnsbuf, buf, sizeof(buf));
- isc_dnsbuffer_remainingregion(dnsbuf, ®);
- assert_true(isc_dnsbuffer_remaininglength(dnsbuf) == reg.length);
+ isc_buffer_remainingregion(dnsbuf, ®);
+ assert_true(isc_buffer_remaininglength(dnsbuf) == reg.length);
assert_true(reg.length == sizeof(buf));
for (size_t i = 0; i < reg.length; i++) {
assert_true(d == i);
}
- isc_dnsbuffer_consume(dnsbuf, reg.length);
- assert_true(isc_dnsbuffer_remaininglength(dnsbuf) == 0);
+ isc_buffer_forward(dnsbuf, reg.length);
+ assert_true(isc_buffer_remaininglength(dnsbuf) == 0);
- isc_dnsbuffer_putmem(dnsbuf, buf, sizeof(buf));
- assert_true(isc_dnsbuffer_remaininglength(dnsbuf) == sizeof(buf));
+ isc_buffer_putmem(dnsbuf, buf, sizeof(buf));
+ assert_true(isc_buffer_remaininglength(dnsbuf) == sizeof(buf));
- isc_dnsbuffer_clear(dnsbuf);
+ isc_buffer_clear(dnsbuf);
- assert_true(isc_dnsbuffer_length(dnsbuf) ==
- ISC_DNSBUFFER_INITIAL_DYNAMIC_BUFFER_SIZE);
+ assert_true(isc_buffer_length(dnsbuf) == DYNAMIC_BUFFER_SIZE);
- assert_true(isc_dnsbuffer_remaininglength(dnsbuf) == 0);
+ assert_true(isc_buffer_remaininglength(dnsbuf) == 0);
- n = ISC_DNSBUFFER_INITIAL_DYNAMIC_BUFFER_SIZE / sizeof(buf) + 1;
+ n = DYNAMIC_BUFFER_SIZE / sizeof(buf) + 1;
for (size_t i = 0; i < n; i++) {
- isc_dnsbuffer_putmem(dnsbuf, buf, sizeof(buf));
+ isc_buffer_putmem(dnsbuf, buf, sizeof(buf));
}
- assert_true(isc_dnsbuffer_length(dnsbuf) >
- ISC_DNSBUFFER_INITIAL_DYNAMIC_BUFFER_SIZE);
- assert_true(isc_dnsbuffer_length(dnsbuf) >= n * sizeof(buf));
+ assert_true(isc_buffer_length(dnsbuf) > DYNAMIC_BUFFER_SIZE);
+ assert_true(isc_buffer_length(dnsbuf) >= n * sizeof(buf));
- assert_true(isc_dnsbuffer_remaininglength(dnsbuf) == n * sizeof(buf));
+ assert_true(isc_buffer_remaininglength(dnsbuf) == n * sizeof(buf));
for (size_t i = 0; i < n; i++) {
for (size_t k = 0; k < sizeof(buf);
- k++, isc_dnsbuffer_consume(dnsbuf, 1))
+ k++, isc_buffer_forward(dnsbuf, 1))
{
- uint8_t *p = isc_dnsbuffer_current(dnsbuf);
+ uint8_t *p = isc_buffer_current(dnsbuf);
assert_true(*p == k);
}
}
ISC_RUN_TEST_IMPL(dnsbuffer_resize_alloc_test) {
- uint8_t buf[ISC_DNSBUFFER_STATIC_BUFFER_SIZE / 2] = { 0 };
- isc_dnsbuffer_t *dnsbuf = (isc_dnsbuffer_t *)*state;
+ uint8_t buf[STATIC_BUFFER_SIZE / 2] = { 0 };
+ isc_buffer_t *dnsbuf = (isc_buffer_t *)*state;
size_t i = 0, n = 0;
for (i = 0; i < sizeof(buf); i++) {
buf[i] = (uint8_t)i;
}
- isc_dnsbuffer_putmem(dnsbuf, buf, sizeof(buf));
+ isc_buffer_putmem(dnsbuf, buf, sizeof(buf));
for (i = 0; i < (sizeof(buf) / 3) * 2;
- i++, isc_dnsbuffer_consume(dnsbuf, 1))
+ i++, isc_buffer_forward(dnsbuf, 1))
{
- uint8_t *p = isc_dnsbuffer_current(dnsbuf);
+ uint8_t *p = isc_buffer_current(dnsbuf);
assert_true(*p == i);
}
- assert_true(isc_dnsbuffer_length(dnsbuf) ==
- ISC_DNSBUFFER_STATIC_BUFFER_SIZE);
+ assert_true(isc_buffer_length(dnsbuf) == STATIC_BUFFER_SIZE);
- n = ISC_DNSBUFFER_INITIAL_DYNAMIC_BUFFER_SIZE / sizeof(buf) + 1;
+ n = DYNAMIC_BUFFER_SIZE / sizeof(buf) + 1;
for (size_t k = 0; k < n; k++) {
- isc_dnsbuffer_putmem(dnsbuf, buf, sizeof(buf));
+ isc_buffer_putmem(dnsbuf, buf, sizeof(buf));
}
- assert_true(isc_dnsbuffer_length(dnsbuf) >=
- ISC_DNSBUFFER_STATIC_BUFFER_SIZE);
+ assert_true(isc_buffer_length(dnsbuf) >= STATIC_BUFFER_SIZE);
- for (; i < sizeof(buf); i++, isc_dnsbuffer_consume(dnsbuf, 1)) {
- uint8_t *p = isc_dnsbuffer_current(dnsbuf);
+ for (; i < sizeof(buf); i++, isc_buffer_forward(dnsbuf, 1)) {
+ uint8_t *p = isc_buffer_current(dnsbuf);
assert_true(*p == i);
}
}
ISC_RUN_TEST_IMPL(dnsbuffer_be_test) {
- isc_dnsbuffer_t *dnsbuf = (isc_dnsbuffer_t *)*state;
+ isc_buffer_t *dnsbuf = (isc_buffer_t *)*state;
const uint16_t u16 = 0xBEEF;
uint16_t *pu16;
+ uint16_t u16v;
- assert_true(isc_dnsbuffer_remaininglength(dnsbuf) == 0);
+ assert_true(isc_buffer_remaininglength(dnsbuf) == 0);
- assert_true(isc_dnsbuffer_peek_uint16be(dnsbuf) == 0);
- assert_true(isc_dnsbuffer_consume_uint16be(dnsbuf) == 0);
+ isc_buffer_putuint16(dnsbuf, u16);
- isc_dnsbuffer_putmem_uint16be(dnsbuf, u16);
+ assert_true(isc_buffer_remaininglength(dnsbuf) == sizeof(u16));
- assert_true(isc_dnsbuffer_remaininglength(dnsbuf) == sizeof(u16));
-
- pu16 = (uint16_t *)isc_dnsbuffer_current(dnsbuf);
+ pu16 = (uint16_t *)isc_buffer_current(dnsbuf);
assert_true(*pu16 == htons(u16));
- assert_true(isc_dnsbuffer_peek_uint16be(dnsbuf) == u16);
- assert_true(isc_dnsbuffer_remaininglength(dnsbuf) == sizeof(u16));
+ assert_int_equal(isc_buffer_peekuint16(dnsbuf, &u16v), ISC_R_SUCCESS);
+ assert_int_equal(u16v, u16);
+ assert_true(isc_buffer_remaininglength(dnsbuf) == sizeof(u16));
- assert_true(isc_dnsbuffer_consume_uint16be(dnsbuf) == u16);
- assert_true(isc_dnsbuffer_remaininglength(dnsbuf) == 0);
+ assert_true(isc_buffer_getuint16(dnsbuf) == u16);
+ assert_true(isc_buffer_remaininglength(dnsbuf) == 0);
}
typedef struct verify_cbdata {
ISC_RUN_TEST_IMPL(dnsasm_multiple_messages_test) {
isc_dnsstream_assembler_t *dnsasm = (isc_dnsstream_assembler_t *)*state;
- isc_dnsbuffer_t dnsbuf;
+ isc_buffer_t dnsbuf;
verify_cbdata_t cbdata = { 0 };
size_t verified = 0;
- isc_dnsbuffer_init(&dnsbuf, mctx);
- isc_dnsbuffer_putmem(&dnsbuf, (void *)request, sizeof(request));
- isc_dnsbuffer_putmem(&dnsbuf, (void *)response, sizeof(response));
- isc_dnsbuffer_putmem(&dnsbuf, (void *)request_large,
- sizeof(request_large));
- isc_dnsbuffer_putmem(&dnsbuf, (void *)response_large,
- sizeof(response_large));
+ isc_buffer_init(&dnsbuf, NULL, 0);
+ isc_buffer_setmctx(&dnsbuf, mctx);
+ isc_buffer_putmem(&dnsbuf, (void *)request, sizeof(request));
+ isc_buffer_putmem(&dnsbuf, (void *)response, sizeof(response));
+ isc_buffer_putmem(&dnsbuf, (void *)request_large,
+ sizeof(request_large));
+ isc_buffer_putmem(&dnsbuf, (void *)response_large,
+ sizeof(response_large));
cbdata.cont_on_success = false;
*/
cbdata.verify_message = (uint8_t *)request;
isc_dnsstream_assembler_setcb(dnsasm, verify_dnsmsg, (void *)&cbdata);
- isc_dnsstream_assembler_incoming(
- dnsasm, &verified, isc_dnsbuffer_current(&dnsbuf),
- isc_dnsbuffer_remaininglength(&dnsbuf));
+ isc_dnsstream_assembler_incoming(dnsasm, &verified,
+ isc_buffer_current(&dnsbuf),
+ isc_buffer_remaininglength(&dnsbuf));
- isc_dnsbuffer_uninit(&dnsbuf);
+ isc_buffer_clearmctx(&dnsbuf);
+ isc_buffer_invalidate(&dnsbuf);
assert_true(verified == 1);
assert_true(isc_dnsstream_assembler_result(dnsasm) == ISC_R_SUCCESS);
isc_dnsstream_assembler_t *dnsasm = (isc_dnsstream_assembler_t *)*state;
verify_cbdata_t cbdata = { 0 };
size_t verified = 0;
- isc_dnsbuffer_t dnsbuf;
+ isc_buffer_t dnsbuf;
uint16_t bad_data = 0;
- isc_dnsbuffer_init(&dnsbuf, mctx);
+ isc_buffer_init(&dnsbuf, NULL, 0);
+ isc_buffer_setmctx(&dnsbuf, mctx);
- isc_dnsbuffer_putmem(&dnsbuf, (void *)request, sizeof(request));
- isc_dnsbuffer_putmem(&dnsbuf, (void *)&bad_data, sizeof(bad_data));
- isc_dnsbuffer_putmem(&dnsbuf, (void *)&bad_data, sizeof(bad_data));
- isc_dnsbuffer_putmem(&dnsbuf, (void *)response_large,
- sizeof(response_large));
+ isc_buffer_putmem(&dnsbuf, (void *)request, sizeof(request));
+ isc_buffer_putmem(&dnsbuf, (void *)&bad_data, sizeof(bad_data));
+ isc_buffer_putmem(&dnsbuf, (void *)&bad_data, sizeof(bad_data));
+ isc_buffer_putmem(&dnsbuf, (void *)response_large,
+ sizeof(response_large));
cbdata.cont_on_success = false;
cbdata.verify_message = (uint8_t *)request;
isc_dnsstream_assembler_setcb(dnsasm, verify_dnsmsg, (void *)&cbdata);
- isc_dnsstream_assembler_incoming(
- dnsasm, &verified, isc_dnsbuffer_current(&dnsbuf),
- isc_dnsbuffer_remaininglength(&dnsbuf));
+ isc_dnsstream_assembler_incoming(dnsasm, &verified,
+ isc_buffer_current(&dnsbuf),
+ isc_buffer_remaininglength(&dnsbuf));
- isc_dnsbuffer_uninit(&dnsbuf);
+ isc_buffer_clearmctx(&dnsbuf);
+ isc_buffer_invalidate(&dnsbuf);
assert_true(verified == 1);
assert_true(isc_dnsstream_assembler_result(dnsasm) == ISC_R_SUCCESS);
isc_dnsstream_assembler_t *dnsasm = (isc_dnsstream_assembler_t *)*state;
verify_cbdata_t cbdata = { 0 };
verify_regions_cbdata_t cbdata_regions = { 0 };
- isc_dnsbuffer_t dnsbuf;
+ isc_buffer_t dnsbuf;
size_t packetno;
isc_region_t packets[] = {
{ (void *)request, sizeof(request) },
};
const size_t npackets = sizeof(packets) / sizeof(packets[0]);
- isc_dnsbuffer_init(&dnsbuf, mctx);
+ isc_buffer_init(&dnsbuf, NULL, 0);
+ isc_buffer_setmctx(&dnsbuf, mctx);
+
for (size_t i = 0; i < npackets; i++) {
- isc_dnsbuffer_putmem(&dnsbuf, packets[i].base,
- packets[i].length);
+ isc_buffer_putmem(&dnsbuf, packets[i].base, packets[i].length);
}
/* process packet by packet */
isc_dnsstream_assembler_setcb(dnsasm, verify_dnsmsg, (void *)&cbdata);
/* process random amount of data */
- for (; isc_dnsbuffer_remaininglength(&dnsbuf) > 0;) {
+ for (; isc_buffer_remaininglength(&dnsbuf) > 0;) {
size_t sz = 1 + isc_random_uniform(
- isc_dnsbuffer_remaininglength(&dnsbuf));
+ isc_buffer_remaininglength(&dnsbuf));
for (bool start = true; packetno < npackets; start = false) {
cbdata.verify_message =
if (start) {
isc_dnsstream_assembler_incoming(
dnsasm, &packetno,
- isc_dnsbuffer_current(&dnsbuf), sz);
+ isc_buffer_current(&dnsbuf), sz);
} else {
isc_dnsstream_assembler_incoming(
dnsasm, &packetno, NULL, 0);
}
}
- isc_dnsbuffer_consume(&dnsbuf, sz);
+ isc_buffer_forward(&dnsbuf, sz);
}
assert_true(packetno == npackets);
assert_true(isc_dnsstream_assembler_remaininglength(dnsasm) == 0);
- assert_true(isc_dnsbuffer_remaininglength(&dnsbuf) == 0);
+ assert_true(isc_buffer_remaininglength(&dnsbuf) == 0);
for (size_t i = 0; i < npackets; i++) {
- isc_dnsbuffer_putmem(&dnsbuf, packets[i].base,
- packets[i].length);
+ isc_buffer_putmem(&dnsbuf, packets[i].base, packets[i].length);
}
/* try to process multiple packets at once, when possible */
(void *)&cbdata_regions);
/* process random amount of data */
- for (; isc_dnsbuffer_remaininglength(&dnsbuf) > 0;) {
+ for (; isc_buffer_remaininglength(&dnsbuf) > 0;) {
size_t sz = 1 + isc_random_uniform(
- isc_dnsbuffer_remaininglength(&dnsbuf));
+ isc_buffer_remaininglength(&dnsbuf));
isc_dnsstream_assembler_incoming(
- dnsasm, &packetno, isc_dnsbuffer_current(&dnsbuf), sz);
+ dnsasm, &packetno, isc_buffer_current(&dnsbuf), sz);
- isc_dnsbuffer_consume(&dnsbuf, sz);
+ isc_buffer_forward(&dnsbuf, sz);
}
assert_true(packetno == npackets);
assert_true(isc_dnsstream_assembler_remaininglength(dnsasm) == 0);
- assert_true(isc_dnsbuffer_remaininglength(&dnsbuf) == 0);
+ assert_true(isc_buffer_remaininglength(&dnsbuf) == 0);
- isc_dnsbuffer_uninit(&dnsbuf);
+ isc_buffer_clearmctx(&dnsbuf);
+ isc_buffer_invalidate(&dnsbuf);
+ dnsasm->cbarg = NULL; /* to make GCC happy about dangling pointers */
}
ISC_RUN_TEST_IMPL(dnsasm_clear_buffer_within_cb_test) {
isc_dnsstream_assembler_t *dnsasm = (isc_dnsstream_assembler_t *)*state;
verify_cbdata_t cbdata = { 0 };
size_t verified = 0;
- isc_dnsbuffer_t dnsbuf;
+ isc_buffer_t dnsbuf;
- isc_dnsbuffer_init(&dnsbuf, mctx);
+ isc_buffer_init(&dnsbuf, NULL, 0);
+ isc_buffer_setmctx(&dnsbuf, mctx);
- isc_dnsbuffer_putmem(&dnsbuf, (void *)request, sizeof(request));
- isc_dnsbuffer_putmem(&dnsbuf, (void *)&response, sizeof(response));
- isc_dnsbuffer_putmem(&dnsbuf, (void *)request, sizeof(request));
+ isc_buffer_putmem(&dnsbuf, (void *)request, sizeof(request));
+ isc_buffer_putmem(&dnsbuf, (void *)&response, sizeof(response));
+ isc_buffer_putmem(&dnsbuf, (void *)request, sizeof(request));
cbdata.cont_on_success = true;
cbdata.clear_on_success = true;
cbdata.verify_message = (uint8_t *)request;
isc_dnsstream_assembler_setcb(dnsasm, verify_dnsmsg, (void *)&cbdata);
- isc_dnsstream_assembler_incoming(
- dnsasm, &verified, isc_dnsbuffer_current(&dnsbuf),
- isc_dnsbuffer_remaininglength(&dnsbuf));
+ isc_dnsstream_assembler_incoming(dnsasm, &verified,
+ isc_buffer_current(&dnsbuf),
+ isc_buffer_remaininglength(&dnsbuf));
- isc_dnsbuffer_uninit(&dnsbuf);
+ isc_buffer_clearmctx(&dnsbuf);
+ isc_buffer_invalidate(&dnsbuf);
assert_true(verified == 1);
assert_true(isc_dnsstream_assembler_result(dnsasm) == ISC_R_UNSET);
projects / thirdparty / bind9.git / commitdiff
