GCOV - Varnish Cache


/*-
 * Copyright (c) 2006 Verdens Gang AS
 * Copyright (c) 2006-2017 Varnish Software AS
 * All rights reserved.
 *
 * Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
 *
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * This file contains the request-handling state engine, which is intended to
 * (over time) be(come) protocol agnostic.
 * We already use this now with ESI:includes, which are for all relevant
 * purposes a different "protocol"
 *
 * A special complication is the fact that we can suspend processing of
 * a request when hash-lookup finds a busy objhdr.
 *
 */

#include "config.h"

#include "cache_varnishd.h"
#include "cache_filter.h"
#include "cache_objhead.h"
#include "cache_transport.h"
#include "vcc_interface.h"

#include "http1/cache_http1.h"
#include "storage/storage.h"
#include "vcl.h"
#include "vct.h"
#include "vsha256.h"
#include "vtim.h"

#define REQ_STEPS \
  REQ_STEP(transport,           TRANSPORT,      ) \
  REQ_STEP(restart,             RESTART,        static) \
  REQ_STEP(recv,                RECV,           ) \
  REQ_STEP(pipe,                PIPE,           static) \
  REQ_STEP(pass,                PASS,           static) \
  REQ_STEP(lookup,              LOOKUP,         static) \
  REQ_STEP(purge,               PURGE,          static) \
  REQ_STEP(miss,                MISS,           static) \
  REQ_STEP(fetch,               FETCH,          static) \
  REQ_STEP(deliver,             DELIVER,        static) \
  REQ_STEP(vclfail,             VCLFAIL,        static) \
  REQ_STEP(synth,               SYNTH,          static) \
  REQ_STEP(transmit,            TRANSMIT,       static) \
  REQ_STEP(finish,              FINISH,         static)

#define REQ_STEP(l, U, priv) \
    static req_state_f cnt_##l; \
    priv const struct req_step R_STP_##U[1] = {{ \
        .name = "Req Step " #l, \
        .func = cnt_##l, \
    }};
REQ_STEPS
#undef REQ_STEP

/*--------------------------------------------------------------------
 * Handle "Expect:" and "Connection:" on incoming request
 */

static enum req_fsm_nxt v_matchproto_(req_state_f)
cnt_transport(struct worker *wrk, struct req *req)
{
        const char *p;

        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
        CHECK_OBJ_NOTNULL(req->http, HTTP_MAGIC);
        CHECK_OBJ_NOTNULL(req->transport, TRANSPORT_MAGIC);
        AN(req->req_body_status);

        if (http_GetHdr(req->http, H_Expect, &p)) {
                if (!http_expect_eq(p, 100-continue)) {
                        req->doclose = SC_RX_JUNK;
                        (void)req->transport->minimal_response(req, 417);
                        wrk->stats->client_req_417++;
                        return (REQ_FSM_DONE);
                }
                if (req->http->protover >= 11 &&
                    req->htc->pipeline_b == NULL)       // XXX: HTTP1 vs 2 ?
                        req->want100cont = 1;
                http_Unset(req->http, H_Expect);
        }

        AZ(req->err_code);

        req->doclose = http_DoConnection(req->http, SC_REQ_CLOSE);
        if (req->doclose == SC_RX_BAD) {
                wrk->stats->client_req_400++;
                (void)req->transport->minimal_response(req, 400);
                return (REQ_FSM_DONE);
        }

        if (req->req_body_status->avail == 1) {
                AN(req->transport->req_body != NULL);
                VFP_Setup(req->vfc, wrk);
                req->vfc->resp = req->http;             // XXX
                req->transport->req_body(req);
        }

        req->ws_req = WS_Snapshot(req->ws);
        HTTP_Clone(req->http0, req->http);      // For ESI & restart
        req->req_step = R_STP_RECV;
        return (REQ_FSM_MORE);
}

/*--------------------------------------------------------------------
 * Deliver an object to client
 */

int
Resp_Setup_Deliver(struct req *req)
{
        struct http *h;
        struct objcore *oc;
        const void *hdrs;

        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
        oc = req->objcore;
        CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);

        h = req->resp;

        HTTP_Setup(h, req->ws, req->vsl, SLT_RespMethod);

        hdrs = ObjGetAttr(req->wrk, oc, OA_HEADERS, NULL);
        if (hdrs == NULL || HTTP_Decode(h, hdrs))
                return (-1);

        http_ForceField(h, HTTP_HDR_PROTO, "HTTP/1.1");

        if (req->is_hit)
                http_PrintfHeader(h, "X-Varnish: %ju %ju", VXID(req->vsl->wid),
                    VXID(ObjGetXID(req->wrk, oc)));
        else
                http_PrintfHeader(h, "X-Varnish: %ju", VXID(req->vsl->wid));

        /*
         * We base Age calculation upon the last timestamp taken during client
         * request processing. This gives some inaccuracy, but since Age is only
         * full second resolution that shouldn't matter. (Last request timestamp
         * could be a Start timestamp taken before the object entered into cache
         * leading to negative age. Truncate to zero in that case).
         */
        http_PrintfHeader(h, "Age: %.0f",
            floor(fmax(0., req->t_prev - oc->t_origin)));

        http_AppendHeader(h, H_Via, http_ViaHeader());

        if (cache_param->http_gzip_support &&
            ObjCheckFlag(req->wrk, oc, OF_GZIPED) &&
            !RFC2616_Req_Gzip(req->http))
                RFC2616_Weaken_Etag(h);
        return (0);
}

void
Resp_Setup_Synth(struct req *req)
{
        struct http *h;

        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);

        h = req->resp;

        HTTP_Setup(h, req->ws, req->vsl, SLT_RespMethod);

        AZ(req->objcore);
        http_PutResponse(h, "HTTP/1.1", req->err_code, req->err_reason);

        http_TimeHeader(h, "Date: ", W_TIM_real(req->wrk));
        http_SetHeader(h, "Server: Varnish");
        http_PrintfHeader(h, "X-Varnish: %ju", VXID(req->vsl->wid));

        /*
         * For late 100-continue, we suggest to VCL to close the connection to
         * neither send a 100-continue nor drain-read the request. But VCL has
         * the option to veto by removing Connection: close
         */
        if (req->want100cont)
                http_SetHeader(h, "Connection: close");
}

