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