Code Coverage: vinyl-cache/bin/vinyld/cache/cache_esi_fetch.c
 
82217aa4fc7094b3610340078afaf78cd95a8ec9
 
0
/*-
1
 * Copyright (c) 2011 Varnish Software AS
2
 * All rights reserved.
3
 *
4
 * Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
5
 *
6
 * SPDX-License-Identifier: BSD-2-Clause
7
 *
8
 * Redistribution and use in source and binary forms, with or without
9
 * modification, are permitted provided that the following conditions
10
 * are met:
11
 * 1. Redistributions of source code must retain the above copyright
12
 *    notice, this list of conditions and the following disclaimer.
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 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
 *
29
 * VEF Vinyl Esi Fetching
30
 */
31
32
#include "config.h"
33
34
#include <stdlib.h>
35
36
#include "cache_int.h"
37
#include "cache_filter.h"
38
#include "cache_vgz.h"
39
40
#include "cache_esi.h"
41
42
#include "vrnd.h"
43
44
/*---------------------------------------------------------------------
45
 */
46
47
struct vef_priv {
48
        unsigned                magic;
49
#define VEF_MAGIC               0xf104b51f
50
        int                     error;
51
        ssize_t                 tot;
52
53
        struct vgz              *vgz;
54
55
        struct vep_state        *vep;
56
57
        char                    *ibuf;
58
        char                    *ibuf_i;
59
        char                    *ibuf_o;
60
        ssize_t                 ibuf_sz;
61
};
62
63
static struct vep_flags
64 611
vep_flags(const struct busyobj *bo) {
65 611
        struct vep_flags flags = {0};
66
67 611
        CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
68 611
#define BERESP_ESI_FLAG(lower, feature, doc) \
69 2444
        flags.lower = bo->lower;
70 611
#include "tbl/beresp_esi_flags.h"
71 611
        return (flags);
72 611
}
73
74
static ssize_t
75
vfp_vep_callback(struct vfp_ctx *vc, void *priv, ssize_t l, enum vgz_flag flg)
76 4760
{
77 4760
        struct vef_priv *vef;
78 4760
        ssize_t dl;
79 4760
        const void *dp;
80 4760
        uint8_t *ptr;
81 4760
        enum vgzret_e i;
82
83 4760
        CHECK_OBJ_NOTNULL(vc, VFP_CTX_MAGIC);
84 4760
        CAST_OBJ_NOTNULL(vef, priv, VEF_MAGIC);
85 4760
        assert(l >= 0);
86
87 4760
        if (vef->error) {
88 5
                vef->tot += l;
89 5
                return (vef->tot);
90 5
        }
91
92
        /*
93
         * l == 0 is valid when 'flg' calls for action, but in the
94
         * normal case we can just ignore a l==0 request.
95
         * (It would cause Z_BUF_ERROR anyway)
96
         */
97 4755
        if (l == 0 && flg == VGZ_NORMAL)
98 761
                return (vef->tot);
99
100 3994
        VGZ_Ibuf(vef->vgz, vef->ibuf_o, l);
101 4190
        do {
102 4190
                dl = 0;
103 4190
                if (VFP_GetStorage(vc, &dl, &ptr) != VFP_OK) {
104 1
                        vef->error = ENOMEM;
105 1
                        vef->tot += l;
106 1
                        return (vef->tot);
107 1
                }
108 4189
                VGZ_Obuf(vef->vgz, ptr, dl);
109 4189
                i = VGZ_Gzip(vef->vgz, &dp, &dl, flg);
110 4189
                VGZ_UpdateObj(vc, vef->vgz, i);
111 4189
                if (dl > 0) {
112 1709
                        vef->tot += dl;
113 1709
                        VFP_Extend(vc, dl, VFP_OK);
114 1709
                }
115 4189
        } while (i != VGZ_ERROR &&
116 4189
            (!VGZ_IbufEmpty(vef->vgz) || VGZ_ObufFull(vef->vgz)));
117 3993
        assert(i == VGZ_ERROR || VGZ_IbufEmpty(vef->vgz));
118 3993
        vef->ibuf_o += l;
119 3993
        return (vef->tot);
120 3993
}
121
122
static enum vfp_status
123
vfp_esi_end(struct vfp_ctx *vc, struct vef_priv *vef,
124
    enum vfp_status retval)
