static enum fetch_step
vbf_stp_mkbereq(struct worker *wrk, struct busyobj *bo)
{
const char *q;
CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
CHECK_OBJ_NOTNULL(bo->req, REQ_MAGIC);
assert(bo->fetch_objcore->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->do_pass ? HTTPH_R_PASS : HTTPH_R_FETCH);
if (!bo->do_pass) {
http_ForceField(bo->bereq0, HTTP_HDR_METHOD, "GET");
http_ForceField(bo->bereq0, HTTP_HDR_PROTO, "HTTP/1.1");
if (cache_param->http_gzip_support)
http_ForceHeader(bo->bereq0, H_Accept_Encoding, "gzip");
} else {
AZ(bo->stale_oc);
if (bo->bereq0->protover > 11)
http_ForceField(bo->bereq0, HTTP_HDR_PROTO, "HTTP/1.1");
}
http_CopyHome(bo->bereq0);
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_PASS);
q = HTTP_GetHdrPack(bo->wrk, bo->stale_oc, H_Last_Modified);
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_Setup(bo->bereq, bo->ws, bo->vsl, SLT_BereqMethod);
bo->ws_bo = WS_Snapshot(bo->ws);
HTTP_Copy(bo->bereq, bo->bereq0);
if (bo->req->req_body_status == REQ_BODY_NONE) {
bo->req = NULL;
ObjSetState(bo->wrk, bo->fetch_objcore, BOS_REQ_DONE);
}
return (F_STP_STARTFETCH);
}
static enum fetch_step
vbf_stp_mkbereq(const struct worker *wrk, struct busyobj *bo)
{
const char *q;
CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
CHECK_OBJ_NOTNULL(bo->req, REQ_MAGIC);
assert(bo->state == BOS_INVALID);
AZ(bo->storage_hint);
HTTP_Setup(bo->bereq0, bo->ws, bo->vsl, SLT_BereqMethod);
http_FilterReq(bo->bereq0, bo->req->http,
bo->do_pass ? HTTPH_R_PASS : HTTPH_R_FETCH);
if (!bo->do_pass) {
http_ForceField(bo->bereq0, HTTP_HDR_METHOD, "GET");
http_ForceField(bo->bereq0, HTTP_HDR_PROTO, "HTTP/1.1");
if (cache_param->http_gzip_support)
http_ForceHeader(bo->bereq0, H_Accept_Encoding, "gzip");
AN(bo->req);
bo->req = NULL;
http_CopyHome(bo->bereq0);
} else
AZ(bo->stale_oc);
if (bo->stale_oc != NULL) {
q = HTTP_GetHdrPack(bo->wrk, bo->stale_oc, H_Last_Modified);
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_Setup(bo->bereq, bo->ws, bo->vsl, SLT_BereqMethod);
bo->ws_bo = WS_Snapshot(bo->ws);
HTTP_Copy(bo->bereq, bo->bereq0);
VBO_setstate(bo, BOS_REQ_DONE);
return (F_STP_STARTFETCH);
}
static enum fetch_step
vbf_stp_mkbereq(const struct worker *wrk, struct busyobj *bo)
{
char *p;
CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
CHECK_OBJ_NOTNULL(bo->req, REQ_MAGIC);
assert(bo->state == BOS_INVALID);
AZ(bo->vbc);
assert(bo->doclose == SC_NULL);
AZ(bo->storage_hint);
HTTP_Setup(bo->bereq0, bo->ws, bo->vsl, SLT_BereqMethod);
http_FilterReq(bo->bereq0, bo->req->http,
bo->do_pass ? HTTPH_R_PASS : HTTPH_R_FETCH);
if (!bo->do_pass) {
http_ForceField(bo->bereq0, HTTP_HDR_METHOD, "GET");
http_ForceField(bo->bereq0, HTTP_HDR_PROTO, "HTTP/1.1");
if (cache_param->http_gzip_support)
http_ForceHeader(bo->bereq0, H_Accept_Encoding, "gzip");
AN(bo->req);
bo->req = NULL;
http_CopyHome(bo->bereq0);
}
if (bo->ims_obj != NULL && bo->ims_obj->http->status == 200) {
if (http_GetHdr(bo->ims_obj->http, H_Last_Modified, &p)) {
http_PrintfHeader(bo->bereq0,
"If-Modified-Since: %s", p);
}
if (http_GetHdr(bo->ims_obj->http, H_ETag, &p)) {
http_PrintfHeader(bo->bereq0,
"If-None-Match: %s", p);
}
}
VBO_setstate(bo, BOS_REQ_DONE);
return (F_STP_STARTFETCH);
}
static void
ved_include(struct req *preq, const char *src, const char *host,
struct ecx *ecx)
{
struct worker *wrk;
struct req *req;
enum req_fsm_nxt s;
struct transport xp;
CHECK_OBJ_NOTNULL(preq, REQ_MAGIC);
CHECK_OBJ_NOTNULL(ecx, ECX_MAGIC);
wrk = preq->wrk;
if (preq->esi_level >= cache_param->max_esi_depth)
return;
req = Req_New(wrk, preq->sp);
req->req_body_status = REQ_BODY_NONE;
AZ(req->vsl->wid);
req->vsl->wid = VXID_Get(wrk, VSL_CLIENTMARKER);
VSLb(req->vsl, SLT_Begin, "req %u esi", VXID(preq->vsl->wid));
VSLb(preq->vsl, SLT_Link, "req %u esi", VXID(req->vsl->wid));
req->esi_level = preq->esi_level + 1;
if (preq->esi_level == 0)
assert(preq->top == preq);
else
CHECK_OBJ_NOTNULL(preq->top, REQ_MAGIC);
req->top = preq->top;
HTTP_Copy(req->http0, preq->http0);
req->http0->ws = req->ws;
req->http0->vsl = req->vsl;
req->http0->logtag = SLT_ReqMethod;
req->http0->conds = 0;
http_SetH(req->http0, HTTP_HDR_URL, src);
if (host != NULL && *host != '\0') {
http_Unset(req->http0, H_Host);
http_SetHeader(req->http0, host);
}
http_ForceField(req->http0, HTTP_HDR_METHOD, "GET");
http_ForceField(req->http0, HTTP_HDR_PROTO, "HTTP/1.1");
/* Don't allow conditionalss, we can't use a 304 */
http_Unset(req->http0, H_If_Modified_Since);
http_Unset(req->http0, H_If_None_Match);
/* Don't allow Range */
http_Unset(req->http0, H_Range);
/* Set Accept-Encoding according to what we want */
http_Unset(req->http0, H_Accept_Encoding);
if (ecx->isgzip)
http_ForceHeader(req->http0, H_Accept_Encoding, "gzip");
/* Client content already taken care of */
http_Unset(req->http0, H_Content_Length);
/* Reset request to status before we started messing with it */
HTTP_Copy(req->http, req->http0);
req->vcl = preq->vcl;
preq->vcl = NULL;
req->wrk = preq->wrk;
/*
* XXX: We should decide if we should cache the director
* XXX: or not (for session/backend coupling). Until then
* XXX: make sure we don't trip up the check in vcl_recv.
*/
req->req_step = R_STP_RECV;
req->t_req = preq->t_req;
assert(isnan(req->t_first));
assert(isnan(req->t_prev));
INIT_OBJ(&xp, TRANSPORT_MAGIC);
xp.deliver = VED_Deliver;
req->transport = &xp;
req->transport_priv = ecx;
THR_SetRequest(req);
VSLb_ts_req(req, "Start", W_TIM_real(wrk));
req->ws_req = WS_Snapshot(req->ws);
while (1) {
req->wrk = wrk;
s = CNT_Request(wrk, req);
if (s == REQ_FSM_DONE)
break;
DSL(DBG_WAITINGLIST, req->vsl->wid,
"loop waiting for ESI (%d)", (int)s);
assert(s == REQ_FSM_DISEMBARK);
AZ(req->wrk);
(void)usleep(10000);
}
VRTPRIV_dynamic_kill(req->sp->privs, (uintptr_t)req);
CNT_AcctLogCharge(wrk->stats, req);
VSL_End(req->vsl);
preq->vcl = req->vcl;
req->vcl = NULL;
req->wrk = NULL;
THR_SetRequest(preq);
Req_Release(req);
}
static enum req_fsm_nxt
cnt_deliver(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);
CHECK_OBJ_NOTNULL(req->objcore->objhead, OBJHEAD_MAGIC);
AN(req->vcl);
assert(req->objcore->refcnt > 0);
ObjTouch(req->wrk, req->objcore, req->t_prev);
HTTP_Setup(req->resp, req->ws, req->vsl, SLT_RespMethod);
if (HTTP_Decode(req->resp,
ObjGetAttr(req->wrk, req->objcore, OA_HEADERS, NULL))) {
req->err_code = 500;
req->req_step = R_STP_SYNTH;
return (REQ_FSM_MORE);
}
http_ForceField(req->resp, HTTP_HDR_PROTO, "HTTP/1.1");
if (req->is_hit)
http_PrintfHeader(req->resp,
"X-Varnish: %u %u", VXID(req->vsl->wid),
ObjGetXID(wrk, req->objcore));
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->objcore->t_origin));
http_SetHeader(req->resp, "Via: 1.1 varnish-v4");
if (cache_param->http_gzip_support &&
ObjCheckFlag(req->wrk, req->objcore, OF_GZIPED) &&
!RFC2616_Req_Gzip(req->http))
RFC2616_Weaken_Etag(req->resp);
VCL_deliver_method(req->vcl, wrk, req, NULL, NULL);
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_DerefObjCore(wrk, &req->objcore);
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:
WRONG("Illegal return from vcl_deliver{}");
}
return (REQ_FSM_MORE);
}
assert(wrk->handling == VCL_RET_DELIVER);
if (!(req->objcore->flags & OC_F_PASS)
&& req->esi_level == 0
&& http_IsStatus(req->resp, 200)
&& req->http->conds && RFC2616_Do_Cond(req))
http_PutResponse(req->resp, "HTTP/1.1", 304, NULL);
req->req_step = R_STP_TRANSMIT;
return (REQ_FSM_MORE);
}
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->objcore, OBJCORE_MAGIC);
CHECK_OBJ_NOTNULL(req->objcore->objhead, OBJHEAD_MAGIC);
AN(req->vcl);
assert(req->objcore->refcnt > 0);
if (req->objcore->exp_flags & OC_EF_EXP)
EXP_Touch(req->objcore, req->t_prev);
HTTP_Setup(req->resp, req->ws, req->vsl, SLT_RespMethod);
AZ(HTTP_Decode(req->resp,
ObjGetattr(req->wrk, req->objcore, OA_HEADERS, NULL)));
http_ForceField(req->resp, HTTP_HDR_PROTO, "HTTP/1.1");
if (req->is_hit)
http_PrintfHeader(req->resp,
"X-Varnish: %u %u", VXID(req->vsl->wid),
ObjGetXID(wrk, req->objcore));
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->objcore->exp.t_origin));
http_SetHeader(req->resp, "Via: 1.1 varnish-v4");
if (cache_param->http_gzip_support &&
ObjCheckFlag(req->wrk, req->objcore, OF_GZIPED) &&
!RFC2616_Req_Gzip(req->http))
RFC2616_Weaken_Etag(req->resp);
VCL_deliver_method(req->vcl, wrk, req, NULL, NULL);
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_DerefObjCore(wrk, &req->objcore);
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->objcore->flags & OC_F_PASS)
&& req->esi_level == 0
&& http_IsStatus(req->resp, 200)
&& req->http->conds && RFC2616_Do_Cond(req))
http_PutResponse(req->resp, "HTTP/1.1", 304, NULL);
/* Grab a ref to the bo if there is one, and hand it down */
bo = HSH_RefBusy(req->objcore);
if (bo != NULL) {
if (req->esi_level == 0 && bo->state == BOS_FINISHED) {
VBO_DerefBusyObj(wrk, &bo);
} else if (!bo->do_stream) {
VBO_waitstate(bo, BOS_FINISHED);
VBO_DerefBusyObj(wrk, &bo);
}
}
cnt_vdp(req, bo);
if (bo != NULL)
VBO_DerefBusyObj(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->objcore->flags & OC_F_PASS) && bo != NULL) {
VBO_waitstate(bo, BOS_FINISHED);
ObjSlim(wrk, req->objcore);
}
(void)HSH_DerefObjCore(wrk, &req->objcore);
http_Teardown(req->resp);
return (REQ_FSM_DONE);
}
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);
}