static enum req_fsm_nxt v_matchproto_(req_state_f)
cnt_deliver(struct worker *wrk, struct req *req)
{
        unsigned status;

        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
        CHECK_OBJ_NOTNULL(req->objcore, OBJCORE_MAGIC);
        CHECK_OBJ_NOTNULL(req->objcore->objhead, OBJHEAD_MAGIC);
        AZ(req->stale_oc);
        AN(req->vcl);

        assert(req->objcore->refcnt > 0);

        ObjTouch(req->wrk, req->objcore, req->t_prev);

        if (Resp_Setup_Deliver(req)) {
                (void)HSH_DerefObjCore(wrk, &req->objcore, HSH_RUSH_POLICY);
                req->err_code = 500;
                req->req_step = R_STP_SYNTH;
                return (REQ_FSM_MORE);
        }

        status = http_GetStatus(req->resp);
        if (cache_param->http_range_support && status == 200 &&
            !(req->objcore->flags & OC_F_PRIVATE))
                http_ForceHeader(req->resp, H_Accept_Ranges, "bytes");

        req->t_resp = W_TIM_real(wrk);
        VCL_deliver_method(req->vcl, wrk, req, NULL, NULL);

        assert(req->restarts <= cache_param->max_restarts);

        if (wrk->vpi->handling != VCL_RET_DELIVER) {
                HSH_Cancel(wrk, req->objcore, NULL);
                (void)HSH_DerefObjCore(wrk, &req->objcore, HSH_RUSH_POLICY);
                http_Teardown(req->resp);

                switch (wrk->vpi->handling) {
                case VCL_RET_RESTART:
                        req->req_step = R_STP_RESTART;
                        break;
                case VCL_RET_FAIL:
                        req->req_step = R_STP_VCLFAIL;
                        break;
                case VCL_RET_SYNTH:
                        req->req_step = R_STP_SYNTH;
                        break;
                default:
                        WRONG("Illegal return from vcl_deliver{}");
                }

                return (REQ_FSM_MORE);
        }

        VSLb_ts_req(req, "Process", W_TIM_real(wrk));

        assert(wrk->vpi->handling == VCL_RET_DELIVER);

        if (IS_TOPREQ(req) && RFC2616_Do_Cond(req))
                http_PutResponse(req->resp, "HTTP/1.1", 304, NULL);

        req->req_step = R_STP_TRANSMIT;
        return (REQ_FSM_MORE);
}

/*--------------------------------------------------------------------
 * VCL failed, die horribly
 */

static enum req_fsm_nxt v_matchproto_(req_state_f)
cnt_vclfail(struct worker *wrk, struct req *req)
{
        struct vrt_ctx ctx[1];

        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);

        AZ(req->objcore);
        AZ(req->stale_oc);

        INIT_OBJ(ctx, VRT_CTX_MAGIC);
        VCL_Req2Ctx(ctx, req);

        Req_Rollback(ctx);

        if (req->req_reset) {
                req->err_code = 408;
                req->err_reason = "Client disconnected";
        } else {
                req->err_code = 503;
                req->err_reason = "VCL failed";
        }
        req->req_step = R_STP_SYNTH;
        req->doclose = SC_VCL_FAILURE;
        req->vdp_filter_list = NULL;
        return (REQ_FSM_MORE);
}

/*--------------------------------------------------------------------
 * Emit a synthetic response
 */

static enum req_fsm_nxt v_matchproto_(req_state_f)
cnt_synth(struct worker *wrk, struct req *req)
{
        struct vsb *synth_body;
        ssize_t sz, szl;
        uint16_t status;
        uint8_t *ptr;
        const char *body;

        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);

        AZ(req->objcore);
        AZ(req->stale_oc);

        wrk->stats->s_synth++;

        if (req->err_code < 100)
                req->err_code = 501;

        Resp_Setup_Synth(req);

        req->vdp_filter_list = NULL;
        synth_body = VSB_new_auto();
        AN(synth_body);

        req->t_resp = W_TIM_real(wrk);
        VCL_synth_method(req->vcl, wrk, req, NULL, synth_body);

        AZ(VSB_finish(synth_body));

        VSLb_ts_req(req, "Process", W_TIM_real(wrk));

        while (wrk->vpi->handling == VCL_RET_FAIL) {
                if (req->esi_level > 0) {
                        wrk->vpi->handling = VCL_RET_DELIVER;
                        break;
                }
                VSB_destroy(&synth_body);
                (void)VRB_Ignore(req);
                status = req->req_reset ? 408 : 500;
                (void)req->transport->minimal_response(req, status);
                req->doclose = SC_VCL_FAILURE; // XXX: Not necessary any more ?
                VSLb_ts_req(req, "Resp", W_TIM_real(wrk));
                http_Teardown(req->resp);
                return (REQ_FSM_DONE);
        }

        if (wrk->vpi->handling == VCL_RET_RESTART &&
            req->restarts > cache_param->max_restarts)
                wrk->vpi->handling = VCL_RET_DELIVER;

        if (wrk->vpi->handling == VCL_RET_RESTART) {
                /*
                 * XXX: Should we reset req->doclose = SC_VCL_FAILURE
                 * XXX: If so, to what ?
                 */
                HTTP_Setup(req->resp, req->ws, req->vsl, SLT_RespMethod);
                VSB_destroy(&synth_body);
                req->req_step = R_STP_RESTART;
                return (REQ_FSM_MORE);
        }
        assert(wrk->vpi->handling == VCL_RET_DELIVER);

        http_Unset(req->resp, H_Content_Length);
        http_PrintfHeader(req->resp, "Content-Length: %zd",
            VSB_len(synth_body));

        if (req->doclose == SC_NULL &&
            http_HdrIs(req->resp, H_Connection, "close"))
                req->doclose = SC_RESP_CLOSE;

        /* Discard any lingering request body before delivery */
        (void)VRB_Ignore(req);

        req->objcore = HSH_Private(wrk);
        CHECK_OBJ_NOTNULL(req->objcore, OBJCORE_MAGIC);
        szl = -1;
        if (STV_NewObject(wrk, req->objcore, stv_transient, 0)) {
                body = VSB_data(synth_body);
                szl = VSB_len(synth_body);
                assert(szl >= 0);
                while (szl > 0) {
                        sz = szl;
                        if (! ObjGetSpace(wrk, req->objcore, &sz, &ptr)) {
                                szl = -1;
                                break;
                        }
                        if (sz > szl)
                                sz = szl;
                        szl -= sz;
                        memcpy(ptr, body, sz);
                        ObjExtend(wrk, req->objcore, sz, szl == 0 ? 1 : 0);
                        body += sz;
                }
        }

        if (szl >= 0)
                AZ(ObjSetU64(wrk, req->objcore, OA_LEN, VSB_len(synth_body)));
        HSH_DerefBoc(wrk, req->objcore);
        VSB_destroy(&synth_body);

        if (szl < 0) {
                VSLb(req->vsl, SLT_Error, "Could not get storage");
                req->doclose = SC_OVERLOAD;
                VSLb_ts_req(req, "Resp", W_TIM_real(wrk));
                (void)HSH_DerefObjCore(wrk, &req->objcore, 1);
                http_Teardown(req->resp);
                return (REQ_FSM_DONE);
        }

        req->req_step = R_STP_TRANSMIT;
        return (REQ_FSM_MORE);
}

/*--------------------------------------------------------------------
 * The mechanics of sending a response (from deliver or synth)
 */