125 559
{
126 559
        struct vsb *vsb;
127 559
        ssize_t l;
128 559
        void *p;
129
130 559
        CHECK_OBJ_NOTNULL(vc, VFP_CTX_MAGIC);
131 559
        CHECK_OBJ_NOTNULL(vef, VEF_MAGIC);
132
133 559
        if (retval == VFP_ERROR) {
134 6
                if (vef->error == 0)
135 5
                        vef->error = errno ? errno : EINVAL;
136 553
        } else {
137 553
                assert(retval == VFP_END);
138 553
        }
139
140 559
        vsb = VEP_Finish(vef->vep);
141
142 559
        if (vsb != NULL) {
143 458
                if (retval == VFP_END) {
144 457
                        l = VSB_len(vsb);
145 457
                        assert(l > 0);
146 457
                        p = ObjSetAttr(vc->wrk, vc->oc,
147 457
                            OA_ESIDATA, l, VSB_data(vsb));
148 457
                        if (p == NULL) {
149 0
                                retval = VFP_Error(vc,
150 0
                                    "Could not allocate storage for esidata");
151 0
                        }
152 457
                }
153 458
                VSB_destroy(&vsb);
154 458
        }
155
156 559
        if (vef->vgz != NULL) {
157 142
                if (retval == VFP_END)
158 138
                        VGZ_UpdateObj(vc, vef->vgz, VGZ_END);
159 142
                if (VGZ_Destroy(vc->wrk, &vef->vgz) != VGZ_END)
160 4
                        retval = VFP_Error(vc,
161 4
                            "ESI+Gzip Failed at the very end");
162 142
        }
163 559
        if (vef->ibuf != NULL)
164 142
                free(vef->ibuf);
165 559
        FREE_OBJ(vef);
166 559
        return (retval);
167 559
}
168
169
static enum vfp_status v_matchproto_(vfp_init_f)
170
vfp_esi_gzip_init(VRT_CTX, struct vfp_ctx *vc, struct vfp_entry *vfe)
171 194
{
172 194
        struct vef_priv *vef;
173
174 194
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
175 194
        CHECK_OBJ_NOTNULL(vc, VFP_CTX_MAGIC);
176 194
        CHECK_OBJ_NOTNULL(vc->req, HTTP_MAGIC);
177 194
        CHECK_OBJ_NOTNULL(vfe, VFP_ENTRY_MAGIC);
178 194
        if (http_GetStatus(vc->resp) == 206) {
179 0
                VSLb(vc->wrk->vsl, SLT_VCL_Error,
180 0
                    "Attempted ESI on partial (206) response");
181 0
                return (VFP_ERROR);
182 0
        }
183 194
        ALLOC_OBJ(vef, VEF_MAGIC);
184 194
        if (vef == NULL)
185 0
                return (VFP_ERROR);
186 194
        vc->obj_flags |= OF_GZIPED | OF_CHGCE | OF_ESIPROC;
187 194
        vef->vep = VEP_Init(vc, vc->req, vfp_vep_callback, vef,
188 194
            vep_flags(ctx->bo));
189 194
        if (vef->vep == NULL) {
190 52
                FREE_OBJ(vef);
191 52
                return (VFP_ERROR);
192 52
        }
193 142
        vef->vgz = VGZ_NewGzip(vc->wrk->vsl, "G F E");
194 142
        AN(vef->vgz);
195
196 142
        vef->ibuf_sz = cache_param->gzip_buffer;
197 142
        vef->ibuf = calloc(1L, vef->ibuf_sz);
198 142
        if (vef->ibuf == NULL)
199 0
                return (vfp_esi_end(vc, vef, VFP_ERROR));
200 142
        vef->ibuf_i = vef->ibuf;
201 142
        vef->ibuf_o = vef->ibuf;
202 142
        vfe->priv1 = vef;
203
204 142
        RFC2616_Weaken_Etag(vc->resp);
205 142
        http_Unset(vc->resp, H_Content_Length);
206 142
        http_Unset(vc->resp, H_Content_Encoding);
207 142
        http_SetHeader(vc->resp, "Content-Encoding: gzip");
208
209 142
        RFC2616_Vary_AE(vc->resp);
210
211 142
        return (VFP_OK);
212 142
}
213
214
static enum vfp_status v_matchproto_(vfp_pull_f)
215
vfp_esi_gzip_pull(struct vfp_ctx *vc, struct vfp_entry *vfe, void *p,
216
   ssize_t *lp)
