#define FREE(cfg, ptr, s) \
(cfg)->Free ? (cfg)->Free((ptr), (s)) : SCFree((ptr))
-static void SBBFree(StreamingBuffer *sb);
+static void SBBFree(StreamingBuffer *sb, const StreamingBufferConfig *cfg);
RB_GENERATE(SBB, StreamingBufferBlock, rb, SBBCompare);
return res;
}
-static inline StreamingBufferRegion *InitBufferRegion(StreamingBuffer *sb, const uint32_t min_size)
+static inline StreamingBufferRegion *InitBufferRegion(
+ StreamingBuffer *sb, const StreamingBufferConfig *cfg, const uint32_t min_size)
{
- if (sb->regions == USHRT_MAX ||
- (sb->cfg->max_regions != 0 && sb->regions >= sb->cfg->max_regions)) {
+ if (sb->regions == USHRT_MAX || (cfg->max_regions != 0 && sb->regions >= cfg->max_regions)) {
SCLogDebug("max regions reached");
return NULL;
}
- StreamingBufferRegion *aux_r = CALLOC(sb->cfg, 1, sizeof(*aux_r));
+ StreamingBufferRegion *aux_r = CALLOC(cfg, 1, sizeof(*aux_r));
if (aux_r == NULL)
return NULL;
- aux_r->buf = CALLOC(sb->cfg, 1, MAX(sb->cfg->buf_size, min_size));
+ aux_r->buf = CALLOC(cfg, 1, MAX(cfg->buf_size, min_size));
if (aux_r->buf == NULL) {
- FREE(sb->cfg, aux_r, sizeof(*aux_r));
+ FREE(cfg, aux_r, sizeof(*aux_r));
return NULL;
}
- aux_r->buf_size = MAX(sb->cfg->buf_size, min_size);
+ aux_r->buf_size = MAX(cfg->buf_size, min_size);
sb->regions++;
sb->max_regions = MAX(sb->regions, sb->max_regions);
return aux_r;
}
-static inline int InitBuffer(StreamingBuffer *sb)
+static inline int InitBuffer(StreamingBuffer *sb, const StreamingBufferConfig *cfg)
{
- sb->region.buf = CALLOC(sb->cfg, 1, sb->cfg->buf_size);
+ sb->region.buf = CALLOC(cfg, 1, cfg->buf_size);
if (sb->region.buf == NULL) {
return -1;
}
- sb->region.buf_size = sb->cfg->buf_size;
+ sb->region.buf_size = cfg->buf_size;
return 0;
}
StreamingBuffer *sb = CALLOC(cfg, 1, sizeof(StreamingBuffer));
if (sb != NULL) {
sb->region.buf_size = cfg->buf_size;
- sb->cfg = cfg;
sb->regions = sb->max_regions = 1;
if (cfg->buf_size > 0) {
- if (InitBuffer(sb) == 0) {
+ if (InitBuffer(sb, cfg) == 0) {
return sb;
}
FREE(cfg, sb, sizeof(StreamingBuffer));
if (sb != NULL) {
SCLogDebug("sb->region.buf_size %u max %u", sb->region.buf_size, sb->buf_size_max);
- SBBFree(sb);
+ SBBFree(sb, cfg);
ListRegions(sb);
if (sb->region.buf != NULL) {
- FREE(sb->cfg, sb->region.buf, sb->region.buf_size);
+ FREE(cfg, sb->region.buf, sb->region.buf_size);
sb->region.buf = NULL;
}
for (StreamingBufferRegion *r = sb->region.next; r != NULL;) {
StreamingBufferRegion *next = r->next;
- FREE(sb->cfg, r->buf, r->buf_size);
- FREE(sb->cfg, r, sizeof(*r));
+ FREE(cfg, r->buf, r->buf_size);
+ FREE(cfg, r, sizeof(*r));
r = next;
}
sb->region.next = NULL;
{
if (sb != NULL) {
StreamingBufferClear(sb, cfg);
- FREE(sb->cfg, sb, sizeof(StreamingBuffer));
+ FREE(cfg, sb, sizeof(StreamingBuffer));
}
}
*
* [block][gap][block]
**/
-static void SBBInit(
- StreamingBuffer *sb, StreamingBufferRegion *region, uint32_t rel_offset, uint32_t data_len)
+static void SBBInit(StreamingBuffer *sb, const StreamingBufferConfig *cfg,
+ StreamingBufferRegion *region, uint32_t rel_offset, uint32_t data_len)
{
DEBUG_VALIDATE_BUG_ON(!RB_EMPTY(&sb->sbb_tree));
DEBUG_VALIDATE_BUG_ON(region->buf_offset > region->stream_offset + rel_offset);
/* need to set up 2: existing data block and new data block */
- StreamingBufferBlock *sbb = CALLOC(sb->cfg, 1, sizeof(*sbb));
+ StreamingBufferBlock *sbb = CALLOC(cfg, 1, sizeof(*sbb));
if (sbb == NULL) {
return;
}
sbb->offset = sb->region.stream_offset;
sbb->len = sb->region.buf_offset;
- StreamingBufferBlock *sbb2 = CALLOC(sb->cfg, 1, sizeof(*sbb2));
+ StreamingBufferBlock *sbb2 = CALLOC(cfg, 1, sizeof(*sbb2));
if (sbb2 == NULL) {
- FREE(sb->cfg, sbb, sizeof(*sbb));
+ FREE(cfg, sbb, sizeof(*sbb));
return;
}
sbb2->offset = region->stream_offset + rel_offset;
*
* [gap][block]
**/
-static void SBBInitLeadingGap(
- StreamingBuffer *sb, StreamingBufferRegion *region, uint64_t offset, uint32_t data_len)
+static void SBBInitLeadingGap(StreamingBuffer *sb, const StreamingBufferConfig *cfg,
+ StreamingBufferRegion *region, uint64_t offset, uint32_t data_len)
{
DEBUG_VALIDATE_BUG_ON(!RB_EMPTY(&sb->sbb_tree));
- StreamingBufferBlock *sbb = CALLOC(sb->cfg, 1, sizeof(*sbb));
+ StreamingBufferBlock *sbb = CALLOC(cfg, 1, sizeof(*sbb));
if (sbb == NULL)
return;
sbb->offset = offset;
#endif
}
-static inline void ConsolidateFwd(StreamingBuffer *sb, StreamingBufferRegion *region,
- struct SBB *tree, StreamingBufferBlock *sa)
+static inline void ConsolidateFwd(StreamingBuffer *sb, const StreamingBufferConfig *cfg,
+ StreamingBufferRegion *region, struct SBB *tree, StreamingBufferBlock *sa)
{
uint64_t sa_re = sa->offset + sa->len;
StreamingBufferBlock *tr, *s = sa;
SCLogDebug("-> (fwd) tr %p %" PRIu64 "/%u REMOVED ECLIPSED (sa overlapped by tr)", tr,
tr->offset, tr->len);
SBB_RB_REMOVE(tree, tr);
- FREE(sb->cfg, tr, sizeof(StreamingBufferBlock));
+ FREE(cfg, tr, sizeof(StreamingBufferBlock));
/* new block (sa) entire eclipses in tree block (tr)
sa: [ ]
tr: [ ]
tr->offset, tr->len);
SBB_RB_REMOVE(tree, tr);
sb->sbb_size -= tr->len;
- FREE(sb->cfg, tr, sizeof(StreamingBufferBlock));
+ FREE(cfg, tr, sizeof(StreamingBufferBlock));
SCLogDebug("-> (fwd) tr %p %" PRIu64 "/%u region %p so %" PRIu64 " bo %u sz %u", sa,
sa->offset, sa->len, region, region->stream_offset, region->buf_offset,
SCLogDebug("-> (fwd) tr %p %" PRIu64 "/%u REMOVED MERGED", tr, tr->offset, tr->len);
SBB_RB_REMOVE(tree, tr);
sb->sbb_size -= (combined_len - sa->len); // remove what we added twice
- FREE(sb->cfg, tr, sizeof(StreamingBufferBlock));
+ FREE(cfg, tr, sizeof(StreamingBufferBlock));
SCLogDebug("-> (fwd) tr %p %" PRIu64 "/%u RESULT", sa, sa->offset, sa->len);
SCLogDebug("-> (fwd) tr %p %" PRIu64 "/%u region %p so %" PRIu64 " bo %u sz %u", sa,
sa->offset, sa->len, region, region->stream_offset, region->buf_offset,
}
}
-static inline void ConsolidateBackward(StreamingBuffer *sb, StreamingBufferRegion *region,
- struct SBB *tree, StreamingBufferBlock *sa)
+static inline void ConsolidateBackward(StreamingBuffer *sb, const StreamingBufferConfig *cfg,
+ StreamingBufferRegion *region, struct SBB *tree, StreamingBufferBlock *sa)
{
uint64_t sa_re = sa->offset + sa->len;
StreamingBufferBlock *tr, *s = sa;
if (sb->head == tr)
sb->head = sa;
SBB_RB_REMOVE(tree, tr);
- FREE(sb->cfg, tr, sizeof(StreamingBufferBlock));
+ FREE(cfg, tr, sizeof(StreamingBufferBlock));
/* new block (sa) entire eclipses in tree block (tr)
sa: [ ]
tr: [ ]
sb->head = sa;
SBB_RB_REMOVE(tree, tr);
sb->sbb_size -= tr->len; // tr entirely eclipsed so remove double accounting
- FREE(sb->cfg, tr, sizeof(StreamingBufferBlock));
+ FREE(cfg, tr, sizeof(StreamingBufferBlock));
SCLogDebug("-> (bwd) tr %p %" PRIu64 "/%u region %p so %" PRIu64 " bo %u sz %u", sa,
sa->offset, sa->len, region, region->stream_offset, region->buf_offset,
sb->head = sa;
SBB_RB_REMOVE(tree, tr);
sb->sbb_size -= (combined_len - sa->len); // remove what we added twice
- FREE(sb->cfg, tr, sizeof(StreamingBufferBlock));
+ FREE(cfg, tr, sizeof(StreamingBufferBlock));
SCLogDebug("-> (bwd) tr %p %" PRIu64 "/%u region %p so %" PRIu64 " bo %u sz %u", sa,
sa->offset, sa->len, region, region->stream_offset, region->buf_offset,
/** \internal
* \param region the region that holds the new data
*/
-static int SBBUpdate(
- StreamingBuffer *sb, StreamingBufferRegion *region, uint32_t rel_offset, uint32_t len)
+static int SBBUpdate(StreamingBuffer *sb, const StreamingBufferConfig *cfg,
+ StreamingBufferRegion *region, uint32_t rel_offset, uint32_t len)
{
struct SBB *tree = &sb->sbb_tree;
SCLogDebug("* inserting: %u/%u", rel_offset, len);
- StreamingBufferBlock *sbb = CALLOC(sb->cfg, 1, sizeof(*sbb));
+ StreamingBufferBlock *sbb = CALLOC(cfg, 1, sizeof(*sbb));
if (sbb == NULL)
return -1;
sbb->offset = region->stream_offset + rel_offset;
// exact overlap
SCLogDebug("* insert failed: exact match in tree with %p %" PRIu64 "/%u", res, res->offset,
res->len);
- FREE(sb->cfg, sbb, sizeof(StreamingBufferBlock));
+ FREE(cfg, sbb, sizeof(StreamingBufferBlock));
return 0;
}
sb->sbb_size += len; // may adjust based on consolidation below
if (SBB_RB_PREV(sbb) == NULL) {
sb->head = sbb;
} else {
- ConsolidateBackward(sb, region, tree, sbb);
+ ConsolidateBackward(sb, cfg, region, tree, sbb);
}
- ConsolidateFwd(sb, region, tree, sbb);
+ ConsolidateFwd(sb, cfg, region, tree, sbb);
#ifdef DEBUG
SBBPrintList(sb);
#endif
return 0;
}
-static void SBBFree(StreamingBuffer *sb)
+static void SBBFree(StreamingBuffer *sb, const StreamingBufferConfig *cfg)
{
StreamingBufferBlock *sbb = NULL, *safe = NULL;
RB_FOREACH_SAFE(sbb, SBB, &sb->sbb_tree, safe) {
SBB_RB_REMOVE(&sb->sbb_tree, sbb);
sb->sbb_size -= sbb->len;
- FREE(sb->cfg, sbb, sizeof(StreamingBufferBlock));
+ FREE(cfg, sbb, sizeof(StreamingBufferBlock));
}
sb->head = NULL;
}
-static void SBBPrune(StreamingBuffer *sb)
+static void SBBPrune(StreamingBuffer *sb, const StreamingBufferConfig *cfg)
{
SCLogDebug("pruning %p to %" PRIu64, sb, sb->region.stream_offset);
StreamingBufferBlock *sbb = NULL, *safe = NULL;
sb->head = NULL;
sb->sbb_size -= sbb->len;
SCLogDebug("sb %p removed %p %" PRIu64 ", %u", sb, sbb, sbb->offset, sbb->len);
- FREE(sb->cfg, sbb, sizeof(StreamingBufferBlock));
+ FREE(cfg, sbb, sizeof(StreamingBufferBlock));
}
#ifdef DEBUG
SBBPrintList(sb);
static thread_local bool g2s_warn_once = false;
-static inline int WARN_UNUSED GrowRegionToSize(
- StreamingBuffer *sb, StreamingBufferRegion *region, const uint32_t size)
+static inline int WARN_UNUSED GrowRegionToSize(StreamingBuffer *sb,
+ const StreamingBufferConfig *cfg, StreamingBufferRegion *region, const uint32_t size)
{
DEBUG_VALIDATE_BUG_ON(region->buf_size > BIT_U32(30));
if (size > BIT_U32(30)) { // 1GiB
return -1;
}
- /* try to grow in multiples of sb->cfg->buf_size */
- uint32_t x = sb->cfg->buf_size ? size % sb->cfg->buf_size : 0;
+ /* try to grow in multiples of cfg->buf_size */
+ uint32_t x = cfg->buf_size ? size % cfg->buf_size : 0;
uint32_t base = size - x;
- uint32_t grow = base + sb->cfg->buf_size;
+ uint32_t grow = base + cfg->buf_size;
- void *ptr = REALLOC(sb->cfg, region->buf, region->buf_size, grow);
+ void *ptr = REALLOC(cfg, region->buf, region->buf_size, grow);
if (ptr == NULL) {
return -1;
}
return 0;
}
-static int WARN_UNUSED GrowToSize(StreamingBuffer *sb, uint32_t size)
+static int WARN_UNUSED GrowToSize(
+ StreamingBuffer *sb, const StreamingBufferConfig *cfg, uint32_t size)
{
- return GrowRegionToSize(sb, &sb->region, size);
+ return GrowRegionToSize(sb, cfg, &sb->region, size);
}
static inline bool RegionBeforeOffset(const StreamingBufferRegion *r, const uint64_t o)
SCLogDebug("main_is_oow");
if (sb->region.buf != NULL) {
SCLogDebug("clearing main");
- FREE(sb->cfg, sb->region.buf, sb->region.buf_size);
+ FREE(cfg, sb->region.buf, sb->region.buf_size);
sb->region.buf = NULL;
sb->region.buf_size = 0;
sb->region.buf_offset = 0;
BUG_ON(r == &sb->region);
prev->next = next;
- FREE(sb->cfg, r->buf, r->buf_size);
- FREE(sb->cfg, r, sizeof(*r));
+ FREE(cfg, r->buf, r->buf_size);
+ FREE(cfg, r, sizeof(*r));
sb->regions--;
BUG_ON(sb->regions == 0);
} else if (RegionContainsOffset(r, slide_offset)) {
sb->region.buf_size = to_shift->buf_size;
sb->region.next = to_shift->next;
- FREE(sb->cfg, to_shift, sizeof(*to_shift));
+ FREE(cfg, to_shift, sizeof(*to_shift));
to_shift = &sb->region;
sb->regions--;
BUG_ON(sb->regions == 0);
const uint32_t new_size = to_shift->buf_size - s;
SCLogDebug("s %u new_size %u", s, new_size);
memmove(to_shift->buf, to_shift->buf + s, new_size);
- void *ptr = REALLOC(sb->cfg, to_shift->buf, to_shift->buf_size, new_size);
+ void *ptr = REALLOC(cfg, to_shift->buf, to_shift->buf_size, new_size);
BUG_ON(ptr == NULL); // TODO
to_shift->buf = ptr;
to_shift->buf_size = new_size;
if (sb->region.next) {
StreamingBufferSlideToOffsetWithRegions(sb, cfg, offset);
- SBBPrune(sb);
+ SBBPrune(sb, cfg);
SCLogDebug("post SBBPrune");
ListRegions(sb);
#ifdef DEBUG
sb->region.buf_offset = 0;
}
}
- SBBPrune(sb);
+ SBBPrune(sb, cfg);
}
#ifdef DEBUG
SBBPrintList(sb);
const StreamingBufferConfig *cfg, const uint8_t *data, uint32_t data_len)
{
if (sb->region.buf == NULL) {
- if (InitBuffer(sb) == -1)
+ if (InitBuffer(sb, cfg) == -1)
return NULL;
}
if (!DATA_FITS(sb, data_len)) {
if (sb->region.buf_size == 0) {
- if (GrowToSize(sb, data_len) != 0)
+ if (GrowToSize(sb, cfg, data_len) != 0)
return NULL;
} else {
- if (GrowToSize(sb, sb->region.buf_offset + data_len) != 0)
+ if (GrowToSize(sb, cfg, sb->region.buf_offset + data_len) != 0)
return NULL;
}
}
DEBUG_VALIDATE_BUG_ON(!DATA_FITS(sb, data_len));
- StreamingBufferSegment *seg = CALLOC(sb->cfg, 1, sizeof(StreamingBufferSegment));
+ StreamingBufferSegment *seg = CALLOC(cfg, 1, sizeof(StreamingBufferSegment));
if (seg != NULL) {
memcpy(sb->region.buf + sb->region.buf_offset, data, data_len);
seg->stream_offset = sb->region.stream_offset + sb->region.buf_offset;
sb->region.buf_offset += data_len;
if (!RB_EMPTY(&sb->sbb_tree)) {
- SBBUpdate(sb, &sb->region, rel_offset, data_len);
+ SBBUpdate(sb, cfg, &sb->region, rel_offset, data_len);
}
return seg;
}
BUG_ON(seg == NULL);
if (sb->region.buf == NULL) {
- if (InitBuffer(sb) == -1)
+ if (InitBuffer(sb, cfg) == -1)
return -1;
}
if (!DATA_FITS(sb, data_len)) {
if (sb->region.buf_size == 0) {
- if (GrowToSize(sb, data_len) != 0)
+ if (GrowToSize(sb, cfg, data_len) != 0)
return -1;
} else {
- if (GrowToSize(sb, sb->region.buf_offset + data_len) != 0)
+ if (GrowToSize(sb, cfg, sb->region.buf_offset + data_len) != 0)
return -1;
}
}
sb->region.buf_offset += data_len;
if (!RB_EMPTY(&sb->sbb_tree)) {
- SBBUpdate(sb, &sb->region, rel_offset, data_len);
+ SBBUpdate(sb, cfg, &sb->region, rel_offset, data_len);
}
return 0;
}
const uint8_t *data, uint32_t data_len)
{
if (sb->region.buf == NULL) {
- if (InitBuffer(sb) == -1)
+ if (InitBuffer(sb, cfg) == -1)
return -1;
}
if (!DATA_FITS(sb, data_len)) {
if (sb->region.buf_size == 0) {
- if (GrowToSize(sb, data_len) != 0)
+ if (GrowToSize(sb, cfg, data_len) != 0)
return -1;
} else {
- if (GrowToSize(sb, sb->region.buf_offset + data_len) != 0)
+ if (GrowToSize(sb, cfg, sb->region.buf_offset + data_len) != 0)
return -1;
}
}
sb->region.buf_offset += data_len;
if (!RB_EMPTY(&sb->sbb_tree)) {
- SBBUpdate(sb, &sb->region, rel_offset, data_len);
+ SBBUpdate(sb, cfg, &sb->region, rel_offset, data_len);
}
return 0;
}
static void ListRegions(StreamingBuffer *sb)
{
- if (sb->cfg == NULL)
+ if (sb->region.buf == NULL && sb->region.buf_offset == 0 && sb->region.next == NULL)
return;
#ifdef DEBUG
#if DUMP_REGIONS == 1
* \brief does data region intersect with list region 'r'
* Takes the max gap into account.
*/
-static inline bool RegionsIntersect(const StreamingBuffer *sb, const StreamingBufferRegion *r,
- const uint64_t offset, const uint32_t len)
+static inline bool RegionsIntersect(const StreamingBuffer *sb, const StreamingBufferConfig *cfg,
+ const StreamingBufferRegion *r, const uint64_t offset, const uint32_t len)
{
const uint64_t re = offset + len;
/* create the data range for the region, adding the max gap */
const uint64_t reg_o =
- r->stream_offset > sb->cfg->region_gap ? (r->stream_offset - sb->cfg->region_gap) : 0;
- const uint64_t reg_re = r->stream_offset + r->buf_size + sb->cfg->region_gap;
+ r->stream_offset > cfg->region_gap ? (r->stream_offset - cfg->region_gap) : 0;
+ const uint64_t reg_re = r->stream_offset + r->buf_size + cfg->region_gap;
SCLogDebug("r %p: %" PRIu64 "/%" PRIu64 " - adjusted %" PRIu64 "/%" PRIu64, r, r->stream_offset,
r->stream_offset + r->buf_size, reg_o, reg_re);
/* check if data range intersects with region range */
* \brief find the first region for merging.
*/
static StreamingBufferRegion *FindFirstRegionForOffset(const StreamingBuffer *sb,
- StreamingBufferRegion *r, const uint64_t offset, const uint32_t len)
+ const StreamingBufferConfig *cfg, StreamingBufferRegion *r, const uint64_t offset,
+ const uint32_t len)
{
const uint64_t data_re = offset + len;
SCLogDebug("looking for first region matching %" PRIu64 "/%" PRIu64, offset, data_re);
for (; r != NULL; r = r->next) {
- if (RegionsIntersect(sb, r, offset, data_re) == true)
+ if (RegionsIntersect(sb, cfg, r, offset, data_re) == true)
return r;
}
return NULL;
}
static StreamingBufferRegion *FindLargestRegionForOffset(const StreamingBuffer *sb,
- StreamingBufferRegion *r, const uint64_t offset, const uint32_t len)
+ const StreamingBufferConfig *cfg, StreamingBufferRegion *r, const uint64_t offset,
+ const uint32_t len)
{
const uint64_t data_re = offset + len;
SCLogDebug("starting at %p/%" PRIu64 ", offset %" PRIu64 ", data_re %" PRIu64, r,
SCLogDebug("checking: %p/%" PRIu64 "/%" PRIu64 ", offset %" PRIu64 "/%" PRIu64, r,
r->stream_offset, reg_re, offset, data_re);
#endif
- if (!RegionsIntersect(sb, r, offset, data_re))
+ if (!RegionsIntersect(sb, cfg, r, offset, data_re))
return candidate;
if (candidate == NULL) {
return candidate;
}
-static StreamingBufferRegion *FindRightEdge(const StreamingBuffer *sb, StreamingBufferRegion *r,
- const uint64_t offset, const uint32_t len)
+static StreamingBufferRegion *FindRightEdge(const StreamingBuffer *sb,
+ const StreamingBufferConfig *cfg, StreamingBufferRegion *r, const uint64_t offset,
+ const uint32_t len)
{
const uint64_t data_re = offset + len;
StreamingBufferRegion *candidate = r;
for (; r != NULL; r = r->next) {
- if (!RegionsIntersect(sb, r, offset, data_re)) {
+ if (!RegionsIntersect(sb, cfg, r, offset, data_re)) {
SCLogDebug("r %p is out of scope: %" PRIu64 "/%u", r, offset, len);
return candidate;
}
* \brief process insert by consolidating the affected regions into one
*/
static StreamingBufferRegion *BufferInsertAtRegionConsolidate(StreamingBuffer *sb,
- StreamingBufferRegion *dst, StreamingBufferRegion *src_start,
- StreamingBufferRegion *src_end, const uint64_t data_offset, const uint32_t data_len)
+ const StreamingBufferConfig *cfg, StreamingBufferRegion *dst,
+ StreamingBufferRegion *src_start, StreamingBufferRegion *src_end,
+ const uint64_t data_offset, const uint32_t data_len)
{
const uint64_t data_re = data_offset + data_len;
SCLogDebug("sb %p dst %p src_start %p src_end %p data_offset %" PRIu64
SCLogDebug("old_size %u, old_offset %u, dst_copy_offset %u", old_size, old_offset,
dst_copy_offset);
#endif
- if (GrowRegionToSize(sb, dst, dst_size) != 0)
+ if (GrowRegionToSize(sb, cfg, dst, dst_size) != 0)
return NULL;
SCLogDebug("resized to %u", dst_size);
if (dst_copy_offset != 0)
memcpy(dst->buf + target_offset, r->buf, r->buf_size);
StreamingBufferRegion *next = r->next;
- FREE(sb->cfg, r->buf, r->buf_size);
- FREE(sb->cfg, r, sizeof(*r));
+ FREE(cfg, r->buf, r->buf_size);
+ FREE(cfg, r, sizeof(*r));
sb->regions--;
BUG_ON(sb->regions == 0);
if (prev != NULL) {
if (start_is_main && dst != &sb->region) {
BUG_ON(sb->region.next != dst);
SCLogDebug("start_is_main && dst != main region");
- FREE(sb->cfg, sb->region.buf, sb->region.buf_size);
+ FREE(cfg, sb->region.buf, sb->region.buf_size);
sb->region.buf = dst->buf;
sb->region.buf_size = dst->buf_size;
sb->region.buf_offset = new_offset;
SCLogDebug("sb->region.buf_offset set to %u", sb->region.buf_offset);
sb->region.next = dst->next;
- FREE(sb->cfg, dst, sizeof(*dst));
+ FREE(cfg, dst, sizeof(*dst));
dst = &sb->region;
sb->regions--;
BUG_ON(sb->regions == 0);
return dst;
}
-static StreamingBufferRegion *BufferInsertAtRegionDo(
- StreamingBuffer *sb, const uint64_t offset, const uint32_t len)
+static StreamingBufferRegion *BufferInsertAtRegionDo(StreamingBuffer *sb,
+ const StreamingBufferConfig *cfg, const uint64_t offset, const uint32_t len)
{
SCLogDebug("offset %" PRIu64 ", len %u", offset, len);
- StreamingBufferRegion *start = FindFirstRegionForOffset(sb, &sb->region, offset, len);
+ StreamingBufferRegion *start = FindFirstRegionForOffset(sb, cfg, &sb->region, offset, len);
if (start) {
SCLogDebug("start region %p/%" PRIu64 "/%u", start, start->stream_offset, start->buf_size);
- StreamingBufferRegion *big = FindLargestRegionForOffset(sb, start, offset, len);
+ StreamingBufferRegion *big = FindLargestRegionForOffset(sb, cfg, start, offset, len);
DEBUG_VALIDATE_BUG_ON(big == NULL);
if (big == NULL)
return NULL;
SCLogDebug("big region %p/%" PRIu64 "/%u", big, big->stream_offset, big->buf_size);
- StreamingBufferRegion *end = FindRightEdge(sb, big, offset, len);
+ StreamingBufferRegion *end = FindRightEdge(sb, cfg, big, offset, len);
DEBUG_VALIDATE_BUG_ON(end == NULL);
if (end == NULL)
return NULL;
SCLogDebug("end region %p/%" PRIu64 "/%u", end, end->stream_offset, end->buf_size);
StreamingBufferRegion *ret =
- BufferInsertAtRegionConsolidate(sb, big, start, end, offset, len);
+ BufferInsertAtRegionConsolidate(sb, cfg, big, start, end, offset, len);
return ret;
} else {
/* if there was no region we can use we add a new region and insert it */
SCLogDebug("no matching region found, append to %p (%s)", append,
append == &sb->region ? "main" : "aux");
- StreamingBufferRegion *add = InitBufferRegion(sb, len);
+ StreamingBufferRegion *add = InitBufferRegion(sb, cfg, len);
if (add == NULL)
return NULL;
add->stream_offset = offset;
* a good fit, it will try to set up a new region. If the region then overlaps or gets
* too close to the next, merge them.
*/
-static StreamingBufferRegion *BufferInsertAtRegion(StreamingBuffer *sb, const uint8_t *data,
- const uint32_t data_len, const uint64_t data_offset)
+static StreamingBufferRegion *BufferInsertAtRegion(StreamingBuffer *sb,
+ const StreamingBufferConfig *cfg, const uint8_t *data, const uint32_t data_len,
+ const uint64_t data_offset)
{
SCLogDebug("data_offset %" PRIu64 ", data_len %u, re %" PRIu64, data_offset, data_len,
data_offset + data_len);
ListRegions(sb);
- if (RegionsIntersect(sb, &sb->region, data_offset, data_len)) {
+ if (RegionsIntersect(sb, cfg, &sb->region, data_offset, data_len)) {
SCLogDebug("data_offset %" PRIu64 ", data_len %u intersects with main region (next %p)",
data_offset, data_len, sb->region.next);
if (sb->region.next == NULL ||
- !RegionsIntersect(sb, sb->region.next, data_offset, data_len)) {
+ !RegionsIntersect(sb, cfg, sb->region.next, data_offset, data_len)) {
SCLogDebug(
"data_offset %" PRIu64
", data_len %u intersects with main region, no next or way before next region",
data_offset, data_len);
if (sb->region.buf == NULL)
- if (InitBuffer(sb) == -1) // TODO init with size
+ if (InitBuffer(sb, cfg) == -1) // TODO init with size
return NULL;
return &sb->region;
}
} else if (sb->region.next == NULL) {
- StreamingBufferRegion *aux_r = sb->region.next = InitBufferRegion(sb, data_len);
+ StreamingBufferRegion *aux_r = sb->region.next = InitBufferRegion(sb, cfg, data_len);
if (aux_r == NULL)
return NULL;
aux_r->stream_offset = data_offset;
aux_r->stream_offset, aux_r->buf_size);
return aux_r;
}
- StreamingBufferRegion *blob = BufferInsertAtRegionDo(sb, data_offset, data_len);
+ StreamingBufferRegion *blob = BufferInsertAtRegionDo(sb, cfg, data_offset, data_len);
SCLogDebug("blob %p (%s)", blob, blob == &sb->region ? "main" : "aux");
return blob;
}
if (offset < sb->region.stream_offset)
return -2;
- StreamingBufferRegion *region = BufferInsertAtRegion(sb, data, data_len, offset);
+ StreamingBufferRegion *region = BufferInsertAtRegion(sb, cfg, data, data_len, offset);
if (region == NULL) {
return -1;
}
uint32_t rel_offset = offset - region->stream_offset;
if (!DATA_FITS_AT_OFFSET(region, data_len, rel_offset)) {
- if (GrowToSize(sb, (rel_offset + data_len)) != 0)
+ if (GrowToSize(sb, cfg, (rel_offset + data_len)) != 0)
return -1;
}
DEBUG_VALIDATE_BUG_ON(!DATA_FITS_AT_OFFSET(region, data_len, rel_offset));
} else if (sb->region.buf_offset) {
SCLogDebug("beyond expected offset: SBBInit");
/* existing data, but there is a gap between us */
- SBBInit(sb, region, rel_offset, data_len);
+ SBBInit(sb, cfg, region, rel_offset, data_len);
} else {
/* gap before data in empty list */
SCLogDebug("empty sbb list: invoking SBBInitLeadingGap");
- SBBInitLeadingGap(sb, region, offset, data_len);
+ SBBInitLeadingGap(sb, cfg, region, offset, data_len);
}
}
} else {
if (sb->region.buf_offset) {
/* existing data, but there is a gap between us */
SCLogDebug("empty sbb list, no data in main: use SBBInit");
- SBBInit(sb, region, rel_offset, data_len);
+ SBBInit(sb, cfg, region, rel_offset, data_len);
} else {
/* gap before data in empty list */
SCLogDebug("empty sbb list: invoking SBBInitLeadingGap");
- SBBInitLeadingGap(sb, region, offset, data_len);
+ SBBInitLeadingGap(sb, cfg, region, offset, data_len);
}
if (rel_offset == region->buf_offset) {
SCLogDebug("pre region->buf_offset %u", region->buf_offset);
} else {
SCLogDebug("updating sbb tree");
/* already have blocks, so append new block based on new data */
- SBBUpdate(sb, region, rel_offset, data_len);
+ SBBUpdate(sb, cfg, region, rel_offset, data_len);
}
BUG_ON(!region_is_main && sb->head == NULL);
projects / thirdparty / suricata.git / commitdiff
