GCOV - Varnish Cache


/*-
 * Copyright (c) 2006 Verdens Gang AS
 * Copyright (c) 2006-2015 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.
 */

#include "config.h"

#include "cache_varnishd.h"
#include "cache_filter.h"
#include "cache_objhead.h"
#include "storage/storage.h"
#include "vcl.h"
#include "vtim.h"
#include "vcc_interface.h"

#define FETCH_STEPS \
        FETCH_STEP(mkbereq,           MKBEREQ) \
        FETCH_STEP(retry,             RETRY) \
        FETCH_STEP(startfetch,        STARTFETCH) \
        FETCH_STEP(condfetch,         CONDFETCH) \
        FETCH_STEP(fetch,             FETCH) \
        FETCH_STEP(fetchbody,         FETCHBODY) \
        FETCH_STEP(fetchend,          FETCHEND) \
        FETCH_STEP(error,             ERROR) \
        FETCH_STEP(fail,              FAIL) \
        FETCH_STEP(done,              DONE)

typedef const struct fetch_step *vbf_state_f(struct worker *, struct busyobj *);

struct fetch_step {
        const char      *name;
        vbf_state_f     *func;
};

#define FETCH_STEP(l, U) \
    static vbf_state_f vbf_stp_##l; \
    static const struct fetch_step F_STP_##U[1] = {{ .name = "Fetch Step " #l, .func = vbf_stp_##l, }};
FETCH_STEPS
#undef FETCH_STEP

static hdr_t const H_X_Varnish = HDR("X-Varnish");

/*--------------------------------------------------------------------
 * Allocate an object, with fall-back to Transient.
 * XXX: This somewhat overlaps the stuff in stevedore.c
 * XXX: Should this be merged over there ?
 */

static int
vbf_allocobj(struct busyobj *bo, unsigned l)
{
        struct objcore *oc;
        const struct stevedore *stv;
        vtim_dur lifetime;

        CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
        oc = bo->fetch_objcore;
        CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);

        lifetime = oc->ttl + oc->grace + oc->keep;

        if (bo->uncacheable) {
                stv = stv_transient;
                bo->wrk->stats->beresp_uncacheable++;
        }
        else if (lifetime < cache_param->shortlived) {
                stv = stv_transient;
                bo->wrk->stats->beresp_shortlived++;
        }
        else
                stv = bo->storage;

        bo->storage = NULL;

        if (stv == NULL)
                return (0);

        if (STV_NewObject(bo->wrk, oc, stv, l))
                return (1);

        if (stv == stv_transient)
                return (0);

        /*
         * Try to salvage the transaction by allocating a shortlived object
         * on Transient storage.
         */

        oc->ttl = vmin_t(float, oc->ttl, cache_param->shortlived);
        oc->grace = 0.0;
        oc->keep = 0.0;
        return (STV_NewObject(bo->wrk, oc, stv_transient, l));
}

static void
vbf_cleanup(struct busyobj *bo)
{
        struct vfp_ctx *vfc;

        CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
        vfc = bo->vfc;
        CHECK_OBJ_NOTNULL(vfc, VFP_CTX_MAGIC);

        bo->acct.beresp_bodybytes += VFP_Close(vfc);
        bo->vfp_filter_list = NULL;

        if (bo->director_state != DIR_S_NULL)
                VDI_Finish(bo);
}

void
Bereq_Rollback(VRT_CTX)
{
        struct busyobj *bo;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        bo = ctx->bo;
        CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);

        if (bo->htc != NULL) {
                assert(bo->htc->body_status != BS_TAKEN);
                if (bo->htc->body_status != BS_NONE)
                        bo->htc->doclose = SC_RESP_CLOSE;
        }

        vbf_cleanup(bo);
        VCL_TaskLeave(ctx, bo->privs);
        VCL_TaskEnter(bo->privs);
        HTTP_Clone(bo->bereq, bo->bereq0);
        bo->vfp_filter_list = NULL;
        bo->err_reason = NULL;
        AN(bo->ws_bo);
        WS_Rollback(bo->ws, bo->ws_bo);
}

/*--------------------------------------------------------------------
 * Turn the beresp into a obj
 */

static int
vbf_beresp2obj(struct busyobj *bo)
{
        unsigned l, l2;
        const char *b;
        uint8_t *bp;
        struct vsb *vary = NULL;
        int varyl = 0;
        struct objcore *oc;

        CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
        oc = bo->fetch_objcore;
        CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);

        l = 0;

        /* Create Vary instructions */
        if (!(oc->flags & OC_F_PRIVATE)) {
                varyl = VRY_Create(bo, &vary);
                if (varyl > 0) {
                        AN(vary);
                        assert(varyl == VSB_len(vary));
                        l += PRNDUP((intptr_t)varyl);
                } else if (varyl < 0) {
                        /*
                         * Vary parse error
                         * Complain about it, and make this a pass.
                         */
                        VSLb(bo->vsl, SLT_Error,
                            "Illegal 'Vary' header from backend, "
                            "making this a pass.");
                        bo->uncacheable = 1;
                        AZ(vary);
                } else
                        /* No vary */
                        AZ(vary);
        }

        l2 = http_EstimateWS(bo->beresp,
            bo->uncacheable ? HTTPH_A_PASS : HTTPH_A_INS);
        l += l2;

        if (bo->uncacheable)
                oc->flags |= OC_F_HFM;

        if (!vbf_allocobj(bo, l)) {
                if (vary != NULL)
                        VSB_destroy(&vary);
                AZ(vary);
                return (VFP_Error(bo->vfc, "Could not get storage"));
        }

        if (vary != NULL) {
                AN(ObjSetAttr(bo->wrk, oc, OA_VARY, varyl, VSB_data(vary)));
                VSB_destroy(&vary);
        }

        AZ(ObjSetXID(bo->wrk, oc, bo->vsl->wid));

        /* for HTTP_Encode() VSLH call */
        bo->beresp->logtag = SLT_ObjMethod;

        /* Filter into object */
        bp = ObjSetAttr(bo->wrk, oc, OA_HEADERS, l2, NULL);
        AN(bp);
        HTTP_Encode(bo->beresp, bp, l2,
            bo->uncacheable ? HTTPH_A_PASS : HTTPH_A_INS);

        if (http_GetHdr(bo->beresp, H_Last_Modified, &b))
                AZ(ObjSetDouble(bo->wrk, oc, OA_LASTMODIFIED, VTIM_parse(b)));
        else
                AZ(ObjSetDouble(bo->wrk, oc, OA_LASTMODIFIED,
                    floor(oc->t_origin)));

        return (0);
}

/*--------------------------------------------------------------------
 * Copy req->bereq and release req if no body
 */

