Code Coverage: vinyl-cache/bin/vinyld/cache/cache_req_fsm.c
 
82217aa4fc7094b3610340078afaf78cd95a8ec9
 
0
/*-
1
 * Copyright (c) 2006 Verdens Gang AS
2
 * Copyright (c) 2006-2017 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
 * This file contains the request-handling state engine, which is intended to
31
 * (over time) be(come) protocol agnostic.
32
 * We already use this now with ESI:includes, which are for all relevant
33
 * purposes a different "protocol"
34
 *
35
 * A special complication is the fact that we can suspend processing of
36
 * a request when hash-lookup finds a busy objhdr.
37
 *
38
 */
39
40
#include "config.h"
41
42
#include "cache_int.h"
43
#include "cache_filter.h"
44
#include "cache_objhead.h"
45
#include "cache_transport.h"
46
#include "vcc_interface.h"
47
48
#include "http1/cache_http1.h"
49
#include "storage/storage.h"
50
#include "vcl.h"
51
#include "vct.h"
52
#include "vsha256.h"
53
#include "vtim.h"
54
55
#define REQ_STEPS \
56
  REQ_STEP(transport,           TRANSPORT,      ) \
57
  REQ_STEP(restart,             RESTART,        static) \
58
  REQ_STEP(recv,                RECV,           ) \
59
  REQ_STEP(pipe,                PIPE,           static) \
60
  REQ_STEP(pass,                PASS,           static) \
61
  REQ_STEP(lookup,              LOOKUP,         static) \
62
  REQ_STEP(purge,               PURGE,          static) \
63
  REQ_STEP(miss,                MISS,           static) \
64
  REQ_STEP(fetch,               FETCH,          static) \
65
  REQ_STEP(deliver,             DELIVER,        static) \
66
  REQ_STEP(vclfail,             VCLFAIL,        static) \
67
  REQ_STEP(synth,               SYNTH,          static) \
68
  REQ_STEP(transmit,            TRANSMIT,       static) \
69
  REQ_STEP(finish,              FINISH,         static)
70
71
#define REQ_STEP(l, U, priv) \
72
    static req_state_f cnt_##l; \
73
    priv const struct req_step R_STP_##U[1] = {{ \
74
        .name = "Req Step " #l, \
75
        .func = cnt_##l, \
76
    }};
77
REQ_STEPS
78
#undef REQ_STEP
79
80
/*--------------------------------------------------------------------
81
 * Handle "Expect:" and "Connection:" on incoming request
82
 */
83
84
static enum req_fsm_nxt v_matchproto_(req_state_f)
85
cnt_transport(struct worker *wrk, struct req *req)
86 8691
{
87 8691
        const char *p;
88
89 8691
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
90 8691
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
91 8691
        CHECK_OBJ_NOTNULL(req->http, HTTP_MAGIC);
92 8691
        CHECK_OBJ_NOTNULL(req->transport, TRANSPORT_MAGIC);
93 8691
        AN(req->req_body_status);
94
95 8691
        if (http_GetHdr(req->http, H_Expect, &p)) {
96 12
                if (!http_expect_eq(p, 100-continue)) {
97 2
                        req->doclose = SC_RX_JUNK;
98 2
                        (void)req->transport->minimal_response(req, 417);
99 2
                        wrk->stats->client_req_417++;
100 2
                        return (REQ_FSM_DONE);
101 2
                }
102 10
                if (req->http->protover >= 11 &&
103 10
                    req->htc->pipeline_b == NULL)       // XXX: HTTP1 vs 2 ?
104 9
                        req->want100cont = 1;
105 10
                http_Unset(req->http, H_Expect);
106 10
        }
107
108 8689
        AZ(req->err_code);
109
110 8689
        req->doclose = http_DoConnection(req->http, SC_REQ_CLOSE);
111 8689
        if (req->doclose == SC_RX_BAD) {
112 3
                wrk->stats->client_req_400++;
113 3
                (void)req->transport->minimal_response(req, 400);
114 3
                return (REQ_FSM_DONE);
115 3
        }
116
117 8686
        if (req->req_body_status->avail == 1) {
118 274
                AN(req->transport->req_body != NULL);
119 274
                VFP_Setup(req->vfc, wrk);
120 274
                req->vfc->resp = req->http;             // XXX
121 274
                req->transport->req_body(req);
122 274
        }
123
124 8686
        req->ws_req = WS_Snapshot(req->ws);
125 8686
        HTTP_Clone(req->http0, req->http);      // For ESI & restart
126 8686
        req->req_step = R_STP_RECV;
127 8686
        return (REQ_FSM_MORE);
128 8686
}
129
130
/*--------------------------------------------------------------------
131
 * Deliver an object to client
132
 */