static enum req_fsm_nxt v_matchproto_(req_state_f)
cnt_transmit(struct worker *wrk, struct req *req)
{
        enum req_fsm_nxt nxt = REQ_FSM_MORE;
        enum vtr_deliver_e dnxt;
        uint16_t status;
        int sendbody, head;
        intmax_t clval;

        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
        CHECK_OBJ_NOTNULL(req->transport, TRANSPORT_MAGIC);
        CHECK_OBJ_NOTNULL(req->objcore, OBJCORE_MAGIC);
        AZ(req->stale_oc);
        AZ(req->res_mode);
        AZ(req->boc);
        req->req_step = R_STP_FINISH;

        /* Grab a ref to the bo if there is one (=streaming) */
        req->boc = HSH_RefBoc(req->objcore);
        if (req->boc && req->boc->state < BOS_STREAM)
                ObjWaitState(req->objcore, BOS_STREAM);
        clval = http_GetContentLength(req->resp);
        /* RFC 7230, 3.3.3 */
        status = http_GetStatus(req->resp);
        head = http_method_eq(req->http0->hd[HTTP_HDR_METHOD].b, HEAD);

        if (req->boc != NULL || (req->objcore->flags & (OC_F_FAILED)))
                req->resp_len = clval;
        else
                req->resp_len = ObjGetLen(req->wrk, req->objcore);

        if (head || status < 200 || status == 204 || status == 304) {
                // rfc7230,l,1748,1752
                sendbody = 0;
        } else {
                sendbody = 1;
        }

        VDP_Init(req->vdc, req->wrk, req->vsl, req, NULL, &req->resp_len);
        if (req->vdp_filter_list == NULL)
                req->vdp_filter_list = resp_Get_Filter_List(req);
        if (req->vdp_filter_list == NULL ||
            VCL_StackVDP(req->vdc, req->vcl, req->vdp_filter_list, req, NULL)) {
                VSLb(req->vsl, SLT_Error, "Failure to push processors");
                req->doclose = SC_OVERLOAD;
                req->acct.resp_bodybytes +=
                        VDP_Close(req->vdc, req->objcore, req->boc);
        } else {
                if (status < 200 || status == 204) {
                        // rfc7230,l,1691,1695
                        http_Unset(req->resp, H_Content_Length);
                } else if (status == 304) {
                        // rfc7230,l,1675,1677
                        http_Unset(req->resp, H_Content_Length);
                } else if (clval >= 0 && clval == req->resp_len) {
                        /* Reuse C-L header */
                } else if (head && req->objcore->flags & OC_F_HFM) {
                        /*
                         * Don't touch C-L header (debatable)
                         *
                         * The only way to do it correctly would be to GET
                         * to the backend, and discard the body once the
                         * filters have had a chance to chew on it, but that
                         * would negate the "pass for huge objects" use case.
                         */
                } else {
                        http_Unset(req->resp, H_Content_Length);
                        if (req->resp_len >= 0)
                                http_PrintfHeader(req->resp,
                                    "Content-Length: %jd", req->resp_len);
                }
                if (req->resp_len == 0)
                        sendbody = 0;
                dnxt = req->transport->deliver(req, sendbody);
                if (dnxt == VTR_D_DISEMBARK)
                        nxt = REQ_FSM_DISEMBARK;
                else
                        assert(dnxt == VTR_D_DONE);
        }
        return (nxt);
}

static enum req_fsm_nxt v_matchproto_(req_state_f)
cnt_finish(struct worker *wrk, struct req *req)
{

        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);

        VSLb_ts_req(req, "Resp", W_TIM_real(wrk));

        if (req->doclose == SC_NULL && (req->objcore->flags & OC_F_FAILED)) {
                /* The object we delivered failed due to a streaming error.
                 * Fail the request. */
                req->doclose = SC_TX_ERROR;
        }

        if (req->boc != NULL) {
                HSH_DerefBoc(wrk, req->objcore);
                req->boc = NULL;
        }

        (void)HSH_DerefObjCore(wrk, &req->objcore, HSH_RUSH_POLICY);
        http_Teardown(req->resp);

        req->vdp_filter_list = NULL;
        req->res_mode = 0;
        return (REQ_FSM_DONE);
}

/*--------------------------------------------------------------------
 * Initiated a fetch (pass/miss) which we intend to deliver
 */

static enum req_fsm_nxt v_matchproto_(req_state_f)
cnt_fetch(struct worker *wrk, struct req *req)
{

        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
        CHECK_OBJ_NOTNULL(req->objcore, OBJCORE_MAGIC);
        AZ(req->stale_oc);

        wrk->stats->s_fetch++;
        (void)VRB_Ignore(req);

        if (req->objcore->flags & OC_F_FAILED) {
                req->err_code = 503;
                req->req_step = R_STP_SYNTH;
                (void)HSH_DerefObjCore(wrk, &req->objcore, 1);
                AZ(req->objcore);
                return (REQ_FSM_MORE);
        }

        req->req_step = R_STP_DELIVER;
        return (REQ_FSM_MORE);
}

/*--------------------------------------------------------------------
 * Attempt to lookup objhdr from hash.  We disembark and reenter
 * this state if we get suspended on a busy objhdr.
 */

static enum req_fsm_nxt v_matchproto_(req_state_f)
cnt_lookup(struct worker *wrk, struct req *req)
{
        struct objcore *oc, *busy;
        enum lookup_e lr;
        int had_objhead = 0;

        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
        AZ(req->objcore);
        AZ(req->stale_oc);

        AN(req->vcl);

        VRY_Prep(req);

        AZ(req->objcore);
        if (req->hash_objhead)
                had_objhead = 1;
        wrk->strangelove = 0;
        lr = HSH_Lookup(req, &oc, &busy);
        if (lr == HSH_BUSY) {
                /*
                 * We lost the session to a busy object, disembark the
                 * worker thread.   We return to STP_LOOKUP when the busy
                 * object has been unbusied, and still have the objhead
                 * around to restart the lookup with.
                 */
                return (REQ_FSM_DISEMBARK);
        }
        assert(wrk->strangelove >= 0);
        if ((unsigned)wrk->strangelove >= cache_param->vary_notice)
                VSLb(req->vsl, SLT_Notice, "vsl: High number of variants (%d)",
                    wrk->strangelove);
        if (had_objhead)
                VSLb_ts_req(req, "Waitinglist", W_TIM_real(wrk));

        if (req->vcf != NULL) {
                (void)req->vcf->func(req, NULL, NULL, 2);
                req->vcf = NULL;
        }

        if (busy == NULL) {
                VRY_Finish(req, DISCARD);
        } else {
                AN(busy->flags & OC_F_BUSY);
                VRY_Finish(req, KEEP);
        }

        AZ(req->objcore);
        if (lr == HSH_MISS || lr == HSH_HITMISS) {
                AN(busy);
                AN(busy->flags & OC_F_BUSY);
                req->objcore = busy;
                req->stale_oc = oc;
                req->req_step = R_STP_MISS;
                if (lr == HSH_HITMISS)
                        req->is_hitmiss = 1;
                return (REQ_FSM_MORE);
        }
        if (lr == HSH_HITPASS) {
                AZ(busy);
                AZ(oc);
                req->req_step = R_STP_PASS;
                req->is_hitpass = 1;
                return (REQ_FSM_MORE);
        }

        assert(lr == HSH_HIT || lr == HSH_GRACE);

        CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
        AZ(oc->flags & OC_F_BUSY);
        req->objcore = oc;
        AZ(oc->flags & OC_F_HFM);

        VCL_hit_method(req->vcl, wrk, req, NULL, NULL);

        switch (wrk->vpi->handling) {
        case VCL_RET_DELIVER:
                if (busy != NULL) {
                        AZ(oc->flags & OC_F_HFM);
                        CHECK_OBJ_NOTNULL(busy->boc, BOC_MAGIC);
                        // XXX: shouldn't we go to miss?
                        VBF_Fetch(wrk, req, busy, oc, VBF_BACKGROUND);
                        wrk->stats->s_fetch++;
                        wrk->stats->s_bgfetch++;
                } else {
                        (void)VRB_Ignore(req);// XXX: handle err
                }
                wrk->stats->cache_hit++;
                req->is_hit = 1;
                if (lr == HSH_GRACE)
                        wrk->stats->cache_hit_grace++;
                req->req_step = R_STP_DELIVER;
                return (REQ_FSM_MORE);
        case VCL_RET_RESTART:
                req->req_step = R_STP_RESTART;
                break;
        case VCL_RET_FAIL:
                req->req_step = R_STP_VCLFAIL;
                break;
        case VCL_RET_SYNTH:
                req->req_step = R_STP_SYNTH;
                break;
        case VCL_RET_PASS:
                wrk->stats->cache_hit++;
                req->is_hit = 1;
                req->req_step = R_STP_PASS;
                break;
        default:
                WRONG("Illegal return from vcl_hit{}");
        }

        /* Drop our object, we won't need it */
        (void)HSH_DerefObjCore(wrk, &req->objcore, HSH_RUSH_POLICY);

        if (busy != NULL) {
                (void)HSH_DerefObjCore(wrk, &busy, 0);
                VRY_Clear(req);
        }

        return (REQ_FSM_MORE);
}