static const struct fetch_step * v_matchproto_(vbf_state_f)
vbf_stp_mkbereq(struct worker *wrk, struct busyobj *bo)
{
        const char *q;
        struct objcore *oc;

        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
        CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
        CHECK_OBJ_NOTNULL(bo->req, REQ_MAGIC);
        oc = bo->fetch_objcore;
        CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);

        assert(oc->boc->state == BOS_INVALID);
        AZ(bo->storage);

        HTTP_Setup(bo->bereq0, bo->ws, bo->vsl, SLT_BereqMethod);
        http_FilterReq(bo->bereq0, bo->req->http,
            bo->uncacheable ? HTTPH_R_PASS : HTTPH_R_FETCH);

        if (bo->uncacheable)
                AZ(bo->stale_oc);
        else {
                http_ForceField(bo->bereq0, HTTP_HDR_METHOD, "GET");
                if (cache_param->http_gzip_support)
                        http_ForceHeader(bo->bereq0, H_Accept_Encoding, "gzip");
        }
        http_ForceField(bo->bereq0, HTTP_HDR_PROTO, "HTTP/1.1");

        if (bo->stale_oc != NULL && !(bo->stale_oc->flags & OC_F_DYING) &&
            ObjCheckFlag(bo->wrk, bo->stale_oc, OF_IMSCAND) &&
            (bo->stale_oc->boc != NULL || ObjGetLen(wrk, bo->stale_oc) != 0)) {
                AZ(bo->stale_oc->flags & (OC_F_HFM|OC_F_PRIVATE));
                q = RFC2616_Strong_LM(NULL, wrk, bo->stale_oc);
                if (q != NULL)
                        http_PrintfHeader(bo->bereq0,
                            "If-Modified-Since: %s", q);
                q = HTTP_GetHdrPack(bo->wrk, bo->stale_oc, H_ETag);
                if (q != NULL)
                        http_PrintfHeader(bo->bereq0,
                            "If-None-Match: %s", q);
        }

        http_CopyHome(bo->bereq0);
        HTTP_Setup(bo->bereq, bo->ws, bo->vsl, SLT_BereqMethod);
        bo->ws_bo = WS_Snapshot(bo->ws);
        HTTP_Clone(bo->bereq, bo->bereq0);

        if (bo->req->req_body_status->avail == 0) {
                VBO_SetState(bo->wrk, bo, BOS_REQ_DONE);
        } else if (bo->req->req_body_status == BS_CACHED) {
                AN(bo->req->body_oc);
                bo->bereq_body = bo->req->body_oc;
                HSH_Ref(bo->bereq_body);
                VBO_SetState(bo->wrk, bo, BOS_REQ_DONE);
        }
        return (F_STP_STARTFETCH);
}

/*--------------------------------------------------------------------
 * Start a new VSL transaction and try again
 * Prepare the busyobj and fetch processors
 */

static const struct fetch_step * v_matchproto_(vbf_state_f)
vbf_stp_retry(struct worker *wrk, struct busyobj *bo)
{
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
        CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);

        assert(bo->fetch_objcore->boc->state <= BOS_REQ_DONE);

        if (bo->no_retry != NULL) {
                VSLb(bo->vsl, SLT_Error,
                    "Retry not possible, %s", bo->no_retry);
                return (F_STP_FAIL);
        }

        VSLb_ts_busyobj(bo, "Retry", W_TIM_real(wrk));

        /* VDI_Finish (via vbf_cleanup) must have been called before */
        assert(bo->director_state == DIR_S_NULL);

        /* reset other bo attributes - See VBO_GetBusyObj */
        bo->storage = NULL;
        bo->do_esi = 0;
        bo->do_stream = 1;
        bo->was_304 = 0;
        bo->err_code = 0;
        bo->err_reason = NULL;
        bo->connect_timeout = NAN;
        bo->first_byte_timeout = NAN;
        bo->between_bytes_timeout = NAN;
        if (bo->htc != NULL)
                bo->htc->doclose = SC_NULL;

        // XXX: BereqEnd + BereqAcct ?
        VSL_ChgId(bo->vsl, "bereq", "retry", VXID_Get(wrk, VSL_BACKENDMARKER));
        VSLb_ts_busyobj(bo, "Start", bo->t_prev);
        http_VSL_log(bo->bereq);

        return (F_STP_STARTFETCH);
}

/*--------------------------------------------------------------------
 * 304 setup logic
 */

static void
vbf_304_logic(struct busyobj *bo)
{

        AZ(bo->stale_oc->flags & (OC_F_HFM|OC_F_PRIVATE));
        if (ObjCheckFlag(bo->wrk, bo->stale_oc, OF_CHGCE)) {
                /*
                 * If a VFP changed C-E in the stored
                 * object, then don't overwrite C-E from
                 * the IMS fetch, and we must weaken any
                 * new ETag we get.
                 */
                RFC2616_Weaken_Etag(bo->beresp);
        }
        http_Unset(bo->beresp, H_Content_Encoding);
        http_Unset(bo->beresp, H_Content_Length);
        HTTP_Merge(bo->wrk, bo->stale_oc, bo->beresp);
}

/*--------------------------------------------------------------------
 * Setup bereq from bereq0, run vcl_backend_fetch
 */

