varnish-cache/lib/libvarnish/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 1791601526
_assert_VSB_integrity(const char *fun, const struct vsb *s)
82
{
83
84 1791601526
        (void)fun;
85 1791601526
        (void)s;
86 1791601526
        KASSERT(s != NULL,
87
            ("%s called with a NULL vsb pointer", fun));
88 1791601526
        KASSERT(s->magic == VSB_MAGIC,
89
            ("%s called wih an bogus vsb pointer", fun));
90 1791601526
        KASSERT(s->s_buf != NULL,
91
            ("%s called with uninitialized or corrupt vsb", fun));
92 1791601526
        KASSERT(s->s_len < s->s_size,
93
            ("wrote past end of vsb (%d >= %d)", s->s_len, s->s_size));
94 1791601526
}
95
96
static void
97 1679222020
_assert_VSB_state(const char *fun, const struct vsb *s, int state)
98
{
99
100 1679222020
        (void)fun;
101 1679222020
        (void)s;
102 1679222020
        (void)state;
103 1679222020
        KASSERT((s->s_flags & VSB_FINISHED) == state,
104
            ("%s called with %sfinished or corrupt vsb", fun,
105
            (state ? "un" : "")));
106 1679222020
}
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 82769598
VSB_extendsize(ssize_t size)
121
{
122
        ssize_t newsize;
123
124 82769598
        if (size < (int)VSB_MAXEXTENDSIZE) {
125 81881952
                newsize = VSB_MINEXTENDSIZE;
126 188637245
                while (newsize < size)
127 106755293
                        newsize *= 2;
128 81881952
        } else {
129 887646
                newsize = rndup2(size, VSB_MAXEXTENDINCR);
130
        }
131 82769598
        KASSERT(newsize >= size, ("%s: %d < %d\n", __func__, newsize, size));
132 82769598
        return (newsize);
133
}
134
135
/*
136
 * Extend an vsb.
137
 */
138
static ssize_t
139 47035294
VSB_extend(struct vsb *s, ssize_t addlen)
140
{
141
        char *newbuf;
142
        ssize_t newsize;
143
144 47035294
        if (!VSB_CANEXTEND(s))
145 812
                return (-1);
146 47034482
        newsize = VSB_extendsize(s->s_size + addlen);
147 47034482
        if (VSB_ISDYNAMIC(s))
148 47034482
                newbuf = realloc(s->s_buf, newsize);
149
        else
150 0
                newbuf = SBMALLOC(newsize);
151 47034482
        if (newbuf == NULL)
152 0
                return (-1);
153 47034482
        if (!VSB_ISDYNAMIC(s)) {
154 0
                memcpy(newbuf, s->s_buf, s->s_size);
155 0
                VSB_SETFLAG(s, VSB_DYNAMIC);
156 0
        }
157 47034482
        s->s_buf = newbuf;
158 47034482
        s->s_size = newsize;
159 47034482
        return (0);
160 47035294
}
161
162
static void
163 1472409978
_vsb_indent(struct vsb *s)
164
{
165 1474677540
        if (s->s_indent == 0 || s->s_error != 0 ||
166 2267562
            (s->s_len > 0 && s->s_buf[s->s_len - 1] != '\n'))
167 1472235677
                return;
168 174301
        if (VSB_FREESPACE(s) <= s->s_indent &&
169 224
            VSB_extend(s, s->s_indent) < 0) {
170 0
                s->s_error = ENOMEM;
171 0
                return;
172
        }
173 174301
        memset(s->s_buf + s->s_len, ' ', s->s_indent);
174 174301
        s->s_len += s->s_indent;
175 1472409978
}
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 36515618
VSB_newbuf(struct vsb *s, char *buf, int length, int flags)
184
{
185
186 36515618
        memset(s, 0, sizeof(*s));
187 36515618
        s->magic = VSB_MAGIC;
188 36515618
        s->s_flags = flags;
189 36515618
        s->s_size = length;
190 36515618
        s->s_buf = buf;
191
192 36515618
        if ((s->s_flags & VSB_AUTOEXTEND) == 0) {
193 780461
                KASSERT(s->s_size > 1,
194
                    ("attempt to create a too small vsb"));
195 780461
        }
196
197 36515618
        if (s->s_buf != NULL)
198 780462
                return (s);
199
200 35735156
        if ((flags & VSB_AUTOEXTEND) != 0)
201 35735135
                s->s_size = VSB_extendsize(s->s_size);
202
203 35735156
        s->s_buf = SBMALLOC(s->s_size);
204 35735156
        if (s->s_buf == NULL)
205 0
                return (NULL);
206 35735130
        VSB_SETFLAG(s, VSB_DYNAMIC);
207 35735130
        return (s);
208 36515592
}
209
210
struct vsb *
211 780466
VSB_init(struct vsb *s, void *buf, ssize_t length)
212
{
213 780466
        AN(s);
214 780466
        AN(buf);
215
216 780466
        KASSERT(length >= 0,
217
            ("attempt to create an vsb of negative length (%zd)", length));
218 780466
        return (VSB_newbuf(s, buf, length, VSB_FIXEDLEN));
219
}
220
221
/*
222
 * Allocate a dynamic vsb
223
 */
