+++ /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.
- */
-/*! \file */
-
-#include <inttypes.h>
-#include <stdarg.h>
-#include <stdbool.h>
-
-#include <isc/buffer.h>
-#include <isc/mem.h>
-#include <isc/print.h>
-#include <isc/region.h>
-#include <isc/string.h>
-#include <isc/util.h>
-
-void
-isc_buffer_reinit(isc_buffer_t *b, void *base, unsigned int length) {
- /*
- * Re-initialize the buffer enough to reconfigure the base of the
- * buffer. We will swap in the new buffer, after copying any
- * data we contain into the new buffer and adjusting all of our
- * internal pointers.
- *
- * The buffer must not be smaller than the length of the original
- * buffer.
- */
- REQUIRE(b->length <= length);
- REQUIRE(base != NULL);
- REQUIRE(b->mctx == NULL);
-
- if (b->length > 0U) {
- (void)memmove(base, b->base, b->length);
- }
-
- b->base = base;
- b->length = length;
-}
-
-void
-isc_buffer_compact(isc_buffer_t *b) {
- unsigned int length;
- void *src;
-
- /*
- * Compact the used region by moving the remaining region so it occurs
- * at the start of the buffer. The used region is shrunk by the size
- * of the consumed region, and the consumed region is then made empty.
- */
-
- REQUIRE(ISC_BUFFER_VALID(b));
-
- src = isc_buffer_current(b);
- length = isc_buffer_remaininglength(b);
- if (length > 0U) {
- (void)memmove(b->base, src, (size_t)length);
- }
-
- if (b->active > b->current) {
- b->active -= b->current;
- } else {
- b->active = 0;
- }
- b->current = 0;
- b->used = length;
-}
-
-isc_result_t
-isc_buffer_dup(isc_mem_t *mctx, isc_buffer_t **dstp, const isc_buffer_t *src) {
- isc_buffer_t *dst = NULL;
- isc_region_t region;
- isc_result_t result;
-
- REQUIRE(dstp != NULL && *dstp == NULL);
- REQUIRE(ISC_BUFFER_VALID(src));
-
- isc_buffer_usedregion(src, ®ion);
-
- isc_buffer_allocate(mctx, &dst, region.length);
-
- result = isc_buffer_copyregion(dst, ®ion);
- RUNTIME_CHECK(result == ISC_R_SUCCESS); /* NOSPACE is impossible */
- *dstp = dst;
- return (ISC_R_SUCCESS);
-}
-
-isc_result_t
-isc_buffer_copyregion(isc_buffer_t *b, const isc_region_t *r) {
- isc_result_t result;
-
- REQUIRE(ISC_BUFFER_VALID(b));
- REQUIRE(r != NULL);
-
- if (b->mctx) {
- result = isc_buffer_reserve(b, r->length);
- if (result != ISC_R_SUCCESS) {
- return (result);
- }
- }
-
- if (r->length > isc_buffer_availablelength(b)) {
- return (ISC_R_NOSPACE);
- }
-
- if (r->length > 0U) {
- memmove(isc_buffer_used(b), r->base, r->length);
- b->used += r->length;
- }
-
- return (ISC_R_SUCCESS);
-}
-
-void
-isc_buffer_allocate(isc_mem_t *mctx, isc_buffer_t **dbufp,
- unsigned int length) {
- REQUIRE(dbufp != NULL && *dbufp == NULL);
-
- isc_buffer_t *dbuf = isc_mem_get(mctx, sizeof(*dbuf) + length);
- uint8_t *bdata = (uint8_t *)dbuf + sizeof(*dbuf);
-
- isc_buffer_init(dbuf, bdata, length);
- dbuf->extra = length;
- dbuf->mctx = mctx;
-
- *dbufp = dbuf;
-}
-
-isc_result_t
-isc_buffer_reserve(isc_buffer_t *dbuf, unsigned int size) {
- REQUIRE(ISC_BUFFER_VALID(dbuf));
-
- size_t len;
- uint8_t *bdata = (uint8_t *)dbuf + sizeof(*dbuf);
-
- len = dbuf->length;
- if ((len - dbuf->used) >= size) {
- return (ISC_R_SUCCESS);
- }
-
- if (dbuf->mctx == NULL) {
- return (ISC_R_NOSPACE);
- }
-
- /* Round to nearest buffer size increment */
- len = size + dbuf->used;
- len = ISC_ALIGN(len, ISC_BUFFER_INCR);
-
- /* Cap at UINT_MAX */
- if (len > UINT_MAX) {
- len = UINT_MAX;
- }
-
- if ((len - dbuf->used) < size) {
- return (ISC_R_NOMEMORY);
- }
-
- if (dbuf->base == bdata) {
- dbuf->base = isc_mem_get(dbuf->mctx, len);
- memmove(dbuf->base, bdata, dbuf->used);
- } else {
- dbuf->base = isc_mem_reget(dbuf->mctx, dbuf->base, dbuf->length,
- len);
- }
- dbuf->length = (unsigned int)len;
-
- return (ISC_R_SUCCESS);
-}
-
-void
-isc_buffer_free(isc_buffer_t **dbufp) {
- REQUIRE(dbufp != NULL && ISC_BUFFER_VALID(*dbufp));
- REQUIRE((*dbufp)->mctx != NULL);
-
- isc_buffer_t *dbuf = *dbufp;
- isc_mem_t *mctx = dbuf->mctx;
- uint8_t *bdata = (uint8_t *)dbuf + sizeof(*dbuf);
- unsigned int extra = dbuf->extra;
-
- *dbufp = NULL; /* destroy external reference */
- dbuf->mctx = NULL;
-
- if (dbuf->base != bdata) {
- isc_mem_put(mctx, dbuf->base, dbuf->length);
- }
-
- isc_buffer_invalidate(dbuf);
- isc_mem_put(mctx, dbuf, sizeof(*dbuf) + extra);
-}
-
-isc_result_t
-isc_buffer_printf(isc_buffer_t *b, const char *format, ...) {
- va_list ap;
- int n;
- isc_result_t result;
-
- REQUIRE(ISC_BUFFER_VALID(b));
-
- va_start(ap, format);
- n = vsnprintf(NULL, 0, format, ap);
- va_end(ap);
-
- if (n < 0) {
- return (ISC_R_FAILURE);
- }
-
- if (b->mctx) {
- result = isc_buffer_reserve(b, n + 1);
- if (result != ISC_R_SUCCESS) {
- return (result);
- }
- }
-
- if (isc_buffer_availablelength(b) < (unsigned int)n + 1) {
- return (ISC_R_NOSPACE);
- }
-
- va_start(ap, format);
- n = vsnprintf(isc_buffer_used(b), n + 1, format, ap);
- va_end(ap);
-
- if (n < 0) {
- return (ISC_R_FAILURE);
- }
-
- b->used += n;
-
- return (ISC_R_SUCCESS);
-}
#include <isc/lang.h>
#include <isc/list.h>
#include <isc/magic.h>
+#include <isc/mem.h>
#include <isc/region.h>
#include <isc/string.h>
#include <isc/types.h>
+#include <isc/util.h>
ISC_LANG_BEGINDECLS
*** Functions
***/
-void
+static inline void
isc_buffer_allocate(isc_mem_t *mctx, isc_buffer_t **dynbuffer,
unsigned int length);
/*!<
*\li Changing the buffer's length field is not permitted.
*/
-isc_result_t
+static inline isc_result_t
isc_buffer_reserve(isc_buffer_t *dynbuffer, unsigned int size);
/*!<
* \brief Make "size" bytes of space available in the buffer. The buffer
*\li ISC_R_NOMEMORY - no memory available
*/
-void
+static inline void
isc_buffer_free(isc_buffer_t **dynbuffer);
/*!<
* \brief Release resources allocated for a dynamic buffer.
* isc_buffer_allocate().
*/
-void
-isc__buffer_initnull(isc_buffer_t *b);
+static inline void
+isc_buffer_initnull(isc_buffer_t *b);
-void
+static inline void
isc_buffer_reinit(isc_buffer_t *b, void *base, unsigned int length);
/*!<
* \brief Make 'b' refer to the 'length'-byte region starting at base.
*
*/
-void
+static inline void
isc_buffer_compact(isc_buffer_t *b);
/*!<
* \brief Compact the used region by moving the remaining region so it occurs
*\li The used pointer in 'b' is advanced by 'length'.
*/
-isc_result_t
+static inline isc_result_t
isc_buffer_copyregion(isc_buffer_t *b, const isc_region_t *r);
/*!<
* \brief Copy the contents of 'r' into 'b'.
* big enough.
*/
-isc_result_t
+static inline isc_result_t
isc_buffer_dup(isc_mem_t *mctx, isc_buffer_t **dstp, const isc_buffer_t *src);
/*!<
* \brief Allocate 'dst' and copy used contents of 'src' into it.
*\li ISC_R_SUCCESS
*/
-isc_result_t
+static inline isc_result_t
isc_buffer_printf(isc_buffer_t *b, const char *format, ...)
ISC_FORMAT_PRINTF(2, 3);
/*!<
*/
static inline void
isc_buffer_init(isc_buffer_t *b, void *base, unsigned int length) {
- ISC_REQUIRE(b != NULL);
+ REQUIRE(b != NULL);
*b = (isc_buffer_t){
.base = base,
*/
static inline void
isc_buffer_invalidate(isc_buffer_t *b) {
- ISC_REQUIRE(ISC_BUFFER_VALID(b));
- ISC_REQUIRE(!ISC_LINK_LINKED(b, link));
- ISC_REQUIRE(b->mctx == NULL);
+ REQUIRE(ISC_BUFFER_VALID(b));
+ REQUIRE(!ISC_LINK_LINKED(b, link));
+ REQUIRE(b->mctx == NULL);
*b = (isc_buffer_t){
.magic = 0,
*/
static inline void
isc_buffer_region(isc_buffer_t *b, isc_region_t *r) {
- ISC_REQUIRE(ISC_BUFFER_VALID(b));
- ISC_REQUIRE(r != NULL);
+ REQUIRE(ISC_BUFFER_VALID(b));
+ REQUIRE(r != NULL);
r->base = b->base;
r->length = b->length;
*/
static inline void
isc_buffer_usedregion(const isc_buffer_t *b, isc_region_t *r) {
- ISC_REQUIRE(ISC_BUFFER_VALID(b));
- ISC_REQUIRE(r != NULL);
+ REQUIRE(ISC_BUFFER_VALID(b));
+ REQUIRE(r != NULL);
r->base = b->base;
r->length = b->used;
*/
static inline void
isc_buffer_availableregion(isc_buffer_t *b, isc_region_t *r) {
- ISC_REQUIRE(ISC_BUFFER_VALID(b));
- ISC_REQUIRE(r != NULL);
+ REQUIRE(ISC_BUFFER_VALID(b));
+ REQUIRE(r != NULL);
r->base = isc_buffer_used(b);
r->length = isc_buffer_availablelength(b);
*/
static inline void
isc_buffer_add(isc_buffer_t *b, unsigned int n) {
- ISC_REQUIRE(ISC_BUFFER_VALID(b));
- ISC_REQUIRE(b->used + n <= b->length);
+ REQUIRE(ISC_BUFFER_VALID(b));
+ REQUIRE(b->used + n <= b->length);
b->used += n;
}
*/
static inline void
isc_buffer_subtract(isc_buffer_t *b, unsigned int n) {
- ISC_REQUIRE(ISC_BUFFER_VALID(b));
- ISC_REQUIRE(b->used >= n);
+ REQUIRE(ISC_BUFFER_VALID(b));
+ REQUIRE(b->used >= n);
b->used -= n;
if (b->current > b->used) {
*/
static inline void
isc_buffer_clear(isc_buffer_t *b) {
- ISC_REQUIRE(ISC_BUFFER_VALID(b));
+ REQUIRE(ISC_BUFFER_VALID(b));
b->used = 0;
b->current = 0;
*/
static inline void
isc_buffer_consumedregion(isc_buffer_t *b, isc_region_t *r) {
- ISC_REQUIRE(ISC_BUFFER_VALID(b));
- ISC_REQUIRE(r != NULL);
+ REQUIRE(ISC_BUFFER_VALID(b));
+ REQUIRE(r != NULL);
r->base = b->base;
r->length = b->current;
*/
static inline void
isc_buffer_remainingregion(isc_buffer_t *b, isc_region_t *r) {
- ISC_REQUIRE(ISC_BUFFER_VALID(b));
- ISC_REQUIRE(r != NULL);
+ REQUIRE(ISC_BUFFER_VALID(b));
+ REQUIRE(r != NULL);
r->base = isc_buffer_current(b);
r->length = isc_buffer_remaininglength(b);
*/
static inline void
isc_buffer_activeregion(isc_buffer_t *b, isc_region_t *r) {
- ISC_REQUIRE(ISC_BUFFER_VALID(b));
- ISC_REQUIRE(r != NULL);
+ REQUIRE(ISC_BUFFER_VALID(b));
+ REQUIRE(r != NULL);
if (b->current < b->active) {
r->base = isc_buffer_current(b);
*/
static inline void
isc_buffer_setactive(isc_buffer_t *b, unsigned int n) {
- ISC_REQUIRE(ISC_BUFFER_VALID(b));
- ISC_REQUIRE(b->current + n <= b->used);
+ REQUIRE(ISC_BUFFER_VALID(b));
+ REQUIRE(b->current + n <= b->used);
b->active = b->current + n;
}
*/
static inline void
isc_buffer_first(isc_buffer_t *b) {
- ISC_REQUIRE(ISC_BUFFER_VALID(b));
+ REQUIRE(ISC_BUFFER_VALID(b));
b->current = 0;
}
*/
static inline void
isc_buffer_forward(isc_buffer_t *b, unsigned int n) {
- ISC_REQUIRE(ISC_BUFFER_VALID(b));
- ISC_REQUIRE(b->current + n <= b->used);
+ REQUIRE(ISC_BUFFER_VALID(b));
+ REQUIRE(b->current + n <= b->used);
b->current += n;
}
*/
static inline void
isc_buffer_back(isc_buffer_t *b, unsigned int n) {
- ISC_REQUIRE(ISC_BUFFER_VALID(b));
- ISC_REQUIRE(n <= b->current);
+ REQUIRE(ISC_BUFFER_VALID(b));
+ REQUIRE(n <= b->current);
b->current -= n;
}
static inline void
isc_buffer_putmem(isc_buffer_t *b, const unsigned char *base,
unsigned int length) {
- ISC_REQUIRE(ISC_BUFFER_VALID(b));
+ REQUIRE(ISC_BUFFER_VALID(b));
if (b->mctx) {
isc_result_t result = isc_buffer_reserve(b, length);
- ISC_REQUIRE(result == ISC_R_SUCCESS);
+ REQUIRE(result == ISC_R_SUCCESS);
}
- ISC_REQUIRE(isc_buffer_availablelength(b) >= (unsigned int)length);
+ REQUIRE(isc_buffer_availablelength(b) >= (unsigned int)length);
if (length > 0U) {
memmove(isc_buffer_used(b), base, length);
unsigned int length;
unsigned char *cp;
- ISC_REQUIRE(ISC_BUFFER_VALID(b));
- ISC_REQUIRE(source != NULL);
+ REQUIRE(ISC_BUFFER_VALID(b));
+ REQUIRE(source != NULL);
length = (unsigned int)strlen(source);
if (b->mctx) {
isc_result_t result = isc_buffer_reserve(b, length);
- ISC_ENSURE(result == ISC_R_SUCCESS);
+ ENSURE(result == ISC_R_SUCCESS);
}
- ISC_REQUIRE(isc_buffer_availablelength(b) >= length);
+ REQUIRE(isc_buffer_availablelength(b) >= length);
cp = isc_buffer_used(b);
memmove(cp, source, length);
b->used += length;
}
+
+static inline void
+isc_buffer_reinit(isc_buffer_t *b, void *base, unsigned int length) {
+ /*
+ * Re-initialize the buffer enough to reconfigure the base of the
+ * buffer. We will swap in the new buffer, after copying any
+ * data we contain into the new buffer and adjusting all of our
+ * internal pointers.
+ *
+ * The buffer must not be smaller than the length of the original
+ * buffer.
+ */
+ REQUIRE(b->length <= length);
+ REQUIRE(base != NULL);
+ REQUIRE(b->mctx == NULL);
+
+ if (b->length > 0U) {
+ (void)memmove(base, b->base, b->length);
+ }
+
+ b->base = base;
+ b->length = length;
+}
+
+static inline void
+isc_buffer_compact(isc_buffer_t *b) {
+ unsigned int length;
+ void *src;
+
+ /*
+ * Compact the used region by moving the remaining region so it occurs
+ * at the start of the buffer. The used region is shrunk by the size
+ * of the consumed region, and the consumed region is then made empty.
+ */
+
+ REQUIRE(ISC_BUFFER_VALID(b));
+
+ src = isc_buffer_current(b);
+ length = isc_buffer_remaininglength(b);
+ if (length > 0U) {
+ (void)memmove(b->base, src, (size_t)length);
+ }
+
+ if (b->active > b->current) {
+ b->active -= b->current;
+ } else {
+ b->active = 0;
+ }
+ b->current = 0;
+ b->used = length;
+}
+
+static inline void
+isc_buffer_allocate(isc_mem_t *mctx, isc_buffer_t **dbufp,
+ unsigned int length) {
+ REQUIRE(dbufp != NULL && *dbufp == NULL);
+
+ isc_buffer_t *dbuf = isc_mem_get(mctx, sizeof(*dbuf) + length);
+ uint8_t *bdata = (uint8_t *)dbuf + sizeof(*dbuf);
+
+ isc_buffer_init(dbuf, bdata, length);
+ dbuf->extra = length;
+ dbuf->mctx = mctx;
+
+ *dbufp = dbuf;
+}
+
+static inline isc_result_t
+isc_buffer_reserve(isc_buffer_t *dbuf, unsigned int size) {
+ REQUIRE(ISC_BUFFER_VALID(dbuf));
+
+ size_t len;
+ uint8_t *bdata = (uint8_t *)dbuf + sizeof(*dbuf);
+
+ len = dbuf->length;
+ if ((len - dbuf->used) >= size) {
+ return (ISC_R_SUCCESS);
+ }
+
+ if (dbuf->mctx == NULL) {
+ return (ISC_R_NOSPACE);
+ }
+
+ /* Round to nearest buffer size increment */
+ len = size + dbuf->used;
+ len = ISC_ALIGN(len, ISC_BUFFER_INCR);
+
+ /* Cap at UINT_MAX */
+ if (len > UINT_MAX) {
+ len = UINT_MAX;
+ }
+
+ if ((len - dbuf->used) < size) {
+ return (ISC_R_NOMEMORY);
+ }
+
+ if (dbuf->base == bdata) {
+ dbuf->base = isc_mem_get(dbuf->mctx, len);
+ memmove(dbuf->base, bdata, dbuf->used);
+ } else {
+ dbuf->base = isc_mem_reget(dbuf->mctx, dbuf->base, dbuf->length,
+ len);
+ }
+ dbuf->length = (unsigned int)len;
+
+ return (ISC_R_SUCCESS);
+}
+
+static inline void
+isc_buffer_free(isc_buffer_t **dbufp) {
+ REQUIRE(dbufp != NULL && ISC_BUFFER_VALID(*dbufp));
+ REQUIRE((*dbufp)->mctx != NULL);
+
+ isc_buffer_t *dbuf = *dbufp;
+ isc_mem_t *mctx = dbuf->mctx;
+ uint8_t *bdata = (uint8_t *)dbuf + sizeof(*dbuf);
+ unsigned int extra = dbuf->extra;
+
+ *dbufp = NULL; /* destroy external reference */
+ dbuf->mctx = NULL;
+
+ if (dbuf->base != bdata) {
+ isc_mem_put(mctx, dbuf->base, dbuf->length);
+ }
+
+ isc_buffer_invalidate(dbuf);
+ isc_mem_put(mctx, dbuf, sizeof(*dbuf) + extra);
+}
+
+static inline isc_result_t
+isc_buffer_dup(isc_mem_t *mctx, isc_buffer_t **dstp, const isc_buffer_t *src) {
+ isc_buffer_t *dst = NULL;
+ isc_region_t region;
+ isc_result_t result;
+
+ REQUIRE(dstp != NULL && *dstp == NULL);
+ REQUIRE(ISC_BUFFER_VALID(src));
+
+ isc_buffer_usedregion(src, ®ion);
+
+ isc_buffer_allocate(mctx, &dst, region.length);
+
+ result = isc_buffer_copyregion(dst, ®ion);
+ RUNTIME_CHECK(result == ISC_R_SUCCESS); /* NOSPACE is impossible */
+ *dstp = dst;
+ return (ISC_R_SUCCESS);
+}
+
+static inline isc_result_t
+isc_buffer_copyregion(isc_buffer_t *b, const isc_region_t *r) {
+ isc_result_t result;
+
+ REQUIRE(ISC_BUFFER_VALID(b));
+ REQUIRE(r != NULL);
+
+ if (b->mctx) {
+ result = isc_buffer_reserve(b, r->length);
+ if (result != ISC_R_SUCCESS) {
+ return (result);
+ }
+ }
+
+ if (r->length > isc_buffer_availablelength(b)) {
+ return (ISC_R_NOSPACE);
+ }
+
+ if (r->length > 0U) {
+ memmove(isc_buffer_used(b), r->base, r->length);
+ b->used += r->length;
+ }
+
+ return (ISC_R_SUCCESS);
+}
+
+static inline isc_result_t
+isc_buffer_printf(isc_buffer_t *b, const char *format, ...) {
+ va_list ap;
+ int n;
+ isc_result_t result;
+
+ REQUIRE(ISC_BUFFER_VALID(b));
+
+ va_start(ap, format);
+ n = vsnprintf(NULL, 0, format, ap);
+ va_end(ap);
+
+ if (n < 0) {
+ return (ISC_R_FAILURE);
+ }
+
+ if (b->mctx) {
+ result = isc_buffer_reserve(b, n + 1);
+ if (result != ISC_R_SUCCESS) {
+ return (result);
+ }
+ }
+
+ if (isc_buffer_availablelength(b) < (unsigned int)n + 1) {
+ return (ISC_R_NOSPACE);
+ }
+
+ va_start(ap, format);
+ n = vsnprintf(isc_buffer_used(b), n + 1, format, ap);
+ va_end(ap);
+
+ if (n < 0) {
+ return (ISC_R_FAILURE);
+ }
+
+ b->used += n;
+
+ return (ISC_R_SUCCESS);
+}
+
ISC_LANG_ENDDECLS
projects / thirdparty / bind9.git / commitdiff
