MemBuf.cc

Go to the documentation of this file.

/*
 * Copyright (C) 1996-2022 The Squid Software Foundation and contributors
 *
 * Squid software is distributed under GPLv2+ license and includes
 * contributions from numerous individuals and organizations.
 * Please see the COPYING and CONTRIBUTORS files for details.
 */
 
#include "squid.h"
#include "mem/forward.h"
#include "MemBuf.h"
 
/* local constants */
 
/* default values for buffer sizes, used by memBufDefInit */
#define MEM_BUF_INIT_SIZE   (2*1024)
#define MEM_BUF_MAX_SIZE    (2*1000*1024*1024)
 
CBDATA_CLASS_INIT(MemBuf);
 
void
MemBuf::init()
{
    init(MEM_BUF_INIT_SIZE, MEM_BUF_MAX_SIZE);
}
 
void
MemBuf::init(mb_size_t szInit, mb_size_t szMax)
{
    assert(szInit > 0 && szMax > 0);
    buf = NULL;
    size = 0;
    max_capacity = szMax;
    capacity = 0;
    stolen = 0;
    grow(szInit);
    terminate();
}
 
void
MemBuf::clean()
{
    if (isNull()) {
        // nothing to do
    } else {
        assert(buf);
        assert(!stolen);    /* not frozen */
 
        memFreeBuf(capacity, buf);
        buf = NULL;
        size = capacity = max_capacity = 0;
    }
}
 
void
MemBuf::reset()
{
    if (isNull()) {
        init();
    } else {
        assert(!stolen);    /* not frozen */
        /* reset */
        memset(buf, 0, capacity);
        size = 0;
    }
}
 
int
MemBuf::isNull() const
{
    if (!buf && !max_capacity && !capacity && !size)
        return 1;       /* is null (not initialized) */
 
    assert(buf && max_capacity && capacity);    /* paranoid */
 
    return 0;
}
 
mb_size_t MemBuf::spaceSize() const
{
    const mb_size_t terminatedSize = size + 1;
    return (terminatedSize < capacity) ? capacity - terminatedSize : 0;
}
 
mb_size_t MemBuf::potentialSpaceSize() const
{
    const mb_size_t terminatedSize = size + 1;
    return (terminatedSize < max_capacity) ? max_capacity - terminatedSize : 0;
}
 
void MemBuf::consume(mb_size_t shiftSize)
{
    const mb_size_t cSize = contentSize();
    assert(0 <= shiftSize && shiftSize <= cSize);
    assert(!stolen); /* not frozen */
 
    if (shiftSize > 0) {
        if (shiftSize < cSize)
            memmove(buf, buf + shiftSize, cSize - shiftSize);
 
        size -= shiftSize;
 
        terminate();
    }
}
 
void MemBuf::consumeWhitespacePrefix()
{
    if (contentSize() > 0) {
        const char *end = buf + contentSize();
        const char *p = buf;
        for (; p<end && xisspace(*p); ++p);
        if (p-buf > 0)
            consume(p-buf);
    }
}
 
// removes last tailSize bytes
void MemBuf::truncate(mb_size_t tailSize)
{
    const mb_size_t cSize = contentSize();
    assert(0 <= tailSize && tailSize <= cSize);
    assert(!stolen); /* not frozen */
    size -= tailSize;
}
 
void MemBuf::append(const char *newContent, int sz)
{
    assert(sz >= 0);
    assert(buf || (0==capacity && 0==size));
    assert(!stolen); /* not frozen */
 
    if (sz > 0) {
        if (size + sz + 1 > capacity)
            grow(size + sz + 1);
 
        assert(size + sz <= capacity); /* paranoid */
        memcpy(space(), newContent, sz);
        appended(sz);
    }
}
 
void MemBuf::appended(mb_size_t sz)
{
    assert(size + sz <= capacity);
    size += sz;
    terminate();
}
 
void MemBuf::terminate()
{
    assert(size < capacity);
    *space() = '\0';
}
 
void
MemBuf::vappendf(const char *fmt, va_list vargs)
{
    int sz = 0;
    assert(fmt);
    assert(buf);
    assert(!stolen);    /* not frozen */
    /* assert in Grow should quit first, but we do not want to have a scary infinite loop */
 
    while (capacity <= max_capacity) {
        mb_size_t free_space = capacity - size;
        /* put as much as we can */
 
        /* Fix of bug 753r. The value of vargs is undefined
         * after vsnprintf() returns. Make a copy of vargs
         * in case we loop around and call vsnprintf() again.
         */
        va_list ap;
        va_copy(ap,vargs);
        sz = vsnprintf(buf + size, free_space, fmt, ap);
        va_end(ap);
 
        /* check for possible overflow */
        /* snprintf on Linuz returns -1 on overflows */
        /* snprintf on FreeBSD returns at least free_space on overflows */
 
        if (sz < 0 || sz >= free_space)
            grow(capacity + 1);
        else
            break;
    }
 
    size += sz;
    /* on Linux and FreeBSD, '\0' is not counted in return value */
    /* on XXX it might be counted */
    /* check that '\0' is appended and not counted */
 
    if (!size || buf[size - 1]) {
        assert(!buf[size]);
    } else {
        --size;
    }
}
 
FREE *
MemBuf::freeFunc()
{
    FREE *ff;
    assert(buf);
    assert(!stolen);    /* not frozen */
 
    ff = memFreeBufFunc((size_t) capacity);
    stolen = 1;     /* freeze */
    return ff;
}
 
void
MemBuf::grow(mb_size_t min_cap)
{
    size_t new_cap;
    size_t buf_cap;
 
    assert(!stolen);
    assert(capacity < min_cap);
 
    /* determine next capacity */
 
    if (min_cap > 64 * 1024) {
        new_cap = 64 * 1024;
 
        while (new_cap < (size_t) min_cap)
            new_cap += 64 * 1024;   /* increase in reasonable steps */
    } else {
        new_cap = (size_t) min_cap;
    }
 
    /* last chance to fit before we assert(!overflow) */
    if (new_cap > (size_t) max_capacity)
        new_cap = (size_t) max_capacity;
 
    assert(new_cap <= (size_t) max_capacity);   /* no overflow */
 
    assert(new_cap > (size_t) capacity);    /* progress */
 
    buf_cap = (size_t) capacity;
 
    buf = (char *)memReallocBuf(buf, new_cap, &buf_cap);
 
    /* done */
    capacity = (mb_size_t) buf_cap;
}
 
/* Reports */
 
void
memBufReport(MemBuf * mb)
{
    assert(mb);
    mb->appendf("memBufReport is not yet implemented @?@\n");
}