From: Victor Julien Date: Fri, 24 Nov 2023 12:58:43 +0000 (+0100) Subject: membuffer: turn complex macros into functions X-Git-Tag: suricata-8.0.0-beta1~1615 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=3ef98f2b87e3cd1de022d9e7eb1581730c08bcdb;p=thirdparty%2Fsuricata.git membuffer: turn complex macros into functions For better readability and type checking. --- diff --git a/src/output-json.c b/src/output-json.c index be2cc81fe2..9c36e54769 100644 --- a/src/output-json.c +++ b/src/output-json.c @@ -892,7 +892,7 @@ int OutputJSONMemBufferCallback(const char *str, size_t size, void *data) MemBufferExpand(memb, wrapper->expand_by); } - MemBufferWriteRaw((*memb), str, size); + MemBufferWriteRaw((*memb), (const uint8_t *)str, size); return 0; } @@ -908,7 +908,7 @@ int OutputJSONBuffer(json_t *js, LogFileCtx *file_ctx, MemBuffer **buffer) } if (file_ctx->prefix) { - MemBufferWriteRaw((*buffer), file_ctx->prefix, file_ctx->prefix_len); + MemBufferWriteRaw((*buffer), (const uint8_t *)file_ctx->prefix, file_ctx->prefix_len); } OutputJSONMemBufferWrapper wrapper = { @@ -942,7 +942,7 @@ int OutputJsonBuilderBuffer(JsonBuilder *js, OutputJsonThreadCtx *ctx) MemBufferReset(*buffer); if (file_ctx->prefix) { - MemBufferWriteRaw((*buffer), file_ctx->prefix, file_ctx->prefix_len); + MemBufferWriteRaw((*buffer), (const uint8_t *)file_ctx->prefix, file_ctx->prefix_len); } size_t jslen = jb_len(js); diff --git a/src/util-buffer.c b/src/util-buffer.c index be7aee4046..a7d4d8bc0d 100644 --- a/src/util-buffer.c +++ b/src/util-buffer.c @@ -1,4 +1,4 @@ -/* Copyright (C) 2007-2012 Open Information Security Foundation +/* Copyright (C) 2007-2023 Open Information Security Foundation * * You can copy, redistribute or modify this Program under the terms of * the GNU General Public License version 2 as published by the Free @@ -40,14 +40,13 @@ MemBuffer *MemBufferCreateNew(uint32_t size) return NULL; } - uint32_t total_size = size + sizeof(MemBuffer); + size_t total_size = size + sizeof(MemBuffer); MemBuffer *buffer = SCCalloc(1, total_size); if (unlikely(buffer == NULL)) { sc_errno = SC_ENOMEM; return NULL; } - buffer->size = size; buffer->buffer = (uint8_t *)buffer + sizeof(MemBuffer); @@ -68,13 +67,12 @@ int MemBufferExpand(MemBuffer **buffer, uint32_t expand_by) { return -1; } - uint32_t total_size = (*buffer)->size + sizeof(MemBuffer) + expand_by; + size_t total_size = (*buffer)->size + sizeof(MemBuffer) + expand_by; MemBuffer *tbuffer = SCRealloc(*buffer, total_size); if (unlikely(tbuffer == NULL)) { return -1; } - *buffer = tbuffer; (*buffer)->size += expand_by; (*buffer)->buffer = (uint8_t *)tbuffer + sizeof(MemBuffer); @@ -89,3 +87,63 @@ void MemBufferFree(MemBuffer *buffer) return; } + +void MemBufferPrintToFP(MemBuffer *buffer, FILE *fp) +{ + for (uint32_t i = 0; i < buffer->offset; i++) { + if (isprint(buffer->buffer[i])) + fprintf(fp, "%c", buffer->buffer[i]); + else + fprintf(fp, "|%02X|", buffer->buffer[i]); + } +} + +size_t MemBufferPrintToFPAsString(MemBuffer *b, FILE *fp) +{ + return fwrite(MEMBUFFER_BUFFER(b), sizeof(uint8_t), MEMBUFFER_OFFSET(b), fp); +} + +void MemBufferPrintToFPAsHex(MemBuffer *b, FILE *fp) +{ + for (uint32_t i = 0; i < MEMBUFFER_OFFSET(b); i++) { + if (MEMBUFFER_OFFSET(b) % 8 == 0) + fprintf(fp, "\n"); + fprintf(fp, " %02X", b->buffer[i]); + } +} + +void MemBufferWriteRaw(MemBuffer *dst, const uint8_t *raw, const uint32_t raw_len) +{ + uint32_t write_len; + if (raw_len >= dst->size - dst->offset) { + SCLogDebug("Truncating data write since it exceeded buffer limit of %" PRIu32, dst->size); + write_len = dst->size - dst->offset - 1; + } else { + write_len = raw_len; + } + memcpy(dst->buffer + dst->offset, raw, write_len); + dst->offset += write_len; + dst->buffer[dst->offset] = '\0'; +} + +void MemBufferWriteString(MemBuffer *dst, const char *fmt, ...) +{ + uint32_t available = dst->size - dst->offset; + uint32_t max_string_size = MIN(available, 2048); + va_list ap; + char string[max_string_size]; + va_start(ap, fmt); + int written = vsnprintf(string, sizeof(string), fmt, ap); + va_end(ap); + if (written < 0) { + return; + } else if ((uint32_t)written > max_string_size) { + SCLogDebug("Truncating data write since it exceeded buffer " + "limit of %" PRIu32, + dst->size); + } + size_t string_size = strlen(string); + memcpy(dst->buffer + dst->offset, string, string_size); + dst->offset += string_size; + dst->buffer[dst->offset] = '\0'; +} diff --git a/src/util-buffer.h b/src/util-buffer.h index a396cc71ff..e6a0cd0679 100644 --- a/src/util-buffer.h +++ b/src/util-buffer.h @@ -1,4 +1,4 @@ -/* Copyright (C) 2007-2012 Open Information Security Foundation +/* Copyright (C) 2007-2023 Open Information Security Foundation * * You can copy, redistribute or modify this Program under the terms of * the GNU General Public License version 2 as published by the Free @@ -39,10 +39,11 @@ void MemBufferFree(MemBuffer *buffer); * * \param mem_buffer Pointer to the mem buffer instance. */ -#define MemBufferReset(mem_buffer) do { \ - (mem_buffer)->buffer[0] = 0; \ - (mem_buffer)->offset = 0; \ - } while (0) +static inline void MemBufferReset(MemBuffer *b) +{ + b->buffer[0] = 0; + b->offset = 0; +} /** * \brief Get the MemBuffers underlying buffer. @@ -73,43 +74,24 @@ void MemBufferFree(MemBuffer *buffer); * \param buffer Pointer to the src MemBuffer instance to write. * \param fp Pointer to the file instance to write to. */ -#define MemBufferPrintToFP(buffer, fp) do { \ - uint32_t i; \ - \ - for (i = 0; i < (buffer)->offset; i++) { \ - if (isprint(buffer->buffer[i])) \ - fprintf(fp, "%c", (buffer)->buffer[i]); \ - else \ - fprintf(fp, "|%02X|", (buffer)->buffer[i]); \ - } \ - } while (0) +void MemBufferPrintToFP(MemBuffer *buffer, FILE *fp); /** * \brief Write a buffer to the file pointer as a printable char string. * - * \param buffer Pointer to the src MemBuffer instance to write. - * \param fp Pointer to the file instance to write to. + * \param b Pointer to the src MemBuffer instance to write. + * \param fp Pointer to the file instance to write to. + * \retval size_t bytes written by fwrite() */ -#define MemBufferPrintToFPAsString(mem_buffer, fp) ({ \ - fwrite((mem_buffer)->buffer, sizeof(uint8_t), (mem_buffer)->offset, fp); \ -}) +size_t MemBufferPrintToFPAsString(MemBuffer *b, FILE *fp); /** * \brief Write a buffer in hex format. * - * \param buffer Pointer to the src MemBuffer instance to write. + * \param b Pointer to the src MemBuffer instance to write. * \param fp Pointer to the file instance to write to. */ -#define MemBufferPrintToFPAsHex(mem_buffer, fp) do { \ - uint32_t i; \ - \ - for (i = 0; i < (mem_buffer)->offset; i++) { \ - if (((mem_buffer)->offset % 8) == 0) \ - fprintf(fp, "\n"); \ - fprintf(fp, " %02X", (mem_buffer)->buffer[i]); \ - } \ - } while (0) - +void MemBufferPrintToFPAsHex(MemBuffer *b, FILE *fp); /** * \brief Write a raw buffer to the MemBuffer dst. @@ -130,21 +112,7 @@ void MemBufferFree(MemBuffer *buffer); * \param raw_buffer The buffer to write. * \param raw_buffer_len Length of the above buffer. */ -#define MemBufferWriteRaw(dst, raw_buffer, raw_buffer_len) do { \ - uint32_t write_len; \ - \ - if (((raw_buffer_len) >= (dst)->size - (dst)->offset)) { \ - SCLogDebug("Truncating data write since it exceeded buffer limit of " \ - "- %"PRIu32, (dst)->size); \ - write_len = ((dst)->size - (dst)->offset) - 1; \ - } else { \ - write_len = (raw_buffer_len); \ - } \ - \ - memcpy((dst)->buffer + (dst)->offset, (raw_buffer), write_len); \ - (dst)->offset += write_len; \ - dst->buffer[dst->offset] = '\0'; \ - } while (0) +void MemBufferWriteRaw(MemBuffer *dst, const uint8_t *raw, const uint32_t raw_len); /** * \brief Write a string buffer to the Membuffer dst. @@ -159,19 +127,6 @@ void MemBufferFree(MemBuffer *buffer); * \param format The format string. * \param ... Variable arguments. */ -#define MemBufferWriteString(dst, ...) do { \ - int cw = snprintf((char *)(dst)->buffer + (dst)->offset, \ - (dst)->size - (dst)->offset, \ - __VA_ARGS__); \ - if (cw >= 0) { \ - if ( ((dst)->offset + cw) >= (dst)->size) { \ - SCLogDebug("Truncating data write since it exceeded buffer " \ - "limit of - %"PRIu32"\n", (dst)->size); \ - (dst)->offset = (dst)->size - 1; \ - } else { \ - (dst->offset) += cw; \ - } \ - } \ - } while (0) +void MemBufferWriteString(MemBuffer *dst, const char *fmt, ...); #endif /* SURICATA_UTIL_BUFFER_H */