Code Coverage: vinyl-cache/bin/vinyld/http1/cache_http1_line.c
 
82217aa4fc7094b3610340078afaf78cd95a8ec9
 
0
/*-
1
 * Copyright (c) 2006 Verdens Gang AS
2
 * Copyright (c) 2006-2011 Varnish Software AS
3
 * All rights reserved.
4
 *
5
 * Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
6
 *
7
 * SPDX-License-Identifier: BSD-2-Clause
8
 *
9
 * Redistribution and use in source and binary forms, with or without
10
 * modification, are permitted provided that the following conditions
11
 * are met:
12
 * 1. Redistributions of source code must retain the above copyright
13
 *    notice, this list of conditions and the following disclaimer.
14
 * 2. Redistributions in binary form must reproduce the above copyright
15
 *    notice, this list of conditions and the following disclaimer in the
16
 *    documentation and/or other materials provided with the distribution.
17
 *
18
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21
 * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
22
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28
 * SUCH DAMAGE.
29
 *
30
 * Write data to fd
31
 * We try to use writev() if possible in order to minimize number of
32
 * syscalls made and packets sent.  It also just might allow the worker
33
 * thread to complete the request without holding stuff locked.
34
 *
35
 * XXX: chunked header (generated in Flush) and Tail (EndChunk)
36
 *      are not accounted by means of the size_t returned. Obvious ideas:
37
 *      - add size_t return value to Flush and EndChunk
38
 *      - base accounting on (struct v1l).cnt
39
 */
40
41
#include "config.h"
42
43
#include <sys/uio.h>
44
#include "cache/cache_int.h"
45
#include "cache/cache_filter.h"
46
47
#include <stdio.h>
48
49
#include "cache_http1.h"
50
#include "vtim.h"
51
52
/*--------------------------------------------------------------------*/
53
54
struct v1l {
55
        unsigned                magic;
56
#define V1L_MAGIC               0x2f2142e5
57
        int                     *wfd;
58
        stream_close_t          werr;   /* valid after V1L_Flush() */
59
        struct iovec            *iov;
60
        int                     siov;
61
        int                     niov;
62
        size_t                  liov;
63
        size_t                  cliov;
64
        int                     ciov;   /* Chunked header marker */
65
        vtim_real               deadline;
66
        struct vsl_log          *vsl;
67
        uint64_t                cnt;    /* Flushed byte count */
68
        struct ws               *ws;
69
        uintptr_t               ws_snap;
70
        void                    **vdp_priv;
71
};
72
73
/*--------------------------------------------------------------------
74
 * for niov == 0, reserve the ws for max number of iovs
75
 * otherwise, up to niov
76
 */
77
78
struct v1l *
79
V1L_Open(struct ws *ws, int *fd, struct vsl_log *vsl,
80
    vtim_real deadline, unsigned niov)
