/**
* Process data from ATS.
*
* Process data from one of the ATS events.
*
* @param[in,out] contp - the continuation
* @param[in,out] ibd - the filter descriptor
*/
static void process_data(TSCont contp, ibd_ctx *ibd)
{
int64_t ntodo;
int64_t navail;
TSIOBufferReader input_reader, output_reader;
TSIOBufferBlock block;
const char *buf;
int64_t nbytes;
ib_status_t rc;
tsib_filter_ctx *fctx = ibd->data;
tsib_txn_ctx *txndata = TSContDataGet(contp);
TSVIO input_vio = TSVConnWriteVIOGet(contp);
TSIOBuffer in_buf = TSVIOBufferGet(input_vio);
/* Test whether we're going into an errordoc */
if (HTTP_CODE(txndata->status)) { /* We're going to an error document,
* so we discard all this data
*/
ib_log_debug2_tx(txndata->tx, "Status is %d, discarding", txndata->status);
ibd->data->buffering = IOBUF_DISCARD;
}
/* Test for EOS */
if (in_buf == NULL) {
if (fctx->output_buffer != NULL) {
/* flush anything we have buffered. This is final! */
rc = flush_data(fctx, -1, 1);
switch(rc) {
case IB_OK:
break;
case IB_EBADVAL:
ib_log_error_tx(txndata->tx, "Bad/Inconsistent stream edit(s) ignored.");
break;
default: /* Can't happen unless a new status is introduced */
ib_log_error_tx(txndata->tx, "Unhandled return value %d", rc);
break;
}
}
else {
/* I guess NULL input may mean something other than EOS.
* This appears to be possible when
* processing an HTTP error from the backend.
*/
ib_log_debug2_tx(txndata->tx, "Filter input was null. No filtering.");
/* RNS-1268: seems we may have to go through all the motions
* of creating and enabling an output_vio with no data.
*/
fctx->output_buffer = TSIOBufferCreate();
ib_mm_register_cleanup(txndata->tx->mm,
(ib_mm_cleanup_fn_t) TSIOBufferDestroy,
(void*) fctx->output_buffer);
output_reader = TSIOBufferReaderAlloc(fctx->output_buffer);
fctx->output_vio = TSVConnWrite(TSTransformOutputVConnGet(contp), contp, output_reader, 0);
TSVIOReenable(fctx->output_vio);
}
return;
}
/* Test for first time, and initialise. */
if (!fctx->output_buffer) {
// FIXME - What to choose here and why?
int64_t output_vio_sz = TSVIONBytesGet(input_vio);
// NOTE: Using INT64_MAX asserts on 4.2.2: InkAPI.cc:6261: failed assert `sdk_sanity_check_iocore_structure(connp) == TS_SUCCESS`
//int64_t output_vio_sz = INT64_MAX;
// NOTE: Does it matter that this is only INT32_MAX as in the examples?
// int64_t output_vio_sz = INT32_MAX;
//int64_t output_vio_sz = fctx->have_edits
// ? INT64_MAX
// : TSVIONBytesGet(input_vio);
fctx->output_buffer = TSIOBufferCreate();
ib_mm_register_cleanup(txndata->tx->mm,
(ib_mm_cleanup_fn_t) TSIOBufferDestroy,
(void*) fctx->output_buffer);
// FIXME - Where is TSIOBufferReaderFree()?
output_reader = TSIOBufferReaderAlloc(fctx->output_buffer);
fctx->output_vio = TSVConnWrite(TSTransformOutputVConnGet(contp), contp, output_reader, output_vio_sz);
fctx->buffer = TSIOBufferCreate();
ib_mm_register_cleanup(txndata->tx->mm,
(ib_mm_cleanup_fn_t) TSIOBufferDestroy,
(void*) fctx->buffer);
// FIXME - Where is TSIOBufferReaderFree()?
fctx->reader = TSIOBufferReaderAlloc(fctx->buffer);
/* Get the buffering config */
if (!HTTP_CODE(txndata->status)) {
buffer_init(ibd, txndata->tx);
}
}
/* Get any unprocessed bytes. */
ntodo = TSVIONTodoGet(input_vio);
/* Test for EOS */
if (ntodo == 0) {
ib_log_debug2_tx(txndata->tx, "ntodo zero before consuming data");
flush_data(fctx, -1, 1);
/* Call back the input VIO continuation to let it know that we
* have completed the write operation.
*/
TSContCall(TSVIOContGet(input_vio), TS_EVENT_VCONN_WRITE_COMPLETE, input_vio);
return;
}
/* OK, there's some input awaiting our attention */
input_reader = TSVIOReaderGet(input_vio);
while (navail = TSIOBufferReaderAvail(input_reader), navail > 0) {
block = TSIOBufferReaderStart(input_reader);
buf = TSIOBufferBlockReadStart(block, input_reader, &nbytes);
rc = (*ibd->ibd->ib_notify_body)(txndata->tx->ib, txndata->tx, buf, nbytes);
if (rc != IB_OK) {
ib_log_error_tx(txndata->tx, "Error %d notifying body data.", rc);
}
rc = buffer_data_chunk(fctx, input_reader, nbytes);
switch (rc) {
case IB_EAGAIN:
case IB_OK:
break;
case IB_EBADVAL:
ib_log_error_tx(txndata->tx, "Bad/Inconsistent stream edit(s) ignored.");
break;
default: /* Can't happen unless a new status is introduced */
ib_log_error_tx(txndata->tx, "Unhandled return value %d", rc);
break;
}
TSIOBufferReaderConsume(input_reader, nbytes);
TSVIONDoneSet(input_vio, TSVIONDoneGet(input_vio) + nbytes);
}
ntodo = TSVIONTodoGet(input_vio);
if (ntodo == 0) {
ib_log_debug2_tx(txndata->tx, "ntodo zero after consuming data");
flush_data(fctx, -1, 1);
/* Call back the input VIO continuation to let it know that we
* have completed the write operation.
*/
TSContCall(TSVIOContGet(input_vio), TS_EVENT_VCONN_WRITE_COMPLETE, input_vio);
}
else {
/* Call back the input VIO continuation to let it know that we
* are ready for more data.
*/
TSContCall(TSVIOContGet(input_vio), TS_EVENT_VCONN_WRITE_READY, input_vio);
}
}
static void
handle_transform(TSCont contp)
{
TSVConn output_conn;
TSIOBuffer buf_test;
TSVIO input_vio;
MyData *data;
int64_t towrite;
int64_t avail;
TSDebug("null-transform", "Entering handle_transform()");
/* Get the output (downstream) vconnection where we'll write data to. */
output_conn = TSTransformOutputVConnGet(contp);
/* Get the write VIO for the write operation that was performed on
* ourself. This VIO contains the buffer that we are to read from
* as well as the continuation we are to call when the buffer is
* empty. This is the input VIO (the write VIO for the upstream
* vconnection).
*/
input_vio = TSVConnWriteVIOGet(contp);
/* 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();
data->output_buffer = TSIOBufferCreate();
data->output_reader = TSIOBufferReaderAlloc(data->output_buffer);
TSDebug("null-transform", "\tWriting %" PRId64 " bytes on VConn", TSVIONBytesGet(input_vio));
// data->output_vio = TSVConnWrite(output_conn, contp, data->output_reader, INT32_MAX);
data->output_vio = TSVConnWrite(output_conn, contp, data->output_reader, INT64_MAX);
// data->output_vio = TSVConnWrite(output_conn, contp, data->output_reader, TSVIONBytesGet(input_vio));
TSContDataSet(contp, data);
}
/* We also check to see if the input VIO's buffer is non-NULL. A
* NULL buffer indicates that the write operation has been
* shutdown and that the upstream continuation does not want us to send any
* more WRITE_READY or WRITE_COMPLETE events. For this simplistic
* transformation that means we're done. In a more complex
* transformation we might have to finish writing the transformed
* data to our output connection.
*/
buf_test = TSVIOBufferGet(input_vio);
if (!buf_test) {
TSVIONBytesSet(data->output_vio, TSVIONDoneGet(input_vio));
TSVIOReenable(data->output_vio);
return;
}
/* Determine how much data we have left to read. For this null
* transform plugin this is also the amount of data we have left
* to write to the output connection.
*/
towrite = TSVIONTodoGet(input_vio);
TSDebug("null-transform", "\ttoWrite is %" PRId64 "", towrite);
if (towrite > 0) {
/* The amount of data left to read needs to be truncated by
* the amount of data actually in the read buffer.
*/
avail = TSIOBufferReaderAvail(TSVIOReaderGet(input_vio));
TSDebug("null-transform", "\tavail is %" PRId64 "", avail);
if (towrite > avail) {
towrite = avail;
}
if (towrite > 0) {
/* Copy the data from the read buffer to the output buffer. */
TSIOBufferCopy(TSVIOBufferGet(data->output_vio), TSVIOReaderGet(input_vio), towrite, 0);
/* Tell the read buffer that we have read the data and are no
* longer interested in it.
*/
TSIOBufferReaderConsume(TSVIOReaderGet(input_vio), towrite);
/* Modify the input VIO to reflect how much data we've
* completed.
*/
TSVIONDoneSet(input_vio, TSVIONDoneGet(input_vio) + towrite);
}
}
/* Now we check the input VIO to see if there is data left to
* read.
*/
if (TSVIONTodoGet(input_vio) > 0) {
if (towrite > 0) {
/* If there is data left to read, then we reenable the output
* connection by reenabling the output VIO. This will wake up
* the output connection and allow it to consume data from the
* output buffer.
*/
TSVIOReenable(data->output_vio);
/* Call back the input VIO continuation to let it know that we
* are ready for more data.
*/
TSContCall(TSVIOContGet(input_vio), TS_EVENT_VCONN_WRITE_READY, input_vio);
}
} else {
/* If there is no data left to read, then we modify the output
* VIO to reflect how much data the output connection should
* expect. This allows the output connection to know when it
* is done reading. We then reenable the output connection so
* that it can consume the data we just gave it.
*/
TSVIONBytesSet(data->output_vio, TSVIONDoneGet(input_vio));
TSVIOReenable(data->output_vio);
/* Call back the input VIO continuation to let it know that we
* have completed the write operation.
*/
TSContCall(TSVIOContGet(input_vio), TS_EVENT_VCONN_WRITE_COMPLETE, input_vio);
}
}
static void
handle_transform(TSCont contp)
{
TSVConn output_conn;
TSVIO write_vio;
MyData *data;
int64_t towrite;
/* Get the output connection where we'll write data to. */
output_conn = TSTransformOutputVConnGet(contp);
/* Get the write VIO for the write operation that was performed on
ourself. This VIO contains the buffer that we are to read from
as well as the continuation we are to call when the buffer is
empty. */
write_vio = TSVConnWriteVIOGet(contp);
/* 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) {
towrite = TSVIONBytesGet(write_vio);
if (towrite != INT64_MAX) {
towrite += append_buffer_length;
}
data = my_data_alloc();
data->output_buffer = TSIOBufferCreate();
data->output_reader = TSIOBufferReaderAlloc(data->output_buffer);
data->output_vio = TSVConnWrite(output_conn, contp, data->output_reader, towrite);
TSContDataSet(contp, data);
}
/* We also check to see if the write VIO's buffer is non-NULL. A
NULL buffer indicates that the write operation has been
shutdown and that the continuation does not want us to send any
more WRITE_READY or WRITE_COMPLETE events. For this simplistic
transformation that means we're done. In a more complex
transformation we might have to finish writing the transformed
data to our output connection. */
if (!TSVIOBufferGet(write_vio)) {
if (data->append_needed) {
data->append_needed = 0;
TSIOBufferCopy(TSVIOBufferGet(data->output_vio), append_buffer_reader, append_buffer_length, 0);
}
TSVIONBytesSet(data->output_vio, TSVIONDoneGet(write_vio) + append_buffer_length);
TSVIOReenable(data->output_vio);
return;
}
/* Determine how much data we have left to read. For this append
transform plugin this is also the amount of data we have left
to write to the output connection. */
towrite = TSVIONTodoGet(write_vio);
if (towrite > 0) {
/* The amount of data left to read needs to be truncated by
the amount of data actually in the read buffer. */
int64_t avail = TSIOBufferReaderAvail(TSVIOReaderGet(write_vio));
if (towrite > avail) {
towrite = avail;
}
if (towrite > 0) {
/* Copy the data from the read buffer to the output buffer. */
TSIOBufferCopy(TSVIOBufferGet(data->output_vio), TSVIOReaderGet(write_vio), towrite, 0);
/* Tell the read buffer that we have read the data and are no
longer interested in it. */
TSIOBufferReaderConsume(TSVIOReaderGet(write_vio), towrite);
/* Modify the write VIO to reflect how much data we've
completed. */
TSVIONDoneSet(write_vio, TSVIONDoneGet(write_vio) + towrite);
}
}
/* Now we check the write VIO to see if there is data left to
read. */
if (TSVIONTodoGet(write_vio) > 0) {
if (towrite > 0) {
/* If there is data left to read, then we reenable the output
connection by reenabling the output VIO. This will wakeup
the output connection and allow it to consume data from the
output buffer. */
TSVIOReenable(data->output_vio);
/* Call back the write VIO continuation to let it know that we
are ready for more data. */
TSContCall(TSVIOContGet(write_vio), TS_EVENT_VCONN_WRITE_READY, write_vio);
}
} else {
if (data->append_needed) {
data->append_needed = 0;
TSIOBufferCopy(TSVIOBufferGet(data->output_vio), append_buffer_reader, append_buffer_length, 0);
}
/* If there is no data left to read, then we modify the output
VIO to reflect how much data the output connection should
expect. This allows the output connection to know when it
is done reading. We then reenable the output connection so
that it can consume the data we just gave it. */
TSVIONBytesSet(data->output_vio, TSVIONDoneGet(write_vio) + append_buffer_length);
TSVIOReenable(data->output_vio);
/* Call back the write VIO continuation to let it know that we
have completed the write operation. */
TSContCall(TSVIOContGet(write_vio), TS_EVENT_VCONN_WRITE_COMPLETE, write_vio);
}
}
static void process_data(TSCont contp, ibd_ctx* ibd)
{
TSVConn output_conn;
TSIOBuffer buf_test;
TSVIO input_vio;
ib_txn_ctx *data;
int64_t towrite;
int64_t avail;
int first_time = 0;
char *bufp = NULL;
TSDebug("ironbee", "Entering process_data()");
/* Get the output (downstream) vconnection where we'll write data to. */
output_conn = TSTransformOutputVConnGet(contp);
/* Get the write VIO for the write operation that was performed on
* ourself. This VIO contains the buffer that we are to read from
* as well as the continuation we are to call when the buffer is
* empty. This is the input VIO (the write VIO for the upstream
* vconnection).
*/
input_vio = TSVConnWriteVIOGet(contp);
data = TSContDataGet(contp);
if (!ibd->data->output_buffer) {
first_time = 1;
ibd->data->output_buffer = TSIOBufferCreate();
ibd->data->output_reader = TSIOBufferReaderAlloc(ibd->data->output_buffer);
TSDebug("ironbee", "\tWriting %d bytes on VConn", TSVIONBytesGet(input_vio));
ibd->data->output_vio = TSVConnWrite(output_conn, contp, ibd->data->output_reader, INT64_MAX);
}
if (ibd->data->buf) {
/* this is the second call to us, and we have data buffered.
* Feed buffered data to ironbee
*/
ib_conndata_t icdata;
icdata.ib = ironbee;
icdata.mp = data->ssn->iconn->mp;
icdata.conn = data->ssn->iconn;
icdata.dalloc = ibd->data->buflen;
icdata.dlen = ibd->data->buflen;
icdata.data = (uint8_t *)ibd->data->buf;
(*ibd->ibd->ib_notify)(ironbee, &icdata);
TSfree(ibd->data->buf);
ibd->data->buf = NULL;
ibd->data->buflen = 0;
}
/* test for input data */
buf_test = TSVIOBufferGet(input_vio);
if (!buf_test) {
TSDebug("ironbee", "No more data, finishing");
TSVIONBytesSet(ibd->data->output_vio, TSVIONDoneGet(input_vio));
TSVIOReenable(ibd->data->output_vio);
/* FIXME - is this right here - can conn data be kept across reqs? */
ibd->data->output_buffer = NULL;
ibd->data->output_reader = NULL;
ibd->data->output_vio = NULL;
return;
}
/* Determine how much data we have left to read. For this null
* transform plugin this is also the amount of data we have left
* to write to the output connection.
*/
towrite = TSVIONTodoGet(input_vio);
TSDebug("ironbee", "\ttoWrite is %" PRId64 "", towrite);
if (towrite > 0) {
/* The amount of data left to read needs to be truncated by
* the amount of data actually in the read buffer.
*/
/* first time through, we have to buffer the data until
* after the headers have been sent. Ugh!
*/
if (first_time) {
bufp = ibd->data->buf = TSmalloc(towrite);
ibd->data->buflen = towrite;
}
avail = TSIOBufferReaderAvail(TSVIOReaderGet(input_vio));
TSDebug("ironbee", "\tavail is %" PRId64 "", avail);
if (towrite > avail) {
towrite = avail;
}
if (towrite > 0) {
int btowrite = towrite;
/* Copy the data from the read buffer to the output buffer. */
TSIOBufferCopy(TSVIOBufferGet(ibd->data->output_vio), TSVIOReaderGet(input_vio), towrite, 0);
/* feed the data to ironbee, and consume them */
while (btowrite > 0) {
ib_conndata_t icdata;
int64_t ilength;
TSIOBufferReader input_reader = TSVIOReaderGet(input_vio);
TSIOBufferBlock blkp = TSIOBufferReaderStart(input_reader);
const char *ibuf = TSIOBufferBlockReadStart(blkp, input_reader, &ilength);
/* feed it to ironbee or to buffer */
if (first_time) {
memcpy(bufp, ibuf, ilength);
bufp += ilength;
}
else {
icdata.ib = ironbee;
icdata.mp = data->ssn->iconn->mp;
icdata.conn = data->ssn->iconn;
icdata.dalloc = ilength;
icdata.dlen = ilength;
icdata.data = (uint8_t *)ibuf;
(*ibd->ibd->ib_notify)(ironbee, &icdata);
}
//"response", TSHttpTxnClientRespGet, ib_state_notify_conn_data_out
// ib_state_notify_conn_data_out(ironbee, &icdata);
/* and mark it as all consumed */
btowrite -= ilength;
TSIOBufferReaderConsume(input_reader, ilength);
TSVIONDoneSet(input_vio, TSVIONDoneGet(input_vio) + ilength);
}
}
}
/* Now we check the input VIO to see if there is data left to
* read.
*/
if (TSVIONTodoGet(input_vio) > 0) {
if (towrite > 0) {
/* If there is data left to read, then we reenable the output
* connection by reenabling the output VIO. This will wake up
* the output connection and allow it to consume data from the
* output buffer.
*/
TSVIOReenable(ibd->data->output_vio);
/* Call back the input VIO continuation to let it know that we
* are ready for more data.
*/
TSContCall(TSVIOContGet(input_vio), TS_EVENT_VCONN_WRITE_READY, input_vio);
}
} else {
/* If there is no data left to read, then we modify the output
* VIO to reflect how much data the output connection should
* expect. This allows the output connection to know when it
* is done reading. We then reenable the output connection so
* that it can consume the data we just gave it.
*/
TSVIONBytesSet(ibd->data->output_vio, TSVIONDoneGet(input_vio));
TSVIOReenable(ibd->data->output_vio);
/* Call back the input VIO continuation to let it know that we
* have completed the write operation.
*/
TSContCall(TSVIOContGet(input_vio), TS_EVENT_VCONN_WRITE_COMPLETE, input_vio);
}
}
static int
ts_lua_transform_handler(TSCont contp, ts_lua_http_transform_ctx *transform_ctx, TSEvent event, int n)
{
TSVConn output_conn;
TSVIO input_vio;
TSIOBufferReader input_reader;
TSIOBufferBlock blk;
int64_t toread, towrite, blk_len, upstream_done, input_avail, input_wm_bytes, l;
const char *start;
const char *res;
size_t res_len;
int ret, eos, write_down, rc, top, empty_input;
ts_lua_coroutine *crt;
ts_lua_cont_info *ci;
lua_State *L;
TSMutex mtxp;
ci = &transform_ctx->cinfo;
crt = &ci->routine;
mtxp = crt->mctx->mutexp;
L = crt->lua;
output_conn = TSTransformOutputVConnGet(contp);
input_vio = TSVConnWriteVIOGet(contp);
empty_input = 0;
if (!TSVIOBufferGet(input_vio)) {
if (transform_ctx->output.vio) {
TSDebug(TS_LUA_DEBUG_TAG, "[%s] reenabling output VIO after input VIO does not exist", __FUNCTION__);
TSVIONBytesSet(transform_ctx->output.vio, transform_ctx->total);
TSVIOReenable(transform_ctx->output.vio);
return 0;
} else {
TSDebug(TS_LUA_DEBUG_TAG, "[%s] no input VIO and output VIO", __FUNCTION__);
empty_input = 1;
}
} else { // input VIO exists
input_wm_bytes = TSIOBufferWaterMarkGet(TSVIOBufferGet(input_vio));
if (transform_ctx->upstream_watermark_bytes >= 0 && transform_ctx->upstream_watermark_bytes != input_wm_bytes) {
TSDebug(TS_LUA_DEBUG_TAG, "[%s] Setting input_vio watermark to %" PRId64 " bytes", __FUNCTION__,
transform_ctx->upstream_watermark_bytes);
TSIOBufferWaterMarkSet(TSVIOBufferGet(input_vio), transform_ctx->upstream_watermark_bytes);
}
}
if (empty_input == 0) {
input_reader = TSVIOReaderGet(input_vio);
}
if (!transform_ctx->output.buffer) {
transform_ctx->output.buffer = TSIOBufferCreate();
transform_ctx->output.reader = TSIOBufferReaderAlloc(transform_ctx->output.buffer);
transform_ctx->reserved.buffer = TSIOBufferCreate();
transform_ctx->reserved.reader = TSIOBufferReaderAlloc(transform_ctx->reserved.buffer);
if (empty_input == 0) {
transform_ctx->upstream_bytes = TSVIONBytesGet(input_vio);
} else {
transform_ctx->upstream_bytes = 0;
}
transform_ctx->downstream_bytes = INT64_MAX;
}
if (empty_input == 0) {
input_avail = TSIOBufferReaderAvail(input_reader);
upstream_done = TSVIONDoneGet(input_vio);
toread = TSVIONTodoGet(input_vio);
if (toread <= input_avail) { // upstream finished
eos = 1;
} else {
eos = 0;
}
} else {
input_avail = 0;
toread = 0;
eos = 1;
}
if (input_avail > 0) {
// move to the reserved.buffer
TSIOBufferCopy(transform_ctx->reserved.buffer, input_reader, input_avail, 0);
// reset input
TSIOBufferReaderConsume(input_reader, input_avail);
TSVIONDoneSet(input_vio, upstream_done + input_avail);
}
write_down = 0;
if (empty_input == 0) {
towrite = TSIOBufferReaderAvail(transform_ctx->reserved.reader);
} else {
towrite = 0;
}
TSMutexLock(mtxp);
ts_lua_set_cont_info(L, ci);
do {
if (event == TS_LUA_EVENT_COROUTINE_CONT) {
event = 0;
goto launch;
} else {
n = 2;
}
if (towrite == 0 && empty_input == 0) {
break;
}
if (empty_input == 0) {
blk = TSIOBufferReaderStart(transform_ctx->reserved.reader);
start = TSIOBufferBlockReadStart(blk, transform_ctx->reserved.reader, &blk_len);
lua_pushlightuserdata(L, transform_ctx);
lua_rawget(L, LUA_GLOBALSINDEX); /* push function */
if (towrite > blk_len) {
lua_pushlstring(L, start, (size_t)blk_len);
towrite -= blk_len;
TSIOBufferReaderConsume(transform_ctx->reserved.reader, blk_len);
} else {
lua_pushlstring(L, start, (size_t)towrite);
TSIOBufferReaderConsume(transform_ctx->reserved.reader, towrite);
towrite = 0;
}
if (!towrite && eos) {
lua_pushinteger(L, 1); /* second param, data finished */
} else {
lua_pushinteger(L, 0); /* second param, data not finish */
}
} else {
lua_pushlightuserdata(L, transform_ctx);
lua_rawget(L, LUA_GLOBALSINDEX); /* push function */
lua_pushlstring(L, "", 0);
lua_pushinteger(L, 1); /* second param, data finished */
}
launch:
rc = lua_resume(L, n);
top = lua_gettop(L);
switch (rc) {
case LUA_YIELD: // coroutine yield
TSMutexUnlock(mtxp);
return 0;
case 0: // coroutine success
if (top == 2) {
ret = lua_tointeger(L, -1); /* 0 is not finished, 1 is finished */
res = lua_tolstring(L, -2, &res_len);
} else { // what hells code are you writing ?
ret = 0;
res = NULL;
res_len = 0;
}
break;
default: // coroutine failed
TSError("[ts_lua] lua_resume failed: %s", lua_tostring(L, -1));
ret = 1;
res = NULL;
res_len = 0;
break;
}
if (res && res_len > 0) {
if (!transform_ctx->output.vio) {
l = transform_ctx->downstream_bytes;
if (ret) {
l = res_len;
}
transform_ctx->output.vio = TSVConnWrite(output_conn, contp, transform_ctx->output.reader, l); // HttpSM go on
}
TSIOBufferWrite(transform_ctx->output.buffer, res, res_len);
transform_ctx->total += res_len;
write_down = 1;
}
lua_pop(L, top);
if (ret || (eos && !towrite)) { // EOS
eos = 1;
break;
}
} while (towrite > 0);
TSMutexUnlock(mtxp);
if (eos && !transform_ctx->output.vio) {
transform_ctx->output.vio = TSVConnWrite(output_conn, contp, transform_ctx->output.reader, 0);
}
if (write_down || eos) {
TSVIOReenable(transform_ctx->output.vio);
}
if (toread > input_avail) { // upstream not finished.
if (eos) {
TSVIONBytesSet(transform_ctx->output.vio, transform_ctx->total);
if (empty_input == 0) {
TSContCall(TSVIOContGet(input_vio), TS_EVENT_VCONN_EOS, input_vio);
}
} else {
if (empty_input == 0) {
TSContCall(TSVIOContGet(input_vio), TS_EVENT_VCONN_WRITE_READY, input_vio);
}
}
} else { // upstream is finished.
TSVIONBytesSet(transform_ctx->output.vio, transform_ctx->total);
if (empty_input == 0) {
TSContCall(TSVIOContGet(input_vio), TS_EVENT_VCONN_WRITE_COMPLETE, input_vio);
}
}
return 0;
}
/**
* Process data from ATS.
*
* Process data from one of the ATS events.
*
* @param[in,out] contp - the continuation
* @param[in,out] ibd - the filter descriptor
*/
static void process_data(TSCont contp, ibd_ctx *ibd)
{
int64_t ntodo;
int64_t navail;
TSIOBufferReader input_reader, output_reader;
TSIOBufferBlock block;
const char *buf;
int64_t nbytes;
ib_status_t rc;
ib_filter_ctx *fctx = ibd->data;
ib_txn_ctx *data = TSContDataGet(contp);
TSVIO input_vio = TSVConnWriteVIOGet(contp);
TSIOBuffer in_buf = TSVIOBufferGet(input_vio);
/* Test whether we're going into an errordoc */
if (IB_HTTP_CODE(data->status)) { /* We're going to an error document,
* so we discard all this data
*/
TSDebug("ironbee", "Status is %d, discarding", data->status);
ibd->data->buffering = IOBUF_DISCARD;
}
/* Test for EOS */
if (in_buf == NULL) {
/* flush anything we have buffered. This is final! */
flush_data(fctx, -1, 1);
return;
}
ntodo = TSVIONTodoGet(input_vio);
/* Test for first time, and initialise. */
if (!fctx->output_buffer) {
fctx->output_buffer = TSIOBufferCreate();
ib_mm_register_cleanup(data->tx->mm,
(ib_mm_cleanup_fn_t) TSIOBufferDestroy,
(void*) fctx->output_buffer);
output_reader = TSIOBufferReaderAlloc(fctx->output_buffer);
fctx->output_vio = TSVConnWrite(TSTransformOutputVConnGet(contp), contp, output_reader, TSVIONBytesGet(input_vio));
fctx->buffer = TSIOBufferCreate();
ib_mm_register_cleanup(data->tx->mm,
(ib_mm_cleanup_fn_t) TSIOBufferDestroy,
(void*) fctx->buffer);
fctx->reader = TSIOBufferReaderAlloc(fctx->buffer);
/* Get the buffering config */
if (!IB_HTTP_CODE(data->status)) {
buffer_init(ibd, data->tx);
}
/* Do we still have to delay feeding the first data to Ironbee
* to keep the IB events in their proper order?
*
* Appears maybe not, so let's do nothing until it shows signs of breakage.
*/
#if BUFFER_FIRST
/* First time through we can only buffer data until headers are sent. */
fctx->first_time = 1;
input_reader = TSVIOReaderGet(input_vio);
fctx->buffered = TSIOBufferCopy(fctx->buffer, TSVIOReaderGet(input_vio),
ntodo, 0);
TSIOBufferReaderConsume(input_reader, fctx->buffered);
/* Do we need to request more input or just continue? */
TSVIONDoneSet(input_vio, fctx->buffu`ered + fctx->bytes_done);
TSContCall(TSVIOContGet(input_vio), TS_EVENT_VCONN_WRITE_READY, input_vio);
return;
#endif
}
/* second time through we have to feed already-buffered data through
* ironbee while retaining it in buffer. Regardless of what else happens.
*/
#if BUFFER_FIRST
if (fctx->first_time) {
fctx->first_time = 0;
for (block = TSIOBufferStart(fctx->buffer);
block != NULL;
block = TSIOBufferBlockNext(block)) {
//nbytes = TSIOBufferBlockDataSizeGet(block);
/* FIXME - do this without a reader ? */
buf = TSIOBufferBlockReadStart(block, fctx->reader, &nbytes);
//rc = examine_data_chunk(ibd->ibd, data->tx, buf, nbytes);
rc = (*ibd->ibd->ib_notify_body)(data->tx->ib, data->tx, buf, nbytes);
if (rc != IB_OK) {
// FIXME ???
}
}
}
#endif
/* Test for EOS */
if (ntodo == 0) {
TSDebug("[ironbee]", "ntodo zero before consuming data");
/* Call back the input VIO continuation to let it know that we
* have completed the write operation.
*/
TSContCall(TSVIOContGet(input_vio), TS_EVENT_VCONN_WRITE_COMPLETE, input_vio);
return;
}
/* OK, there's some input awaiting our attention */
input_reader = TSVIOReaderGet(input_vio);
while (navail = TSIOBufferReaderAvail(input_reader), navail > 0) {
block = TSIOBufferReaderStart(input_reader);
buf = TSIOBufferBlockReadStart(block, input_reader, &nbytes);
rc = (*ibd->ibd->ib_notify_body)(data->tx->ib, data->tx, buf, nbytes);
if (rc != IB_OK) {
// FIXME ???
}
rc = buffer_data_chunk(fctx, input_reader, nbytes);
if (rc != IB_OK) {
// FIXME ???
}
TSIOBufferReaderConsume(input_reader, nbytes);
TSVIONDoneSet(input_vio, TSVIONDoneGet(input_vio) + nbytes);
}
ntodo = TSVIONTodoGet(input_vio);
if (ntodo == 0) {
TSDebug("[ironbee]", "ntodo zero after consuming data");
/* Call back the input VIO continuation to let it know that we
* have completed the write operation.
*/
TSContCall(TSVIOContGet(input_vio), TS_EVENT_VCONN_WRITE_COMPLETE, input_vio);
}
else {
/* Call back the input VIO continuation to let it know that we
* are ready for more data.
*/
TSContCall(TSVIOContGet(input_vio), TS_EVENT_VCONN_WRITE_READY, input_vio);
}
}
