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 [18/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/README.txt
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/test/plugin/INKHttpHooksTrans/README.txt?rev=1035782&r1=1035781&r2=1035782&view=diff
==============================================================================
--- trafficserver/traffic/trunk/test/plugin/INKHttpHooksTrans/README.txt (original)
+++ trafficserver/traffic/trunk/test/plugin/INKHttpHooksTrans/README.txt Tue Nov 16 20:22:02 2010
@@ -2,74 +2,74 @@
Test plan for Ch. 6 Programmers Guilde
-INKHttpHook.c
+TSHttpHook.c
------------
Tests for "global" hooks, i.e., registering for events not at the session
or transaction level and processing those events.
-INKHttpSsnHookAdd.c
+TSHttpSsnHookAdd.c
------------------
Tests for registering/processing events at the session level.
-Currently, only have INK_HTTP_REQUEST_TRANSFORM_HOOK.
-TODO test that transforms the response INK_HTTP_RESPONSE_TRANSFORM_HOOK
+Currently, only have TS_HTTP_REQUEST_TRANSFORM_HOOK.
+TODO test that transforms the response TS_HTTP_RESPONSE_TRANSFORM_HOOK
-INKHttpTxnHookAdd.c
+TSHttpTxnHookAdd.c
-------------------
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
events at the transaction level.
The test starts by registering and receiving events at the session
level and then registering events at the transaction level.
-INKHttpSelAlt.c
+TSHttpSelAlt.c
---------------
-TODO tests that register, receive and process event INK_HTTP_SELECT_ALT_HOOK
+TODO 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.
Notes altSelect.notes indicate how such a plug-in can be written.
-INKHttpReenableStop.c
+TSHttpReenableStop.c
--------------------
TODO tests of stopping an event at the session and transaction level
-INKHttpTxnServer.c
+TSHttpTxnServer.c
------------------
Test for origin server interaction:
- INKHttpTxnServerReqGet
- INKHttpTxnServerRespGet
+ TSHttpTxnServerReqGet
+ TSHttpTxnServerRespGet
and one misc Session level interface:
- INKHttpTxnSsnGet
+ TSHttpTxnSsnGet
-Delayed due to: INKqa08306.
+Delayed due to: TSqa08306.
-INKHttpTxnErrBodySet.c
+TSHttpTxnErrBodySet.c
----------------------
Implements setting the response
body on error.
-INKHttpTxnIPAddress.cc
+TSHttpTxnIPAddress.cc
---------------------
Tests of retrieving IP address
for a given transaction.
-INKHttpTransaction.c
+TSHttpTransaction.c
--------------------
Currently unused.
@@ -78,62 +78,62 @@ Currently unused.
----------------------------------------------------------------------------
-Debug tag: INKHttpHook and INKHttpSsnHookAdd
+Debug tag: TSHttpHook and TSHttpSsnHookAdd
----------------------------------------------------------------------------
-INKHttpSsnHookAdd.c:
+TSHttpSsnHookAdd.c:
Summary
CACHE MISS
-ChkEvents: -- INK_EVENT_HTTP_SSN_START --
-ChkEvents: -- INK_EVENT_HTTP_TXN_START --
-ChkEvents: -- INK_EVENT_HTTP_READ_REQUEST_HDR --
-ChkEvents: -- INK_EVENT_HTTP_OS_DNS --
-ChkEvents: -- INK_EVENT_HTTP_SEND_REQUEST_HDR --
-ChkEvents: -- INK_EVENT_HTTP_READ_RESPONSE_HDR --
-ChkEvents: -- INK_EVENT_HTTP_SEND_RESPONSE_HDR --
-ChkEvents: -- INK_EVENT_HTTP_SSN_CLOSE --
-ChkEvents: -- INK_EVENT_HTTP_TXN_CLOSE --
-ChkEvents: -- INK_EVENT_HTTP_RESPONSE_TRANSFORM --
-Event [0] INK_EVENT_HTTP_CONTINUE registered and not called back
-Event [1] INK_EVENT_HTTP_ERROR registered and not called back
-Event [5] INK_EVENT_HTTP_READ_CACHE_HDR registered and not called back
-Event [8] INK_EVENT_HTTP_REQUEST_TRANSFORM registered and not called back
-Event [10] INK_EVENT_HTTP_SELECT_ALT registered and not called back
-Event [15] INK_EVENT_MGMT_UPDATE registered and not called back
+ChkEvents: -- TS_EVENT_HTTP_SSN_START --
+ChkEvents: -- TS_EVENT_HTTP_TXN_START --
+ChkEvents: -- TS_EVENT_HTTP_READ_REQUEST_HDR --
+ChkEvents: -- TS_EVENT_HTTP_OS_DNS --
+ChkEvents: -- TS_EVENT_HTTP_SEND_REQUEST_HDR --
+ChkEvents: -- TS_EVENT_HTTP_READ_RESPONSE_HDR --
+ChkEvents: -- TS_EVENT_HTTP_SEND_RESPONSE_HDR --
+ChkEvents: -- TS_EVENT_HTTP_SSN_CLOSE --
+ChkEvents: -- TS_EVENT_HTTP_TXN_CLOSE --
+ChkEvents: -- TS_EVENT_HTTP_RESPONSE_TRANSFORM --
+Event [0] TS_EVENT_HTTP_CONTINUE registered and not called back
+Event [1] TS_EVENT_HTTP_ERROR registered and not called back
+Event [5] TS_EVENT_HTTP_READ_CACHE_HDR registered and not called back
+Event [8] TS_EVENT_HTTP_REQUEST_TRANSFORM registered and not called back
+Event [10] TS_EVENT_HTTP_SELECT_ALT registered and not called back
+Event [15] TS_EVENT_MGMT_UPDATE registered and not called back
CACHE HIT
-ChkEvents: -- INK_EVENT_HTTP_SSN_START --
-ChkEvents: -- INK_EVENT_HTTP_TXN_START --
-ChkEvents: -- INK_EVENT_HTTP_READ_REQUEST_HDR --
-ChkEvents: -- INK_EVENT_HTTP_OS_DNS --
-ChkEvents: -- INK_EVENT_HTTP_SELECT_ALT --
-ChkEvents: -- INK_EVENT_HTTP_READ_CACHE_HDR --
-ChkEvents: -- INK_EVENT_HTTP_SEND_RESPONSE_HDR --
-ChkEvents: -- INK_EVENT_HTTP_SSN_CLOSE --
-ChkEvents: -- INK_EVENT_HTTP_TXN_CLOSE --
-+OK: Event [0] INK_EVENT_HTTP_CONTINUE registered and not called back
-+OK: Event [1] INK_EVENT_HTTP_ERROR registered and not called back
-*OK: Event [8] INK_EVENT_HTTP_REQUEST_TRANSFORM registered and not called back
-++OK: Event [15] INK_EVENT_MGMT_UPDATE registered and not called back
+ChkEvents: -- TS_EVENT_HTTP_SSN_START --
+ChkEvents: -- TS_EVENT_HTTP_TXN_START --
+ChkEvents: -- TS_EVENT_HTTP_READ_REQUEST_HDR --
+ChkEvents: -- TS_EVENT_HTTP_OS_DNS --
+ChkEvents: -- TS_EVENT_HTTP_SELECT_ALT --
+ChkEvents: -- TS_EVENT_HTTP_READ_CACHE_HDR --
+ChkEvents: -- TS_EVENT_HTTP_SEND_RESPONSE_HDR --
+ChkEvents: -- TS_EVENT_HTTP_SSN_CLOSE --
+ChkEvents: -- TS_EVENT_HTTP_TXN_CLOSE --
++OK: Event [0] TS_EVENT_HTTP_CONTINUE registered and not called back
++OK: Event [1] TS_EVENT_HTTP_ERROR registered and not called back
+*OK: Event [8] TS_EVENT_HTTP_REQUEST_TRANSFORM registered and not called back
+++OK: Event [15] TS_EVENT_MGMT_UPDATE registered and not called back
-------
+OK: These events are listed here for completeness but are not events
that a plug-in would register or receive.
*OK: Not yet implimented.
-Event INK_EVENT_HTTP_REQUEST_TRANSFORM should be covered in INKHttpSelAlt.c
+Event TS_EVENT_HTTP_REQUEST_TRANSFORM should be covered in TSHttpSelAlt.c
but this plug-in is waiting input from devel.
++OK: Covered in the blacklist plugin. Further work should excercise this
plugin here.
-INK_HTTP_SELECT_ALT_HOOK (received)
+TS_HTTP_SELECT_ALT_HOOK (received)
----------------------------------------------------------------------------
-If INK_HTTP_SELECT_ALT_HOOK is not registered at the global level, event
+If TS_HTTP_SELECT_ALT_HOOK is not registered at the global level, event
is never received. This is documented.
Modified: trafficserver/traffic/trunk/test/plugin/INKHttpHooksTrans/altSelect.notes
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/test/plugin/INKHttpHooksTrans/altSelect.notes?rev=1035782&r1=1035781&r2=1035782&view=diff
==============================================================================
--- trafficserver/traffic/trunk/test/plugin/INKHttpHooksTrans/altSelect.notes (original)
+++ trafficserver/traffic/trunk/test/plugin/INKHttpHooksTrans/altSelect.notes Tue Nov 16 20:22:02 2010
@@ -12,25 +12,25 @@ see my responses below.
>Q: If a transformation is occuring, the default is
>to not cache the transformed content. A call to:
>
-> INKHttpTxnUntransformedRespCache(txnp, 1)
+> TSHttpTxnUntransformedRespCache(txnp, 1)
>
>should allow caching of both types of content.
I don't follow. My recollection is that if a transformation
is occurring, the default is
that transformed content, and only transformed content,
-is cached. (See the description of INKHttpTxnTransformedRespCache.)
+is cached. (See the description of TSHttpTxnTransformedRespCache.)
-If you set INKHttpTxnUntransformedRespCache(txnp, 1),
+If you set TSHttpTxnUntransformedRespCache(txnp, 1),
then untransformed content is cached. I believe the way
to make sure that both transformed and untransformed
content is cached is: to set both
-INKHttpTxnUntransformedRespCache(txnp, 1)
+TSHttpTxnUntransformedRespCache(txnp, 1)
and
-INKHttpTxnTransformedRespCache(txnp, 1)
+TSHttpTxnTransformedRespCache(txnp, 1)
-This is what the description of INKHttpTxnUntransformedRespCache
+This is what the description of TSHttpTxnUntransformedRespCache
seems to be saying. (It's directly from the engineer who designed it).
- but I could be wrong. this part of the api has not been
tested.
@@ -38,11 +38,11 @@ tested.
>
>Is this the same as:
>
-> INKHttpTxnTransformedRespCache(txnp, 1)
+> TSHttpTxnTransformedRespCache(txnp, 1)
>
>Q:
>Transformed/non-transformed content is made by
->using INK_HTTP_SELECT_ALT hook. The "infop"
+>using TS_HTTP_SELECT_ALT hook. The "infop"
>is passed in as a data parameter to the event
>handler.
>
@@ -54,11 +54,11 @@ tested.
>seem to be wrong about this:
>
>OK:
->INKHttpAltInfoCachedReqGet()
+>TSHttpAltInfoCachedReqGet()
>Get the cached client req hdr for this pAltInfo/multiplier value
>
>
->INKHttpAltInfoCachedRespGet()
+>TSHttpAltInfoCachedRespGet()
>Wrong:
> Get the cached client resp hdr for this pAltInfo/multiplier value
>Should be:
@@ -68,7 +68,7 @@ I agree. This is a mistake. I'll fix it.
>
>OK:
->INKHttpAltInfoClientReqGet
+>TSHttpAltInfoClientReqGet
>Get the client request hdr for this pAltInfo/multiplier value
>
>
@@ -113,7 +113,7 @@ book.
>> >Hi,
>> > I am writting a plug-in that uses all of the
>> > global events of the api. Would you have any
->> > coding samples for processing INK_HTTP_SELECT_ALT_HOOK.
+>> > coding samples for processing TS_HTTP_SELECT_ALT_HOOK.
>> >
>> > I can register and receive the event, but I don't have
>> > any other details on how to actually process this
Modified: trafficserver/traffic/trunk/test/plugin/INKNetConnect/INKNetConnectTest.c
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/test/plugin/INKNetConnect/INKNetConnectTest.c?rev=1035782&r1=1035781&r2=1035782&view=diff
==============================================================================
--- trafficserver/traffic/trunk/test/plugin/INKNetConnect/INKNetConnectTest.c (original)
+++ trafficserver/traffic/trunk/test/plugin/INKNetConnect/INKNetConnectTest.c Tue Nov 16 20:22:02 2010
@@ -24,22 +24,22 @@
#include <string.h>
#include "ts.h"
-static const char *g_strPluginName = "INKNetConnectTest plugin";
+static const char *g_strPluginName = "TSNetConnectTest plugin";
static unsigned int g_ConnectionAddress;
static int g_ConnectionPort = 0;
typedef struct
{
- INKCont m_MainCont;
- INKCont m_CheckCont;
- INKVConn m_VConn;
- INKHttpTxn m_Txnp;
- INKMBuffer m_Buffer;
- INKMLoc m_ClientHeaderLoc;
- INKMLoc m_ClientURLLoc;
- INKIOBuffer m_ReadIOBuffer;
- INKIOBuffer m_SendIOBuffer;
- INKAction m_Action;
+ TSCont m_MainCont;
+ TSCont m_CheckCont;
+ TSVConn m_VConn;
+ TSHttpTxn m_Txnp;
+ TSMBuffer m_Buffer;
+ TSMLoc m_ClientHeaderLoc;
+ TSMLoc m_ClientURLLoc;
+ TSIOBuffer m_ReadIOBuffer;
+ TSIOBuffer m_SendIOBuffer;
+ TSAction m_Action;
unsigned int m_ClientIP;
char *m_strClientURL;
} CheckData_T;
@@ -53,7 +53,7 @@ Log(const char *strLogMessage)
static CheckData_T *
CheckDataCreate()
{
- CheckData_T *pCheckData = (CheckData_T *) INKmalloc(sizeof(CheckData_T));
+ CheckData_T *pCheckData = (CheckData_T *) TSmalloc(sizeof(CheckData_T));
pCheckData->m_Action = NULL;
pCheckData->m_Buffer = NULL;
pCheckData->m_CheckCont = NULL;
@@ -76,134 +76,134 @@ CheckDataDestroy(CheckData_T * pCheckDat
if (pCheckData) {
/* free strings... */
if (pCheckData->m_strClientURL) {
- INKfree(pCheckData->m_strClientURL);
+ TSfree(pCheckData->m_strClientURL);
}
/* free IOBuffer... */
if (pCheckData->m_ReadIOBuffer) {
- INKIOBufferDestroy(pCheckData->m_ReadIOBuffer);
+ TSIOBufferDestroy(pCheckData->m_ReadIOBuffer);
}
if (pCheckData->m_SendIOBuffer) {
- INKIOBufferDestroy(pCheckData->m_SendIOBuffer);
+ TSIOBufferDestroy(pCheckData->m_SendIOBuffer);
}
if (pCheckData->m_Action) {
- INKActionCancel(pCheckData->m_Action);
+ TSActionCancel(pCheckData->m_Action);
}
if (pCheckData->m_VConn) {
- INKVConnClose(pCheckData->m_VConn);
+ TSVConnClose(pCheckData->m_VConn);
}
if (pCheckData->m_CheckCont) {
- INKContDestroy(pCheckData->m_CheckCont);
+ TSContDestroy(pCheckData->m_CheckCont);
}
- INKfree(pCheckData);
+ TSfree(pCheckData);
pCheckData = NULL;
}
}
static void
-SendCheck(INKCont contp, CheckData_T * pCheckData)
+SendCheck(TSCont contp, CheckData_T * pCheckData)
{
- char *strRequestData = (char *) INKmalloc(4096);
+ char *strRequestData = (char *) TSmalloc(4096);
int RequestLength = 0;
- strcpy(strRequestData, "INKNetConnect CHECK");
+ strcpy(strRequestData, "TSNetConnect CHECK");
RequestLength = strlen(strRequestData);
- pCheckData->m_SendIOBuffer = INKIOBufferCreate();
- INKIOBufferAppend(pCheckData->m_SendIOBuffer,
- INKIOBufferBlockCreate(INKIOBufferDataCreate(strRequestData, RequestLength, INK_DATA_MALLOCED),
+ pCheckData->m_SendIOBuffer = TSIOBufferCreate();
+ TSIOBufferAppend(pCheckData->m_SendIOBuffer,
+ TSIOBufferBlockCreate(TSIOBufferDataCreate(strRequestData, RequestLength, TS_DATA_MALLOCED),
RequestLength, 0));
- INKVConnWrite(pCheckData->m_VConn, contp, INKIOBufferReaderAlloc(pCheckData->m_SendIOBuffer), RequestLength);
+ TSVConnWrite(pCheckData->m_VConn, contp, TSIOBufferReaderAlloc(pCheckData->m_SendIOBuffer), RequestLength);
- pCheckData->m_ReadIOBuffer = INKIOBufferCreate();
- INKVConnRead(pCheckData->m_VConn, contp, pCheckData->m_ReadIOBuffer, 4096);
+ pCheckData->m_ReadIOBuffer = TSIOBufferCreate();
+ TSVConnRead(pCheckData->m_VConn, contp, pCheckData->m_ReadIOBuffer, 4096);
}
static void
-ReadCheck(INKCont contp, CheckData_T * pCheckData)
+ReadCheck(TSCont contp, CheckData_T * pCheckData)
{
- INKIOBufferReader IOBufferReader = INKIOBufferReaderAlloc(pCheckData->m_ReadIOBuffer);
- INKIOBufferBlock IOBufferBlock = INKIOBufferReaderStart(IOBufferReader);
+ TSIOBufferReader IOBufferReader = TSIOBufferReaderAlloc(pCheckData->m_ReadIOBuffer);
+ TSIOBufferBlock IOBufferBlock = TSIOBufferReaderStart(IOBufferReader);
const char *strBuffer = NULL;
int Avail;
- if (INK_HTTP_TYPE_REQUEST != INKHttpHdrTypeGet(pCheckData->m_Buffer, pCheckData->m_ClientHeaderLoc)) {
+ if (TS_HTTP_TYPE_REQUEST != TSHttpHdrTypeGet(pCheckData->m_Buffer, pCheckData->m_ClientHeaderLoc)) {
/* If the function returns something else, the transaction was canceled.
Therefore don't do anything...simply exit... */
- Log("HTTP header was not a INK_HTTP_TYPE_REQUEST (in ReadCheck)");
+ Log("HTTP header was not a TS_HTTP_TYPE_REQUEST (in ReadCheck)");
/*fwrite (pCheckData->m_Buffer, pCheckData->m_ClientHeaderLoc, 1,stderr); */
- fprintf(stderr, " TYPE = %d \n", (int) INKHttpHdrTypeGet(pCheckData->m_Buffer, pCheckData->m_ClientHeaderLoc));
+ fprintf(stderr, " TYPE = %d \n", (int) TSHttpHdrTypeGet(pCheckData->m_Buffer, pCheckData->m_ClientHeaderLoc));
} else {
if (IOBufferBlock) {
/* get a pointer to the data... */
- strBuffer = INKIOBufferBlockReadStart(IOBufferBlock, IOBufferReader, &Avail);
+ strBuffer = TSIOBufferBlockReadStart(IOBufferBlock, IOBufferReader, &Avail);
if (Avail) {
- if (strncmp("INKNetConnect CHECK", strBuffer, Avail) == 0) {
+ if (strncmp("TSNetConnect CHECK", strBuffer, Avail) == 0) {
Log("Succeeded");
} else {
Log("Failed");
}
/* indicate consumption of data... */
- INKIOBufferReaderConsume(IOBufferReader, Avail);
+ TSIOBufferReaderConsume(IOBufferReader, Avail);
} else {
Log("Avail was zero!!!");
}
}
}
- INKHttpTxnReenable(pCheckData->m_Txnp, INK_EVENT_HTTP_CONTINUE);
- INKVConnShutdown(pCheckData->m_VConn, 1, 0);
+ TSHttpTxnReenable(pCheckData->m_Txnp, TS_EVENT_HTTP_CONTINUE);
+ TSVConnShutdown(pCheckData->m_VConn, 1, 0);
CheckDataDestroy(pCheckData);
}
static int
-CheckAccessHandler(INKCont contp, INKEvent event, void *edata)
+CheckAccessHandler(TSCont contp, TSEvent event, void *edata)
{
- CheckData_T *pCheckData = (CheckData_T *) INKContDataGet(contp);
+ CheckData_T *pCheckData = (CheckData_T *) TSContDataGet(contp);
switch (event) {
- case INK_EVENT_NET_CONNECT: /* Connection established */
- Log("INK_EVENT_NET_CONNECT");
- pCheckData->m_VConn = (INKVConn) edata;
+ case TS_EVENT_NET_CONNECT: /* Connection established */
+ Log("TS_EVENT_NET_CONNECT");
+ pCheckData->m_VConn = (TSVConn) edata;
SendCheck(contp, pCheckData);
break;
- case INK_EVENT_NET_CONNECT_FAILED: /* Connection failed */
- Log("INK_EVENT_NET_CONNECT_FAILED");
+ case TS_EVENT_NET_CONNECT_FAILED: /* Connection failed */
+ Log("TS_EVENT_NET_CONNECT_FAILED");
CheckDataDestroy(pCheckData);
break;
- case INK_EVENT_VCONN_WRITE_READY: /* VConnection is ready for writing */
- Log("INK_EVENT_VCONN_WRITE_READY");
+ case TS_EVENT_VCONN_WRITE_READY: /* VConnection is ready for writing */
+ Log("TS_EVENT_VCONN_WRITE_READY");
break;
- case INK_EVENT_VCONN_WRITE_COMPLETE: /* VConnection has done its writing */
- Log("INK_EVENT_VCONN_WRITE_COMPLETE");
- INKVConnShutdown(pCheckData->m_VConn, 0, 1);
+ case TS_EVENT_VCONN_WRITE_COMPLETE: /* VConnection has done its writing */
+ Log("TS_EVENT_VCONN_WRITE_COMPLETE");
+ TSVConnShutdown(pCheckData->m_VConn, 0, 1);
break;
- case INK_EVENT_VCONN_READ_READY: /* VConnection is ready for reading */
- Log("INK_EVENT_VCONN_READ_READY");
+ case TS_EVENT_VCONN_READ_READY: /* VConnection is ready for reading */
+ Log("TS_EVENT_VCONN_READ_READY");
ReadCheck(contp, pCheckData);
break;
- case INK_EVENT_VCONN_READ_COMPLETE: /* VConnection has read all data */
- Log("INK_EVENT_VCONN_READ_COMPLETE");
+ case TS_EVENT_VCONN_READ_COMPLETE: /* VConnection has read all data */
+ Log("TS_EVENT_VCONN_READ_COMPLETE");
break;
- case INK_EVENT_VCONN_EOS:
- Log("INK_EVENT_VCONN_EOS");
+ case TS_EVENT_VCONN_EOS:
+ Log("TS_EVENT_VCONN_EOS");
CheckDataDestroy(pCheckData);
break;
- case INK_EVENT_ERROR:
- Log("INK_EVENT_ERROR");
+ case TS_EVENT_ERROR:
+ Log("TS_EVENT_ERROR");
CheckDataDestroy(pCheckData);
break;
@@ -218,60 +218,60 @@ CheckAccessHandler(INKCont contp, INKEve
static void
-HandleRequest(INKHttpTxn txnp, INKCont contp)
+HandleRequest(TSHttpTxn txnp, TSCont contp)
{
- INKAction Action;
+ TSAction Action;
const char *ClientURLScheme = NULL;
CheckData_T *pCheckData = CheckDataCreate();
- pCheckData->m_CheckCont = INKContCreate(CheckAccessHandler, INKMutexCreate());
+ pCheckData->m_CheckCont = TSContCreate(CheckAccessHandler, TSMutexCreate());
pCheckData->m_Txnp = txnp;
pCheckData->m_MainCont = contp;
- if (!INKHttpTxnClientReqGet(pCheckData->m_Txnp, &pCheckData->m_Buffer, &pCheckData->m_ClientHeaderLoc)) {
+ if (!TSHttpTxnClientReqGet(pCheckData->m_Txnp, &pCheckData->m_Buffer, &pCheckData->m_ClientHeaderLoc)) {
Log("couldn't retrieve client request header!\n");
goto done;
}
- if (INK_HTTP_TYPE_REQUEST != INKHttpHdrTypeGet(pCheckData->m_Buffer, pCheckData->m_ClientHeaderLoc)) {
+ if (TS_HTTP_TYPE_REQUEST != TSHttpHdrTypeGet(pCheckData->m_Buffer, pCheckData->m_ClientHeaderLoc)) {
/* If the function returns something else, the transaction was canceled.
Therefore don't do anything...simply exit... */
- Log("HTTP header was not a INK_HTTP_TYPE_REQUEST (in HandleRequest)");
+ Log("HTTP header was not a TS_HTTP_TYPE_REQUEST (in HandleRequest)");
return;
}
- pCheckData->m_ClientURLLoc = INKHttpHdrUrlGet(pCheckData->m_Buffer, pCheckData->m_ClientHeaderLoc);
+ pCheckData->m_ClientURLLoc = TSHttpHdrUrlGet(pCheckData->m_Buffer, pCheckData->m_ClientHeaderLoc);
if (!pCheckData->m_ClientURLLoc) {
Log("couldn't retrieve request url!\n");
goto done;
}
/* check if the request-scheme is HTTP */
- ClientURLScheme = INKUrlSchemeGet(pCheckData->m_Buffer, pCheckData->m_ClientURLLoc, NULL);
+ ClientURLScheme = TSUrlSchemeGet(pCheckData->m_Buffer, pCheckData->m_ClientURLLoc, NULL);
if (!ClientURLScheme) {
Log("couldn't retrieve request url scheme!\n");
goto done;
}
- if (strcmp(ClientURLScheme, INK_URL_SCHEME_HTTP) != 0) {
+ if (strcmp(ClientURLScheme, TS_URL_SCHEME_HTTP) != 0) {
/* it's not a HTTP request... */
goto done;
}
/* get client-ip */
- pCheckData->m_ClientIP = INKHttpTxnClientIPGet(pCheckData->m_Txnp);
+ pCheckData->m_ClientIP = TSHttpTxnClientIPGet(pCheckData->m_Txnp);
/* get client-url */
- pCheckData->m_strClientURL = INKUrlStringGet(pCheckData->m_Buffer, pCheckData->m_ClientURLLoc, NULL);
+ pCheckData->m_strClientURL = TSUrlStringGet(pCheckData->m_Buffer, pCheckData->m_ClientURLLoc, NULL);
if (!pCheckData->m_strClientURL) {
Log("couldn't retrieve request url string!\n");
goto done;
}
- INKContDataSet(pCheckData->m_CheckCont, pCheckData);
+ TSContDataSet(pCheckData->m_CheckCont, pCheckData);
- Action = INKNetConnect(pCheckData->m_CheckCont, g_ConnectionAddress, g_ConnectionPort);
+ Action = TSNetConnect(pCheckData->m_CheckCont, g_ConnectionAddress, g_ConnectionPort);
- if (!INKActionDone(Action)) {
+ if (!TSActionDone(Action)) {
pCheckData->m_Action = Action;
}
@@ -279,17 +279,17 @@ HandleRequest(INKHttpTxn txnp, INKCont c
done:
CheckDataDestroy(pCheckData);
- INKHttpTxnReenable(txnp, INK_EVENT_HTTP_CONTINUE);
+ TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
}
static int
-MediaACEPlugin(INKCont contp, INKEvent event, void *edata)
+MediaACEPlugin(TSCont contp, TSEvent event, void *edata)
{
- INKHttpTxn txnp = NULL;
+ TSHttpTxn txnp = NULL;
switch (event) {
- case INK_EVENT_HTTP_READ_REQUEST_HDR: /* after reading the request... */
- txnp = (INKHttpTxn) edata;
+ case TS_EVENT_HTTP_READ_REQUEST_HDR: /* after reading the request... */
+ txnp = (TSHttpTxn) edata;
printf("Transaction:%x\n", txnp);
HandleRequest(txnp, contp);
break;
@@ -301,7 +301,7 @@ MediaACEPlugin(INKCont contp, INKEvent e
}
void
-INKPluginInit(int argc, const char *argv[])
+TSPluginInit(int argc, const char *argv[])
{
/* Localhost */
g_ConnectionAddress = (127 << 24) | (0 << 16) | (0 << 8) | (1);
@@ -309,7 +309,7 @@ INKPluginInit(int argc, const char *argv
g_ConnectionPort = 7;
if (g_ConnectionAddress > 0) {
- INKHttpHookAdd(INK_HTTP_READ_REQUEST_HDR_HOOK, INKContCreate(MediaACEPlugin, NULL));
+ TSHttpHookAdd(TS_HTTP_READ_REQUEST_HDR_HOOK, TSContCreate(MediaACEPlugin, NULL));
}
Log("Loaded");
}
Modified: trafficserver/traffic/trunk/test/plugin/INKNetConnect/INKqa8418.c
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/test/plugin/INKNetConnect/INKqa8418.c?rev=1035782&r1=1035781&r2=1035782&view=diff
==============================================================================
--- trafficserver/traffic/trunk/test/plugin/INKNetConnect/INKqa8418.c (original)
+++ trafficserver/traffic/trunk/test/plugin/INKNetConnect/INKqa8418.c Tue Nov 16 20:22:02 2010
@@ -29,50 +29,50 @@
typedef struct
{
- INKHttpTxn txn;
- INKCont cont;
- INKAction act;
- INKIOBuffer abuf;
- INKIOBufferReader areader;
- INKIOBuffer rbuf;
- INKIOBufferReader rreader;
- INKVConn avc;
- INKVIO avio;
+ TSHttpTxn txn;
+ TSCont cont;
+ TSAction act;
+ TSIOBuffer abuf;
+ TSIOBufferReader areader;
+ TSIOBuffer rbuf;
+ TSIOBufferReader rreader;
+ TSVConn avc;
+ TSVIO avio;
} AuthData;
-static int auth_plugin(INKCont, INKEvent, void *);
-static void check_auth(INKHttpTxn, INKCont);
-static void require_auth(INKHttpTxn);
-static int verify_auth(INKCont, INKEvent, void *);
-static void destroy_auth(INKCont);
+static int auth_plugin(TSCont, TSEvent, void *);
+static void check_auth(TSHttpTxn, TSCont);
+static void require_auth(TSHttpTxn);
+static int verify_auth(TSCont, TSEvent, void *);
+static void destroy_auth(TSCont);
static in_addr_t svrip;
static int svrport;
void
-INKPluginInit(int argc, const char *argv[])
+TSPluginInit(int argc, const char *argv[])
{
svrip = (127 << 24) | (0 << 16) | (0 << 8) | (1);
svrip = htonl(svrip);
svrport = 7;
- INKHttpHookAdd(INK_HTTP_READ_REQUEST_HDR_HOOK, INKContCreate(auth_plugin, NULL));
+ TSHttpHookAdd(TS_HTTP_READ_REQUEST_HDR_HOOK, TSContCreate(auth_plugin, NULL));
}
static int
-auth_plugin(INKCont contp, INKEvent event, void *edata)
+auth_plugin(TSCont contp, TSEvent event, void *edata)
{
- INKHttpTxn txnp = (INKHttpTxn *) edata;
+ TSHttpTxn txnp = (TSHttpTxn *) edata;
- INKDebug("extauth", "auth_plugin: entered");
+ TSDebug("extauth", "auth_plugin: entered");
switch (event) {
- case INK_EVENT_HTTP_READ_REQUEST_HDR:
+ case TS_EVENT_HTTP_READ_REQUEST_HDR:
check_auth(txnp, contp);
return 0;
- case INK_EVENT_HTTP_SEND_RESPONSE_HDR:
+ case TS_EVENT_HTTP_SEND_RESPONSE_HDR:
require_auth(txnp);
return 0;
default:
@@ -83,16 +83,16 @@ auth_plugin(INKCont contp, INKEvent even
}
static void
-check_auth(INKHttpTxn txnp, INKCont contp)
+check_auth(TSHttpTxn txnp, TSCont contp)
{
AuthData *adata;
- INKCont acontp;
- INKAction action;
+ TSCont acontp;
+ TSAction action;
- INKDebug("extauth", "check_auth: entered");
+ TSDebug("extauth", "check_auth: entered");
- adata = (AuthData *) INKmalloc(sizeof(AuthData));
+ adata = (AuthData *) TSmalloc(sizeof(AuthData));
adata->txn = txnp;
adata->cont = contp;
adata->act = NULL;
@@ -102,172 +102,172 @@ check_auth(INKHttpTxn txnp, INKCont cont
adata->rreader = NULL;
adata->avc = NULL;
adata->avio = NULL;
- acontp = INKContCreate(verify_auth, INKMutexCreate());
- INKContDataSet(acontp, adata);
+ acontp = TSContCreate(verify_auth, TSMutexCreate());
+ TSContDataSet(acontp, adata);
- action = INKNetConnect(acontp, svrip, svrport);
- if (!INKActionDone(action)) {
+ action = TSNetConnect(acontp, svrip, svrport);
+ if (!TSActionDone(action)) {
adata->act = action;
}
- INKDebug("extauth", "check_auth: INKNetConnect called");
- INKDebug("extauth", "check_auth: returning");
+ TSDebug("extauth", "check_auth: TSNetConnect called");
+ TSDebug("extauth", "check_auth: returning");
return;
}
static int
-verify_auth(INKCont acontp, INKEvent event, void *edata)
+verify_auth(TSCont acontp, TSEvent event, void *edata)
{
AuthData *adata;
- INKIOBufferData d;
- INKIOBufferBlock b;
+ TSIOBufferData d;
+ TSIOBufferBlock b;
char *userinfo = "good:evil";
int uil = strlen(userinfo);
- INKDebug("extauth", "verify_auth: entered");
+ TSDebug("extauth", "verify_auth: entered");
- adata = (AuthData *) INKContDataGet(acontp);
+ adata = (AuthData *) TSContDataGet(acontp);
switch (event) {
- case INK_EVENT_NET_CONNECT:
+ case TS_EVENT_NET_CONNECT:
- INKDebug("extauth", "verify_auth: NET_CONNECT");
+ TSDebug("extauth", "verify_auth: NET_CONNECT");
adata->act = NULL;
- adata->abuf = INKIOBufferCreate();
- adata->areader = INKIOBufferReaderAlloc(adata->abuf);
- d = INKIOBufferDataCreate(userinfo, uil, INK_DATA_CONSTANT);
- b = INKIOBufferBlockCreate(d, uil, 0);
- INKIOBufferAppend(adata->abuf, b);
+ adata->abuf = TSIOBufferCreate();
+ adata->areader = TSIOBufferReaderAlloc(adata->abuf);
+ d = TSIOBufferDataCreate(userinfo, uil, TS_DATA_CONSTANT);
+ b = TSIOBufferBlockCreate(d, uil, 0);
+ TSIOBufferAppend(adata->abuf, b);
- adata->avc = (INKVConn) edata;
- adata->avio = INKVConnWrite(adata->avc, acontp, adata->areader, INKIOBufferReaderAvail(adata->areader));
+ adata->avc = (TSVConn) edata;
+ adata->avio = TSVConnWrite(adata->avc, acontp, adata->areader, TSIOBufferReaderAvail(adata->areader));
return 0;
- case INK_EVENT_VCONN_WRITE_READY:
+ case TS_EVENT_VCONN_WRITE_READY:
- INKDebug("extauth", "verify_auth: VCONN_WRITE_READY");
+ TSDebug("extauth", "verify_auth: VCONN_WRITE_READY");
- INKVIOReenable(adata->avio);
+ TSVIOReenable(adata->avio);
return 0;
- case INK_EVENT_VCONN_WRITE_COMPLETE:
+ case TS_EVENT_VCONN_WRITE_COMPLETE:
- INKDebug("extauth", "verify_auth: VCONN_WRITE_COMPLETE");
+ TSDebug("extauth", "verify_auth: VCONN_WRITE_COMPLETE");
- INKVConnShutdown(adata->avc, 0, 1);
- adata->rbuf = INKIOBufferCreate();
- adata->rreader = INKIOBufferReaderAlloc(adata->rbuf);
- adata->avio = INKVConnRead(adata->avc, acontp, adata->rbuf, uil);
+ TSVConnShutdown(adata->avc, 0, 1);
+ adata->rbuf = TSIOBufferCreate();
+ adata->rreader = TSIOBufferReaderAlloc(adata->rbuf);
+ adata->avio = TSVConnRead(adata->avc, acontp, adata->rbuf, uil);
return 0;
- case INK_EVENT_VCONN_READ_READY:
+ case TS_EVENT_VCONN_READ_READY:
- INKDebug("extauth", "verify_auth: VCONN_READ_READY");
+ TSDebug("extauth", "verify_auth: VCONN_READ_READY");
- INKVIOReenable(adata->avio);
+ TSVIOReenable(adata->avio);
return 0;
- case INK_EVENT_VCONN_READ_COMPLETE:
+ case TS_EVENT_VCONN_READ_COMPLETE:
- INKDebug("extauth", "verify_auth: VCONN_READ_COMPLETE");
+ TSDebug("extauth", "verify_auth: VCONN_READ_COMPLETE");
- if (INKIOBufferReaderAvail(adata->rreader) == uil) {
- INKIOBufferBlock rb;
+ if (TSIOBufferReaderAvail(adata->rreader) == uil) {
+ TSIOBufferBlock rb;
const char *resp;
char *respstr;
int avail, i;
- rb = INKIOBufferReaderStart(adata->rreader);
- resp = INKIOBufferBlockReadStart(rb, adata->rreader, &avail);
+ rb = TSIOBufferReaderStart(adata->rreader);
+ resp = TSIOBufferBlockReadStart(rb, adata->rreader, &avail);
if (avail == uil) {
- respstr = (char *) INKmalloc(sizeof(char) * (uil + 1));
+ respstr = (char *) TSmalloc(sizeof(char) * (uil + 1));
for (i = 0; i < uil; i++) {
respstr[i] = resp[i];
}
respstr[i] = '\0';
- INKIOBufferReaderConsume(adata->rreader, uil);
- INKDebug("extauth", "AuthServer Response - %s", respstr);
- INKfree(respstr);
+ TSIOBufferReaderConsume(adata->rreader, uil);
+ TSDebug("extauth", "AuthServer Response - %s", respstr);
+ TSfree(respstr);
}
- INKIOBufferDestroy(adata->rbuf);
+ TSIOBufferDestroy(adata->rbuf);
adata->rbuf = NULL;
adata->rreader = NULL;
- INKVConnClose(adata->avc);
+ TSVConnClose(adata->avc);
adata->avc = NULL;
adata->avio = NULL;
- INKHttpTxnReenable(adata->txn, INK_EVENT_HTTP_CONTINUE);
+ TSHttpTxnReenable(adata->txn, TS_EVENT_HTTP_CONTINUE);
destroy_auth(acontp);
return 0;
}
break;
- case INK_EVENT_NET_CONNECT_FAILED:
+ case TS_EVENT_NET_CONNECT_FAILED:
- INKDebug("extauth", "verify_auth: NET_CONNECT_FAILED");
+ TSDebug("extauth", "verify_auth: NET_CONNECT_FAILED");
adata->act = NULL;
break;
- case INK_EVENT_ERROR:
+ case TS_EVENT_ERROR:
- INKDebug("extauth", "verify_auth: ERROR");
+ TSDebug("extauth", "verify_auth: ERROR");
break;
default:
break;
}
- INKHttpTxnHookAdd(adata->txn, INK_HTTP_SEND_RESPONSE_HDR_HOOK, adata->cont);
- INKHttpTxnReenable(adata->txn, INK_EVENT_HTTP_ERROR);
+ TSHttpTxnHookAdd(adata->txn, TS_HTTP_SEND_RESPONSE_HDR_HOOK, adata->cont);
+ TSHttpTxnReenable(adata->txn, TS_EVENT_HTTP_ERROR);
destroy_auth(acontp);
return 0;
}
static void
-destroy_auth(INKCont acontp)
+destroy_auth(TSCont acontp)
{
AuthData *adata;
- adata = INKContDataGet(acontp);
+ adata = TSContDataGet(acontp);
if (adata->abuf) {
- INKIOBufferDestroy(adata->abuf);
+ TSIOBufferDestroy(adata->abuf);
}
if (adata->rbuf) {
- INKIOBufferDestroy(adata->rbuf);
+ TSIOBufferDestroy(adata->rbuf);
}
if (adata->act) {
- INKActionCancel(adata->act);
+ TSActionCancel(adata->act);
}
if (adata->avc) {
- INKVConnAbort(adata->avc, 1);
+ TSVConnAbort(adata->avc, 1);
}
- INKfree(adata);
- INKContDestroy(acontp);
+ TSfree(adata);
+ TSContDestroy(acontp);
return;
}
static void
-require_auth(INKHttpTxn txnp)
+require_auth(TSHttpTxn txnp)
{
- INKMBuffer bufp;
- INKMLoc hdr_loc, newfld_loc;
+ TSMBuffer bufp;
+ TSMLoc hdr_loc, newfld_loc;
- if (!INKHttpTxnClientRespGet(txnp, &bufp, &hdr_loc)) {
- INKError("require_auth: failed to retrieve client response");
+ if (!TSHttpTxnClientRespGet(txnp, &bufp, &hdr_loc)) {
+ TSError("require_auth: failed to retrieve client response");
goto done;
}
- INKHttpHdrStatusSet(bufp, hdr_loc, INK_HTTP_STATUS_PROXY_AUTHENTICATION_REQUIRED);
- INKHttpHdrReasonSet(bufp, hdr_loc, INKHttpHdrReasonLookup(INK_HTTP_STATUS_PROXY_AUTHENTICATION_REQUIRED), -1);
+ TSHttpHdrStatusSet(bufp, hdr_loc, TS_HTTP_STATUS_PROXY_AUTHENTICATION_REQUIRED);
+ TSHttpHdrReasonSet(bufp, hdr_loc, TSHttpHdrReasonLookup(TS_HTTP_STATUS_PROXY_AUTHENTICATION_REQUIRED), -1);
- newfld_loc = INKMimeHdrFieldCreate(bufp, hdr_loc);
- INKMimeHdrFieldNameSet(bufp, hdr_loc, newfld_loc, INK_MIME_FIELD_PROXY_AUTHENTICATE, INK_MIME_LEN_PROXY_AUTHENTICATE);
- INKMimeFieldValueInsert(bufp, newfld_loc, "Basic realm=\"Armageddon\"", -1, -1);
- INKMimeHdrFieldAppend(bufp, hdr_loc, newfld_loc);
+ newfld_loc = TSMimeHdrFieldCreate(bufp, hdr_loc);
+ TSMimeHdrFieldNameSet(bufp, hdr_loc, newfld_loc, TS_MIME_FIELD_PROXY_AUTHENTICATE, TS_MIME_LEN_PROXY_AUTHENTICATE);
+ TSMimeFieldValueInsert(bufp, newfld_loc, "Basic realm=\"Armageddon\"", -1, -1);
+ TSMimeHdrFieldAppend(bufp, hdr_loc, newfld_loc);
done:
- INKHttpTxnReenable(txnp, INK_EVENT_HTTP_CONTINUE);
+ TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
}
Modified: trafficserver/traffic/trunk/test/plugin/alt-info/alt-info.c
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/test/plugin/alt-info/alt-info.c?rev=1035782&r1=1035781&r2=1035782&view=diff
==============================================================================
--- trafficserver/traffic/trunk/test/plugin/alt-info/alt-info.c (original)
+++ trafficserver/traffic/trunk/test/plugin/alt-info/alt-info.c Tue Nov 16 20:22:02 2010
@@ -22,8 +22,8 @@
*/
/**********************************************************************************************
- * The plugins uses the functions in the INKHttpAltInfo* group. They are called back on the
- * INK_HTTP_SELECT_ALT_HOOK. It also calls some other functions in the INK_HTTP_OS_DNS_HOOK.
+ * The plugins uses the functions in the TSHttpAltInfo* group. They are called back on the
+ * TS_HTTP_SELECT_ALT_HOOK. It also calls some other functions in the TS_HTTP_OS_DNS_HOOK.
**********************************************************************************************/
#include <stdio.h>
@@ -33,10 +33,10 @@
#define DEBUG_TAG "alt-info-dbg"
#define PLUGIN_NAME "alt-info"
-#define VALID_POINTER(X) ((X != NULL) && (X != INK_ERROR_PTR))
+#define VALID_POINTER(X) ((X != NULL) && (X != TS_ERROR_PTR))
#define LOG_SET_FUNCTION_NAME(NAME) const char * FUNCTION_NAME = NAME
#define LOG_ERROR(API_NAME) { \
- INKDebug(PLUGIN_NAME, "%s: %s %s %s File %s, line number %d", PLUGIN_NAME, API_NAME, "APIFAIL", \
+ TSDebug(PLUGIN_NAME, "%s: %s %s %s File %s, line number %d", PLUGIN_NAME, API_NAME, "APIFAIL", \
FUNCTION_NAME, __FILE__, __LINE__); \
}
#define LOG_ERROR_AND_RETURN(API_NAME) { \
@@ -49,62 +49,62 @@
}
#define LOG_ERROR_AND_REENABLE(API_NAME) { \
LOG_ERROR(API_NAME); \
- INKHttpTxnReenable(txnp, INK_EVENT_HTTP_CONTINUE); \
+ TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE); \
}
#define LOG_ERROR_NEG(API_NAME) { \
- INKDebug(PLUGIN_NAME, "%s: %s %s %s File %s, line number %d",PLUGIN_NAME, API_NAME, "NEGAPIFAIL", \
+ TSDebug(PLUGIN_NAME, "%s: %s %s %s File %s, line number %d",PLUGIN_NAME, API_NAME, "NEGAPIFAIL", \
FUNCTION_NAME, __FILE__, __LINE__); \
}
/***********************************************************************
- * play with the functions in the INKHttpAltInfo* group
+ * play with the functions in the TSHttpAltInfo* group
***********************************************************************/
static void
-handle_select_alt(INKHttpAltInfo infop)
+handle_select_alt(TSHttpAltInfo infop)
{
LOG_SET_FUNCTION_NAME("handle_select_alt");
- INKMBuffer client_req_buf = NULL;
- INKMBuffer cache_req_buf = NULL;
- INKMBuffer cache_resp_buf = NULL;
-
- INKMLoc client_req_hdr = NULL;
- INKMLoc cache_req_hdr = NULL;
- INKMLoc cache_resp_hdr = NULL;
+ TSMBuffer client_req_buf = NULL;
+ TSMBuffer cache_req_buf = NULL;
+ TSMBuffer cache_resp_buf = NULL;
+
+ TSMLoc client_req_hdr = NULL;
+ TSMLoc cache_req_hdr = NULL;
+ TSMLoc cache_resp_hdr = NULL;
- INKMLoc accept_language_field = NULL;
- INKMLoc content_language_field = NULL;
+ TSMLoc accept_language_field = NULL;
+ TSMLoc content_language_field = NULL;
int len;
const char *accept_value = NULL;
const char *content_value = NULL;
int quality = 0;
- /* negative test for INKHttpAltInfo* functions */
+ /* negative test for TSHttpAltInfo* functions */
#ifdef DEBUG
- if (INKHttpAltInfoClientReqGet(NULL, &client_req_buf, &client_req_hdr) != INK_ERROR)
- LOG_ERROR_NEG("INKHttpAltInfoClientReqGet");
+ if (TSHttpAltInfoClientReqGet(NULL, &client_req_buf, &client_req_hdr) != TS_ERROR)
+ LOG_ERROR_NEG("TSHttpAltInfoClientReqGet");
- if (INKHttpAltInfoCachedReqGet(NULL, &cache_req_buf, &cache_req_hdr) != INK_ERROR)
- LOG_ERROR_NEG("INKHttpAltInfoCachedReqGet");
+ if (TSHttpAltInfoCachedReqGet(NULL, &cache_req_buf, &cache_req_hdr) != TS_ERROR)
+ LOG_ERROR_NEG("TSHttpAltInfoCachedReqGet");
- if (INKHttpAltInfoCachedRespGet(NULL, &cache_resp_buf, &cache_resp_hdr) != INK_ERROR)
- LOG_ERROR_NEG("INKHttpAltInfoCachedRespGet");
+ if (TSHttpAltInfoCachedRespGet(NULL, &cache_resp_buf, &cache_resp_hdr) != TS_ERROR)
+ LOG_ERROR_NEG("TSHttpAltInfoCachedRespGet");
- if (INKHttpAltInfoQualitySet(NULL, quality) != INK_ERROR)
- LOG_ERROR_NEG("INKHttpAltInfoQualitySet");
+ if (TSHttpAltInfoQualitySet(NULL, quality) != TS_ERROR)
+ LOG_ERROR_NEG("TSHttpAltInfoQualitySet");
#endif
/* get client request, cached request and cached response */
- if (INKHttpAltInfoClientReqGet(infop, &client_req_buf, &client_req_hdr) != INK_SUCCESS)
- LOG_ERROR_AND_CLEANUP("INKHttpAltInfoClientReqGet");
+ if (TSHttpAltInfoClientReqGet(infop, &client_req_buf, &client_req_hdr) != TS_SUCCESS)
+ LOG_ERROR_AND_CLEANUP("TSHttpAltInfoClientReqGet");
- if (INKHttpAltInfoCachedReqGet(infop, &cache_req_buf, &cache_req_hdr) != INK_SUCCESS)
- LOG_ERROR_AND_CLEANUP("INKHttpAltInfoCachedReqGet");
+ if (TSHttpAltInfoCachedReqGet(infop, &cache_req_buf, &cache_req_hdr) != TS_SUCCESS)
+ LOG_ERROR_AND_CLEANUP("TSHttpAltInfoCachedReqGet");
- if (INKHttpAltInfoCachedRespGet(infop, &cache_resp_buf, &cache_resp_hdr) != INK_SUCCESS)
- LOG_ERROR_AND_CLEANUP("INKHttpAltInfoCachedRespGet");
+ if (TSHttpAltInfoCachedRespGet(infop, &cache_resp_buf, &cache_resp_hdr) != TS_SUCCESS)
+ LOG_ERROR_AND_CLEANUP("TSHttpAltInfoCachedRespGet");
/*
* get the Accept-Language field value from the client request
@@ -112,25 +112,25 @@ handle_select_alt(INKHttpAltInfo infop)
* if these two values are equivalent, set the quality of this alternate to 1
* otherwise set it to 0
*/
- if ((accept_language_field = INKMimeHdrFieldFind(client_req_buf, client_req_hdr, INK_MIME_FIELD_ACCEPT_LANGUAGE,
- INK_MIME_LEN_ACCEPT_LANGUAGE)) == INK_ERROR_PTR)
- LOG_ERROR_AND_CLEANUP("INKMimeHdrFieldFind");
+ if ((accept_language_field = TSMimeHdrFieldFind(client_req_buf, client_req_hdr, TS_MIME_FIELD_ACCEPT_LANGUAGE,
+ TS_MIME_LEN_ACCEPT_LANGUAGE)) == TS_ERROR_PTR)
+ LOG_ERROR_AND_CLEANUP("TSMimeHdrFieldFind");
if (accept_language_field) {
- if (INKMimeHdrFieldValueStringGet(client_req_buf, client_req_hdr, accept_language_field,
- 0, &accept_value, &len) == INK_ERROR)
- LOG_ERROR_AND_CLEANUP("INKMimeHdrFieldValueStringGet");
+ if (TSMimeHdrFieldValueStringGet(client_req_buf, client_req_hdr, accept_language_field,
+ 0, &accept_value, &len) == TS_ERROR)
+ LOG_ERROR_AND_CLEANUP("TSMimeHdrFieldValueStringGet");
} else {
/* If field Accept-language not found, set quality to 0 */
quality = 0;
}
- if ((content_language_field = INKMimeHdrFieldFind(cache_resp_buf, cache_resp_hdr, INK_MIME_FIELD_CONTENT_LANGUAGE,
- INK_MIME_LEN_CONTENT_LANGUAGE)) == INK_ERROR_PTR)
- LOG_ERROR_AND_CLEANUP("INKMimeHdrFieldFind");
+ if ((content_language_field = TSMimeHdrFieldFind(cache_resp_buf, cache_resp_hdr, TS_MIME_FIELD_CONTENT_LANGUAGE,
+ TS_MIME_LEN_CONTENT_LANGUAGE)) == TS_ERROR_PTR)
+ LOG_ERROR_AND_CLEANUP("TSMimeHdrFieldFind");
if (content_language_field) {
- if (INKMimeHdrFieldValueStringGet(cache_resp_buf, cache_resp_hdr, content_language_field,
- 0, &content_value, &len) == INK_ERROR)
- LOG_ERROR_AND_CLEANUP("INKMimeHdrFieldFind");
+ if (TSMimeHdrFieldValueStringGet(cache_resp_buf, cache_resp_hdr, content_language_field,
+ 0, &content_value, &len) == TS_ERROR)
+ LOG_ERROR_AND_CLEANUP("TSMimeHdrFieldFind");
} else {
/* If field content_language_field not found, set quality to 0 */
quality = 0;
@@ -140,50 +140,50 @@ handle_select_alt(INKHttpAltInfo infop)
quality = 1;
}
- if (INKHttpAltInfoQualitySet(infop, quality) == INK_ERROR)
- LOG_ERROR_AND_CLEANUP("INKHttpAltInfoQualitySet");
+ if (TSHttpAltInfoQualitySet(infop, quality) == TS_ERROR)
+ LOG_ERROR_AND_CLEANUP("TSHttpAltInfoQualitySet");
- INKDebug(DEBUG_TAG, "Accept-Language: %s, Content-Language: %s, alternate quality set to %d",
+ TSDebug(DEBUG_TAG, "Accept-Language: %s, Content-Language: %s, alternate quality set to %d",
accept_value, content_value, quality);
/* cleanup */
Lcleanup:
if (VALID_POINTER(accept_value))
- INKHandleStringRelease(client_req_buf, accept_language_field, accept_value);
+ TSHandleStringRelease(client_req_buf, accept_language_field, accept_value);
if (VALID_POINTER(accept_language_field))
- INKHandleMLocRelease(client_req_buf, client_req_hdr, accept_language_field);
+ TSHandleMLocRelease(client_req_buf, client_req_hdr, accept_language_field);
if (VALID_POINTER(client_req_hdr))
- INKHandleMLocRelease(client_req_buf, INK_NULL_MLOC, client_req_hdr);
+ TSHandleMLocRelease(client_req_buf, TS_NULL_MLOC, client_req_hdr);
if (VALID_POINTER(content_value))
- INKHandleStringRelease(cache_resp_buf, content_language_field, content_value);
+ TSHandleStringRelease(cache_resp_buf, content_language_field, content_value);
if (VALID_POINTER(content_language_field))
- INKHandleMLocRelease(cache_resp_buf, cache_resp_hdr, content_language_field);
+ TSHandleMLocRelease(cache_resp_buf, cache_resp_hdr, content_language_field);
if (VALID_POINTER(cache_resp_hdr))
- INKHandleMLocRelease(cache_resp_buf, INK_NULL_MLOC, cache_resp_hdr);
+ TSHandleMLocRelease(cache_resp_buf, TS_NULL_MLOC, cache_resp_hdr);
if (VALID_POINTER(cache_req_hdr))
- INKHandleMLocRelease(cache_req_buf, INK_NULL_MLOC, cache_req_hdr);
+ TSHandleMLocRelease(cache_req_buf, TS_NULL_MLOC, cache_req_hdr);
}
/**********************************************************************
- * Call the following functions on the INK_HTTP_OS_DNS_HOOK:
- * -- INKHttpTxnCachedReqGet
- * -- INKHttpTxnSsnGet
- * -- INKHttpTxnParentProxySet
- * -- INKrealloc
+ * Call the following functions on the TS_HTTP_OS_DNS_HOOK:
+ * -- TSHttpTxnCachedReqGet
+ * -- TSHttpTxnSsnGet
+ * -- TSHttpTxnParentProxySet
+ * -- TSrealloc
**********************************************************************/
static void
-handle_os_dns(INKHttpTxn txnp)
+handle_os_dns(TSHttpTxn txnp)
{
LOG_SET_FUNCTION_NAME("handle_os_dns");
- INKMBuffer bufp = NULL;
- INKMLoc hdr_loc = NULL;
- INKHttpSsn ssnp = NULL;
+ TSMBuffer bufp = NULL;
+ TSMLoc hdr_loc = NULL;
+ TSHttpSsn ssnp = NULL;
void *m = NULL;
void *r = NULL;
@@ -194,65 +194,65 @@ handle_os_dns(INKHttpTxn txnp)
int port = 10180;
/* get the cached request header */
- if (INKHttpTxnCachedReqGet(txnp, &bufp, &hdr_loc) == 0) {
- INKDebug(DEBUG_TAG, "Cannot get cached request header");
+ if (TSHttpTxnCachedReqGet(txnp, &bufp, &hdr_loc) == 0) {
+ TSDebug(DEBUG_TAG, "Cannot get cached request header");
} else {
- INKDebug(DEBUG_TAG, "Successfully get cached request header");
- INKHandleMLocRelease(bufp, INK_NULL_MLOC, hdr_loc);
+ TSDebug(DEBUG_TAG, "Successfully get cached request header");
+ TSHandleMLocRelease(bufp, TS_NULL_MLOC, hdr_loc);
}
/* get the session of this transaction */
- if ((ssnp = INKHttpTxnSsnGet(txnp)) == INK_ERROR_PTR || ssnp == NULL)
- LOG_ERROR_AND_REENABLE("INKHttpTxnSsnGet");
+ if ((ssnp = TSHttpTxnSsnGet(txnp)) == TS_ERROR_PTR || ssnp == NULL)
+ LOG_ERROR_AND_REENABLE("TSHttpTxnSsnGet");
- /* negative test for INKHttpTxnSsnGet */
+ /* negative test for TSHttpTxnSsnGet */
#ifdef DEBUG
- if (INKHttpTxnSsnGet(NULL) != INK_ERROR_PTR)
- LOG_ERROR_NEG("INKHttpTxnSsnGet");
+ if (TSHttpTxnSsnGet(NULL) != TS_ERROR_PTR)
+ LOG_ERROR_NEG("TSHttpTxnSsnGet");
#endif
/* set the parent proxy */
- if (INKHttpTxnParentProxySet(txnp, hostname, port) == INK_ERROR)
- LOG_ERROR_AND_REENABLE("INKHttpTxnParentProxySet");
+ if (TSHttpTxnParentProxySet(txnp, hostname, port) == TS_ERROR)
+ LOG_ERROR_AND_REENABLE("TSHttpTxnParentProxySet");
- /* negative test for INKHttpTxnParentProxySet */
+ /* negative test for TSHttpTxnParentProxySet */
#ifdef DEBUG
- if (INKHttpTxnParentProxySet(NULL, hostname, port) != INK_ERROR)
- LOG_ERROR_NEG("INKHttpTxnParentProxySet");
+ if (TSHttpTxnParentProxySet(NULL, hostname, port) != TS_ERROR)
+ LOG_ERROR_NEG("TSHttpTxnParentProxySet");
- if (INKHttpTxnParentProxySet(txnp, NULL, port) != INK_ERROR)
- LOG_ERROR_NEG("INKHttpTxnParentProxySet");
+ if (TSHttpTxnParentProxySet(txnp, NULL, port) != TS_ERROR)
+ LOG_ERROR_NEG("TSHttpTxnParentProxySet");
#endif
- /* try INKrealloc */
- if ((m = INKmalloc(size1)) == NULL)
- LOG_ERROR_AND_REENABLE("INKmalloc");
- if ((r = INKrealloc(m, size2)) == NULL)
- LOG_ERROR_AND_REENABLE("INKrealloc");
+ /* try TSrealloc */
+ if ((m = TSmalloc(size1)) == NULL)
+ LOG_ERROR_AND_REENABLE("TSmalloc");
+ if ((r = TSrealloc(m, size2)) == NULL)
+ LOG_ERROR_AND_REENABLE("TSrealloc");
- INKfree(r);
+ TSfree(r);
/* reenable the transaction */
- if (INKHttpTxnReenable(txnp, INK_EVENT_HTTP_CONTINUE) == INK_ERROR)
- LOG_ERROR("INKHttpTxnReenable");
+ if (TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE) == TS_ERROR)
+ LOG_ERROR("TSHttpTxnReenable");
}
static int
-alt_plugin(INKCont contp, INKEvent event, void *edata)
+alt_plugin(TSCont contp, TSEvent event, void *edata)
{
- INKHttpAltInfo infop;
- INKHttpTxn txnp;
+ TSHttpAltInfo infop;
+ TSHttpTxn txnp;
switch (event) {
- case INK_EVENT_HTTP_SELECT_ALT:
- infop = (INKHttpAltInfo) edata;
+ case TS_EVENT_HTTP_SELECT_ALT:
+ infop = (TSHttpAltInfo) edata;
handle_select_alt(infop);
break;
- case INK_EVENT_HTTP_OS_DNS:
- txnp = (INKHttpTxn) edata;
+ case TS_EVENT_HTTP_OS_DNS:
+ txnp = (TSHttpTxn) edata;
handle_os_dns(txnp);
break;
@@ -264,17 +264,17 @@ alt_plugin(INKCont contp, INKEvent event
}
void
-INKPluginInit(int argc, const char *argv[])
+TSPluginInit(int argc, const char *argv[])
{
- LOG_SET_FUNCTION_NAME("INKPluginInit");
- INKCont contp;
+ LOG_SET_FUNCTION_NAME("TSPluginInit");
+ TSCont contp;
- if ((contp = INKContCreate(alt_plugin, NULL)) == INK_ERROR_PTR)
- LOG_ERROR("INKContCreate")
+ if ((contp = TSContCreate(alt_plugin, NULL)) == TS_ERROR_PTR)
+ LOG_ERROR("TSContCreate")
else {
- if (INKHttpHookAdd(INK_HTTP_SELECT_ALT_HOOK, contp) == INK_ERROR)
- LOG_ERROR("INKHttpHookAdd");
- if (INKHttpHookAdd(INK_HTTP_OS_DNS_HOOK, contp) == INK_ERROR)
- LOG_ERROR("INKHttpHookAdd");
+ if (TSHttpHookAdd(TS_HTTP_SELECT_ALT_HOOK, contp) == TS_ERROR)
+ LOG_ERROR("TSHttpHookAdd");
+ if (TSHttpHookAdd(TS_HTTP_OS_DNS_HOOK, contp) == TS_ERROR)
+ LOG_ERROR("TSHttpHookAdd");
}
}
Modified: trafficserver/traffic/trunk/test/plugin/alt-info/alt_info_spec.htm
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/test/plugin/alt-info/alt_info_spec.htm?rev=1035782&r1=1035781&r2=1035782&view=diff
==============================================================================
--- trafficserver/traffic/trunk/test/plugin/alt-info/alt_info_spec.htm (original)
+++ trafficserver/traffic/trunk/test/plugin/alt-info/alt_info_spec.htm Tue Nov 16 20:22:02 2010
@@ -25,27 +25,27 @@
<p align="center"><b><font size="+2">Plugin alt-info Spec</font></b></p>
<p> </p>
<p><font size="+1"><b>Overview</b></font></p>
-<p>The plugin is mainly for testing the functions in the INKHttpAltInfo* group.
+<p>The plugin is mainly for testing the functions in the TSHttpAltInfo* group.
It also tests the following APIs:</p>
<ul>
- <li> INKHttpTxnCachedReqGet </li>
- <li>INKHttpTxnSsnGet </li>
- <li>INKHttpTxnParentProxySet </li>
- <li>INKrealloc </li>
+ <li> TSHttpTxnCachedReqGet </li>
+ <li>TSHttpTxnSsnGet </li>
+ <li>TSHttpTxnParentProxySet </li>
+ <li>TSrealloc </li>
</ul>
<p><font size="+1"><b>Plugin Specification</b></font></p>
-<p>In INKPluginInit(), the pluign registers two handler functions on INK_HTTP_OS_DNS_HOOK
- and INK_HTTP_SELECT_ALT_HOOK respectively.</p>
-<p>On INK_HTTP_OS_DNS_HOOK, the plugin calls the following functions:</p>
+<p>In TSPluginInit(), the pluign registers two handler functions on TS_HTTP_OS_DNS_HOOK
+ and TS_HTTP_SELECT_ALT_HOOK respectively.</p>
+<p>On TS_HTTP_OS_DNS_HOOK, the plugin calls the following functions:</p>
<ul>
- <li> INKHttpTxnCachedReqGet </li>
- <li>INKHttpTxnSsnGet </li>
- <li>INKHttpTxnParentProxySet </li>
- <li>INKrealloc </li>
+ <li> TSHttpTxnCachedReqGet </li>
+ <li>TSHttpTxnSsnGet </li>
+ <li>TSHttpTxnParentProxySet </li>
+ <li>TSrealloc </li>
</ul>
According to the return values of the functions, it prints out the status the
function calls: pass or fail.
-<p>On INK_HTTP_SELECT_ALT_HOOK, the plugins gets client request, cached request
+<p>On TS_HTTP_SELECT_ALT_HOOK, the plugins gets client request, cached request
and cached response from the alternate information. It then gets the Accept-Language
field value from the client request and the Content-language field value from
the cached response. If these two values are equivalent, the quality of this