81 6827
{
82 6827
        struct v1l *v1l;
83 6827
        unsigned u;
84 6827
        uintptr_t ws_snap;
85 6827
        size_t sz;
86
87 6827
        if (WS_Overflowed(ws))
88 0
                return (NULL);
89
90 6827
        if (niov != 0)
91 3974
                assert(niov >= 3);
92
93 6827
        ws_snap = WS_Snapshot(ws);
94
95 6827
        v1l = WS_Alloc(ws, sizeof *v1l);
96 6827
        if (v1l == NULL)
97 1
                return (NULL);
98 6826
        INIT_OBJ(v1l, V1L_MAGIC);
99
100 6826
        v1l->ws = ws;
101 6826
        v1l->ws_snap = ws_snap;
102
103 6826
        u = WS_ReserveLumps(ws, sizeof(struct iovec));
104 6826
        if (u < 3) {
105
                /* Must have at least 3 in case of chunked encoding */
106 0
                WS_Release(ws, 0);
107 0
                WS_MarkOverflow(ws);
108 0
                return (NULL);
109 0
        }
110 6826
        if (u > IOV_MAX)
111 72
                u = IOV_MAX;
112 6826
        if (niov != 0 && u > niov)
113 3898
                u = niov;
114 13652
        v1l->iov = WS_Reservation(ws);
115 0
        v1l->siov = (int)u;
116 13652
        v1l->ciov = (int)u;
117 13652
        v1l->wfd = fd;
118 13652
        v1l->deadline = deadline;
119 13652
        v1l->vsl = vsl;
120 13652
        v1l->werr = SC_NULL;
121
122 13652
        sz = u * sizeof(struct iovec);
123 13652
        assert(sz < UINT_MAX);
124 6826
        WS_Release(ws, (unsigned)sz);
125 6826
        return (v1l);
126 13652
}
127
128
void
129
V1L_NoRollback(struct v1l *v1l)
130 72
{
131
132 72
        CHECK_OBJ_NOTNULL(v1l, V1L_MAGIC);
133 72
        v1l->ws_snap = 0;
134 72
}
135
136
stream_close_t
137
V1L_Close(struct v1l **v1lp, uint64_t *cnt)
138 6822
{
139 6822
        struct v1l *v1l;
140 6822
        struct ws *ws;
141 6822
        uintptr_t ws_snap;
142 6822
        stream_close_t sc;
143
144 6822
        AN(cnt);
145 6822
        TAKE_OBJ_NOTNULL(v1l, v1lp, V1L_MAGIC);
146 6822
        if (v1l->vdp_priv != NULL) {
147 5453
                assert(*v1l->vdp_priv == v1l);
148 5453
                *v1l->vdp_priv = NULL;
149 5453
        }
150 6822
        sc = V1L_Flush(v1l);
151 6822
        *cnt = v1l->cnt;
152 6822
        ws = v1l->ws;
153 6822
        ws_snap = v1l->ws_snap;
154 6822
        ZERO_OBJ(v1l, sizeof *v1l);
155 6822
        if (ws_snap != 0)
156 6753
                WS_Rollback(ws, ws_snap);
157 6822
        return (sc);
158 6822
}
159
160
static void
161
v1l_prune(struct v1l *v1l, ssize_t abytes)
162 5
{
163 5
        size_t used = 0;
164 5
        size_t sz, bytes, used_here;
165 5
        int j;
166
167 5
        assert(abytes > 0);
168 5
        bytes = (size_t)abytes;
169
170 84
        for (j = 0; j < v1l->niov; j++) {
171 84
                if (used + v1l->iov[j].iov_len > bytes) {
172
                        /* Cutoff is in this iov */
173 5
                        used_here = bytes - used;
174 5
                        v1l->iov[j].iov_len -= used_here;
175 5
                        v1l->iov[j].iov_base =
176 5
                            (char*)v1l->iov[j].iov_base + used_here;
177 5
                        sz = (unsigned)v1l->niov - (unsigned)j;
178 5
                        sz *= sizeof(struct iovec);
179 5
                        vmemmove(v1l->iov, &v1l->iov[j], sz);
180 5
                        v1l->niov -= j;
181 5
                        assert(v1l->liov >= bytes);
182 5
                        v1l->liov -= bytes;
183 5
                        return;
184 5
                }
185 79
                used += v1l->iov[j].iov_len;
186 79
        }
187 0
        AZ(v1l->liov);
188 0
}
189
190
stream_close_t
191
V1L_Flush(struct v1l *v1l)
192 38889
{
193 38889
        ssize_t i;
194 38889
        size_t sz;
195 38889
        int err;
196 38889
        char cbuf[32];
197
198 38889
        CHECK_OBJ_NOTNULL(v1l, V1L_MAGIC);
199 38889
        CHECK_OBJ_NOTNULL(v1l->werr, STREAM_CLOSE_MAGIC);
200 38889
        AN(v1l->wfd);
201
202 38889
        assert(v1l->niov <= v1l->siov);
203
204 38889
        if (*v1l->wfd >= 0 && v1l->liov > 0 && v1l->werr == SC_NULL) {
205 26922
                if (v1l->ciov < v1l->siov && v1l->cliov > 0) {
206
                        /* Add chunk head & tail */
207 6190
                        bprintf(cbuf, "00%zx\r\n", v1l->cliov);
208 6190
                        sz = vstrlen(cbuf);
209 6190
                        v1l->iov[v1l->ciov].iov_base = cbuf;
210 6190
                        v1l->iov[v1l->ciov].iov_len = sz;
211 6190
                        v1l->liov += sz;
212
213
                        /* This is OK, because siov was --'ed */
214 6190
                        v1l->iov[v1l->niov].iov_base = cbuf + sz - 2;
215 6190
                        v1l->iov[v1l->niov++].iov_len = 2;
216 6190
                        v1l->liov += 2;
217 20732
                } else if (v1l->ciov < v1l->siov) {
218 102
                        v1l->iov[v1l->ciov].iov_base = cbuf;
219 102
                        v1l->iov[v1l->ciov].iov_len = 0;
220 102
                }
221
222 26922
                i = 0;
223 26922
                err = 0;
224 26962
                do {
225 26962
                        if (VTIM_real() > v1l->deadline) {
226 4
                                VSLb(v1l->vsl, SLT_Debug,
227 4
                                    "Hit total send timeout, "
228 4
                                    "wrote = %zd/%zd; not retrying",
229 4
                                    i, v1l->liov);
230 4
                                i = -1;
231 4
                                break;
232 4
                        }
233
234 26958
                        i = writev(*v1l->wfd, v1l->iov, v1l->niov);
235 26958
                        if (i > 0) {
236 26915
                                v1l->cnt += (size_t)i;
237 26915
                                if ((size_t)i == v1l->liov)
238 26910
                                        break;
239 26915
                        }
240
241
                        /* we hit a timeout, and some data may have been sent:
242
                         * Remove sent data from start of I/O vector, then retry
243
                         *
244
                         * XXX: Add a "minimum sent data per timeout counter to
245
                         * prevent slowloris attacks
246
                         */
247
248 48
                        err = errno;
249
250 48
                        if (err == EWOULDBLOCK) {
251 35
                                VSLb(v1l->vsl, SLT_Debug,
252 35
                                    "Hit idle send timeout, "
253 35
                                    "wrote = %zd/%zd; retrying",
254 35
                                    i, v1l->liov);
255 35
                        }
256
257 48
                        if (i > 0)
258 5
                                v1l_prune(v1l, i);
259 48
                } while (i > 0 || err == EWOULDBLOCK);
260
261 26922
                if (i <= 0) {
262 11
                        VSLb(v1l->vsl, SLT_Debug,
263 11
                            "Write error, retval = %zd, len = %zd, errno = %s",
264 11
                            i, v1l->liov, VAS_errtxt(err));
265 11
                        assert(v1l->werr == SC_NULL);
266 11
                        if (err == EPIPE)
267 7
                                v1l->werr = SC_REM_CLOSE;
268 4
                        else
269 4
                                v1l->werr = SC_TX_ERROR;
270 11
                        errno = err;
271 11
                }
272 26922
        }
273 38889
        v1l->liov = 0;
274 38889
        v1l->cliov = 0;
275 38889
        v1l->niov = 0;
276 38889
        if (v1l->ciov < v1l->siov)
277 15008
                v1l->ciov = v1l->niov++;
278 38889
        CHECK_OBJ_NOTNULL(v1l->werr, STREAM_CLOSE_MAGIC);
279 38889
        return (v1l->werr);
280 38889
}
281
282
size_t
283
V1L_Write(struct v1l *v1l, const void *ptr, ssize_t alen)
284 178999
{
285 178999
        size_t len = 0;
286
287 178999
        CHECK_OBJ_NOTNULL(v1l, V1L_MAGIC);
288 178999
        AN(v1l->wfd);
289 179005
        if (alen == 0 || *v1l->wfd < 0)
290 0
                return (0);
291 178999
        if (alen > 0)
292 101275
                len = (size_t)alen;
293 77724
        else if (alen == -1)
294 77774
                len = vstrlen(ptr);
295 18446744073709551566
        else
296 18446744073709551566
                WRONG("alen");
297
298 179049
        assert(v1l->niov < v1l->siov);
299 179049
        v1l->iov[v1l->niov].iov_base = TRUST_ME(ptr);
300 179049
        v1l->iov[v1l->niov].iov_len = len;
301 179049
        v1l->liov += len;
302 179049
        v1l->niov++;
303 179049
        v1l->cliov += len;
304 179049
        if (v1l->niov >= v1l->siov) {
305 113
                (void)V1L_Flush(v1l);
306 113
                VSC_C_main->http1_iovs_flush++;
307 113
        }
308 179049
        return (len);
309 179049
}
310
311
void
312
V1L_Chunked(struct v1l *v1l)
313 410
{
314
315 410
        CHECK_OBJ_NOTNULL(v1l, V1L_MAGIC);
316
317 410
        assert(v1l->ciov == v1l->siov);
318 410
        assert(v1l->siov >= 3);
319
        /*
320
         * If there is no space for chunked header, a chunk of data and
321
         * a chunk tail, we might as well flush right away.
322
         */
323 410
        if (v1l->niov + 3 >= v1l->siov) {
324 0
                (void)V1L_Flush(v1l);
325 0
                VSC_C_main->http1_iovs_flush++;
326 0
        }
327 410
        v1l->siov--;
328 410
        v1l->ciov = v1l->niov++;
329 410
        v1l->cliov = 0;
330 410
        assert(v1l->ciov < v1l->siov);
331 410
        assert(v1l->niov < v1l->siov);
332 410
}
333
334
/*
335
 * XXX: It is not worth the complexity to attempt to get the
336
 * XXX: end of chunk into the V1L_Flush(), because most of the time
337
 * XXX: if not always, that is a no-op anyway, because the calling
338
 * XXX: code already called V1L_Flush() to release local storage.
339
 */
