GCOV - Varnish Cache


/*-
 * Copyright (c) 2000-2008 Poul-Henning Kamp <phk@FreeBSD.org>
 * Copyright (c) 2000-2008 Dag-Erling Coïdan Smørgrav
 * All rights reserved.
 *
 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer
 *    in this position and unchanged.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
__FBSDID("$FreeBSD: head/sys/kern/subr_vsb.c 222004 2011-05-17 06:36:32Z phk $")
 */

#include "config.h"

#include <ctype.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "vdef.h"
#include "vas.h"        // XXX Flexelint "not used" - but req'ed for assert()
#include "vsb.h"

#define KASSERT(e, m)           assert(e)
#define SBMALLOC(size)          malloc(size)
#define SBFREE(buf)             free(buf)

#define rndup2(x, y)    (((x)+((y)-1))&(~((y)-1))) /* if y is powers of two */

/*
 * Predicates
 */
#define VSB_ISDYNAMIC(s)        ((s)->s_flags & VSB_DYNAMIC)
#define VSB_ISDYNSTRUCT(s)      ((s)->s_flags & VSB_DYNSTRUCT)
#define VSB_HASROOM(s)          ((s)->s_len < (s)->s_size - 1L)
#define VSB_FREESPACE(s)        ((s)->s_size - ((s)->s_len + 1L))
#define VSB_CANEXTEND(s)        ((s)->s_flags & VSB_AUTOEXTEND)

/*
 * Set / clear flags
 */
#define VSB_SETFLAG(s, f)       do { (s)->s_flags |= (f); } while (0)
#define VSB_CLEARFLAG(s, f)     do { (s)->s_flags &= ~(f); } while (0)

#define VSB_MINEXTENDSIZE       16              /* Should be power of 2. */

#ifdef PAGE_SIZE
#define VSB_MAXEXTENDSIZE       PAGE_SIZE
#define VSB_MAXEXTENDINCR       PAGE_SIZE
#else
#define VSB_MAXEXTENDSIZE       4096
#define VSB_MAXEXTENDINCR       4096
#endif

/*
 * Debugging support
 */
#if !defined(NDEBUG)
static void
_assert_VSB_integrity(const char *fun, const struct vsb *s)
{

        (void)fun;
        (void)s;
        KASSERT(s != NULL,
            ("%s called with a NULL vsb pointer", fun));
        KASSERT(s->magic == VSB_MAGIC,
            ("%s called with a bogus vsb pointer", fun));
        KASSERT(s->s_buf != NULL,
            ("%s called with uninitialized or corrupt vsb", fun));
        KASSERT(s->s_len < s->s_size,
            ("wrote past end of vsb (%d >= %d)", s->s_len, s->s_size));
}

static void
_assert_VSB_state(const char *fun, const struct vsb *s, int state)
{

        (void)fun;
        (void)s;
        (void)state;
        KASSERT((s->s_flags & VSB_FINISHED) == state,
            ("%s called with %sfinished or corrupt vsb", fun,
            (state ? "un" : "")));
}
#define assert_VSB_integrity(s) _assert_VSB_integrity(__func__, (s))
#define assert_VSB_state(s, i)   _assert_VSB_state(__func__, (s), (i))
#else
#define assert_VSB_integrity(s) do { } while (0)
#define assert_VSB_state(s, i)   do { } while (0)
#endif

#ifdef CTASSERT
CTASSERT(powerof2(VSB_MAXEXTENDSIZE));
CTASSERT(powerof2(VSB_MAXEXTENDINCR));
#endif

static ssize_t
VSB_extendsize(ssize_t size)
{
        ssize_t newsize;

        if (size < (int)VSB_MAXEXTENDSIZE) {
                newsize = VSB_MINEXTENDSIZE;
                while (newsize < size)
                        newsize *= 2;
        } else {
                newsize = rndup2(size, VSB_MAXEXTENDINCR);
        }
        KASSERT(newsize >= size, ("%s: %d < %d\n", __func__, newsize, size));
        return (newsize);
}

/*
 * Extend an vsb.
 */
static ssize_t
VSB_extend(struct vsb *s, ssize_t addlen)
{
        char *newbuf;
        ssize_t newsize;

        if (!VSB_CANEXTEND(s))
                return (-1);
        newsize = VSB_extendsize(s->s_size + addlen);
        if (VSB_ISDYNAMIC(s))
                newbuf = realloc(s->s_buf, newsize);
        else
                newbuf = SBMALLOC(newsize);
        if (newbuf == NULL)
                return (-1);
        if (!VSB_ISDYNAMIC(s)) {
                vmemcpy(newbuf, s->s_buf, s->s_size);
                VSB_SETFLAG(s, VSB_DYNAMIC);
        }
        s->s_buf = newbuf;
        s->s_size = newsize;
        return (0);
}