static const struct fetch_step * v_matchproto_(vbf_state_f)
vbf_stp_startfetch(struct worker *wrk, struct busyobj *bo)
{
        int i;
        const char *q;
        vtim_real now;
        unsigned handling, skip_vbr = 0;
        struct objcore *oc;

        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
        CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
        oc = bo->fetch_objcore;
        CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);

        // this complements the stale_oc handling in vbf_stp_mkbereq():
        // Conditions might have changed since we made the bereq (retry)
        if (! bo->uncacheable && bo->stale_oc != NULL &&
            bo->stale_oc->flags & OC_F_DYING) {
                http_Unset(bo->bereq, H_If_Modified_Since);
                http_Unset(bo->bereq, H_If_None_Match);
        }

        AZ(bo->storage);
        bo->storage = bo->uncacheable ? stv_transient : STV_next();

        if (bo->retries > 0)
                http_Unset(bo->bereq, H_X_Varnish);

        http_PrintfHeader(bo->bereq, "X-Varnish: %ju", VXID(bo->vsl->wid));

        if (bo->bereq_body == NULL && bo->req == NULL)
                http_Unset(bo->bereq, H_Content_Length);

        VCL_backend_fetch_method(bo->vcl, wrk, NULL, bo, NULL);

        if (wrk->vpi->handling == VCL_RET_ABANDON ||
            wrk->vpi->handling == VCL_RET_FAIL)
                return (F_STP_FAIL);

        assert (wrk->vpi->handling == VCL_RET_FETCH ||
            wrk->vpi->handling == VCL_RET_ERROR);

        HTTP_Setup(bo->beresp, bo->ws, bo->vsl, SLT_BerespMethod);

        assert(oc->boc->state <= BOS_REQ_DONE);

        AZ(bo->htc);

        VFP_Setup(bo->vfc, wrk);
        bo->vfc->oc = oc;
        bo->vfc->resp = bo->beresp;
        bo->vfc->req = bo->bereq;

        if (wrk->vpi->handling == VCL_RET_ERROR)
                return (F_STP_ERROR);

        VSLb_ts_busyobj(bo, "Fetch", W_TIM_real(wrk));
        i = VDI_GetHdr(bo);
        if (bo->htc != NULL)
                CHECK_OBJ_NOTNULL(bo->htc->doclose, STREAM_CLOSE_MAGIC);

        bo->t_resp = now = W_TIM_real(wrk);
        VSLb_ts_busyobj(bo, "Beresp", now);

        if (i) {
                assert(bo->director_state == DIR_S_NULL);
                return (F_STP_ERROR);
        }

        if (bo->htc != NULL && bo->htc->body_status == BS_ERROR) {
                bo->htc->doclose = SC_RX_BODY;
                vbf_cleanup(bo);
                VSLb(bo->vsl, SLT_Error, "Body cannot be fetched");
                assert(bo->director_state == DIR_S_NULL);
                return (F_STP_ERROR);
        }

        if (!http_GetHdr(bo->beresp, H_Date, NULL)) {
                /*
                 * RFC 2616 14.18 Date: The Date general-header field
                 * represents the date and time at which the message was
                 * originated, having the same semantics as orig-date in
                 * RFC 822. ... A received message that does not have a
                 * Date header field MUST be assigned one by the recipient
                 * if the message will be cached by that recipient or
                 * gatewayed via a protocol which requires a Date.
                 *
                 * If we didn't get a Date header, we assign one here.
                 */
                http_TimeHeader(bo->beresp, "Date: ", now);
        }

        /*
         * These two headers can be spread over multiple actual headers
         * and we rely on their content outside of VCL, so collect them
         * into one line here.
         */
        http_CollectHdr(bo->beresp, H_Cache_Control);
        http_CollectHdr(bo->beresp, H_Vary);

        /* What does RFC2616 think about TTL ? */
        RFC2616_Ttl(bo, now,
            &oc->t_origin,
            &oc->ttl,
            &oc->grace,
            &oc->keep);

        AZ(bo->do_esi);
        AZ(bo->was_304);

        if (http_IsStatus(bo->beresp, 304) && !bo->uncacheable) {
                if (bo->stale_oc == NULL){
                        VSLb(bo->vsl, SLT_Error,
                            "304 response but not conditional fetch");
                        bo->htc->doclose = SC_RX_BAD;
                        vbf_cleanup(bo);
                        return (F_STP_ERROR);
                }
                bo->was_304 = 1;
                VCL_backend_refresh_method(bo->vcl, wrk, NULL, bo, NULL);
                switch (wrk->vpi->handling) {
                case VCL_RET_MERGE:
                        vbf_304_logic(bo);
                        break;
                case VCL_RET_BERESP:
                        http_SetStatus(bo->beresp, 200, NULL);
                        http_Unset(bo->beresp, H_Content_Length);
                        http_Unset(bo->beresp, H_Content_Encoding);
                        q = HTTP_GetHdrPack(wrk, bo->stale_oc,
                            H_Content_Length);
                        if (q != NULL) {
                                http_ForceHeader(bo->beresp,
                                    H_Content_Length, q);
                        }
                        q = HTTP_GetHdrPack(wrk, bo->stale_oc,
                            H_Content_Encoding);
                        if (q != NULL) {
                                http_ForceHeader(bo->beresp,
                                    H_Content_Encoding, q);
                        }
                        q = HTTP_GetHdrPack(wrk, bo->stale_oc,
                            H_Last_Modified);
                        if (q != NULL) {
                                http_ForceHeader(bo->beresp,
                                    H_Last_Modified, q);
                        }
                        q = HTTP_GetHdrPack(wrk, bo->stale_oc, H_ETag);
                        if (q != NULL)
                                http_ForceHeader(bo->beresp, H_ETag, q);
                        break;
                case VCL_RET_OBJ_STALE:
                        if (HTTP_Decode(bo->beresp, ObjGetAttr(bo->wrk,
                                bo->stale_oc, OA_HEADERS, NULL))) {
                                bo->htc->doclose = SC_RX_OVERFLOW;
                                vbf_cleanup(bo);
                                return (F_STP_ERROR);
                        }
                        break;
                case VCL_RET_RETRY:
                case VCL_RET_ERROR:
                case VCL_RET_ABANDON:
                case VCL_RET_FAIL:
                        skip_vbr = 1;
                        break;
                default:
                        WRONG("Illegal return from vcl_backend_refresh{}");
                }
        }

        if (bo->htc != NULL && bo->htc->doclose == SC_NULL &&
            http_GetHdrField(bo->bereq, H_Connection, "close", NULL))
                bo->htc->doclose = SC_REQ_CLOSE;
        if (!skip_vbr)
                VCL_backend_response_method(bo->vcl, wrk, NULL, bo, NULL);

        if (bo->htc != NULL && bo->htc->doclose == SC_NULL &&
            http_GetHdrField(bo->beresp, H_Connection, "close", NULL))
                bo->htc->doclose = SC_RESP_CLOSE;

        if (VRG_CheckBo(bo) < 0) {
                if (bo->director_state != DIR_S_NULL)
                        VDI_Finish(bo);
                return (F_STP_ERROR);
        }

        if (wrk->vpi->handling == VCL_RET_ABANDON ||
            wrk->vpi->handling == VCL_RET_FAIL ||
            wrk->vpi->handling == VCL_RET_ERROR) {
                /* do not count deliberately ending the backend connection as
                 * fetch failure
                 */
                handling = wrk->vpi->handling;
                if (bo->htc)
                        bo->htc->doclose = SC_RESP_CLOSE;
                vbf_cleanup(bo);
                wrk->vpi->handling = handling;

                if (wrk->vpi->handling == VCL_RET_ERROR)
                        return (F_STP_ERROR);
                else
                        return (F_STP_FAIL);
        }

        if (wrk->vpi->handling == VCL_RET_RETRY) {
                if (bo->htc && bo->htc->body_status != BS_NONE)
                        bo->htc->doclose = SC_RESP_CLOSE;
                vbf_cleanup(bo);

                if (bo->retries++ < bo->max_retries)
                        return (F_STP_RETRY);

                VSLb(bo->vsl, SLT_VCL_Error,
                    "Too many retries, delivering 503");
                assert(bo->director_state == DIR_S_NULL);
                return (F_STP_ERROR);
        }

        VSLb_ts_busyobj(bo, "Process", W_TIM_real(wrk));
        assert(oc->boc->state <= BOS_REQ_DONE);
        if (oc->boc->state != BOS_REQ_DONE)
                VBO_SetState(wrk, bo, BOS_REQ_DONE);

        if (bo->do_esi)
                bo->do_stream = 0;
        if (wrk->vpi->handling == VCL_RET_PASS) {
                oc->flags |= OC_F_HFP;
                bo->uncacheable = 1;
                wrk->vpi->handling = VCL_RET_DELIVER;
        }
        if (!bo->uncacheable || !bo->do_stream)
                oc->boc->transit_buffer = 0;
        if (bo->uncacheable)
                oc->flags |= OC_F_HFM;

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

        return (bo->was_304 ? F_STP_CONDFETCH : F_STP_FETCH);
}

/*--------------------------------------------------------------------
 */

static const struct fetch_step * v_matchproto_(vbf_state_f)
vbf_stp_fetchbody(struct worker *wrk, struct busyobj *bo)
{
        ssize_t l;
        uint8_t *ptr;
        enum vfp_status vfps = VFP_ERROR;
        ssize_t est;
        struct vfp_ctx *vfc;
        struct objcore *oc;

        CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
        vfc = bo->vfc;
        CHECK_OBJ_NOTNULL(vfc, VFP_CTX_MAGIC);
        oc = bo->fetch_objcore;
        CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);

        AN(vfc->vfp_nxt);

        est = bo->htc->content_length;
        if (est < 0)
                est = 0;

        do {
                if (oc->flags & OC_F_CANCEL) {
                        /*
                         * A pass object and delivery was terminated
                         * We don't fail the fetch, in order for HitMiss
                         * objects to be created.
                         */
                        AN(oc->flags & OC_F_HFM);
                        VSLb(wrk->vsl, SLT_Debug,
                            "Fetch: Pass delivery abandoned");
                        bo->htc->doclose = SC_RX_BODY;
                        break;
                }
                AZ(vfc->failed);
                l = est;
                assert(l >= 0);
                if (VFP_GetStorage(vfc, &l, &ptr) != VFP_OK) {
                        bo->htc->doclose = SC_RX_BODY;
                        break;
                }

                AZ(vfc->failed);
                vfps = VFP_Suck(vfc, ptr, &l);
                if (l >= 0 && vfps != VFP_ERROR) {
                        VFP_Extend(vfc, l, vfps);
                        if (est >= l)
                                est -= l;
                        else
                                est = 0;
                }
        } while (vfps == VFP_OK);

        if (vfc->failed) {
                (void)VFP_Error(vfc, "Fetch pipeline failed to process");
                bo->htc->doclose = SC_RX_BODY;
                vbf_cleanup(bo);
                if (!bo->do_stream) {
                        assert(oc->boc->state < BOS_STREAM);
                        // XXX: doclose = ?
                        return (F_STP_ERROR);
                } else {
                        wrk->stats->fetch_failed++;
                        return (F_STP_FAIL);
                }
        }

        return (F_STP_FETCHEND);
}

