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.
* On systems which return errors for ioctl, we close early
*/
if (http1_getstate(sp) == H1NEWREQ && VTCP_blocking(sp->fd)) {
if (errno == ECONNRESET)
SES_Close(sp, SC_REM_CLOSE);
else
SES_Close(sp, SC_TX_ERROR);
AN(Req_Cleanup(sp, wrk, req));
return;
}
while (1) {
st = http1_getstate(sp);
if (st == H1NEWREQ) {
assert(isnan(req->t_prev));
assert(isnan(req->t_req));
AZ(req->vcl);
AZ(req->esi_level);
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,
cache_param->http_req_size);
XXXAZ(req->htc->ws->r);
if (hs < HTC_S_EMPTY) {
req->acct.req_hdrbytes +=
req->htc->rxbuf_e - req->htc->rxbuf_b;
CNT_AcctLogCharge(wrk->stats, 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_Release(req);
SES_Wait(sp, &HTTP1_transport);
return;
}
if (hs != HTC_S_COMPLETE)
WRONG("htc_status (nonbad)");
i = http1_dissect(wrk, req);
req->acct.req_hdrbytes +=
req->htc->rxbuf_e - req->htc->rxbuf_b;
if (i) {
SES_Close(req->sp, req->doclose);
http1_setstate(sp, H1CLEANUP);
} else {
req->req_step = R_STP_RECV;
http1_setstate(sp, H1PROC);
}
} else if (st == H1BUSY) {
/*
* Return from waitinglist.
* Check to see if the remote has left.
*/
if (VTCP_check_hup(sp->fd)) {
AN(req->hash_objhead);
(void)HSH_DerefObjHead(wrk, &req->hash_objhead);
AZ(req->hash_objhead);
SES_Close(sp, SC_REM_CLOSE);
AN(Req_Cleanup(sp, wrk, req));
return;
}
http1_setstate(sp, H1PROC);
} else if (st == H1PROC) {
req->transport = &HTTP1_transport;
if (CNT_Request(wrk, req) == REQ_FSM_DISEMBARK) {
req->task.func = http1_req;
req->task.priv = req;
http1_setstate(sp, H1BUSY);
return;
}
req->transport = NULL;
http1_setstate(sp, H1CLEANUP);
} else if (st == H1CLEANUP) {
if (Req_Cleanup(sp, wrk, req))
return;
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");
}
}
}
void
HTTP1_Session(struct worker *wrk, struct req *req)
{
enum req_fsm_nxt nxt = REQ_FSM_MORE;
struct sess *sp;
enum http1_cleanup_ret sdr;
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.
* On systems which return errors for ioctl, we close early
*/
if (sp->sess_step == S_STP_NEWREQ && VTCP_blocking(sp->fd)) {
if (errno == ECONNRESET)
SES_Close(sp, SC_REM_CLOSE);
else
SES_Close(sp, SC_TX_ERROR);
sdr = http1_cleanup(sp, wrk, req);
assert(sdr == SESS_DONE_RET_GONE);
return;
}
/*
* Return from waitinglist. Check to see if the remote has left.
*/
if (req->req_step == R_STP_LOOKUP && VTCP_check_hup(sp->fd)) {
AN(req->hash_objhead);
(void)HSH_DerefObjHead(wrk, &req->hash_objhead);
AZ(req->hash_objhead);
SES_Close(sp, SC_REM_CLOSE);
sdr = http1_cleanup(sp, wrk, req);
assert(sdr == SESS_DONE_RET_GONE);
return;
}
if (sp->sess_step == S_STP_NEWREQ) {
HTTP1_Init(req->htc, req->ws, sp->fd, req->vsl,
cache_param->http_req_size,
cache_param->http_req_hdr_len);
}
while (1) {
assert(
sp->sess_step == S_STP_NEWREQ ||
req->req_step == R_STP_LOOKUP ||
req->req_step == R_STP_RECV);
if (sp->sess_step == S_STP_WORKING) {
if (req->req_step == R_STP_RECV)
nxt = http1_dissect(wrk, req);
if (nxt == REQ_FSM_MORE)
nxt = CNT_Request(wrk, req);
if (nxt == REQ_FSM_DISEMBARK)
return;
assert(nxt == REQ_FSM_DONE);
sdr = http1_cleanup(sp, wrk, req);
switch (sdr) {
case SESS_DONE_RET_GONE:
return;
case SESS_DONE_RET_WAIT:
sp->sess_step = S_STP_NEWREQ;
break;
case SESS_DONE_RET_START:
sp->sess_step = S_STP_WORKING;
req->req_step = R_STP_RECV;
break;
default:
WRONG("Illegal enum http1_cleanup_ret");
}
}
if (sp->sess_step == S_STP_NEWREQ) {
nxt = http1_wait(sp, wrk, req);
if (nxt != REQ_FSM_MORE)
return;
sp->sess_step = S_STP_WORKING;
req->req_step = R_STP_RECV;
}
}
}