static void
_vsb_indent(struct vsb *s)
{
        if (s->s_indent == 0 || s->s_error != 0 ||
            (s->s_len > 0 && s->s_buf[s->s_len - 1] != '\n'))
                return;
        if (VSB_FREESPACE(s) <= s->s_indent &&
            VSB_extend(s, s->s_indent) < 0) {
                s->s_error = ENOMEM;
                return;
        }
        memset(s->s_buf + s->s_len, ' ', s->s_indent);
        s->s_len += s->s_indent;
}

/*
 * Initialize the internals of an vsb.
 * If buf is non-NULL, it points to a static or already-allocated string
 * big enough to hold at least length characters.
 */
static struct vsb *
VSB_newbuf(struct vsb *s, char *buf, int length, int flags)
{

        memset(s, 0, sizeof(*s));
        s->magic = VSB_MAGIC;
        s->s_flags = flags;
        s->s_size = length;
        s->s_buf = buf;

        if ((s->s_flags & VSB_AUTOEXTEND) == 0) {
                KASSERT(s->s_size > 1,
                    ("attempt to create a too small vsb"));
        }

        if (s->s_buf != NULL)
                return (s);

        if ((flags & VSB_AUTOEXTEND) != 0)
                s->s_size = VSB_extendsize(s->s_size);

        s->s_buf = SBMALLOC(s->s_size);
        if (s->s_buf == NULL)
                return (NULL);
        VSB_SETFLAG(s, VSB_DYNAMIC);
        return (s);
}

struct vsb *
VSB_init(struct vsb *s, void *buf, ssize_t length)
{
        AN(s);
        AN(buf);

        KASSERT(length >= 0,
            ("attempt to create an vsb of negative length (%zd)", length));
        return (VSB_newbuf(s, buf, length, VSB_FIXEDLEN));
}

/*
 * Allocate a dynamic vsb
 */
struct vsb *
VSB_new_auto(void)
{
        struct vsb *s;

        s = SBMALLOC(sizeof(*s));
        if (s == NULL)
                return (NULL);
        if (VSB_newbuf(s, NULL, 0, VSB_AUTOEXTEND) == NULL) {
                SBFREE(s);
                return (NULL);
        }
        VSB_SETFLAG(s, VSB_DYNSTRUCT);
        return (s);
}

/*
 * Clear an vsb and reset its position.
 */
void
VSB_clear(struct vsb *s)
{

        assert_VSB_integrity(s);
        /* don't care if it's finished or not */

        VSB_CLEARFLAG(s, VSB_FINISHED);
        s->s_error = 0;
        s->s_len = 0;
        s->s_indent = 0;
}

/*
 * Append a byte to an vsb.  This is the core function for appending
 * to an vsb and is the main place that deals with extending the
 * buffer and marking overflow.
 */
static void
VSB_put_byte(struct vsb *s, int c)
{

        assert_VSB_integrity(s);
        assert_VSB_state(s, 0);

        if (s->s_error != 0)
                return;
        _vsb_indent(s);
        if (VSB_FREESPACE(s) <= 0) {
                if (VSB_extend(s, 1) < 0)
                        s->s_error = ENOMEM;
                if (s->s_error != 0)
                        return;
        }
        s->s_buf[s->s_len++] = (char)c;
}

/*
 * Append a byte string to an vsb.
 */
int
VSB_bcat(struct vsb *s, const void *buf, ssize_t len)
{
        assert_VSB_integrity(s);
        assert_VSB_state(s, 0);

        assert(len >= 0);
        if (s->s_error != 0)
                return (-1);
        if (len == 0)
                return (0);
        _vsb_indent(s);
        if (len > VSB_FREESPACE(s)) {
                if (VSB_extend(s, len - VSB_FREESPACE(s)) < 0)
                        s->s_error = ENOMEM;
                if (s->s_error != 0)
                        return (-1);
        }
        vmemcpy(s->s_buf + s->s_len, buf, len);
        s->s_len += len;
        return (0);
}

/*
 * Append a string to an vsb.
 */
int
VSB_cat(struct vsb *s, const char *str)
{
        const char *nl;
        size_t l;

        assert_VSB_integrity(s);
        assert_VSB_state(s, 0);
        KASSERT(str != NULL,
            ("%s called with a NULL str pointer", __func__));

        if (s->s_error != 0)
                return (-1);

        while (s->s_indent > 0 && (nl = strchr(str, '\n')) != NULL) {
                l = (nl - str) + 1;
                if (VSB_bcat(s, str, l) < 0)
                        return (-1);
                str += l;
        }

        l = vstrlen(str);
        return (VSB_bcat(s, str, l));
}