340
341
void
342
V1L_EndChunk(struct v1l *v1l)
343 387
{
344
345 387
        CHECK_OBJ_NOTNULL(v1l, V1L_MAGIC);
346
347 387
        assert(v1l->ciov < v1l->siov);
348 387
        (void)V1L_Flush(v1l);
349 387
        v1l->siov++;
350 387
        v1l->ciov = v1l->siov;
351 387
        v1l->niov = 0;
352 387
        v1l->cliov = 0;
353 387
        (void)V1L_Write(v1l, "0\r\n\r\n", -1);
354 387
}
355
356
/*--------------------------------------------------------------------
357
 * VDP using V1L
358
 */
359
360
/* remember priv pointer for V1L_Close() to clear */
361
static int v_matchproto_(vdp_init_f)
362
v1l_init(VRT_CTX, struct vdp_ctx *vdc, void **priv)
363 5426
{
364 5426
        struct v1l *v1l;
365
366 5426
        (void) ctx;
367 5426
        (void) vdc;
368 5426
        AN(priv);
369 5426
        CAST_OBJ_NOTNULL(v1l, *priv, V1L_MAGIC);
370
371 5426
        v1l->vdp_priv = priv;
372 5426
        return (0);
373 5426
}
374
375
static int v_matchproto_(vdp_bytes_f)
376
v1l_bytes(struct vdp_ctx *vdc, enum vdp_action act, void **priv,
377
    const void *ptr, ssize_t len)