224
struct vsb *
225 35735134
VSB_new_auto(void)
226
{
227
        struct vsb *s;
228
229 35735134
        s = SBMALLOC(sizeof(*s));
230 35735134
        if (s == NULL)
231 0
                return (NULL);
232 35735134
        if (VSB_newbuf(s, NULL, 0, VSB_AUTOEXTEND) == NULL) {
233 0
                SBFREE(s);
234 0
                return (NULL);
235
        }
236 35735134
        VSB_SETFLAG(s, VSB_DYNSTRUCT);
237 35735134
        return (s);
238 35735134
}
239
240
/*
241
 * Clear an vsb and reset its position.
242
 */
243
void
244 53420395
VSB_clear(struct vsb *s)
245
{
246
247 53420395
        assert_VSB_integrity(s);
248
        /* don't care if it's finished or not */
249
250 53420395
        VSB_CLEARFLAG(s, VSB_FINISHED);
251 53420395
        s->s_error = 0;
252 53420395
        s->s_len = 0;
253 53420395
        s->s_indent = 0;
254 53420395
}
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 1131490562
VSB_put_byte(struct vsb *s, int c)
263
{
264
265 1131490562
        assert_VSB_integrity(s);
266 1131490562
        assert_VSB_state(s, 0);
267
268 1131490562
        if (s->s_error != 0)
269 0
                return;
270 1131490562
        _vsb_indent(s);
271 1131490562
        if (VSB_FREESPACE(s) <= 0) {
272 13661217
                if (VSB_extend(s, 1) < 0)
273 0
                        s->s_error = ENOMEM;
274 13661217
                if (s->s_error != 0)
275 0
                        return;
276 13661217
        }
277 1131490562
        s->s_buf[s->s_len++] = (char)c;
278 1131490562
}
279
280
/*
281
 * Append a byte string to an vsb.
282
 */
283
int
284 66296415
VSB_bcat(struct vsb *s, const void *buf, ssize_t len)
285
{
286 66296415
        assert_VSB_integrity(s);
287 66296415
        assert_VSB_state(s, 0);
288
289 66296415
        assert(len >= 0);
290 66296415
        if (s->s_error != 0)
291 0
                return (-1);
292 66296415
        if (len == 0)
293 4121268
                return (0);
294 62175147
        _vsb_indent(s);
295 62175147
        if (len > VSB_FREESPACE(s)) {
296 12573898
                if (VSB_extend(s, len - VSB_FREESPACE(s)) < 0)
297 224
                        s->s_error = ENOMEM;
298 12573898
                if (s->s_error != 0)
299 224
                        return (-1);
300 12573674
        }
301 62174923
        memcpy(s->s_buf + s->s_len, buf, len);
302 62174923
        s->s_len += len;
303 62174923
        return (0);
304 66296415
}
305
306
/*
307
 * Append a string to an vsb.
308
 */