133
134
int
135
Resp_Setup_Deliver(struct req *req)
136 5006
{
137 5006
        struct http *h;
138 5006
        struct objcore *oc;
139 5006
        const void *hdrs;
140
141 5006
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
142 5006
        oc = req->objcore;
143 5006
        CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
144
145 5006
        h = req->resp;
146
147 5006
        HTTP_Setup(h, req->ws, req->vsl, SLT_RespMethod);
148
149 5006
        hdrs = ObjGetAttr(req->wrk, oc, OA_HEADERS, NULL);
150 5006
        if (hdrs == NULL || HTTP_Decode(h, hdrs))
151 2
                return (-1);
152
153 5004
        http_ForceField(h, HTTP_HDR_PROTO, "HTTP/1.1");
154
155 5004
        if (req->is_hit)
156 2145
                http_PrintfHeader(h, "X-Vinyl: %ju %ju", VXID(req->vsl->wid),
157 2145
                    VXID(ObjGetXID(req->wrk, oc)));
158 2859
        else
159 2859
                http_PrintfHeader(h, "X-Vinyl: %ju", VXID(req->vsl->wid));
160
161
        /*
162
         * We base Age calculation upon the last timestamp taken during client
163
         * request processing. This gives some inaccuracy, but since Age is only
164
         * full second resolution that shouldn't matter. (Last request timestamp
165
         * could be a Start timestamp taken before the object entered into cache
166
         * leading to negative age. Truncate to zero in that case).
167
         */
168 5004
        http_PrintfHeader(h, "Age: %.0f",
169 5004
            floor(fmax(0., req->t_prev - oc->t_origin)));
170
171 5004
        http_AppendHeader(h, H_Via, http_ViaHeader());
172
173 5004
        if (cache_param->http_gzip_support &&
174 5004
            ObjCheckFlag(req->wrk, oc, OF_GZIPED) &&
175 5004
            !RFC2616_Req_Gzip(req->http))
176 418
                RFC2616_Weaken_Etag(h);
177 5004
        return (0);
178 5006
}
179
180
void
181
Resp_Setup_Synth(struct req *req)
182 3753
{
183 3753
        struct http *h;
184
185 3753
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
186
187 3753
        h = req->resp;
188
189 3753
        HTTP_Setup(h, req->ws, req->vsl, SLT_RespMethod);
190
191 3753
        AZ(req->objcore);
192 3753
        http_PutResponse(h, "HTTP/1.1", req->err_code, req->err_reason);
193
194 3753
        http_TimeHeader(h, "Date: ", W_TIM_real(req->wrk));
195 3753
        http_SetHeader(h, "Server: Vinyl-Cache");
196 3753
        http_PrintfHeader(h, "X-Vinyl: %ju", VXID(req->vsl->wid));
197
198
        /*
199
         * For late 100-continue, we suggest to VCL to close the connection to
200
         * neither send a 100-continue nor drain-read the request. But VCL has
201
         * the option to veto by removing Connection: close
202
         */
203 3753
        if (req->want100cont)
204 3
                http_SetHeader(h, "Connection: close");
205 3753
}
206
207
static enum req_fsm_nxt v_matchproto_(req_state_f)
208
cnt_deliver(struct worker *wrk, struct req *req)
209 4996
{
210 4996
        unsigned status;
211
212 4996
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
213 4996
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
214 4996
        CHECK_OBJ_NOTNULL(req->objcore, OBJCORE_MAGIC);
215 4996
        CHECK_OBJ_NOTNULL(req->objcore->objhead, OBJHEAD_MAGIC);
216 4996
        AZ(req->stale_oc);
217 4996
        AN(req->vcl);
218
219 4996
        assert(req->objcore->refcnt > 0);
220
221 4996
        ObjTouch(req->wrk, req->objcore, req->t_prev);
222
223 4996
        if (Resp_Setup_Deliver(req)) {
224 2
                HSH_Cancel(wrk, req->objcore, NULL);
225 2
                Req_StashObjcore(req, &req->objcore);
226 2
                req->err_code = 500;
227 2
                req->req_step = R_STP_SYNTH;
228 2
                return (REQ_FSM_MORE);
229 2
        }
230
231 4994
        status = http_GetStatus(req->resp);
232 4994
        if (cache_param->http_range_support && status == 200 &&
233 4994
            !(req->objcore->flags & OC_F_PRIVATE))
234 3405
                http_ForceHeader(req->resp, H_Accept_Ranges, "bytes");
235
236 4994
        req->esi_include_onerror = FEATURE(FEATURE_ESI_INCLUDE_ONERROR);
237
238 4994
        req->t_resp = W_TIM_real(wrk);
239 4994
        VCL_deliver_method(req->vcl, wrk, req, NULL, NULL);
240
241 4994
        assert(req->restarts <= req->max_restarts);
242
243 4994
        if (wrk->vpi->handling != VCL_RET_DELIVER) {
244 82
                HSH_Cancel(wrk, req->objcore, NULL);
245 82
                Req_StashObjcore(req, &req->objcore);
246 82
                http_Teardown(req->resp);
247
248 82
                switch (wrk->vpi->handling) {
249 34
                case VCL_RET_RESTART:
250 34
                        req->req_step = R_STP_RESTART;
251 34
                        break;
252 39
                case VCL_RET_FAIL:
253 39
                        req->req_step = R_STP_VCLFAIL;
254 39
                        break;
255 9
                case VCL_RET_SYNTH:
256 9
                        req->req_step = R_STP_SYNTH;
257 9
                        break;
258 0
                default:
259 0
                        WRONG("Illegal return from vcl_deliver{}");
260 82
                }
261
262 82
                return (REQ_FSM_MORE);
263 82
        }
264
265 4912
        VSLb_ts_req(req, "Process", W_TIM_real(wrk));
266
267 4912
        assert(wrk->vpi->handling == VCL_RET_DELIVER);
268
269 4912
        if (IS_TOPREQ(req) && RFC2616_Do_Cond(req))
270 30
                http_PutResponse(req->resp, "HTTP/1.1", 304, NULL);
271
272 4912
        req->req_step = R_STP_TRANSMIT;
273 4912
        return (REQ_FSM_MORE);
274 4912
}
275
276
/*--------------------------------------------------------------------
277
 * VCL failed, die horribly
278
 */
279
280
static enum req_fsm_nxt v_matchproto_(req_state_f)
281
cnt_vclfail(struct worker *wrk, struct req *req)
282 114
{
283 114
        struct vrt_ctx ctx[1];
284
285 114
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
286 114
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
287
288 114
        AZ(req->objcore);
289 114
        AZ(req->stale_oc);
290
291 114
        INIT_OBJ(ctx, VRT_CTX_MAGIC);
292 114
        VCL_Req2Ctx(ctx, req);
293
294 114
        Req_Rollback(ctx);
295
296 114
        if (req->req_reset) {
297 27
                req->err_code = 408;
298 27
                req->err_reason = "Client disconnected";
299 87
        } else {
300 87
                req->err_code = 503;
301 87
                req->err_reason = "VCL failed";
302 87
        }
303 114
        req->req_step = R_STP_SYNTH;
304 114
        req->doclose = SC_VCL_FAILURE;
305 114
        req->vdp_filter_list = NULL;
306 114
        return (REQ_FSM_MORE);
307 114
}
308
309
/*--------------------------------------------------------------------
310
 * Emit a synthetic response
311
 */