217 677
{
218 677
        enum vfp_status vp;
219 677
        ssize_t d, l;
220 677
        struct vef_priv *vef;
221
222 677
        CHECK_OBJ_NOTNULL(vc, VFP_CTX_MAGIC);
223 677
        CHECK_OBJ_NOTNULL(vfe, VFP_ENTRY_MAGIC);
224 677
        CAST_OBJ_NOTNULL(vef, vfe->priv1, VEF_MAGIC);
225 677
        AN(p);
226 677
        AN(lp);
227 677
        *lp = 0;
228 677
        l = vef->ibuf_sz - (vef->ibuf_i - vef->ibuf);
229 677
        if (DO_DEBUG(DBG_ESI_CHOP)) {
230 384
                d = (VRND_RandomTestable() & 3) + 1;
231 384
                if (d < l)
232 384
                        l = d;
233 384
        }
234 677
        vp = VFP_Suck(vc, vef->ibuf_i, &l);
235
236 677
        if (l > 0) {
237 554
                VEP_Parse(vef->vep, vef->ibuf_i, l);
238 554
                vef->ibuf_i += l;
239 554
                assert(vef->ibuf_o >= vef->ibuf && vef->ibuf_o <= vef->ibuf_i);
240 554
                if (vef->error) {
241 1
                        errno = vef->error;
242 1
                        return (VFP_ERROR);
243 1
                }
244 553
                l = vef->ibuf_i - vef->ibuf_o;
245 553
                if (l > 0)
246 32
                        vmemmove(vef->ibuf, vef->ibuf_o, l);
247 553
                vef->ibuf_o = vef->ibuf;
248 553
                vef->ibuf_i = vef->ibuf + l;
249 553
        }
250 676
        if (vp == VFP_END) {
251 138
                vp = vfp_esi_end(vc, vef, vp);
252 138
                vfe->priv1 = NULL;
253 138
        }
254 676
        return (vp);
255 677
}
256
257
static enum vfp_status v_matchproto_(vfp_init_f)
258
vfp_esi_init(VRT_CTX, struct vfp_ctx *vc, struct vfp_entry *vfe)
259 418
{
260 418
        struct vef_priv *vef;
261 418
        struct vep_state *vep;
262
263 418
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
264 418
        CHECK_OBJ_NOTNULL(vc, VFP_CTX_MAGIC);
265 418
        CHECK_OBJ_NOTNULL(vc->req, HTTP_MAGIC);
266 418
        if (http_GetStatus(vc->resp) == 206) {
267 1
                VSLb(vc->wrk->vsl, SLT_VCL_Error,
268 1
                    "Attempted ESI on partial (206) response");
269 1
                return (VFP_ERROR);
270 1
        }
271 417
        vep = VEP_Init(vc, vc->req, NULL, NULL, vep_flags(ctx->bo));
272 417
        if (vep == NULL)
273 0
                return (VFP_ERROR);
274 417
        ALLOC_OBJ(vef, VEF_MAGIC);
275 417
        if (vef == NULL)
276 0
                return (VFP_ERROR);
277 417
        vc->obj_flags |= OF_ESIPROC;
278 417
        vef->vep = vep;
279 417
        vfe->priv1 = vef;
280 417
        return (VFP_OK);
281 417
}
282
283
static enum vfp_status v_matchproto_(vfp_pull_f)
284
vfp_esi_pull(struct vfp_ctx *vc, struct vfp_entry *vfe, void *p, ssize_t *lp)
285 53486
{
286 53486
        enum vfp_status vp;
287 53486
        struct vef_priv *vef;
288
289 53486
        CHECK_OBJ_NOTNULL(vc, VFP_CTX_MAGIC);
290 53486
        CHECK_OBJ_NOTNULL(vfe, VFP_ENTRY_MAGIC);
291 53486
        CAST_OBJ_NOTNULL(vef, vfe->priv1, VEF_MAGIC);
292 53486
        AN(p);
293 53486
        AN(lp);
294 53486
        if (DO_DEBUG(DBG_ESI_CHOP)) {
295 53020
                *lp = vmin_t(size_t, *lp, (VRND_RandomTestable() & 3) + 1);
296 53020
        }
297 53486
        vp = VFP_Suck(vc, p, lp);
298 53486
        if (vp != VFP_ERROR && *lp > 0)
299 53478
                VEP_Parse(vef->vep, p, *lp);
300 53486
        if (vp == VFP_END) {
301 415
                vp = vfp_esi_end(vc, vef, vp);
302 415
                vfe->priv1 = NULL;
303 415
        }
304 53486
        return (vp);
305 53486
}
306
307
static void v_matchproto_(vfp_fini_f)
308
vfp_esi_fini(struct vfp_ctx *vc, struct vfp_entry *vfe)
309 611
{
310 611
        CHECK_OBJ_NOTNULL(vc, VFP_CTX_MAGIC);
311 611
        CHECK_OBJ_NOTNULL(vfe, VFP_ENTRY_MAGIC);
312
313 611
        if (vfe->priv1 == NULL)
314 606
                return;
315
316 5
        if (vc->oc->stobj->stevedore == NULL)
317 5
                errno = ENOMEM;
318
319 5
        (void)vfp_esi_end(vc, vfe->priv1, VFP_ERROR);
320
        vfe->priv1 = NULL;
321 5
}
322
323
const struct vfp VFP_esi = {
324
        .name = "esi",
325
        .init = vfp_esi_init,
326
        .pull = vfp_esi_pull,
327
        .fini = vfp_esi_fini,
328
};
329
330
const struct vfp VFP_esi_gzip = {
331
        .name = "esi_gzip",
332
        .init = vfp_esi_gzip_init,
333
        .pull = vfp_esi_gzip_pull,
334
        .fini = vfp_esi_fini,
335
};