void
lcbio_ctx_close_ex(lcbio_CTX *ctx, lcbio_CTXCLOSE_cb cb, void *arg,
lcbio_CTXDTOR_cb dtor, void *dtor_arg)
{
unsigned oldrc;
ctx->state = ES_DETACHED;
assert(ctx->sock);
if (ctx->event) {
deactivate_watcher(ctx);
IOT_V0EV(CTX_IOT(ctx)).destroy(IOT_ARG(CTX_IOT(ctx)), ctx->event);
ctx->event = NULL;
}
if (ctx->as_err) {
lcbio_timer_destroy(ctx->as_err);
ctx->as_err = NULL;
}
oldrc = ctx->sock->refcount;
lcb_log(LOGARGS(ctx, DEBUG), CTX_LOGFMT "Destroying. PND=%d,ENT=%d,SORC=%d", CTX_LOGID(ctx), (int)ctx->npending, (int)ctx->entered, oldrc);
if (cb) {
int reusable =
ctx->npending == 0 && /* no pending events */
ctx->err == LCB_SUCCESS && /* no socket errors */
ctx->rdwant == 0 && /* no expected input */
ctx->wwant == 0 && /* no expected output */
(ctx->output == NULL || ctx->output->rb.nbytes == 0);
cb(ctx->sock, reusable, arg);
}
if (oldrc == ctx->sock->refcount) {
lcbio_shutdown(ctx->sock);
}
if (ctx->output) {
ringbuffer_destruct(&ctx->output->rb);
free(ctx->output);
ctx->output = NULL;
}
ctx->fd = INVALID_SOCKET;
ctx->sd = NULL;
if (dtor) {
ctx->data = dtor_arg;
ctx->procs.cb_flush_ready = dtor;
} else {
ctx->procs.cb_flush_ready = NULL;
}
if (ctx->npending == 0 && ctx->entered == 0) {
free_ctx(ctx);
}
}
/**
* Handler invoked to deliver final status for a connection. This will invoke
* the user supplied callback with the relevant status (if it has not been
* cancelled) and then free the CONNSTART object.
*/
static void
cs_handler(void *cookie)
{
lcbio_CONNSTART *cs = cookie;
lcb_error_t err;
lcbio_SOCKET *s = cs->sock;
if (s && cs->event) {
cs_unwatch(cs);
IOT_V0EV(s->io).destroy(IOT_ARG(s->io), cs->event);
}
if (cs->state == CS_PENDING) {
/* state was not changed since initial scheduling */
err = LCB_ETIMEDOUT;
} else if (cs->state == CS_CONNECTED) {
/* clear pending error */
err = LCB_SUCCESS;
} else {
if (s != NULL && cs->pending == LCB_CONNECT_ERROR) {
err = lcbio_mklcberr(cs->syserr, s->settings);
} else {
err = cs->pending;
}
}
if (cs->state == CS_CANCELLED) {
/* ignore everything. Clean up resources */
goto GT_DTOR;
}
if (s) {
lcbio__load_socknames(s);
if (err == LCB_SUCCESS) {
lcb_log(LOGARGS(s, INFO), CSLOGFMT "Connected ", CSLOGID(s));
} else {
lcb_log(LOGARGS(s, ERR), CSLOGFMT "Failed: lcb_err=0x%x, os_errno=%u", CSLOGID(s), err, cs->syserr);
}
}
/** Handler section */
cs->in_uhandler = 1;
cs->handler(err == LCB_SUCCESS ? s : NULL, cs->arg, err, cs->syserr);
GT_DTOR:
if (cs->async) {
lcbio_timer_destroy(cs->async);
}
if (cs->sock) {
lcbio_unref(cs->sock);
}
if (cs->ai_root) {
freeaddrinfo(cs->ai_root);
}
free(cs);
}
static void shutdown_file(clconfig_provider *pb)
{
file_provider *provider = (file_provider *)pb;
free(provider->filename);
if (provider->timer) {
lcbio_timer_destroy(provider->timer);
}
if (provider->config) {
lcb_clconfig_decref(provider->config);
}
free(provider);
}
static void
mcraw_shutdown(clconfig_provider *pb)
{
bc_MCRAW *mcr = (bc_MCRAW *)pb;
if (mcr->config) {
lcb_clconfig_decref(mcr->config);
}
if (mcr->async) {
lcbio_timer_destroy(mcr->async);
}
free(mcr);
}
void lcb_bootstrap_destroy(lcb_t instance)
{
struct lcb_BOOTSTRAP *bs = instance->bootstrap;
if (!bs) {
return;
}
if (bs->tm) {
lcbio_timer_destroy(bs->tm);
}
lcb_confmon_remove_listener(instance->confmon, &bs->listener);
free(bs);
instance->bootstrap = NULL;
}
static void
cleanup_pending(mc_pSESSREQ sreq)
{
if (sreq->inner) {
cleanup_negotiated(sreq->inner);
sreq->inner = NULL;
}
if (sreq->timer) {
lcbio_timer_destroy(sreq->timer);
sreq->timer = NULL;
}
if (sreq->ctx) {
lcbio_ctx_close(sreq->ctx, NULL, NULL);
sreq->ctx = NULL;
}
free(sreq);
}