/*--------------------------------------------------------------------
 * Cache miss.
 */

static enum req_fsm_nxt v_matchproto_(req_state_f)
cnt_miss(struct worker *wrk, struct req *req)
{

        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
        AN(req->vcl);
        CHECK_OBJ_NOTNULL(req->objcore, OBJCORE_MAGIC);
        CHECK_OBJ_ORNULL(req->stale_oc, OBJCORE_MAGIC);

        VCL_miss_method(req->vcl, wrk, req, NULL, NULL);
        switch (wrk->vpi->handling) {
        case VCL_RET_FETCH:
                wrk->stats->cache_miss++;
                VBF_Fetch(wrk, req, req->objcore, req->stale_oc, VBF_NORMAL);
                if (req->stale_oc != NULL)
                        (void)HSH_DerefObjCore(wrk, &req->stale_oc, 0);
                req->req_step = R_STP_FETCH;
                return (REQ_FSM_MORE);
        case VCL_RET_FAIL:
                req->req_step = R_STP_VCLFAIL;
                break;
        case VCL_RET_SYNTH:
                req->req_step = R_STP_SYNTH;
                break;
        case VCL_RET_RESTART:
                req->req_step = R_STP_RESTART;
                break;
        case VCL_RET_PASS:
                req->req_step = R_STP_PASS;
                break;
        default:
                WRONG("Illegal return from vcl_miss{}");
        }
        VRY_Clear(req);
        if (req->stale_oc != NULL)
                (void)HSH_DerefObjCore(wrk, &req->stale_oc, 0);
        AZ(HSH_DerefObjCore(wrk, &req->objcore, 1));
        return (REQ_FSM_MORE);
}

/*--------------------------------------------------------------------
 * Pass processing
 */

static enum req_fsm_nxt v_matchproto_(req_state_f)
cnt_pass(struct worker *wrk, struct req *req)
{

        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
        AN(req->vcl);
        AZ(req->objcore);
        AZ(req->stale_oc);

        VCL_pass_method(req->vcl, wrk, req, NULL, NULL);
        switch (wrk->vpi->handling) {
        case VCL_RET_FAIL:
                req->req_step = R_STP_VCLFAIL;
                break;
        case VCL_RET_SYNTH:
                req->req_step = R_STP_SYNTH;
                break;
        case VCL_RET_RESTART:
                req->req_step = R_STP_RESTART;
                break;
        case VCL_RET_FETCH:
                wrk->stats->s_pass++;
                req->objcore = HSH_Private(wrk);
                CHECK_OBJ_NOTNULL(req->objcore, OBJCORE_MAGIC);
                VBF_Fetch(wrk, req, req->objcore, NULL, VBF_PASS);
                req->req_step = R_STP_FETCH;
                break;
        default:
                WRONG("Illegal return from cnt_pass{}");
        }
        return (REQ_FSM_MORE);
}

/*--------------------------------------------------------------------
 * Pipe mode
 */

static enum req_fsm_nxt v_matchproto_(req_state_f)
cnt_pipe(struct worker *wrk, struct req *req)
{
        struct busyobj *bo;
        enum req_fsm_nxt nxt;

        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
        AZ(req->objcore);
        AZ(req->stale_oc);
        AN(req->vcl);

        wrk->stats->s_pipe++;
        bo = VBO_GetBusyObj(wrk, req);
        CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
        VSLb(bo->vsl, SLT_Begin, "bereq %ju pipe", VXID(req->vsl->wid));
        VSLb(req->vsl, SLT_Link, "bereq %ju pipe", VXID(bo->vsl->wid));
        VSLb_ts_busyobj(bo, "Start", W_TIM_real(wrk));
        THR_SetBusyobj(bo);
        bo->sp = req->sp;
        SES_Ref(bo->sp);

        HTTP_Setup(bo->bereq, req->ws, bo->vsl, SLT_BereqMethod);
        http_FilterReq(bo->bereq, req->http, 0);        // XXX: 0 ?
        http_PrintfHeader(bo->bereq, "X-Varnish: %ju", VXID(req->vsl->wid));
        http_ForceHeader(bo->bereq, H_Connection, "close");

        if (req->want100cont) {
                http_SetHeader(bo->bereq, "Expect: 100-continue");
                req->want100cont = 0;
        }

        bo->wrk = wrk;
        bo->task_deadline = NAN; /* XXX: copy req->task_deadline */
        if (WS_Overflowed(req->ws))
                wrk->vpi->handling = VCL_RET_FAIL;
        else
                VCL_pipe_method(req->vcl, wrk, req, bo, NULL);

        switch (wrk->vpi->handling) {
        case VCL_RET_SYNTH:
                req->req_step = R_STP_SYNTH;
                nxt = REQ_FSM_MORE;
                break;
        case VCL_RET_PIPE:
                VSLb_ts_req(req, "Process", W_TIM_real(wrk));
                VSLb_ts_busyobj(bo, "Process", wrk->lastused);
                if (V1P_Enter() == 0) {
                        AZ(bo->req);
                        bo->req = req;
                        bo->wrk = wrk;
                        /* Unless cached, reqbody is not our job */
                        if (req->req_body_status != BS_CACHED)
                                req->req_body_status = BS_NONE;
                        SES_Close(req->sp, VDI_Http1Pipe(req, bo));
                        nxt = REQ_FSM_DONE;
                        V1P_Leave();
                        break;
                }
                wrk->stats->pipe_limited++;
                /* fall through */
        case VCL_RET_FAIL:
                req->req_step = R_STP_VCLFAIL;
                nxt = REQ_FSM_MORE;
                break;
        default:
                WRONG("Illegal return from vcl_pipe{}");
        }
        http_Teardown(bo->bereq);
        SES_Rel(bo->sp);
        VBO_ReleaseBusyObj(wrk, &bo);
        THR_SetBusyobj(NULL);
        return (nxt);
}

