vfp_esi_gzip_init(struct vfp_ctx *vc, struct vfp_entry *vfe)
{
struct vef_priv *vef;
CHECK_OBJ_NOTNULL(vc, VFP_CTX_MAGIC);
CHECK_OBJ_NOTNULL(vc->req, HTTP_MAGIC);
CHECK_OBJ_NOTNULL(vfe, VFP_ENTRY_MAGIC);
if (http_GetStatus(vc->resp) == 206) {
VSLb(vc->wrk->vsl, SLT_VCL_Error,
"Attempted ESI on partial (206) response");
return (VFP_ERROR);
}
ALLOC_OBJ(vef, VEF_MAGIC);
if (vef == NULL)
return (VFP_ERROR);
vc->obj_flags |= OF_GZIPED | OF_CHGGZIP | OF_ESIPROC;
vef->vgz = VGZ_NewGzip(vc->wrk->vsl, "G F E");
vef->vep = VEP_Init(vc, vc->req, vfp_vep_callback, vef);
vef->ibuf_sz = cache_param->gzip_buffer;
vef->ibuf = calloc(1L, vef->ibuf_sz);
if (vef->ibuf == NULL)
return (vfp_esi_end(vc, vef, VFP_ERROR));
vef->ibuf_i = vef->ibuf;
vef->ibuf_o = vef->ibuf;
vfe->priv1 = vef;
RFC2616_Weaken_Etag(vc->resp);
http_Unset(vc->resp, H_Content_Length);
http_Unset(vc->resp, H_Content_Encoding);
http_SetHeader(vc->resp, "Content-Encoding: gzip");
RFC2616_Vary_AE(vc->resp);
return (VFP_OK);
}
static enum req_fsm_nxt
cnt_fetch(struct worker *wrk, struct req *req)
{
CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
CHECK_OBJ_NOTNULL(req->objcore, OBJCORE_MAGIC);
AZ(req->obj);
wrk->stats.s_fetch++;
(void)HTTP1_DiscardReqBody(req);
if (req->objcore->flags & OC_F_FAILED) {
req->err_code = 503;
req->req_step = R_STP_SYNTH;
(void)HSH_DerefObjCore(&wrk->stats, &req->objcore);
req->objcore = NULL;
return (REQ_FSM_MORE);
}
req->obj = ObjGetObj(req->objcore, &wrk->stats);
req->objcore = NULL;
req->err_code = http_GetStatus(req->obj->http);
req->req_step = R_STP_DELIVER;
return (REQ_FSM_MORE);
}
static void
cnt_vdp(struct req *req, struct busyobj *bo)
{
const char *r;
uint16_t status;
int wantbody;
CHECK_OBJ_NOTNULL(req->transport, TRANSPORT_MAGIC);
req->res_mode = 0;
wantbody = 1;
status = http_GetStatus(req->resp);
if (!strcmp(req->http0->hd[HTTP_HDR_METHOD].b, "HEAD")) {
wantbody = 0;
} else if (status < 200 || status == 204) {
req->resp_len = 0;
http_Unset(req->resp, H_Content_Length);
wantbody = 0;
} else if (status == 304) {
http_Unset(req->resp, H_Content_Length);
wantbody = 0;
} else if (bo != NULL)
req->resp_len = http_GetContentLength(req->resp);
else
req->resp_len = ObjGetLen(req->wrk, req->objcore);
/*
* Determine ESI status first. Not dependent on wantbody, because
* we want ESI to supress C-L in HEAD too.
*/
if (!req->disable_esi && req->resp_len != 0 && wantbody &&
ObjGetattr(req->wrk, req->objcore, OA_ESIDATA, NULL) != NULL) {
req->res_mode |= RES_ESI;
RFC2616_Weaken_Etag(req->resp);
req->resp_len = -1;
VDP_push(req, VDP_ESI, NULL, 0);
}
if (cache_param->http_gzip_support &&
ObjCheckFlag(req->wrk, req->objcore, OF_GZIPED) &&
!RFC2616_Req_Gzip(req->http)) {
req->res_mode |= RES_GUNZIP;
VDP_push(req, VDP_gunzip, NULL, 1);
}
/*
* Range comes after the others and pushes on bottom because
* it can (maybe) generate a correct C-L header.
*/
if (cache_param->http_range_support && http_IsStatus(req->resp, 200)) {
http_SetHeader(req->resp, "Accept-Ranges: bytes");
if (wantbody && http_GetHdr(req->http, H_Range, &r))
VRG_dorange(req, r);
}
req->transport->deliver(req, bo, wantbody);
}
vfp_esi_init(struct vfp_ctx *vc, struct vfp_entry *vfe)
{
struct vef_priv *vef;
CHECK_OBJ_NOTNULL(vc, VFP_CTX_MAGIC);
CHECK_OBJ_NOTNULL(vc->req, HTTP_MAGIC);
if (http_GetStatus(vc->resp) == 206) {
VSLb(vc->wrk->vsl, SLT_VCL_Error,
"Attempted ESI on partial (206) response");
return (VFP_ERROR);
}
ALLOC_OBJ(vef, VEF_MAGIC);
if (vef == NULL)
return (VFP_ERROR);
vc->obj_flags |= OF_ESIPROC;
vef->vep = VEP_Init(vc, vc->req, NULL, NULL);
vfe->priv1 = vef;
return (VFP_OK);
}
static int
vbf_figure_out_vfp(struct busyobj *bo)
{
/*
* The VCL variables beresp.do_g[un]zip tells us how we want the
* object processed before it is stored.
*
* The backend Content-Encoding header tells us what we are going
* to receive, which we classify in the following three classes:
*
* "Content-Encoding: gzip" --> object is gzip'ed.
* no Content-Encoding --> object is not gzip'ed.
* anything else --> do nothing wrt gzip
*
* On partial responses (206 on pass), we fail if do_esi is
* requested because it could leak partial esi-directives, and
* ignore gzipery, because it makes no sense.
*
*/
if (http_GetStatus(bo->beresp) == 206) {
if (bo->do_esi) {
VSLb(bo->vsl, SLT_VCL_Error,
"beresp.do_esi on partial response");
return (-1);
}
bo->do_gzip = bo->do_gunzip = 0;
return (0);
}
/* No body or no GZIP support -> done */
if (bo->htc->body_status == BS_NONE ||
bo->htc->content_length == 0 ||
!cache_param->http_gzip_support) {
http_Unset(bo->beresp, H_Content_Encoding);
bo->do_gzip = bo->do_gunzip = 0;
bo->do_stream = 0;
return (0);
}
bo->is_gzip = http_HdrIs(bo->beresp, H_Content_Encoding, "gzip");
bo->is_gunzip = !http_GetHdr(bo->beresp, H_Content_Encoding, NULL);
assert(bo->is_gzip == 0 || bo->is_gunzip == 0);
/* We won't gunzip unless it is gzip'ed */
if (bo->do_gunzip && !bo->is_gzip)
bo->do_gunzip = 0;
/* We wont gzip unless if it already is gzip'ed */
if (bo->do_gzip && !bo->is_gunzip)
bo->do_gzip = 0;
/* But we can't do both at the same time */
assert(bo->do_gzip == 0 || bo->do_gunzip == 0);
if (bo->do_gunzip || (bo->is_gzip && bo->do_esi))
if (VFP_Push(bo->vfc, &VFP_gunzip) == NULL)
return (-1);
if (bo->do_esi && (bo->do_gzip || (bo->is_gzip && !bo->do_gunzip)))
return (VFP_Push(bo->vfc, &VFP_esi_gzip) == NULL ? -1 : 0);
if (bo->do_esi)
return (VFP_Push(bo->vfc, &VFP_esi) == NULL ? -1 : 0);
if (bo->do_gzip)
return (VFP_Push(bo->vfc, &VFP_gzip) == NULL ? -1 : 0);
if (bo->is_gzip && !bo->do_gunzip)
return (VFP_Push(bo->vfc, &VFP_testgunzip) == NULL ? -1 : 0);
return (0);
}
void
RFC2616_Ttl(struct busyobj *bo)
{
unsigned max_age, age;
double h_date, h_expires;
char *p;
const struct http *hp;
struct exp *expp;
CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
expp = &bo->exp;
hp = bo->beresp;
assert(bo->t_fetch != 0.0 && !isnan(bo->t_fetch));
expp->t_origin = bo->t_fetch;
expp->ttl = cache_param->default_ttl;
expp->grace = cache_param->default_grace;
expp->keep = cache_param->default_keep;
max_age = age = 0;
h_expires = 0;
h_date = 0;
/*
* Initial cacheability determination per [RFC2616, 13.4]
* We do not support ranges yet, so 206 is out.
*/
if (http_GetHdr(hp, H_Age, &p)) {
/*
* We deliberately run with partial results, rather than
* reject the Age: header outright. This will be future
* compatible with fractional seconds.
*/
age = strtoul(p, NULL, 10);
expp->t_origin -= age;
}
if (http_GetHdr(hp, H_Expires, &p))
h_expires = VTIM_parse(p);
if (http_GetHdr(hp, H_Date, &p))
h_date = VTIM_parse(p);
switch (http_GetStatus(hp)) {
default:
expp->ttl = -1.;
break;
case 200: /* OK */
case 203: /* Non-Authoritative Information */
case 300: /* Multiple Choices */
case 301: /* Moved Permanently */
case 302: /* Moved Temporarily */
case 307: /* Temporary Redirect */
case 410: /* Gone */
case 404: /* Not Found */
/*
* First find any relative specification from the backend
* These take precedence according to RFC2616, 13.2.4
*/
if ((http_GetHdrField(hp, H_Cache_Control, "s-maxage", &p) ||
http_GetHdrField(hp, H_Cache_Control, "max-age", &p)) &&
p != NULL) {
if (*p == '-')
max_age = 0;
else
max_age = strtoul(p, NULL, 0);
if (age > max_age)
expp->ttl = 0;
else
expp->ttl = max_age - age;
break;
}
/* No expire header, fall back to default */
if (h_expires == 0)
break;
/* If backend told us it is expired already, don't cache. */
if (h_expires < h_date) {
expp->ttl = 0;
break;
}
if (h_date == 0 ||
fabs(h_date - bo->t_fetch) < cache_param->clock_skew) {
/*
* If we have no Date: header or if it is
* sufficiently close to our clock we will
* trust Expires: relative to our own clock.
*/
if (h_expires < bo->t_fetch)
expp->ttl = 0;
else
expp->ttl = h_expires - bo->t_fetch;
break;
} else {
/*
* But even if the clocks are out of whack we can still
* derive a relative time from the two headers.
* (the negative ttl case is caught above)
*/
expp->ttl = (int)(h_expires - h_date);
}
}
/* calculated TTL, Our time, Date, Expires, max-age, age */
VSLb(bo->vsl, SLT_TTL,
"RFC %.0f %.0f %.0f %.0f %.0f %.0f %.0f %u",
expp->ttl, -1., -1., bo->t_fetch,
expp->t_origin, h_date, h_expires, max_age);
}
static enum fetch_step
vbf_stp_fetchhdr(struct worker *wrk, struct busyobj *bo)
{
int i;
CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
xxxassert (wrk->handling == VCL_RET_FETCH);
HTTP_Setup(bo->beresp, bo->ws, bo->vsl, HTTP_Beresp);
if (!bo->do_pass)
vbf_release_req(bo); /* XXX: retry ?? */
assert(bo->state == BOS_INVALID);
i = V1F_fetch_hdr(wrk, bo, bo->req);
/*
* If we recycle a backend connection, there is a finite chance
* that the backend closed it before we get a request to it.
* Do a single retry in that case.
*/
if (i == 1) {
VSC_C_main->backend_retry++;
i = V1F_fetch_hdr(wrk, bo, bo->req);
}
if (bo->do_pass)
vbf_release_req(bo); /* XXX : retry ?? */
AZ(bo->req);
if (i) {
AZ(bo->vbc);
bo->err_code = 503;
http_SetH(bo->beresp, HTTP_HDR_PROTO, "HTTP/1.1");
http_SetResp(bo->beresp,
"HTTP/1.1", 503, "Backend fetch failed");
http_SetHeader(bo->beresp, "Content-Length: 0");
http_SetHeader(bo->beresp, "Connection: close");
} else {
AN(bo->vbc);
}
/*
* 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);
/*
* Figure out how the fetch is supposed to happen, before the
* headers are adultered by VCL
* NB: Also sets other wrk variables
*/
bo->htc.body_status = RFC2616_Body(bo, &wrk->stats);
bo->err_code = http_GetStatus(bo->beresp);
/*
* What does RFC2616 think about TTL ?
*/
EXP_Clr(&bo->exp);
bo->exp.entered = W_TIM_real(wrk);
RFC2616_Ttl(bo);
/* pass from vclrecv{} has negative TTL */
if (bo->fetch_objcore->objhead == NULL)
bo->exp.ttl = -1.;
AZ(bo->do_esi);
VCL_backend_response_method(bo->vcl, wrk, NULL, bo, bo->beresp->ws);
if (bo->do_esi)
bo->do_stream = 0;
if (wrk->handling == VCL_RET_DELIVER)
return (F_STP_FETCH);
if (wrk->handling == VCL_RET_RETRY) {
assert(bo->state == BOS_INVALID);
bo->retries++;
if (bo->retries <= cache_param->max_retries) {
VDI_CloseFd(&bo->vbc);
return (F_STP_STARTFETCH);
}
// XXX: wrk->handling = VCL_RET_SYNTH;
}
return (F_STP_NOTYET);
}
static enum req_fsm_nxt
cnt_transmit(struct worker *wrk, struct req *req)
{
struct boc *boc;
const char *r;
uint16_t status;
int sendbody;
intmax_t clval;
CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
CHECK_OBJ_NOTNULL(req->transport, TRANSPORT_MAGIC);
/* Grab a ref to the bo if there is one */
boc = HSH_RefBoc(req->objcore);
clval = http_GetContentLength(req->resp);
if (boc != NULL)
req->resp_len = clval;
else
req->resp_len = ObjGetLen(req->wrk, req->objcore);
req->res_mode = 0;
/* RFC 7230, 3.3.3 */
status = http_GetStatus(req->resp);
if (!strcmp(req->http0->hd[HTTP_HDR_METHOD].b, "HEAD")) {
if (req->objcore->flags & OC_F_PASS)
sendbody = -1;
else
sendbody = 0;
} else if (status < 200 || status == 204 || status == 304) {
req->resp_len = -1;
sendbody = 0;
} else
sendbody = 1;
if (sendbody >= 0) {
if (!req->disable_esi && req->resp_len != 0 &&
ObjHasAttr(wrk, req->objcore, OA_ESIDATA))
VDP_push(req, VDP_ESI, NULL, 0, "ESI");
if (cache_param->http_gzip_support &&
ObjCheckFlag(req->wrk, req->objcore, OF_GZIPED) &&
!RFC2616_Req_Gzip(req->http))
VDP_push(req, VDP_gunzip, NULL, 1, "GUZ");
if (cache_param->http_range_support &&
http_IsStatus(req->resp, 200)) {
http_SetHeader(req->resp, "Accept-Ranges: bytes");
if (sendbody && http_GetHdr(req->http, H_Range, &r))
VRG_dorange(req, r);
}
}
if (sendbody < 0) {
/* Don't touch pass+HEAD C-L */
sendbody = 0;
} else if (clval >= 0 && clval == req->resp_len) {
/* Reuse C-L header */
} else {
http_Unset(req->resp, H_Content_Length);
if (req->resp_len >= 0 && sendbody)
http_PrintfHeader(req->resp,
"Content-Length: %jd", req->resp_len);
}
req->transport->deliver(req, boc, sendbody);
VSLb_ts_req(req, "Resp", W_TIM_real(wrk));
if (req->objcore->flags & (OC_F_PRIVATE | OC_F_PASS)) {
if (boc != NULL) {
HSH_Abandon(req->objcore);
ObjWaitState(req->objcore, BOS_FINISHED);
}
ObjSlim(wrk, req->objcore);
}
if (boc != NULL)
HSH_DerefBoc(wrk, req->objcore);
(void)HSH_DerefObjCore(wrk, &req->objcore);
http_Teardown(req->resp);
return (REQ_FSM_DONE);
}
static enum fetch_step
vbf_stp_startfetch(struct worker *wrk, struct busyobj *bo)
{
int i;
double now;
CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
AZ(bo->storage_hint);
if (bo->do_pass)
AN(bo->req);
else
AZ(bo->req);
if (bo->retries > 0)
http_Unset(bo->bereq, "\012X-Varnish:");
http_PrintfHeader(bo->bereq, "X-Varnish: %u", VXID(bo->vsl->wid));
VCL_backend_fetch_method(bo->vcl, wrk, NULL, bo, NULL);
bo->uncacheable = bo->do_pass;
if (wrk->handling == VCL_RET_ABANDON)
return (F_STP_FAIL);
assert (wrk->handling == VCL_RET_FETCH);
HTTP_Setup(bo->beresp, bo->ws, bo->vsl, SLT_BerespMethod);
assert(bo->state <= BOS_REQ_DONE);
AZ(bo->htc);
i = VDI_GetHdr(wrk, bo);
now = W_TIM_real(wrk);
VSLb_ts_busyobj(bo, "Beresp", now);
if (i) {
assert(bo->director_state == DIR_S_NULL);
return (F_STP_ERROR);
}
http_VSL_log(bo->beresp);
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);
/*
* Figure out how the fetch is supposed to happen, before the
* headers are adultered by VCL
*/
if (!strcasecmp(http_GetMethod(bo->bereq), "head")) {
/*
* A HEAD request can never have a body in the reply,
* no matter what the headers might say.
* [RFC2516 4.3 p33]
*/
wrk->stats->fetch_head++;
bo->htc->body_status = BS_NONE;
} else if (http_GetStatus(bo->beresp) <= 199) {
/*
* 1xx responses never have a body.
* [RFC2616 4.3 p33]
* ... but we should never see them.
*/
wrk->stats->fetch_1xx++;
bo->htc->body_status = BS_ERROR;
} else if (http_IsStatus(bo->beresp, 204)) {
/*
* 204 is "No Content", obviously don't expect a body.
* [RFC7230 3.3.1 p28 and 3.3.2 p30]
*/
wrk->stats->fetch_204++;
if (http_GetHdr(bo->beresp, H_Content_Length, NULL) ||
http_GetHdr(bo->beresp, H_Transfer_Encoding, NULL))
bo->htc->body_status = BS_ERROR;
else
bo->htc->body_status = BS_NONE;
} else if (http_IsStatus(bo->beresp, 304)) {
/*
* 304 is "Not Modified" it has no body.
* [RFC2616 10.3.5 p63]
*/
wrk->stats->fetch_304++;
bo->htc->body_status = BS_NONE;
} else if (bo->htc->body_status == BS_CHUNKED) {
wrk->stats->fetch_chunked++;
} else if (bo->htc->body_status == BS_LENGTH) {
assert(bo->htc->content_length > 0);
wrk->stats->fetch_length++;
} else if (bo->htc->body_status == BS_EOF) {
wrk->stats->fetch_eof++;
} else if (bo->htc->body_status == BS_ERROR) {
wrk->stats->fetch_bad++;
} else if (bo->htc->body_status == BS_NONE) {
wrk->stats->fetch_none++;
} else {
WRONG("wrong bodystatus");
}
if (bo->htc->body_status == BS_ERROR) {
bo->htc->doclose = SC_RX_BODY;
VDI_Finish(bo->wrk, bo);
VSLb(bo->vsl, SLT_Error, "Body cannot be fetched");
assert(bo->director_state == DIR_S_NULL);
return (F_STP_ERROR);
}
/*
* What does RFC2616 think about TTL ?
*/
EXP_Clr(&bo->fetch_objcore->exp);
RFC2616_Ttl(bo, now);
/* private objects have negative TTL */
if (bo->fetch_objcore->flags & OC_F_PRIVATE)
bo->fetch_objcore->exp.ttl = -1.;
AZ(bo->do_esi);
AZ(bo->was_304);
if (http_IsStatus(bo->beresp, 304)) {
if (bo->stale_oc != NULL &&
ObjCheckFlag(bo->wrk, bo->stale_oc, OF_IMSCAND)) {
if (ObjCheckFlag(bo->wrk, bo->stale_oc, OF_CHGGZIP)) {
/*
* If we changed the gzip status of the object
* the stored Content_Encoding controls we
* must weaken any new ETag we get.
*/
http_Unset(bo->beresp, H_Content_Encoding);
RFC2616_Weaken_Etag(bo->beresp);
}
http_Unset(bo->beresp, H_Content_Length);
HTTP_Merge(bo->wrk, bo->stale_oc, bo->beresp);
assert(http_IsStatus(bo->beresp, 200));
bo->was_304 = 1;
} else if (!bo->do_pass) {
/*
* Backend sent unallowed 304
*/
VSLb(bo->vsl, SLT_Error,
"304 response but not conditional fetch");
bo->htc->doclose = SC_RX_BAD;
VDI_Finish(bo->wrk, bo);
return (F_STP_FAIL);
}
}
bo->vfc->bo = bo;
bo->vfc->oc = bo->fetch_objcore;
bo->vfc->wrk = bo->wrk;
bo->vfc->http = bo->beresp;
bo->vfc->esi_req = bo->bereq;
VCL_backend_response_method(bo->vcl, wrk, NULL, bo, NULL);
if (wrk->handling == VCL_RET_ABANDON) {
bo->htc->doclose = SC_RESP_CLOSE;
VDI_Finish(bo->wrk, bo);
return (F_STP_FAIL);
}
if (wrk->handling == VCL_RET_RETRY) {
if (bo->htc->body_status != BS_NONE)
bo->htc->doclose = SC_RESP_CLOSE;
if (bo->director_state != DIR_S_NULL)
VDI_Finish(bo->wrk, bo);
if (bo->retries++ < cache_param->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);
}
assert(bo->state == BOS_REQ_DONE);
if (bo->do_esi)
bo->do_stream = 0;
if (bo->do_pass || bo->uncacheable)
bo->fetch_objcore->flags |= OC_F_PASS;
assert(wrk->handling == VCL_RET_DELIVER);
return (bo->was_304 ? F_STP_CONDFETCH : F_STP_FETCH);
}
static enum fetch_step
vbf_stp_fetchhdr(struct worker *wrk, struct busyobj *bo)
{
int i, do_ims;
CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
xxxassert (wrk->handling == VCL_RET_FETCH);
HTTP_Setup(bo->beresp, bo->ws, bo->vsl, HTTP_Beresp);
if (!bo->do_pass && bo->req != NULL)
vbf_release_req(bo); /* XXX: retry ?? */
assert(bo->state <= BOS_REQ_DONE);
i = V1F_fetch_hdr(wrk, bo, bo->req);
/*
* If we recycle a backend connection, there is a finite chance
* that the backend closed it before we get a request to it.
* Do a single retry in that case.
*/
if (i == 1) {
VSC_C_main->backend_retry++;
i = V1F_fetch_hdr(wrk, bo, bo->req);
}
if (bo->do_pass && bo->req != NULL)
vbf_release_req(bo); /* XXX : retry ?? */
AZ(bo->req);
if (i) {
AZ(bo->vbc);
make_it_503(bo);
} else {
AN(bo->vbc);
}
/*
* 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);
/*
* Figure out how the fetch is supposed to happen, before the
* headers are adultered by VCL
* NB: Also sets other wrk variables
*/
bo->htc.body_status = RFC2616_Body(bo, &wrk->stats);
if (i && bo->htc.body_status == BS_LENGTH)
bo->htc.body_status = BS_NONE;
bo->err_code = http_GetStatus(bo->beresp);
/*
* What does RFC2616 think about TTL ?
*/
EXP_Clr(&bo->exp);
RFC2616_Ttl(bo);
/* private objects have negative TTL */
if (bo->fetch_objcore->flags & OC_F_PRIVATE)
bo->exp.ttl = -1.;
AZ(bo->do_esi);
if (bo->ims_obj != NULL && bo->beresp->status == 304) {
bo->beresp->status = 200;
http_PrintfHeader(bo->beresp, "Content-Length: %jd",
(intmax_t)bo->ims_obj->len);
do_ims = 1;
} else
do_ims = 0;
VCL_backend_response_method(bo->vcl, wrk, NULL, bo, bo->beresp->ws);
if (bo->do_esi)
bo->do_stream = 0;
if (bo->do_pass)
bo->fetch_objcore->flags |= OC_F_PASS;
if (wrk->handling == VCL_RET_DELIVER)
return (do_ims ? F_STP_CONDFETCH : F_STP_FETCH);
if (wrk->handling == VCL_RET_RETRY) {
assert(bo->state == BOS_REQ_DONE);
bo->retries++;
if (bo->retries <= cache_param->max_retries) {
VDI_CloseFd(&bo->vbc);
return (F_STP_STARTFETCH);
}
// XXX: wrk->handling = VCL_RET_SYNTH;
}
INCOMPL();
}
static int
cnt_fetch(struct worker *wrk, struct req *req)
{
int i, need_host_hdr;
struct busyobj *bo;
CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
CHECK_OBJ_NOTNULL(req->vcl, VCL_CONF_MAGIC);
bo = req->busyobj;
CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
AN(req->director);
AZ(bo->vbc);
AZ(bo->should_close);
AZ(req->storage_hint);
HTTP_Setup(bo->beresp, bo->ws, bo->vsl, HTTP_Beresp);
need_host_hdr = !http_GetHdr(bo->bereq, H_Host, NULL);
req->acct_req.fetch++;
i = FetchHdr(req, need_host_hdr, req->objcore->objhead == NULL);
/*
* If we recycle a backend connection, there is a finite chance
* that the backend closed it before we get a request to it.
* Do a single retry in that case.
*/
if (i == 1) {
VSC_C_main->backend_retry++;
i = FetchHdr(req, need_host_hdr, req->objcore->objhead == NULL);
}
if (i) {
req->handling = VCL_RET_ERROR;
req->err_code = 503;
} else {
/*
* 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);
/*
* Figure out how the fetch is supposed to happen, before the
* headers are adultered by VCL
* NB: Also sets other wrk variables
*/
bo->body_status = RFC2616_Body(bo, &wrk->stats);
req->err_code = http_GetStatus(bo->beresp);
/*
* What does RFC2616 think about TTL ?
*/
EXP_Clr(&bo->exp);
bo->exp.entered = W_TIM_real(wrk);
RFC2616_Ttl(bo);
/* pass from vclrecv{} has negative TTL */
if (req->objcore->objhead == NULL)
bo->exp.ttl = -1.;
AZ(bo->do_esi);
AZ(bo->do_pass);
VCL_fetch_method(req);
if (bo->do_pass)
req->objcore->flags |= OC_F_PASS;
switch (req->handling) {
case VCL_RET_DELIVER:
req->req_step = R_STP_FETCHBODY;
return (0);
default:
break;
}
/* We are not going to fetch the body, Close the connection */
VDI_CloseFd(&bo->vbc);
}
/* Clean up partial fetch */
AZ(bo->vbc);
if (req->objcore->objhead != NULL || req->handling == VCL_RET_ERROR) {
CHECK_OBJ_NOTNULL(req->objcore, OBJCORE_MAGIC);
AZ(HSH_Deref(&wrk->stats, req->objcore, NULL));
req->objcore = NULL;
}
assert(bo->refcount == 2);
VBO_DerefBusyObj(wrk, &bo);
VBO_DerefBusyObj(wrk, &req->busyobj);
req->director = NULL;
req->storage_hint = NULL;
switch (req->handling) {
case VCL_RET_RESTART:
req->req_step = R_STP_RESTART;
return (0);
case VCL_RET_ERROR:
req->req_step = R_STP_ERROR;
return (0);
default:
WRONG("Illegal action in vcl_fetch{}");
}
}
static enum req_fsm_nxt
cnt_deliver(struct worker *wrk, struct req *req)
{
struct busyobj *bo;
CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
CHECK_OBJ_NOTNULL(req->obj, OBJECT_MAGIC);
CHECK_OBJ_NOTNULL(req->obj->objcore, OBJCORE_MAGIC);
CHECK_OBJ_NOTNULL(req->obj->objcore->objhead, OBJHEAD_MAGIC);
CHECK_OBJ_NOTNULL(req->vcl, VCL_CONF_MAGIC);
assert(WRW_IsReleased(wrk));
assert(req->obj->objcore->refcnt > 0);
if (req->obj->objcore->exp_flags & OC_EF_EXP)
EXP_Touch(req->obj->objcore, req->t_prev);
HTTP_Setup(req->resp, req->ws, req->vsl, SLT_RespMethod);
http_FilterResp(req->obj->http, req->resp, 0);
http_ForceField(req->resp, HTTP_HDR_PROTO, "HTTP/1.1");
if (req->wrk->stats.cache_hit)
http_PrintfHeader(req->resp,
"X-Varnish: %u %u", VXID(req->vsl->wid),
VXID(req->obj->vxid));
else
http_PrintfHeader(req->resp,
"X-Varnish: %u", VXID(req->vsl->wid));
/* We base Age calculation upon the last timestamp taken during
client request processing. This gives some inaccuracy, but
since Age is only full second resolution that shouldn't
matter. (Last request timestamp could be a Start timestamp
taken before the object entered into cache leading to negative
age. Truncate to zero in that case).
*/
http_PrintfHeader(req->resp, "Age: %.0f",
fmax(0., req->t_prev - req->obj->objcore->exp.t_origin));
http_SetHeader(req->resp, "Via: 1.1 varnish-v4");
if (cache_param->http_gzip_support && req->obj->gziped &&
!RFC2616_Req_Gzip(req->http))
RFC2616_Weaken_Etag(req->resp);
VCL_deliver_method(req->vcl, wrk, req, NULL, req->http->ws);
VSLb_ts_req(req, "Process", W_TIM_real(wrk));
/* Stop the insanity before it turns "Hotel California" on us */
if (req->restarts >= cache_param->max_restarts)
wrk->handling = VCL_RET_DELIVER;
if (wrk->handling != VCL_RET_DELIVER) {
(void)HSH_DerefObj(&wrk->stats, &req->obj);
AZ(req->obj);
http_Teardown(req->resp);
switch (wrk->handling) {
case VCL_RET_RESTART:
req->req_step = R_STP_RESTART;
break;
case VCL_RET_SYNTH:
req->req_step = R_STP_SYNTH;
break;
default:
INCOMPL();
}
return (REQ_FSM_MORE);
}
assert(wrk->handling == VCL_RET_DELIVER);
if (!(req->obj->objcore->flags & OC_F_PASS)
&& req->esi_level == 0
&& http_GetStatus(req->obj->http) == 200
&& req->http->conds && RFC2616_Do_Cond(req)) {
http_PutResponse(req->resp, "HTTP/1.1", 304, NULL);
req->wantbody = 0;
}
/* Grab a ref to the bo if there is one, and hand it down */
bo = HSH_RefBusy(req->obj->objcore);
V1D_Deliver(req, bo);
if (bo != NULL)
VBO_DerefBusyObj(req->wrk, &bo);
VSLb_ts_req(req, "Resp", W_TIM_real(wrk));
if (http_HdrIs(req->resp, H_Connection, "close"))
req->doclose = SC_RESP_CLOSE;
if (req->obj->objcore->flags & OC_F_PASS) {
/*
* No point in saving the body if it is hit-for-pass,
* but we can't yank it until the fetching thread has
* finished/abandoned also.
*/
while (req->obj->objcore->busyobj != NULL)
(void)usleep(100000);
STV_Freestore(req->obj);
}
assert(WRW_IsReleased(wrk));
VSLb(req->vsl, SLT_Debug, "XXX REF %d", req->obj->objcore->refcnt);
(void)HSH_DerefObj(&wrk->stats, &req->obj);
http_Teardown(req->resp);
return (REQ_FSM_DONE);
}
static int
cnt_fetch(struct sess *sp)
{
int i, transient;
struct http *hp, *hp2;
char *b;
unsigned handling;
CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
CHECK_OBJ_NOTNULL(sp->vcl, VCL_CONF_MAGIC);
AN(sp->director);
AZ(sp->vbe);
/* sp->wrk->http[0] is (still) bereq */
sp->wrk->beresp = &sp->wrk->http[1];
http_Setup(sp->wrk->beresp, sp->wrk->ws);
i = FetchHdr(sp);
/*
* Save a copy before it might get mangled in VCL. When it comes to
* dealing with the body, we want to see the unadultered headers.
*/
sp->wrk->beresp1 = &sp->wrk->http[2];
*sp->wrk->beresp1 = *sp->wrk->beresp;
if (i) {
if (sp->objhead) {
CHECK_OBJ_NOTNULL(sp->objhead, OBJHEAD_MAGIC);
CHECK_OBJ_NOTNULL(sp->objcore, OBJCORE_MAGIC);
HSH_DerefObjCore(sp);
}
AZ(sp->obj);
sp->wrk->bereq = NULL;
sp->wrk->beresp = NULL;
sp->wrk->beresp1 = NULL;
sp->err_code = 503;
sp->step = STP_ERROR;
return (0);
}
sp->err_code = http_GetStatus(sp->wrk->beresp);
/*
* Initial cacheability determination per [RFC2616, 13.4]
* We do not support ranges yet, so 206 is out.
*/
switch (sp->err_code) {
case 200: /* OK */
case 203: /* Non-Authoritative Information */
case 300: /* Multiple Choices */
case 301: /* Moved Permanently */
case 302: /* Moved Temporarily */
case 410: /* Gone */
case 404: /* Not Found */
sp->wrk->cacheable = 1;
break;
default:
sp->wrk->cacheable = 0;
break;
}
sp->wrk->entered = TIM_real();
sp->wrk->age = 0;
sp->wrk->ttl = RFC2616_Ttl(sp);
if (sp->wrk->ttl == 0.)
sp->wrk->cacheable = 0;
sp->wrk->do_esi = 0;
sp->wrk->grace = NAN;
VCL_fetch_method(sp);
/*
* When we fetch the body, we may hit the LRU cleanup and that
* will overwrite sp->handling, so we have to save our plans
* here.
*/
handling = sp->handling;
if (sp->objhead == NULL)
transient = 1;
else if (sp->handling == VCL_RET_DELIVER)
transient = 0;
else
transient = 1;
/*
* XXX: If we have a Length: header, we should allocate the body
* XXX: also.
*/
sp->obj = HSH_NewObject(sp, transient);
if (sp->objhead != NULL) {
CHECK_OBJ_NOTNULL(sp->objhead, OBJHEAD_MAGIC);
CHECK_OBJ_NOTNULL(sp->objcore, OBJCORE_MAGIC);
sp->objcore->obj = sp->obj;
sp->obj->objcore = sp->objcore;
sp->obj->objhead = sp->objhead;
sp->objhead = NULL; /* refcnt follows pointer. */
sp->objcore = NULL; /* refcnt follows pointer. */
}
BAN_NewObj(sp->obj);
sp->obj->xid = sp->xid;
sp->obj->response = sp->err_code;
sp->obj->cacheable = sp->wrk->cacheable;
sp->obj->ttl = sp->wrk->ttl;
sp->obj->grace = sp->wrk->grace;
if (sp->obj->ttl == 0. && sp->obj->grace == 0.)
sp->obj->cacheable = 0;
sp->obj->age = sp->wrk->age;
sp->obj->entered = sp->wrk->entered;
WS_Assert(sp->obj->ws_o);
/* Filter into object */
hp = sp->wrk->beresp;
hp2 = sp->obj->http;
hp2->logtag = HTTP_Obj;
http_CopyResp(hp2, hp);
http_FilterFields(sp->wrk, sp->fd, hp2, hp, HTTPH_A_INS);
http_CopyHome(sp->wrk, sp->fd, hp2);
if (http_GetHdr(hp, H_Last_Modified, &b))
sp->obj->last_modified = TIM_parse(b);
i = FetchBody(sp);
AZ(sp->wrk->wfd);
AZ(sp->vbe);
AN(sp->director);
if (i) {
HSH_Drop(sp);
AZ(sp->obj);
sp->wrk->bereq = NULL;
sp->wrk->beresp = NULL;
sp->wrk->beresp1 = NULL;
sp->err_code = 503;
sp->step = STP_ERROR;
return (0);
}
if (!transient)
HSH_Object(sp);
if (sp->wrk->do_esi)
ESI_Parse(sp);
switch (handling) {
case VCL_RET_RESTART:
HSH_Drop(sp);
sp->director = NULL;
sp->restarts++;
sp->wrk->bereq = NULL;
sp->wrk->beresp = NULL;
sp->wrk->beresp1 = NULL;
sp->step = STP_RECV;
return (0);
case VCL_RET_PASS:
if (sp->obj->objcore != NULL)
sp->obj->objcore->flags |= OC_F_PASS;
if (sp->obj->ttl - sp->t_req < params->default_ttl)
sp->obj->ttl = sp->t_req + params->default_ttl;
break;
case VCL_RET_DELIVER:
break;
case VCL_RET_ERROR:
HSH_Drop(sp);
sp->wrk->bereq = NULL;
sp->wrk->beresp = NULL;
sp->wrk->beresp1 = NULL;
sp->step = STP_ERROR;
return (0);
default:
WRONG("Illegal action in vcl_fetch{}");
}
sp->obj->cacheable = 1;
if (sp->obj->objhead != NULL) {
VRY_Create(sp);
EXP_Insert(sp->obj);
AN(sp->obj->ban);
HSH_Unbusy(sp);
}
sp->acct_req.fetch++;
sp->wrk->bereq = NULL;
sp->wrk->beresp = NULL;
sp->wrk->beresp1 = NULL;
sp->step = STP_DELIVER;
return (0);
}
static int
cnt_fetch(struct sess *sp)
{
int i, need_host_hdr;
struct worker *wrk;
CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
wrk = sp->wrk;
CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
CHECK_OBJ_NOTNULL(sp->vcl, VCL_CONF_MAGIC);
CHECK_OBJ_NOTNULL(wrk->busyobj, BUSYOBJ_MAGIC);
AN(sp->director);
AZ(wrk->busyobj->vbc);
AZ(wrk->busyobj->should_close);
AZ(wrk->storage_hint);
http_Setup(wrk->busyobj->beresp, wrk->ws);
need_host_hdr = !http_GetHdr(wrk->busyobj->bereq, H_Host, NULL);
i = FetchHdr(sp, need_host_hdr);
/*
* If we recycle a backend connection, there is a finite chance
* that the backend closed it before we get a request to it.
* Do a single retry in that case.
*/
if (i == 1) {
VSC_C_main->backend_retry++;
i = FetchHdr(sp, need_host_hdr);
}
if (i) {
sp->handling = VCL_RET_ERROR;
sp->err_code = 503;
} else {
/*
* 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(wrk->busyobj->beresp, H_Cache_Control);
http_CollectHdr(wrk->busyobj->beresp, H_Vary);
/*
* Figure out how the fetch is supposed to happen, before the
* headers are adultered by VCL
* NB: Also sets other wrk variables
*/
wrk->busyobj->body_status = RFC2616_Body(sp);
sp->err_code = http_GetStatus(wrk->busyobj->beresp);
/*
* What does RFC2616 think about TTL ?
*/
EXP_Clr(&wrk->busyobj->exp);
wrk->busyobj->exp.entered = W_TIM_real(wrk);
RFC2616_Ttl(sp);
/* pass from vclrecv{} has negative TTL */
if (wrk->objcore == NULL)
wrk->busyobj->exp.ttl = -1.;
AZ(wrk->busyobj->do_esi);
VCL_fetch_method(sp);
switch (sp->handling) {
case VCL_RET_HIT_FOR_PASS:
if (wrk->objcore != NULL)
wrk->objcore->flags |= OC_F_PASS;
sp->step = STP_FETCHBODY;
return (0);
case VCL_RET_DELIVER:
AssertObjCorePassOrBusy(wrk->objcore);
sp->step = STP_FETCHBODY;
return (0);
default:
break;
}
/* We are not going to fetch the body, Close the connection */
VDI_CloseFd(wrk, &wrk->busyobj->vbc);
}
/* Clean up partial fetch */
AZ(wrk->busyobj->vbc);
if (wrk->objcore != NULL) {
CHECK_OBJ_NOTNULL(wrk->objcore, OBJCORE_MAGIC);
AZ(HSH_Deref(wrk, wrk->objcore, NULL));
wrk->objcore = NULL;
}
VBO_DerefBusyObj(wrk, &wrk->busyobj);
sp->director = NULL;
wrk->storage_hint = NULL;
switch (sp->handling) {
case VCL_RET_RESTART:
sp->restarts++;
sp->step = STP_RECV;
return (0);
case VCL_RET_ERROR:
sp->step = STP_ERROR;
return (0);
default:
WRONG("Illegal action in vcl_fetch{}");
}
}
static enum req_fsm_nxt
cnt_deliver(struct worker *wrk, struct req *req)
{
char time_str[30];
double now;
CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
CHECK_OBJ_NOTNULL(req->obj, OBJECT_MAGIC);
CHECK_OBJ_NOTNULL(req->obj->objcore, OBJCORE_MAGIC);
CHECK_OBJ_NOTNULL(req->obj->objcore->objhead, OBJHEAD_MAGIC);
CHECK_OBJ_NOTNULL(req->vcl, VCL_CONF_MAGIC);
assert(WRW_IsReleased(wrk));
assert(req->obj->objcore->refcnt > 0);
now = W_TIM_real(wrk);
VSLb_ts_req(req, "Process", now);
if (req->obj->objcore->exp_flags & OC_EF_EXP)
EXP_Touch(req->obj->objcore, now);
HTTP_Setup(req->resp, req->ws, req->vsl, SLT_RespMethod);
http_ClrHeader(req->resp);
http_FilterResp(req->obj->http, req->resp, 0);
http_Unset(req->resp, H_Date);
VTIM_format(now, time_str);
http_PrintfHeader(req->resp, "Date: %s", time_str);
if (req->wrk->stats.cache_hit)
http_PrintfHeader(req->resp,
"X-Varnish: %u %u", req->vsl->wid & VSL_IDENTMASK,
req->obj->vxid & VSL_IDENTMASK);
else
http_PrintfHeader(req->resp,
"X-Varnish: %u", req->vsl->wid & VSL_IDENTMASK);
http_PrintfHeader(req->resp, "Age: %.0f",
now - req->obj->exp.t_origin);
http_SetHeader(req->resp, "Via: 1.1 varnish (v4)");
if (cache_param->http_gzip_support && req->obj->gziped &&
!RFC2616_Req_Gzip(req->http))
RFC2616_Weaken_Etag(req->resp);
VCL_deliver_method(req->vcl, wrk, req, NULL, req->http->ws);
/* Stop the insanity before it turns "Hotel California" on us */
if (req->restarts >= cache_param->max_restarts)
wrk->handling = VCL_RET_DELIVER;
if (wrk->handling == VCL_RET_RESTART) {
(void)HSH_DerefObj(&wrk->stats, &req->obj);
AZ(req->obj);
http_Teardown(req->resp);
req->req_step = R_STP_RESTART;
return (REQ_FSM_MORE);
}
assert(wrk->handling == VCL_RET_DELIVER);
if (!(req->obj->objcore->flags & OC_F_PASS)
&& req->esi_level == 0
&& http_GetStatus(req->obj->http) == 200
&& req->http->conds && RFC2616_Do_Cond(req))
http_SetResp(req->resp, "HTTP/1.1", 304, "Not Modified");
V1D_Deliver(req);
VSLb_ts_req(req, "Resp", W_TIM_real(wrk));
if (http_HdrIs(req->resp, H_Connection, "close"))
req->doclose = SC_RESP_CLOSE;
if (req->obj->objcore->flags & OC_F_PASS) {
/*
* No point in saving the body if it is hit-for-pass,
* but we can't yank it until the fetching thread has
* finished/abandoned also.
*/
while (req->obj->objcore->busyobj != NULL)
(void)usleep(100000);
STV_Freestore(req->obj);
}
assert(WRW_IsReleased(wrk));
VSLb(req->vsl, SLT_Debug, "XXX REF %d", req->obj->objcore->refcnt);
(void)HSH_DerefObj(&wrk->stats, &req->obj);
http_Teardown(req->resp);
return (REQ_FSM_DONE);
}
void
RFC2616_Ttl(struct busyobj *bo, double now, double *t_origin,
float *ttl, float *grace, float *keep)
{
unsigned max_age, age;
double h_date, h_expires;
const char *p;
const struct http *hp;
CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
assert(now != 0.0 && !isnan(now));
AN(t_origin);
AN(ttl);
AN(grace);
AN(keep);
*t_origin = now;
*ttl = cache_param->default_ttl;
*grace = cache_param->default_grace;
*keep = cache_param->default_keep;
hp = bo->beresp;
max_age = age = 0;
h_expires = 0;
h_date = 0;
/*
* Initial cacheability determination per [RFC2616, 13.4]
* We do not support ranges to the backend yet, so 206 is out.
*/
if (http_GetHdr(hp, H_Age, &p)) {
/*
* We deliberately run with partial results, rather than
* reject the Age: header outright. This will be future
* compatible with fractional seconds.
*/
age = strtoul(p, NULL, 10);
*t_origin -= age;
}
if (http_GetHdr(hp, H_Expires, &p))
h_expires = VTIM_parse(p);
if (http_GetHdr(hp, H_Date, &p))
h_date = VTIM_parse(p);
switch (http_GetStatus(hp)) {
default:
*ttl = -1.;
break;
case 302: /* Moved Temporarily */
case 307: /* Temporary Redirect */
/*
* https://tools.ietf.org/html/rfc7231#section-6.1
*
* Do not apply the default ttl, only set a ttl if Cache-Control
* or Expires are present. Uncacheable otherwise.
*/
*ttl = -1.;
/* FALL-THROUGH */
case 200: /* OK */
case 203: /* Non-Authoritative Information */
case 204: /* No Content */
case 300: /* Multiple Choices */
case 301: /* Moved Permanently */
case 304: /* Not Modified - handled like 200 */
case 404: /* Not Found */
case 410: /* Gone */
case 414: /* Request-URI Too Large */
/*
* First find any relative specification from the backend
* These take precedence according to RFC2616, 13.2.4
*/
if ((http_GetHdrField(hp, H_Cache_Control, "s-maxage", &p) ||
http_GetHdrField(hp, H_Cache_Control, "max-age", &p)) &&
p != NULL) {
if (*p == '-')
max_age = 0;
else
max_age = strtoul(p, NULL, 0);
*ttl = max_age;
break;
}
/* No expire header, fall back to default */
if (h_expires == 0)
break;
/* If backend told us it is expired already, don't cache. */
if (h_expires < h_date) {
*ttl = 0;
break;
}
if (h_date == 0 ||
fabs(h_date - now) < cache_param->clock_skew) {
/*
* If we have no Date: header or if it is
* sufficiently close to our clock we will
* trust Expires: relative to our own clock.
*/
if (h_expires < now)
*ttl = 0;
else
*ttl = h_expires - now;
break;
} else {
/*
* But even if the clocks are out of whack we can still
* derive a relative time from the two headers.
* (the negative ttl case is caught above)
*/
*ttl = (int)(h_expires - h_date);
}
}
/*
* RFC5861 outlines a way to control the use of stale responses.
* We use this to initialize the grace period.
*/
if (*ttl >= 0 && http_GetHdrField(hp, H_Cache_Control,
"stale-while-revalidate", &p) && p != NULL) {
if (*p == '-')
*grace = 0;
else
*grace = strtoul(p, NULL, 0);
}
VSLb(bo->vsl, SLT_TTL,
"RFC %.0f %.0f %.0f %.0f %.0f %.0f %.0f %u",
*ttl, *grace, -1., now,
*t_origin, h_date, h_expires, max_age);
}
