aiden
/
suricata
mirror of https://github.com/OISF/suricata
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

membuffer: turn complex macros into functions

Browse Source 
For better readability and type checking.
pull/10654/head
Victor Julien 3 years ago committed by Victor Julien
parent ea98df8da2
commit 3ef98f2b87
3 changed files with 81 additions and 68 deletions
Show Stats Download Patch File Download Diff File

6
src/output-json.c
Unescape Escape View File

@ -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);

68
src/util-buffer.c
Unescape Escape View File

@ -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';
}

75
src/util-buffer.h
Unescape Escape View File

@ -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 */

Write Preview
Loading…
Cancel
Save