static const struct fetch_step * v_matchproto_(vbf_state_f)
vbf_stp_fetch(struct worker *wrk, struct busyobj *bo)
{
        struct vrt_ctx ctx[1];
        struct objcore *oc;

        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
        CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
        oc = bo->fetch_objcore;
        CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);

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

        if (bo->htc == NULL) {
                (void)VFP_Error(bo->vfc, "No backend connection (rollback?)");
                vbf_cleanup(bo);
                return (F_STP_ERROR);
        }

        /* No body -> done */
        if (bo->htc->body_status == BS_NONE || bo->htc->content_length == 0) {
                http_Unset(bo->beresp, H_Content_Encoding);
                bo->do_gzip = bo->do_gunzip = 0;
                bo->do_stream = 0;
                bo->vfp_filter_list = "";
        } else if (bo->vfp_filter_list == NULL) {
                bo->vfp_filter_list = VBF_Get_Filter_List(bo);
        }

        if (bo->vfp_filter_list == NULL ||
            VCL_StackVFP(bo->vfc, bo->vcl, bo->vfp_filter_list)) {
                (bo)->htc->doclose = SC_OVERLOAD;
                vbf_cleanup(bo);
                return (F_STP_ERROR);
        }

        if (oc->flags & OC_F_PRIVATE)
                AN(bo->uncacheable);

        oc->boc->fetched_so_far = 0;

        INIT_OBJ(ctx, VRT_CTX_MAGIC);
        VCL_Bo2Ctx(ctx, bo);

        if (VFP_Open(ctx, bo->vfc)) {
                (void)VFP_Error(bo->vfc, "Fetch pipeline failed to open");
                bo->htc->doclose = SC_RX_BODY;
                vbf_cleanup(bo);
                return (F_STP_ERROR);
        }

        if (vbf_beresp2obj(bo)) {
                bo->htc->doclose = SC_RX_BODY;
                vbf_cleanup(bo);
                return (F_STP_ERROR);
        }

#define OBJ_FLAG(U, l, v)                                               \
        if (bo->vfc->obj_flags & OF_##U)                                \
                ObjSetFlag(bo->wrk, oc, OF_##U, 1);
#include "tbl/obj_attr.h"

        if (!(oc->flags & OC_F_HFM) &&
            http_IsStatus(bo->beresp, 200) && (
              RFC2616_Strong_LM(bo->beresp, NULL, NULL) != NULL ||
              http_GetHdr(bo->beresp, H_ETag, NULL)))
                ObjSetFlag(bo->wrk, oc, OF_IMSCAND, 1);

        assert(oc->boc->refcount >= 1);

        assert(oc->boc->state == BOS_REQ_DONE);

        if (bo->do_stream)
                VBO_SetState(wrk, bo, BOS_STREAM);

        VSLb(bo->vsl, SLT_Fetch_Body, "%u %s %s",
            bo->htc->body_status->nbr, bo->htc->body_status->name,
            bo->do_stream ? "stream" : "-");

        if (bo->htc->body_status != BS_NONE) {
                assert(bo->htc->body_status != BS_ERROR);
                return (F_STP_FETCHBODY);
        }
        AZ(bo->vfc->failed);
        return (F_STP_FETCHEND);
}

static const struct fetch_step * v_matchproto_(vbf_state_f)
vbf_stp_fetchend(struct worker *wrk, struct busyobj *bo)
{

        struct objcore *oc;

        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
        CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
        oc = bo->fetch_objcore;
        CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);

        AZ(bo->vfc->failed);

        /* Recycle the backend connection before setting BOS_FINISHED to
           give predictable backend reuse behavior for varnishtest */
        vbf_cleanup(bo);

        AZ(ObjSetU64(wrk, oc, OA_LEN, oc->boc->fetched_so_far));

        if (bo->do_stream)
                assert(oc->boc->state == BOS_STREAM);
        else
                assert(oc->boc->state == BOS_REQ_DONE);

        VBO_SetState(wrk, bo, BOS_FINISHED);
        VSLb_ts_busyobj(bo, "BerespBody", W_TIM_real(wrk));
        if (bo->stale_oc != NULL) {
                VSL(SLT_ExpKill, NO_VXID, "VBF_Superseded x=%ju n=%ju",
                    VXID(ObjGetXID(wrk, bo->stale_oc)),
                    VXID(ObjGetXID(wrk, bo->fetch_objcore)));
                HSH_Replace(bo->stale_oc, bo->fetch_objcore);
        }
        return (F_STP_DONE);
}

/*--------------------------------------------------------------------
 */

struct vbf_objiter_priv {
        unsigned                magic;
#define VBF_OBITER_PRIV_MAGIC   0x3c272a17
        struct busyobj          *bo;
        // not yet allocated
        ssize_t         l;
        // current allocation
        uint8_t         *p;
        ssize_t         pl;
};

static int v_matchproto_(objiterate_f)
vbf_objiterate(void *priv, unsigned flush, const void *ptr, ssize_t len)
{
        struct vbf_objiter_priv *vop;
        ssize_t l;
        const uint8_t *ps = ptr;

        CAST_OBJ_NOTNULL(vop, priv, VBF_OBITER_PRIV_MAGIC);
        CHECK_OBJ_NOTNULL(vop->bo, BUSYOBJ_MAGIC);

        flush &= OBJ_ITER_END;

        while (len > 0) {
                if (vop->pl == 0) {
                        vop->p = NULL;
                        AN(vop->l);
                        vop->pl = vop->l;
                        if (VFP_GetStorage(vop->bo->vfc, &vop->pl, &vop->p)
                            != VFP_OK)
                                return (1);
                        if (vop->pl < vop->l)
                                vop->l -= vop->pl;
                        else
                                vop->l = 0;
                }
                AN(vop->pl);
                AN(vop->p);

                l = vmin(vop->pl, len);
                memcpy(vop->p, ps, l);
                VFP_Extend(vop->bo->vfc, l,
                           flush && l == len ? VFP_END : VFP_OK);
                ps += l;
                vop->p += l;
                len -= l;
                vop->pl -= l;
        }
        if (flush && vop->bo->vfc->failed == 0)
                AZ(vop->l);
        return (0);
}

static const struct fetch_step * v_matchproto_(vbf_state_f)
vbf_stp_condfetch(struct worker *wrk, struct busyobj *bo)
{
        struct boc *stale_boc;
        enum boc_state_e stale_state;
        struct objcore *oc, *stale_oc;
        struct vbf_objiter_priv vop[1];

        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
        CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
        oc = bo->fetch_objcore;
        CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
        stale_oc = bo->stale_oc;
        CHECK_OBJ_NOTNULL(stale_oc, OBJCORE_MAGIC);

        stale_boc = HSH_RefBoc(stale_oc);
        CHECK_OBJ_ORNULL(stale_boc, BOC_MAGIC);
        if (stale_boc) {
                /* Wait for the stale object to become fully fetched, so
                 * that we can catch fetch errors, before we unbusy the
                 * new object. This serves two purposes. First it helps
                 * with request coalescing, and stops long chains of
                 * IMS-updated short-TTL objects all streaming from a
                 * single slow body fetch. Second it makes sure that all
                 * the object attributes are complete when we copy them
                 * (this would be an issue for ie OA_GZIPBITS). */
                VSLb(bo->vsl, SLT_Notice,
                    "vsl: Conditional fetch wait for streaming object");
                /* XXX: We should have a VCL controlled timeout here */
                ObjWaitState(stale_oc, BOS_FINISHED);
                stale_state = stale_boc->state;
                HSH_DerefBoc(bo->wrk, stale_oc);
                stale_boc = NULL;
                if (stale_state != BOS_FINISHED) {
                        assert(stale_state == BOS_FAILED);
                        AN(stale_oc->flags & OC_F_FAILED);
                }
        }

        AZ(stale_boc);
        if (stale_oc->flags & OC_F_FAILED) {
                (void)VFP_Error(bo->vfc, "Template object failed");
                vbf_cleanup(bo);
                wrk->stats->fetch_failed++;
                return (F_STP_FAIL);
        }

        if (vbf_beresp2obj(bo)) {
                vbf_cleanup(bo);
                wrk->stats->fetch_failed++;
                return (F_STP_FAIL);
        }

        if (ObjHasAttr(bo->wrk, stale_oc, OA_ESIDATA))
                AZ(ObjCopyAttr(bo->wrk, oc, stale_oc, OA_ESIDATA));

        AZ(ObjCopyAttr(bo->wrk, oc, stale_oc, OA_FLAGS));
        if (oc->flags & OC_F_HFM)
                ObjSetFlag(bo->wrk, oc, OF_IMSCAND, 0);
        AZ(ObjCopyAttr(bo->wrk, oc, stale_oc, OA_GZIPBITS));

        if (bo->do_stream)
                VBO_SetState(wrk, bo, BOS_STREAM);

        INIT_OBJ(vop, VBF_OBITER_PRIV_MAGIC);
        vop->bo = bo;
        vop->l = ObjGetLen(bo->wrk, stale_oc);
        if (ObjIterate(wrk, stale_oc, vop, vbf_objiterate, 0))
                (void)VFP_Error(bo->vfc, "Template object failed");

        if (bo->vfc->failed) {
                vbf_cleanup(bo);
                wrk->stats->fetch_failed++;
                return (F_STP_FAIL);
        }
        return (F_STP_FETCHEND);
}

