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 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); } }