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);
}
static int
vbf_beresp2obj(struct busyobj *bo)
{
unsigned l, l2;
const char *b;
uint8_t *bp;
struct vsb *vary = NULL;
int varyl = 0;
l = 0;
/* Create Vary instructions */
if (!(bo->fetch_objcore->flags & OC_F_PRIVATE)) {
varyl = VRY_Create(bo, &vary);
if (varyl > 0) {
AN(vary);
assert(varyl == VSB_len(vary));
l += PRNDUP((intptr_t)varyl);
} else if (varyl < 0) {
/*
* Vary parse error
* Complain about it, and make this a pass.
*/
VSLb(bo->vsl, SLT_Error,
"Illegal 'Vary' header from backend, "
"making this a pass.");
bo->uncacheable = 1;
AZ(vary);
} else
/* No vary */
AZ(vary);
}
l2 = http_EstimateWS(bo->beresp,
bo->uncacheable ? HTTPH_R_PASS : HTTPH_A_INS);
l += l2;
if (bo->uncacheable)
bo->fetch_objcore->flags |= OC_F_PASS;
if (!vbf_allocobj(bo, l))
return (-1);
if (vary != NULL) {
b = ObjSetattr(bo->wrk, bo->fetch_objcore, OA_VARY, varyl,
VSB_data(vary));
VSB_delete(vary);
}
AZ(ObjSetU32(bo->wrk, bo->fetch_objcore, OA_VXID, VXID(bo->vsl->wid)));
/* for HTTP_Encode() VSLH call */
bo->beresp->logtag = SLT_ObjMethod;
/* Filter into object */
bp = ObjSetattr(bo->wrk, bo->fetch_objcore, OA_HEADERS, l2, NULL);
AN(bp);
HTTP_Encode(bo->beresp, bp, l2,
bo->uncacheable ? HTTPH_R_PASS : HTTPH_A_INS);
if (http_GetHdr(bo->beresp, H_Last_Modified, &b))
AZ(ObjSetDouble(bo->wrk, bo->fetch_objcore, OA_LASTMODIFIED,
VTIM_parse(b)));
else
AZ(ObjSetDouble(bo->wrk, bo->fetch_objcore, OA_LASTMODIFIED,
floor(bo->fetch_objcore->exp.t_origin)));
return (0);
}
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);
}
struct req *
SES_GetReq(const 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);
p += sz;
p = (void*)PRNDUP(p);
assert(p < e);
WS_Init(req->ws, "req", p, e - p);
req->req_bodybytes = 0;
req->resp_hdrbytes = 0;
req->resp_bodybytes = 0;
req->t_first = NAN;
req->t_prev = NAN;
req->t_req = NAN;
return (req);
}
struct req *
Req_New(const struct worker *wrk, struct sess *sp)
{
struct pool *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->pool;
CHECK_OBJ_NOTNULL(pp, POOL_MAGIC);
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, hl);
p += hl;
p = (void*)PRNDUP(p);
assert(p < e);
req->http0 = HTTP_create(p, nhttp, hl);
p += hl;
p = (void*)PRNDUP(p);
assert(p < e);
req->resp = HTTP_create(p, nhttp, hl);
p += hl;
p = (void*)PRNDUP(p);
assert(p < e);
sz = cache_param->vsl_buffer;
VSL_Setup(req->vsl, p, sz);
p += sz;
p = (void*)PRNDUP(p);
req->vfc = (void*)p;
INIT_OBJ(req->vfc, VFP_CTX_MAGIC);
p = (void*)PRNDUP(p + sizeof(*req->vfc));
req->htc = (void*)p;
p = (void*)PRNDUP(p + sizeof(*req->htc));
req->vdc = (void*)p;
INIT_OBJ(req->vdc, VDP_CTX_MAGIC);
VTAILQ_INIT(&req->vdc->vdp);
p = (void*)PRNDUP(p + sizeof(*req->vdc));
req->htc = (void*)p;
INIT_OBJ(req->htc, HTTP_CONN_MAGIC);
p = (void*)PRNDUP(p + sizeof(*req->htc));
assert(p < e);
WS_Init(req->ws, "req", p, e - p);
req->t_first = NAN;
req->t_prev = NAN;
req->t_req = NAN;
req->topreq = req;
return (req);
}
void *
VSMW_Allocv(struct vsmw *vsmw, struct vsmw_cluster *vc,
const char *class, size_t payload,
const char *fmt, va_list va)
{
struct vsmwseg *seg;
vsmw_lock();
CHECK_OBJ_NOTNULL(vsmw, VSMW_MAGIC);
(void)vc;
ALLOC_OBJ(seg, VSMWSEG_MAGIC);
AN(seg);
REPLACE(seg->class, class);
seg->len = PRNDUP(payload);
VSB_clear(vsmw->vsb);
VSB_vprintf(vsmw->vsb, fmt, va);
AZ(VSB_finish(vsmw->vsb));
REPLACE(seg->id, VSB_data(vsmw->vsb));
if (vc == NULL)
vc = vsmw_newcluster(vsmw, seg->len, class);
AN(vc);
vc->refs++;
seg->cluster = vc;
seg->off = vc->next;
vc->next += seg->len;
assert(vc->next <= vc->len);
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);
}