/*--------------------------------------------------------------------
 * Handle restart events
 */

static enum req_fsm_nxt v_matchproto_(req_state_f)
cnt_restart(struct worker *wrk, struct req *req)
{

        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
        AZ(req->objcore);
        AZ(req->stale_oc);

        if (++req->restarts > cache_param->max_restarts) {
                VSLb(req->vsl, SLT_VCL_Error, "Too many restarts");
                req->err_code = 503;
                req->req_step = R_STP_SYNTH;
        } else {
                // XXX: ReqEnd + ReqAcct ?
                VSLb_ts_req(req, "Restart", W_TIM_real(wrk));
                VSL_ChgId(req->vsl, "req", "restart",
                    VXID_Get(wrk, VSL_CLIENTMARKER));
                VSLb_ts_req(req, "Start", req->t_prev);
                req->err_code = 0;
                req->req_step = R_STP_RECV;
        }
        return (REQ_FSM_MORE);
}

/*
 * prepare the request for vcl_recv, either initially or after a reset
 * e.g. due to vcl switching
 *
 * TODO
 * - make restarts == 0 bit re-usable for rollback
 * - remove duplication with Req_Cleanup()
 */

static void v_matchproto_(req_state_f)
cnt_recv_prep(struct req *req, const char *ci)
{

        if (req->restarts == 0) {
                /*
                 * This really should be done earlier, but we want to capture
                 * it in the VSL log.
                 */
                http_AppendHeader(req->http, H_X_Forwarded_For, ci);
                http_AppendHeader(req->http, H_Via, http_ViaHeader());
                http_CollectHdr(req->http, H_Cache_Control);

                /* By default we use the first backend */
                VRT_Assign_Backend(&req->director_hint,
                    VCL_DefaultDirector(req->vcl));

                req->d_ttl = -1;
                req->d_grace = -1;
                req->disable_esi = 0;
                req->hash_always_miss = 0;
                req->hash_ignore_busy = 0;
                req->hash_ignore_vary = 0;
                req->client_identity = NULL;
                req->storage = NULL;
                req->trace = FEATURE(FEATURE_TRACE);
        }

        req->is_hit = 0;
        req->is_hitmiss = 0;
        req->is_hitpass = 0;
        req->err_code = 0;
        req->err_reason = NULL;

        req->vfp_filter_list = NULL;
}

/*--------------------------------------------------------------------
 * We have a complete request, set everything up and start it.
 * We can come here both with a request from the client and with
 * a interior request during ESI delivery.
 */

static enum req_fsm_nxt v_matchproto_(req_state_f)
cnt_recv(struct worker *wrk, struct req *req)
{
        unsigned recv_handling;
        struct VSHA256Context sha256ctx;
        const char *ci;

        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
        AN(req->vcl);
        AZ(req->objcore);
        AZ(req->stale_oc);
        AZ(req->err_code);

        AZ(isnan(req->t_first));
        AZ(isnan(req->t_prev));
        AZ(isnan(req->t_req));

        ci = Req_LogStart(wrk, req);
        http_VSL_log(req->http);

        if (http_CountHdr(req->http0, H_Host) > 1) {
                VSLb(req->vsl, SLT_BogoHeader, "Multiple Host: headers");
                wrk->stats->client_req_400++;
                (void)req->transport->minimal_response(req, 400);
                return (REQ_FSM_DONE);
        }

        if (http_CountHdr(req->http0, H_Content_Length) > 1) {
                VSLb(req->vsl, SLT_BogoHeader, "Multiple Content-Length: headers");
                wrk->stats->client_req_400++;
                (void)req->transport->minimal_response(req, 400);
                return (REQ_FSM_DONE);
        }

        cnt_recv_prep(req, ci);

        if (req->req_body_status == BS_ERROR) {
                req->doclose = SC_OVERLOAD;
                return (REQ_FSM_DONE);
        }

        VCL_recv_method(req->vcl, wrk, req, NULL, NULL);

        if (wrk->vpi->handling == VCL_RET_FAIL) {
                req->req_step = R_STP_VCLFAIL;
                return (REQ_FSM_MORE);
        }

        if (wrk->vpi->handling == VCL_RET_VCL && req->restarts == 0) {
                // Req_Rollback has happened in VPI_vcl_select
                assert(WS_Snapshot(req->ws) == req->ws_req);
                cnt_recv_prep(req, ci);
                VCL_recv_method(req->vcl, wrk, req, NULL, NULL);
        }

        if (req->want100cont && !req->late100cont) {
                req->want100cont = 0;
                if (req->transport->minimal_response(req, 100)) {
                        req->doclose = SC_REM_CLOSE;
                        return (REQ_FSM_DONE);
                }
        }

        /* Attempts to cache req.body may fail */
        if (req->req_body_status == BS_ERROR) {
                req->doclose = SC_RX_BODY;
                return (REQ_FSM_DONE);
        }

        recv_handling = wrk->vpi->handling;

        /* We wash the A-E header here for the sake of VRY */
        if (cache_param->http_gzip_support &&
             (recv_handling != VCL_RET_PIPE) &&
             (recv_handling != VCL_RET_PASS)) {
                if (RFC2616_Req_Gzip(req->http)) {
                        http_ForceHeader(req->http, H_Accept_Encoding, "gzip");
                } else {
                        http_Unset(req->http, H_Accept_Encoding);
                }
        }

        VSHA256_Init(&sha256ctx);
        VCL_hash_method(req->vcl, wrk, req, NULL, &sha256ctx);
        if (wrk->vpi->handling == VCL_RET_FAIL)
                recv_handling = wrk->vpi->handling;
        else
                assert(wrk->vpi->handling == VCL_RET_LOOKUP);
        VSHA256_Final(req->digest, &sha256ctx);

        switch (recv_handling) {
        case VCL_RET_VCL:
                VSLb(req->vsl, SLT_VCL_Error,
                    "Illegal return(vcl): %s",
                    req->restarts ? "Not after restarts" :
                    "Only from active VCL");
                req->err_code = 503;
                req->req_step = R_STP_SYNTH;
                break;
        case VCL_RET_PURGE:
                req->req_step = R_STP_PURGE;
                break;
        case VCL_RET_HASH:
                req->req_step = R_STP_LOOKUP;
                break;
        case VCL_RET_PIPE:
                if (!IS_TOPREQ(req)) {
                        VSLb(req->vsl, SLT_VCL_Error,
                            "vcl_recv{} returns pipe for ESI included object."
                            "  Doing pass.");
                        req->req_step = R_STP_PASS;
                } else if (req->http0->protover > 11) {
                        VSLb(req->vsl, SLT_VCL_Error,
                            "vcl_recv{} returns pipe for HTTP/2 request."
                            "  Doing pass.");
                        req->req_step = R_STP_PASS;
                } else {
                        req->req_step = R_STP_PIPE;
                }
                break;
        case VCL_RET_PASS:
                req->req_step = R_STP_PASS;
                break;
        case VCL_RET_SYNTH:
                req->req_step = R_STP_SYNTH;
                break;
        case VCL_RET_RESTART:
                req->req_step = R_STP_RESTART;
                break;
        case VCL_RET_FAIL:
                req->req_step = R_STP_VCLFAIL;
                break;
        default:
                WRONG("Illegal return from vcl_recv{}");
        }
        return (REQ_FSM_MORE);
}

