void
SES_pool_accept_task(struct worker *wrk, void *arg)
{
struct sesspool *pp;
struct sess *sp;
const char *lsockname;
CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
CAST_OBJ_NOTNULL(pp, arg, SESSPOOL_MAGIC);
/* Turn accepted socket into a session */
AN(wrk->aws->r);
sp = ses_new(pp);
if (sp == NULL) {
VCA_FailSess(wrk);
return;
}
wrk->stats->s_sess++;
sp->t_open = VTIM_real();
sp->t_idle = sp->t_open;
sp->vxid = VXID_Get(wrk, VSL_CLIENTMARKER);
lsockname = VCA_SetupSess(wrk, sp);
ses_vsl_socket(sp, lsockname);
ses_sess_pool_task(wrk, sp);
}
static enum fetch_step
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);
VSLb_ts_busyobj(bo, "Retry", W_TIM_real(wrk));
/* VDI_Finish 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;
// 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);
}
static enum req_fsm_nxt
cnt_restart(struct worker *wrk, struct req *req)
{
unsigned wid, owid;
CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
req->director_hint = NULL;
if (++req->restarts >= cache_param->max_restarts) {
VSLb(req->vsl, SLT_VCL_Error, "Too many restarts");
req->err_code = 503;
req->req_step = R_STP_SYNTH;
} else {
wid = VXID_Get(&wrk->vxid_pool);
// XXX: ReqEnd + ReqAcct ?
VSLb_ts_req(req, "Restart", W_TIM_real(wrk));
VSLb(req->vsl, SLT_Link, "req %u restart", wid);
VSLb(req->vsl, SLT_End, "%s", "");
VSL_Flush(req->vsl, 0);
owid = req->vsl->wid & VSL_IDENTMASK;
req->vsl->wid = wid | VSL_CLIENTMARKER;
VSLb(req->vsl, SLT_Begin, "req %u restart", owid);
VSLb_ts_req(req, "Start", req->t_prev);
req->err_code = 0;
req->req_step = R_STP_RECV;
}
return (REQ_FSM_MORE);
}
static int
http1_dissect(struct worker *wrk, struct req *req)
{
CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
CHECK_OBJ_NOTNULL(req->transport, TRANSPORT_MAGIC);
/* Allocate a new vxid now that we know we'll need it. */
AZ(req->vsl->wid);
req->vsl->wid = VXID_Get(wrk, VSL_CLIENTMARKER);
VSLb(req->vsl, SLT_Begin, "req %u rxreq", VXID(req->sp->vxid));
VSL(SLT_Link, req->sp->vxid, "req %u rxreq", VXID(req->vsl->wid));
AZ(isnan(req->t_first)); /* First byte timestamp set by http1_wait */
AZ(isnan(req->t_req)); /* Complete req rcvd set by http1_wait */
req->t_prev = req->t_first;
VSLb_ts_req(req, "Start", req->t_first);
VSLb_ts_req(req, "Req", req->t_req);
HTTP_Setup(req->http, req->ws, req->vsl, SLT_ReqMethod);
req->err_code = HTTP1_DissectRequest(req->htc, req->http);
/* If we could not even parse the request, just close */
if (req->err_code != 0) {
VSLb(req->vsl, SLT_HttpGarbage, "%.*s",
(int)(req->htc->rxbuf_e - req->htc->rxbuf_b),
req->htc->rxbuf_b);
wrk->stats->client_req_400++;
req->doclose = SC_RX_JUNK;
http1_abort(req, 400);
return (-1);
}
assert (req->req_body_status == REQ_BODY_INIT);
switch (req->htc->body_status) {
case BS_CHUNKED:
req->req_body_status = REQ_BODY_WITHOUT_LEN;
break;
case BS_LENGTH:
req->req_body_status = REQ_BODY_WITH_LEN;
break;
case BS_NONE:
req->req_body_status = REQ_BODY_NONE;
break;
case BS_EOF:
req->req_body_status = REQ_BODY_WITHOUT_LEN;
break;
default:
WRONG("Unknown req_body_status situation");
}
return (0);
}
static enum fetch_step
vbf_stp_retry(struct worker *wrk, struct busyobj *bo)
{
CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
VSLb_ts_busyobj(bo, "Retry", W_TIM_real(wrk));
// XXX: BereqEnd + BereqAcct ?
VSL_ChgId(bo->vsl, "bereq", "retry", VXID_Get(wrk, VSL_BACKENDMARKER));
VSLb_ts_busyobj(bo, "Start", bo->t_prev);
return (F_STP_STARTFETCH);
}
static enum fetch_step
vbf_stp_retry(struct worker *wrk, struct busyobj *bo)
{
unsigned owid, wid;
CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
VSLb_ts_busyobj(bo, "Retry", W_TIM_real(wrk));
// XXX: BereqEnd + BereqAcct ?
wid = VXID_Get(&wrk->vxid_pool);
VSLb(bo->vsl, SLT_Link, "bereq %u retry", wid);
VSLb(bo->vsl, SLT_End, "%s", "");
VSL_Flush(bo->vsl, 0);
owid = bo->vsl->wid & VSL_IDENTMASK;
bo->vsl->wid = wid | VSL_BACKENDMARKER;
VSLb(bo->vsl, SLT_Begin, "bereq %u retry", owid);
VSLb_ts_busyobj(bo, "Start", bo->t_prev);
return (F_STP_STARTFETCH);
}
static enum req_fsm_nxt
cnt_restart(struct worker *wrk, struct req *req)
{
CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
req->director_hint = NULL;
if (++req->restarts >= cache_param->max_restarts) {
VSLb(req->vsl, SLT_VCL_Error, "Too many restarts");
req->err_code = 503;
req->req_step = R_STP_SYNTH;
} else {
// XXX: ReqEnd + ReqAcct ?
VSLb_ts_req(req, "Restart", W_TIM_real(wrk));
VSL_ChgId(req->vsl, "req", "restart",
VXID_Get(wrk, VSL_CLIENTMARKER));
VSLb_ts_req(req, "Start", req->t_prev);
req->err_code = 0;
req->req_step = R_STP_RECV;
}
return (REQ_FSM_MORE);
}
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);
}
struct busyobj *
VBO_GetBusyObj(struct worker *wrk, const struct req *req)
{
struct busyobj *bo = NULL;
uint16_t nhttp;
unsigned sz;
char *p;
CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
if (wrk->nbo != NULL) {
bo = wrk->nbo;
wrk->nbo = NULL;
}
if (bo == NULL)
bo = vbo_New();
CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
AZ(bo->refcount);
bo->refcount = 1;
p = (void*)(bo + 1);
p = (void*)PRNDUP(p);
assert(p < bo->end);
nhttp = (uint16_t)cache_param->http_max_hdr;
sz = HTTP_estimate(nhttp);
bo->bereq0 = HTTP_create(p, nhttp);
p += sz;
p = (void*)PRNDUP(p);
assert(p < bo->end);
bo->bereq = HTTP_create(p, nhttp);
p += sz;
p = (void*)PRNDUP(p);
assert(p < bo->end);
bo->beresp = HTTP_create(p, nhttp);
p += sz;
p = (void*)PRNDUP(p);
assert(p < bo->end);
sz = cache_param->vsl_buffer;
VSL_Setup(bo->vsl, p, sz);
bo->vsl->wid = VXID_Get(wrk, VSL_BACKENDMARKER);
p += sz;
p = (void*)PRNDUP(p);
assert(p < bo->end);
WS_Init(bo->ws, "bo", p, bo->end - p);
bo->do_stream = 1;
bo->director = req->director_hint;
bo->vcl = req->vcl;
VCL_Ref(bo->vcl);
bo->t_first = bo->t_prev = NAN;
bo->content_length = -1;
bo->doclose = SC_NULL;
return (bo);
}
struct busyobj *
VBO_GetBusyObj(struct worker *wrk, struct req *req)
{
struct busyobj *bo = NULL;
uint16_t nhttp;
unsigned sz;
char *p;
CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
if (wrk->nbo != NULL) {
bo = wrk->nbo;
wrk->nbo = NULL;
}
if (bo == NULL)
bo = vbo_New();
CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
AZ(bo->refcount);
bo->refcount = 1;
p = (void*)(bo + 1);
p = (void*)PRNDUP(p);
assert(p < bo->end);
nhttp = (uint16_t)cache_param->http_max_hdr;
sz = HTTP_estimate(nhttp);
bo->bereq0 = HTTP_create(p, nhttp);
p += sz;
p = (void*)PRNDUP(p);
assert(p < bo->end);
bo->bereq = HTTP_create(p, nhttp);
p += sz;
p = (void*)PRNDUP(p);
assert(p < bo->end);
bo->beresp = HTTP_create(p, nhttp);
p += sz;
p = (void*)PRNDUP(p);
assert(p < bo->end);
sz = cache_param->vsl_buffer;
VSL_Setup(bo->vsl, p, sz);
bo->vsl->wid = VXID_Get(&wrk->vxid_pool) | VSL_BACKENDMARKER;
VSLb(bo->vsl, SLT_Begin, "bereq %u", req->vsl->wid & VSL_IDENTMASK);
VSLb(req->vsl, SLT_Link, "bereq %u", bo->vsl->wid & VSL_IDENTMASK);
p += sz;
p = (void*)PRNDUP(p);
assert(p < bo->end);
WS_Init(bo->ws, "bo", p, bo->end - p);
bo->do_stream = 1;
bo->director = req->director;
bo->vcl = req->vcl;
VCL_Ref(bo->vcl);
bo->t_fetch = req->t_req;
return (bo);
}
static int
http1_dissect(struct worker *wrk, struct req *req)
{
const char *r_100 = "HTTP/1.1 100 Continue\r\n\r\n";
const char *r_400 = "HTTP/1.1 400 Bad Request\r\n\r\n";
const char *r_417 = "HTTP/1.1 417 Expectation Failed\r\n\r\n";
const char *p;
ssize_t r;
CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
/* Allocate a new vxid now that we know we'll need it. */
AZ(req->vsl->wid);
req->vsl->wid = VXID_Get(wrk, VSL_CLIENTMARKER);
VSLb(req->vsl, SLT_Begin, "req %u rxreq", VXID(req->sp->vxid));
VSL(SLT_Link, req->sp->vxid, "req %u rxreq", VXID(req->vsl->wid));
AZ(isnan(req->t_first)); /* First byte timestamp set by http1_wait */
AZ(isnan(req->t_req)); /* Complete req rcvd set by http1_wait */
req->t_prev = req->t_first;
VSLb_ts_req(req, "Start", req->t_first);
VSLb_ts_req(req, "Req", req->t_req);
/* Borrow VCL reference from worker thread */
VCL_Refresh(&wrk->vcl);
req->vcl = wrk->vcl;
wrk->vcl = NULL;
HTTP_Setup(req->http, req->ws, req->vsl, SLT_ReqMethod);
req->err_code = HTTP1_DissectRequest(req->htc, req->http);
/* If we could not even parse the request, just close */
if (req->err_code != 0) {
VSLb(req->vsl, SLT_HttpGarbage, "%.*s",
(int)(req->htc->rxbuf_e - req->htc->rxbuf_b),
req->htc->rxbuf_b);
wrk->stats->client_req_400++;
r = write(req->sp->fd, r_400, strlen(r_400));
if (r > 0)
req->acct.resp_hdrbytes += r;
req->doclose = SC_RX_JUNK;
return (-1);
}
assert (req->req_body_status == REQ_BODY_INIT);
if (req->htc->body_status == BS_CHUNKED) {
req->req_body_status = REQ_BODY_WITHOUT_LEN;
} else if (req->htc->body_status == BS_LENGTH) {
req->req_body_status = REQ_BODY_WITH_LEN;
} else if (req->htc->body_status == BS_NONE) {
req->req_body_status = REQ_BODY_NONE;
} else if (req->htc->body_status == BS_EOF) {
req->req_body_status = REQ_BODY_WITHOUT_LEN;
} else {
WRONG("Unknown req.body_length situation");
}
if (http_GetHdr(req->http, H_Expect, &p)) {
if (strcasecmp(p, "100-continue")) {
wrk->stats->client_req_417++;
req->err_code = 417;
r = write(req->sp->fd, r_417, strlen(r_417));
if (r > 0)
req->acct.resp_hdrbytes += r;
req->doclose = SC_RX_JUNK;
return (-1);
}
r = write(req->sp->fd, r_100, strlen(r_100));
if (r > 0)
req->acct.resp_hdrbytes += r;
if (r != strlen(r_100)) {
req->doclose = SC_REM_CLOSE;
return (-1);
}
http_Unset(req->http, H_Expect);
}
wrk->stats->client_req++;
wrk->stats->s_req++;
AZ(req->err_code);
req->ws_req = WS_Snapshot(req->ws);
req->doclose = http_DoConnection(req->http);
if (req->doclose == SC_RX_BAD) {
r = write(req->sp->fd, r_400, strlen(r_400));
if (r > 0)
req->acct.resp_hdrbytes += r;
return (-1);
}
assert(req->req_body_status != REQ_BODY_INIT);
HTTP_Copy(req->http0, req->http); // For ESI & restart
return (0);
}
struct req *
SES_GetReq(struct worker *wrk, struct sess *sp)
{
struct sesspool *pp;
struct req *req;
uint16_t nhttp;
unsigned sz, hl;
char *p, *e;
CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
pp = sp->sesspool;
CHECK_OBJ_NOTNULL(pp, SESSPOOL_MAGIC);
AN(pp->pool);
req = MPL_Get(pp->mpl_req, &sz);
AN(req);
req->magic = REQ_MAGIC;
req->sp = sp;
e = (char*)req + sz;
p = (char*)(req + 1);
p = (void*)PRNDUP(p);
assert(p < e);
nhttp = (uint16_t)cache_param->http_max_hdr;
hl = HTTP_estimate(nhttp);
req->http = HTTP_create(p, nhttp);
p += hl;
p = (void*)PRNDUP(p);
assert(p < e);
req->http0 = HTTP_create(p, nhttp);
p += hl;
p = (void*)PRNDUP(p);
assert(p < e);
req->resp = HTTP_create(p, nhttp);
p += hl;
p = (void*)PRNDUP(p);
assert(p < e);
sz = cache_param->vsl_buffer;
VSL_Setup(req->vsl, p, sz);
req->vsl->wid = VXID_Get(&wrk->vxid_pool) | VSL_CLIENTMARKER;
VSLb(req->vsl, SLT_Begin, "req %u", sp->vxid & VSL_IDENTMASK);
VSL(SLT_Link, req->sp->vxid, "req %u", req->vsl->wid & VSL_IDENTMASK);
p += sz;
p = (void*)PRNDUP(p);
assert(p < e);
WS_Init(req->ws, "req", p, e - p);
req->t_req = NAN;
req->t_resp = NAN;
VTAILQ_INIT(&req->body);
return (req);
}
