static config_t* get_config(TSCont cont) {
config_holder_t* configh = (config_holder_t *) TSContDataGet(cont);
if(!configh) {
return 0;
}
return configh->config;
}
static int
hdr_handler(TSCont contp, TSHttpTxn txnp)
{
TSMBuffer bufp;
TSMLoc hdr_loc, field_loc;
hdr_list *hdr;
hdr = TSContDataGet(contp);
if (hdr == NULL) {
goto done;
}
if (TSHttpTxnClientRespGet(txnp, &bufp, &hdr_loc) != TS_SUCCESS) {
TSError("couldn't retrieve client response header\n");
goto done;
}
for (; hdr; hdr = hdr->next) {
TSMimeHdrFieldCreate(bufp, hdr_loc, &field_loc);
TSMimeHdrFieldNameSet(bufp, hdr_loc, field_loc, hdr->name, strlen(hdr->name));
TSMimeHdrFieldValueStringInsert(bufp, hdr_loc, field_loc, -1, hdr->val, strlen(hdr->val));
TSMimeHdrFieldAppend(bufp, hdr_loc, field_loc);
TSHandleMLocRelease(bufp, hdr_loc, field_loc);
TSHandleMLocRelease(bufp, TS_NULL_MLOC, hdr_loc);
}
done:
TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
return 0;
}
/*-------------------------------------------------------------------------
wake_up_streams
Send an event to the upstream vconnection to either
- ask for more data
- let it know we're done
Reenable the downstream vconnection
Input:
contp continuation for the current transaction
Output :
Return Value:
0 if failure
1 if success
-------------------------------------------------------------------------*/
static int
wake_up_streams(TSCont contp)
{
TSVIO input_vio;
ContData *data;
int ntodo;
data = TSContDataGet(contp);
TSAssert(data->magic == MAGIC_ALIVE);
input_vio = TSVConnWriteVIOGet(contp);
ntodo = TSVIONTodoGet(input_vio);
if (ntodo > 0) {
TSVIOReenable(data->output_vio);
TSContCall(TSVIOContGet(input_vio), TS_EVENT_VCONN_WRITE_READY, input_vio);
} else {
TSDebug(DBG_TAG, "Total bytes produced by transform = %d", data->transform_bytes);
TSVIONBytesSet(data->output_vio, data->transform_bytes);
TSVIOReenable(data->output_vio);
TSContCall(TSVIOContGet(input_vio), TS_EVENT_VCONN_WRITE_COMPLETE, input_vio);
}
return 1;
}
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);
}
static void
handle_transform(TSCont contp)
{
MyData *data;
int done;
/* Get our data structure for this operation. The private data
structure contains the output VIO and output buffer. If the
private data structure pointer is NULL, then we'll create it
and initialize its internals. */
data = TSContDataGet(contp);
if (!data) {
data = my_data_alloc();
TSContDataSet(contp, data);
}
do {
switch (data->state) {
case STATE_BUFFER_DATA:
done = handle_buffering(contp, data);
break;
case STATE_OUTPUT_DATA:
done = handle_output(contp, data);
break;
default:
done = 1;
break;
}
} while (!done);
}
static int
ts_dechunk_transform_entry(TSCont contp, TSEvent event, void *edata)
{
TSVIO input_vio;
ts_dechunk_transform_ctx *transform_ctx = (ts_dechunk_transform_ctx*)TSContDataGet(contp);
if (TSVConnClosedGet(contp)) {
TSContDestroy(contp);
ts_dechunk_destroy_transform_ctx(transform_ctx);
return 0;
}
switch (event) {
case TS_EVENT_ERROR:
input_vio = TSVConnWriteVIOGet(contp);
TSContCall(TSVIOContGet(input_vio), TS_EVENT_ERROR, input_vio);
break;
case TS_EVENT_VCONN_WRITE_COMPLETE:
TSVConnShutdown(TSTransformOutputVConnGet(contp), 0, 1);
break;
case TS_EVENT_VCONN_WRITE_READY:
default:
ts_dechunk_transform_handler(contp, transform_ctx);
break;
}
return 0;
}
// This serves to consume all the data that arrives. If it's not consumed the tunnel gets stalled
// and the transaction doesn't complete. Other things could be done with the data, accessible via
// the IO buffer @a reader, such as writing it to disk to make an externally accessible copy.
static int
client_reader(TSCont contp, TSEvent event, void *edata)
{
SinkData *data = TSContDataGet(contp);
// If we got closed, we're done.
if (TSVConnClosedGet(contp)) {
TSfree(data);
TSContDestroy(contp);
return 0;
}
TSVIO input_vio = TSVConnWriteVIOGet(contp);
if (!data) {
data = TSmalloc(sizeof(SinkData));
data->total = 0;
TSContDataSet(contp, data);
}
switch (event) {
case TS_EVENT_ERROR:
TSDebug(PLUGIN_NAME, "Error event");
TSContCall(TSVIOContGet(input_vio), TS_EVENT_ERROR, input_vio);
break;
case TS_EVENT_VCONN_READ_COMPLETE:
TSDebug(PLUGIN_NAME, "READ_COMPLETE");
break;
case TS_EVENT_VCONN_READ_READY:
case TS_EVENT_IMMEDIATE:
TSDebug(PLUGIN_NAME, "Data event - %s", event == TS_EVENT_IMMEDIATE ? "IMMEDIATE" : "READ_READY");
// Look for data and if we find any, consume.
if (TSVIOBufferGet(input_vio)) {
TSIOBufferReader reader = TSVIOReaderGet(input_vio);
int64_t n = TSIOBufferReaderAvail(reader);
if (n > 0) {
TSIOBufferReaderConsume(reader, n);
TSVIONDoneSet(input_vio, TSVIONDoneGet(input_vio) + n);
data->total += n; // internal accounting so we can print the value at the end.
TSDebug(PLUGIN_NAME, "Consumed %" PRId64 " bytes", n);
}
if (TSVIONTodoGet(input_vio) > 0) {
// signal that we can accept more data.
TSContCall(TSVIOContGet(input_vio), TS_EVENT_VCONN_WRITE_READY, input_vio);
} else {
TSDebug(PLUGIN_NAME, "send WRITE_COMPLETE");
TSContCall(TSVIOContGet(input_vio), TS_EVENT_VCONN_WRITE_COMPLETE, input_vio);
}
} else { // buffer gone, we're done.
TSDebug(PLUGIN_NAME, "upstream buffer disappeared - %" PRId64 " bytes", data->total);
}
break;
default:
TSDebug(PLUGIN_NAME, "unhandled event %d", event);
break;
}
return 0;
}
static int in_data_event(TSCont contp, TSEvent event, void *edata)
{
ib_txn_ctx *data = TSContDataGet(contp);
ibd_ctx direction;
direction.ibd = &ironbee_direction_req;
direction.data = &data->in;
return data_event(contp, event, &direction);
}
static int config_handler(TSCont cont, TSEvent event, void *edata) {
config_holder_t *config_holder;
TSDebug(PLUGIN_TAG, "In config Handler");
config_holder = (config_holder_t *) TSContDataGet(cont);
load_config_file(config_holder);
return 0;
}
static void ironbee_plugin_ssn_close(TSCont contp, TSHttpSsn ssnp)
{
assert(contp != NULL);
TSDebug("ironbee", "SSN Close: %p", (void *)contp);
tsib_ssn_ctx_destroy(TSContDataGet(contp));
tsib_manager_engine_cleanup();
TSHttpSsnReenable(ssnp, TS_EVENT_HTTP_CONTINUE);
}
static ib_status_t ironbee_conn_init(ib_engine_t *ib,
ib_conn_t *iconn, void *cbdata)
{
/* when does this happen? */
ib_status_t rc;
const struct sockaddr *addr;
int port;
TSCont contp = iconn->pctx;
ib_ssn_ctx* data = TSContDataGet(contp);
// ib_clog_debug(....);
/* remote ip */
addr = TSHttpTxnClientAddrGet(data->txnp);
addr2str(addr, data->remote_ip, &port);
iconn->remote_ipstr = data->remote_ip;
rc = ib_data_add_bytestr(iconn->dpi,
"remote_ip",
(uint8_t *)iconn->remote_ipstr,
strlen(data->remote_ip),
NULL);
if (rc != IB_OK) {
return rc;
}
/* remote port */
iconn->remote_port = port;
rc = ib_data_add_num(iconn->dpi, "remote_port", port, NULL);
if (rc != IB_OK) {
return rc;
}
/* local end */
addr = TSHttpTxnIncomingAddrGet(data->txnp);
addr2str(addr, data->local_ip, &port);
iconn->local_ipstr = data->local_ip;
rc = ib_data_add_bytestr(iconn->dpi,
"local_ip",
(uint8_t *)iconn->local_ipstr,
strlen(data->local_ip),
NULL);
if (rc != IB_OK) {
return rc;
}
/* local_port */
iconn->local_port = port;
rc = ib_data_add_num(iconn->dpi, "local_port", port, NULL);
if (rc != IB_OK) {
return rc;
}
return IB_OK;
}
static int free_handler(TSCont cont, TSEvent event, void *edata) {
config_t *config;
TSDebug(PLUGIN_TAG, "Freeing old config");
config = (config_t *) TSContDataGet(cont);
delete_config(config);
TSContDestroy(cont);
return 0;
}
/*-------------------------------------------------------------------------
trylock_handler
Small handler to handle TSMutexLockTry failures
Input:
contp continuation for the current transaction
event event received
data pointer on optional data
Output :
Return Value:
-------------------------------------------------------------------------*/
static int
trylock_handler(TSCont contp, TSEvent event, void *edata)
{
TryLockData *data = TSContDataGet(contp);
transform_handler(data->contp, data->event, NULL);
TSfree(data);
TSContDestroy(contp);
return 0;
}
static int
null_transform(TSCont contp, TSEvent event, void *edata)
{
/* Check to see if the transformation has been closed by a call to
* TSVConnClose.
*/
TSDebug("null-transform", "Entering null_transform()");
if (TSVConnClosedGet(contp)) {
TSDebug("null-transform", "\tVConn is closed");
my_data_destroy(TSContDataGet(contp));
TSContDestroy(contp);
return 0;
} else {
switch (event) {
case TS_EVENT_ERROR:
{
TSVIO input_vio;
TSDebug("null-transform", "\tEvent is TS_EVENT_ERROR");
/* Get the write VIO for the write operation that was
* performed on ourself. This VIO contains the continuation of
* our parent transformation. This is the input VIO.
*/
input_vio = TSVConnWriteVIOGet(contp);
/* Call back the write VIO continuation to let it know that we
* have completed the write operation.
*/
TSContCall(TSVIOContGet(input_vio), TS_EVENT_ERROR, input_vio);
}
break;
case TS_EVENT_VCONN_WRITE_COMPLETE:
TSDebug("null-transform", "\tEvent is TS_EVENT_VCONN_WRITE_COMPLETE");
/* When our output connection says that it has finished
* reading all the data we've written to it then we should
* shutdown the write portion of its connection to
* indicate that we don't want to hear about it anymore.
*/
TSVConnShutdown(TSTransformOutputVConnGet(contp), 0, 1);
break;
case TS_EVENT_VCONN_WRITE_READY:
TSDebug("null-transform", "\tEvent is TS_EVENT_VCONN_WRITE_READY");
default:
TSDebug("null-transform", "\t(event is %d)", event);
/* If we get a WRITE_READY event or any other type of
* event (sent, perhaps, because we were reenabled) then
* we'll attempt to transform more data.
*/
handle_transform(contp);
break;
}
}
return 0;
}
static int
free_handler(TSCont cont, TSEvent event, void *edata)
{
invalidate_t *iptr;
TSDebug(LOG_PREFIX, "Freeing old config");
iptr = (invalidate_t *)TSContDataGet(cont);
free_invalidate_t_list(iptr);
TSContDestroy(cont);
return 0;
}
static void ironbee_plugin_send_response_hdr(TSCont contp, TSHttpTxn txnp)
{
assert(contp != NULL);
assert(txnp != NULL);
tsib_txn_ctx *txndata;
txndata = TSContDataGet(contp);
if (txndata == NULL) {
/* Ironbee is unavailable to help with our response. */
/* This contp is not ours, so we leave it. */
internal_error_response(txnp);
TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
return;
}
/* If ironbee has sent us into an error response then
* we came here in our error path, with nonzero status.
*/
if (txndata->status != 0) {
error_response(txnp, txndata);
}
/* Feed ironbee the headers if not done already. */
if (!ib_flags_all(txndata->tx->flags, IB_TX_FRES_STARTED)) {
if (process_hdr(txndata, txnp, &tsib_direction_client_resp) != HDR_OK) {
/* I think this is a shouldn't happen event, and that
* if it does we have an ironbee bug or misconfiguration.
* Log an error to catch if it happens in practice.
*/
ib_log_error_tx(txndata->tx, "process_hdr returned error in send_response_hdr event");
}
}
/* If there is an ironbee-generated response body, notify ironbee.
*
* NOTE: I do not see anywhere else to put this as the error body is
* just a buffer and not delivered via normal IO channels, so
* the error body will never get caught by an event.
*/
if ((txndata->status != 0) && (txndata->err_body != NULL)) {
const char *data = txndata->err_body;
size_t data_length = txndata->err_body_len;
ib_log_debug_tx(txndata->tx,
"error_response: calling ib_state_notify_response_body_data() %s:%d",
__FILE__, __LINE__);
ib_state_notify_response_body_data(txndata->tx->ib,
txndata->tx,
data, data_length);
}
TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
}
static int
ts_lua_schedule_handler(TSCont contp, TSEvent ev, void *edata)
{
lua_State *L;
ts_lua_cont_info *ci;
ts_lua_coroutine *crt;
int event, n, ret;
ts_lua_http_ctx *actx;
ts_lua_main_ctx *main_ctx;
event = (int)ev;
TSDebug(TS_LUA_DEBUG_TAG, "getting actx and other info");
actx = (ts_lua_http_ctx *)TSContDataGet(contp);
TSDebug(TS_LUA_DEBUG_TAG, "getting http_Ctx");
ci = &actx->cinfo;
crt = &ci->routine;
main_ctx = crt->mctx;
L = crt->lua;
ret = 0;
TSMutexLock(main_ctx->mutexp);
ts_lua_set_cont_info(L, ci);
if (event == TS_LUA_EVENT_COROUTINE_CONT) {
TSDebug(TS_LUA_DEBUG_TAG, "event is coroutine_cont");
n = (intptr_t)edata;
ret = lua_resume(L, n);
} else {
TSDebug(TS_LUA_DEBUG_TAG, "event is not coroutine_cont");
n = lua_gettop(L);
ret = lua_resume(L, n - 1);
}
if (ret == LUA_YIELD) {
TSMutexUnlock(main_ctx->mutexp);
goto done;
}
if (ret != 0) {
TSError("[ts_lua] lua_resume failed: %s", lua_tostring(L, -1));
}
lua_pop(L, lua_gettop(L));
TSMutexUnlock(main_ctx->mutexp);
ts_lua_destroy_async_ctx(actx);
done:
return 0;
}
/**
* Handle a incoming data event from ATS.
*
* Handles all incoming data events from ATS, uses process_data to handle the
* data itself.
*
* @param[in,out] contp Pointer to the continuation
* @param[in,out] event Event from ATS
* @param[in,out] edata Event data
*
* @returns status
*/
int in_data_event(TSCont contp, TSEvent event, void *edata)
{
ibd_ctx direction;
tsib_txn_ctx *txndata = TSContDataGet(contp);
if ( (txndata == NULL) || (txndata->tx == NULL) ) {
TSDebug("ironbee", "\tout_data_event: tx == NULL");
return 0;
}
direction.ibd = &tsib_direction_client_req;
direction.data = &txndata->in;
return data_event(contp, event, &direction);
}
/**
* Handle a outgoing data event from ATS.
*
* Handles all outgoing data events from ATS, uses process_data to handle the
* data itself.
*
* @param[in,out] contp Pointer to the continuation
* @param[in,out] event Event from ATS
* @param[in,out] edata Event data
*
* @returns status
*/
int out_data_event(TSCont contp, TSEvent event, void *edata)
{
ibd_ctx direction;
ib_txn_ctx *data = TSContDataGet(contp);
if ( (data == NULL) || (data->tx == NULL) ) {
TSDebug("ironbee", "\tout_data_event: tx == NULL");
return 0;
}
direction.ibd = &ib_direction_server_resp;
direction.data = &data->out;
return data_event(contp, event, &direction);
}
static void
destroy_continuation(TSHttpTxn txnp, TSCont contp)
{
cdata *cd = NULL;
cd = (cdata *)TSContDataGet(contp);
if (cd != NULL) {
TSfree(cd);
}
TSContDestroy(contp);
TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
return;
}
static int
ts_lua_cache_main_handler(TSCont contp, TSEvent event, void *edata)
{
ts_lua_async_item *ai;
ts_lua_cache_info *info;
ts_lua_cont_info *ci;
ai = TSContDataGet(contp);
ci = ai->cinfo;
info = (ts_lua_cache_info*)ai->data;
return info->current_handler(ci, info, event, edata);
}
static int
main_handler(TSCont cont, TSEvent event, void *edata)
{
TSHttpTxn txn = (TSHttpTxn)edata;
int status;
invalidate_t *iptr;
plugin_state_t *pstate;
time_t date = 0, now = 0;
char *url = NULL;
int url_len = 0;
switch (event) {
case TS_EVENT_HTTP_CACHE_LOOKUP_COMPLETE:
if (TSHttpTxnCacheLookupStatusGet(txn, &status) == TS_SUCCESS) {
if (status == TS_CACHE_LOOKUP_HIT_FRESH) {
pstate = (plugin_state_t *)TSContDataGet(cont);
iptr = pstate->invalidate_list;
while (iptr) {
if (!date) {
date = get_date_from_cached_hdr(txn);
now = time(NULL);
}
if ((difftime(iptr->epoch, date) >= 0) && (difftime(iptr->expiry, now) >= 0)) {
if (!url) {
url = TSHttpTxnEffectiveUrlStringGet(txn, &url_len);
}
if (pcre_exec(iptr->regex, iptr->regex_extra, url, url_len, 0, 0, NULL, 0) >= 0) {
TSHttpTxnCacheLookupStatusSet(txn, TS_CACHE_LOOKUP_HIT_STALE);
iptr = NULL;
TSDebug(LOG_PREFIX, "Forced revalidate - %.*s", url_len, url);
}
}
if (iptr) {
iptr = iptr->next;
}
}
if (url) {
TSfree(url);
}
}
}
break;
default:
break;
}
TSHttpTxnReenable(txn, TS_EVENT_HTTP_CONTINUE);
return 0;
}
static int stats_dostuff(TSCont contp, TSEvent event, void *edata) {
stats_state *my_state = TSContDataGet(contp);
if (event == TS_EVENT_NET_ACCEPT) {
my_state->net_vc = (TSVConn) edata;
stats_process_accept(contp, my_state);
} else if (edata == my_state->read_vio)
stats_process_read(contp, event, my_state);
else if (edata == my_state->write_vio)
stats_process_write(contp, event, my_state);
else
TSReleaseAssert(!"Unexpected Event");
return 0;
}
/**
* Handle a incoming data event from ATS.
*
* Handles all incoming data events from ATS, uses process_data to handle the
* data itself.
*
* @param[in,out] contp Pointer to the continuation
* @param[in,out] event Event from ATS
* @param[in,out] edata Event data
*
* @returns status
*/
int in_data_event(TSCont contp, TSEvent event, void *edata)
{
ibd_ctx direction;
ib_txn_ctx *data;
TSDebug("ironbee-in-data", "in_data_event: contp=%p", contp);
data = TSContDataGet(contp);
if ( (data == NULL) || (data->tx == NULL) ) {
TSDebug("ironbee", "\tin_data_event: tx == NULL");
return 0;
}
direction.ibd = &ib_direction_client_req;
direction.data = &data->in;
return data_event(contp, event, &direction);
}
static int
handle_read_req_hdr(TSCont cont, TSEvent event ATS_UNUSED, void *edata)
{
TSHttpTxn txn = (TSHttpTxn) edata;
config_t *config;
void *txnd;
config = (config_t *) TSContDataGet(cont);
txnd = (void *) get_effective_host(txn); // low bit left 0 because we do not know that remap succeeded yet
TSHttpTxnArgSet(txn, config->txn_slot, txnd);
TSHttpTxnReenable(txn, TS_EVENT_HTTP_CONTINUE);
TSDebug(DEBUG_TAG, "Read Req Handler Finished");
return 0;
}
static int
transform_handler(TSCont contp, TSEvent event, void *edata)
{
/* Check to see if the transformation has been closed by a call to
TSVConnClose. */
if (TSVConnClosedGet(contp)) {
TSDebug("strans", "transformation closed");
transform_destroy(contp);
return 0;
} else {
TransformData *data;
int val = 0;
data = (TransformData *)TSContDataGet(contp);
if (data == NULL) {
TSError("Didn't get Continuation's Data. Ignoring Event..");
return 0;
}
TSDebug("strans", "transform handler event [%d], data->state = [%d]",
event, data->state);
do {
switch (data->state) {
case STATE_BUFFER:
val = transform_buffer_event(contp, data, event, edata);
break;
case STATE_CONNECT:
val = transform_connect_event(contp, data, event, edata);
break;
case STATE_WRITE:
val = transform_write_event(contp, data, event, edata);
break;
case STATE_READ_STATUS:
val = transform_read_status_event(contp, data, event, edata);
break;
case STATE_READ:
val = transform_read_event(contp, data, event, edata);
break;
case STATE_BYPASS:
val = transform_bypass_event(contp, data, event, edata);
break;
}
} while (val);
}
return 0;
}
static int
bnull_transform(TSCont contp, TSEvent event, void *edata)
{
/* Check to see if the transformation has been closed by a
call to TSVConnClose. */
if (TSVConnClosedGet(contp)) {
my_data_destroy(TSContDataGet(contp));
TSContDestroy(contp);
} else {
switch (event) {
case TS_EVENT_ERROR:{
TSVIO write_vio;
/* Get the write VIO for the write operation that was
performed on ourself. This VIO contains the continuation of
our parent transformation. */
write_vio = TSVConnWriteVIOGet(contp);
/* Call back the write VIO continuation to let it know that we
have completed the write operation. */
TSContCall(TSVIOContGet(write_vio), TS_EVENT_ERROR, write_vio);
break;
}
case TS_EVENT_VCONN_WRITE_COMPLETE:
/* When our output connection says that it has finished
reading all the data we've written to it then we should
shutdown the write portion of its connection to
indicate that we don't want to hear about it anymore. */
TSVConnShutdown(TSTransformOutputVConnGet(contp), 0, 1);
break;
case TS_EVENT_VCONN_WRITE_READY:
default:
/* If we get a WRITE_READY event or any other type of event
(sent, perhaps, because we were reenabled) then we'll attempt
to transform more data. */
handle_transform(contp);
break;
}
}
return 0;
}
/**
* Engine Manager Control Channel continuation.
*
* This polls and takes action on commands to IronBee.
*
* @param[in] contp Pointer to the continuation.
* @param[in] event Event from ATS. Unused.
* @param[in] edata Event data. Unused.
*
* @returns
* - 0 On success.
* - -1 On error.
*/
static int manager_ctl(TSCont contp, TSEvent event, void *edata)
{
module_data_t *mod_data = (module_data_t *)(TSContDataGet(contp));
if (ib_engine_manager_control_ready(mod_data->manager_ctl)) {
ib_status_t rc;
rc = ib_engine_manager_control_recv(mod_data->manager_ctl, false);
if (rc != IB_EAGAIN && rc != IB_OK) {
TSError("[ironbee] Error processing message: %s",
ib_status_to_string(rc));
return -1;
}
}
return 0;
}
/* Imlement the server intercept */
static int
hc_intercept(TSCont contp, TSEvent event, void *edata)
{
HCState *my_state = TSContDataGet(contp);
if (event == TS_EVENT_NET_ACCEPT) {
my_state->net_vc = (TSVConn)edata;
hc_process_accept(contp, my_state);
} else if (edata == my_state->read_vio) { /* All read events */
hc_process_read(contp, event, my_state);
} else if (edata == my_state->write_vio) { /* All write events */
hc_process_write(contp, event, my_state);
} else {
TSReleaseAssert(!"Unexpected Event");
}
return 0;
}
/* This is the main continuation, triggered after DoRemap has decided we should
handle this request internally. */
static int
purge_cont(TSCont contp, TSEvent event, void *edata)
{
TSHttpTxn txnp = (TSHttpTxn)edata;
PurgeInstance *purge = (PurgeInstance *)TSContDataGet(contp);
switch (event) {
case TS_EVENT_HTTP_SEND_RESPONSE_HDR:
return on_send_response_header(txnp, contp, purge);
break;
default:
TSDebug(PLUGIN_NAME, "Unexpected event: %d", event);
break;
}
return TS_SUCCESS;
}