/*--------------------------------------------------------------------
 * Create synth object
 *
 * replaces a stale object unless
 * - abandoning the bereq or
 * - leaving vcl_backend_error with return (deliver)
 *
 * We do want the stale replacement to avoid an object pileup with short ttl and
 * long grace/keep, yet there could exist cases where a cache object is
 * deliberately created to momentarily override a stale object.
 *
 * If this case exists, we should add a vcl veto (e.g. beresp.replace_stale with
 * default true)
 */

static const struct fetch_step * v_matchproto_(vbf_state_f)
vbf_stp_error(struct worker *wrk, struct busyobj *bo)
{
        ssize_t l, ll, o;
        vtim_real now;
        uint8_t *ptr;
        struct vsb *synth_body;
        struct objcore *stale, *oc;

        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
        CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
        oc = bo->fetch_objcore;
        CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
        CHECK_OBJ_NOTNULL(oc->boc, BOC_MAGIC);
        assert(oc->boc->state < BOS_STREAM);
        assert(bo->director_state == DIR_S_NULL);

        if (wrk->vpi->handling != VCL_RET_ERROR)
                wrk->stats->fetch_failed++;

        now = W_TIM_real(wrk);
        VSLb_ts_busyobj(bo, "Error", now);

        if (oc->stobj->stevedore != NULL) {
                // replacing an already fetched object with a "synth" one
                assert(oc->boc->state < BOS_STREAM);
                oc->boc->fetched_so_far = 0;
                ObjFreeObj(bo->wrk, oc);
        }

        if (bo->storage == NULL)
                bo->storage = STV_next();

        // XXX: reset all beresp flags ?

        HTTP_Setup(bo->beresp, bo->ws, bo->vsl, SLT_BerespMethod);
        if (bo->err_code > 0)
                http_PutResponse(bo->beresp, "HTTP/1.1", bo->err_code,
                    bo->err_reason);
        else
                http_PutResponse(bo->beresp, "HTTP/1.1", 503,
                    "Backend fetch failed");

        http_TimeHeader(bo->beresp, "Date: ", now);
        http_SetHeader(bo->beresp, "Server: Varnish");

        stale = bo->stale_oc;
        oc->t_origin = now;
        oc->ttl = 0;
        oc->grace = 0;
        oc->keep = 0;

        synth_body = VSB_new_auto();
        AN(synth_body);

        VCL_backend_error_method(bo->vcl, wrk, NULL, bo, synth_body);

        AZ(VSB_finish(synth_body));

        if (wrk->vpi->handling == VCL_RET_ABANDON || wrk->vpi->handling == VCL_RET_FAIL) {
                VSB_destroy(&synth_body);
                return (F_STP_FAIL);
        }

        if (wrk->vpi->handling == VCL_RET_RETRY) {
                VSB_destroy(&synth_body);
                if (bo->retries++ < bo->max_retries)
                        return (F_STP_RETRY);
                VSLb(bo->vsl, SLT_VCL_Error, "Too many retries, failing");
                return (F_STP_FAIL);
        }

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

        assert(bo->vfc->wrk == bo->wrk);
        assert(bo->vfc->oc == oc);
        assert(bo->vfc->resp == bo->beresp);
        assert(bo->vfc->req == bo->bereq);

        if (vbf_beresp2obj(bo)) {
                VSB_destroy(&synth_body);
                return (F_STP_FAIL);
        }

        oc->boc->transit_buffer = 0;

        ll = VSB_len(synth_body);
        o = 0;
        while (ll > 0) {
                l = ll;
                if (VFP_GetStorage(bo->vfc, &l, &ptr) != VFP_OK) {
                        VSB_destroy(&synth_body);
                        return (F_STP_FAIL);
                }
                l = vmin(l, ll);
                memcpy(ptr, VSB_data(synth_body) + o, l);
                VFP_Extend(bo->vfc, l, l == ll ? VFP_END : VFP_OK);
                ll -= l;
                o += l;
        }
        assert(o == VSB_len(synth_body));
        AZ(ObjSetU64(wrk, oc, OA_LEN, o));
        VSB_destroy(&synth_body);
        if (stale != NULL && oc->ttl > 0)
                HSH_Kill(stale);
        VBO_SetState(wrk, bo, BOS_FINISHED);
        return (F_STP_DONE);
}

/*--------------------------------------------------------------------
 */

static const struct fetch_step * v_matchproto_(vbf_state_f)
vbf_stp_fail(struct worker *wrk, struct busyobj *bo)
{
        struct objcore *oc;

        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
        CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
        oc = bo->fetch_objcore;
        CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);

        assert(oc->boc->state < BOS_FINISHED);
        VBO_SetState(wrk, bo, BOS_FAILED);
        HSH_Kill(oc);
        return (F_STP_DONE);
}

/*--------------------------------------------------------------------
 */

static const struct fetch_step * v_matchproto_(vbf_state_f)
vbf_stp_done(struct worker *wrk, struct busyobj *bo)
{

        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
        CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
        WRONG("Just plain wrong");
        NEEDLESS(return (F_STP_DONE));
}

static void v_matchproto_(task_func_t)
vbf_fetch_thread(struct worker *wrk, void *priv)
{
        struct vrt_ctx ctx[1];
        struct busyobj *bo;
        struct objcore *oc;
        const struct fetch_step *stp;

        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
        CAST_OBJ_NOTNULL(bo, priv, BUSYOBJ_MAGIC);
        CHECK_OBJ_NOTNULL(bo->req, REQ_MAGIC);
        oc = bo->fetch_objcore;
        CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);

        THR_SetBusyobj(bo);
        stp = F_STP_MKBEREQ;
        assert(isnan(bo->t_first));
        assert(isnan(bo->t_prev));
        VSLb_ts_busyobj(bo, "Start", W_TIM_real(wrk));

        bo->wrk = wrk;
        wrk->vsl = bo->vsl;

#if 0
        if (bo->stale_oc != NULL) {
                CHECK_OBJ_NOTNULL(bo->stale_oc, OBJCORE_MAGIC);
                /* We don't want the oc/stevedore ops in fetching thread */
                if (!ObjCheckFlag(wrk, bo->stale_oc, OF_IMSCAND))
                        (void)HSH_DerefObjCore(wrk, &bo->stale_oc, 0);
        }
#endif

        VCL_TaskEnter(bo->privs);
        while (stp != F_STP_DONE) {
                CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
                assert(oc->boc->refcount >= 1);
                if (oc->boc->state < BOS_REQ_DONE)
                        AN(bo->req);
                else
                        AZ(bo->req);
                AN(stp);
                AN(stp->name);
                AN(stp->func);
                stp = stp->func(wrk, bo);
        }

        assert(bo->director_state == DIR_S_NULL);

        INIT_OBJ(ctx, VRT_CTX_MAGIC);
        VCL_Bo2Ctx(ctx, bo);
        VCL_TaskLeave(ctx, bo->privs);
        http_Teardown(bo->bereq);
        http_Teardown(bo->beresp);
        // cannot make assumptions about the number of references here #3434
        if (bo->bereq_body != NULL)
                (void)HSH_DerefObjCore(bo->wrk, &bo->bereq_body);

        if (oc->boc->state == BOS_FINISHED) {
                AZ(oc->flags & OC_F_FAILED);
                VSLb(bo->vsl, SLT_Length, "%ju",
                    (uintmax_t)ObjGetLen(bo->wrk, oc));
        }
        // AZ(oc->boc); // XXX

        if (bo->stale_oc != NULL)
                (void)HSH_DerefObjCore(wrk, &bo->stale_oc);

        wrk->vsl = NULL;
        HSH_DerefBoc(wrk, oc);
        SES_Rel(bo->sp);
        VBO_ReleaseBusyObj(wrk, &bo);
        THR_SetBusyobj(NULL);
}