312
313
static enum req_fsm_nxt v_matchproto_(req_state_f)
314
cnt_synth(struct worker *wrk, struct req *req)
315 3751
{
316 3751
        ssize_t szl = 0;
317 3751
        uint16_t status;
318
319 3751
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
320 3751
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
321
322 3751
        AZ(req->objcore);
323 3751
        AZ(req->stale_oc);
324
325 3751
        wrk->stats->s_synth++;
326
327 3751
        if (req->err_code < 100)
328 0
                req->err_code = 501;
329
330 3751
        Resp_Setup_Synth(req);
331 3751
        AZ(req->objcore);
332
333 3751
        req->vdp_filter_list = NULL;
334
335 3751
        req->t_resp = W_TIM_real(wrk);
336 3751
        VCL_synth_method(req->vcl, wrk, req, NULL, &szl);
337
338 3751
        VSLb_ts_req(req, "Process", W_TIM_real(wrk));
339
340 3751
        while (wrk->vpi->handling == VCL_RET_FAIL) {
341 95
                if (req->esi_level > 0) {
342 1
                        wrk->vpi->handling = VCL_RET_DELIVER;
343 1
                        break;
344 1
                }
345 94
                (void)VRB_Ignore(req);
346 94
                status = req->req_reset ? 408 : 500;
347 94
                (void)req->transport->minimal_response(req, status);
348 94
                req->doclose = SC_VCL_FAILURE; // XXX: Not necessary any more ?
349 94
                if (req->objcore != NULL)
350 2
                        Resp_u_storage(req);
351 94
                VSLb_ts_req(req, "Resp", W_TIM_real(wrk));
352 94
                http_Teardown(req->resp);
353 94
                return (REQ_FSM_DONE);
354 95
        }
355
356 3657
        if (wrk->vpi->handling == VCL_RET_RESTART && req->restarts > req->max_restarts)
357 1
                wrk->vpi->handling = VCL_RET_DELIVER;
358
359 3657
        if (wrk->vpi->handling == VCL_RET_RESTART) {
360
                /*
361
                 * XXX: Should we reset req->doclose = SC_VCL_FAILURE
362
                 * XXX: If so, to what ?
363
                 */
364 13
                HTTP_Setup(req->resp, req->ws, req->vsl, SLT_RespMethod);
365 13
                if (req->objcore != NULL)
366 2
                        Resp_u_storage(req);
367 13
                req->req_step = R_STP_RESTART;
368 13
                return (REQ_FSM_MORE);
369 13
        }
370 3644
        assert(wrk->vpi->handling == VCL_RET_DELIVER);
371
372
        // also happens in cnt_transmit, but we need req->doclose earlier for VRB_Ignore
373 3644
        if (req->doclose == SC_NULL)
374 3550
                req->doclose = http_DoConnection(req->http, SC_REQ_CLOSE);
375 3644
        if (req->doclose == SC_NULL)
376 3547
                req->doclose = http_DoConnection(req->resp, SC_RESP_CLOSE);
377
378
        /* Discard any lingering request body before delivery */
379 3644
        (void)VRB_Ignore(req);
380
381 3644
        if (req->objcore == NULL)
382 88
                szl = Resp_l_storage(req, stv_synth) ? 0 : -1;
383
384 3645
        if (req->objcore == NULL || szl < 0)
385 0
                szl = -1;
386 3644
        else if (req->objcore->stobj->stevedore->allocobj != ssy_stevedore.allocobj) {
387
                // XXX generalize to bocless #4573
388 1546
                assert(szl >= 0);
389
                //// XXX worth the alloc+memcpy in trimstore?
390
                //ObjExtend(wrk, req->objcore, 0, 1);
391 1546
                AZ(ObjSetU64(wrk, req->objcore, OA_LEN, szl));
392 1546
        }
393 3644
        if (req->objcore != NULL)
394 3645
                HSH_DerefBoc(wrk, req->objcore);
395
396 3644
        if (szl < 0) {
397 0
                VSLb(req->vsl, SLT_Error, "Could not get storage");
398 0
                req->doclose = SC_OVERLOAD;
399 0
                VSLb_ts_req(req, "Resp", W_TIM_real(wrk));
400 0
                if (req->objcore != NULL)
401 0
                        (void)HSH_DerefObjCore(wrk, &req->objcore);
402 0
                http_Teardown(req->resp);
403 0
                return (REQ_FSM_DONE);
404 0
        }
405
406 3644
        req->req_step = R_STP_TRANSMIT;
407 3644
        return (REQ_FSM_MORE);
408 3644
}
409
410
/*--------------------------------------------------------------------
411
 * The mechanics of sending a response (from deliver or synth)
412
 */
413
414
static enum req_fsm_nxt v_matchproto_(req_state_f)
415
cnt_transmit(struct worker *wrk, struct req *req)
416 8554
{
417 8554
        enum req_fsm_nxt nxt = REQ_FSM_MORE;
418 8554
        enum vtr_deliver_e dnxt;
419 8554
        uint16_t status;
420 8554
        int sendbody, head;
421 8554
        intmax_t clval;
422
423 8554
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
424 8554
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
425 8554
        CHECK_OBJ_NOTNULL(req->transport, TRANSPORT_MAGIC);
426 8554
        CHECK_OBJ_NOTNULL(req->objcore, OBJCORE_MAGIC);
427 8554
        AZ(req->stale_oc);
428 8554
        AZ(req->res_pipe | req->res_esi);
429 8554
        AZ(req->boc);
430 8554
        req->req_step = R_STP_FINISH;
431
432 8554
        if (req->doclose == SC_NULL)
433 8366
                req->doclose = http_DoConnection(req->http, SC_REQ_CLOSE);
434 8554
        if (req->doclose == SC_NULL)
435 8367
                req->doclose = http_DoConnection(req->resp, SC_RESP_CLOSE);
436
437
        /* Grab a ref to the bo if there is one (=streaming) */
438 8554
        req->boc = HSH_RefBoc(req->objcore);
439 8554
        if (req->boc && req->boc->state < BOS_STREAM)
440 0
                (void)ObjWaitState(req->objcore, BOS_STREAM);
441 8554
        clval = http_GetContentLength(req->resp);
442
        /* RFC 7230, 3.3.3 */
443 8554
        status = http_GetStatus(req->resp);
444 8554
        head = http_method_eq(req->http0->wkm, WKM_HEAD);
445
446 8554
        if (req->boc != NULL || (req->objcore->flags & (OC_F_FAILED)))
447 1090
                req->resp_len = clval;
448 7464
        else
449 7464
                req->resp_len = ObjGetLen(req->wrk, req->objcore);
450
451 8554
        if (head || status < 200 || status == 204 || status == 304) {
452
                // rfc7230,l,1748,1752
453 171
                sendbody = 0;
454 8383
        } else {
455 8383
                sendbody = 1;
456 8383
        }
457
458 8554
        VDP_Init(req->vdc, req->wrk, req->vsl, req, NULL, &req->resp_len);
459 8554
        if (req->vdp_filter_list == NULL)
460 8264
                req->vdp_filter_list = resp_Get_Filter_List(req);
461 8554
        if (req->vdp_filter_list == NULL ||
462 8556
            VCL_StackVDP(req->vdc, req->vcl, req->vdp_filter_list, req, NULL)) {
463 64
                VSLb(req->vsl, SLT_Error, "Failure to push processors");
464 64
                req->doclose = SC_OVERLOAD;
465 64
                req->acct.resp_bodybytes +=
466 64
                        VDP_Close(req->vdc, req->objcore, req->boc);
467 8490
        } else {
468 8490
                if (status < 200 || status == 204) {
469
                        // rfc7230,l,1691,1695
470 24
                        http_Unset(req->resp, H_Content_Length);
471 8466
                } else if (status == 304) {
472
                        // rfc7230,l,1675,1677
473 34
                        http_Unset(req->resp, H_Content_Length);
474 8432
                } else if (clval >= 0 && clval == req->resp_len) {
475
                        /* Reuse C-L header */
476 5515
                } else if (head) {
477
                        /* rfc9110,l,3226,3227
478
                         * "MAY send Content-Length ... [for] HEAD"
479
                         * do not touch to support cached HEAD #4245
480
                         */
481 5
                        req->resp_len = 0;
482 5510
                } else {
483 5510
                        http_Unset(req->resp, H_Content_Length);
484 5510
                        if (req->resp_len >= 0)
485 4779
                                http_PrintfHeader(req->resp,
486 4779
                                    "Content-Length: %jd", req->resp_len);
487 5510
                }
488 8490
                if (req->resp_len == 0)
489 1267
                        sendbody = 0;
490 8490
                dnxt = req->transport->deliver(req, sendbody);
491 8490
                if (dnxt == VTR_D_DISEMBARK)
492 72
                        nxt = REQ_FSM_DISEMBARK;
493 8418
                else
494 8418
                        assert(dnxt == VTR_D_DONE);
495 8490
        }
496 8554
        return (nxt);
497 8554
}
498
499
static enum req_fsm_nxt v_matchproto_(req_state_f)
500
cnt_finish(struct worker *wrk, struct req *req)
501 8554
{
502
503 8554
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
504 8554
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
505
506 8554
        VSLb_ts_req(req, "Resp", W_TIM_real(wrk));
507
508 8554
        if (req->doclose == SC_NULL && (req->objcore->flags & OC_F_FAILED)) {
509
                /* The object we delivered failed due to a streaming error.
510
                 * Fail the request. */
511 20
                req->doclose = SC_TX_ERROR;
512 20
        }
513
514 8554
        if (req->boc != NULL) {
515 1089
                HSH_DerefBoc(wrk, req->objcore);
516 1089
                req->boc = NULL;
517 1089
        }
518
519 8554
        (void)HSH_DerefObjCore(wrk, &req->objcore);
520 8554
        http_Teardown(req->resp);
521
522 8554
        req->vdp_filter_list = NULL;
523 8554
        req->res_pipe = 0;
524 8554
        req->res_esi = 0;
525 8554
        return (REQ_FSM_DONE);
526 8554
}
527
528
/*--------------------------------------------------------------------
529
 * Initiated a fetch (pass/miss) which we intend to deliver
530
 */
