void
VRT_DelDirector(VCL_BACKEND *bp)
{
struct vcl *vcl;
struct vcldir *vdir;
VCL_BACKEND d;
TAKE_OBJ_NOTNULL(d, bp, DIRECTOR_MAGIC);
vdir = d->vdir;
CHECK_OBJ_NOTNULL(vdir, VCLDIR_MAGIC);
vcl = vdir->vcl;
CHECK_OBJ_NOTNULL(vcl, VCL_MAGIC);
Lck_Lock(&vcl_mtx);
VTAILQ_REMOVE(&vcl->director_list, vdir, list);
Lck_Unlock(&vcl_mtx);
AZ(errno=pthread_rwlock_rdlock(&vcl->temp_rwl));
if (VCL_WARM(vcl))
VDI_Event(d, VCL_EVENT_COLD);
AZ(errno=pthread_rwlock_unlock(&vcl->temp_rwl));
if(vdir->methods->destroy != NULL)
vdir->methods->destroy(d);
free(vdir->cli_name);
FREE_OBJ(vdir->dir);
FREE_OBJ(vdir);
}
void
vex_Free(struct vex **pvex)
{
if ((*pvex)->lhs != NULL) {
if ((*pvex)->lhs->tags != NULL)
vbit_destroy((*pvex)->lhs->tags);
if ((*pvex)->lhs->prefix != NULL)
free((*pvex)->lhs->prefix);
FREE_OBJ((*pvex)->lhs);
}
if ((*pvex)->rhs != NULL) {
if ((*pvex)->rhs->val_string)
free((*pvex)->rhs->val_string);
if ((*pvex)->rhs->val_regex)
VRE_free(&(*pvex)->rhs->val_regex);
FREE_OBJ((*pvex)->rhs);
}
if ((*pvex)->a != NULL) {
vex_Free(&(*pvex)->a);
AZ((*pvex)->a);
}
if ((*pvex)->b != NULL) {
vex_Free(&(*pvex)->b);
AZ((*pvex)->b);
}
FREE_OBJ(*pvex);
*pvex = NULL;
}
VCL_VOID
vmod_file_system__fini(struct vmod_fsdirector_file_system **fsp)
{
struct vmod_fsdirector_file_system *fs;
void *res;
// XXX It seems that the destructor is not called yet.
// A little reminder then...
abort();
fs = *fsp;
*fsp = NULL;
CHECK_OBJ_NOTNULL(fs, VMOD_FSDIRECTOR_MAGIC);
AZ(pthread_cancel(fs->tp));
AZ(pthread_join(fs->tp, &res));
assert(res == PTHREAD_CANCELED);
magic_close(fs->magic_cookie);
free(fs->thread_name);
free(fs->ws_name);
free(fs->wrk->aws);
FREE_OBJ(fs->wrk);
FREE_OBJ(fs);
}
/*---------------------------------------------------------------------*/
void
HSH_Cleanup(struct worker *wrk)
{
if (wrk->nobjcore != NULL) {
FREE_OBJ(wrk->nobjcore);
wrk->stats->n_objectcore--;
wrk->nobjcore = NULL;
}
if (wrk->nobjhead != NULL) {
Lck_Delete(&wrk->nobjhead->mtx);
FREE_OBJ(wrk->nobjhead);
wrk->nobjhead = NULL;
wrk->stats->n_objecthead--;
}
if (wrk->nwaitinglist != NULL) {
FREE_OBJ(wrk->nwaitinglist);
wrk->nwaitinglist = NULL;
wrk->stats->n_waitinglist--;
}
if (wrk->nhashpriv != NULL) {
/* XXX: If needed, add slinger method for this */
free(wrk->nhashpriv);
wrk->nhashpriv = NULL;
}
}
char *popen_fread(char *cmd, char *buf, int len)
{
char *str_tmp = NULL;
char *p = NULL;
FILE *fp = NULL;
if((cmd == NULL) || (buf == NULL))
return NULL;
//str_tmp = malloc(len);
CREATE_STRING_ERR(str_tmp,len,MALLOC_ERR_RET(NULL));
if(str_tmp == NULL)
{
goto err;
}
printf_d("CMD: %s\n", cmd);
fp = popen(cmd, "r");
if(fp)
{
memset(str_tmp, 0, len);
if(fread(str_tmp, 1, len, fp) > 0)
{
if(strlen(str_tmp) < 1)
{
pclose(fp);
goto err;
}
if(str_tmp[strlen(str_tmp)-1] == '\n')
{
str_tmp[strlen(str_tmp)-1] = '\0';
}
else
{
str_tmp[strlen(str_tmp)] = '\0';
}
p = trim(str_tmp);
if(p == NULL)
{
buf[0] = 0;
}
else
strcpy(buf, p);
pclose(fp);
}
else
{
pclose(fp);
goto err;
}
}
else
{
goto err;
}
FREE_OBJ(str_tmp);
return buf;
err:
FREE_OBJ(str_tmp);
return NULL;
}
void
vdir_delete(struct vdir **vdp)
{
struct vdir *vd;
TAKE_OBJ_NOTNULL(vd, vdp, VDIR_MAGIC);
free(vd->backend);
free(vd->weight);
AZ(pthread_rwlock_destroy(&vd->mtx));
free(vd->dir->vcl_name);
FREE_OBJ(vd->dir);
vbit_destroy(vd->vbm);
FREE_OBJ(vd);
}
void
TestCB_destroy(TestCharBuf *self)
{
DECREF(self->wanted);
DECREF(self->got);
FREE_OBJ(self);
}
void ME_DeleteReObject(REOBJECT* reo)
{
if (reo->poleobj) IOleObject_Release(reo->poleobj);
if (reo->pstg) IStorage_Release(reo->pstg);
if (reo->polesite) IOleClientSite_Release(reo->polesite);
FREE_OBJ(reo);
}
void
Snapshot_destroy(Snapshot *self)
{
DECREF(self->entries);
DECREF(self->filename);
FREE_OBJ(self);
}
// Free a memblock object.
void Memblock::free(Memory& mem, Memblock* m)
{
if(m->ownData)
m->data.free(mem);
FREE_OBJ(mem, Memblock, m);
}
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);
}
void ME_DestroyDisplayItem(ME_DisplayItem *item)
{
/* TRACE("type=%s\n", ME_GetDITypeName(item->type)); */
if (item->type==diParagraph)
{
FREE_OBJ(item->member.para.pFmt);
ME_DestroyString(item->member.para.text);
}
if (item->type==diRun)
{
if (item->member.run.ole_obj) ME_DeleteReObject(item->member.run.ole_obj);
ME_ReleaseStyle(item->member.run.style);
}
FREE_OBJ(item);
}
static void
vsmw_delseg(struct vsmw *vsmw, struct vsmwseg *seg, int fixidx)
{
char *t = NULL;
ssize_t s;
int fd;
CHECK_OBJ_NOTNULL(vsmw, VSMW_MAGIC);
CHECK_OBJ_NOTNULL(seg, VSMWSEG_MAGIC);
VTAILQ_REMOVE(&vsmw->segs, seg, list);
REPLACE(seg->class, NULL);
REPLACE(seg->id, NULL);
FREE_OBJ(seg);
if (fixidx) {
vsmw_mkent(vsmw, vsmw->idx);
REPLACE(t, VSB_data(vsmw->vsb));
AN(t);
fd = openat(vsmw->vdirfd,
t, O_WRONLY|O_CREAT|O_EXCL, vsmw->mode);
assert(fd >= 0);
vsmw_idx_head(vsmw, fd);
VSB_clear(vsmw->vsb);
VTAILQ_FOREACH(seg, &vsmw->segs, list)
vsmw_fmt_index(vsmw, seg);
AZ(VSB_finish(vsmw->vsb));
s = write(fd, VSB_data(vsmw->vsb), VSB_len(vsmw->vsb));
assert(s == VSB_len(vsmw->vsb));
AZ(close(fd));
AZ(renameat(vsmw->vdirfd, t, vsmw->vdirfd, vsmw->idx));
REPLACE(t, NULL);
}
}
void
VRT_rel_vcl(VRT_CTX, struct vclref **refp)
{
struct vcl *vcl;
struct vclref *ref;
AN(refp);
ref = *refp;
*refp = NULL;
CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
CHECK_OBJ_NOTNULL(ref, VCLREF_MAGIC);
vcl = ctx->vcl;
CHECK_OBJ_NOTNULL(vcl, VCL_MAGIC);
assert(vcl == ref->vcl);
/* NB: A VCL may be released by a VMOD at any time, but it must happen
* after a warmup and before the end of a cooldown. The release may or
* may not happen while the same thread holds the temperature lock, so
* instead we check that all references are gone in VCL_Nuke.
*/
Lck_Lock(&vcl_mtx);
assert(!VTAILQ_EMPTY(&vcl->ref_list));
VTAILQ_REMOVE(&vcl->ref_list, ref, list);
vcl->nrefs--;
/* No garbage collection here, for the same reasons as in VCL_Rel. */
Lck_Unlock(&vcl_mtx);
FREE_OBJ(ref);
}
void
ObjIterEnd(struct objiter **oi)
{
CHECK_OBJ_NOTNULL((*oi), OBJITER_MAGIC);
FREE_OBJ((*oi));
}
static void *
vbp_wrk_poll_backend(void *priv)
{
struct vbp_target *vt;
THR_SetName("backend poll");
CAST_OBJ_NOTNULL(vt, priv, VBP_TARGET_MAGIC);
while (!vt->stop) {
AN(vt->req);
assert(vt->req_len > 0);
if (!vt->disable) {
vbp_start_poke(vt);
vbp_poke(vt);
vbp_has_poked(vt);
}
if (!vt->stop)
VTIM_sleep(vt->probe.interval);
}
Lck_Delete(&vt->mtx);
VTAILQ_REMOVE(&vbp_list, vt, list);
VBT_Rel(&vt->tcp_pool);
free(vt->req);
FREE_OBJ(vt);
return (NULL);
}
void
LockFact_destroy(LockFactory *self)
{
DECREF(self->folder);
DECREF(self->agent_id);
FREE_OBJ(self);
}
void
SeriesMatcher_destroy(SeriesMatcher *self)
{
DECREF(self->matchers);
DECREF(self->offsets);
FREE_OBJ(self);
}
void
VRT_Vmod_Fini(void **hdl)
{
struct vmod *v;
ASSERT_CLI();
AN(*hdl);
CAST_OBJ_NOTNULL(v, *hdl, VMOD_MAGIC);
*hdl = NULL;
#ifndef DONT_DLCLOSE_VMODS
/*
* atexit(3) handlers are not called during dlclose(3). We don't
* normally use them, but we do when running GCOV. This option
* enables us to do that.
*/
AZ(dlclose(v->hdl));
#endif
if (--v->ref != 0)
return;
free(v->nm);
free(v->path);
VTAILQ_REMOVE(&vmods, v, list);
VSC_C_main->vmods--;
FREE_OBJ(v);
}
static void ME_DestroyStyle(ME_Style *s) {
if (s->hFont)
{
DeleteObject(s->hFont);
s->hFont = NULL;
}
FREE_OBJ(s);
}
void
VLU_Destroy(struct vlu *l)
{
CHECK_OBJ_NOTNULL(l, LINEUP_MAGIC);
free(l->buf);
FREE_OBJ(l);
}
VCL_VOID vmod_mqueue__fini(struct vmod_msgsend_mqueue **qp)
{
AN(qp);
CHECK_OBJ_NOTNULL(*qp, VMOD_MSGSEND_OBJ_MAGIC);
queue_close(&(*qp)->queue);
FREE_OBJ(*qp);
*qp = NULL;
}
void
BAN_Abandon(struct ban_proto *bp)
{
CHECK_OBJ_NOTNULL(bp, BAN_PROTO_MAGIC);
VSB_delete(bp->vsb);
FREE_OBJ(bp);
}
void
fifolog_write_destroy(struct fifolog_writer *f)
{
free(f->obuf);
free(f->ibuf);
FREE_OBJ(f);
}
static void
vcc_delete_expr(struct expr *e)
{
if (e == NULL)
return;
CHECK_OBJ_NOTNULL(e, EXPR_MAGIC);
VSB_delete(e->vsb);
FREE_OBJ(e);
}
void
vdir_delete(struct vdir **vdp)
{
struct vdir *vd;
AN(vdp);
vd = *vdp;
*vdp = NULL;
CHECK_OBJ_NOTNULL(vd, VDIR_MAGIC);
free(vd->backend);
free(vd->weight);
AZ(pthread_mutex_destroy(&vd->mtx));
FREE_OBJ(vd->dir);
vbit_destroy(vd->vbm);
FREE_OBJ(vd);
}
static void
telnet_close(void *priv)
{
struct telnet *tn;
CAST_OBJ_NOTNULL(tn, priv, TELNET_MAGIC);
(void)close(tn->fd);
FREE_OBJ(tn);
}
void
SES_DeletePool(struct sesspool *pp)
{
CHECK_OBJ_NOTNULL(pp, SESSPOOL_MAGIC);
MPL_Destroy(&pp->mpl_sess);
MPL_Destroy(&pp->mpl_req);
FREE_OBJ(pp);
}
void
vtc_logclose(struct vtclog *vl)
{
CHECK_OBJ_NOTNULL(vl, VTCLOG_MAGIC);
vsb_delete(vl->vsb);
AZ(pthread_mutex_destroy(&vl->mtx));
FREE_OBJ(vl);
}
void
HSH_DeleteObjHead(struct worker *wrk, struct objhead *oh)
{
AZ(oh->refcnt);
assert(VTAILQ_EMPTY(&oh->objcs));
Lck_Delete(&oh->mtx);
wrk->stats->n_objecthead--;
FREE_OBJ(oh);
}