/*--------------------------------------------------------------------
 */

void
VBF_Fetch(struct worker *wrk, struct req *req, struct objcore *oc,
    struct objcore *oldoc, enum vbf_fetch_mode_e mode)
{
        struct boc *boc;
        struct busyobj *bo;
        enum task_prio prio;
        const char *how;

        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
        CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
        CHECK_OBJ_ORNULL(oldoc, OBJCORE_MAGIC);

        bo = VBO_GetBusyObj(wrk, req);
        CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
        AN(bo->vcl);

        boc = HSH_RefBoc(oc);
        CHECK_OBJ_NOTNULL(boc, BOC_MAGIC);
        assert(boc->state < BOS_STREAM);
        boc->transit_buffer = cache_param->transit_buffer;

        switch (mode) {
        case VBF_PASS:
                prio = TASK_QUEUE_BO;
                how = "pass";
                bo->uncacheable = 1;
                break;
        case VBF_NORMAL:
                prio = TASK_QUEUE_BO;
                how = "fetch";
                break;
        case VBF_BACKGROUND:
                prio = TASK_QUEUE_BG;
                how = "bgfetch";
                bo->is_bgfetch = 1;
                break;
        default:
                WRONG("Wrong fetch mode");
        }

#define REQ_BEREQ_FLAG(l, r, w, d) bo->l = req->l;
#include "tbl/req_bereq_flags.h"

        VSLb(bo->vsl, SLT_Begin, "bereq %ju %s", VXID(req->vsl->wid), how);
        VSLbs(bo->vsl, SLT_VCL_use, TOSTRAND(VCL_Name(bo->vcl)));
        VSLb(req->vsl, SLT_Link, "bereq %ju %s", VXID(bo->vsl->wid), how);

        THR_SetBusyobj(bo);

        bo->sp = req->sp;
        SES_Ref(bo->sp);

        oc->boc->vary = req->vary_b;
        req->vary_b = NULL;

        HSH_Ref(oc);
        AZ(bo->fetch_objcore);
        bo->fetch_objcore = oc;

        AZ(bo->stale_oc);
        if (oldoc != NULL) {
                assert(oldoc->refcnt > 0);
                HSH_Ref(oldoc);
                bo->stale_oc = oldoc;
        }

        AZ(bo->req);
        bo->req = req;

        bo->fetch_task->priv = bo;
        bo->fetch_task->func = vbf_fetch_thread;

        if (Pool_Task(wrk->pool, bo->fetch_task, prio)) {
                wrk->stats->bgfetch_no_thread++;
                VSLb(bo->vsl, SLT_FetchError,
                    "No thread available for bgfetch");
                (void)vbf_stp_fail(req->wrk, bo);
                if (bo->stale_oc != NULL)
                        (void)HSH_DerefObjCore(wrk, &bo->stale_oc);
                HSH_DerefBoc(wrk, oc);
                SES_Rel(bo->sp);
                THR_SetBusyobj(NULL);
                VBO_ReleaseBusyObj(wrk, &bo);
        } else {
                THR_SetBusyobj(NULL);
                bo = NULL; /* ref transferred to fetch thread */
                if (mode == VBF_BACKGROUND) {
                        ObjWaitState(oc, BOS_REQ_DONE);
                        (void)VRB_Ignore(req);
                } else {
                        ObjWaitState(oc, BOS_STREAM);
                        AZ(oc->flags & OC_F_BUSY);
                        if (oc->boc->state == BOS_FAILED)
                                AN(oc->flags & OC_F_FAILED);
                }
        }
        AZ(bo);
        VSLb_ts_req(req, "Fetch", W_TIM_real(wrk));
        assert(oc->boc == boc);
        HSH_DerefBoc(wrk, oc);
        if (mode == VBF_BACKGROUND)
                (void)HSH_DerefObjCore(wrk, &oc);
}

		varnish-cache/bin/varnishd/cache/cache_fetch.c
