vfp_gzip_end(struct busyobj *bo)
{
struct vgz *vg;
size_t dl;
const void *dp;
int i;
CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
vg = bo->vgz_rx;
CHECK_OBJ_NOTNULL(vg, VGZ_MAGIC);
bo->vgz_rx = NULL;
if (bo->state == BOS_FAILED) {
(void)VGZ_Destroy(&vg);
return(0);
}
do {
VGZ_Ibuf(vg, "", 0);
if (VGZ_ObufStorage(bo, vg))
return(-1);
i = VGZ_Gzip(vg, &dp, &dl, VGZ_FINISH);
VBO_extend(bo, dl);
} while (i != Z_STREAM_END);
VGZ_UpdateObj(vg, bo->fetch_obj);
if (VGZ_Destroy(&vg) != VGZ_END)
return(VFP_Error(bo, "Gzip error at the very end"));
return (0);
}
vfp_esi_end(struct sess *sp)
{
struct vsb *vsb;
struct vef_priv *vef;
ssize_t l;
CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
AN(sp->wrk->vep);
vsb = VEP_Finish(sp);
if (vsb != NULL) {
l = VSB_len(vsb);
assert(l > 0);
/* XXX: This is a huge waste of storage... */
sp->obj->esidata = STV_alloc(sp, l);
XXXAN(sp->obj->esidata);
memcpy(sp->obj->esidata->ptr, VSB_data(vsb), l);
sp->obj->esidata->len = l;
VSB_delete(vsb);
}
if (sp->wrk->vgz_rx != NULL)
VGZ_Destroy(&sp->wrk->vgz_rx);
if (sp->wrk->vef_priv != NULL) {
vef = sp->wrk->vef_priv;
CHECK_OBJ_NOTNULL(vef, VEF_MAGIC);
sp->wrk->vef_priv = NULL;
VGZ_UpdateObj(vef->vgz, sp->obj);
VGZ_Destroy(&vef->vgz);
XXXAZ(vef->error);
FREE_OBJ(vef);
}
return (0);
}
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_esi_end(struct busyobj *bo)
{
struct vsb *vsb;
struct vef_priv *vef;
ssize_t l;
int retval = 0;
CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
AN(bo->vep);
if (bo->state == BOS_FAILED)
retval = -1;
if (bo->vgz_rx != NULL && VGZ_Destroy(&bo->vgz_rx) != VGZ_END)
retval = VFP_Error(bo, "Gunzip+ESI Failed at the very end");
vsb = VEP_Finish(bo);
if (vsb != NULL) {
if (!retval) {
l = VSB_len(vsb);
assert(l > 0);
/* XXX: This is a huge waste of storage... */
bo->fetch_obj->esidata = STV_alloc(bo, l);
if (bo->fetch_obj->esidata != NULL) {
memcpy(bo->fetch_obj->esidata->ptr,
VSB_data(vsb), l);
bo->fetch_obj->esidata->len = l;
} else {
retval = VFP_Error(bo,
"Could not allocate storage for esidata");
}
}
VSB_delete(vsb);
}
vef = bo->vef_priv;
bo->vef_priv = NULL;
CHECK_OBJ_NOTNULL(vef, VEF_MAGIC);
if (vef->vgz != NULL) {
VGZ_UpdateObj(vef->vgz, bo->fetch_obj);
if (VGZ_Destroy(&vef->vgz) != VGZ_END)
retval = VFP_Error(bo,
"ESI+Gzip Failed at the very end");
}
if (vef->ibuf != NULL)
free(vef->ibuf);
if (vef->ibuf2 != NULL)
free(vef->ibuf2);
FREE_OBJ(vef);
return (retval);
}
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_esi_end(struct worker *wrk)
{
struct vsb *vsb;
struct vef_priv *vef;
struct busyobj *bo;
ssize_t l;
int retval;
CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
bo = wrk->busyobj;
CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
AN(bo->vep);
retval = bo->fetch_failed;
if (bo->vgz_rx != NULL && VGZ_Destroy(&bo->vgz_rx, -1) != VGZ_END)
retval = FetchError(wrk, "Gunzip+ESI Failed at the very end");
vsb = VEP_Finish(wrk);
if (vsb != NULL) {
if (!retval) {
l = VSB_len(vsb);
assert(l > 0);
/* XXX: This is a huge waste of storage... */
bo->fetch_obj->esidata = STV_alloc(wrk, l);
if (bo->fetch_obj->esidata != NULL) {
memcpy(bo->fetch_obj->esidata->ptr,
VSB_data(vsb), l);
bo->fetch_obj->esidata->len = l;
} else {
retval = FetchError(wrk,
"Could not allocate storage for esidata");
}
}
VSB_delete(vsb);
}
vef = bo->vef_priv;
if (vef != NULL) {
CHECK_OBJ_NOTNULL(vef, VEF_MAGIC);
bo->vef_priv = NULL;
VGZ_UpdateObj(vef->vgz, bo->fetch_obj);
if (VGZ_Destroy(&vef->vgz, -1) != VGZ_END)
retval = FetchError(wrk,
"ESI+Gzip Failed at the very end");
FREE_OBJ(vef);
}
return (retval);
}
static ssize_t
vfp_vep_callback(struct vfp_ctx *vc, void *priv, ssize_t l, enum vgz_flag flg)
{
struct vef_priv *vef;
ssize_t dl;
const void *dp;
uint8_t *ptr;
int i;
CHECK_OBJ_NOTNULL(vc, VFP_CTX_MAGIC);
CAST_OBJ_NOTNULL(vef, priv, VEF_MAGIC);
assert(l >= 0);
if (vef->error) {
vef->tot += l;
return (vef->tot);
}
/*
* l == 0 is valid when 'flg' calls for action, but in the
* normal case we can just ignore a l==0 request.
* (It would cause Z_BUF_ERROR anyway)
*/
if (l == 0 && flg == VGZ_NORMAL)
return (vef->tot);
CHECK_OBJ_NOTNULL(vc->bo, BUSYOBJ_MAGIC);
VGZ_Ibuf(vef->vgz, vef->ibuf_o, l);
do {
dl = 0;
if (VFP_GetStorage(vc, &dl, &ptr) != VFP_OK) {
vef->error = ENOMEM;
vef->tot += l;
return (vef->tot);
}
VGZ_Obuf(vef->vgz, ptr, dl);
i = VGZ_Gzip(vef->vgz, &dp, &dl, flg);
VGZ_UpdateObj(vc, vef->vgz, VUA_UPDATE);
if (dl > 0) {
vef->tot += dl;
VFP_Extend(vc, dl);
}
} while (i != VGZ_ERROR &&
(!VGZ_IbufEmpty(vef->vgz) || VGZ_ObufFull(vef->vgz)));
assert(i == VGZ_ERROR || VGZ_IbufEmpty(vef->vgz));
vef->ibuf_o += l;
return (vef->tot);
}
vfp_testgzip_end(struct busyobj *bo)
{
struct vgz *vg;
CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
vg = bo->vgz_rx;
bo->vgz_rx = NULL;
CHECK_OBJ_NOTNULL(vg, VGZ_MAGIC);
if (bo->state == BOS_FAILED) {
(void)VGZ_Destroy(&vg);
return(0);
}
VGZ_UpdateObj(vg, bo->fetch_obj);
if (VGZ_Destroy(&vg) != VGZ_END)
return(VFP_Error(bo, "TestGunzip error at the very end"));
return (0);
}
static enum vfp_status
vfp_esi_end(struct busyobj *bo, struct vef_priv *vef, enum vfp_status retval)
{
struct vsb *vsb;
ssize_t l;
CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
CHECK_OBJ_NOTNULL(vef, VEF_MAGIC);
vsb = VEP_Finish(vef->vep, bo);
if (vsb != NULL) {
if (retval == VFP_END) {
l = VSB_len(vsb);
assert(l > 0);
/* XXX: This is a huge waste of storage... */
bo->fetch_obj->esidata = STV_alloc(bo, l);
if (bo->fetch_obj->esidata != NULL) {
memcpy(bo->fetch_obj->esidata->ptr,
VSB_data(vsb), l);
bo->fetch_obj->esidata->len = l;
} else {
retval = VFP_Error(bo,
"Could not allocate storage for esidata");
}
}
VSB_delete(vsb);
}
if (vef->vgz != NULL) {
VGZ_UpdateObj(vef->vgz, bo->fetch_obj);
if (VGZ_Destroy(&vef->vgz) != VGZ_END)
retval = VFP_Error(bo,
"ESI+Gzip Failed at the very end");
}
if (vef->ibuf != NULL)
free(vef->ibuf);
FREE_OBJ(vef);
return (retval);
}
static enum vfp_status
vfp_esi_end(struct vfp_ctx *vc, struct vef_priv *vef,
enum vfp_status retval)
{
struct vsb *vsb;
ssize_t l;
void *p;
CHECK_OBJ_NOTNULL(vc, VFP_CTX_MAGIC);
CHECK_OBJ_NOTNULL(vef, VEF_MAGIC);
vsb = VEP_Finish(vef->vep);
if (vsb != NULL) {
if (retval == VFP_END) {
l = VSB_len(vsb);
assert(l > 0);
p = ObjSetattr(vc->wrk, vc->oc,
OA_ESIDATA, l, VSB_data(vsb));
if (p == NULL) {
retval = VFP_Error(vc,
"Could not allocate storage for esidata");
}
}
VSB_delete(vsb);
}
if (vef->vgz != NULL) {
VGZ_UpdateObj(vc, vef->vgz, VUA_END_GZIP);
if (VGZ_Destroy(&vef->vgz) != VGZ_END)
retval = VFP_Error(vc,
"ESI+Gzip Failed at the very end");
}
if (vef->ibuf != NULL)
free(vef->ibuf);
FREE_OBJ(vef);
return (retval);
}
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);
}
