void
Req_Rollback(struct req *req)
{
VCL_TaskLeave(req->vcl, req->privs);
VCL_TaskEnter(req->vcl, req->privs);
HTTP_Clone(req->http, req->http0);
if (WS_Overflowed(req->ws))
req->wrk->stats->ws_client_overflow++;
WS_Reset(req->ws, req->ws_req);
}
void
VRT_vcl_select(VRT_CTX, VCL_VCL vcl)
{
struct req *req = ctx->req;
CHECK_OBJ_NOTNULL(vcl, VCL_MAGIC);
VCL_TaskLeave(req->vcl, req->privs);
VCL_Rel(&req->vcl);
vcl_get(&req->vcl, vcl);
/* XXX: better logging */
VSLb(ctx->req->vsl, SLT_Debug, "Now using %s VCL", vcl->loaded_name);
VCL_TaskEnter(req->vcl, req->privs);
}
static void
HTTP1_Session(struct worker *wrk, struct req *req)
{
enum htc_status_e hs;
struct sess *sp;
const char *st;
int i;
CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
sp = req->sp;
CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
/*
* Whenever we come in from the acceptor or waiter, we need to set
* blocking mode. It would be simpler to do this in the acceptor
* or waiter, but we'd rather do the syscall in the worker thread.
*/
if (http1_getstate(sp) == H1NEWREQ)
VTCP_blocking(sp->fd);
req->transport = &HTTP1_transport;
while (1) {
st = http1_getstate(sp);
if (st == H1NEWREQ) {
CHECK_OBJ_NOTNULL(req->transport, TRANSPORT_MAGIC);
assert(isnan(req->t_prev));
assert(isnan(req->t_req));
AZ(req->vcl);
AZ(req->esi_level);
AN(req->htc->ws->r);
hs = HTC_RxStuff(req->htc, HTTP1_Complete,
&req->t_first, &req->t_req,
sp->t_idle + cache_param->timeout_linger,
sp->t_idle + cache_param->timeout_idle,
NAN,
cache_param->http_req_size);
AZ(req->htc->ws->r);
if (hs < HTC_S_EMPTY) {
req->acct.req_hdrbytes +=
req->htc->rxbuf_e - req->htc->rxbuf_b;
Req_Cleanup(sp, wrk, req);
Req_Release(req);
switch (hs) {
case HTC_S_CLOSE:
SES_Delete(sp, SC_REM_CLOSE, NAN);
return;
case HTC_S_TIMEOUT:
SES_Delete(sp, SC_RX_TIMEOUT, NAN);
return;
case HTC_S_OVERFLOW:
SES_Delete(sp, SC_RX_OVERFLOW, NAN);
return;
case HTC_S_EOF:
SES_Delete(sp, SC_REM_CLOSE, NAN);
return;
default:
WRONG("htc_status (bad)");
}
}
if (hs == HTC_S_IDLE) {
wrk->stats->sess_herd++;
Req_Cleanup(sp, wrk, req);
Req_Release(req);
SES_Wait(sp, &HTTP1_transport);
return;
}
if (hs != HTC_S_COMPLETE)
WRONG("htc_status (nonbad)");
if (H2_prism_complete(req->htc) == HTC_S_COMPLETE) {
if (!FEATURE(FEATURE_HTTP2)) {
SES_Close(req->sp, SC_REQ_HTTP20);
AZ(req->ws->r);
AZ(wrk->aws->r);
http1_setstate(sp, H1CLEANUP);
continue;
}
http1_setstate(sp, NULL);
H2_PU_Sess(wrk, sp, req);
return;
}
i = http1_dissect(wrk, req);
req->acct.req_hdrbytes +=
req->htc->rxbuf_e - req->htc->rxbuf_b;
if (i) {
assert(req->doclose > 0);
SES_Close(req->sp, req->doclose);
AZ(req->ws->r);
AZ(wrk->aws->r);
http1_setstate(sp, H1CLEANUP);
continue;
}
if (http_HdrIs(req->http, H_Upgrade, "h2c")) {
if (!FEATURE(FEATURE_HTTP2)) {
VSLb(req->vsl, SLT_Debug,
"H2 upgrade attempt");
} else if (req->htc->body_status != BS_NONE) {
VSLb(req->vsl, SLT_Debug,
"H2 upgrade attempt has body");
} else {
http1_setstate(sp, NULL);
req->err_code = 2;
H2_OU_Sess(wrk, sp, req);
return;
}
}
req->req_step = R_STP_TRANSPORT;
http1_setstate(sp, H1PROC);
} else if (st == H1PROC) {
req->task.func = http1_req;
req->task.priv = req;
wrk->stats->client_req++;
CNT_Embark(wrk, req);
if (req->req_step == R_STP_TRANSPORT)
VCL_TaskEnter(req->vcl, req->privs);
if (CNT_Request(req) == REQ_FSM_DISEMBARK)
return;
AZ(req->vcl0);
req->task.func = NULL;
req->task.priv = NULL;
AZ(req->ws->r);
AZ(wrk->aws->r);
http1_setstate(sp, H1CLEANUP);
} else if (st == H1CLEANUP) {
AZ(wrk->aws->r);
AZ(req->ws->r);
if (sp->fd >= 0 && req->doclose != SC_NULL)
SES_Close(sp, req->doclose);
if (sp->fd < 0) {
wrk->stats->sess_closed++;
Req_Cleanup(sp, wrk, req);
Req_Release(req);
SES_Delete(sp, SC_NULL, NAN);
return;
}
Req_Cleanup(sp, wrk, req);
HTC_RxInit(req->htc, req->ws);
if (req->htc->rxbuf_e != req->htc->rxbuf_b)
wrk->stats->sess_readahead++;
http1_setstate(sp, H1NEWREQ);
} else {
WRONG("Wrong H1 session state");
}
}
}