/*
 * Format the given argument list and append the resulting string to an vsb.
 */
int
VSB_vprintf(struct vsb *s, const char *fmt, va_list ap)
{
        va_list ap_copy;
        int len;

        assert_VSB_integrity(s);
        assert_VSB_state(s, 0);

        KASSERT(fmt != NULL,
            ("%s called with a NULL format string", __func__));

        if (s->s_error != 0)
                return (-1);
        _vsb_indent(s);

        /*
         * For the moment, there is no way to get vsnprintf(3) to hand
         * back a character at a time, to push everything into
         * VSB_putc_func() as was done for the kernel.
         *
         * In userspace, while drains are useful, there's generally
         * not a problem attempting to malloc(3) on out of space.  So
         * expand a userland vsb if there is not enough room for the
         * data produced by VSB_[v]printf(3).
         */

        do {
                va_copy(ap_copy, ap);
                len = vsnprintf(&s->s_buf[s->s_len], VSB_FREESPACE(s) + 1,
                    fmt, ap_copy);
                va_end(ap_copy);
                if (len < 0) {
                        s->s_error = errno;
                        return (-1);
                }
        } while (len > VSB_FREESPACE(s) &&
            VSB_extend(s, len - VSB_FREESPACE(s)) == 0);

        /*
         * s->s_len is the length of the string, without the terminating nul.
         * When updating s->s_len, we must subtract 1 from the length that
         * we passed into vsnprintf() because that length includes the
         * terminating nul.
         *
         * vsnprintf() returns the amount that would have been copied,
         * given sufficient space, so don't over-increment s_len.
         */
        s->s_len += vmin_t(ssize_t, len, VSB_FREESPACE(s));
        if (!VSB_HASROOM(s) && !VSB_CANEXTEND(s))
                s->s_error = ENOMEM;

        KASSERT(s->s_len < s->s_size,
            ("wrote past end of vsb (%d >= %d)", s->s_len, s->s_size));

        if (s->s_error != 0)
                return (-1);
        return (0);
}

/*
 * Format the given arguments and append the resulting string to an vsb.
 */
int
VSB_printf(struct vsb *s, const char *fmt, ...)
{
        va_list ap;
        int result;

        va_start(ap, fmt);
        result = VSB_vprintf(s, fmt, ap);
        va_end(ap);
        return (result);
}

/*
 * Append a character to an vsb.
 */
int
VSB_putc(struct vsb *s, int c)
{

        VSB_put_byte(s, c);
        if (s->s_error != 0)
                return (-1);
        return (0);
}

/*
 * Check if an vsb has an error.
 */
int
VSB_error(const struct vsb *s)
{

        return (s->s_error);
}

/*
 * Finish off an vsb.
 */
int
VSB_finish(struct vsb *s)
{

        assert_VSB_integrity(s);
        assert_VSB_state(s, 0);

        s->s_buf[s->s_len] = '\0';
        VSB_SETFLAG(s, VSB_FINISHED);
        errno = s->s_error;
        if (s->s_error)
                return (-1);
        return (0);
}

/*
 * Return a pointer to the vsb data.
 */
char *
VSB_data(const struct vsb *s)
{

        assert_VSB_integrity(s);
        assert_VSB_state(s, VSB_FINISHED);

        return (s->s_buf);
}

/*
 * Return the length of the vsb data.
 */
ssize_t
VSB_len(const struct vsb *s)
{

        assert_VSB_integrity(s);
        /* don't care if it's finished or not */

        if (s->s_error != 0)
                return (-1);
        return (s->s_len);
}

void
VSB_fini(struct vsb *s)
{

        assert_VSB_integrity(s);
        assert(!VSB_ISDYNAMIC(s));
        assert(!VSB_ISDYNSTRUCT(s));
        memset(s, 0, sizeof(*s));
}

void
VSB_destroy(struct vsb **s)
{

        AN(s);
        assert_VSB_integrity(*s);
        assert(VSB_ISDYNAMIC(*s));
        assert(VSB_ISDYNSTRUCT(*s));
        SBFREE((*s)->s_buf);
        memset(*s, 0, sizeof(**s));
        SBFREE(*s);
        *s = NULL;
}

/*
 * Quote a string
 */

static void
vsb_quote_hex(struct vsb *s, const uint8_t *u, size_t len)
{
        const uint8_t *w;

        VSB_cat(s, "0x");
        for (w = u; w < u + len; w++)
                if (*w != 0x00)
                        break;
        if (w == u + len && len > 4) {
                VSB_cat(s, "0...0");
        } else {
                for (w = u; w < u + len; w++)
                        VSB_printf(s, "%02x", *w);
        }
}

