Code Coverage: vinyl-cache/bin/vinyld/cache/cache_ws_common.c
 
82217aa4fc7094b3610340078afaf78cd95a8ec9
 
0
/*-
1
 * Copyright (c) 2006 Verdens Gang AS
2
 * Copyright (c) 2006-2021 Varnish Software AS
3
 * All rights reserved.
4
 *
5
 * Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
6
 * Author: Dridi Boukelmoune <dridi.boukelmoune@gmail.com>
7
 *
8
 * SPDX-License-Identifier: BSD-2-Clause
9
 *
10
 * Redistribution and use in source and binary forms, with or without
11
 * modification, are permitted provided that the following conditions
12
 * are met:
13
 * 1. Redistributions of source code must retain the above copyright
14
 *    notice, this list of conditions and the following disclaimer.
15
 * 2. Redistributions in binary form must reproduce the above copyright
16
 *    notice, this list of conditions and the following disclaimer in the
17
 *    documentation and/or other materials provided with the distribution.
18
 *
19
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
20
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22
 * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
23
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29
 * SUCH DAMAGE.
30
 *
31
 */
32
33
#include "config.h"
34
35
#include <stdio.h>
36
37
#include "cache_int.h"
38
39
void
40
WS_Id(const struct ws *ws, char *id)
41 109
{
42
43 109
        WS_Assert(ws);
44 109
        AN(id);
45 109
        vmemcpy(id, ws->id, WS_ID_SIZE);
46 109
        id[0] |= 0x20;                  // cheesy tolower()
47 109
}
48
49
void
50
WS_MarkOverflow(struct ws *ws)
51 1064
{
52 1064
        CHECK_OBJ_NOTNULL(ws, WS_MAGIC);
53
54 1064
        ws->id[0] &= ~0x20;             // cheesy toupper()
55 1064
}
56
57
static void
58
ws_ClearOverflow(struct ws *ws)
59 56214
{
60 56214
        CHECK_OBJ_NOTNULL(ws, WS_MAGIC);
61
62 56214
        ws->id[0] |= 0x20;              // cheesy tolower()
63 56214
}
64
65
int
66
WS_Overflowed(const struct ws *ws)
67 292548
{
68 292548
        CHECK_OBJ_NOTNULL(ws, WS_MAGIC);
69 292548
        AN(ws->id[0]);
70
71 292548
        if (ws->id[0] & 0x20)           // cheesy islower()
72 291968
                return (0);
73 580
        return (1);
74 292548
}
75
76
/*
77
 * Reset the WS to a cookie or its start and clears any overflow
78
 *
79
 * for vinyld internal use only
80
 */
81
82
void
83
WS_Rollback(struct ws *ws, uintptr_t pp)
84 56221
{
85
86 56221
        WS_Assert(ws);
87
88 56221
        if (pp == 0)
89 45236
                pp = (uintptr_t)ws->s;
90 56221
        ws_ClearOverflow(ws);
91 56221
        WS_Reset(ws, pp);
92 56221
}
93
94
/*--------------------------------------------------------------------*/
95
96
const char *
97
WS_Printf(struct ws *ws, const char *fmt, ...)
98 6490
{
99 6490
        unsigned u, v;
100 6490
        va_list ap;
101 6490
        char *p;
102
103 6490
        u = WS_ReserveAll(ws);
104 6490
        p = ws->f;
105 6490
        va_start(ap, fmt);
106 6490
        v = vsnprintf(p, u, fmt, ap);
107 6490
        va_end(ap);
108 6490
        if (v >= u) {
109 296
                WS_Release(ws, 0);
110 296
                WS_MarkOverflow(ws);
111 296
                p = NULL;
112 6194
        } else {
113 6194
                WS_Release(ws, v + 1);
114 6194
        }
115 6490
        return (p);
116 6490
}
117
118
/*---------------------------------------------------------------------
119
 * Build a VSB on a workspace.
120
 * Usage pattern:
121
 *
122
 *      struct vsb vsb[1];
123
 *      char *p;
124
 *
125
 *      WS_VSB_new(vsb, ctx->ws);
126
 *      VSB_printf(vsb, "blablabla");
127
 *      p = WS_VSB_finish(vsb, ctx->ws, NULL);
128
 *      if (p == NULL)
129
 *              return (FAILURE);
130
 */
131
132
void
133
WS_VSB_new(struct vsb *vsb, struct ws *ws)
134 65143
{
135 65143
        unsigned u;
136 65143
        static char bogus[2];   // Smallest possible vsb
137
138 65143
        AN(vsb);
139 65143
        WS_Assert(ws);
140 65143
        u = WS_ReserveAll(ws);
141 65143
        if (WS_Overflowed(ws) || u < 2)
142 47
                AN(VSB_init(vsb, bogus, sizeof bogus));
143 65096
        else
144 65096
                AN(VSB_init(vsb, WS_Reservation(ws), u));
145 65143
}
146
147
char *
148
WS_VSB_finish(struct vsb *vsb, struct ws *ws, size_t *szp)
149 65097
{
150 65097
        char *p;
151
152 65097
        AN(vsb);
153 65097
        WS_Assert(ws);
154 65097
        if (!VSB_finish(vsb)) {
155 65042
                p = VSB_data(vsb);
156 65042
                if (p == ws->f) {
157 65020
                        WS_Release(ws, VSB_len(vsb) + 1);
158 65020
                        if (szp != NULL)
159 50040
                                *szp = VSB_len(vsb);
160 65020
                        VSB_fini(vsb);
161 65020
                        return (p);
162 65020
                }
163 65042
        }
164 77
        WS_MarkOverflow(ws);
165 77
        VSB_fini(vsb);
166 77
        WS_Release(ws, 0);
167 77
        if (szp)
168 32
                *szp = 0;
169
        return (NULL);
170 65097
}