531
532
static enum req_fsm_nxt v_matchproto_(req_state_f)
533
cnt_fetch(struct worker *wrk, struct req *req)
534 2879
{
535
536 2879
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
537 2879
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
538 2879
        CHECK_OBJ_NOTNULL(req->objcore, OBJCORE_MAGIC);
539 2879
        AZ(req->stale_oc);
540
541 2879
        wrk->stats->s_fetch++;
542 2879
        (void)VRB_Ignore(req);
543
544 2879
        if (req->objcore->flags & OC_F_FAILED) {
545 28
                req->err_code = 503;
546 28
                req->req_step = R_STP_SYNTH;
547 28
                (void)HSH_DerefObjCore(wrk, &req->objcore);
548 28
                AZ(req->objcore);
549 28
                return (REQ_FSM_MORE);
550 28
        }
551
552 2851
        req->req_step = R_STP_DELIVER;
553 2851
        return (REQ_FSM_MORE);
554 2879
}
555
556
/*--------------------------------------------------------------------
557
 * Attempt to lookup objhdr from hash.  We disembark and reenter
558
 * this state if we get suspended on a busy objhdr.
559
 */
560
561
static enum req_fsm_nxt v_matchproto_(req_state_f)
562
cnt_lookup(struct worker *wrk, struct req *req)
563 3702
{
564 3702
        struct objcore *oc, *busy;
565 3702
        enum lookup_e lr;
566 3702
        int waitinglist_gen;
567
568 3702
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
569 3702
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
570 3702
        AZ(req->stale_oc);
571
572 3702
        AN(req->vcl);
573
574 3702
        VRY_Prep(req);
575 3702
        waitinglist_gen = req->waitinglist_gen;
576
577 3702
        if (req->waitinglist_gen) {
578 59
                CHECK_OBJ_NOTNULL(req->objcore, OBJCORE_MAGIC);
579 59
                req->waitinglist_gen = 0;
580 59
        } else
581 3643
                AZ(req->objcore);
582
583 3702
        wrk->strangelove = 0;
584 3702
        lr = HSH_Lookup(req, &oc, &busy);
585 3702
        if (lr == HSH_BUSY) {
586
                /*
587
                 * We lost the session to a busy object, disembark the
588
                 * worker thread.   We return to STP_LOOKUP when the busy
589
                 * object has been unbusied, and still have the objhead
590
                 * around to restart the lookup with.
591
                 */
592 59
                return (REQ_FSM_DISEMBARK);
593 59
        }
594 3643
        assert(wrk->strangelove >= 0);
595 3643
        if ((unsigned)wrk->strangelove >= cache_param->vary_notice)
596 62
                VSLb(req->vsl, SLT_Notice, "vsl: High number of variants (%d)",
597 62
                    wrk->strangelove);
598 3643
        if (waitinglist_gen)
599 59
                VSLb_ts_req(req, "Waitinglist", W_TIM_real(wrk));
600
601 3643
        if (req->vcf != NULL) {
602 6
                (void)req->vcf->func(req, NULL, NULL, 2);
603 6
                req->vcf = NULL;
604 6
        }
605
606 3643
        if (busy == NULL) {
607 2092
                VRY_Finish(req, DISCARD);
608 2092
        } else {
609 1551
                AN(busy->flags & OC_F_BUSY);
610 1551
                VRY_Finish(req, KEEP);
611 1551
        }
612
613 3643
        AZ(req->objcore);
614 3643
        if (lr == HSH_MISS || lr == HSH_HITMISS) {
615 1455
                AN(busy);
616 1455
                AN(busy->flags & OC_F_BUSY);
617 1455
                req->objcore = busy;
618 1455
                req->stale_oc = oc;
619 1455
                req->req_step = R_STP_MISS;
620 1455
                if (lr == HSH_HITMISS)
621 36
                        req->is_hitmiss = 1;
622 1455
                return (REQ_FSM_MORE);
623 1455
        }
624 2188
        if (lr == HSH_HITPASS) {
625 13
                AZ(busy);
626 13
                AZ(oc);
627 13
                req->req_step = R_STP_PASS;
628 13
                req->is_hitpass = 1;
629 13
                return (REQ_FSM_MORE);
630 13
        }
631
632 2175
        assert(lr == HSH_HIT || lr == HSH_GRACE);
633
634 2175
        CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
635 2175
        AZ(oc->flags & (OC_F_BUSY | OC_F_HFM));
636 2175
        req->objcore = oc;
637
638 2175
        VCL_hit_method(req->vcl, wrk, req, NULL, NULL);
639
640 2175
        switch (wrk->vpi->handling) {
641 2144
        case VCL_RET_DELIVER:
642 2144
                if (busy != NULL) {
643 89
                        AZ(oc->flags & OC_F_HFM);
644 89
                        CHECK_OBJ_NOTNULL(busy->boc, BOC_MAGIC);
645
                        // XXX: shouldn't we go to miss?
646 89
                        VBF_Fetch(wrk, req, busy, oc, VBF_BACKGROUND);
647 89
                        wrk->stats->s_fetch++;
648 89
                        wrk->stats->s_bgfetch++;
649 2055
                } else {
650 2055
                        (void)VRB_Ignore(req);// XXX: handle err
651 2055
                }
652 2144
                wrk->stats->cache_hit++;
653 2144
                req->is_hit = 1;
654 2144
                if (lr == HSH_GRACE)
655 92
                        wrk->stats->cache_hit_grace++;
656 2144
                req->req_step = R_STP_DELIVER;
657 2144
                return (REQ_FSM_MORE);
658 14
        case VCL_RET_RESTART:
659 14
                req->req_step = R_STP_RESTART;
660 14
                break;
661 5
        case VCL_RET_FAIL:
662 5
                req->req_step = R_STP_VCLFAIL;
663 5
                break;
664 9
        case VCL_RET_SYNTH:
665 9
                req->req_step = R_STP_SYNTH;
666 9
                break;
667 2
        case VCL_RET_PASS:
668 2
                wrk->stats->cache_hit++;
669 2
                req->is_hit = 1;
670 2
                req->req_step = R_STP_PASS;
671 2
                break;
672 0
        default:
673 0
                WRONG("Illegal return from vcl_hit{}");
674 2175
        }
675
676 30
        Req_StashObjcore(req, &req->objcore);
677
678 30
        if (busy != NULL) {
679 7
                HSH_Withdraw(wrk, &busy);
680 7
                VRY_Clear(req);
681 7
        }
682
683 30
        return (REQ_FSM_MORE);
684 2175
}
685
686
/*--------------------------------------------------------------------
687
 * Cache miss.
688
 */
