You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@trafficserver.apache.org by zw...@apache.org on 2010/11/16 21:22:08 UTC
svn commit: r1035782 [17/29] - in /trafficserver/traffic/trunk:
example/add-header/ example/append-transform/ example/basic-auth/
example/blacklist-0/ example/blacklist-1/ example/bnull-transform/
example/cache_plugin/ example/cache_scan/ example/file-...
Modified: trafficserver/traffic/trunk/test/plugin/INKHttpHooksTrans/INKHttpReenableStop.c
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/test/plugin/INKHttpHooksTrans/INKHttpReenableStop.c?rev=1035782&r1=1035781&r2=1035782&view=diff
==============================================================================
--- trafficserver/traffic/trunk/test/plugin/INKHttpHooksTrans/INKHttpReenableStop.c (original)
+++ trafficserver/traffic/trunk/test/plugin/INKHttpHooksTrans/INKHttpReenableStop.c Tue Nov 16 20:22:02 2010
@@ -38,16 +38,16 @@ TODO tests of stoping an event at the se
*************************************************************************/
/*
-1. inkapi void INKHttpHookAdd(INKHttpHookID id, INKCont contp);
- Covered in INKHttpHookAdd.c
-2. inkapi void INKHttpSsnHookAdd(INKHttpSsn ssnp, INKHttpHookID id, INKCont contp);
- Called for all events except INK_HTTP_SESSION_START, INK_EVENT_MGMT_UPDATE.
-3. inkapi void INKHttpSsnReenable(INKHttpSsn ssnp, INKEvent event);
- INK_EVENT_HTTP_CONTINUE
-TODO build a test case for event INK_EVENT_HTTP_ERROR HTTP Transactions
-4. void INKHttpTxnReenable(INKHttpTxn txnp, INKEvent INK_EVENT_HTTP_ERROR)
- INK_EVENT_HTTP_CONTINUE
-TODO build a test case for event INK_EVENT_HTTP_ERROR
+1. inkapi void TSHttpHookAdd(TSHttpHookID id, TSCont contp);
+ Covered in TSHttpHookAdd.c
+2. inkapi void TSHttpSsnHookAdd(TSHttpSsn ssnp, TSHttpHookID id, TSCont contp);
+ Called for all events except TS_HTTP_SESSION_START, TS_EVENT_MGMT_UPDATE.
+3. inkapi void TSHttpSsnReenable(TSHttpSsn ssnp, TSEvent event);
+ TS_EVENT_HTTP_CONTINUE
+TODO build a test case for event TS_EVENT_HTTP_ERROR HTTP Transactions
+4. void TSHttpTxnReenable(TSHttpTxn txnp, TSEvent TS_EVENT_HTTP_ERROR)
+ TS_EVENT_HTTP_CONTINUE
+TODO build a test case for event TS_EVENT_HTTP_ERROR
*/
/**************************************************************************
Modified: trafficserver/traffic/trunk/test/plugin/INKHttpHooksTrans/INKHttpSelAlt.c
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/test/plugin/INKHttpHooksTrans/INKHttpSelAlt.c?rev=1035782&r1=1035781&r2=1035782&view=diff
==============================================================================
--- trafficserver/traffic/trunk/test/plugin/INKHttpHooksTrans/INKHttpSelAlt.c (original)
+++ trafficserver/traffic/trunk/test/plugin/INKHttpHooksTrans/INKHttpSelAlt.c Tue Nov 16 20:22:02 2010
@@ -26,10 +26,10 @@
Cannot asynchronously process this event. Same as a non-blocking event,
i.e., event does not have to be reenabled at any level.
-Tests that register, receive and process event INK_HTTP_SELECT_ALT_HOOK. This
+Tests that register, receive and process event TS_HTTP_SELECT_ALT_HOOK. This
test was written as a stand-alone plug-in since there appeared to be
interactions with other events that interfered with this event. Once this
-code works, it could be incorporated into the INKHttpTxn.c plug-in since this
+code works, it could be incorporated into the TSHttpTxn.c plug-in since this
is a test of "global" hook/event processing.
*/
@@ -38,29 +38,29 @@ is a test of "global" hook/event process
#include <sys/types.h>
#include <stdio.h>
-const char *const INKEventStrId[] = {
- "INK_EVENT_HTTP_CONTINUE", /* 60000 */
- "INK_EVENT_HTTP_ERROR", /* 60001 */
- "INK_EVENT_HTTP_READ_REQUEST_HDR", /* 60002 */
- "INK_EVENT_HTTP_OS_DNS", /* 60003 */
- "INK_EVENT_HTTP_SEND_REQUEST_HDR", /* 60004 */
- "INK_EVENT_HTTP_READ_CACHE_HDR", /* 60005 */
- "INK_EVENT_HTTP_READ_RESPONSE_HDR", /* 60006 */
- "INK_EVENT_HTTP_SEND_RESPONSE_HDR", /* 60007 */
- "INK_EVENT_HTTP_REQUEST_TRANSFORM", /* 60008 */
- "INK_EVENT_HTTP_RESPONSE_TRANSFORM", /* 60009 */
- "INK_EVENT_HTTP_SELECT_ALT", /* 60010 */
- "INK_EVENT_HTTP_TXN_START", /* 60011 */
- "INK_EVENT_HTTP_TXN_CLOSE", /* 60012 */
- "INK_EVENT_HTTP_SSN_START", /* 60013 */
- "INK_EVENT_HTTP_SSN_CLOSE", /* 60014 */
+const char *const TSEventStrId[] = {
+ "TS_EVENT_HTTP_CONTINUE", /* 60000 */
+ "TS_EVENT_HTTP_ERROR", /* 60001 */
+ "TS_EVENT_HTTP_READ_REQUEST_HDR", /* 60002 */
+ "TS_EVENT_HTTP_OS_DNS", /* 60003 */
+ "TS_EVENT_HTTP_SEND_REQUEST_HDR", /* 60004 */
+ "TS_EVENT_HTTP_READ_CACHE_HDR", /* 60005 */
+ "TS_EVENT_HTTP_READ_RESPONSE_HDR", /* 60006 */
+ "TS_EVENT_HTTP_SEND_RESPONSE_HDR", /* 60007 */
+ "TS_EVENT_HTTP_REQUEST_TRANSFORM", /* 60008 */
+ "TS_EVENT_HTTP_RESPONSE_TRANSFORM", /* 60009 */
+ "TS_EVENT_HTTP_SELECT_ALT", /* 60010 */
+ "TS_EVENT_HTTP_TXN_START", /* 60011 */
+ "TS_EVENT_HTTP_TXN_CLOSE", /* 60012 */
+ "TS_EVENT_HTTP_SSN_START", /* 60013 */
+ "TS_EVENT_HTTP_SSN_CLOSE", /* 60014 */
- "INK_EVENT_MGMT_UPDATE" /* 60100 */
+ "TS_EVENT_MGMT_UPDATE" /* 60100 */
};
/*
* We track that each hook was called using this array. We start with
- * all values set to zero, meaning that the INKEvent has not been
+ * all values set to zero, meaning that the TSEvent has not been
* received.
* There 16 entries.
*/
@@ -73,12 +73,12 @@ static int
ChkEvents(const int event)
{
int i, re = 0;
- /* INKDebug("INKHttpHook", */
- printf("ChkEvents: -- %s -- \n", INKEventStrId[index(event)]);
+ /* TSDebug("TSHttpHook", */
+ printf("ChkEvents: -- %s -- \n", TSEventStrId[index(event)]);
for (i = 0; i < inktHookTblSize; i++) {
if (!inktHookTbl[i]) {
- printf("Event [%d] %s registered and not called back\n", i, INKEventStrId[i]);
+ printf("Event [%d] %s registered and not called back\n", i, TSEventStrId[i]);
re = 1;
}
}
@@ -86,37 +86,37 @@ ChkEvents(const int event)
}
-/* event routine: for each INKHttpHookID this routine should be called
+/* event routine: for each TSHttpHookID this routine should be called
* with a matching event.
*/
static int
-INKHttpHook(INKCont contp, INKEvent event, void *eData)
+TSHttpHook(TSCont contp, TSEvent event, void *eData)
{
- INKHttpSsn ssnp = (INKHttpSsn) eData;
- INKHttpTxn txnp = (INKHttpTxn) eData;
- INKHttpAltInfo pAltInfo = (INKHttpAltInfo) eData;
+ TSHttpSsn ssnp = (TSHttpSsn) eData;
+ TSHttpTxn txnp = (TSHttpTxn) eData;
+ TSHttpAltInfo pAltInfo = (TSHttpAltInfo) eData;
float mult = 0.0;
switch (event) {
- case INK_EVENT_HTTP_SSN_START:
+ case TS_EVENT_HTTP_SSN_START:
/* Reged at the "session" level, all but
- * INK_HTTP_TXN_CLOSE_HOOK is received.
+ * TS_HTTP_TXN_CLOSE_HOOK is received.
*/
- inktHookTbl[index(INK_EVENT_HTTP_SSN_START)] = 1;
- ChkEvents(INK_EVENT_HTTP_SSN_START);
+ inktHookTbl[index(TS_EVENT_HTTP_SSN_START)] = 1;
+ ChkEvents(TS_EVENT_HTTP_SSN_START);
/* Only a global hook/event
- * INKHttpSsnHookAdd(ssnp,INK_HTTP_SELECT_ALT_HOOK,contp);
+ * TSHttpSsnHookAdd(ssnp,TS_HTTP_SELECT_ALT_HOOK,contp);
*/
- INKHttpSsnReenable(ssnp, INK_EVENT_HTTP_CONTINUE);
+ TSHttpSsnReenable(ssnp, TS_EVENT_HTTP_CONTINUE);
break;
- case INK_EVENT_HTTP_SELECT_ALT:
- inktHookTbl[index(INK_EVENT_HTTP_SELECT_ALT)] = 1;
- ChkEvents(INK_EVENT_HTTP_SELECT_ALT);
+ case TS_EVENT_HTTP_SELECT_ALT:
+ inktHookTbl[index(TS_EVENT_HTTP_SELECT_ALT)] = 1;
+ ChkEvents(TS_EVENT_HTTP_SELECT_ALT);
/* Cache hit
* Now set mult value based on cached req IP address.
@@ -129,8 +129,8 @@ INKHttpHook(INKCont contp, INKEvent even
mult = 0.0123;
- INKHttpAltInfoQualitySet(pAltInfo, mult);
- printf("INKHttpSelAtl: pAltInfo: 0x%0x8, mult: %f\n", pAltInfo, mult);
+ TSHttpAltInfoQualitySet(pAltInfo, mult);
+ printf("TSHttpSelAtl: pAltInfo: 0x%0x8, mult: %f\n", pAltInfo, mult);
/* Get the cached client req URL for this pAltInfo/multiplier value */
@@ -145,27 +145,27 @@ INKHttpHook(INKCont contp, INKEvent even
break;
default:
- INKError("INKHttpHook: undefined event [%d] received\n", event);
+ TSError("TSHttpHook: undefined event [%d] received\n", event);
break;
}
}
void
-INKPluginInit(int argc, const char *argv[])
+TSPluginInit(int argc, const char *argv[])
{
- INKCont myCont = NULL;
+ TSCont myCont = NULL;
inktHookTblSize = sizeof(inktHookTbl) / sizeof(int);
/* Create continuation */
- myCont = INKContCreate(INKHttpHook, NULL);
+ myCont = TSContCreate(TSHttpHook, NULL);
if (myCont != NULL) {
/* Reged at the "global" level, these 4 events are
* received.
*/
- INKHttpHookAdd(INK_HTTP_SSN_START_HOOK, myCont);
- INKHttpHookAdd(INK_HTTP_SELECT_ALT_HOOK, myCont);
+ TSHttpHookAdd(TS_HTTP_SSN_START_HOOK, myCont);
+ TSHttpHookAdd(TS_HTTP_SELECT_ALT_HOOK, myCont);
} else
- INKError("INKHttpHook: INKContCreate() failed \n");
+ TSError("TSHttpHook: TSContCreate() failed \n");
}
Modified: trafficserver/traffic/trunk/test/plugin/INKHttpHooksTrans/INKHttpSsnHookAdd.c
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/test/plugin/INKHttpHooksTrans/INKHttpSsnHookAdd.c?rev=1035782&r1=1035781&r2=1035782&view=diff
==============================================================================
--- trafficserver/traffic/trunk/test/plugin/INKHttpHooksTrans/INKHttpSsnHookAdd.c (original)
+++ trafficserver/traffic/trunk/test/plugin/INKHttpHooksTrans/INKHttpSsnHookAdd.c Tue Nov 16 20:22:02 2010
@@ -24,7 +24,7 @@
/*
Tests for registering/processing events at the session level.
- INKHttpSsnHookAdd( HOOK_ID is either SSN_START or SSN_CLOSE )
+ TSHttpSsnHookAdd( HOOK_ID is either SSN_START or SSN_CLOSE )
*/
@@ -34,29 +34,29 @@ Tests for registering/processing events
const char *const
- INKEventStrId[] = {
- "INK_EVENT_HTTP_CONTINUE", /* 60000 */
- "INK_EVENT_HTTP_ERROR", /* 60001 */
- "INK_EVENT_HTTP_READ_REQUEST_HDR", /* 60002 */
- "INK_EVENT_HTTP_OS_DNS", /* 60003 */
- "INK_EVENT_HTTP_SEND_REQUEST_HDR", /* 60004 */
- "INK_EVENT_HTTP_READ_CACHE_HDR", /* 60005 */
- "INK_EVENT_HTTP_READ_RESPONSE_HDR", /* 60006 */
- "INK_EVENT_HTTP_SEND_RESPONSE_HDR", /* 60007 */
- "INK_EVENT_HTTP_REQUEST_TRANSFORM", /* 60008 */
- "INK_EVENT_HTTP_RESPONSE_TRANSFORM", /* 60009 */
- "INK_EVENT_HTTP_SELECT_ALT", /* 60010 */
- "INK_EVENT_HTTP_TXN_START", /* 60011 */
- "INK_EVENT_HTTP_TXN_CLOSE", /* 60012 */
- "INK_EVENT_HTTP_SSN_START", /* 60013 */
- "INK_EVENT_HTTP_SSN_CLOSE", /* 60014 */
+ TSEventStrId[] = {
+ "TS_EVENT_HTTP_CONTINUE", /* 60000 */
+ "TS_EVENT_HTTP_ERROR", /* 60001 */
+ "TS_EVENT_HTTP_READ_REQUEST_HDR", /* 60002 */
+ "TS_EVENT_HTTP_OS_DNS", /* 60003 */
+ "TS_EVENT_HTTP_SEND_REQUEST_HDR", /* 60004 */
+ "TS_EVENT_HTTP_READ_CACHE_HDR", /* 60005 */
+ "TS_EVENT_HTTP_READ_RESPONSE_HDR", /* 60006 */
+ "TS_EVENT_HTTP_SEND_RESPONSE_HDR", /* 60007 */
+ "TS_EVENT_HTTP_REQUEST_TRANSFORM", /* 60008 */
+ "TS_EVENT_HTTP_RESPONSE_TRANSFORM", /* 60009 */
+ "TS_EVENT_HTTP_SELECT_ALT", /* 60010 */
+ "TS_EVENT_HTTP_TXN_START", /* 60011 */
+ "TS_EVENT_HTTP_TXN_CLOSE", /* 60012 */
+ "TS_EVENT_HTTP_SSN_START", /* 60013 */
+ "TS_EVENT_HTTP_SSN_CLOSE", /* 60014 */
- "INK_EVENT_MGMT_UPDATE" /* 60100 */
+ "TS_EVENT_MGMT_UPDATE" /* 60100 */
};
/*
* We track that each hook was called using this array. We start with
- * all values set to zero, meaning that the INKEvent has not been
+ * all values set to zero, meaning that the TSEvent has not been
* received.
* There 16 entries.
*/
@@ -69,9 +69,9 @@ static int inktHookTblSize;
/*********************** null-transform.c *********************************/
typedef struct
{
- INKVIO output_vio;
- INKIOBuffer output_buffer;
- INKIOBufferReader output_reader;
+ TSVIO output_vio;
+ TSIOBuffer output_buffer;
+ TSIOBufferReader output_reader;
} MyData;
static MyData *
@@ -79,7 +79,7 @@ my_data_alloc()
{
MyData *data;
- data = (MyData *) INKmalloc(sizeof(MyData));
+ data = (MyData *) TSmalloc(sizeof(MyData));
data->output_vio = NULL;
data->output_buffer = NULL;
data->output_reader = NULL;
@@ -92,24 +92,24 @@ my_data_destroy(MyData * data)
{
if (data) {
if (data->output_buffer) {
- INKIOBufferDestroy(data->output_buffer);
+ TSIOBufferDestroy(data->output_buffer);
}
- INKfree(data);
+ TSfree(data);
}
}
static void
-handle_transform(INKCont contp)
+handle_transform(TSCont contp)
{
- INKVConn output_conn;
- INKVIO input_vio;
+ TSVConn output_conn;
+ TSVIO input_vio;
MyData *data;
int towrite;
int avail;
/* Get the output (downstream) vconnection where we'll write data to. */
- output_conn = INKTransformOutputVConnGet(contp);
+ 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
@@ -117,20 +117,20 @@ handle_transform(INKCont contp)
* empty. This is the input VIO (the write VIO for the upstream
* vconnection).
*/
- input_vio = INKVConnWriteVIOGet(contp);
+ 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 = INKContDataGet(contp);
+ data = TSContDataGet(contp);
if (!data) {
data = my_data_alloc();
- data->output_buffer = INKIOBufferCreate();
- data->output_reader = INKIOBufferReaderAlloc(data->output_buffer);
- data->output_vio = INKVConnWrite(output_conn, contp, data->output_reader, INKVIONBytesGet(input_vio));
- INKContDataSet(contp, data);
+ data->output_buffer = TSIOBufferCreate();
+ data->output_reader = TSIOBufferReaderAlloc(data->output_buffer);
+ 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
@@ -141,9 +141,9 @@ handle_transform(INKCont contp)
* transformation we might have to finish writing the transformed
* data to our output connection.
*/
- if (!INKVIOBufferGet(input_vio)) {
- INKVIONBytesSet(data->output_vio, INKVIONDoneGet(input_vio));
- INKVIOReenable(data->output_vio);
+ if (!TSVIOBufferGet(input_vio)) {
+ TSVIONBytesSet(data->output_vio, TSVIONDoneGet(input_vio));
+ TSVIOReenable(data->output_vio);
return;
}
@@ -151,48 +151,48 @@ handle_transform(INKCont contp)
* transform plugin this is also the amount of data we have left
* to write to the output connection.
*/
- towrite = INKVIONTodoGet(input_vio);
+ towrite = TSVIONTodoGet(input_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.
*/
- avail = INKIOBufferReaderAvail(INKVIOReaderGet(input_vio));
+ avail = TSIOBufferReaderAvail(TSVIOReaderGet(input_vio));
if (towrite > avail) {
towrite = avail;
}
if (towrite > 0) {
/* Copy the data from the read buffer to the output buffer. */
- INKIOBufferCopy(INKVIOBufferGet(data->output_vio), INKVIOReaderGet(input_vio), towrite, 0);
+ 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.
*/
- INKIOBufferReaderConsume(INKVIOReaderGet(input_vio), towrite);
+ TSIOBufferReaderConsume(TSVIOReaderGet(input_vio), towrite);
/* Modify the input VIO to reflect how much data we've
* completed.
*/
- INKVIONDoneSet(input_vio, INKVIONDoneGet(input_vio) + towrite);
+ TSVIONDoneSet(input_vio, TSVIONDoneGet(input_vio) + towrite);
}
}
/* Now we check the input VIO to see if there is data left to
* read.
*/
- if (INKVIONTodoGet(input_vio) > 0) {
+ 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.
*/
- INKVIOReenable(data->output_vio);
+ TSVIOReenable(data->output_vio);
/* Call back the input VIO continuation to let it know that we
* are ready for more data.
*/
- INKContCall(INKVIOContGet(input_vio), INK_EVENT_VCONN_WRITE_READY, input_vio);
+ 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
@@ -201,13 +201,13 @@ handle_transform(INKCont contp)
* is done reading. We then reenable the output connection so
* that it can consume the data we just gave it.
*/
- INKVIONBytesSet(data->output_vio, INKVIONDoneGet(input_vio));
- INKVIOReenable(data->output_vio);
+ 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.
*/
- INKContCall(INKVIOContGet(input_vio), INK_EVENT_VCONN_WRITE_COMPLETE, input_vio);
+ TSContCall(TSVIOContGet(input_vio), TS_EVENT_VCONN_WRITE_COMPLETE, input_vio);
}
}
@@ -216,49 +216,49 @@ handle_transform(INKCont contp)
* that have been registered. Cut/Paste for now.
*/
static int
-null_transform(INKCont contp, INKEvent event, void *edata)
+null_transform(TSCont contp, TSEvent event, void *edata)
{
/* This is the "event(s)" that are delivered for
- * INK_EVENT_HTTP_RESPONSE_TRANSFORM.
+ * TS_EVENT_HTTP_RESPONSE_TRANSFORM.
*/
- inktHookTbl[index(INK_EVENT_HTTP_RESPONSE_TRANSFORM)] = 1;
- ChkEvents(INK_EVENT_HTTP_RESPONSE_TRANSFORM);
+ inktHookTbl[index(TS_EVENT_HTTP_RESPONSE_TRANSFORM)] = 1;
+ ChkEvents(TS_EVENT_HTTP_RESPONSE_TRANSFORM);
/* Check to see if the transformation has been closed by a call to
- * INKVConnClose.
+ * TSVConnClose.
*/
- if (INKVConnClosedGet(contp)) {
- my_data_destroy(INKContDataGet(contp));
- INKContDestroy(contp);
+ if (TSVConnClosedGet(contp)) {
+ my_data_destroy(TSContDataGet(contp));
+ TSContDestroy(contp);
return 0;
} else {
switch (event) {
- case INK_EVENT_ERROR:
+ case TS_EVENT_ERROR:
{
- INKVIO input_vio;
+ TSVIO input_vio;
/* 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 = INKVConnWriteVIOGet(contp);
+ input_vio = TSVConnWriteVIOGet(contp);
/* Call back the write VIO continuation to let it know that we
* have completed the write operation.
*/
- INKContCall(INKVIOContGet(input_vio), INK_EVENT_ERROR, input_vio);
+ TSContCall(TSVIOContGet(input_vio), TS_EVENT_ERROR, input_vio);
}
break;
- case INK_EVENT_VCONN_WRITE_COMPLETE:
+ 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.
*/
- INKVConnShutdown(INKTransformOutputVConnGet(contp), 0, 1);
+ TSVConnShutdown(TSTransformOutputVConnGet(contp), 0, 1);
break;
- case INK_EVENT_VCONN_WRITE_READY:
+ 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
@@ -275,159 +275,159 @@ null_transform(INKCont contp, INKEvent e
/* Since this is event based, it can be re-used with
- * INKHttpHookAdd()
- * INKHttpSsnHookAdd()
- * INKHttpTxnHokkAdd()
+ * TSHttpHookAdd()
+ * TSHttpSsnHookAdd()
+ * TSHttpTxnHokkAdd()
*/
static int
ChkEvents(const int event)
{
int i, re = 0;
- /* INKDebug("INKHttpSsnHookAdd", */
- printf("ChkEvents: -- %s -- \n", INKEventStrId[index(event)]);
+ /* TSDebug("TSHttpSsnHookAdd", */
+ printf("ChkEvents: -- %s -- \n", TSEventStrId[index(event)]);
for (i = 0; i < inktHookTblSize; i++) {
if (!inktHookTbl[i]) {
- printf("Event [%d] %s registered and not called back\n", i, INKEventStrId[i]);
+ printf("Event [%d] %s registered and not called back\n", i, TSEventStrId[i]);
re = 1;
}
}
return re;
}
-/* event routine: for each INKHttpHookID this routine should be called
+/* event routine: for each TSHttpHookID this routine should be called
* with a matching event.
*/
static int
-SsnHookAddEvent(INKCont contp, INKEvent event, void *eData)
+SsnHookAddEvent(TSCont contp, TSEvent event, void *eData)
{
- INKHttpSsn ssnp = (INKHttpSsn) eData;
- INKHttpTxn txnp = (INKHttpTxn) eData;
- INKVConn vconnp;
+ TSHttpSsn ssnp = (TSHttpSsn) eData;
+ TSHttpTxn txnp = (TSHttpTxn) eData;
+ TSVConn vconnp;
switch (event) {
- case INK_EVENT_HTTP_READ_REQUEST_HDR:
- inktHookTbl[index(INK_EVENT_HTTP_READ_REQUEST_HDR)] = 1;
+ case TS_EVENT_HTTP_READ_REQUEST_HDR:
+ inktHookTbl[index(TS_EVENT_HTTP_READ_REQUEST_HDR)] = 1;
/* List what events have been called back at
* this point in procesing
*/
- ChkEvents(INK_EVENT_HTTP_READ_REQUEST_HDR);
+ ChkEvents(TS_EVENT_HTTP_READ_REQUEST_HDR);
- /* TODO test for INK_HTTP_REQUEST_TRANSFORM_HOOK */
+ /* TODO test for TS_HTTP_REQUEST_TRANSFORM_HOOK */
/* This event is delivered to a transaction. Reenable the
* txnp pointer not the session.
*/
- INKHttpTxnReenable(txnp, INK_EVENT_HTTP_CONTINUE);
+ TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
break;
- case INK_EVENT_HTTP_OS_DNS:
- inktHookTbl[index(INK_EVENT_HTTP_OS_DNS)] = 1;
- ChkEvents(INK_EVENT_HTTP_OS_DNS);
- INKHttpTxnReenable(txnp, INK_EVENT_HTTP_CONTINUE);
+ case TS_EVENT_HTTP_OS_DNS:
+ inktHookTbl[index(TS_EVENT_HTTP_OS_DNS)] = 1;
+ ChkEvents(TS_EVENT_HTTP_OS_DNS);
+ TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
break;
- case INK_EVENT_HTTP_SEND_REQUEST_HDR:
- inktHookTbl[index(INK_EVENT_HTTP_SEND_REQUEST_HDR)] = 1;
- ChkEvents(INK_EVENT_HTTP_SEND_REQUEST_HDR);
- INKHttpTxnReenable(txnp, INK_EVENT_HTTP_CONTINUE);
+ case TS_EVENT_HTTP_SEND_REQUEST_HDR:
+ inktHookTbl[index(TS_EVENT_HTTP_SEND_REQUEST_HDR)] = 1;
+ ChkEvents(TS_EVENT_HTTP_SEND_REQUEST_HDR);
+ TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
break;
- case INK_EVENT_HTTP_READ_CACHE_HDR:
- inktHookTbl[index(INK_EVENT_HTTP_READ_CACHE_HDR)] = 1;
- ChkEvents(INK_EVENT_HTTP_READ_CACHE_HDR);
- INKHttpTxnReenable(txnp, INK_EVENT_HTTP_CONTINUE);
+ case TS_EVENT_HTTP_READ_CACHE_HDR:
+ inktHookTbl[index(TS_EVENT_HTTP_READ_CACHE_HDR)] = 1;
+ ChkEvents(TS_EVENT_HTTP_READ_CACHE_HDR);
+ TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
break;
- case INK_EVENT_HTTP_READ_RESPONSE_HDR:
- inktHookTbl[index(INK_EVENT_HTTP_READ_RESPONSE_HDR)] = 1;
- ChkEvents(INK_EVENT_HTTP_READ_RESPONSE_HDR);
+ case TS_EVENT_HTTP_READ_RESPONSE_HDR:
+ inktHookTbl[index(TS_EVENT_HTTP_READ_RESPONSE_HDR)] = 1;
+ ChkEvents(TS_EVENT_HTTP_READ_RESPONSE_HDR);
#error FIX Check if event is transformable using code from null-transform.c
/* TODO fix check if event is transformable
* Using code from null-transform.c
*/
- vconnp = INKTransformCreate(null_transform, txnp);
+ vconnp = TSTransformCreate(null_transform, txnp);
/* TODO verify
* should be:
- * INK_EVENT_HTTP_READ_REQUEST_HDR_HOOK
- * INK_HTTP_REQUEST_TRANSFORM_HOOK
+ * TS_EVENT_HTTP_READ_REQUEST_HDR_HOOK
+ * TS_HTTP_REQUEST_TRANSFORM_HOOK
* for
- * INK_EVENT_HTTP_READ_RESPONSE_HDR_HOOK
- * INK_HTTP_RESPONSE_TRANSFORM_HOOK
+ * TS_EVENT_HTTP_READ_RESPONSE_HDR_HOOK
+ * TS_HTTP_RESPONSE_TRANSFORM_HOOK
* Registering with a new continuation / callback.
*/
- INKHttpTxnReenable(txnp, INK_EVENT_HTTP_CONTINUE);
+ TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
break;
- case INK_EVENT_HTTP_SEND_RESPONSE_HDR:
- inktHookTbl[index(INK_EVENT_HTTP_SEND_RESPONSE_HDR)] = 1;
- ChkEvents(INK_EVENT_HTTP_SEND_RESPONSE_HDR);
- INKHttpTxnReenable(txnp, INK_EVENT_HTTP_CONTINUE);
+ case TS_EVENT_HTTP_SEND_RESPONSE_HDR:
+ inktHookTbl[index(TS_EVENT_HTTP_SEND_RESPONSE_HDR)] = 1;
+ ChkEvents(TS_EVENT_HTTP_SEND_RESPONSE_HDR);
+ TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
break;
- case INK_EVENT_HTTP_REQUEST_TRANSFORM:
- inktHookTbl[index(INK_EVENT_HTTP_REQUEST_TRANSFORM)] = 1;
- ChkEvents(INK_EVENT_HTTP_REQUEST_TRANSFORM);
- INKHttpTxnReenable(txnp, INK_EVENT_HTTP_CONTINUE);
+ case TS_EVENT_HTTP_REQUEST_TRANSFORM:
+ inktHookTbl[index(TS_EVENT_HTTP_REQUEST_TRANSFORM)] = 1;
+ ChkEvents(TS_EVENT_HTTP_REQUEST_TRANSFORM);
+ TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
break;
- case INK_EVENT_HTTP_RESPONSE_TRANSFORM:
+ case TS_EVENT_HTTP_RESPONSE_TRANSFORM:
/* This event is not delivered here. See null_transform
- * and verify that INK_EVENT_ERROR,
- * INK_EVENT_VCONN_WRITE_COMPLETE, INK_EVENT_CVONN_WRITE_READY
+ * and verify that TS_EVENT_ERROR,
+ * TS_EVENT_VCONN_WRITE_COMPLETE, TS_EVENT_CVONN_WRITE_READY
*
* TODO do not use as a defined event if it does not get delivered
*/
- inktHookTbl[index(INK_EVENT_HTTP_RESPONSE_TRANSFORM)] = 1;
- ChkEvents(INK_EVENT_HTTP_RESPONSE_TRANSFORM);
- INKHttpTxnReenable(txnp, INK_EVENT_HTTP_CONTINUE);
+ inktHookTbl[index(TS_EVENT_HTTP_RESPONSE_TRANSFORM)] = 1;
+ ChkEvents(TS_EVENT_HTTP_RESPONSE_TRANSFORM);
+ TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
break;
- case INK_EVENT_HTTP_SELECT_ALT:
- inktHookTbl[index(INK_EVENT_HTTP_SELECT_ALT)] = 1;
- ChkEvents(INK_EVENT_HTTP_SELECT_ALT);
+ case TS_EVENT_HTTP_SELECT_ALT:
+ inktHookTbl[index(TS_EVENT_HTTP_SELECT_ALT)] = 1;
+ ChkEvents(TS_EVENT_HTTP_SELECT_ALT);
/* Non-blocking & synchronous event
*/
break;
- case INK_EVENT_HTTP_TXN_START:
- inktHookTbl[index(INK_EVENT_HTTP_TXN_START)] = 1;
- ChkEvents(INK_EVENT_HTTP_TXN_START);
- INKHttpTxnHookAdd(txnp, INK_HTTP_TXN_CLOSE_HOOK, contp);
- INKHttpTxnReenable(txnp, INK_EVENT_HTTP_CONTINUE);
+ case TS_EVENT_HTTP_TXN_START:
+ inktHookTbl[index(TS_EVENT_HTTP_TXN_START)] = 1;
+ ChkEvents(TS_EVENT_HTTP_TXN_START);
+ TSHttpTxnHookAdd(txnp, TS_HTTP_TXN_CLOSE_HOOK, contp);
+ TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
break;
- case INK_EVENT_HTTP_TXN_CLOSE:
- inktHookTbl[index(INK_EVENT_HTTP_TXN_CLOSE)] = 1;
- ChkEvents(INK_EVENT_HTTP_TXN_CLOSE);
- INKHttpTxnReenable(txnp, INK_EVENT_HTTP_CONTINUE);
+ case TS_EVENT_HTTP_TXN_CLOSE:
+ inktHookTbl[index(TS_EVENT_HTTP_TXN_CLOSE)] = 1;
+ ChkEvents(TS_EVENT_HTTP_TXN_CLOSE);
+ TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
break;
- case INK_EVENT_HTTP_SSN_START:
+ case TS_EVENT_HTTP_SSN_START:
- inktHookTbl[index(INK_EVENT_HTTP_SSN_START)] = 1;
- ChkEvents(INK_EVENT_HTTP_SSN_START); /* code re-use */
+ inktHookTbl[index(TS_EVENT_HTTP_SSN_START)] = 1;
+ ChkEvents(TS_EVENT_HTTP_SSN_START); /* code re-use */
/* For this session, register for all events */
- INKHttpSsnHookAdd(ssnp, INK_HTTP_READ_REQUEST_HDR_HOOK, contp);
- INKHttpSsnHookAdd(ssnp, INK_HTTP_OS_DNS_HOOK, contp);
- INKHttpSsnHookAdd(ssnp, INK_HTTP_SEND_REQUEST_HDR_HOOK, contp);
- INKHttpSsnHookAdd(ssnp, INK_HTTP_READ_CACHE_HDR_HOOK, contp);
- INKHttpSsnHookAdd(ssnp, INK_HTTP_READ_RESPONSE_HDR_HOOK, contp);
- INKHttpSsnHookAdd(ssnp, INK_HTTP_SEND_RESPONSE_HDR_HOOK, contp);
+ TSHttpSsnHookAdd(ssnp, TS_HTTP_READ_REQUEST_HDR_HOOK, contp);
+ TSHttpSsnHookAdd(ssnp, TS_HTTP_OS_DNS_HOOK, contp);
+ TSHttpSsnHookAdd(ssnp, TS_HTTP_SEND_REQUEST_HDR_HOOK, contp);
+ TSHttpSsnHookAdd(ssnp, TS_HTTP_READ_CACHE_HDR_HOOK, contp);
+ TSHttpSsnHookAdd(ssnp, TS_HTTP_READ_RESPONSE_HDR_HOOK, contp);
+ TSHttpSsnHookAdd(ssnp, TS_HTTP_SEND_RESPONSE_HDR_HOOK, contp);
/* These are considered "global" hooks and must be reged at
* init.
- *INKHttpSsnHookAdd(ssnp,INK_HTTP_REQUEST_TRANSFORM_HOOK,contp);
- *INKHttpSsnHookAdd(ssnp,INK_HTTP_RESPONSE_TRANSFORM_HOOK,contp);
- *INKHttpSsnHookAdd(ssnp,INK_HTTP_SELECT_ALT_HOOK, contp);
+ *TSHttpSsnHookAdd(ssnp,TS_HTTP_REQUEST_TRANSFORM_HOOK,contp);
+ *TSHttpSsnHookAdd(ssnp,TS_HTTP_RESPONSE_TRANSFORM_HOOK,contp);
+ *TSHttpSsnHookAdd(ssnp,TS_HTTP_SELECT_ALT_HOOK, contp);
*/
- INKHttpSsnHookAdd(ssnp, INK_HTTP_TXN_START_HOOK, contp);
+ TSHttpSsnHookAdd(ssnp, TS_HTTP_TXN_START_HOOK, contp);
/********************************************************
* We've already registered for this event as a global
@@ -435,54 +435,54 @@ SsnHookAddEvent(INKCont contp, INKEvent
* level will send this event twice: once for the registration
* done at PluginInit and once for the sessions.
*
- INKHttpSsnHookAdd(ssnp,INK_HTTP_SSN_START_HOOK, contp);
+ TSHttpSsnHookAdd(ssnp,TS_HTTP_SSN_START_HOOK, contp);
*******************************************************/
- INKHttpSsnHookAdd(ssnp, INK_HTTP_SSN_CLOSE_HOOK, contp);
+ TSHttpSsnHookAdd(ssnp, TS_HTTP_SSN_CLOSE_HOOK, contp);
- INKHttpSsnReenable(ssnp, INK_EVENT_HTTP_CONTINUE);
+ TSHttpSsnReenable(ssnp, TS_EVENT_HTTP_CONTINUE);
break;
- case INK_EVENT_HTTP_SSN_CLOSE:
+ case TS_EVENT_HTTP_SSN_CLOSE:
/* Here as a result of:
- * INKHTTPSsnHookAdd(ssnp, INK_HTTP_SSN_CLOSE_HOOK, contp)
+ * TSHTTPSsnHookAdd(ssnp, TS_HTTP_SSN_CLOSE_HOOK, contp)
*/
- inktHookTbl[index(INK_EVENT_HTTP_SSN_CLOSE)] = 1;
+ inktHookTbl[index(TS_EVENT_HTTP_SSN_CLOSE)] = 1;
/* Assumption: at this point all other events have
* have been called. Since a session can have one or
* more transactions, the close of a session should
* prompt us to check that all events have been called back
*/
- if (ChkEvents(INK_EVENT_HTTP_SSN_CLOSE))
- INKError("INKHttpHook: Fail: All events not called back.\n");
+ if (ChkEvents(TS_EVENT_HTTP_SSN_CLOSE))
+ TSError("TSHttpHook: Fail: All events not called back.\n");
else
- INKError("INKHttpHook: Pass: All events called back.\n");
+ TSError("TSHttpHook: Pass: All events called back.\n");
- INKHttpSsnReenable(ssnp, INK_EVENT_HTTP_CONTINUE);
+ TSHttpSsnReenable(ssnp, TS_EVENT_HTTP_CONTINUE);
break;
default:
- INKError("INKHttpHook: undefined event [%d] received\n", event);
+ TSError("TSHttpHook: undefined event [%d] received\n", event);
break;
}
}
void
-INKPluginInit(int argc, const char *argv[])
+TSPluginInit(int argc, const char *argv[])
{
- INKCont myCont = NULL;
+ TSCont myCont = NULL;
inktHookTblSize = sizeof(inktHookTbl) / sizeof(int);
/* Create continuation */
- myCont = INKContCreate(SsnHookAddEvent, NULL);
+ myCont = TSContCreate(SsnHookAddEvent, NULL);
if (myCont != NULL) {
/* We need to register ourselves with a global hook
* so that we can process a session.
*/
- INKHttpHookAdd(INK_HTTP_SSN_START_HOOK, myCont);
- INKHttpHookAdd(INK_HTTP_SELECT_ALT_HOOK, myCont);
+ TSHttpHookAdd(TS_HTTP_SSN_START_HOOK, myCont);
+ TSHttpHookAdd(TS_HTTP_SELECT_ALT_HOOK, myCont);
} else
- INKError("INKHttpHook: INKContCreate() failed \n");
+ TSError("TSHttpHook: TSContCreate() failed \n");
}
Modified: trafficserver/traffic/trunk/test/plugin/INKHttpHooksTrans/INKHttpTransaction.c
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/test/plugin/INKHttpHooksTrans/INKHttpTransaction.c?rev=1035782&r1=1035781&r2=1035782&view=diff
==============================================================================
--- trafficserver/traffic/trunk/test/plugin/INKHttpHooksTrans/INKHttpTransaction.c (original)
+++ trafficserver/traffic/trunk/test/plugin/INKHttpHooksTrans/INKHttpTransaction.c Tue Nov 16 20:22:02 2010
@@ -26,24 +26,24 @@
static int
-handle_HTTP_SEND_RESPONSE_HDR(INKCont contp, INKEvent event, void *eData)
+handle_HTTP_SEND_RESPONSE_HDR(TSCont contp, TSEvent event, void *eData)
{
- INKMBuffer buffer;
- INKMLoc buffOffset;
- INKHttpTxn txnp = (INKHttpTxn) contp;
+ TSMBuffer buffer;
+ TSMLoc buffOffset;
+ TSHttpTxn txnp = (TSHttpTxn) contp;
int re = 0, err = 0;
- re = INKHttpTxnCachedReqGet(txnp, &buffer, &buffOffset);
+ re = TSHttpTxnCachedReqGet(txnp, &buffer, &buffOffset);
if (re) {
- INKDebug("INKHttpTransaction", "INKHttpTxnCachedReqGet(): INK_EVENT_HTTP_SEND_RESPONSE_HDR, and txnp set\n");
+ TSDebug("TSHttpTransaction", "TSHttpTxnCachedReqGet(): TS_EVENT_HTTP_SEND_RESPONSE_HDR, and txnp set\n");
/* Display all buffer contents */
} else {
- INKDebug("INKHttpTransaction", "INKHttpTxnCachedReqGet(): Failed.");
+ TSDebug("TSHttpTransaction", "TSHttpTxnCachedReqGet(): Failed.");
err++;
}
/*
-INKHttpTxnCachedRespGet (INKHttpTxn txnp, INKMBuffer *bufp, INKMLoc *offset);
+TSHttpTxnCachedRespGet (TSHttpTxn txnp, TSMBuffer *bufp, TSMLoc *offset);
*/
/* Display buffer contents */
@@ -54,40 +54,40 @@ INKHttpTxnCachedRespGet (INKHttpTxn txnp
}
static int
-handle_READ_REQUEST_HDR(INKCont cont, INKEvent event, void *eData)
+handle_READ_REQUEST_HDR(TSCont cont, TSEvent event, void *eData)
{
int err = 0;
return err;
}
static int
-handle_READ_RESPONSE_HDR(INKCont contp, INKEvent event, void *eData)
+handle_READ_RESPONSE_HDR(TSCont contp, TSEvent event, void *eData)
{
int err = 0;
return err;
}
static int
-INKHttpTransaction(INKCont contp, INKEvent event, void *eData)
+TSHttpTransaction(TSCont contp, TSEvent event, void *eData)
{
- INKHttpSsn ssnp = (INKHttpSsn) eData;
- INKHttpTxn txnp = (INKHttpTxn) eData;
+ TSHttpSsn ssnp = (TSHttpSsn) eData;
+ TSHttpTxn txnp = (TSHttpTxn) eData;
switch (event) {
- case INK_EVENT_HTTP_SEND_RESPONSE_HDR:
+ case TS_EVENT_HTTP_SEND_RESPONSE_HDR:
handle_HTTP_SEND_RESPONSE_HDR(contp, event, eData);
- INKHttpTxnReenable(txnp, INK_EVENT_HTTP_CONTINUE);
+ TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
break;
- case INK_EVENT_HTTP_READ_REQUEST_HDR:
+ case TS_EVENT_HTTP_READ_REQUEST_HDR:
handle_READ_REQUEST_HDR(contp, event, eData);
- INKHttpTxnReenable(txnp, INK_EVENT_HTTP_CONTINUE);
+ TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
break;
- case INK_EVENT_HTTP_READ_RESPONSE_HDR:
+ case TS_EVENT_HTTP_READ_RESPONSE_HDR:
handle_READ_RESPONSE_HDR(contp, event, eData);
- INKHttpTxnReenable(txnp, INK_EVENT_HTTP_CONTINUE);
+ TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
break;
default:
break;
@@ -95,8 +95,8 @@ INKHttpTransaction(INKCont contp, INKEve
}
void
-INKPluginInit(int argc, const char *argv[])
+TSPluginInit(int argc, const char *argv[])
{
- INKCont contp = INKContCreate(INKHttpTransaction, NULL);
- INKHttpHookAdd(INK_HTTP_SSN_START_HOOK, contp);
+ TSCont contp = TSContCreate(TSHttpTransaction, NULL);
+ TSHttpHookAdd(TS_HTTP_SSN_START_HOOK, contp);
}
Modified: trafficserver/traffic/trunk/test/plugin/INKHttpHooksTrans/INKHttpTxnErrBodySet.c
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/test/plugin/INKHttpHooksTrans/INKHttpTxnErrBodySet.c?rev=1035782&r1=1035781&r2=1035782&view=diff
==============================================================================
--- trafficserver/traffic/trunk/test/plugin/INKHttpHooksTrans/INKHttpTxnErrBodySet.c (original)
+++ trafficserver/traffic/trunk/test/plugin/INKHttpHooksTrans/INKHttpTxnErrBodySet.c Tue Nov 16 20:22:02 2010
@@ -26,15 +26,15 @@
/* This is a response to a client (req), which will be executed after reciept
* of:
- * INK_HTTP_SEND_RESPONSE_HDR_HOOK
+ * TS_HTTP_SEND_RESPONSE_HDR_HOOK
*
* htmlBody: text
- * INKHttpTxnErrorBodySet(txnp, htmlBody, sizeof(htmlBody), NULL);
+ * TSHttpTxnErrorBodySet(txnp, htmlBody, sizeof(htmlBody), NULL);
*
* htmlBody: other fmt (?)
- * INKHttpTxnErrorBodySet(txnp, htmlBody, sizeof(htmlBody), "image/jpeg");
+ * TSHttpTxnErrorBodySet(txnp, htmlBody, sizeof(htmlBody), "image/jpeg");
*
- * INKHttpTxnErrorBodySet(txnp, "inktomi.gif", 1308, "image/jpeg");
+ * TSHttpTxnErrorBodySet(txnp, "inktomi.gif", 1308, "image/jpeg");
*
* This api requires that a GET request of a site that does not exist or
* of a site that is not answering requests. This API will not overwrite
@@ -46,7 +46,7 @@
* GET http://www.bogusHTML.com HTTP/1.0
* GET http://www.bogusOTHER.com HTTP/1.0
*
- * retrieve the URL: INKHttpHdrURLGet()
+ * retrieve the URL: TSHttpHdrURLGet()
* strstr to parse and find a substring in the URL string
* search for the above predefined sites and return the appropriate
* body type.
@@ -54,35 +54,35 @@
* API in a single plug in.
*/
-const char *const INKEventStrId[] = {
- "INK_EVENT_HTTP_CONTINUE", /* 60000 */
- "INK_EVENT_HTTP_ERROR", /* 60001 */
- "INK_EVENT_HTTP_READ_REQUEST_HDR", /* 60002 */
- "INK_EVENT_HTTP_OS_DNS", /* 60003 */
- "INK_EVENT_HTTP_SEND_REQUEST_HDR", /* 60004 */
- "INK_EVENT_HTTP_READ_CACHE_HDR", /* 60005 */
- "INK_EVENT_HTTP_READ_RESPONSE_HDR", /* 60006 */
- "INK_EVENT_HTTP_SEND_RESPONSE_HDR", /* 60007 */
- "INK_EVENT_HTTP_REQUEST_TRANSFORM", /* 60008 */
- "INK_EVENT_HTTP_RESPONSE_TRANSFORM", /* 60009 */
- "INK_EVENT_HTTP_SELECT_ALT", /* 60010 */
- "INK_EVENT_HTTP_TXN_START", /* 60011 */
- "INK_EVENT_HTTP_TXN_CLOSE", /* 60012 */
- "INK_EVENT_HTTP_SSN_START", /* 60013 */
- "INK_EVENT_HTTP_SSN_CLOSE", /* 60014 */
+const char *const TSEventStrId[] = {
+ "TS_EVENT_HTTP_CONTINUE", /* 60000 */
+ "TS_EVENT_HTTP_ERROR", /* 60001 */
+ "TS_EVENT_HTTP_READ_REQUEST_HDR", /* 60002 */
+ "TS_EVENT_HTTP_OS_DNS", /* 60003 */
+ "TS_EVENT_HTTP_SEND_REQUEST_HDR", /* 60004 */
+ "TS_EVENT_HTTP_READ_CACHE_HDR", /* 60005 */
+ "TS_EVENT_HTTP_READ_RESPONSE_HDR", /* 60006 */
+ "TS_EVENT_HTTP_SEND_RESPONSE_HDR", /* 60007 */
+ "TS_EVENT_HTTP_REQUEST_TRANSFORM", /* 60008 */
+ "TS_EVENT_HTTP_RESPONSE_TRANSFORM", /* 60009 */
+ "TS_EVENT_HTTP_SELECT_ALT", /* 60010 */
+ "TS_EVENT_HTTP_TXN_START", /* 60011 */
+ "TS_EVENT_HTTP_TXN_CLOSE", /* 60012 */
+ "TS_EVENT_HTTP_SSN_START", /* 60013 */
+ "TS_EVENT_HTTP_SSN_CLOSE", /* 60014 */
- "INK_EVENT_MGMT_UPDATE" /* 60100 */
+ "TS_EVENT_MGMT_UPDATE" /* 60100 */
};
#define index(x) ((x)%(1000))
-/* Used in INKHttpTxnErrrorBodySet */
+/* Used in TSHttpTxnErrrorBodySet */
#define FMT_TXT_HTML ("text/html")
#define FMT_IMAGE_JPEG ("image/jpeg")
#define FMT_TXT (NULL)
-/* Body of HTML page sent by INKHttpErrorBodySet()
+/* Body of HTML page sent by TSHttpErrorBodySet()
*/
const char htmlBody[] = " \
<html> \
@@ -108,15 +108,15 @@ const char htmlBody[] = " \
/* Type can be used to display/compare request/response differently */
static void
-DisplayBufferContents(INKMBuffer bufp, INKMLoc hdr_loc, INKHttpType type)
+DisplayBufferContents(TSMBuffer bufp, TSMLoc hdr_loc, TSHttpType type)
{
- INKIOBuffer output_buffer;
- INKIOBufferReader reader;
+ TSIOBuffer output_buffer;
+ TSIOBufferReader reader;
int total_avail;
- INKIOBufferBlock block;
+ TSIOBufferBlock block;
const char *block_start;
int block_avail;
@@ -124,36 +124,36 @@ DisplayBufferContents(INKMBuffer bufp, I
char *output_string;
int output_len;
- output_buffer = INKIOBufferCreate();
+ output_buffer = TSIOBufferCreate();
if (!output_buffer) {
- INKError("couldn't allocate IOBuffer\n");
+ TSError("couldn't allocate IOBuffer\n");
}
- reader = INKIOBufferReaderAlloc(output_buffer);
+ reader = TSIOBufferReaderAlloc(output_buffer);
/****** Print the HTTP header (for either a resp or req) first ********/
- INKHttpHdrPrint(bufp, hdr_loc, output_buffer);
+ TSHttpHdrPrint(bufp, hdr_loc, output_buffer);
/* This will print MIMEFields (for either a resp or req) */
- INKMimeHdrPrint(bufp, hdr_loc, output_buffer);
+ TSMimeHdrPrint(bufp, hdr_loc, output_buffer);
/* Find out how the big the complete header is by
seeing the total bytes in the buffer. We need to
look at the buffer rather than the first block to
see the size of the entire header */
- total_avail = INKIOBufferReaderAvail(reader);
+ total_avail = TSIOBufferReaderAvail(reader);
/* Allocate the string with an extra byte for the string
terminator */
- output_string = (char *) INKmalloc(total_avail + 1);
+ output_string = (char *) TSmalloc(total_avail + 1);
output_len = 0;
/* We need to loop over all the buffer blocks to make
sure we get the complete header since the header can
be in multiple blocks */
- block = INKIOBufferReaderStart(reader);
+ block = TSIOBufferReaderStart(reader);
while (block) {
- block_start = INKIOBufferBlockReadStart(block, reader, &block_avail);
+ block_start = TSIOBufferBlockReadStart(block, reader, &block_avail);
/* We'll get a block pointer back even if there is no data
left to read so check for this condition and break out of
@@ -168,26 +168,26 @@ DisplayBufferContents(INKMBuffer bufp, I
output_len += block_avail;
/* Consume the data so that we get to the next block */
- INKIOBufferReaderConsume(reader, block_avail);
+ TSIOBufferReaderConsume(reader, block_avail);
/* Get the next block now that we've consumed the
data off the last block */
- block = INKIOBufferReaderStart(reader);
+ block = TSIOBufferReaderStart(reader);
}
/* Terminate the string */
output_string[output_len] = '\0';
output_len++;
- /* Free up the INKIOBuffer that we used to print out the header */
- INKIOBufferReaderFree(reader);
- INKIOBufferDestroy(output_buffer);
+ /* Free up the TSIOBuffer that we used to print out the header */
+ TSIOBufferReaderFree(reader);
+ TSIOBufferDestroy(output_buffer);
/* Although I'd never do this a production plugin, printf
the header so that we can see it's all there */
printf("%s", output_string);
- INKfree(output_string);
+ TSfree(output_string);
}
/* TODO this is probably not visible in a browser--get one that is */
@@ -200,68 +200,68 @@ static unsigned char marker_gif_data[] =
0x01, 0x00, 0x3b,
};
-/* Test of INKHttpTxnErrorBodySet() with an image/jpeg from
- * INK_HTTP_SSN_START. This code should be working. However,
+/* Test of TSHttpTxnErrorBodySet() with an image/jpeg from
+ * TS_HTTP_SSN_START. This code should be working. However,
* there is no such thing as the image is too small. The telnet
* client should see "GIF" in the body of the response.
*/
static int
-handle_HTTP_SSN_START(INKCont contp, INKEvent event, void *eData)
+handle_HTTP_SSN_START(TSCont contp, TSEvent event, void *eData)
{
/* Just send back the body */
- INKHttpTxn txnp = (INKHttpTxn) eData;
+ TSHttpTxn txnp = (TSHttpTxn) eData;
void *markerPtr = NULL, *fmtPtr = NULL;
int err = 0;
- INKDebug("INKHttpTxnErrorBodySet", "HTTP_SSN_START: ********* INKHttpTxnErrorBodySet\n");
+ TSDebug("TSHttpTxnErrorBodySet", "HTTP_SSN_START: ********* TSHttpTxnErrorBodySet\n");
- markerPtr = INKmalloc(sizeof(marker_gif_data));
+ markerPtr = TSmalloc(sizeof(marker_gif_data));
memcpy(markerPtr, marker_gif_data, sizeof(marker_gif_data));
- fmtPtr = INKmalloc(sizeof(FMT_IMAGE_JPEG) + 1);
+ fmtPtr = TSmalloc(sizeof(FMT_IMAGE_JPEG) + 1);
strncpy(fmtPtr, FMT_IMAGE_JPEG, sizeof(FMT_IMAGE_JPEG));
- INKHttpTxnErrorBodySet(txnp, (char *) markerPtr, sizeof(marker_gif_data), fmtPtr);
+ TSHttpTxnErrorBodySet(txnp, (char *) markerPtr, sizeof(marker_gif_data), fmtPtr);
/* TS managed space:
- * INKfree(markerPtr);
- * INKfree(fmtPtr);
+ * TSfree(markerPtr);
+ * TSfree(fmtPtr);
*/
return err;
}
-/* Test of INKHttpTxnErrorBodySet() by returning an HTML page from
- * INK_HTTP_SEND_RESPONSE hook.
+/* Test of TSHttpTxnErrorBodySet() by returning an HTML page from
+ * TS_HTTP_SEND_RESPONSE hook.
*/
static int
-handle_HTTP_SEND_RESPONSE_HDR(INKCont contp, INKEvent event, void *eData)
+handle_HTTP_SEND_RESPONSE_HDR(TSCont contp, TSEvent event, void *eData)
{
- INKMBuffer reqBuf, respBuf;
- INKMLoc reqBufLoc, respBufLoc;
- INKHttpTxn txnp = (INKHttpTxn) eData;
+ TSMBuffer reqBuf, respBuf;
+ TSMLoc reqBufLoc, respBufLoc;
+ TSHttpTxn txnp = (TSHttpTxn) eData;
void *bufPtr = NULL, *fmtPtr = NULL;
int re = 0, err = 0;
/* This is the response back to the client */
- re = INKHttpTxnClientRespGet(txnp, &respBuf, &respBufLoc);
+ re = TSHttpTxnClientRespGet(txnp, &respBuf, &respBufLoc);
if (re) {
- INKDebug("INKHttpTxnErrorBodySet", "HTTP_SEND_RESPONSE_HDR: ********* INKHttpTxnClientRespGet\n");
+ TSDebug("TSHttpTxnErrorBodySet", "HTTP_SEND_RESPONSE_HDR: ********* TSHttpTxnClientRespGet\n");
- DisplayBufferContents(respBuf, respBufLoc, INK_HTTP_TYPE_REQUEST);
+ DisplayBufferContents(respBuf, respBufLoc, TS_HTTP_TYPE_REQUEST);
- INKHandleMLocRelease(respBuf, INK_NULL_MLOC, respBufLoc);
+ TSHandleMLocRelease(respBuf, TS_NULL_MLOC, respBufLoc);
- bufPtr = INKmalloc(sizeof(htmlBody));
+ bufPtr = TSmalloc(sizeof(htmlBody));
strncpy(bufPtr, htmlBody, sizeof(htmlBody));
- fmtPtr = INKmalloc(sizeof(FMT_TXT_HTML) + 1);
+ fmtPtr = TSmalloc(sizeof(FMT_TXT_HTML) + 1);
strncpy(fmtPtr, FMT_TXT_HTML, sizeof(FMT_TXT_HTML));
- INKHttpTxnErrorBodySet(txnp, (char *) bufPtr, sizeof(htmlBody), fmtPtr);
+ TSHttpTxnErrorBodySet(txnp, (char *) bufPtr, sizeof(htmlBody), fmtPtr);
/* TS frees when no longer needed:
- * INKfree(bufPtr);
- * INKfree(fmtPtr);
+ * TSfree(bufPtr);
+ * TSfree(fmtPtr);
*/
}
return err;
@@ -269,23 +269,23 @@ handle_HTTP_SEND_RESPONSE_HDR(INKCont co
static int
-INKHttpTransaction(INKCont contp, INKEvent event, void *eData)
+TSHttpTransaction(TSCont contp, TSEvent event, void *eData)
{
- INKHttpSsn ssnp = (INKHttpSsn) eData;
- INKHttpTxn txnp = (INKHttpTxn) eData;
+ TSHttpSsn ssnp = (TSHttpSsn) eData;
+ TSHttpTxn txnp = (TSHttpTxn) eData;
- INKDebug("INKHttpTxnErrorBodySet", "INKHttpTxnCachedReqGet(): event: %s \n", INKEventStrId[index(event)]);
+ TSDebug("TSHttpTxnErrorBodySet", "TSHttpTxnCachedReqGet(): event: %s \n", TSEventStrId[index(event)]);
switch (event) {
- case INK_EVENT_HTTP_SSN_START:
+ case TS_EVENT_HTTP_SSN_START:
handle_HTTP_SSN_START(contp, event, eData);
- INKHttpSsnReenable(ssnp, INK_EVENT_HTTP_CONTINUE);
+ TSHttpSsnReenable(ssnp, TS_EVENT_HTTP_CONTINUE);
break;
- case INK_EVENT_HTTP_SEND_RESPONSE_HDR:
+ case TS_EVENT_HTTP_SEND_RESPONSE_HDR:
handle_HTTP_SEND_RESPONSE_HDR(contp, event, eData);
- INKHttpTxnReenable(txnp, INK_EVENT_HTTP_CONTINUE);
+ TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
break;
default:
break;
@@ -293,9 +293,9 @@ INKHttpTransaction(INKCont contp, INKEve
}
void
-INKPluginInit(int argc, const char *argv[])
+TSPluginInit(int argc, const char *argv[])
{
- INKCont contp = INKContCreate(INKHttpTransaction, NULL);
- INKHttpHookAdd(INK_HTTP_SSN_START_HOOK, contp);
- INKHttpHookAdd(INK_HTTP_SEND_RESPONSE_HDR_HOOK, contp);
+ TSCont contp = TSContCreate(TSHttpTransaction, NULL);
+ TSHttpHookAdd(TS_HTTP_SSN_START_HOOK, contp);
+ TSHttpHookAdd(TS_HTTP_SEND_RESPONSE_HDR_HOOK, contp);
}
Modified: trafficserver/traffic/trunk/test/plugin/INKHttpHooksTrans/INKHttpTxnHookAdd.c
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/test/plugin/INKHttpHooksTrans/INKHttpTxnHookAdd.c?rev=1035782&r1=1035781&r2=1035782&view=diff
==============================================================================
--- trafficserver/traffic/trunk/test/plugin/INKHttpHooksTrans/INKHttpTxnHookAdd.c (original)
+++ trafficserver/traffic/trunk/test/plugin/INKHttpHooksTrans/INKHttpTxnHookAdd.c Tue Nov 16 20:22:02 2010
@@ -25,10 +25,10 @@
/*
Tests for registering/processing:
- INK_HTTP_SESSION_START
- INK_HTTP_TXN_START
- INK_HTTP_SESSION_CLOSE
- INK_HTTP_TXN_CLOSE
+ TS_HTTP_SESSION_START
+ TS_HTTP_TXN_START
+ TS_HTTP_SESSION_CLOSE
+ TS_HTTP_TXN_CLOSE
*/
@@ -36,29 +36,29 @@ Tests for registering/processing:
#include <sys/types.h>
#include <stdio.h>
-const char *const INKEventStrId[] = {
- "INK_EVENT_HTTP_CONTINUE", /* 60000 */
- "INK_EVENT_HTTP_ERROR", /* 60001 */
- "INK_EVENT_HTTP_READ_REQUEST_HDR", /* 60002 */
- "INK_EVENT_HTTP_OS_DNS", /* 60003 */
- "INK_EVENT_HTTP_SEND_REQUEST_HDR", /* 60004 */
- "INK_EVENT_HTTP_READ_CACHE_HDR", /* 60005 */
- "INK_EVENT_HTTP_READ_RESPONSE_HDR", /* 60006 */
- "INK_EVENT_HTTP_SEND_RESPONSE_HDR", /* 60007 */
- "INK_EVENT_HTTP_REQUEST_TRANSFORM", /* 60008 */
- "INK_EVENT_HTTP_RESPONSE_TRANSFORM", /* 60009 */
- "INK_EVENT_HTTP_SELECT_ALT", /* 60010 */
- "INK_EVENT_HTTP_TXN_START", /* 60011 */
- "INK_EVENT_HTTP_TXN_CLOSE", /* 60012 */
- "INK_EVENT_HTTP_SSN_START", /* 60013 */
- "INK_EVENT_HTTP_SSN_CLOSE", /* 60014 */
+const char *const TSEventStrId[] = {
+ "TS_EVENT_HTTP_CONTINUE", /* 60000 */
+ "TS_EVENT_HTTP_ERROR", /* 60001 */
+ "TS_EVENT_HTTP_READ_REQUEST_HDR", /* 60002 */
+ "TS_EVENT_HTTP_OS_DNS", /* 60003 */
+ "TS_EVENT_HTTP_SEND_REQUEST_HDR", /* 60004 */
+ "TS_EVENT_HTTP_READ_CACHE_HDR", /* 60005 */
+ "TS_EVENT_HTTP_READ_RESPONSE_HDR", /* 60006 */
+ "TS_EVENT_HTTP_SEND_RESPONSE_HDR", /* 60007 */
+ "TS_EVENT_HTTP_REQUEST_TRANSFORM", /* 60008 */
+ "TS_EVENT_HTTP_RESPONSE_TRANSFORM", /* 60009 */
+ "TS_EVENT_HTTP_SELECT_ALT", /* 60010 */
+ "TS_EVENT_HTTP_TXN_START", /* 60011 */
+ "TS_EVENT_HTTP_TXN_CLOSE", /* 60012 */
+ "TS_EVENT_HTTP_SSN_START", /* 60013 */
+ "TS_EVENT_HTTP_SSN_CLOSE", /* 60014 */
- "INK_EVENT_MGMT_UPDATE" /* 60100 */
+ "TS_EVENT_MGMT_UPDATE" /* 60100 */
};
/*
* We track that each hook was called using this array. We start with
- * all values set to zero, meaning that the INKEvent has not been
+ * all values set to zero, meaning that the TSEvent has not been
* received.
* There 16 entries.
*/
@@ -71,12 +71,12 @@ static int
ChkEvents(const int event)
{
int i, re = 0;
- /* INKDebug("INKHttpHook", */
- printf("ChkEvents: -- %s -- \n", INKEventStrId[index(event)]);
+ /* TSDebug("TSHttpHook", */
+ printf("ChkEvents: -- %s -- \n", TSEventStrId[index(event)]);
for (i = 0; i < inktHookTblSize; i++) {
if (!inktHookTbl[i]) {
- printf("Event [%d] %s registered and not called back\n", i, INKEventStrId[i]);
+ printf("Event [%d] %s registered and not called back\n", i, TSEventStrId[i]);
re = 1;
}
}
@@ -84,19 +84,19 @@ ChkEvents(const int event)
}
-/* event routine: for each INKHttpHookID this routine should be called
+/* event routine: for each TSHttpHookID this routine should be called
* with a matching event.
*/
static int
-INKHttpHook(INKCont contp, INKEvent event, void *eData)
+TSHttpHook(TSCont contp, TSEvent event, void *eData)
{
- INKHttpSsn ssnp = (INKHttpSsn) eData;
- INKHttpTxn txnp = (INKHttpTxn) eData;
+ TSHttpSsn ssnp = (TSHttpSsn) eData;
+ TSHttpTxn txnp = (TSHttpTxn) eData;
switch (event) {
- case INK_EVENT_HTTP_TXN_START:
- inktHookTbl[index(INK_EVENT_HTTP_TXN_START)] = 1;
- ChkEvents(INK_EVENT_HTTP_TXN_START);
+ case TS_EVENT_HTTP_TXN_START:
+ inktHookTbl[index(TS_EVENT_HTTP_TXN_START)] = 1;
+ ChkEvents(TS_EVENT_HTTP_TXN_START);
/*
* We do have a transaction.
@@ -105,48 +105,48 @@ INKHttpHook(INKCont contp, INKEvent even
* live, session or transaction ? Should be transparent.
*/
/* OK */
- INKHttpTxnHookAdd(txnp, INK_HTTP_TXN_CLOSE_HOOK, contp);
+ TSHttpTxnHookAdd(txnp, TS_HTTP_TXN_CLOSE_HOOK, contp);
/* Event lives in the session. Transaction is deleted before
* the session. Event will not be received
- * INKHttpSsnHookAdd(ssnp,INK_HTTP_TXN_CLOSE_HOOK,contp);
+ * TSHttpSsnHookAdd(ssnp,TS_HTTP_TXN_CLOSE_HOOK,contp);
*/
/* Since this is a transaction level event, activate the
* transaction.
*/
- INKHttpTxnReenable(txnp, INK_EVENT_HTTP_CONTINUE);
+ TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
break;
- case INK_EVENT_HTTP_TXN_CLOSE:
- inktHookTbl[index(INK_EVENT_HTTP_TXN_CLOSE)] = 1;
- ChkEvents(INK_EVENT_HTTP_TXN_CLOSE);
- INKHttpTxnReenable(txnp, INK_EVENT_HTTP_CONTINUE);
+ case TS_EVENT_HTTP_TXN_CLOSE:
+ inktHookTbl[index(TS_EVENT_HTTP_TXN_CLOSE)] = 1;
+ ChkEvents(TS_EVENT_HTTP_TXN_CLOSE);
+ TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
break;
- case INK_EVENT_HTTP_SSN_START:
+ case TS_EVENT_HTTP_SSN_START:
/* Reged at the "session" level, all but
- * INK_HTTP_TXN_CLOSE_HOOK is received.
+ * TS_HTTP_TXN_CLOSE_HOOK is received.
*/
- inktHookTbl[index(INK_EVENT_HTTP_SSN_START)] = 1;
- ChkEvents(INK_EVENT_HTTP_SSN_START);
+ inktHookTbl[index(TS_EVENT_HTTP_SSN_START)] = 1;
+ ChkEvents(TS_EVENT_HTTP_SSN_START);
/* There has to be some way to get from the session to
* the transaction. This is how:
* No transaction yet, register TXN_START with the session
*/
- INKHttpSsnHookAdd(ssnp, INK_HTTP_TXN_START_HOOK, contp);
+ TSHttpSsnHookAdd(ssnp, TS_HTTP_TXN_START_HOOK, contp);
/* session level event with the session */
- INKHttpSsnHookAdd(ssnp, INK_HTTP_SSN_CLOSE_HOOK, contp);
- INKHttpSsnReenable(ssnp, INK_EVENT_HTTP_CONTINUE);
+ TSHttpSsnHookAdd(ssnp, TS_HTTP_SSN_CLOSE_HOOK, contp);
+ TSHttpSsnReenable(ssnp, TS_EVENT_HTTP_CONTINUE);
break;
- case INK_EVENT_HTTP_SSN_CLOSE:
+ case TS_EVENT_HTTP_SSN_CLOSE:
/* Here as a result of:
- * INKHTTPHookAdd(INK_HTTP_SSN_CLOSE_HOOK)
+ * TSHTTPHookAdd(TS_HTTP_SSN_CLOSE_HOOK)
*/
- inktHookTbl[index(INK_EVENT_HTTP_SSN_CLOSE)] = 1;
+ inktHookTbl[index(TS_EVENT_HTTP_SSN_CLOSE)] = 1;
/* Assumption: at this point all other events have
* have been called. Since a session can have one or
@@ -154,34 +154,34 @@ INKHttpHook(INKCont contp, INKEvent even
* prompt us to check that all events have been called back
* CAUTION: can a single request trigger all events?
*/
- if (ChkEvents(INK_EVENT_HTTP_SSN_CLOSE))
- INKError("INKHttpHook: Fail: All events not called back.\n");
+ if (ChkEvents(TS_EVENT_HTTP_SSN_CLOSE))
+ TSError("TSHttpHook: Fail: All events not called back.\n");
else
- INKError("INKHttpHook: Pass: All events called back.\n");
+ TSError("TSHttpHook: Pass: All events called back.\n");
- INKHttpSsnReenable(ssnp, INK_EVENT_HTTP_CONTINUE);
+ TSHttpSsnReenable(ssnp, TS_EVENT_HTTP_CONTINUE);
break;
default:
- INKError("INKHttpHook: undefined event [%d] received\n", event);
+ TSError("TSHttpHook: undefined event [%d] received\n", event);
break;
}
}
void
-INKPluginInit(int argc, const char *argv[])
+TSPluginInit(int argc, const char *argv[])
{
- INKCont myCont = NULL;
+ TSCont myCont = NULL;
inktHookTblSize = sizeof(inktHookTbl) / sizeof(int);
/* Create continuation */
- myCont = INKContCreate(INKHttpHook, NULL);
+ myCont = TSContCreate(TSHttpHook, NULL);
if (myCont != NULL) {
/* Reged at the "global" level, these 4 events are
* received.
*/
- INKHttpHookAdd(INK_HTTP_SSN_START_HOOK, myCont);
+ TSHttpHookAdd(TS_HTTP_SSN_START_HOOK, myCont);
} else
- INKError("INKHttpHook: INKContCreate() failed \n");
+ TSError("TSHttpHook: TSContCreate() failed \n");
}
Modified: trafficserver/traffic/trunk/test/plugin/INKHttpHooksTrans/INKHttpTxnIPAddress.cc
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/test/plugin/INKHttpHooksTrans/INKHttpTxnIPAddress.cc?rev=1035782&r1=1035781&r2=1035782&view=diff
==============================================================================
--- trafficserver/traffic/trunk/test/plugin/INKHttpHooksTrans/INKHttpTxnIPAddress.cc (original)
+++ trafficserver/traffic/trunk/test/plugin/INKHttpHooksTrans/INKHttpTxnIPAddress.cc Tue Nov 16 20:22:02 2010
@@ -38,7 +38,7 @@
char *
uint2ddip(unsigned int addr)
{
- char *ptr = (char *) INKmalloc(64);
+ char *ptr = (char *) TSmalloc(64);
if (!ptr)
return NULL;
@@ -51,7 +51,7 @@ uint2ddip(unsigned int addr)
}
-/* Set in INKPluginInit */
+/* Set in TSPluginInit */
typedef struct parentProxyInfo
{
char parentProxyp[BUFSIZ];
@@ -59,9 +59,9 @@ typedef struct parentProxyInfo
} parentProxyInfo_t;
static int
-handle_SEND_REQUEST(INKCont contp, INKEvent event, void *eData)
+handle_SEND_REQUEST(TSCont contp, TSEvent event, void *eData)
{
- INKHttpTxn txnp = (INKHttpTxn *) eData;
+ TSHttpTxn txnp = (TSHttpTxn *) eData;
unsigned int nextHopIP = 0;
int err = 0;
char *ipAddrp = NULL;
@@ -70,14 +70,14 @@ handle_SEND_REQUEST(INKCont contp, INKEv
* TODO use return addr with an actual network library routine (gethostbyaddr) to validate addr
* TODO tests with an actual parent proxy
*/
- nextHopIP = INKHttpTxnNextHopIPGet(txnp);
+ nextHopIP = TSHttpTxnNextHopIPGet(txnp);
if (!nextHopIP) {
- INKDebug("INKHttpTxnIPAddress", "INKHttpTxnNextHopIPGet failed");
+ TSDebug("TSHttpTxnIPAddress", "TSHttpTxnNextHopIPGet failed");
return ++err;
}
ipAddrp = uint2ddip(nextHopIP);
- INKDebug("INKHttpTxnIPAddress", "INKHttpTxnNextHopIPGet passed for %s", ipAddrp ? ipAddrp : "NULL ptr!");
- INKfree(ipAddrp);
+ TSDebug("TSHttpTxnIPAddress", "TSHttpTxnNextHopIPGet passed for %s", ipAddrp ? ipAddrp : "NULL ptr!");
+ TSfree(ipAddrp);
/* TODO validate this IP address, not just an integer value
* see below
*/
@@ -86,19 +86,19 @@ handle_SEND_REQUEST(INKCont contp, INKEv
/* Test:
-* INKHttpTxnClientReqGet
-* INKHttpTxnServerIPGet (specific)
-* INKHttpHdrUrlGet
-* INKUrlHostGet
-* Test is to use the address returend by INKHttpTxnServerIPGet
+* TSHttpTxnClientReqGet
+* TSHttpTxnServerIPGet (specific)
+* TSHttpHdrUrlGet
+* TSUrlHostGet
+* Test is to use the address returend by TSHttpTxnServerIPGet
* with a standard network interface api and compare that
* host with the hostname found in the request URL.
*/
static int
-handle_OS_DNS(INKCont contp, INKEvent event, void *eData)
+handle_OS_DNS(TSCont contp, TSEvent event, void *eData)
{
unsigned int os_ip;
- INKHttpTxn txnp = (INKHttpTxn *) eData;
+ TSHttpTxn txnp = (TSHttpTxn *) eData;
struct in_addr inAddr;
struct hostent *hostEntp = NULL;
int err = 0;
@@ -106,52 +106,52 @@ handle_OS_DNS(INKCont contp, INKEvent ev
int hostLen = 0;
char strTokenp = '.'; /* URLs separated by this token */
char *domain_os_ip = NULL, *domain_url = NULL;
- INKMBuffer buf;
+ TSMBuffer buf;
unsigned int nextHopIP;
- INKMLoc loc, hdrLoc;
+ TSMLoc loc, hdrLoc;
char *ptr = NULL;
- /* See: handle_SEND_REQUEST(): nextHopIP = INKHttpTxnNextHopIPGet(txnp);
+ /* See: handle_SEND_REQUEST(): nextHopIP = TSHttpTxnNextHopIPGet(txnp);
*/
- os_ip = INKHttpTxnServerIPGet(txnp);
+ os_ip = TSHttpTxnServerIPGet(txnp);
if (os_ip) {
inAddr.s_addr = os_ip;
hostEntp = gethostbyaddr((const char *) &inAddr, sizeof(struct in_addr), AF_INET);
if (!hostEntp) {
ptr = uint2ddip(os_ip);
/* failure */
- INKDebug("INKHttpTxnIPAddress", "INKHttpTxnServerIPGet: gethostbyaddr failed for %s", ptr ? ptr : "NULL ptr!");
- INKfree(ptr);
+ TSDebug("TSHttpTxnIPAddress", "TSHttpTxnServerIPGet: gethostbyaddr failed for %s", ptr ? ptr : "NULL ptr!");
+ TSfree(ptr);
return ++err;
}
} else {
/* failure */
- INKDebug("INKHttpTxnIPAddress", "INKHttpTxnServerIPGet: gethostbyaddr no hostname");
+ TSDebug("TSHttpTxnIPAddress", "TSHttpTxnServerIPGet: gethostbyaddr no hostname");
++err;
}
- if (!INKHttpTxnClientReqGet(txnp, &buf, &loc)) {
+ if (!TSHttpTxnClientReqGet(txnp, &buf, &loc)) {
/* failure */
- INKDebug("INKHttpTxnIPAddress", "INKHttpTxnServerIPGet: INKHttpTxnClientReqGet failed");
- return ++err; /* ret here, else INKMHandleRelease */
+ TSDebug("TSHttpTxnIPAddress", "TSHttpTxnServerIPGet: TSHttpTxnClientReqGet failed");
+ return ++err; /* ret here, else TSMHandleRelease */
}
- if ((hdrLoc = INKHttpHdrUrlGet(buf, loc)) == NULL) {
+ if ((hdrLoc = TSHttpHdrUrlGet(buf, loc)) == NULL) {
/* failure */
- INKDebug("INKHttpTxnIPAddress", "INKHttpTxnServerIPGet: INKHttpHdrURLGet failed");
- INKHandleMLocRelease(buf, INK_NULL_MLOC, loc);
- return ++err; /* ret here, else INKMHandleRelease */
+ TSDebug("TSHttpTxnIPAddress", "TSHttpTxnServerIPGet: TSHttpHdrURLGet failed");
+ TSHandleMLocRelease(buf, TS_NULL_MLOC, loc);
+ return ++err; /* ret here, else TSMHandleRelease */
}
/* no memory del on reqURLHost */
- reqURLHost = INKUrlHostGet(buf, hdrLoc, &hostLen);
+ reqURLHost = TSUrlHostGet(buf, hdrLoc, &hostLen);
if (!reqURLHost || !hostLen) {
/* FAILURE */
- INKDebug("INKHttpTxnIPAddress", "INKHttpTxnServerIPGet: gethostbyaddr no hostname");
- INKHandleMLocRelease(buf, INK_NULL_MLOC, loc);
+ TSDebug("TSHttpTxnIPAddress", "TSHttpTxnServerIPGet: gethostbyaddr no hostname");
+ TSHandleMLocRelease(buf, TS_NULL_MLOC, loc);
return ++err;
}
/* compare the domains of the hostname
- * from gethostbyaddr and INKURLHostGet: e.g.:
+ * from gethostbyaddr and TSURLHostGet: e.g.:
* w1.someGiantSite.com with a request of: www.someGiantSite.com
*/
else {
@@ -162,33 +162,33 @@ handle_OS_DNS(INKCont contp, INKEvent ev
domain_os_ip = strchr(hostEntp->h_name, (int) strTokenp);
if (!domain_os_ip || !domain_url) {
- INKDebug("INKHttpTxnIPAddress", "INKHttpTxnServerIPGet: fail: strtok");
+ TSDebug("TSHttpTxnIPAddress", "TSHttpTxnServerIPGet: fail: strtok");
++err;
}
if (strncmp(++domain_os_ip, ++domain_url, BUFSIZ)) {
- INKDebug("INKHttpTxnIPAddress", "INKHttpTxnServerIPGet: fail: domain names %s != %s", domain_os_ip, domain_url);
+ TSDebug("TSHttpTxnIPAddress", "TSHttpTxnServerIPGet: fail: domain names %s != %s", domain_os_ip, domain_url);
++err;
}
}
- INKHandleMLocRelease(buf, INK_NULL_MLOC, loc);
+ TSHandleMLocRelease(buf, TS_NULL_MLOC, loc);
return err;
}
-/* Currently not used. Interfaces like INKHttpTxnNextHopIPGet
+/* Currently not used. Interfaces like TSHttpTxnNextHopIPGet
* should only be called from SEND_REQUEST, inclusive, forward
*/
static int
-handle_TXN_START(INKCont contp, INKEvent event, void *eData)
+handle_TXN_START(TSCont contp, TSEvent event, void *eData)
{
return 0;
}
static int
-handle_TXN_CLOSE(INKCont contp, INKEvent event, void *eData)
+handle_TXN_CLOSE(TSCont contp, TSEvent event, void *eData)
{
- INKMBuffer respBuf;
- INKMLoc respBufLoc;
- INKHttpTxn txnp = (INKHttpTxn) eData;
+ TSMBuffer respBuf;
+ TSMLoc respBufLoc;
+ TSHttpTxn txnp = (TSHttpTxn) eData;
char *hostNamep = NULL;
void *dataPtr = NULL;
int err = 0, re = 0;
@@ -199,9 +199,9 @@ handle_TXN_CLOSE(INKCont contp, INKEvent
int incomingPort;
char *ipAddrp = NULL;
- incomingPort = INKHttpTxnClientIncomingPortGet(txnp);
+ incomingPort = TSHttpTxnClientIncomingPortGet(txnp);
if (!incomingPort) {
- INKDebug("INKHttpTxnIPAddress", "INKHttpTxnClientIncomingPortGet failed");
+ TSDebug("TSHttpTxnIPAddress", "TSHttpTxnClientIncomingPortGet failed");
++err; /* failure */
}
/* TODO validate this port, not just an integer value
@@ -209,16 +209,16 @@ handle_TXN_CLOSE(INKCont contp, INKEvent
*/
/* Client IP for a transaction (not incoming) */
- clientIP = INKHttpTxnClientIPGet(txnp);
+ clientIP = TSHttpTxnClientIPGet(txnp);
if (!clientIP) {
- INKDebug("INKHttpTxnIPAddress", "INKHttpTxnClientIPGet failed");
+ TSDebug("TSHttpTxnIPAddress", "TSHttpTxnClientIPGet failed");
err++;
}
/* TODO validate this IP address, not just an integer value
* see below
*/
- /* See: handle_SEND_REQUEST(): nextHopIP = INKHttpTxnNextHopIPGet(txnp);
+ /* See: handle_SEND_REQUEST(): nextHopIP = TSHttpTxnNextHopIPGet(txnp);
*
* If origin server was contacted, its adress
* will be returned. Need a cach hit true/false interface ?
@@ -226,13 +226,13 @@ handle_TXN_CLOSE(INKCont contp, INKEvent
* Origin Server (destination) or Parent IP
* TODO tests with an actual parent proxy
*/
- nextHopIP = INKHttpTxnNextHopIPGet(txnp);
+ nextHopIP = TSHttpTxnNextHopIPGet(txnp);
if (!nextHopIP) {
/* It is the responsibility of the plug-in to store hit/miss
- * details and resolve this as INKHttpTxnNextHopIPGet failure
+ * details and resolve this as TSHttpTxnNextHopIPGet failure
* or cache miss (no o.s. contected).
*/
- INKDebug("INKHttpTxnIPAddress", "INKHttpTxnNextHopIPGet failed for or cache miss");
+ TSDebug("TSHttpTxnIPAddress", "TSHttpTxnNextHopIPGet failed for or cache miss");
err++;
}
/* TODO validate this IP address, not just an integer value
@@ -243,19 +243,19 @@ handle_TXN_CLOSE(INKCont contp, INKEvent
* Failure in the following tests will cause remaining tests
* to not execute.
*/
- os_addr = INKHttpTxnServerIPGet(txnp);
+ os_addr = TSHttpTxnServerIPGet(txnp);
if (!os_addr) {
- INKDebug("INKHttpTxnIPAddress", "INKHttpTxnServerIPGet failed");
+ TSDebug("TSHttpTxnIPAddress", "TSHttpTxnServerIPGet failed");
return ++err; /* failure */
}
- hostname = (char **) INKmalloc(BUFSIZ);
+ hostname = (char **) TSmalloc(BUFSIZ);
/* if parent proxy is not set: re is -1
*/
- INKHttpTxnParentProxyGet(txnp, hostname, &hostPort);
+ TSHttpTxnParentProxyGet(txnp, hostname, &hostPort);
/* TODO value of hostname when parent not set? */
if (hostPort == (-1) || *hostname == NULL) {
- INKDebug("INKHttpTxnIPAddress", "INKHttpTxnParentProxyGet failed");
+ TSDebug("TSHttpTxnIPAddress", "TSHttpTxnParentProxyGet failed");
/* return ++err; failure */
/* Allow other test to continue */
}
@@ -263,25 +263,25 @@ handle_TXN_CLOSE(INKCont contp, INKEvent
/*
* Get the parent/port that were set at plug-in init
*/
- dataPtr = INKContDataGet(contp);
+ dataPtr = TSContDataGet(contp);
if (!dataPtr) {
- INKDebug("INKHttpTxnIPAddress", "INKContDataGet returned NULL pointer, cannot test INKHttpTxnParentProxySet");
+ TSDebug("TSHttpTxnIPAddress", "TSContDataGet returned NULL pointer, cannot test TSHttpTxnParentProxySet");
return ++err;
}
- INKDebug("INKHttpTxnIPAddress",
+ TSDebug("TSHttpTxnIPAddress",
"Setting parent proxy to %s:%d",
((parentProxyInfo_t *) dataPtr)->parentProxyp, ((parentProxyInfo_t *) dataPtr)->parentPort);
/* TODO how do we check return value? */
- INKHttpTxnParentProxySet(txnp,
+ TSHttpTxnParentProxySet(txnp,
((parentProxyInfo_t *) dataPtr)->parentProxyp, ((parentProxyInfo_t *) dataPtr)->parentPort);
/* parent proxy was set
*/
- INKHttpTxnParentProxyGet(txnp, hostname, &hostPort);
+ TSHttpTxnParentProxyGet(txnp, hostname, &hostPort);
if (hostPort == (-1) || *hostname == NULL) {
- INKDebug("INKHttpTxnIPAddress", "INKHttpTxnParentProxyGet failed");
+ TSDebug("TSHttpTxnIPAddress", "TSHttpTxnParentProxyGet failed");
/* return ++err; failure */
/* Allow other test to continue */
}
@@ -290,52 +290,52 @@ handle_TXN_CLOSE(INKCont contp, INKEvent
if ((strncmp(*hostname,
((parentProxyInfo_t *) dataPtr)->parentProxyp, BUFSIZ)) ||
((parentProxyInfo_t *) dataPtr)->parentPort != hostPort) {
- INKDebug("INKHttpTxnIPAddress", "INKHttpTxnParentProxySet/Get failed");
+ TSDebug("TSHttpTxnIPAddress", "TSHttpTxnParentProxySet/Get failed");
++err;
}
- INKfree(hostname);
- INKfree(hostname);
+ TSfree(hostname);
+ TSfree(hostname);
return err;
}
static int
-INKHttpTransaction(INKCont contp, INKEvent event, void *eData)
+TSHttpTransaction(TSCont contp, TSEvent event, void *eData)
{
- INKHttpSsn ssnp = (INKHttpSsn) eData;
- INKHttpTxn txnp = (INKHttpTxn) eData;
+ TSHttpSsn ssnp = (TSHttpSsn) eData;
+ TSHttpTxn txnp = (TSHttpTxn) eData;
int err = 0;
unsigned int nextHopIP = 0;
switch (event) {
- case INK_EVENT_HTTP_SSN_START:
- INKHttpSsnHookAdd(ssnp, INK_HTTP_TXN_START_HOOK, contp);
- INKHttpSsnHookAdd(ssnp, INK_HTTP_TXN_CLOSE_HOOK, contp);
- INKHttpSsnHookAdd(ssnp, INK_HTTP_SEND_REQUEST_HDR_HOOK, contp);
- INKHttpSsnHookAdd(ssnp, INK_HTTP_OS_DNS_HOOK, contp);
+ case TS_EVENT_HTTP_SSN_START:
+ TSHttpSsnHookAdd(ssnp, TS_HTTP_TXN_START_HOOK, contp);
+ TSHttpSsnHookAdd(ssnp, TS_HTTP_TXN_CLOSE_HOOK, contp);
+ TSHttpSsnHookAdd(ssnp, TS_HTTP_SEND_REQUEST_HDR_HOOK, contp);
+ TSHttpSsnHookAdd(ssnp, TS_HTTP_OS_DNS_HOOK, contp);
- INKHttpSsnReenable(ssnp, INK_EVENT_HTTP_CONTINUE);
+ TSHttpSsnReenable(ssnp, TS_EVENT_HTTP_CONTINUE);
break;
- case INK_EVENT_HTTP_OS_DNS:
+ case TS_EVENT_HTTP_OS_DNS:
handle_OS_DNS(contp, event, eData);
- INKHttpTxnReenable(txnp, INK_EVENT_HTTP_CONTINUE);
+ TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
break;
- case INK_EVENT_HTTP_TXN_START:
+ case TS_EVENT_HTTP_TXN_START:
handle_TXN_START(contp, event, eData);
- INKHttpTxnReenable(txnp, INK_EVENT_HTTP_CONTINUE);
+ TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
break;
- case INK_EVENT_HTTP_TXN_CLOSE:
+ case TS_EVENT_HTTP_TXN_CLOSE:
handle_TXN_CLOSE(contp, event, eData);
- INKHttpTxnReenable(txnp, INK_EVENT_HTTP_CONTINUE);
+ TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
break;
- case INK_EVENT_HTTP_SEND_REQUEST_HDR:
+ case TS_EVENT_HTTP_SEND_REQUEST_HDR:
handle_SEND_REQUEST(contp, event, eData);
- INKHttpTxnReenable(txnp, INK_EVENT_HTTP_CONTINUE);
+ TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
break;
default:
@@ -345,7 +345,7 @@ INKHttpTransaction(INKCont contp, INKEve
}
void
-INKPluginInit(int argc, const char *argv[])
+TSPluginInit(int argc, const char *argv[])
{
int err = 0;
int length = 0, argCnt = 0;
@@ -353,36 +353,36 @@ INKPluginInit(int argc, const char *argv
/* Passed in as args to the plug-in and does not get deleted
*/
- parentProxyInfo_t *parentInfop = (parentProxyInfo_t *) INKmalloc(sizeof(parentProxyInfo_t));
+ parentProxyInfo_t *parentInfop = (parentProxyInfo_t *) TSmalloc(sizeof(parentProxyInfo_t));
if (!parentInfop) {
- INKDebug("INKHttpTxnIPAddress", "INKmalloc(parentProxyInfo_t = [%d]) failed", sizeof(parentProxyInfo_t));
- INKDebug("INKHttpTxnIPAddress", "INKHttpTxnIPAddress failed and did not run");
+ TSDebug("TSHttpTxnIPAddress", "TSmalloc(parentProxyInfo_t = [%d]) failed", sizeof(parentProxyInfo_t));
+ TSDebug("TSHttpTxnIPAddress", "TSHttpTxnIPAddress failed and did not run");
return;
}
strncpy(parentInfop->parentProxyp, argv[++argCnt], strlen(argv[argCnt]));
parentInfop->parentPort = atoi(argv[++argCnt]);
- INKCont contp = INKContCreate(INKHttpTransaction, NULL);
- INKContDataSet(contp, (void *) parentInfop); /* Used in txn */
+ TSCont contp = TSContCreate(TSHttpTransaction, NULL);
+ TSContDataSet(contp, (void *) parentInfop); /* Used in txn */
- /* Never: INKfree(parentInfop);
- * if you expect to use INKContDataGet
+ /* Never: TSfree(parentInfop);
+ * if you expect to use TSContDataGet
* not a leak since TS keeps a reference to this heap
* space
* Here's a leak (bad stuff man!):
*
- * ptr = INKmalloc() ;
+ * ptr = TSmalloc() ;
* Init(ptr);
- * INKConDataSet(contp, ptr);
+ * TSConDataSet(contp, ptr);
*
* at some other event at a later time
*
- * retreivePtr = INKContDataGet(contp);
+ * retreivePtr = TSContDataGet(contp);
* newPtr = Modify(retrievePtr);
- * INKConDataSet(contp, newPtr);
- * INKfree(retrievedPtr); if not freed, leak
+ * TSConDataSet(contp, newPtr);
+ * TSfree(retrievedPtr); if not freed, leak
*/
- INKHttpHookAdd(INK_HTTP_SSN_START_HOOK, contp);
+ TSHttpHookAdd(TS_HTTP_SSN_START_HOOK, contp);
}
Modified: trafficserver/traffic/trunk/test/plugin/INKHttpHooksTrans/INKHttpTxnServer.c
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/test/plugin/INKHttpHooksTrans/INKHttpTxnServer.c?rev=1035782&r1=1035781&r2=1035782&view=diff
==============================================================================
--- trafficserver/traffic/trunk/test/plugin/INKHttpHooksTrans/INKHttpTxnServer.c (original)
+++ trafficserver/traffic/trunk/test/plugin/INKHttpHooksTrans/INKHttpTxnServer.c Tue Nov 16 20:22:02 2010
@@ -24,24 +24,24 @@
#include "ts.h"
-const char *const INKEventStrId[] = {
- "INK_EVENT_HTTP_CONTINUE", /* 60000 */
- "INK_EVENT_HTTP_ERROR", /* 60001 */
- "INK_EVENT_HTTP_READ_REQUEST_HDR", /* 60002 */
- "INK_EVENT_HTTP_OS_DNS", /* 60003 */
- "INK_EVENT_HTTP_SEND_REQUEST_HDR", /* 60004 */
- "INK_EVENT_HTTP_READ_CACHE_HDR", /* 60005 */
- "INK_EVENT_HTTP_READ_RESPONSE_HDR", /* 60006 */
- "INK_EVENT_HTTP_SEND_RESPONSE_HDR", /* 60007 */
- "INK_EVENT_HTTP_REQUEST_TRANSFORM", /* 60008 */
- "INK_EVENT_HTTP_RESPONSE_TRANSFORM", /* 60009 */
- "INK_EVENT_HTTP_SELECT_ALT", /* 60010 */
- "INK_EVENT_HTTP_TXN_START", /* 60011 */
- "INK_EVENT_HTTP_TXN_CLOSE", /* 60012 */
- "INK_EVENT_HTTP_SSN_START", /* 60013 */
- "INK_EVENT_HTTP_SSN_CLOSE", /* 60014 */
+const char *const TSEventStrId[] = {
+ "TS_EVENT_HTTP_CONTINUE", /* 60000 */
+ "TS_EVENT_HTTP_ERROR", /* 60001 */
+ "TS_EVENT_HTTP_READ_REQUEST_HDR", /* 60002 */
+ "TS_EVENT_HTTP_OS_DNS", /* 60003 */
+ "TS_EVENT_HTTP_SEND_REQUEST_HDR", /* 60004 */
+ "TS_EVENT_HTTP_READ_CACHE_HDR", /* 60005 */
+ "TS_EVENT_HTTP_READ_RESPONSE_HDR", /* 60006 */
+ "TS_EVENT_HTTP_SEND_RESPONSE_HDR", /* 60007 */
+ "TS_EVENT_HTTP_REQUEST_TRANSFORM", /* 60008 */
+ "TS_EVENT_HTTP_RESPONSE_TRANSFORM", /* 60009 */
+ "TS_EVENT_HTTP_SELECT_ALT", /* 60010 */
+ "TS_EVENT_HTTP_TXN_START", /* 60011 */
+ "TS_EVENT_HTTP_TXN_CLOSE", /* 60012 */
+ "TS_EVENT_HTTP_SSN_START", /* 60013 */
+ "TS_EVENT_HTTP_SSN_CLOSE", /* 60014 */
- "INK_EVENT_MGMT_UPDATE" /* 60100 */
+ "TS_EVENT_MGMT_UPDATE" /* 60100 */
};
#define index(x) ((x)%(1000))
@@ -56,51 +56,51 @@ const char *const INKEventStrId[] = {
/* Type can be used to display/compare request/response differently */
static void
-DisplayBufferContents(INKMBuffer bufp, INKMLoc hdr_loc, INKHttpType type)
+DisplayBufferContents(TSMBuffer bufp, TSMLoc hdr_loc, TSHttpType type)
{
- INKIOBuffer output_buffer;
- INKIOBufferReader reader;
+ TSIOBuffer output_buffer;
+ TSIOBufferReader reader;
int total_avail;
- INKIOBufferBlock block;
+ TSIOBufferBlock block;
const char *block_start;
int block_avail;
char *output_string;
int output_len;
- output_buffer = INKIOBufferCreate();
+ output_buffer = TSIOBufferCreate();
if (!output_buffer) {
- INKError("couldn't allocate IOBuffer\n");
+ TSError("couldn't allocate IOBuffer\n");
}
- reader = INKIOBufferReaderAlloc(output_buffer);
+ reader = TSIOBufferReaderAlloc(output_buffer);
/****** Print the HTTP header (for either a resp or req) first ********/
- INKHttpHdrPrint(bufp, hdr_loc, output_buffer);
+ TSHttpHdrPrint(bufp, hdr_loc, output_buffer);
/* This will print MIMEFields (for either a resp or req) */
- INKMimeHdrPrint(bufp, hdr_loc, output_buffer);
+ TSMimeHdrPrint(bufp, hdr_loc, output_buffer);
/* Find out how the big the complete header is by
seeing the total bytes in the buffer. We need to
look at the buffer rather than the first block to
see the size of the entire header */
- total_avail = INKIOBufferReaderAvail(reader);
+ total_avail = TSIOBufferReaderAvail(reader);
/* Allocate the string with an extra byte for the string
terminator */
- output_string = (char *) INKmalloc(total_avail + 1);
+ output_string = (char *) TSmalloc(total_avail + 1);
output_len = 0;
/* We need to loop over all the buffer blocks to make
sure we get the complete header since the header can
be in multiple blocks */
- block = INKIOBufferReaderStart(reader);
+ block = TSIOBufferReaderStart(reader);
while (block) {
- block_start = INKIOBufferBlockReadStart(block, reader, &block_avail);
+ block_start = TSIOBufferBlockReadStart(block, reader, &block_avail);
/* We'll get a block pointer back even if there is no data
left to read so check for this condition and break out of
@@ -115,40 +115,40 @@ DisplayBufferContents(INKMBuffer bufp, I
output_len += block_avail;
/* Consume the data so that we get to the next block */
- INKIOBufferReaderConsume(reader, block_avail);
+ TSIOBufferReaderConsume(reader, block_avail);
/* Get the next block now that we've consumed the
data off the last block */
- block = INKIOBufferReaderStart(reader);
+ block = TSIOBufferReaderStart(reader);
}
/* Terminate the string */
output_string[output_len] = '\0';
output_len++;
- /* Free up the INKIOBuffer that we used to print out the header */
- INKIOBufferReaderFree(reader);
- INKIOBufferDestroy(output_buffer);
+ /* Free up the TSIOBuffer that we used to print out the header */
+ TSIOBufferReaderFree(reader);
+ TSIOBufferDestroy(output_buffer);
/* Although I'd never do this a production plugin, printf
the header so that we can see it's all there */
printf("%s", output_string);
- INKfree(output_string);
+ TSfree(output_string);
/* Caller reenable the session/transaction:
- * INKHttpTxnReenable (txnp, INK_EVENT_HTTP_CONTINUE);
+ * TSHttpTxnReenable (txnp, TS_EVENT_HTTP_CONTINUE);
*/
}
/* This event registered at init (globally) */
static int
-handle_HTTP_SEND_RESPONSE_HDR(INKCont contp, INKEvent event, void *eData)
+handle_HTTP_SEND_RESPONSE_HDR(TSCont contp, TSEvent event, void *eData)
{
- INKMBuffer reqBuf, respBuf;
- INKMLoc reqBufLoc, respBufLoc;
- INKHttpTxn txnp = (INKHttpTxn) eData;
+ TSMBuffer reqBuf, respBuf;
+ TSMLoc reqBufLoc, respBufLoc;
+ TSHttpTxn txnp = (TSHttpTxn) eData;
void *bufPtr = NULL, *fmtPtr = NULL;
int re = 0, err = 0;
@@ -157,84 +157,84 @@ handle_HTTP_SEND_RESPONSE_HDR(INKCont co
}
static int
-handle_READ_REQUEST_HDR(INKCont cont, INKEvent event, void *eData)
+handle_READ_REQUEST_HDR(TSCont cont, TSEvent event, void *eData)
{
- INKMBuffer reqBuf;
- INKMLoc reqBufLoc;
+ TSMBuffer reqBuf;
+ TSMLoc reqBufLoc;
- INKHttpTxn txnp = (INKHttpTxn) eData;
+ TSHttpTxn txnp = (TSHttpTxn) eData;
int err = 0, re = 0;
/* Non-cached,
- * get client req after recieving INK_HTTP_READ_REQUEST_HDR_HOOK
+ * get client req after recieving TS_HTTP_READ_REQUEST_HDR_HOOK
*/
- re = INKHttpTxnClientReqGet(txnp, &reqBuf, &reqBufLoc);
+ re = TSHttpTxnClientReqGet(txnp, &reqBuf, &reqBufLoc);
if (re) {
- DisplayBufferContents(reqBuf, reqBufLoc, INK_HTTP_TYPE_REQUEST);
+ DisplayBufferContents(reqBuf, reqBufLoc, TS_HTTP_TYPE_REQUEST);
} else {
- INKDebug("INKHttpTransaction", "INKHttpTxnClientReqGet(): Header not found.");
+ TSDebug("TSHttpTransaction", "TSHttpTxnClientReqGet(): Header not found.");
err++;
}
- INKHandleMLocRelease(reqBuf, INK_NULL_MLOC, reqBufLoc);
+ TSHandleMLocRelease(reqBuf, TS_NULL_MLOC, reqBufLoc);
return err;
}
static int
-handle_READ_RESPONSE_HDR(INKCont contp, INKEvent event, void *eData)
+handle_READ_RESPONSE_HDR(TSCont contp, TSEvent event, void *eData)
{
- INKMBuffer respBuf;
- INKMLoc respBufLoc;
- INKHttpTxn txnp = (INKHttpTxn) eData;
+ TSMBuffer respBuf;
+ TSMLoc respBufLoc;
+ TSHttpTxn txnp = (TSHttpTxn) eData;
void *bufPtr = NULL;
int err = 0, re = 0;
/* Non-cached,
- * get "client" resp after recieving INK_HTTP_READ_RESPONSE_HDR_HOOK
+ * get "client" resp after recieving TS_HTTP_READ_RESPONSE_HDR_HOOK
*/
- re = INKHttpTxnClientRespGet(txnp, &respBuf, &respBufLoc);
+ re = TSHttpTxnClientRespGet(txnp, &respBuf, &respBufLoc);
if (re) {
- DisplayBufferContents(respBuf, respBufLoc, INK_HTTP_TYPE_RESPONSE);
+ DisplayBufferContents(respBuf, respBufLoc, TS_HTTP_TYPE_RESPONSE);
} else {
- INKDebug("INKHttpTransaction", "INKHttpTxnClientRespGet(): Header not found.");
+ TSDebug("TSHttpTransaction", "TSHttpTxnClientRespGet(): Header not found.");
err++;
}
- INKHandleMLocRelease(respBuf, INK_NULL_MLOC, respBufLoc);
+ TSHandleMLocRelease(respBuf, TS_NULL_MLOC, respBufLoc);
return err;
}
static int
-INKHttpTransaction(INKCont contp, INKEvent event, void *eData)
+TSHttpTransaction(TSCont contp, TSEvent event, void *eData)
{
- INKHttpSsn ssnp = (INKHttpSsn) eData;
- INKHttpTxn txnp = (INKHttpTxn) eData;
+ TSHttpSsn ssnp = (TSHttpSsn) eData;
+ TSHttpTxn txnp = (TSHttpTxn) eData;
- INKDebug("INKHttpTransaction", "INKHttpTxnCachedReqGet(): event: %s \n", INKEventStrId[index(event)]);
- /* printf("ChkEvents: -- %s -- \n",INKEventStrId[index(event)]); */
+ TSDebug("TSHttpTransaction", "TSHttpTxnCachedReqGet(): event: %s \n", TSEventStrId[index(event)]);
+ /* printf("ChkEvents: -- %s -- \n",TSEventStrId[index(event)]); */
switch (event) {
- case INK_EVENT_HTTP_SSN_START:
- INKHttpSsnReenable(ssnp, INK_EVENT_HTTP_CONTINUE);
+ case TS_EVENT_HTTP_SSN_START:
+ TSHttpSsnReenable(ssnp, TS_EVENT_HTTP_CONTINUE);
break;
- case INK_EVENT_HTTP_SEND_RESPONSE_HDR:
+ case TS_EVENT_HTTP_SEND_RESPONSE_HDR:
handle_HTTP_SEND_RESPONSE_HDR(contp, event, eData);
- INKHttpTxnReenable(txnp, INK_EVENT_HTTP_CONTINUE);
+ TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
break;
- case INK_EVENT_HTTP_READ_REQUEST_HDR:
+ case TS_EVENT_HTTP_READ_REQUEST_HDR:
handle_READ_REQUEST_HDR(contp, event, eData);
- INKHttpTxnReenable(txnp, INK_EVENT_HTTP_CONTINUE);
+ TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
break;
- case INK_EVENT_HTTP_READ_RESPONSE_HDR:
+ case TS_EVENT_HTTP_READ_RESPONSE_HDR:
handle_READ_RESPONSE_HDR(contp, event, eData);
- INKHttpTxnReenable(txnp, INK_EVENT_HTTP_CONTINUE);
+ TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
break;
default:
break;
@@ -242,11 +242,11 @@ INKHttpTransaction(INKCont contp, INKEve
}
void
-INKPluginInit(int argc, const char *argv[])
+TSPluginInit(int argc, const char *argv[])
{
- INKCont contp = INKContCreate(INKHttpTransaction, NULL);
- INKHttpHookAdd(INK_HTTP_SSN_START_HOOK, contp);
- INKHttpHookAdd(INK_HTTP_SEND_RESPONSE_HDR_HOOK, contp);
- INKHttpHookAdd(INK_HTTP_READ_RESPONSE_HDR_HOOK, contp);
- INKHttpHookAdd(INK_HTTP_READ_REQUEST_HDR_HOOK, contp);
+ TSCont contp = TSContCreate(TSHttpTransaction, NULL);
+ TSHttpHookAdd(TS_HTTP_SSN_START_HOOK, contp);
+ TSHttpHookAdd(TS_HTTP_SEND_RESPONSE_HDR_HOOK, contp);
+ TSHttpHookAdd(TS_HTTP_READ_RESPONSE_HDR_HOOK, contp);
+ TSHttpHookAdd(TS_HTTP_READ_REQUEST_HDR_HOOK, contp);
}
Modified: trafficserver/traffic/trunk/test/plugin/INKHttpHooksTrans/INKProto.c
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/test/plugin/INKHttpHooksTrans/INKProto.c?rev=1035782&r1=1035781&r2=1035782&view=diff
==============================================================================
--- trafficserver/traffic/trunk/test/plugin/INKHttpHooksTrans/INKProto.c (original)
+++ trafficserver/traffic/trunk/test/plugin/INKHttpHooksTrans/INKProto.c Tue Nov 16 20:22:02 2010
@@ -29,39 +29,39 @@
* code into it's own section.
*/
static int
-INKProto(INKCont contp, INKEvent event, void *eData)
+TSProto(TSCont contp, TSEvent event, void *eData)
{
- INKHttpTxn txnp = (INKHttpTxn) eData;
- INKHttpSsn ssnp = (INKHttpSsn) eData;
+ TSHttpTxn txnp = (TSHttpTxn) eData;
+ TSHttpSsn ssnp = (TSHttpSsn) eData;
switch (event) {
- case INK_EVENT_HTTP_READ_RESPONSE_HDR:
- INKDebug("tag", "event %d received\n", event);
- /* INKHttpSsnReenable(ssnp, INK_EVENT_HTTP_CONTINUE); */
- INKHttpTxnReenable(txnp, INK_EVENT_HTTP_CONTINUE);
+ case TS_EVENT_HTTP_READ_RESPONSE_HDR:
+ TSDebug("tag", "event %d received\n", event);
+ /* TSHttpSsnReenable(ssnp, TS_EVENT_HTTP_CONTINUE); */
+ TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
break;
- case INK_EVENT_HTTP_RESPONSE_TRANSFORM:
- INKDebug("tag", "event %d received\n", event);
- INKHttpSsnReenable(ssnp, INK_EVENT_HTTP_CONTINUE);
+ case TS_EVENT_HTTP_RESPONSE_TRANSFORM:
+ TSDebug("tag", "event %d received\n", event);
+ TSHttpSsnReenable(ssnp, TS_EVENT_HTTP_CONTINUE);
break;
default:
- INKDebug("tag", "Undefined event %d received\n");
+ TSDebug("tag", "Undefined event %d received\n");
break;
}
}
void
-INKPluginInit(int argc, const char *argv[])
+TSPluginInit(int argc, const char *argv[])
{
- INKCont contp = INKContCreate(INKProto, NULL);
+ TSCont contp = TSContCreate(TSProto, NULL);
- /* Context: INKHttpTxnTransformRespGet():
+ /* Context: TSHttpTxnTransformRespGet():
* Q: are both of these received and if so, in what order?
*/
- INKHttpHookAdd(INK_HTTP_READ_RESPONSE_HDR_HOOK, contp);
- INKHttpHookAdd(INK_HTTP_RESPONSE_TRANSFORM_HOOK, contp);
+ TSHttpHookAdd(TS_HTTP_READ_RESPONSE_HDR_HOOK, contp);
+ TSHttpHookAdd(TS_HTTP_RESPONSE_TRANSFORM_HOOK, contp);
}