vfp_esi_pull(struct vfp_ctx *vc, struct vfp_entry *vfe, void *p, ssize_t *lp)
{
enum vfp_status vp;
ssize_t d;
struct vef_priv *vef;
CHECK_OBJ_NOTNULL(vc, VFP_CTX_MAGIC);
CHECK_OBJ_NOTNULL(vfe, VFP_ENTRY_MAGIC);
CAST_OBJ_NOTNULL(vef, vfe->priv1, VEF_MAGIC);
AN(p);
AN(lp);
if (DO_DEBUG(DBG_ESI_CHOP)) {
d = (random() & 3) + 1;
if (d < *lp)
*lp = d;
}
vp = VFP_Suck(vc, p, lp);
if (vp != VFP_ERROR && *lp > 0)
VEP_Parse(vef->vep, p, *lp);
if (vp == VFP_END) {
vp = vfp_esi_end(vc, vef, vp);
vfe->priv1 = NULL;
}
return (vp);
}
vfp_gzip_pull(struct vfp_ctx *vc, struct vfp_entry *vfe, void *p,
ssize_t *lp)
{
ssize_t l;
struct vgz *vg;
enum vgzret_e vr = VGZ_ERROR;
const void *dp;
ssize_t dl;
enum vfp_status vp = VFP_ERROR;
CHECK_OBJ_NOTNULL(vc, VFP_CTX_MAGIC);
CHECK_OBJ_NOTNULL(vfe, VFP_ENTRY_MAGIC);
CAST_OBJ_NOTNULL(vg, vfe->priv1, VGZ_MAGIC);
AN(p);
AN(lp);
l = *lp;
*lp = 0;
VGZ_Obuf(vg, p, l);
do {
if (VGZ_IbufEmpty(vg)) {
l = vg->m_sz;
vp = VFP_Suck(vc, vg->m_buf, &l);
if (vp == VFP_ERROR)
break;
if (vp == VFP_END)
vg->flag = VGZ_FINISH;
VGZ_Ibuf(vg, vg->m_buf, l);
}
if (!VGZ_IbufEmpty(vg) || vg->flag == VGZ_FINISH) {
vr = VGZ_Gzip(vg, &dp, &dl, vg->flag);
if (vr < VGZ_OK)
return (VFP_Error(vc, "Gzip failed"));
if (dl > 0) {
VGZ_UpdateObj(vc, vg, VUA_UPDATE);
*lp = dl;
assert(dp == p);
return (VFP_OK);
}
}
AN(VGZ_IbufEmpty(vg));
} while (vg->flag != VGZ_FINISH);
if (vr != VGZ_END)
return (VFP_Error(vc, "Gzip failed"));
VGZ_UpdateObj(vc, vg, VUA_END_GZIP);
return (VFP_END);
}
vfp_gunzip_pull(struct vfp_ctx *vc, struct vfp_entry *vfe, void *p,
ssize_t *lp)
{
ssize_t l;
struct vgz *vg;
enum vgzret_e vr = VGZ_ERROR;
const void *dp;
ssize_t dl;
enum vfp_status vp = VFP_OK;
CHECK_OBJ_NOTNULL(vc, VFP_CTX_MAGIC);
CHECK_OBJ_NOTNULL(vfe, VFP_ENTRY_MAGIC);
CAST_OBJ_NOTNULL(vg, vfe->priv1, VGZ_MAGIC);
AN(p);
AN(lp);
l = *lp;
*lp = 0;
VGZ_Obuf(vg, p, l);
do {
if (VGZ_IbufEmpty(vg)) {
l = vg->m_sz;
vp = VFP_Suck(vc, vg->m_buf, &l);
if (vp == VFP_ERROR)
return (vp);
VGZ_Ibuf(vg, vg->m_buf, l);
}
if (!VGZ_IbufEmpty(vg) || vp == VFP_END) {
vr = VGZ_Gunzip(vg, &dp, &dl);
if (vr == VGZ_END && !VGZ_IbufEmpty(vg))
return(VFP_Error(vc, "Junk after gzip data"));
if (vr < VGZ_OK)
return (VFP_Error(vc,
"Invalid Gzip data: %s", vgz_msg(vg)));
if (dl > 0) {
*lp = dl;
assert(dp == p);
return (VFP_OK);
}
}
AN(VGZ_IbufEmpty(vg));
} while (vp == VFP_OK);
if (vr != VGZ_END)
return(VFP_Error(vc, "Gunzip error at the very end"));
return (vp);
}
vfp_esi_gzip_pull(struct vfp_ctx *vc, struct vfp_entry *vfe, void *p,
ssize_t *lp)
{
enum vfp_status vp;
ssize_t d, l;
struct vef_priv *vef;
CHECK_OBJ_NOTNULL(vc, VFP_CTX_MAGIC);
CHECK_OBJ_NOTNULL(vfe, VFP_ENTRY_MAGIC);
CAST_OBJ_NOTNULL(vef, vfe->priv1, VEF_MAGIC);
AN(p);
AN(lp);
*lp = 0;
l = vef->ibuf_sz - (vef->ibuf_i - vef->ibuf);
if (DO_DEBUG(DBG_ESI_CHOP)) {
d = (random() & 3) + 1;
if (d < l)
l = d;
}
vp = VFP_Suck(vc, vef->ibuf_i, &l);
if (l > 0) {
VEP_Parse(vef->vep, vef->ibuf_i, l);
vef->ibuf_i += l;
assert(vef->ibuf_o >= vef->ibuf && vef->ibuf_o <= vef->ibuf_i);
if (vef->error) {
errno = vef->error;
return (VFP_ERROR);
}
l = vef->ibuf_i - vef->ibuf_o;
if (l > 0)
memmove(vef->ibuf, vef->ibuf_o, l);
vef->ibuf_o = vef->ibuf;
vef->ibuf_i = vef->ibuf + l;
}
if (vp == VFP_END) {
vp = vfp_esi_end(vc, vef, vp);
vfe->priv1 = NULL;
}
return (vp);
}
vfp_testgunzip_pull(struct vfp_ctx *vc, struct vfp_entry *vfe, void *p,
ssize_t *lp)
{
struct vgz *vg;
enum vgzret_e vr = VGZ_ERROR;
const void *dp;
ssize_t dl;
enum vfp_status vp;
CHECK_OBJ_NOTNULL(vc, VFP_CTX_MAGIC);
CHECK_OBJ_NOTNULL(vfe, VFP_ENTRY_MAGIC);
CAST_OBJ_NOTNULL(vg, vfe->priv1, VGZ_MAGIC);
AN(p);
AN(lp);
CAST_OBJ_NOTNULL(vg, vfe->priv1, VGZ_MAGIC);
vp = VFP_Suck(vc, p, lp);
if (vp == VFP_ERROR)
return (vp);
if (*lp > 0 || vp == VFP_END) {
VGZ_Ibuf(vg, p, *lp);
do {
VGZ_Obuf(vg, vg->m_buf, vg->m_sz);
vr = VGZ_Gunzip(vg, &dp, &dl);
if (vr == VGZ_END && !VGZ_IbufEmpty(vg))
return(VFP_Error(vc, "Junk after gzip data"));
if (vr < VGZ_OK)
return (VFP_Error(vc,
"Invalid Gzip data: %s", vgz_msg(vg)));
} while (!VGZ_IbufEmpty(vg));
}
VGZ_UpdateObj(vc, vg, VUA_UPDATE);
if (vp == VFP_END) {
if (vr != VGZ_END)
return (VFP_Error(vc, "tGunzip failed"));
VGZ_UpdateObj(vc, vg, VUA_END_GUNZIP);
}
return (vp);
}
vfp_testgunzip_pull(struct busyobj *bo, struct vfp_entry *vfe, void *p,
ssize_t *lp)
{
struct vgz *vg;
enum vgzret_e vr = VGZ_ERROR;
const void *dp;
size_t dl;
enum vfp_status vp;
CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
CHECK_OBJ_NOTNULL(vfe, VFP_ENTRY_MAGIC);
CAST_OBJ_NOTNULL(vg, vfe->priv1, VGZ_MAGIC);
AN(p);
AN(lp);
CAST_OBJ_NOTNULL(vg, vfe->priv1, VGZ_MAGIC);
vp = VFP_Suck(bo, p, lp);
if (vp == VFP_ERROR)
return (vp);
if (*lp > 0 || vp == VFP_END) {
VGZ_Ibuf(vg, p, *lp);
do {
VGZ_Obuf(vg, vg->m_buf, vg->m_sz);
vr = VGZ_Gunzip(vg, &dp, &dl);
if (vr == VGZ_END && !VGZ_IbufEmpty(vg))
return(VFP_Error(bo, "Junk after gzip data"));
if (vr < VGZ_OK)
return (VFP_Error(bo,
"Invalid Gzip data: %s", vg->vz.msg));
} while (!VGZ_IbufEmpty(vg));
}
if (vp == VFP_END) {
if (vr != VGZ_END)
return (VFP_Error(bo, "tGunzip failed"));
VGZ_UpdateObj(vg, bo->fetch_obj);
}
return (vp);
}
static enum fetch_step
vbf_stp_fetchbody(struct worker *wrk, struct busyobj *bo)
{
ssize_t l;
uint8_t *ptr;
enum vfp_status vfps = VFP_ERROR;
ssize_t est;
struct vfp_ctx *vfc;
CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
vfc = bo->vfc;
CHECK_OBJ_NOTNULL(vfc, VFP_CTX_MAGIC);
AN(vfc->vfp_nxt);
est = bo->htc->content_length;
if (est < 0)
est = 0;
do {
if (vfc->oc->flags & OC_F_ABANDON) {
/*
* A pass object and delivery was terminated
* We don't fail the fetch, in order for hit-for-pass
* objects to be created.
*/
AN(vfc->oc->flags & OC_F_PASS);
VSLb(wrk->vsl, SLT_Debug,
"Fetch: Pass delivery abandoned");
bo->htc->doclose = SC_RX_BODY;
break;
}
AZ(vfc->failed);
l = est;
assert(l >= 0);
if (VFP_GetStorage(vfc, &l, &ptr) != VFP_OK) {
bo->htc->doclose = SC_RX_BODY;
break;
}
AZ(vfc->failed);
vfps = VFP_Suck(vfc, ptr, &l);
if (l > 0 && vfps != VFP_ERROR) {
bo->acct.beresp_bodybytes += l;
VFP_Extend(vfc, l);
if (est >= l)
est -= l;
else
est = 0;
}
} while (vfps == VFP_OK);
if (vfc->failed) {
(void)VFP_Error(vfc, "Fetch pipeline failed to process");
bo->htc->doclose = SC_RX_BODY;
VFP_Close(vfc);
VDI_Finish(wrk, bo);
if (!bo->do_stream) {
assert(bo->fetch_objcore->boc->state < BOS_STREAM);
// XXX: doclose = ?
return (F_STP_ERROR);
} else {
wrk->stats->fetch_failed++;
return (F_STP_FAIL);
}
}
ObjTrimStore(wrk, vfc->oc);
return (F_STP_FETCHEND);
}
static void
vbf_fetch_body_helper(struct busyobj *bo)
{
ssize_t l;
uint8_t *ptr;
enum vfp_status vfps = VFP_ERROR;
ssize_t est;
struct vfp_ctx *vfc;
CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
vfc = bo->vfc;
CHECK_OBJ_NOTNULL(vfc, VFP_CTX_MAGIC);
AN(vfc->vfp_nxt);
est = bo->htc->content_length;
if (est < 0)
est = 0;
do {
if (bo->abandon) {
/*
* A pass object and delivery was terminated
* We don't fail the fetch, in order for hit-for-pass
* objects to be created.
*/
AN(vfc->oc->flags & OC_F_PASS);
VSLb(vfc->wrk->vsl, SLT_FetchError,
"Pass delivery abandoned");
vfps = VFP_END;
bo->htc->doclose = SC_RX_BODY;
break;
}
AZ(vfc->failed);
l = est;
assert(l >= 0);
if (VFP_GetStorage(vfc, &l, &ptr) != VFP_OK) {
bo->htc->doclose = SC_RX_BODY;
break;
}
AZ(vfc->failed);
vfps = VFP_Suck(vfc, ptr, &l);
if (l > 0 && vfps != VFP_ERROR) {
bo->acct.beresp_bodybytes += l;
VBO_extend(bo, l);
if (est >= l)
est -= l;
else
est = 0;
}
} while (vfps == VFP_OK);
VFP_Close(vfc);
if (vfps == VFP_ERROR) {
AN(vfc->failed);
(void)VFP_Error(vfc, "Fetch pipeline failed to process");
bo->htc->doclose = SC_RX_BODY;
}
if (!bo->do_stream)
ObjTrimStore(bo->wrk, vfc->oc);
}
static ssize_t
vrb_pull(struct req *req, ssize_t maxsize, objiterate_f *func, void *priv)
{
ssize_t l, r = 0, yet;
struct vfp_ctx *vfc;
uint8_t *ptr;
enum vfp_status vfps = VFP_ERROR;
CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
CHECK_OBJ_NOTNULL(req->htc, HTTP_CONN_MAGIC);
CHECK_OBJ_NOTNULL(req->htc->vfc, VFP_CTX_MAGIC);
vfc = req->htc->vfc;
req->body_oc = HSH_Private(req->wrk);
AN(req->body_oc);
XXXAN(STV_NewObject(req->wrk, req->body_oc, TRANSIENT_STORAGE, 8));
vfc->oc = req->body_oc;
if (VFP_Open(vfc) < 0) {
req->req_body_status = REQ_BODY_FAIL;
HSH_DerefBoc(req->wrk, req->body_oc);
AZ(HSH_DerefObjCore(req->wrk, &req->body_oc, 0));
return (-1);
}
AZ(req->req_bodybytes);
AN(req->htc);
yet = req->htc->content_length;
if (yet < 0)
yet = 0;
do {
AZ(vfc->failed);
if (maxsize >= 0 && req->req_bodybytes > maxsize) {
(void)VFP_Error(vfc, "Request body too big to cache");
break;
}
l = yet;
if (VFP_GetStorage(vfc, &l, &ptr) != VFP_OK)
break;
AZ(vfc->failed);
AN(ptr);
AN(l);
vfps = VFP_Suck(vfc, ptr, &l);
if (l > 0 && vfps != VFP_ERROR) {
req->req_bodybytes += l;
req->acct.req_bodybytes += l;
if (yet >= l)
yet -= l;
if (func != NULL) {
r = func(priv, 1, ptr, l);
if (r)
break;
} else {
ObjExtend(req->wrk, req->body_oc, l);
}
}
} while (vfps == VFP_OK);
VFP_Close(vfc);
VSLb_ts_req(req, "ReqBody", VTIM_real());
if (func != NULL) {
HSH_DerefBoc(req->wrk, req->body_oc);
AZ(HSH_DerefObjCore(req->wrk, &req->body_oc, 0));
if (vfps != VFP_END) {
req->req_body_status = REQ_BODY_FAIL;
if (r == 0)
r = -1;
}
return (r);
}
ObjTrimStore(req->wrk, req->body_oc);
AZ(ObjSetU64(req->wrk, req->body_oc, OA_LEN, req->req_bodybytes));
HSH_DerefBoc(req->wrk, req->body_oc);
if (vfps != VFP_END) {
req->req_body_status = REQ_BODY_FAIL;
AZ(HSH_DerefObjCore(req->wrk, &req->body_oc, 0));
return (-1);
}
assert(req->req_bodybytes >= 0);
if (req->req_bodybytes != req->htc->content_length) {
/* We must update also the "pristine" req.* copy */
http_Unset(req->http0, H_Content_Length);
http_Unset(req->http0, H_Transfer_Encoding);
http_PrintfHeader(req->http0, "Content-Length: %ju",
(uintmax_t)req->req_bodybytes);
http_Unset(req->http, H_Content_Length);
http_Unset(req->http, H_Transfer_Encoding);
http_PrintfHeader(req->http, "Content-Length: %ju",
(uintmax_t)req->req_bodybytes);
}
req->req_body_status = REQ_BODY_CACHED;
return (req->req_bodybytes);
}
int
VRB_Iterate(struct req *req, objiterate_f *func, void *priv)
{
char buf[8192];
ssize_t l;
int i;
struct vfp_ctx *vfc;
enum vfp_status vfps = VFP_ERROR;
int ret = 0;
CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
AN(func);
switch(req->req_body_status) {
case REQ_BODY_CACHED:
if (ObjIterate(req->wrk, req->body_oc, priv, func))
return (-1);
return (0);
case REQ_BODY_NONE:
return (0);
case REQ_BODY_WITH_LEN:
case REQ_BODY_WITHOUT_LEN:
break;
case REQ_BODY_TAKEN:
VSLb(req->vsl, SLT_VCL_Error,
"Uncached req.body can only be consumed once.");
return (-1);
case REQ_BODY_FAIL:
VSLb(req->vsl, SLT_FetchError,
"Had failed reading req.body before.");
return (-1);
default:
WRONG("Wrong req_body_status in VRB_IterateReqBody()");
}
Lck_Lock(&req->sp->mtx);
if (req->req_body_status == REQ_BODY_WITH_LEN ||
req->req_body_status == REQ_BODY_WITHOUT_LEN) {
req->req_body_status = REQ_BODY_TAKEN;
i = 0;
} else
i = -1;
Lck_Unlock(&req->sp->mtx);
if (i) {
VSLb(req->vsl, SLT_VCL_Error,
"Multiple attempts to access non-cached req.body");
return (i);
}
CHECK_OBJ_NOTNULL(req->htc, HTTP_CONN_MAGIC);
vfc = req->htc->vfc;
VFP_Setup(vfc);
vfc->http = req->http;
vfc->wrk = req->wrk;
V1F_Setup_Fetch(vfc, req->htc);
if (VFP_Open(vfc) < 0) {
VSLb(req->vsl, SLT_FetchError, "Could not open Fetch Pipeline");
return (-1);
}
do {
l = sizeof buf;
vfps = VFP_Suck(vfc, buf, &l);
if (vfps == VFP_ERROR) {
req->req_body_status = REQ_BODY_FAIL;
ret = -1;
break;
} else if (l > 0) {
req->req_bodybytes += l;
req->acct.req_bodybytes += l;
l = func(priv, 1, buf, l);
if (l) {
req->req_body_status = REQ_BODY_FAIL;
ret = -1;
break;
}
}
} while (vfps == VFP_OK);
VFP_Close(vfc);
VSLb_ts_req(req, "ReqBody", VTIM_real());
return (ret);
}
ssize_t
VRB_Cache(struct req *req, ssize_t maxsize)
{
ssize_t l, yet;
struct vfp_ctx *vfc;
uint8_t *ptr;
enum vfp_status vfps = VFP_ERROR;
CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
assert (req->req_step == R_STP_RECV);
switch(req->req_body_status) {
case REQ_BODY_CACHED:
return (req->req_bodybytes);
case REQ_BODY_FAIL:
return (-1);
case REQ_BODY_NONE:
return (0);
case REQ_BODY_WITHOUT_LEN:
case REQ_BODY_WITH_LEN:
break;
default:
WRONG("Wrong req_body_status in VRB_Cache()");
}
CHECK_OBJ_NOTNULL(req->htc, HTTP_CONN_MAGIC);
vfc = req->htc->vfc;
VFP_Setup(vfc);
vfc->wrk = req->wrk;
if (req->htc->content_length > maxsize) {
req->req_body_status = REQ_BODY_FAIL;
(void)VFP_Error(vfc, "Request body too big to cache");
return (-1);
}
req->body_oc = HSH_Private(req->wrk);
AN(req->body_oc);
XXXAN(STV_NewObject(req->wrk, req->body_oc, TRANSIENT_STORAGE, 8));
vfc->http = req->http;
vfc->oc = req->body_oc;
V1F_Setup_Fetch(vfc, req->htc);
if (VFP_Open(vfc) < 0) {
req->req_body_status = REQ_BODY_FAIL;
return (-1);
}
AZ(req->req_bodybytes);
AN(req->htc);
yet = req->htc->content_length;
if (yet < 0)
yet = 0;
do {
AZ(vfc->failed);
if (req->req_bodybytes > maxsize) {
req->req_body_status = REQ_BODY_FAIL;
(void)VFP_Error(vfc, "Request body too big to cache");
VFP_Close(vfc);
return(-1);
}
l = yet;
if (VFP_GetStorage(vfc, &l, &ptr) != VFP_OK)
break;
AZ(vfc->failed);
AN(ptr);
AN(l);
vfps = VFP_Suck(vfc, ptr, &l);
if (l > 0 && vfps != VFP_ERROR) {
req->req_bodybytes += l;
req->acct.req_bodybytes += l;
if (yet >= l)
yet -= l;
ObjExtend(req->wrk, req->body_oc, l);
}
} while (vfps == VFP_OK);
VFP_Close(vfc);
ObjTrimStore(req->wrk, req->body_oc);
/* XXX: check missing:
if (req->htc->content_length >= 0)
MUSTBE (req->req_bodybytes == req->htc->content_length);
*/
if (vfps == VFP_END) {
assert(req->req_bodybytes >= 0);
if (req->req_bodybytes != req->htc->content_length) {
/* We must update also the "pristine" req.* copy */
http_Unset(req->http0, H_Content_Length);
http_Unset(req->http0, H_Transfer_Encoding);
http_PrintfHeader(req->http0, "Content-Length: %ju",
(uintmax_t)req->req_bodybytes);
http_Unset(req->http, H_Content_Length);
http_Unset(req->http, H_Transfer_Encoding);
http_PrintfHeader(req->http, "Content-Length: %ju",
(uintmax_t)req->req_bodybytes);
}
req->req_body_status = REQ_BODY_CACHED;
} else {
req->req_body_status = REQ_BODY_FAIL;
}
VSLb_ts_req(req, "ReqBody", VTIM_real());
return (vfps == VFP_END ? req->req_bodybytes : -1);
}
void
VFP_Fetch_Body(struct busyobj *bo, ssize_t est)
{
ssize_t l;
enum vfp_status vfps = VFP_ERROR;
struct storage *st = NULL;
CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
AN(bo->vfp_nxt);
if (est < 0)
est = 0;
if (vfp_suck_init(bo) != VFP_OK) {
(void)VFP_Error(bo, "Fetch Pipeline failed to initialize");
bo->should_close = 1;
return;
}
do {
if (bo->abandon) {
/*
* A pass object and delivery was terminted
* We don't fail the fetch, in order for hit-for-pass
* objects to be created.
*/
AN(bo->fetch_objcore->flags & OC_F_PASS);
VSLb(bo->vsl, SLT_FetchError,
"Pass delivery abandoned");
vfps = VFP_END;
bo->should_close = 1;
break;
}
AZ(bo->failed);
if (st == NULL) {
st = VFP_GetStorage(bo, est);
est = 0;
}
if (st == NULL) {
bo->should_close = 1;
(void)VFP_Error(bo, "Out of storage");
break;
}
CHECK_OBJ_NOTNULL(st, STORAGE_MAGIC);
assert(st == VTAILQ_LAST(&bo->fetch_obj->store, storagehead));
l = st->space - st->len;
AZ(bo->failed);
vfps = VFP_Suck(bo, st->ptr + st->len, &l);
if (l > 0 && vfps != VFP_ERROR) {
AZ(VTAILQ_EMPTY(&bo->fetch_obj->store));
VBO_extend(bo, l);
}
if (st->len == st->space)
st = NULL;
} while (vfps == VFP_OK);
if (vfps == VFP_ERROR) {
AN(bo->failed);
(void)VFP_Error(bo, "Fetch Pipeline failed to process");
bo->should_close = 1;
}
vfp_suck_fini(bo);
/*
* Trim or delete the last segment, if any
*/
st = VTAILQ_LAST(&bo->fetch_obj->store, storagehead);
/* XXX: Temporary: Only trim if we are not streaming */
if (st != NULL && !bo->do_stream) {
/* None of this this is safe under streaming */
if (st->len == 0) {
VTAILQ_REMOVE(&bo->fetch_obj->store, st, list);
STV_free(st);
} else if (st->len < st->space) {
STV_trim(st, st->len, 1);
}
}
}