689
690
static enum req_fsm_nxt v_matchproto_(req_state_f)
691
cnt_miss(struct worker *wrk, struct req *req)
692 1455
{
693
694 1455
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
695 1455
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
696 1455
        AN(req->vcl);
697 1455
        CHECK_OBJ_NOTNULL(req->objcore, OBJCORE_MAGIC);
698 1455
        CHECK_OBJ_ORNULL(req->stale_oc, OBJCORE_MAGIC);
699
700 1455
        VCL_miss_method(req->vcl, wrk, req, NULL, NULL);
701 1455
        switch (wrk->vpi->handling) {
702 1440
        case VCL_RET_FETCH:
703 1440
                wrk->stats->cache_miss++;
704 1440
                VBF_Fetch(wrk, req, req->objcore, req->stale_oc, VBF_NORMAL);
705 1440
                if (req->stale_oc != NULL)
706 71
                        Req_StashObjcore(req, &req->stale_oc);
707 1440
                req->req_step = R_STP_FETCH;
708 1440
                return (REQ_FSM_MORE);
709 3
        case VCL_RET_FAIL:
710 3
                req->req_step = R_STP_VCLFAIL;
711 3
                break;
712 5
        case VCL_RET_SYNTH:
713 5
                req->req_step = R_STP_SYNTH;
714 5
                break;
715 4
        case VCL_RET_RESTART:
716 4
                req->req_step = R_STP_RESTART;
717 4
                break;
718 3
        case VCL_RET_PASS:
719 3
                req->req_step = R_STP_PASS;
720 3
                break;
721 0
        default:
722 0
                WRONG("Illegal return from vcl_miss{}");
723 1455
        }
724 15
        VRY_Clear(req);
725 15
        if (req->stale_oc != NULL)
726 1
                Req_StashObjcore(req, &req->stale_oc);
727 15
        HSH_Withdraw(wrk, &req->objcore);
728 15
        return (REQ_FSM_MORE);
729 1455
}
730
731
/*--------------------------------------------------------------------
732
 * Pass processing
733
 */
734
735
static enum req_fsm_nxt v_matchproto_(req_state_f)
736
cnt_pass(struct worker *wrk, struct req *req)
737 1443
{
738
739 1443
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
740 1443
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
741 1443
        AN(req->vcl);
742 1443
        AZ(req->objcore);
743 1443
        AZ(req->stale_oc);
744
745 1443
        VCL_pass_method(req->vcl, wrk, req, NULL, NULL);
746 1443
        switch (wrk->vpi->handling) {
747 1
        case VCL_RET_FAIL:
748 1
                req->req_step = R_STP_VCLFAIL;
749 1
                break;
750 1
        case VCL_RET_SYNTH:
751 1
                req->req_step = R_STP_SYNTH;
752 1
                break;
753 0
        case VCL_RET_RESTART:
754 0
                req->req_step = R_STP_RESTART;
755 0
                break;
756 1441
        case VCL_RET_FETCH:
757 1441
                wrk->stats->s_pass++;
758 1441
                req->objcore = HSH_Private(wrk);
759 1441
                CHECK_OBJ_NOTNULL(req->objcore, OBJCORE_MAGIC);
760 1441
                VBF_Fetch(wrk, req, req->objcore, NULL, VBF_PASS);
761 1441
                req->req_step = R_STP_FETCH;
762 1441
                break;
763 0
        default:
764 0
                WRONG("Illegal return from cnt_pass{}");
765 1443
        }
766 1443
        return (REQ_FSM_MORE);
767 1443
}
768
769
/*--------------------------------------------------------------------
770
 * Pipe mode
771
 */