309
int
310 60483984
VSB_cat(struct vsb *s, const char *str)
311
{
312
        const char *nl;
313
        size_t l;
314
315 60483984
        assert_VSB_integrity(s);
316 60483984
        assert_VSB_state(s, 0);
317 60483984
        KASSERT(str != NULL,
318
            ("%s called with a NULL str pointer", __func__));
319
320 60483984
        if (s->s_error != 0)
321 140
                return (-1);
322
323 60502592
        while (s->s_indent > 0 && (nl = strchr(str, '\n')) != NULL) {
324 18748
                l = (nl - str) + 1;
325 18748
                if (VSB_bcat(s, str, l) < 0)
326 0
                        return (-1);
327 18748
                str += l;
328
        }
329
330 60483844
        l = strlen(str);
331 60483844
        return (VSB_bcat(s, str, l));
332 60483984
}
333
334
/*
335
 * Format the given argument list and append the resulting string to an vsb.
336
 */
337
int
338 278832136
VSB_vprintf(struct vsb *s, const char *fmt, va_list ap)
339
{
340
        va_list ap_copy;
341
        int len;
342
343 278832136
        assert_VSB_integrity(s);
344 278832136
        assert_VSB_state(s, 0);
345
346 278832136
        KASSERT(fmt != NULL,
347
            ("%s called with a NULL format string", __func__));
348
349 278832136
        if (s->s_error != 0)
350 0
                return (-1);
351 278832136
        _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 278832136
        do {
365 299631013
                va_copy(ap_copy, ap);
366 599262026
                len = vsnprintf(&s->s_buf[s->s_len], VSB_FREESPACE(s) + 1,
367 299631013
                    fmt, ap_copy);
368 299631013
                va_end(ap_copy);
369 299631013
                if (len < 0) {
370 0
                        s->s_error = errno;
371 0
                        return (-1);
372
                }
373 320431008
        } while (len > VSB_FREESPACE(s) &&
374 20799995
            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 278832136
        s->s_len += vmin_t(ssize_t, len, VSB_FREESPACE(s));
386 278832136
        if (!VSB_HASROOM(s) && !VSB_CANEXTEND(s))
387 644
                s->s_error = ENOMEM;
388
389 278832136
        KASSERT(s->s_len < s->s_size,
390
            ("wrote past end of vsb (%d >= %d)", s->s_len, s->s_size));
391
392 278832136
        if (s->s_error != 0)
393 495
                return (-1);
394 278831641
        return (0);
395 278832136
}
396
397
/*
398
 * Format the given arguments and append the resulting string to an vsb.
399
 */
400
int
401 150210791
VSB_printf(struct vsb *s, const char *fmt, ...)
402
{
403
        va_list ap;
404
        int result;
405
406 150210791
        va_start(ap, fmt);
407 150210791
        result = VSB_vprintf(s, fmt, ap);
408 150210791
        va_end(ap);
409 150210791
        return (result);
410
}
411
412
/*
413
 * Append a character to an vsb.
414
 */
415
int
416 1131487211
VSB_putc(struct vsb *s, int c)
417
{
418
419 1131487211
        VSB_put_byte(s, c);
420 1131487211
        if (s->s_error != 0)
421 0
                return (-1);
422 1131487211
        return (0);
423 1131487211
}
424
425
/*
426
 * Check if an vsb has an error.
427
 */
428
int
429 30342
VSB_error(const struct vsb *s)
430
{
431
432 30342
        return (s->s_error);
433
}
434
435
/*
436
 * Finish off an vsb.
437
 */
438
int
439 68637753
VSB_finish(struct vsb *s)
440
{
441
442 68637753
        assert_VSB_integrity(s);
443 68637753
        assert_VSB_state(s, 0);
444
445 68637753
        s->s_buf[s->s_len] = '\0';
446 68637753
        VSB_SETFLAG(s, VSB_FINISHED);
447 68637753
        errno = s->s_error;
448 68637753
        if (s->s_error)
449 868
                return (-1);
450 68636885
        return (0);
451 68637753
}
452
453
/*
454
 * Return a pointer to the vsb data.
455
 */
456
char *
457 72036734
VSB_data(const struct vsb *s)
458
{
459
460 72036734
        assert_VSB_integrity(s);
461 72036734
        assert_VSB_state(s, VSB_FINISHED);
462
463 72036734
        return (s->s_buf);
464
}
465
466
/*
467
 * Return the length of the vsb data.
468
 */
469
ssize_t
470 28578542
VSB_len(const struct vsb *s)
471
{
472
473 28578542
        assert_VSB_integrity(s);
474
        /* don't care if it's finished or not */
475
476 28578542
        if (s->s_error != 0)
477 0
                return (-1);
478 28578542
        return (s->s_len);
479 28578542
}
480
481
void
482 756530
VSB_fini(struct vsb *s)
483
{
484
485 756530
        assert_VSB_integrity(s);
486 756530
        assert(!VSB_ISDYNAMIC(s));
487 756530
        assert(!VSB_ISDYNSTRUCT(s));
488 756530
        memset(s, 0, sizeof(*s));
489 756530
}
490
491
void
492 29707836
VSB_destroy(struct vsb **s)
493
{
494
495 29707836
        AN(s);
496 29707836
        assert_VSB_integrity(*s);
497 29707836
        assert(VSB_ISDYNAMIC(*s));
498 29707836
        assert(VSB_ISDYNSTRUCT(*s));
499 29707836
        SBFREE((*s)->s_buf);
500 29707836
        memset(*s, 0, sizeof(**s));
501 29707836
        SBFREE(*s);
502 29707836
        *s = NULL;
503 29707836
}
504
505
/*
506
 * Quote a string
507
 */
508
509
static void
510 56305
vsb_quote_hex(struct vsb *s, const uint8_t *u, size_t len)
511
{
512
        const uint8_t *w;
513
514 56305
        VSB_cat(s, "0x");
515 139157
        for (w = u; w < u + len; w++)
516 127117
                if (*w != 0x00)
517 44265
                        break;
518 56305
        if (w == u + len && len > 4) {
519 280
                VSB_cat(s, "0...0");
520 280
        } else {
521 15152213
                for (w = u; w < u + len; w++)
522 15096188
                        VSB_printf(s, "%02x", *w);
523
        }
524 56305
}
525
526
void
527 6324962
VSB_quote_pfx(struct vsb *s, const char *pfx, const void *v, int len, int how)
528
{
529 6324962
        const uint8_t *p = v;
530
        const uint8_t *q;
531 6324962
        int quote = 0;
532
        int nl;
533
534 6324962
        nl = how &
535
            (VSB_QUOTE_JSON|VSB_QUOTE_HEX|VSB_QUOTE_CSTR|VSB_QUOTE_UNSAFE);
536 6324962
        AZ(nl & (nl - 1)); // Only one bit can be set
537
538 6324962
        if (how & VSB_QUOTE_ESCHEX)
539 2965093
                AZ(how & (VSB_QUOTE_JSON|VSB_QUOTE_HEX));
540
541 6324962
        if (how & VSB_QUOTE_UNSAFE)
542 2958540
                how |= VSB_QUOTE_NONL;
543
544 6324962
        assert(p != NULL);
545 6324962
        if (len == -1)
546 3100900
                len = strlen(v);
547
548 6324962
        if (len == 0 && (how & VSB_QUOTE_CSTR)) {
549 5544
                VSB_printf(s, "%s\"\"", pfx);
550 5544
                if ((how & VSB_QUOTE_NONL))
551 0
                        VSB_putc(s, '\n');
552 5544
        }
553
554 6324962
        if (len == 0)
555 209232
                return;
556
557 6115730
        VSB_cat(s, pfx);
558
559 6115730
        if (how & VSB_QUOTE_HEX) {
560 56305
                vsb_quote_hex(s, v, len);
561 56305
                if (how & VSB_QUOTE_NONL)
562 28
                        VSB_putc(s, '\n');
563 56305
                return;
564
        }
565
566 6059425
        if (how & VSB_QUOTE_CSTR)
567 2887641
                VSB_putc(s, '"');
568
569 130426955
        for (q = p; q < p + len; q++) {
570
                if (
571 126198193
                    *q < 0x20 ||
572 124539843
                    *q == '"' ||
573 124516447
                    *q == '\\' ||
574 124512866
                    (*q == '?' && (how & VSB_QUOTE_CSTR)) ||
575 124367530
                    (*q > 0x7e && !(how & VSB_QUOTE_JSON))
576
                ) {
577 1828830
                        quote++;
578 1828830
                        break;
579
                }
580 124367530
        }
581
582 6059425
        if (!quote) {
583 4230631
                VSB_bcat(s, p, len);
584 4230631
                if ((how & VSB_QUOTE_NONL) &&
585 1901468
                    p[len-1] != '\n')
586 1901472
                        (void)VSB_putc(s, '\n');
587 4230639
                if (how & VSB_QUOTE_CSTR)
588 1960393
                        VSB_putc(s, '"');
589 4230639
                return;
590
        }
591
592 1828794
        nl = 0;
593 387985457
        for (q = p; q < p + len; q++) {
594 386156663
                if (nl)
595 3795633
                        VSB_cat(s, pfx);
596 386156663
                nl = 0;
597 386156663
                switch (*q) {
598
                case '?':
599
                        /* Avoid C Trigraph insanity */
600 523788
                        if (how & VSB_QUOTE_CSTR && !(how & VSB_QUOTE_JSON))
601 207676
                                (void)VSB_putc(s, '\\');
602 523788
                        (void)VSB_putc(s, *q);
603 523788
                        break;
604
                case '\\':
605
                case '"':
606 3922855
                        if (!(how & VSB_QUOTE_UNSAFE))
607 2711216
                                (void)VSB_putc(s, '\\');
608 3922855
                        (void)VSB_putc(s, *q);
609 3922855
                        break;
610
                case '\n':
611 16273955
                        if (how & VSB_QUOTE_CSTR) {
612 11618516
                                VSB_printf(s, "\\n\"\n%s\"", pfx);
613 16273955
                        } else if (how & VSB_QUOTE_JSON) {
614 36830
                                VSB_cat(s, "\\n");
615 4655439
                        } else if (how & VSB_QUOTE_NONL) {
616 4618245
                                VSB_putc(s, *q);
617 4618245
                                nl = 1;
618 4618245
                        } else {
619 364
                                VSB_cat(s, "\\n");
620
                        }
621 16273955
                        break;
622
                case '\r':
623 1808198
                        VSB_cat(s, "\\r");
624 1808198
                        break;
625
                case '\t':
626 5378984
                        VSB_cat(s, "\\t");
627 5378984
                        break;
628
                case '\v':
629 1088
                        VSB_cat(s, "\\v");
630 1088
                        break;
631
                default:
632 358247795
                        if (0x20 <= *q && *q <= 0x7e)
633 357840845
                                VSB_putc(s, *q);
634 406950
                        else if (*q > 0x7e && (how & VSB_QUOTE_JSON))
635 112
                                VSB_putc(s, *q);
636 406838
                        else if (how & VSB_QUOTE_JSON)
637 84
                                VSB_printf(s, "\\u%04x", *q);
638 406754
                        else if (how & VSB_QUOTE_ESCHEX)
639 404962
                                VSB_printf(s, "\\x%02x", *q);
640
                        else
641 1792
                                VSB_printf(s, "\\%03o", *q);
642 358247795
                        break;
643
                }
644 386156663
        }
645 1828794
        if (how & VSB_QUOTE_CSTR)
646 927248
                VSB_putc(s, '"');
647 1828794
        if ((how & VSB_QUOTE_NONL) && !nl)
648 70528
                VSB_putc(s, '\n');
649 6324970
}
650
651
void
652 3267066
VSB_quote(struct vsb *s, const void *v, int len, int how)
653
{
654 3267066
        VSB_quote_pfx(s, "", v, len, how);
655 3267066
}
656
657
/*
658
 * Indentation
659
 */
660
661
void
662 60854
VSB_indent(struct vsb *s, int i)
663
{
664
665 60854
        assert_VSB_integrity(s);
666 60854
        if (s->s_indent + i < 0)
667 0
                s->s_error = EINVAL;
668
        else
669 60854
                s->s_indent += i;
670 60854
}
671
672
int
673 1677872
VSB_tofile(const struct vsb *s, int fd)
674
{
675
        int sz;
676
677 1677872
        assert_VSB_integrity(s);
678 1677872
        assert_VSB_state(s, VSB_FINISHED);
679 1677872
        assert(s->s_len >= 0);
680 1677872
        sz = write(fd, s->s_buf, s->s_len);
681 1677872
        return (sz == s->s_len ? 0 : -1);
682
}