378 41411
{
379 41411
        size_t wl = 0;
380
381 41411
        CHECK_OBJ_NOTNULL(vdc, VDP_CTX_MAGIC);
382 41411
        AN(priv);
383
384 41411
        AZ(vdc->nxt);           /* always at the bottom of the pile */
385
386 41411
        if (len > 0)
387 30532
                wl = V1L_Write(*priv, ptr, len);
388 41411
        if (act > VDP_NULL && V1L_Flush(*priv) != SC_NULL)
389 11
                return (-1);
390 41400
        if ((size_t)len != wl)
391 0
                return (-1);
392 41400
        return (0);
393 41400
}
394
395
/*--------------------------------------------------------------------
396
 * VDPIO using V1L
397
 *
398
 * this is deliverately half-baked to reduce work in progress while heading
399
 * towards VAI/VDPIO: we update the v1l with the scarab, which we
400
 * return unmodified.
401
 *
402
 */
403
404
/* remember priv pointer for V1L_Close() to clear */
405
static int v_matchproto_(vpio_init_f)
406
v1l_io_init(VRT_CTX, struct vdp_ctx *vdc, void **priv, int capacity)
407 32
{
408 32
        struct v1l *v1l;
409
410 32
        (void) ctx;
411 32
        (void) vdc;
412 32
        AN(priv);
413
414 32
        CAST_OBJ_NOTNULL(v1l, *priv, V1L_MAGIC);
415
416 32
        v1l->vdp_priv = priv;
417 32
        return (capacity);
418 32
}
419
420
static int v_matchproto_(vpio_init_f)
421
v1l_io_upgrade(VRT_CTX, struct vdp_ctx *vdc, void **priv, int capacity)
422 0
{
423 0
        return (v1l_io_init(ctx, vdc, priv, capacity));
424 0
}
425
426
/*
427
 * API note
428
 *
429
 * this VDP is special in that it does not transform data, but prepares
430
 * the write. From the perspective of VDPIO, its current state is only
431
 * transitional.
432
 *
433
 * Because the VDP prepares the actual writes, but the caller needs
434
 * to return the scarab's leases, the caller in this case is
435
 * required to empty the scarab after V1L_Flush()'ing.
436
 */
437
438
static int v_matchproto_(vdpio_lease_f)
439
v1l_io_lease(struct vdp_ctx *vdc, struct vdp_entry *this, struct vscarab *scarab)
440 192
{
441 192
        struct v1l *v1l;
442 192
        struct viov *v;
443 192
        int r;
444
445 192
        CHECK_OBJ_NOTNULL(vdc, VDP_CTX_MAGIC);
446 192
        CHECK_OBJ_NOTNULL(this, VDP_ENTRY_MAGIC);
447 192
        CAST_OBJ_NOTNULL(v1l, this->priv, V1L_MAGIC);
448 192
        VSCARAB_CHECK(scarab);
449 192
        AZ(scarab->used);       // see note above
450 192
        this->calls++;
451 192
        r = vdpio_pull(vdc, this, scarab);
452 192
        if (r < 0)
453 128
                return (r);
454 64
        VSCARAB_FOREACH(v, scarab)
455 64
                this->bytes_in += V1L_Write(v1l, v->iov.iov_base, v->iov.iov_len);
456 64
        return (r);
457 192
}
458
459
const struct vdp * const VDP_v1l = &(struct vdp){
460
        .name =         "V1B",
461
        .init =         v1l_init,
462
        .bytes =        v1l_bytes,
463
464
        .io_init =      v1l_io_init,
465
        .io_upgrade =   v1l_io_upgrade,
466
        .io_lease =     v1l_io_lease,
467
};