772
773
static enum req_fsm_nxt v_matchproto_(req_state_f)
774
cnt_pipe(struct worker *wrk, struct req *req)
775 31
{
776 31
        struct busyobj *bo;
777 31
        enum req_fsm_nxt nxt;
778
779 31
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
780 31
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
781 31
        AZ(req->objcore);
782 31
        AZ(req->stale_oc);
783 31
        AN(req->vcl);
784
785 31
        wrk->stats->s_pipe++;
786 31
        bo = VBO_GetBusyObj(wrk, req);
787 31
        CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
788 31
        VSLb(bo->vsl, SLT_Begin, "bereq %ju pipe", VXID(req->vsl->wid));
789 31
        VSLb(req->vsl, SLT_Link, "bereq %ju pipe", VXID(bo->vsl->wid));
790 31
        VSLb_ts_busyobj(bo, "Start", W_TIM_real(wrk));
791 31
        THR_SetBusyobj(bo);
792 31
        bo->sp = req->sp;
793 31
        SES_Ref(bo->sp);
794
795 31
        HTTP_Setup(bo->bereq, req->ws, bo->vsl, SLT_BereqMethod);
796 31
        http_FilterReq(bo->bereq, req->http, 0);        // XXX: 0 ?
797 31
        http_PrintfHeader(bo->bereq, "X-Vinyl: %ju", VXID(req->vsl->wid));
798 31
        http_ForceHeader(bo->bereq, H_Connection, "close");
799
800 31
        if (req->want100cont) {
801 0
                http_SetHeader(bo->bereq, "Expect: 100-continue");
802 0
                req->want100cont = 0;
803 0
        }
804
805 31
        bo->wrk = wrk;
806 31
        bo->task_deadline = NAN; /* XXX: copy req->task_deadline */
807 31
        if (WS_Overflowed(req->ws))
808 1
                wrk->vpi->handling = VCL_RET_FAIL;
809 30
        else
810 30
                VCL_pipe_method(req->vcl, wrk, req, bo, NULL);
811
812 31
        switch (wrk->vpi->handling) {
813 3
        case VCL_RET_SYNTH:
814 3
                req->req_step = R_STP_SYNTH;
815 3
                nxt = REQ_FSM_MORE;
816 3
                break;
817 26
        case VCL_RET_PIPE:
818 26
                VSLb_ts_req(req, "Process", W_TIM_real(wrk));
819 26
                VSLb_ts_busyobj(bo, "Process", wrk->lastused);
820 26
                if (V1P_Enter() == 0) {
821 25
                        AZ(bo->req);
822 25
                        bo->req = req;
823 25
                        bo->wrk = wrk;
824
                        /* Unless cached, reqbody is not our job */
825 25
                        if (req->req_body_status != BS_CACHED)
826 24
                                req->req_body_status = BS_NONE;
827 25
                        SES_Close(req->sp, VDI_Http1Pipe(req, bo));
828 25
                        nxt = REQ_FSM_DONE;
829 25
                        V1P_Leave();
830 25
                        break;
831 25
                }
832 1
                wrk->stats->pipe_limited++;
833
                /* fall through */
834 3
        case VCL_RET_FAIL:
835 3
                req->req_step = R_STP_VCLFAIL;
836 3
                nxt = REQ_FSM_MORE;
837 3
                break;
838 0
        default:
839 0
                WRONG("Illegal return from vcl_pipe{}");
840 31
        }
841 31
        http_Teardown(bo->bereq);
842 31
        SES_Rel(bo->sp);
843 31
        VBO_ReleaseBusyObj(wrk, &bo);
844 31
        THR_SetBusyobj(NULL);
845 31
        return (nxt);
846 31
}
847
848
/*--------------------------------------------------------------------
849
 * Handle restart events
850
 */
851
852
static enum req_fsm_nxt v_matchproto_(req_state_f)
853
cnt_restart(struct worker *wrk, struct req *req)
854 77
{
855
856 77
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
857 77
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
858 77
        AZ(req->objcore);
859 77
        AZ(req->stale_oc);
860
861 77
        req->vdp_filter_list = NULL;
862
863 77
        if (++req->restarts > req->max_restarts) {
864 10
                VSLb(req->vsl, SLT_VCL_Error, "Too many restarts");
865 10
                req->err_code = 503;
866 10
                req->req_step = R_STP_SYNTH;
867 67
        } else {
868
                // XXX: ReqEnd + ReqAcct ?
869 67
                VSLb_ts_req(req, "Restart", W_TIM_real(wrk));
870 67
                VSL_ChgId(req->vsl, "req", "restart",
871 67
                    VXID_Get(wrk, VSL_CLIENTMARKER));
872 67
                VSLb_ts_req(req, "Start", req->t_prev);
873 67
                req->err_code = 0;
874 67
                req->req_step = R_STP_RECV;
875 67
        }
876 77
        return (REQ_FSM_MORE);
877 77
}
878
879
/*
880
 * prepare the request for vcl_recv, either initially or after a reset
881
 * e.g. due to vcl switching
882
 *
883
 * TODO
884
 * - make restarts == 0 bit re-usable for rollback
885
 * - remove duplication with Req_Cleanup()
886
 */
887
888
static void v_matchproto_(req_state_f)
889
cnt_recv_prep(struct req *req, const char *ci)
890 8765
{
891
892 8765
        if (req->restarts == 0) {
893
                /*
894
                 * This really should be done earlier, but we want to capture
895
                 * it in the VSL log.
896
                 */
897 8698
                http_AppendHeader(req->http, H_X_Forwarded_For, ci);
898 8698
                http_AppendHeader(req->http, H_Via, http_ViaHeader());
899 8698
                http_CollectHdr(req->http, H_Cache_Control);
900
901
                /* By default we use the first backend */
902 8698
                VRT_Assign_Backend(&req->director_hint,
903 8698
                    VCL_DefaultDirector(req->vcl));
904
905 8698
                req->d_ttl = -1;
906 8698
                req->d_grace = -1;
907 8698
                req->disable_esi = 0;
908 8698
                req->hash_always_miss = 0;
909 8698
                req->hash_ignore_busy = 0;
910 8698
                req->hash_ignore_vary = 0;
911 8698
                req->client_identity = NULL;
912 8698
                req->storage = NULL;
913 8698
                req->trace = FEATURE(FEATURE_TRACE);
914 8698
        }
915
916 8765
        req->is_hit = 0;
917 8765
        req->is_hitmiss = 0;
918 8765
        req->is_hitpass = 0;
919 8765
        req->err_code = 0;
920 8765
        req->err_reason = NULL;
921
922 8765
        req->vfp_filter_list = NULL;
923 8765
}
924
925
/*--------------------------------------------------------------------
926
 * We have a complete request, set everything up and start it.
927
 * We can come here both with a request from the client and with
928
 * a interior request during ESI delivery.
929
 */