/*--------------------------------------------------------------------
 * Find the objhead, purge it.
 *
 * In VCL, a restart is necessary to get a new object
 */

static enum req_fsm_nxt v_matchproto_(req_state_f)
cnt_purge(struct worker *wrk, struct req *req)
{
        struct objcore *oc, *boc;
        enum lookup_e lr;

        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
        AZ(req->objcore);
        AZ(req->stale_oc);

        AN(req->vcl);

        VRY_Prep(req);

        AZ(req->objcore);
        req->hash_always_miss = 1;
        lr = HSH_Lookup(req, &oc, &boc);
        assert (lr == HSH_MISS);
        AZ(oc);
        CHECK_OBJ_NOTNULL(boc, OBJCORE_MAGIC);
        VRY_Finish(req, DISCARD);

        (void)HSH_Purge(wrk, boc->objhead, req->t_req, 0, 0, 0);

        AZ(HSH_DerefObjCore(wrk, &boc, 1));

        VCL_purge_method(req->vcl, wrk, req, NULL, NULL);
        switch (wrk->vpi->handling) {
        case VCL_RET_RESTART:
                req->req_step = R_STP_RESTART;
                break;
        case VCL_RET_FAIL:
                req->req_step = R_STP_VCLFAIL;
                break;
        case VCL_RET_SYNTH:
                req->req_step = R_STP_SYNTH;
                break;
        default:
                WRONG("Illegal return from vcl_purge{}");
        }
        return (REQ_FSM_MORE);
}

/*--------------------------------------------------------------------
 * Central state engine dispatcher.
 *
 * Kick the session around until it has had enough.
 *
 */

static void v_matchproto_(req_state_f)
cnt_diag(struct req *req, const char *state)
{

        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);

        VSLb(req->vsl,  SLT_Debug, "vxid %ju STP_%s sp %p vcl %p",
            VXID(req->vsl->wid), state, req->sp, req->vcl);
        VSL_Flush(req->vsl, 0);
}

void
CNT_Embark(struct worker *wrk, struct req *req)
{

        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);

        /* wrk can have changed for restarts */
        req->vfc->wrk = req->wrk = wrk;
        wrk->vsl = req->vsl;
        if (req->req_step == R_STP_TRANSPORT && req->vcl == NULL) {
                VCL_Refresh(&wrk->wpriv->vcl);
                req->vcl = wrk->wpriv->vcl;
                wrk->wpriv->vcl = NULL;
                VSLbs(req->vsl, SLT_VCL_use, TOSTRAND(VCL_Name(req->vcl)));
        }

        AN(req->vcl);
}

enum req_fsm_nxt
CNT_Request(struct req *req)
{
        struct vrt_ctx ctx[1];
        struct worker *wrk;
        enum req_fsm_nxt nxt;

        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);

        wrk = req->wrk;
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);

        CHECK_OBJ_NOTNULL(req->transport, TRANSPORT_MAGIC);
        AN(req->transport->deliver);
        AN(req->transport->minimal_response);

        /*
         * Possible entrance states
         */
        assert(
            req->req_step == R_STP_LOOKUP ||
            req->req_step == R_STP_FINISH ||
            req->req_step == R_STP_TRANSPORT);

        AN(VXID_TAG(req->vsl->wid) & VSL_CLIENTMARKER);
        AN(req->vcl);

        for (nxt = REQ_FSM_MORE; nxt == REQ_FSM_MORE; ) {
                /*
                 * This is a good place to be paranoid about the various
                 * pointers still pointing to the things we expect.
                 */
                CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
                CHECK_OBJ_NOTNULL(wrk->wpriv, WORKER_PRIV_MAGIC);
                CHECK_OBJ_ORNULL(wrk->wpriv->nobjhead, OBJHEAD_MAGIC);
                CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
                CHECK_OBJ_NOTNULL(req->doclose, STREAM_CLOSE_MAGIC);

                AN(req->req_step);
                AN(req->req_step->name);
                AN(req->req_step->func);
                if (DO_DEBUG(DBG_REQ_STATE))
                        cnt_diag(req, req->req_step->name);
                nxt = req->req_step->func(wrk, req);
                CHECK_OBJ_ORNULL(wrk->wpriv->nobjhead, OBJHEAD_MAGIC);
        }
        wrk->vsl = NULL;
        if (nxt == REQ_FSM_DONE) {
                INIT_OBJ(ctx, VRT_CTX_MAGIC);
                VCL_Req2Ctx(ctx, req);
                if (IS_TOPREQ(req)) {
                        VCL_TaskLeave(ctx, req->top->privs);
                        if (req->top->vcl0 != NULL)
                                VCL_Recache(wrk, &req->top->vcl0);
                }
                VCL_TaskLeave(ctx, req->privs);
                assert(!IS_NO_VXID(req->vsl->wid));
                VRB_Free(req);
                VRT_Assign_Backend(&req->director_hint, NULL);
                req->wrk = NULL;
        }
        assert(nxt == REQ_FSM_DISEMBARK || !WS_IsReserved(req->ws));
        return (nxt);
}

		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	18049	cnt_transport(struct worker wrk, struct req req)