void
VSB_quote_pfx(struct vsb *s, const char *pfx, const void *v, int len, int how)
{
        const uint8_t *p = v;
        const uint8_t *q;
        int quote = 0;
        int nl;

        nl = how &
            (VSB_QUOTE_JSON|VSB_QUOTE_HEX|VSB_QUOTE_CSTR|VSB_QUOTE_UNSAFE);
        AZ(nl & (nl - 1)); // Only one bit can be set

        if (how & VSB_QUOTE_ESCHEX)
                AZ(how & (VSB_QUOTE_JSON|VSB_QUOTE_HEX));

        if (how & VSB_QUOTE_UNSAFE)
                how |= VSB_QUOTE_NONL;

        assert(p != NULL);
        if (how & VSB_QUOTE_ABBREVIATE) {
                assert (len > 5);
                if (vstrlen(v) < (unsigned)len) {
                        len = vstrlen(v);
                        how &= ~VSB_QUOTE_ABBREVIATE;
                } else {
                        len -= 5;
                }
        }
        if (len == -1)
                len = vstrlen(v);

        if (len == 0 && (how & VSB_QUOTE_CSTR)) {
                VSB_printf(s, "%s\"\"", pfx);
                if ((how & VSB_QUOTE_NONL))
                        VSB_putc(s, '\n');
        }

        if (len == 0)
                return;

        VSB_cat(s, pfx);

        if (how & VSB_QUOTE_HEX) {
                vsb_quote_hex(s, v, len);
                if (how & VSB_QUOTE_NONL)
                        VSB_putc(s, '\n');
                return;
        }

        if (how & VSB_QUOTE_CSTR)
                VSB_putc(s, '"');

        for (q = p; q < p + len; q++) {
                if (
                    *q < 0x20 ||
                    *q == '"' ||
                    *q == '\\' ||
                    (*q == '?' && (how & VSB_QUOTE_CSTR)) ||
                    (*q > 0x7e && !(how & VSB_QUOTE_JSON))
                ) {
                        quote++;
                        break;
                }
        }

        if (!quote) {
                VSB_bcat(s, p, len);
                if (how & VSB_QUOTE_CSTR)
                        VSB_putc(s, '"');
                if (how & VSB_QUOTE_ABBREVIATE)
                        VSB_cat(s, "[...]");
                if ((how & VSB_QUOTE_NONL) &&
                    p[len-1] != '\n')
                        (void)VSB_putc(s, '\n');
                return;
        }

        nl = 0;
        for (q = p; q < p + len; q++) {
                if (nl)
                        VSB_cat(s, pfx);
                nl = 0;
                switch (*q) {
                case '?':
                        /* Avoid C Trigraph insanity */
                        if (how & VSB_QUOTE_CSTR && !(how & VSB_QUOTE_JSON))
                                (void)VSB_putc(s, '\\');
                        (void)VSB_putc(s, *q);
                        break;
                case '\\':
                case '"':
                        if (!(how & VSB_QUOTE_UNSAFE))
                                (void)VSB_putc(s, '\\');
                        (void)VSB_putc(s, *q);
                        break;
                case '\n':
                        if (how & VSB_QUOTE_CSTR) {
                                VSB_printf(s, "\\n\"\n%s\"", pfx);
                        } else if (how & VSB_QUOTE_JSON) {
                                VSB_cat(s, "\\n");
                        } else if (how & VSB_QUOTE_NONL) {
                                VSB_putc(s, *q);
                                nl = 1;
                        } else {
                                VSB_cat(s, "\\n");
                        }
                        break;
                case '\r':
                        VSB_cat(s, "\\r");
                        break;
                case '\t':
                        VSB_cat(s, "\\t");
                        break;
                default:
                        if (0x20 <= *q && *q <= 0x7e)
                                VSB_putc(s, *q);
                        else if (*q > 0x7e && (how & VSB_QUOTE_JSON))
                                VSB_putc(s, *q);
                        else if (how & VSB_QUOTE_JSON)
                                VSB_printf(s, "\\u%04x", *q);
                        else if (how & VSB_QUOTE_ESCHEX)
                                VSB_printf(s, "\\x%02x", *q);
                        else
                                VSB_printf(s, "\\%03o", *q);
                        break;
                }
        }
        if (how & VSB_QUOTE_CSTR)
                VSB_putc(s, '"');
        if (how & VSB_QUOTE_ABBREVIATE)
                VSB_cat(s, "[...]");
        if ((how & VSB_QUOTE_NONL) && !nl)
                VSB_putc(s, '\n');
}

void
VSB_quote(struct vsb *s, const void *v, int len, int how)
{
        VSB_quote_pfx(s, "", v, len, how);
}