0		/*-
1		* Copyright (c) 2006 Verdens Gang AS
2		* Copyright (c) 2006-2015 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
31		#include "config.h"
32
33		#include "cache_varnishd.h"
34		#include "cache_filter.h"
35		#include "cache_objhead.h"
36		#include "storage/storage.h"
37		#include "vcl.h"
38		#include "vtim.h"
39		#include "vcc_interface.h"
40
41		#define FETCH_STEPS \
42		FETCH_STEP(mkbereq, MKBEREQ) \
43		FETCH_STEP(retry, RETRY) \
44		FETCH_STEP(startfetch, STARTFETCH) \
45		FETCH_STEP(condfetch, CONDFETCH) \
46		FETCH_STEP(fetch, FETCH) \
47		FETCH_STEP(fetchbody, FETCHBODY) \
48		FETCH_STEP(fetchend, FETCHEND) \
49		FETCH_STEP(error, ERROR) \
50		FETCH_STEP(fail, FAIL) \
51		FETCH_STEP(done, DONE)
52
53		typedef const struct fetch_step vbf_state_f(struct worker , struct busyobj *);
54
55		struct fetch_step {
56		const char *name;
57		vbf_state_f *func;
58	74352	};
59	74352
60	74352	#define FETCH_STEP(l, U) \
61	74352	static vbf_state_f vbf_stp_##l; \
62		static const struct fetch_step F_STP_##U[1] = {{ .name = "Fetch Step " #l, .func = vbf_stp_##l, }};
63		FETCH_STEPS
64		#undef FETCH_STEP
65
66		static hdr_t const H_X_Varnish = HDR("X-Varnish");
67
68		/*--------------------------------------------------------------------
69		* Allocate an object, with fall-back to Transient.
70		* XXX: This somewhat overlaps the stuff in stevedore.c
71		* XXX: Should this be merged over there ?
72		*/
73
74		static int
75	90278	vbf_allocobj(struct busyobj *bo, unsigned l)
76		{
77		struct objcore *oc;
78		const struct stevedore *stv;
79		vtim_dur lifetime;
80
81	90278	CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
82	90278	oc = bo->fetch_objcore;
83	90278	CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
84
85	90278	lifetime = oc->ttl + oc->grace + oc->keep;
86
87	90278	if (bo->uncacheable) {
88	35518	stv = stv_transient;
89	35518	bo->wrk->stats->beresp_uncacheable++;
90	35518	}
91	54760	else if (lifetime < cache_param->shortlived) {
92	5080	stv = stv_transient;
93	5080	bo->wrk->stats->beresp_shortlived++;
94	5080	}
95		else
96	49680	stv = bo->storage;
97
98	90278	bo->storage = NULL;
99
100	90278	if (stv == NULL)
101	40	return (0);
102
103	90238	if (STV_NewObject(bo->wrk, oc, stv, l))
104	89958	return (1);
105
106	280	if (stv == stv_transient)
107	160	return (0);
108
109		/*
110		* Try to salvage the transaction by allocating a shortlived object
111		* on Transient storage.
112		*/
113
114	120	oc->ttl = vmin_t(float, oc->ttl, cache_param->shortlived);
115	120	oc->grace = 0.0;
116	120	oc->keep = 0.0;
117	120	return (STV_NewObject(bo->wrk, oc, stv_transient, l));
118	90278	}
119
120		static void
121	81309	vbf_cleanup(struct busyobj *bo)
122		{
123		struct vfp_ctx *vfc;
124
125	81309	CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
126	81309	vfc = bo->vfc;
127	81309	CHECK_OBJ_NOTNULL(vfc, VFP_CTX_MAGIC);
128
129	81309	bo->acct.beresp_bodybytes += VFP_Close(vfc);
130	81309	bo->vfp_filter_list = NULL;
131
132	81309	if (bo->director_state != DIR_S_NULL)
133	80989	VDI_Finish(bo);
134	81309	}
135
136		void
137	360	Bereq_Rollback(VRT_CTX)
138		{
139		struct busyobj *bo;
140
141	360	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
142	360	bo = ctx->bo;
143	360	CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
144
145	360	if (bo->htc != NULL) {
146	320	assert(bo->htc->body_status != BS_TAKEN);
147	320	if (bo->htc->body_status != BS_NONE)
148	40	bo->htc->doclose = SC_RESP_CLOSE;
149	320	}
150
151	360	vbf_cleanup(bo);
152	360	VCL_TaskLeave(ctx, bo->privs);
153	360	VCL_TaskEnter(bo->privs);
154	360	HTTP_Clone(bo->bereq, bo->bereq0);
155	360	bo->vfp_filter_list = NULL;
156	360	bo->err_reason = NULL;
157	360	AN(bo->ws_bo);
158	360	WS_Rollback(bo->ws, bo->ws_bo);
159	360	}
160
161		/*--------------------------------------------------------------------
162		* Turn the beresp into a obj
163		*/
164
165		static int
166	90276	vbf_beresp2obj(struct busyobj *bo)
167		{
168		unsigned l, l2;
169		const char *b;
170		uint8_t *bp;
171	90276	struct vsb *vary = NULL;
172	90276	int varyl = 0;
173		struct objcore *oc;
174
175	90276	CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
176	90276	oc = bo->fetch_objcore;
177	90276	CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
178
179	90276	l = 0;
180
181		/* Create Vary instructions */
182	90276	if (!(oc->flags & OC_F_PRIVATE)) {
183	58839	varyl = VRY_Create(bo, &vary);
184	58839	if (varyl > 0) {
185	8600	AN(vary);
186	8600	assert(varyl == VSB_len(vary));
187	8600	l += PRNDUP((intptr_t)varyl);
188	58839	} else if (varyl < 0) {
189		/*
190		* Vary parse error
191		* Complain about it, and make this a pass.
192		*/
193	200	VSLb(bo->vsl, SLT_Error,
194		"Illegal 'Vary' header from backend, "
195		"making this a pass.");
196	200	bo->uncacheable = 1;
197	200	AZ(vary);
198	200	} else
199		/* No vary */
200	50039	AZ(vary);
201	58839	}
202
203	180552	l2 = http_EstimateWS(bo->beresp,
204	90276	bo->uncacheable ? HTTPH_A_PASS : HTTPH_A_INS);
205	90276	l += l2;
206
207	90276	if (bo->uncacheable)
208	35517	oc->flags \|= OC_F_HFM;
209
210	90276	if (!vbf_allocobj(bo, l)) {
211	240	if (vary != NULL)
212	0	VSB_destroy(&vary);
213	240	AZ(vary);
214	240	return (VFP_Error(bo->vfc, "Could not get storage"));
215		}
216
217	90036	if (vary != NULL) {
218	8600	AN(ObjSetAttr(bo->wrk, oc, OA_VARY, varyl, VSB_data(vary)));
219	8600	VSB_destroy(&vary);
220	8600	}
221
222	90036	AZ(ObjSetXID(bo->wrk, oc, bo->vsl->wid));
223
224		/* for HTTP_Encode() VSLH call */
225	90036	bo->beresp->logtag = SLT_ObjMethod;
226
227		/* Filter into object */
228	90036	bp = ObjSetAttr(bo->wrk, oc, OA_HEADERS, l2, NULL);
229	90036	AN(bp);
230	180072	HTTP_Encode(bo->beresp, bp, l2,
231	90036	bo->uncacheable ? HTTPH_A_PASS : HTTPH_A_INS);
232
233	90036	if (http_GetHdr(bo->beresp, H_Last_Modified, &b))
234	1720	AZ(ObjSetDouble(bo->wrk, oc, OA_LASTMODIFIED, VTIM_parse(b)));
235		else
236	88316	AZ(ObjSetDouble(bo->wrk, oc, OA_LASTMODIFIED,
237		floor(oc->t_origin)));
238
239	90036	return (0);
240	90276	}
241
242		/*--------------------------------------------------------------------
243		* Copy req->bereq and release req if no body
244		*/
245
246		static const struct fetch_step * v_matchproto_(vbf_state_f)
247	91195	vbf_stp_mkbereq(struct worker wrk, struct busyobj bo)
248		{
249		const char *q;
250		struct objcore *oc;
251
252	91195	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
253	91195	CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
254	91195	CHECK_OBJ_NOTNULL(bo->req, REQ_MAGIC);
255	91195	oc = bo->fetch_objcore;
256	91195	CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
257
258	91195	assert(oc->boc->state == BOS_INVALID);
259	91195	AZ(bo->storage);
260
261	91195	HTTP_Setup(bo->bereq0, bo->ws, bo->vsl, SLT_BereqMethod);
262	182390	http_FilterReq(bo->bereq0, bo->req->http,
263	91195	bo->uncacheable ? HTTPH_R_PASS : HTTPH_R_FETCH);
264
265	91195	if (bo->uncacheable)
266	31395	AZ(bo->stale_oc);
267		else {
268	59800	http_ForceField(bo->bereq0, HTTP_HDR_METHOD, "GET");
269	59800	if (cache_param->http_gzip_support)
270	59600	http_ForceHeader(bo->bereq0, H_Accept_Encoding, "gzip");
271		}
272	91195	http_ForceField(bo->bereq0, HTTP_HDR_PROTO, "HTTP/1.1");
273
274	92675	if (bo->stale_oc != NULL && !(bo->stale_oc->flags & OC_F_DYING) &&
275	6240	ObjCheckFlag(bo->wrk, bo->stale_oc, OF_IMSCAND) &&
276	1640	(bo->stale_oc->boc != NULL \|\| ObjGetLen(wrk, bo->stale_oc) != 0)) {
277	1560	AZ(bo->stale_oc->flags & (OC_F_HFM\|OC_F_PRIVATE));
278	1560	q = RFC2616_Strong_LM(NULL, wrk, bo->stale_oc);
279	1560	if (q != NULL)
280	1040	http_PrintfHeader(bo->bereq0,
281	520	"If-Modified-Since: %s", q);
282	1560	q = HTTP_GetHdrPack(bo->wrk, bo->stale_oc, H_ETag);
283	1560	if (q != NULL)
284	2160	http_PrintfHeader(bo->bereq0,
285	1080	"If-None-Match: %s", q);
286	1560	}
287
288	91195	http_CopyHome(bo->bereq0);
289	91195	HTTP_Setup(bo->bereq, bo->ws, bo->vsl, SLT_BereqMethod);
290	91195	bo->ws_bo = WS_Snapshot(bo->ws);
291	91195	HTTP_Clone(bo->bereq, bo->bereq0);
292
293	91195	if (bo->req->req_body_status->avail == 0) {
294	87521	VBO_SetState(bo->wrk, bo, BOS_REQ_DONE);
295	91195	} else if (bo->req->req_body_status == BS_CACHED) {
296	920	AN(bo->req->body_oc);
297	920	bo->bereq_body = bo->req->body_oc;
298	920	HSH_Ref(bo->bereq_body);
299	920	VBO_SetState(bo->wrk, bo, BOS_REQ_DONE);
300	920	}
301	91195	return (F_STP_STARTFETCH);
302		}
303
304		/*--------------------------------------------------------------------
305		* Start a new VSL transaction and try again
306		* Prepare the busyobj and fetch processors
307		*/
308
309		static const struct fetch_step * v_matchproto_(vbf_state_f)
310	1480	vbf_stp_retry(struct worker wrk, struct busyobj bo)
311		{
312	1480	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
313	1480	CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
314
315	1480	assert(bo->fetch_objcore->boc->state <= BOS_REQ_DONE);
316
317	1480	if (bo->no_retry != NULL) {
318	160	VSLb(bo->vsl, SLT_Error,
319	80	"Retry not possible, %s", bo->no_retry);
320	80	return (F_STP_FAIL);
321		}
322
323	1400	VSLb_ts_busyobj(bo, "Retry", W_TIM_real(wrk));
324
325		/* VDI_Finish (via vbf_cleanup) must have been called before */
326	1400	assert(bo->director_state == DIR_S_NULL);
327
328		/* reset other bo attributes - See VBO_GetBusyObj */
329	1400	bo->storage = NULL;
330	1400	bo->do_esi = 0;
331	1400	bo->do_stream = 1;
332	1400	bo->was_304 = 0;
333	1400	bo->err_code = 0;
334	1400	bo->err_reason = NULL;
335	1400	bo->connect_timeout = NAN;
336	1400	bo->first_byte_timeout = NAN;
337	1400	bo->between_bytes_timeout = NAN;
338	1400	if (bo->htc != NULL)
339	0	bo->htc->doclose = SC_NULL;
340
341		// XXX: BereqEnd + BereqAcct ?
342	1400	VSL_ChgId(bo->vsl, "bereq", "retry", VXID_Get(wrk, VSL_BACKENDMARKER));
343	1400	VSLb_ts_busyobj(bo, "Start", bo->t_prev);
344	1400	http_VSL_log(bo->bereq);
345
346	1400	return (F_STP_STARTFETCH);
347	1480	}
348
349		/*--------------------------------------------------------------------
350		* 304 setup logic
351		*/
352
353		static void
354	1240	vbf_304_logic(struct busyobj *bo)
355		{
356
357	1240	AZ(bo->stale_oc->flags & (OC_F_HFM\|OC_F_PRIVATE));
358	1240	if (ObjCheckFlag(bo->wrk, bo->stale_oc, OF_CHGCE)) {
359		/*
360		* If a VFP changed C-E in the stored
361		* object, then don't overwrite C-E from
362		* the IMS fetch, and we must weaken any
363		* new ETag we get.
364		*/
365	80	RFC2616_Weaken_Etag(bo->beresp);
366	80	}
367	1240	http_Unset(bo->beresp, H_Content_Encoding);
368	1240	http_Unset(bo->beresp, H_Content_Length);
369	1240	HTTP_Merge(bo->wrk, bo->stale_oc, bo->beresp);
370	1240	}
371
372		/*--------------------------------------------------------------------
373		* Setup bereq from bereq0, run vcl_backend_fetch
374		*/
375
376		static const struct fetch_step * v_matchproto_(vbf_state_f)
377	92595	vbf_stp_startfetch(struct worker wrk, struct busyobj bo)
378		{
379		int i;
380		const char *q;
381		vtim_real now;
382	92595	unsigned handling, skip_vbr = 0;
383		struct objcore *oc;
384
385	92595	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
386	92595	CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
387	92595	oc = bo->fetch_objcore;
388	92595	CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
389
390		// this complements the stale_oc handling in vbf_stp_mkbereq():
391		// Conditions might have changed since we made the bereq (retry)
392	92595	if (! bo->uncacheable && bo->stale_oc != NULL &&
393	6360	bo->stale_oc->flags & OC_F_DYING) {
394	80	http_Unset(bo->bereq, H_If_Modified_Since);
395	80	http_Unset(bo->bereq, H_If_None_Match);
396	80	}
397
398	92595	AZ(bo->storage);
399	92595	bo->storage = bo->uncacheable ? stv_transient : STV_next();
400
401	92595	if (bo->retries > 0)
402	1400	http_Unset(bo->bereq, H_X_Varnish);
403
404	92595	http_PrintfHeader(bo->bereq, "X-Varnish: %ju", VXID(bo->vsl->wid));
405
406	92595	if (bo->bereq_body == NULL && bo->req == NULL)
407	88921	http_Unset(bo->bereq, H_Content_Length);
408
409	92595	VCL_backend_fetch_method(bo->vcl, wrk, NULL, bo, NULL);
410
411	92595	if (wrk->vpi->handling == VCL_RET_ABANDON \|\|
412	92474	wrk->vpi->handling == VCL_RET_FAIL)
413	270	return (F_STP_FAIL);
414
415	92325	assert (wrk->vpi->handling == VCL_RET_FETCH \|\|
416		wrk->vpi->handling == VCL_RET_ERROR);
417
418	92325	HTTP_Setup(bo->beresp, bo->ws, bo->vsl, SLT_BerespMethod);
419
420	92325	assert(oc->boc->state <= BOS_REQ_DONE);
421
422	92325	AZ(bo->htc);
423
424	92325	VFP_Setup(bo->vfc, wrk);
425	92325	bo->vfc->oc = oc;
426	92325	bo->vfc->resp = bo->beresp;
427	92325	bo->vfc->req = bo->bereq;
428
429	92325	if (wrk->vpi->handling == VCL_RET_ERROR)
430	400	return (F_STP_ERROR);
431
432	91925	VSLb_ts_busyobj(bo, "Fetch", W_TIM_real(wrk));
433	91925	i = VDI_GetHdr(bo);
434	91925	if (bo->htc != NULL)
435	81275	CHECK_OBJ_NOTNULL(bo->htc->doclose, STREAM_CLOSE_MAGIC);
436
437	91925	bo->t_resp = now = W_TIM_real(wrk);
438	91925	VSLb_ts_busyobj(bo, "Beresp", now);
439
440	91925	if (i) {
441	10599	assert(bo->director_state == DIR_S_NULL);
442	10599	return (F_STP_ERROR);
443		}
444
445	81326	if (bo->htc != NULL && bo->htc->body_status == BS_ERROR) {
446	240	bo->htc->doclose = SC_RX_BODY;
447	240	vbf_cleanup(bo);
448	240	VSLb(bo->vsl, SLT_Error, "Body cannot be fetched");
449	240	assert(bo->director_state == DIR_S_NULL);
450	240	return (F_STP_ERROR);
451		}
452
453	81086	if (!http_GetHdr(bo->beresp, H_Date, NULL)) {
454		/*
455		* RFC 2616 14.18 Date: The Date general-header field
456		* represents the date and time at which the message was
457		* originated, having the same semantics as orig-date in
458		* RFC 822. ... A received message that does not have a
459		* Date header field MUST be assigned one by the recipient
460		* if the message will be cached by that recipient or
461		* gatewayed via a protocol which requires a Date.
462		*
463		* If we didn't get a Date header, we assign one here.
464		*/
465	3320	http_TimeHeader(bo->beresp, "Date: ", now);
466	3320	}
467
468		/*
469		* These two headers can be spread over multiple actual headers
470		* and we rely on their content outside of VCL, so collect them
471		* into one line here.
472		*/
473	81084	http_CollectHdr(bo->beresp, H_Cache_Control);
474	81084	http_CollectHdr(bo->beresp, H_Vary);
475
476		/* What does RFC2616 think about TTL ? */
477	162168	RFC2616_Ttl(bo, now,
478	81084	&oc->t_origin,
479	81084	&oc->ttl,
480	81084	&oc->grace,
481	81084	&oc->keep);
482
483	81084	AZ(bo->do_esi);
484	81084	AZ(bo->was_304);
485
486	81084	if (http_IsStatus(bo->beresp, 304) && !bo->uncacheable) {
487	1600	if (bo->stale_oc == NULL){
488	0	VSLb(bo->vsl, SLT_Error,
489		"304 response but not conditional fetch");
490	0	bo->htc->doclose = SC_RX_BAD;
491	0	vbf_cleanup(bo);
492	0	return (F_STP_ERROR);
493		}
494	1600	bo->was_304 = 1;
495	1600	VCL_backend_refresh_method(bo->vcl, wrk, NULL, bo, NULL);
496	1600	switch (wrk->vpi->handling) {
497		case VCL_RET_MERGE:
498	1240	vbf_304_logic(bo);
499	1240	break;