86		{
87		const char *p;
88
89	18049	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
90	18049	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
91	18049	CHECK_OBJ_NOTNULL(req->http, HTTP_MAGIC);
92	18049	CHECK_OBJ_NOTNULL(req->transport, TRANSPORT_MAGIC);
93	18049	AN(req->req_body_status);
94
95	18049	if (http_GetHdr(req->http, H_Expect, &p)) {
96	60	if (!http_expect_eq(p, 100-continue)) {
97	10	req->doclose = SC_RX_JUNK;
98	10	(void)req->transport->minimal_response(req, 417);
99	10	wrk->stats->client_req_417++;
100	10	return (REQ_FSM_DONE);
101		}
102	50	if (req->http->protover >= 11 &&
103	50	req->htc->pipeline_b == NULL) // XXX: HTTP1 vs 2 ?
104	45	req->want100cont = 1;
105	50	http_Unset(req->http, H_Expect);
106	50	}
107
108	18039	AZ(req->err_code);
109
110	18039	req->doclose = http_DoConnection(req->http, SC_REQ_CLOSE);
111	18039	if (req->doclose == SC_RX_BAD) {
112	15	wrk->stats->client_req_400++;
113	15	(void)req->transport->minimal_response(req, 400);
114	15	return (REQ_FSM_DONE);
115		}
116
117	18024	if (req->req_body_status->avail == 1) {
118	600	AN(req->transport->req_body != NULL);
119	600	VFP_Setup(req->vfc, wrk);
120	600	req->vfc->resp = req->http; // XXX
121	600	req->transport->req_body(req);
122	600	}
123
124	18024	req->ws_req = WS_Snapshot(req->ws);
125	18024	HTTP_Clone(req->http0, req->http); // For ESI & restart
126	18024	req->req_step = R_STP_RECV;
127	18024	return (REQ_FSM_MORE);
128	18049	}
129
130		/*--------------------------------------------------------------------
131		* Deliver an object to client
132		*/
133
134		int
135	15832	Resp_Setup_Deliver(struct req *req)
136		{
137		struct http *h;
138		struct objcore *oc;
139		const void *hdrs;
140
141	15832	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
142	15832	oc = req->objcore;
143	15832	CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
144
145	15832	h = req->resp;
146
147	15832	HTTP_Setup(h, req->ws, req->vsl, SLT_RespMethod);
148
149	15832	hdrs = ObjGetAttr(req->wrk, oc, OA_HEADERS, NULL);
150	15832	if (hdrs == NULL \|\| HTTP_Decode(h, hdrs))
151	18	return (-1);
152
153	15820	http_ForceField(h, HTTP_HDR_PROTO, "HTTP/1.1");
154
155	15820	if (req->is_hit)
156	10608	http_PrintfHeader(h, "X-Varnish: %ju %ju", VXID(req->vsl->wid),
157	5304	VXID(ObjGetXID(req->wrk, oc)));
158		else
159	10516	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	31640	http_PrintfHeader(h, "Age: %.0f",
169	15820	floor(fmax(0., req->t_prev - oc->t_origin)));
170
171	15820	http_AppendHeader(h, H_Via, http_ViaHeader());
172
173	16995	if (cache_param->http_gzip_support &&
174	15797	ObjCheckFlag(req->wrk, oc, OF_GZIPED) &&
175	1175	!RFC2616_Req_Gzip(req->http))
176	380	RFC2616_Weaken_Etag(h);
177	15820	return (0);
178	15838	}
179
180		void
181	2755	Resp_Setup_Synth(struct req *req)
182		{
183		struct http *h;
184
185	2755	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
186
187	2755	h = req->resp;
188
189	2755	HTTP_Setup(h, req->ws, req->vsl, SLT_RespMethod);
190
191	2755	AZ(req->objcore);
192	2755	http_PutResponse(h, "HTTP/1.1", req->err_code, req->err_reason);
193
194	2755	http_TimeHeader(h, "Date: ", W_TIM_real(req->wrk));
195	2755	http_SetHeader(h, "Server: Varnish");
196	2755	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	2755	if (req->want100cont)
204	15	http_SetHeader(h, "Connection: close");
205	2755	}
206
207		static enum req_fsm_nxt v_matchproto_(req_state_f)
208	15783	cnt_deliver(struct worker wrk, struct req req)
209		{
210		unsigned status;
211
212	15783	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
213	15783	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
214	15783	CHECK_OBJ_NOTNULL(req->objcore, OBJCORE_MAGIC);
215	15783	CHECK_OBJ_NOTNULL(req->objcore->objhead, OBJHEAD_MAGIC);
216	15783	AZ(req->stale_oc);
217	15783	AN(req->vcl);
218
219	15783	assert(req->objcore->refcnt > 0);
220
221	15783	ObjTouch(req->wrk, req->objcore, req->t_prev);
222
223	15783	if (Resp_Setup_Deliver(req)) {
224	10	(void)HSH_DerefObjCore(wrk, &req->objcore, HSH_RUSH_POLICY);
225	10	req->err_code = 500;
226	10	req->req_step = R_STP_SYNTH;
227	10	return (REQ_FSM_MORE);
228		}
229
230	15773	status = http_GetStatus(req->resp);
231	15773	if (cache_param->http_range_support && status == 200 &&
232	14030	!(req->objcore->flags & OC_F_PRIVATE))
233	11310	http_ForceHeader(req->resp, H_Accept_Ranges, "bytes");
234
235	15773	req->t_resp = W_TIM_real(wrk);
236	15773	VCL_deliver_method(req->vcl, wrk, req, NULL, NULL);
237
238	15773	assert(req->restarts <= cache_param->max_restarts);
239
240	15773	if (wrk->vpi->handling != VCL_RET_DELIVER) {
241	630	HSH_Cancel(wrk, req->objcore, NULL);
242	630	(void)HSH_DerefObjCore(wrk, &req->objcore, HSH_RUSH_POLICY);
243	630	http_Teardown(req->resp);
244
245	630	switch (wrk->vpi->handling) {
246		case VCL_RET_RESTART:
247	135	req->req_step = R_STP_RESTART;
248	135	break;
249		case VCL_RET_FAIL:
250	455	req->req_step = R_STP_VCLFAIL;
251	455	break;
252		case VCL_RET_SYNTH:
253	40	req->req_step = R_STP_SYNTH;
254	40	break;
255		default:
256	0	WRONG("Illegal return from vcl_deliver{}");
257	0	}
258
259	630	return (REQ_FSM_MORE);
260		}
261
262	15143	VSLb_ts_req(req, "Process", W_TIM_real(wrk));
263
264	15143	assert(wrk->vpi->handling == VCL_RET_DELIVER);
265
266	15143	if (IS_TOPREQ(req) && RFC2616_Do_Cond(req))
267	150	http_PutResponse(req->resp, "HTTP/1.1", 304, NULL);
268
269	15143	req->req_step = R_STP_TRANSMIT;
270	15143	return (REQ_FSM_MORE);
271	15783	}
272
273		/*--------------------------------------------------------------------
274		* VCL failed, die horribly
275		*/
276
277		static enum req_fsm_nxt v_matchproto_(req_state_f)
278	785	cnt_vclfail(struct worker wrk, struct req req)
279		{
280		struct vrt_ctx ctx[1];
281
282	785	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
283	785	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
284
285	785	AZ(req->objcore);
286	785	AZ(req->stale_oc);
287
288	785	INIT_OBJ(ctx, VRT_CTX_MAGIC);
289	785	VCL_Req2Ctx(ctx, req);
290
291	785	Req_Rollback(ctx);
292
293	785	if (req->req_reset) {
294	110	req->err_code = 408;
295	110	req->err_reason = "Client disconnected";
296	110	} else {
297	675	req->err_code = 503;
298	675	req->err_reason = "VCL failed";
299		}
300	785	req->req_step = R_STP_SYNTH;
301	785	req->doclose = SC_VCL_FAILURE;
302	785	req->vdp_filter_list = NULL;
303	785	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	2745	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	2745	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
320	2745	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
321
322	2745	AZ(req->objcore);
323	2745	AZ(req->stale_oc);
324
325	2745	wrk->stats->s_synth++;
326
327	2745	if (req->err_code < 100)
328	0	req->err_code = 501;
329
330	2745	Resp_Setup_Synth(req);
331
332	2745	req->vdp_filter_list = NULL;
333	2745	synth_body = VSB_new_auto();
334	2745	AN(synth_body);
335
336	2745	req->t_resp = W_TIM_real(wrk);
337	2745	VCL_synth_method(req->vcl, wrk, req, NULL, synth_body);
338
339	2745	AZ(VSB_finish(synth_body));
340
341	2745	VSLb_ts_req(req, "Process", W_TIM_real(wrk));
342
343	2745	while (wrk->vpi->handling == VCL_RET_FAIL) {
344	130	if (req->esi_level > 0) {
345	5	wrk->vpi->handling = VCL_RET_DELIVER;
346	5	break;
347		}
348	125	VSB_destroy(&synth_body);
349	125	(void)VRB_Ignore(req);
350	125	status = req->req_reset ? 408 : 500;
351	125	(void)req->transport->minimal_response(req, status);
352	125	req->doclose = SC_VCL_FAILURE; // XXX: Not necessary any more ?
353	125	VSLb_ts_req(req, "Resp", W_TIM_real(wrk));
354	125	http_Teardown(req->resp);
355	125	return (REQ_FSM_DONE);
356		}
357
358	2620	if (wrk->vpi->handling == VCL_RET_RESTART &&
359	60	req->restarts > cache_param->max_restarts)
360	5	wrk->vpi->handling = VCL_RET_DELIVER;
361
362	2620	if (wrk->vpi->handling == VCL_RET_RESTART) {
363		/*
364		* XXX: Should we reset req->doclose = SC_VCL_FAILURE
365		* XXX: If so, to what ?
366		*/
367	55	HTTP_Setup(req->resp, req->ws, req->vsl, SLT_RespMethod);
368	55	VSB_destroy(&synth_body);
369	55	req->req_step = R_STP_RESTART;
370	55	return (REQ_FSM_MORE);
371		}
372	2565	assert(wrk->vpi->handling == VCL_RET_DELIVER);
373
374	2565	http_Unset(req->resp, H_Content_Length);
375	5130	http_PrintfHeader(req->resp, "Content-Length: %zd",
376	2565	VSB_len(synth_body));
377
378	2565	if (req->doclose == SC_NULL &&
379	1870	http_HdrIs(req->resp, H_Connection, "close"))
380	15	req->doclose = SC_RESP_CLOSE;
381
382		/* Discard any lingering request body before delivery */
383	2565	(void)VRB_Ignore(req);
384
385	2565	req->objcore = HSH_Private(wrk);
386	2565	CHECK_OBJ_NOTNULL(req->objcore, OBJCORE_MAGIC);
387	2565	szl = -1;
388	2565	if (STV_NewObject(wrk, req->objcore, stv_transient, 0)) {
389	2555	body = VSB_data(synth_body);
390	2555	szl = VSB_len(synth_body);
391	2555	assert(szl >= 0);
392	4955	while (szl > 0) {
393	2400	sz = szl;
394	2400	if (! ObjGetSpace(wrk, req->objcore, &sz, &ptr)) {
395	0	szl = -1;
396	0	break;
397		}
398	2400	if (sz > szl)
399	0	sz = szl;
400	2400	szl -= sz;
401	2400	memcpy(ptr, body, sz);
402	2400	ObjExtend(wrk, req->objcore, sz, szl == 0 ? 1 : 0);
403	2400	body += sz;
404		}
405	2555	}
406
407	2565	if (szl >= 0)
408	2555	AZ(ObjSetU64(wrk, req->objcore, OA_LEN, VSB_len(synth_body)));
409	2565	HSH_DerefBoc(wrk, req->objcore);
410	2565	VSB_destroy(&synth_body);
411
412	2565	if (szl < 0) {
413	10	VSLb(req->vsl, SLT_Error, "Could not get storage");
414	10	req->doclose = SC_OVERLOAD;
415	10	VSLb_ts_req(req, "Resp", W_TIM_real(wrk));
416	10	(void)HSH_DerefObjCore(wrk, &req->objcore, 1);
417	10	http_Teardown(req->resp);
418	10	return (REQ_FSM_DONE);
419		}
420
421	2555	req->req_step = R_STP_TRANSMIT;
422	2555	return (REQ_FSM_MORE);
423	2745	}
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	17696	cnt_transmit(struct worker wrk, struct req req)
431		{
432	17696	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	17696	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
439	17696	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
440	17696	CHECK_OBJ_NOTNULL(req->transport, TRANSPORT_MAGIC);
441	17696	CHECK_OBJ_NOTNULL(req->objcore, OBJCORE_MAGIC);
442	17696	AZ(req->stale_oc);
443	17696	AZ(req->res_mode);
444	17696	AZ(req->boc);
445	17696	req->req_step = R_STP_FINISH;
446
447		/* Grab a ref to the bo if there is one (=streaming) */
448	17696	req->boc = HSH_RefBoc(req->objcore);
449	17696	if (req->boc && req->boc->state < BOS_STREAM)
450	0	ObjWaitState(req->objcore, BOS_STREAM);
451	17696	clval = http_GetContentLength(req->resp);
452		/* RFC 7230, 3.3.3 */
453	17696	status = http_GetStatus(req->resp);
454	17696	head = http_method_eq(req->http0->hd[HTTP_HDR_METHOD].b, HEAD);
455
456	17696	if (req->boc != NULL \|\| (req->objcore->flags & (OC_F_FAILED)))
457	4220	req->resp_len = clval;
458		else
459	13476	req->resp_len = ObjGetLen(req->wrk, req->objcore);
460
461	17696	if (head \|\| status < 200 \|\| status == 204 \|\| status == 304) {
462		// rfc7230,l,1748,1752
463	807	sendbody = 0;
464	807	} else {
465	16889	sendbody = 1;
466		}
467
468	17696	VDP_Init(req->vdc, req->wrk, req->vsl, req, NULL, &req->resp_len);
469	17696	if (req->vdp_filter_list == NULL)
470	16365	req->vdp_filter_list = resp_Get_Filter_List(req);
471	17696	if (req->vdp_filter_list == NULL \|\|
472	17698	VCL_StackVDP(req->vdc, req->vcl, req->vdp_filter_list, req, NULL)) {
473	318	VSLb(req->vsl, SLT_Error, "Failure to push processors");
474	318	req->doclose = SC_OVERLOAD;
475	318	req->acct.resp_bodybytes +=
476	318	VDP_Close(req->vdc, req->objcore, req->boc);
477	318	} else {
478	17384	if (status < 200 \|\| status == 204) {
479		// rfc7230,l,1691,1695
480	98	http_Unset(req->resp, H_Content_Length);
481	17384	} else if (status == 304) {
482		// rfc7230,l,1675,1677
483	170	http_Unset(req->resp, H_Content_Length);
484	17286	} else if (clval >= 0 && clval == req->resp_len) {
485		/* Reuse C-L header */
486	17116	} else if (head && req->objcore->flags & OC_F_HFM) {
487		/*
488		* Don't touch C-L header (debatable)
489		*
490		* The only way to do it correctly would be to GET
491		* to the backend, and discard the body once the
492		* filters have had a chance to chew on it, but that
493		* would negate the "pass for huge objects" use case.
494		*/
495	5	} else {
496	4353	http_Unset(req->resp, H_Content_Length);
497	4353	if (req->resp_len >= 0)
498	5100	http_PrintfHeader(req->resp,
499	2550	"Content-Length: %jd", req->resp_len);