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 &&
            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);

        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	3706	};
59	3706
60	3706	#define FETCH_STEP(l, U) \
61	3706	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	4500	vbf_allocobj(struct busyobj *bo, unsigned l)
76		{
77		struct objcore *oc;
78		const struct stevedore *stv;
79		vtim_dur lifetime;
80
81	4500	CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
82	4500	oc = bo->fetch_objcore;
83	4500	CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
84
85	4500	lifetime = oc->ttl + oc->grace + oc->keep;
86
87	4500	if (bo->uncacheable) {
88	1774	stv = stv_transient;
89	1774	bo->wrk->stats->beresp_uncacheable++;
90	1774	}
91	2726	else if (lifetime < cache_param->shortlived) {
92	254	stv = stv_transient;
93	254	bo->wrk->stats->beresp_shortlived++;
94	254	}
95		else
96	2472	stv = bo->storage;
97
98	4500	bo->storage = NULL;
99
100	4500	if (stv == NULL)
101	2	return (0);
102
103	4498	if (STV_NewObject(bo->wrk, oc, stv, l))
104	4484	return (1);
105
106	14	if (stv == stv_transient)
107	8	return (0);
108
109		/*
110		* Try to salvage the transaction by allocating a shortlived object
111		* on Transient storage.
112		*/
113
114	6	oc->ttl = vmin_t(float, oc->ttl, cache_param->shortlived);
115	6	oc->grace = 0.0;
116	6	oc->keep = 0.0;
117	6	return (STV_NewObject(bo->wrk, oc, stv_transient, l));
118	4500	}
119
120		static void
121	4050	vbf_cleanup(struct busyobj *bo)
122		{
123		struct vfp_ctx *vfc;
124
125	4050	CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
126	4050	vfc = bo->vfc;
127	4050	CHECK_OBJ_NOTNULL(vfc, VFP_CTX_MAGIC);
128
129	4050	bo->acct.beresp_bodybytes += VFP_Close(vfc);
130	4050	bo->vfp_filter_list = NULL;
131
132	4050	if (bo->director_state != DIR_S_NULL)
133	4034	VDI_Finish(bo);
134	4050	}
135
136		void
137	18	Bereq_Rollback(VRT_CTX)
138		{
139		struct busyobj *bo;
140
141	18	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
142	18	bo = ctx->bo;
143	18	CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
144
145	18	if (bo->htc != NULL) {
146	16	assert(bo->htc->body_status != BS_TAKEN);
147	16	if (bo->htc->body_status != BS_NONE)
148	2	bo->htc->doclose = SC_RESP_CLOSE;
149	16	}
150
151	18	vbf_cleanup(bo);
152	18	VCL_TaskLeave(ctx, bo->privs);
153	18	VCL_TaskEnter(bo->privs);
154	18	HTTP_Clone(bo->bereq, bo->bereq0);
155	18	bo->vfp_filter_list = NULL;
156	18	bo->err_reason = NULL;
157	18	AN(bo->ws_bo);
158	18	WS_Rollback(bo->ws, bo->ws_bo);
159	18	}
160
161		/*--------------------------------------------------------------------
162		* Turn the beresp into a obj
163		*/
164
165		static int
166	4500	vbf_beresp2obj(struct busyobj *bo)
167		{
168		unsigned l, l2;
169		const char *b;
170		uint8_t *bp;
171	4500	struct vsb *vary = NULL;
172	4500	int varyl = 0;
173		struct objcore *oc;
174
175	4500	CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
176	4500	oc = bo->fetch_objcore;
177	4500	CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
178
179	4500	l = 0;
180
181		/* Create Vary instructions */
182	4500	if (!(oc->flags & OC_F_PRIVATE)) {
183	2930	varyl = VRY_Create(bo, &vary);
184	2930	if (varyl > 0) {
185	430	AN(vary);
186	430	assert(varyl == VSB_len(vary));
187	430	l += PRNDUP((intptr_t)varyl);
188	2930	} else if (varyl < 0) {
189		/*
190		* Vary parse error
191		* Complain about it, and make this a pass.
192		*/
193	10	VSLb(bo->vsl, SLT_Error,
194		"Illegal 'Vary' header from backend, "
195		"making this a pass.");
196	10	bo->uncacheable = 1;
197	10	AZ(vary);
198	10	} else
199		/* No vary */
200	2490	AZ(vary);
201	2930	}
202
203	9000	l2 = http_EstimateWS(bo->beresp,
204	4500	bo->uncacheable ? HTTPH_A_PASS : HTTPH_A_INS);
205	4500	l += l2;
206
207	4500	if (bo->uncacheable)
208	1774	oc->flags \|= OC_F_HFM;
209
210	4500	if (!vbf_allocobj(bo, l)) {
211	12	if (vary != NULL)
212	0	VSB_destroy(&vary);
213	12	AZ(vary);
214	12	return (VFP_Error(bo->vfc, "Could not get storage"));
215		}
216
217	4488	if (vary != NULL) {
218	430	AN(ObjSetAttr(bo->wrk, oc, OA_VARY, varyl, VSB_data(vary)));
219	430	VSB_destroy(&vary);
220	430	}
221
222	4488	AZ(ObjSetXID(bo->wrk, oc, bo->vsl->wid));
223
224		/* for HTTP_Encode() VSLH call */
225	4488	bo->beresp->logtag = SLT_ObjMethod;
226
227		/* Filter into object */
228	4488	bp = ObjSetAttr(bo->wrk, oc, OA_HEADERS, l2, NULL);
229	4488	AN(bp);
230	8976	HTTP_Encode(bo->beresp, bp, l2,
231	4488	bo->uncacheable ? HTTPH_A_PASS : HTTPH_A_INS);
232
233	4488	if (http_GetHdr(bo->beresp, H_Last_Modified, &b))
234	86	AZ(ObjSetDouble(bo->wrk, oc, OA_LASTMODIFIED, VTIM_parse(b)));
235		else
236	4402	AZ(ObjSetDouble(bo->wrk, oc, OA_LASTMODIFIED,
237		floor(oc->t_origin)));
238
239	4488	return (0);
240	4500	}
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	4546	vbf_stp_mkbereq(struct worker wrk, struct busyobj bo)
248		{
249		const char *q;
250		struct objcore *oc;
251
252	4546	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
253	4546	CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
254	4546	CHECK_OBJ_NOTNULL(bo->req, REQ_MAGIC);
255	4546	oc = bo->fetch_objcore;
256	4546	CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
257
258	4546	assert(oc->boc->state == BOS_INVALID);
259	4546	AZ(bo->storage);
260
261	4546	HTTP_Setup(bo->bereq0, bo->ws, bo->vsl, SLT_BereqMethod);
262	9092	http_FilterReq(bo->bereq0, bo->req->http,
263	4546	bo->uncacheable ? HTTPH_R_PASS : HTTPH_R_FETCH);
264
265	4546	if (bo->uncacheable)
266	1568	AZ(bo->stale_oc);
267		else {
268	2978	http_ForceField(bo->bereq0, HTTP_HDR_METHOD, "GET");
269	2978	if (cache_param->http_gzip_support)
270	2968	http_ForceHeader(bo->bereq0, H_Accept_Encoding, "gzip");
271		}
272	4546	http_ForceField(bo->bereq0, HTTP_HDR_PROTO, "HTTP/1.1");
273
274	4618	if (bo->stale_oc != NULL &&
275	308	ObjCheckFlag(bo->wrk, bo->stale_oc, OF_IMSCAND) &&
276	80	(bo->stale_oc->boc != NULL \|\| ObjGetLen(wrk, bo->stale_oc) != 0)) {
277	76	AZ(bo->stale_oc->flags & (OC_F_HFM\|OC_F_PRIVATE));
278	76	q = RFC2616_Strong_LM(NULL, wrk, bo->stale_oc);
279	76	if (q != NULL)
280	52	http_PrintfHeader(bo->bereq0,
281	26	"If-Modified-Since: %s", q);
282	76	q = HTTP_GetHdrPack(bo->wrk, bo->stale_oc, H_ETag);
283	76	if (q != NULL)
284	104	http_PrintfHeader(bo->bereq0,
285	52	"If-None-Match: %s", q);
286	76	}
287
288	4546	http_CopyHome(bo->bereq0);
289	4546	HTTP_Setup(bo->bereq, bo->ws, bo->vsl, SLT_BereqMethod);
290	4546	bo->ws_bo = WS_Snapshot(bo->ws);
291	4546	HTTP_Clone(bo->bereq, bo->bereq0);
292
293	4546	if (bo->req->req_body_status->avail == 0) {
294	4364	VBO_SetState(bo->wrk, bo, BOS_REQ_DONE);
295	4546	} else if (bo->req->req_body_status == BS_CACHED) {
296	46	AN(bo->req->body_oc);
297	46	bo->bereq_body = bo->req->body_oc;
298	46	HSH_Ref(bo->bereq_body);
299	46	VBO_SetState(bo->wrk, bo, BOS_REQ_DONE);
300	46	}
301	4546	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	72	vbf_stp_retry(struct worker wrk, struct busyobj bo)
311		{
312	72	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
313	72	CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
314
315	72	assert(bo->fetch_objcore->boc->state <= BOS_REQ_DONE);
316
317	72	if (bo->no_retry != NULL) {
318	8	VSLb(bo->vsl, SLT_Error,
319	4	"Retry not possible, %s", bo->no_retry);
320	4	return (F_STP_FAIL);
321		}
322
323	68	VSLb_ts_busyobj(bo, "Retry", W_TIM_real(wrk));
324
325		/* VDI_Finish (via vbf_cleanup) must have been called before */
326	68	assert(bo->director_state == DIR_S_NULL);
327
328		/* reset other bo attributes - See VBO_GetBusyObj */
329	68	bo->storage = NULL;
330	68	bo->do_esi = 0;
331	68	bo->do_stream = 1;
332	68	bo->was_304 = 0;
333	68	bo->err_code = 0;
334	68	bo->err_reason = NULL;
335	68	bo->connect_timeout = NAN;
336	68	bo->first_byte_timeout = NAN;
337	68	bo->between_bytes_timeout = NAN;
338	68	if (bo->htc != NULL)
339	0	bo->htc->doclose = SC_NULL;
340
341		// XXX: BereqEnd + BereqAcct ?
342	68	VSL_ChgId(bo->vsl, "bereq", "retry", VXID_Get(wrk, VSL_BACKENDMARKER));
343	68	VSLb_ts_busyobj(bo, "Start", bo->t_prev);
344	68	http_VSL_log(bo->bereq);
345
346	68	return (F_STP_STARTFETCH);
347	72	}
348
349		/*--------------------------------------------------------------------
350		* 304 setup logic
351		*/
352
353		static void
354	60	vbf_304_logic(struct busyobj *bo)
355		{
356
357	60	AZ(bo->stale_oc->flags & (OC_F_HFM\|OC_F_PRIVATE));
358	60	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	4	RFC2616_Weaken_Etag(bo->beresp);
366	4	}
367	60	http_Unset(bo->beresp, H_Content_Encoding);
368	60	http_Unset(bo->beresp, H_Content_Length);
369	60	HTTP_Merge(bo->wrk, bo->stale_oc, bo->beresp);
370	60	}
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	4614	vbf_stp_startfetch(struct worker wrk, struct busyobj bo)
378		{
379		int i;
380		const char *q;
381		vtim_real now;
382	4614	unsigned handling, skip_vbr = 0;
383		struct objcore *oc;
384
385	4614	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
386	4614	CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
387	4614	oc = bo->fetch_objcore;
388	4614	CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
389
390	4614	AZ(bo->storage);
391	4614	bo->storage = bo->uncacheable ? stv_transient : STV_next();
392
393	4614	if (bo->retries > 0)
394	68	http_Unset(bo->bereq, H_X_Varnish);
395
396	4614	http_PrintfHeader(bo->bereq, "X-Varnish: %ju", VXID(bo->vsl->wid));
397
398	4614	if (bo->bereq_body == NULL && bo->req == NULL)
399	4432	http_Unset(bo->bereq, H_Content_Length);
400
401	4614	VCL_backend_fetch_method(bo->vcl, wrk, NULL, bo, NULL);
402
403	4614	if (wrk->vpi->handling == VCL_RET_ABANDON \|\|
404	4608	wrk->vpi->handling == VCL_RET_FAIL)
405	13	return (F_STP_FAIL);
406
407	4601	assert (wrk->vpi->handling == VCL_RET_FETCH \|\|
408		wrk->vpi->handling == VCL_RET_ERROR);
409
410	4601	HTTP_Setup(bo->beresp, bo->ws, bo->vsl, SLT_BerespMethod);
411
412	4601	assert(oc->boc->state <= BOS_REQ_DONE);
413
414	4601	AZ(bo->htc);
415
416	4601	VFP_Setup(bo->vfc, wrk);
417	4601	bo->vfc->oc = oc;
418	4601	bo->vfc->resp = bo->beresp;
419	4601	bo->vfc->req = bo->bereq;
420
421	4601	if (wrk->vpi->handling == VCL_RET_ERROR)
422	20	return (F_STP_ERROR);
423
424	4581	VSLb_ts_busyobj(bo, "Fetch", W_TIM_real(wrk));
425	4581	i = VDI_GetHdr(bo);
426	4581	if (bo->htc != NULL)
427	4048	CHECK_OBJ_NOTNULL(bo->htc->doclose, STREAM_CLOSE_MAGIC);
428
429	4581	bo->t_resp = now = W_TIM_real(wrk);
430	4581	VSLb_ts_busyobj(bo, "Beresp", now);
431
432	4581	if (i) {
433	530	assert(bo->director_state == DIR_S_NULL);
434	530	return (F_STP_ERROR);
435		}
436
437	4051	if (bo->htc != NULL && bo->htc->body_status == BS_ERROR) {
438	12	bo->htc->doclose = SC_RX_BODY;
439	12	vbf_cleanup(bo);
440	12	VSLb(bo->vsl, SLT_Error, "Body cannot be fetched");
441	12	assert(bo->director_state == DIR_S_NULL);
442	12	return (F_STP_ERROR);
443		}
444
445	4039	if (!http_GetHdr(bo->beresp, H_Date, NULL)) {
446		/*
447		* RFC 2616 14.18 Date: The Date general-header field
448		* represents the date and time at which the message was
449		* originated, having the same semantics as orig-date in
450		* RFC 822. ... A received message that does not have a
451		* Date header field MUST be assigned one by the recipient
452		* if the message will be cached by that recipient or
453		* gatewayed via a protocol which requires a Date.
454		*
455		* If we didn't get a Date header, we assign one here.
456		*/
457	166	http_TimeHeader(bo->beresp, "Date: ", now);
458	166	}
459
460		/*
461		* These two headers can be spread over multiple actual headers
462		* and we rely on their content outside of VCL, so collect them
463		* into one line here.
464		*/
465	4039	http_CollectHdr(bo->beresp, H_Cache_Control);
466	4039	http_CollectHdr(bo->beresp, H_Vary);
467
468		/* What does RFC2616 think about TTL ? */
469	8078	RFC2616_Ttl(bo, now,
470	4039	&oc->t_origin,
471	4039	&oc->ttl,
472	4039	&oc->grace,
473	4039	&oc->keep);
474
475	4039	AZ(bo->do_esi);
476	4039	AZ(bo->was_304);
477
478	4039	if (http_IsStatus(bo->beresp, 304) && !bo->uncacheable) {
479	76	if (bo->stale_oc == NULL){
480	0	VSLb(bo->vsl, SLT_Error,
481		"304 response but not conditional fetch");
482	0	bo->htc->doclose = SC_RX_BAD;
483	0	vbf_cleanup(bo);
484	0	return (F_STP_ERROR);
485		}
486	76	bo->was_304 = 1;
487	76	VCL_backend_refresh_method(bo->vcl, wrk, NULL, bo, NULL);
488	76	switch (wrk->vpi->handling) {
489		case VCL_RET_MERGE:
490	60	vbf_304_logic(bo);
491	60	break;
492		case VCL_RET_BERESP:
493	4	http_SetStatus(bo->beresp, 200, NULL);
494	4	http_Unset(bo->beresp, H_Content_Length);
495	4	http_Unset(bo->beresp, H_Content_Encoding);
496	8	q = HTTP_GetHdrPack(wrk, bo->stale_oc,
497	4	H_Content_Length);
498	4	if (q != NULL) {
499	4	http_ForceHeader(bo->beresp,