930
931
static enum req_fsm_nxt v_matchproto_(req_state_f)
932
cnt_recv(struct worker *wrk, struct req *req)
933 8754
{
934 8754
        unsigned recv_handling;
935 8754
        struct VSHA256Context sha256ctx;
936 8754
        const char *ci;
937
938 8754
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
939 8754
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
940 8754
        AN(req->vcl);
941 8754
        AZ(req->objcore);
942 8754
        AZ(req->stale_oc);
943 8754
        AZ(req->err_code);
944
945 8754
        AZ(isnan(req->t_first));
946 8754
        AZ(isnan(req->t_prev));
947 8754
        AZ(isnan(req->t_req));
948
949 8754
        ci = Req_LogStart(wrk, req);
950 8754
        http_VSL_log(req->http);
951
952 8754
        if (http_CountHdr(req->http0, H_Host) > 1) {
953 2
                VSLb(req->vsl, SLT_BogoHeader, "Multiple Host: headers");
954 2
                wrk->stats->client_req_400++;
955 2
                req->doclose = SC_RX_BAD;
956 2
                (void)req->transport->minimal_response(req, 400);
957 2
                return (REQ_FSM_DONE);
958 2
        }
959
960 8752
        cnt_recv_prep(req, ci);
961
962 8752
        if (req->req_body_status == BS_ERROR) {
963 0
                req->doclose = SC_OVERLOAD;
964 0
                return (REQ_FSM_DONE);
965 0
        }
966
967 8752
        VCL_recv_method(req->vcl, wrk, req, NULL, NULL);
968
969 8752
        if (wrk->vpi->handling == VCL_RET_FAIL) {
970 51
                req->req_step = R_STP_VCLFAIL;
971 51
                return (REQ_FSM_MORE);
972 51
        }
973
974 8701
        if (wrk->vpi->handling == VCL_RET_VCL && req->restarts == 0) {
975
                // Req_Rollback has happened in VPI_vcl_select
976 13
                assert(WS_Snapshot(req->ws) == req->ws_req);
977 13
                cnt_recv_prep(req, ci);
978 13
                VCL_recv_method(req->vcl, wrk, req, NULL, NULL);
979 13
        }
980
981 8701
        if (req->want100cont && !req->late100cont) {
982 4
                req->want100cont = 0;
983 4
                if (req->transport->minimal_response(req, 100)) {
984 0
                        req->doclose = SC_REM_CLOSE;
985 0
                        return (REQ_FSM_DONE);
986 0
                }
987 4
        }
988
989
        /* Attempts to cache req.body may fail */
990 8701
        if (req->req_body_status == BS_ERROR) {
991 6
                req->doclose = SC_RX_BODY;
992 6
                (void)req->transport->minimal_response(req, 400);
993 6
                return (REQ_FSM_DONE);
994 6
        }
995
996 8695
        recv_handling = wrk->vpi->handling;
997
998
        /* We wash the A-E header here for the sake of VRY */
999 8695
        if (cache_param->http_gzip_support &&
1000 8695
             (recv_handling != VCL_RET_PIPE) &&
1001 8695
             (recv_handling != VCL_RET_PASS)) {
1002 7231
                if (RFC2616_Req_Gzip(req->http)) {
1003 1603
                        http_ForceHeader(req->http, H_Accept_Encoding, "gzip");
1004 5628
                } else {
1005 5628
                        http_Unset(req->http, H_Accept_Encoding);
1006 5628
                }
1007 7231
        }
1008
1009 8695
        VSHA256_Init(&sha256ctx);
1010 8695
        VCL_hash_method(req->vcl, wrk, req, NULL, &sha256ctx);
1011 8695
        if (wrk->vpi->handling == VCL_RET_FAIL)
1012 11
                recv_handling = wrk->vpi->handling;
1013 8684
        else
1014 8684
                assert(wrk->vpi->handling == VCL_RET_LOOKUP);
1015 8695
        VSHA256_Final(req->digest, &sha256ctx);
1016
1017 8695
        switch (recv_handling) {
1018 4
        case VCL_RET_VCL:
1019 4
                VSLb(req->vsl, SLT_VCL_Error,
1020 4
                    "Illegal return(vcl): %s",
1021 4
                    req->restarts ? "Not after restarts" :
1022 4
                    "Only from active VCL");
1023 4
                req->err_code = 503;
1024 4
                req->req_step = R_STP_SYNTH;
1025 4
                break;
1026 10
        case VCL_RET_PURGE:
1027 10
                req->req_step = R_STP_PURGE;
1028 10
                break;
1029 3642
        case VCL_RET_HASH:
1030 3642
                req->req_step = R_STP_LOOKUP;
1031 3642
                break;
1032 33
        case VCL_RET_PIPE:
1033 33
                if (!IS_TOPREQ(req)) {
1034 0
                        VSLb(req->vsl, SLT_VCL_Error,
1035 0
                            "vcl_recv{} returns pipe for ESI included object."
1036 0
                            "  Doing pass.");
1037 0
                        req->req_step = R_STP_PASS;
1038 33
                } else if (req->http0->protover > 11) {
1039 2
                        VSLb(req->vsl, SLT_VCL_Error,
1040 2
                            "vcl_recv{} returns pipe for HTTP/2 request."
1041 2
                            "  Doing pass.");
1042 2
                        req->req_step = R_STP_PASS;
1043 31
                } else {
1044 31
                        req->req_step = R_STP_PIPE;
1045 31
                }
1046 33
                break;
1047 1423
        case VCL_RET_PASS:
1048 1423
                req->req_step = R_STP_PASS;
1049 1423
                break;
1050 3561
        case VCL_RET_SYNTH:
1051 3561
                req->req_step = R_STP_SYNTH;
1052 3561
                break;
1053 9
        case VCL_RET_RESTART:
1054 9
                req->req_step = R_STP_RESTART;
1055 9
                break;
1056 11
        case VCL_RET_FAIL:
1057 11
                req->req_step = R_STP_VCLFAIL;
1058 11
                break;
1059 0
        default:
1060 0
                WRONG("Illegal return from vcl_recv{}");
1061 8695
        }
1062 8692
        return (REQ_FSM_MORE);
1063 8695
}
1064
1065
/*--------------------------------------------------------------------
1066
 * Find the objhead, purge it.
1067
 *
1068
 * In VCL, a restart is necessary to get a new object
1069
 */
