static void
transform_destroy(TSCont contp)
{
TransformData *data;
data = TSContDataGet(contp);
if (data != NULL) {
if (data->input_buf) {
TSIOBufferDestroy(data->input_buf);
}
if (data->output_buf) {
TSIOBufferDestroy(data->output_buf);
}
if (data->pending_action) {
TSActionCancel(data->pending_action);
}
if (data->server_vc) {
TSVConnAbort(data->server_vc, 1);
}
TSfree(data);
} else {
TSError("[%s] Unable to get Continuation's Data. TSContDataGet returns NULL", PLUGIN_NAME);
}
TSContDestroy(contp);
}
/* When the handle is called, the net_vc is returned. */
static int
accept_handler(TSCont contp, TSEvent event, void *edata)
{
TSCont txn_sm;
TSMutex pmutex;
switch (event) {
case TS_EVENT_NET_ACCEPT:
/* Create a new mutex for the TxnSM, which is going
to handle the incoming request. */
pmutex = (TSMutex)TSMutexCreate();
txn_sm = (TSCont)TxnSMCreate(pmutex, (TSVConn)edata, server_port);
/* This is no reason for not grabbing the lock.
So skip the routine which handle LockTry failure case. */
TSMutexLockTry(pmutex); // TODO: why should it not check if we got the lock??
TSContCall(txn_sm, 0, NULL);
TSMutexUnlock(pmutex);
break;
default:
/* Something wrong with the network, if there are any
pending NetAccept, cancel them. */
if (pending_action && !TSActionDone(pending_action))
TSActionCancel(pending_action);
TSContDestroy(contp);
break;
}
return TS_EVENT_NONE;
}
static void
ts_lua_release_cache_info(ts_lua_cache_info *info, int destroy)
{
if (info == NULL)
return;
if (info->cache_action) {
TSActionCancel(info->cache_action);
info->cache_action = NULL;
}
if (info->cache_key) {
TSCacheKeyDestroy(info->cache_key);
info->cache_key = NULL;
}
if (info->cache_vc) {
TSVConnClose(info->cache_vc);
info->cache_vc = NULL;
}
TS_LUA_RELEASE_IO_HANDLE((&info->ioh));
TS_LUA_RELEASE_IO_HANDLE((&info->reserved));
if (destroy) {
TSfree(info);
}
}
void
ts_http_fetcher_destroy(http_fetcher *fch)
{
if (fch->action) {
TSActionCancel(fch->action);
fch->action = NULL;
}
fch->deleted = 1;
if (fch->ref)
return;
ts_http_fetcher_release(fch);
}
int
ts_http_fetcher_filter_body(http_fetcher *fch, int ev)
{
int ret;
int64_t resp_avail, body_avail, wavail, need;
if (fch->action) {
TSActionCancel(fch->action);
fch->action = NULL;
}
need = 0;
resp_avail = TSIOBufferReaderAvail(fch->resp_reader);
if (ev != BODY_COMPLETE) {
body_avail = TSIOBufferReaderAvail(fch->body_reader);
wavail = TS_FETCH_MARK_BODY_HIGH_WATER - body_avail;
if (wavail <= 0)
return TS_FETCH_EVENT_BODY_QUIET;
need = resp_avail > wavail ? wavail : resp_avail;
TSIOBufferCopy(fch->flow_buffer, fch->resp_reader, need, 0);
TSIOBufferReaderConsume(fch->resp_reader, need);
if (TSIOBufferReaderAvail(fch->resp_reader) < TS_FETCH_MARK_RESP_LOW_WATER)
TSVIOReenable(fch->read_vio);
} else {
TSIOBufferCopy(fch->flow_buffer, fch->resp_reader, resp_avail, 0);
TSIOBufferReaderConsume(fch->resp_reader, resp_avail);
need = resp_avail;
}
if (fch->chunked) {
ret = ts_http_fetcher_verify_chunked(fch, ev);
} else if (fch->resp_cl >= 0) {
ret = ts_http_fetcher_verify_cl(fch, ev);
} else {
ret = ts_http_fetcher_transfer(fch, ev);
}
switch (ret) {
case BODY_READY:
if (need == 0)
return TS_FETCH_EVENT_BODY_QUIET;
return TS_FETCH_EVENT_BODY_READY;
case BODY_COMPLETE:
fch->body_done = 1;
return TS_FETCH_EVENT_BODY_COMPLETE;
default:
break;
}
fch->error = 1;
return TS_FETCH_EVENT_ERROR;
}