/*
 * Indentation
 */

void
VSB_indent(struct vsb *s, int i)
{

        assert_VSB_integrity(s);
        if (s->s_indent + i < 0)
                s->s_error = EINVAL;
        else
                s->s_indent += i;
}

int
VSB_tofile(const struct vsb *s, int fd)
{
        const char *p;
        ssize_t r;
        size_t sz;

        assert_VSB_integrity(s);
        assert_VSB_state(s, VSB_FINISHED);
        assert(s->s_len >= 0);
        r = 0;
        p = s->s_buf;
        sz = (typeof(sz))s->s_len;
        while (sz > 0) {
                r = write(fd, p, sz);
                if (r < 0)
                        return (-1);
                assert((typeof(sz))r <= sz);
                p += r;
                sz -= r;
        }
        return (0);
}

		vinyl-cache/lib/libvinyl/vsb.c
0		/*-
1		* Copyright (c) 2000-2008 Poul-Henning Kamp <phk@FreeBSD.org>
2		* Copyright (c) 2000-2008 Dag-Erling Coïdan Smørgrav
3		* All rights reserved.
4		*
5		* SPDX-License-Identifier: BSD-2-Clause-FreeBSD
6		*
7		* Redistribution and use in source and binary forms, with or without
8		* modification, are permitted provided that the following conditions
9		* are met:
10		* 1. Redistributions of source code must retain the above copyright
11		* notice, this list of conditions and the following disclaimer
12		* in this position and unchanged.
13		* 2. Redistributions in binary form must reproduce the above copyright
14		* notice, this list of conditions and the following disclaimer in the
15		* documentation and/or other materials provided with the distribution.
16		*
17		* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18		* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19		* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20		* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
21		* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22		* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23		* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24		* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25		* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26		* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27		* SUCH DAMAGE.
28		__FBSDID("$FreeBSD: head/sys/kern/subr_vsb.c 222004 2011-05-17 06:36:32Z phk $")
29		*/
30
31		#include "config.h"
32
33		#include <ctype.h>
34		#include <stdarg.h>
35		#include <stdio.h>
36		#include <stdint.h>
37		#include <stdlib.h>
38		#include <string.h>
39		#include <unistd.h>
40
41		#include "vdef.h"
42		#include "vas.h" // XXX Flexelint "not used" - but req'ed for assert()
43		#include "vsb.h"
44
45		#define KASSERT(e, m) assert(e)
46		#define SBMALLOC(size) malloc(size)
47		#define SBFREE(buf) free(buf)
48
49		#define rndup2(x, y) (((x)+((y)-1))&(~((y)-1))) /* if y is powers of two */
50
51		/*
52		* Predicates
53		*/
54		#define VSB_ISDYNAMIC(s) ((s)->s_flags & VSB_DYNAMIC)
55		#define VSB_ISDYNSTRUCT(s) ((s)->s_flags & VSB_DYNSTRUCT)
56		#define VSB_HASROOM(s) ((s)->s_len < (s)->s_size - 1L)
57		#define VSB_FREESPACE(s) ((s)->s_size - ((s)->s_len + 1L))
58		#define VSB_CANEXTEND(s) ((s)->s_flags & VSB_AUTOEXTEND)
59
60		/*
61		* Set / clear flags
62		*/
63		#define VSB_SETFLAG(s, f) do { (s)->s_flags \|= (f); } while (0)
64		#define VSB_CLEARFLAG(s, f) do { (s)->s_flags &= ~(f); } while (0)
65
66		#define VSB_MINEXTENDSIZE 16 /* Should be power of 2. */
67
68		#ifdef PAGE_SIZE
69		#define VSB_MAXEXTENDSIZE PAGE_SIZE
70		#define VSB_MAXEXTENDINCR PAGE_SIZE
71		#else
72		#define VSB_MAXEXTENDSIZE 4096
73		#define VSB_MAXEXTENDINCR 4096
74		#endif
75
76		/*
77		* Debugging support
78		*/
79		#if !defined(NDEBUG)
80		static void
81	1959160326	_assert_VSB_integrity(const char fun, const struct vsb s)
82		{
83
84	1959160326	(void)fun;
85	1959160326	(void)s;
86	1959160326	KASSERT(s != NULL,
87		("%s called with a NULL vsb pointer", fun));
88	1959160326	KASSERT(s->magic == VSB_MAGIC,
89		("%s called with a bogus vsb pointer", fun));
90	1959160326	KASSERT(s->s_buf != NULL,
91		("%s called with uninitialized or corrupt vsb", fun));
92	1959160326	KASSERT(s->s_len < s->s_size,
93		("wrote past end of vsb (%d >= %d)", s->s_len, s->s_size));
94	1959160326	}
95
96		static void
97	1844980040	_assert_VSB_state(const char fun, const struct vsb s, int state)
98		{
99
100	1844980040	(void)fun;
101	1844980040	(void)s;
102	1844980040	(void)state;
103	1844980040	KASSERT((s->s_flags & VSB_FINISHED) == state,
104		("%s called with %sfinished or corrupt vsb", fun,
105		(state ? "un" : "")));
106	1844980040	}
107		#define assert_VSB_integrity(s) _assert_VSB_integrity(__func__, (s))
108		#define assert_VSB_state(s, i) _assert_VSB_state(__func__, (s), (i))
109		#else
110		#define assert_VSB_integrity(s) do { } while (0)
111		#define assert_VSB_state(s, i) do { } while (0)
112		#endif
113
114		#ifdef CTASSERT
115		CTASSERT(powerof2(VSB_MAXEXTENDSIZE));
116		CTASSERT(powerof2(VSB_MAXEXTENDINCR));
117		#endif
118
119		static ssize_t
120	92477749	VSB_extendsize(ssize_t size)
121		{
122		ssize_t newsize;
123
124	92477749	if (size < (int)VSB_MAXEXTENDSIZE) {
125	91519058	newsize = VSB_MINEXTENDSIZE;
126	218290430	while (newsize < size)
127	126771372	newsize *= 2;
128	91519058	} else {
129	958691	newsize = rndup2(size, VSB_MAXEXTENDINCR);
130		}
131	92477749	KASSERT(newsize >= size, ("%s: %d < %d\n", __func__, newsize, size));
132	92477749	return (newsize);
133		}
134
135		/*
136		* Extend an vsb.
137		*/
138		static ssize_t
139	53146488	VSB_extend(struct vsb *s, ssize_t addlen)
140		{
141		char *newbuf;
142		ssize_t newsize;
143
144	53146488	if (!VSB_CANEXTEND(s))
145	819	return (-1);
146	53145669	newsize = VSB_extendsize(s->s_size + addlen);
147	53145669	if (VSB_ISDYNAMIC(s))
148	53145669	newbuf = realloc(s->s_buf, newsize);
149		else
150	0	newbuf = SBMALLOC(newsize);
151	53145669	if (newbuf == NULL)
152	0	return (-1);
153	53145669	if (!VSB_ISDYNAMIC(s)) {
154	0	vmemcpy(newbuf, s->s_buf, s->s_size);
155	0	VSB_SETFLAG(s, VSB_DYNAMIC);
156	0	}
157	53145669	s->s_buf = newbuf;
158	53145669	s->s_size = newsize;
159	53145669	return (0);
160	53146488	}
161
162		static void
163	1619531006	_vsb_indent(struct vsb *s)
164		{
165	1622154614	if (s->s_indent == 0 \|\| s->s_error != 0 \|\|
166	2623608	(s->s_len > 0 && s->s_buf[s->s_len - 1] != '\n'))
167	1619361139	return;
168	169867	if (VSB_FREESPACE(s) <= s->s_indent &&
169	364	VSB_extend(s, s->s_indent) < 0) {
170	0	s->s_error = ENOMEM;
171	0	return;
172		}
173	169867	memset(s->s_buf + s->s_len, ' ', s->s_indent);
174	169867	s->s_len += s->s_indent;
175	1619531006	}
176
177		/*
178		* Initialize the internals of an vsb.
179		* If buf is non-NULL, it points to a static or already-allocated string
180		* big enough to hold at least length characters.
181		*/
182		static struct vsb *
183	40053137	VSB_newbuf(struct vsb s, char buf, int length, int flags)
184		{
185
186	40053137	memset(s, 0, sizeof(*s));
187	40053137	s->magic = VSB_MAGIC;
188	40053137	s->s_flags = flags;
189	40053137	s->s_size = length;
190	40053137	s->s_buf = buf;
191
192	40053137	if ((s->s_flags & VSB_AUTOEXTEND) == 0) {
193	720781	KASSERT(s->s_size > 1,
194		("attempt to create a too small vsb"));
195	720781	}
196
197	40053137	if (s->s_buf != NULL)
198	720781	return (s);
199
200	39332356	if ((flags & VSB_AUTOEXTEND) != 0)
201	39332338	s->s_size = VSB_extendsize(s->s_size);
202
203	39332356	s->s_buf = SBMALLOC(s->s_size);
204	39332356	if (s->s_buf == NULL)
205	0	return (NULL);
206	39332338	VSB_SETFLAG(s, VSB_DYNAMIC);
207	39332338	return (s);
208	40053119	}
209
210		struct vsb *
211	720794	VSB_init(struct vsb s, void buf, ssize_t length)
212		{
213	720794	AN(s);
214	720794	AN(buf);
215
216	720794	KASSERT(length >= 0,
217		("attempt to create an vsb of negative length (%zd)", length));
218	720794	return (VSB_newbuf(s, buf, length, VSB_FIXEDLEN));
219		}
220
221		/*
222		* Allocate a dynamic vsb
223		*/
224		struct vsb *
225	39332338	VSB_new_auto(void)
226		{
227		struct vsb *s;
228
229	39332338	s = SBMALLOC(sizeof(*s));
230	39332338	if (s == NULL)
231	0	return (NULL);
232	39332338	if (VSB_newbuf(s, NULL, 0, VSB_AUTOEXTEND) == NULL) {
233	0	SBFREE(s);
234	0	return (NULL);
235		}
236	39332338	VSB_SETFLAG(s, VSB_DYNSTRUCT);
237	39332338	return (s);
238	39332338	}
239
240		/*
241		* Clear an vsb and reset its position.
242		*/
243		void
244	53992256	VSB_clear(struct vsb *s)
245		{
246
247	53992256	assert_VSB_integrity(s);
248		/* don't care if it's finished or not */
249
250	53992256	VSB_CLEARFLAG(s, VSB_FINISHED);
251	53992256	s->s_error = 0;
252	53992256	s->s_len = 0;
253	53992256	s->s_indent = 0;
254	53992256	}
255
256		/*
257		* Append a byte to an vsb. This is the core function for appending
258		* to an vsb and is the main place that deals with extending the
259		* buffer and marking overflow.
260		*/
261		static void
262	1238453979	VSB_put_byte(struct vsb *s, int c)
263		{
264
265	1238453979	assert_VSB_integrity(s);
266	1238453979	assert_VSB_state(s, 0);
267
268	1238453979	if (s->s_error != 0)
269	0	return;
270	1238453979	_vsb_indent(s);
271	1238453979	if (VSB_FREESPACE(s) <= 0) {
272	12463649	if (VSB_extend(s, 1) < 0)
273	0	s->s_error = ENOMEM;
274	12463649	if (s->s_error != 0)
275	0	return;
276	12463649	}
277	1238453979	s->s_buf[s->s_len++] = (char)c;
278	1238453979	}
279
280		/*
281		* Append a byte string to an vsb.
282		*/
283		int
284	78324156	VSB_bcat(struct vsb s, const void buf, ssize_t len)
285		{
286	78324156	assert_VSB_integrity(s);
287	78324156	assert_VSB_state(s, 0);
288
289	78324156	assert(len >= 0);
290	78324156	if (s->s_error != 0)
291	0	return (-1);
292	78324156	if (len == 0)
293	5095538	return (0);
294	73228618	_vsb_indent(s);
295	73228618	if (len > VSB_FREESPACE(s)) {
296	14594044	if (VSB_extend(s, len - VSB_FREESPACE(s)) < 0)
297	168	s->s_error = ENOMEM;
298	14594044	if (s->s_error != 0)
299	168	return (-1);
300	14593876	}
301	73228450	vmemcpy(s->s_buf + s->s_len, buf, len);
302	73228450	s->s_len += len;
303	73228450	return (0);
304	78324156	}
305
306		/*
307		* Append a string to an vsb.
308		*/
309		int
310	71488988	VSB_cat(struct vsb s, const char str)
311		{
312		const char *nl;
313		size_t l;
314
315	71488988	assert_VSB_integrity(s);
316	71488988	assert_VSB_state(s, 0);
317	71488988	KASSERT(str != NULL,
318		("%s called with a NULL str pointer", __func__));
319
320	71488988	if (s->s_error != 0)
321	105	return (-1);
322
323	71513694	while (s->s_indent > 0 && (nl = strchr(str, '\n')) != NULL) {
324	24811	l = (nl - str) + 1;
325	24811	if (VSB_bcat(s, str, l) < 0)
326	0	return (-1);
327	24811	str += l;
328		}
329
330	71488883	l = vstrlen(str);
331	71488883	return (VSB_bcat(s, str, l));
332	71488988	}
333
334		/*
335		* Format the given argument list and append the resulting string to an vsb.
336		*/
337		int
338	308057110	VSB_vprintf(struct vsb s, const char fmt, va_list ap)
339		{
340		va_list ap_copy;
341		int len;
342
343	308057110	assert_VSB_integrity(s);
344	308057110	assert_VSB_state(s, 0);
345
346	308057110	KASSERT(fmt != NULL,
347		("%s called with a NULL format string", __func__));
348
349	308057110	if (s->s_error != 0)
350	0	return (-1);
351	308057110	_vsb_indent(s);
352
353		/*
354		* For the moment, there is no way to get vsnprintf(3) to hand
355		* back a character at a time, to push everything into
356		* VSB_putc_func() as was done for the kernel.
357		*
358		* In userspace, while drains are useful, there's generally
359		* not a problem attempting to malloc(3) on out of space. So
360		* expand a userland vsb if there is not enough room for the
361		* data produced by VSB_[v]printf(3).
362		*/
363
364	308057110	do {
365	334144433	va_copy(ap_copy, ap);
366	668288866	len = vsnprintf(&s->s_buf[s->s_len], VSB_FREESPACE(s) + 1,
367	334144433	fmt, ap_copy);
368	334144433	va_end(ap_copy);
369	334144433	if (len < 0) {
370	0	s->s_error = errno;
371	0	return (-1);
372		}
373	360232907	} while (len > VSB_FREESPACE(s) &&
374	26088474	VSB_extend(s, len - VSB_FREESPACE(s)) == 0);
375
376		/*
377		* s->s_len is the length of the string, without the terminating nul.
378		* When updating s->s_len, we must subtract 1 from the length that
379		* we passed into vsnprintf() because that length includes the
380		* terminating nul.
381		*
382		* vsnprintf() returns the amount that would have been copied,
383		* given sufficient space, so don't over-increment s_len.
384		*/
385	308057110	s->s_len += vmin_t(ssize_t, len, VSB_FREESPACE(s));
386	308057110	if (!VSB_HASROOM(s) && !VSB_CANEXTEND(s))
387	651	s->s_error = ENOMEM;
388
389	308057110	KASSERT(s->s_len < s->s_size,
390		("wrote past end of vsb (%d >= %d)", s->s_len, s->s_size));
391
392	308057110	if (s->s_error != 0)
393	638	return (-1);
394	308056472	return (0);
395	308057110	}
396
397		/*
398		* Format the given arguments and append the resulting string to an vsb.
399		*/
400		int
401	163495579	VSB_printf(struct vsb s, const char fmt, ...)
402		{
403		va_list ap;
404		int result;
405
406	163495579	va_start(ap, fmt);
407	163495579	result = VSB_vprintf(s, fmt, ap);
408	163495579	va_end(ap);
409	163495579	return (result);
410		}
411
412		/*
413		* Append a character to an vsb.
414		*/
415		int
416	1238449850	VSB_putc(struct vsb *s, int c)
417		{
418
419	1238449850	VSB_put_byte(s, c);
420	1238449850	if (s->s_error != 0)
421	0	return (-1);
422	1238449850	return (0);
423	1238449850	}
424
425		/*
426		* Check if an vsb has an error.
427		*/
428		int
429	32416	VSB_error(const struct vsb *s)
430		{
431
432	32416	return (s->s_error);
433		}
434
435		/*
436		* Finish off an vsb.
437		*/
438		int
439	72594200	VSB_finish(struct vsb *s)
440		{
441
442	72594200	assert_VSB_integrity(s);
443	72594200	assert_VSB_state(s, 0);
444
445	72594200	s->s_buf[s->s_len] = '\0';
446	72594200	VSB_SETFLAG(s, VSB_FINISHED);
447	72594200	errno = s->s_error;
448	72594200	if (s->s_error)
449	819	return (-1);
450	72593381	return (0);
451	72594200	}
452
453		/*
454		* Return a pointer to the vsb data.
455		*/
456		char *
457	74818633	VSB_data(const struct vsb *s)
458		{
459
460	74818633	assert_VSB_integrity(s);
461	74818633	assert_VSB_state(s, VSB_FINISHED);
462
463	74818633	return (s->s_buf);
464		}
465
466		/*
467		* Return the length of the vsb data.
468		*/
469		ssize_t
470	26899667	VSB_len(const struct vsb *s)
471		{
472
473	26899667	assert_VSB_integrity(s);
474		/* don't care if it's finished or not */
475
476	26899667	if (s->s_error != 0)
477	0	return (-1);
478	26899667	return (s->s_len);
479	26899667	}
480
481		void
482	699357	VSB_fini(struct vsb *s)
483		{
484
485	699357	assert_VSB_integrity(s);
486	699357	assert(!VSB_ISDYNAMIC(s));
487	699357	assert(!VSB_ISDYNSTRUCT(s));
488	699357	memset(s, 0, sizeof(*s));
489	699357	}
490
491		void
492	32738317	VSB_destroy(struct vsb **s)
493		{
494
495	32738317	AN(s);
496	32738317	assert_VSB_integrity(*s);
497	32738317	assert(VSB_ISDYNAMIC(*s));
498	32738317	assert(VSB_ISDYNSTRUCT(*s));
499	32738317	SBFREE((*s)->s_buf);