1070
1071
static enum req_fsm_nxt v_matchproto_(req_state_f)
1072
cnt_purge(struct worker *wrk, struct req *req)
1073 10
{
1074 10
        struct objcore *oc, *boc;
1075 10
        enum lookup_e lr;
1076
1077 10
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
1078 10
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
1079 10
        AZ(req->objcore);
1080 10
        AZ(req->stale_oc);
1081
1082 10
        AN(req->vcl);
1083
1084 10
        VRY_Prep(req);
1085
1086 10
        AZ(req->objcore);
1087 10
        req->hash_always_miss = 1;
1088 10
        lr = HSH_Lookup(req, &oc, &boc);
1089 10
        assert (lr == HSH_MISS);
1090 10
        AZ(oc);
1091 10
        CHECK_OBJ_NOTNULL(boc, OBJCORE_MAGIC);
1092 10
        VRY_Finish(req, DISCARD);
1093
1094 10
        (void)HSH_Purge(wrk, boc->objhead, req->t_req, 0, 0, 0);
1095
1096 10
        HSH_Withdraw(wrk, &boc);
1097
1098 10
        VCL_purge_method(req->vcl, wrk, req, NULL, NULL);
1099 10
        switch (wrk->vpi->handling) {
1100 3
        case VCL_RET_RESTART:
1101 3
                req->req_step = R_STP_RESTART;
1102 3
                break;
1103 1
        case VCL_RET_FAIL:
1104 1
                req->req_step = R_STP_VCLFAIL;
1105 1
                break;
1106 6
        case VCL_RET_SYNTH:
1107 6
                req->req_step = R_STP_SYNTH;
1108 6
                break;
1109 0
        default:
1110 0
                WRONG("Illegal return from vcl_purge{}");
1111 10
        }
1112 10
        return (REQ_FSM_MORE);
1113 10
}
1114
1115
/*--------------------------------------------------------------------
1116
 * Central state engine dispatcher.
1117
 *
1118
 * Kick the session around until it has had enough.
1119
 *
1120
 */
1121
1122
static void v_matchproto_(req_state_f)
1123
cnt_diag(struct req *req, const char *state)
1124 446
{
1125
1126 446
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
1127
1128 446
        VSLb(req->vsl,  SLT_Debug, "vxid %ju STP_%s sp %p vcl %p",
1129 446
            VXID(req->vsl->wid), state, req->sp, req->vcl);
1130 446
        VSL_Flush(req->vsl, 0);
1131 446
}
1132
1133
void
1134
CNT_Embark(struct worker *wrk, struct req *req)
1135 8893
{
1136
1137 8893
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
1138 8893
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
1139
1140
        /* wrk can have changed for restarts */
1141 8893
        req->vfc->wrk = req->wrk = wrk;
1142 8893
        wrk->vsl = req->vsl;
1143 8893
        if (req->req_step == R_STP_TRANSPORT && req->vcl == NULL) {
1144 4285
                VCL_Refresh(&wrk->wpriv->vcl);
1145 4285
                req->vcl = wrk->wpriv->vcl;
1146 4285
                wrk->wpriv->vcl = NULL;
1147 4285
                VSLbs(req->vsl, SLT_VCL_use, TOSTRAND(VCL_Name(req->vcl)));
1148 4285
        }
1149
1150 8893
        AN(req->vcl);
1151 8893
}
1152
1153
enum req_fsm_nxt
1154
CNT_Request(struct req *req)
1155 8826
{
1156 8826
        struct vrt_ctx ctx[1];
1157 8826
        struct worker *wrk;
1158 8826
        enum req_fsm_nxt nxt;
1159
1160 8826
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
1161
1162 8826
        wrk = req->wrk;
1163 8826
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
1164
1165 8826
        CHECK_OBJ_NOTNULL(req->transport, TRANSPORT_MAGIC);
1166 8826
        AN(req->transport->deliver);
1167 8826
        AN(req->transport->minimal_response);
1168
1169
        /*
1170
         * Possible entrance states
1171
         */
1172 8826
        assert(
1173 8826
            req->req_step == R_STP_LOOKUP ||
1174 8826
            req->req_step == R_STP_FINISH ||
1175 8826
            req->req_step == R_STP_TRANSPORT);
1176
1177 8826
        AN(VXID_TAG(req->vsl->wid) & VSL_CLIENTMARKER);
1178 8826
        AN(req->vcl);
1179
1180 61827
        for (nxt = REQ_FSM_MORE; nxt == REQ_FSM_MORE; ) {
1181
                /*
1182
                 * This is a good place to be paranoid about the various
1183
                 * pointers still pointing to the things we expect.
1184
                 */
1185 53001
                CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
1186 53001
                CHECK_OBJ_NOTNULL(wrk->wpriv, WORKER_PRIV_MAGIC);
1187 53001
                CHECK_OBJ_ORNULL(wrk->wpriv->nobjhead, OBJHEAD_MAGIC);
1188 53001
                CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
1189 53001
                CHECK_OBJ_NOTNULL(req->doclose, STREAM_CLOSE_MAGIC);
1190
1191 53001
                AN(req->req_step);
1192 53001
                AN(req->req_step->name);
1193 53001
                AN(req->req_step->func);
1194 53001
                if (DO_DEBUG(DBG_REQ_STATE))
1195 446
                        cnt_diag(req, req->req_step->name);
1196 53001
                nxt = req->req_step->func(wrk, req);
1197 53001
                CHECK_OBJ_ORNULL(wrk->wpriv->nobjhead, OBJHEAD_MAGIC);
1198 53001
        }
1199 8826
        wrk->vsl = NULL;
1200 8826
        if (nxt == REQ_FSM_DONE) {
1201 8687
                INIT_OBJ(ctx, VRT_CTX_MAGIC);
1202 8687
                VCL_Req2Ctx(ctx, req);
1203 8687
                if (IS_TOPREQ(req)) {
1204 4280
                        VCL_TaskLeave(ctx, req->top->privs);
1205 4280
                        if (req->top->vcl0 != NULL)
1206 12
                                VCL_Recache(wrk, &req->top->vcl0);
1207 4280
                }
1208 8687
                VCL_TaskLeave(ctx, req->privs);
1209 8687
                assert(!IS_NO_VXID(req->vsl->wid));
1210 8687
                VRB_Free(req);
1211 8687
                VRT_Assign_Backend(&req->director_hint, NULL);
1212 8687
                req->wrk = NULL;
1213 8687
        }
1214 8826
        assert(nxt == REQ_FSM_DISEMBARK || !WS_IsReserved(req->ws));
1215 8826
        return (nxt);
1216 8826
}