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 [5/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-1...
Modified: trafficserver/traffic/trunk/example/response-header-1/response-header-1.c
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/example/response-header-1/response-header-1.c?rev=1035782&r1=1035781&r2=1035782&view=diff
==============================================================================
--- trafficserver/traffic/trunk/example/response-header-1/response-header-1.c (original)
+++ trafficserver/traffic/trunk/example/response-header-1/response-header-1.c Tue Nov 16 20:22:02 2010
@@ -59,22 +59,22 @@ static char *mimehdr1_name;
static char *mimehdr2_name;
static char *mimehdr1_value;
-static INKMBuffer hdr_bufp;
-static INKMLoc hdr_loc;
+static TSMBuffer hdr_bufp;
+static TSMLoc hdr_loc;
-static INKMLoc field_loc;
-static INKMLoc value_loc;
+static TSMLoc field_loc;
+static TSMLoc value_loc;
static void
-modify_header(INKHttpTxn txnp, INKCont contp)
+modify_header(TSHttpTxn txnp, TSCont contp)
{
- INKMBuffer resp_bufp;
- INKMBuffer cached_bufp;
- INKMLoc resp_loc;
- INKMLoc cached_loc;
- INKHttpStatus resp_status;
- INKMLoc new_field_loc;
- INKMLoc cached_field_loc;
+ TSMBuffer resp_bufp;
+ TSMBuffer cached_bufp;
+ TSMLoc resp_loc;
+ TSMLoc cached_loc;
+ TSHttpStatus resp_status;
+ TSMLoc new_field_loc;
+ TSMLoc cached_field_loc;
time_t recvd_time;
const char *chkptr;
@@ -85,98 +85,98 @@ modify_header(INKHttpTxn txnp, INKCont c
if (!init_buffer_status)
return; /* caller reenables */
- if (!INKHttpTxnServerRespGet(txnp, &resp_bufp, &resp_loc)) {
- INKError("couldn't retrieve server response header\n");
+ if (!TSHttpTxnServerRespGet(txnp, &resp_bufp, &resp_loc)) {
+ TSError("couldn't retrieve server response header\n");
return; /* caller reenables */
}
- /* INKqa06246/INKqa06144 */
- resp_status = INKHttpHdrStatusGet(resp_bufp, resp_loc);
+ /* TSqa06246/TSqa06144 */
+ resp_status = TSHttpHdrStatusGet(resp_bufp, resp_loc);
- if (INK_HTTP_STATUS_OK == resp_status) {
+ if (TS_HTTP_STATUS_OK == resp_status) {
- INKDebug("resphdr", "Processing 200 OK");
- new_field_loc = INKMimeHdrFieldCreate(resp_bufp, resp_loc);
- INKDebug("resphdr", "Created new resp field with loc %d", new_field_loc);
+ TSDebug("resphdr", "Processing 200 OK");
+ new_field_loc = TSMimeHdrFieldCreate(resp_bufp, resp_loc);
+ TSDebug("resphdr", "Created new resp field with loc %d", new_field_loc);
/* copy name/values created at init
* ( "x-num-served-from-cache" ) : ( "0" )
*/
- INKMimeHdrFieldCopy(resp_bufp, resp_loc, new_field_loc, hdr_bufp, hdr_loc, field_loc);
+ TSMimeHdrFieldCopy(resp_bufp, resp_loc, new_field_loc, hdr_bufp, hdr_loc, field_loc);
/*********** Unclear why this is needed **************/
- INKMimeHdrFieldAppend(resp_bufp, resp_loc, new_field_loc);
+ TSMimeHdrFieldAppend(resp_bufp, resp_loc, new_field_loc);
/* Cache-Control: Public */
- new_field_loc = INKMimeHdrFieldCreate(resp_bufp, resp_loc);
- INKDebug("resphdr", "Created new resp field with loc %d", new_field_loc);
- INKMimeHdrFieldAppend(resp_bufp, resp_loc, new_field_loc);
- INKMimeHdrFieldNameSet(resp_bufp, resp_loc, new_field_loc,
- INK_MIME_FIELD_CACHE_CONTROL, INK_MIME_LEN_CACHE_CONTROL);
- INKMimeHdrFieldValueStringInsert(resp_bufp, resp_loc, new_field_loc,
- -1, INK_HTTP_VALUE_PUBLIC, INK_HTTP_LEN_PUBLIC);
+ new_field_loc = TSMimeHdrFieldCreate(resp_bufp, resp_loc);
+ TSDebug("resphdr", "Created new resp field with loc %d", new_field_loc);
+ TSMimeHdrFieldAppend(resp_bufp, resp_loc, new_field_loc);
+ TSMimeHdrFieldNameSet(resp_bufp, resp_loc, new_field_loc,
+ TS_MIME_FIELD_CACHE_CONTROL, TS_MIME_LEN_CACHE_CONTROL);
+ TSMimeHdrFieldValueStringInsert(resp_bufp, resp_loc, new_field_loc,
+ -1, TS_HTTP_VALUE_PUBLIC, TS_HTTP_LEN_PUBLIC);
/*
- * mimehdr2_name = INKstrdup( "x-date-200-recvd" ) : CurrentDateTime
+ * mimehdr2_name = TSstrdup( "x-date-200-recvd" ) : CurrentDateTime
*/
- new_field_loc = INKMimeHdrFieldCreate(resp_bufp, resp_loc);
- INKDebug("resphdr", "Created new resp field with loc %d", new_field_loc);
- INKMimeHdrFieldAppend(resp_bufp, resp_loc, new_field_loc);
- INKMimeHdrFieldNameSet(resp_bufp, resp_loc, new_field_loc, mimehdr2_name, strlen(mimehdr2_name));
+ new_field_loc = TSMimeHdrFieldCreate(resp_bufp, resp_loc);
+ TSDebug("resphdr", "Created new resp field with loc %d", new_field_loc);
+ TSMimeHdrFieldAppend(resp_bufp, resp_loc, new_field_loc);
+ TSMimeHdrFieldNameSet(resp_bufp, resp_loc, new_field_loc, mimehdr2_name, strlen(mimehdr2_name));
recvd_time = time(NULL);
- INKMimeHdrFieldValueDateInsert(resp_bufp, resp_loc, new_field_loc, recvd_time);
+ TSMimeHdrFieldValueDateInsert(resp_bufp, resp_loc, new_field_loc, recvd_time);
- INKHandleMLocRelease(resp_bufp, resp_loc, new_field_loc);
- INKHandleMLocRelease(resp_bufp, INK_NULL_MLOC, resp_loc);
+ TSHandleMLocRelease(resp_bufp, resp_loc, new_field_loc);
+ TSHandleMLocRelease(resp_bufp, TS_NULL_MLOC, resp_loc);
- } else if (INK_HTTP_STATUS_NOT_MODIFIED == resp_status) {
+ } else if (TS_HTTP_STATUS_NOT_MODIFIED == resp_status) {
- INKDebug("resphdr", "Processing 304 Not Modified");
+ TSDebug("resphdr", "Processing 304 Not Modified");
/* N.B.: Protect writes to data (hash on URL + mutex: (ies)) */
/* Get the cached HTTP header */
- if (!INKHttpTxnCachedRespGet(txnp, &cached_bufp, &cached_loc)) {
- INKError("STATUS 304, INKHttpTxnCachedRespGet():");
- INKError("couldn't retrieve cached response header\n");
- INKHandleMLocRelease(resp_bufp, INK_NULL_MLOC, resp_loc);
+ if (!TSHttpTxnCachedRespGet(txnp, &cached_bufp, &cached_loc)) {
+ TSError("STATUS 304, TSHttpTxnCachedRespGet():");
+ TSError("couldn't retrieve cached response header\n");
+ TSHandleMLocRelease(resp_bufp, TS_NULL_MLOC, resp_loc);
return; /* Caller reenables */
}
/* Get the cached MIME field name for this HTTP header */
- cached_field_loc = INKMimeHdrFieldFind(cached_bufp, cached_loc,
+ cached_field_loc = TSMimeHdrFieldFind(cached_bufp, cached_loc,
(const char *) mimehdr1_name, strlen(mimehdr1_name));
if (0 == cached_field_loc) {
- INKError("Can't find header %s in cached document", mimehdr1_name);
- INKHandleMLocRelease(resp_bufp, INK_NULL_MLOC, resp_loc);
- INKHandleMLocRelease(cached_bufp, INK_NULL_MLOC, cached_loc);
+ TSError("Can't find header %s in cached document", mimehdr1_name);
+ TSHandleMLocRelease(resp_bufp, TS_NULL_MLOC, resp_loc);
+ TSHandleMLocRelease(cached_bufp, TS_NULL_MLOC, cached_loc);
return; /* Caller reenables */
}
/* Get the cached MIME value for this name in this HTTP header */
- if (INKMimeHdrFieldValueStringGet(cached_bufp, cached_loc, cached_field_loc, 0, &chkptr, &chklength) == INK_ERROR ||
+ if (TSMimeHdrFieldValueStringGet(cached_bufp, cached_loc, cached_field_loc, 0, &chkptr, &chklength) == TS_ERROR ||
NULL == chkptr || !chklength) {
- INKError("Could not find value for cached MIME field name %s", mimehdr1_name);
- INKHandleMLocRelease(resp_bufp, INK_NULL_MLOC, resp_loc);
- INKHandleMLocRelease(cached_bufp, INK_NULL_MLOC, cached_loc);
- INKHandleMLocRelease(cached_bufp, cached_loc, cached_field_loc);
+ TSError("Could not find value for cached MIME field name %s", mimehdr1_name);
+ TSHandleMLocRelease(resp_bufp, TS_NULL_MLOC, resp_loc);
+ TSHandleMLocRelease(cached_bufp, TS_NULL_MLOC, cached_loc);
+ TSHandleMLocRelease(cached_bufp, cached_loc, cached_field_loc);
return; /* Caller reenables */
}
- INKDebug("resphdr", "Header field value is %s, with length %d", chkptr, chklength);
+ TSDebug("resphdr", "Header field value is %s, with length %d", chkptr, chklength);
/* TODO check these comments for correctness */
/*
- * Since INKMimeHdrFieldValueStringGet returned with valid values
- * are we also guaranteed that INKMimeHdrFieldValueUintGet returns
- * valid values? There is no erro code for INKMimeHdrFieldValueUintGet
+ * Since TSMimeHdrFieldValueStringGet returned with valid values
+ * are we also guaranteed that TSMimeHdrFieldValueUintGet returns
+ * valid values? There is no erro code for TSMimeHdrFieldValueUintGet
* and 0 is a valid value.
*/
/* Get the cached MIME value for this name in this HTTP header */
/*
- INKMimeHdrFieldValueUintGet(cached_bufp, cached_loc, cached_field_loc, 0, &num_refreshes);
- INKDebug("resphdr",
+ TSMimeHdrFieldValueUintGet(cached_bufp, cached_loc, cached_field_loc, 0, &num_refreshes);
+ TSDebug("resphdr",
"Cached header shows %d refreshes so far", num_refreshes );
num_refreshes++ ;
@@ -193,23 +193,23 @@ modify_header(INKHttpTxn txnp, INKCont c
* in the in-process response in order to have the cached response
* become invalid.
*/
- new_field_loc = INKMimeHdrFieldCreate(resp_bufp, resp_loc);
+ new_field_loc = TSMimeHdrFieldCreate(resp_bufp, resp_loc);
- /* mimehdr1_name : INKstrdup( "x-num-served-from-cache" ) ; */
+ /* mimehdr1_name : TSstrdup( "x-num-served-from-cache" ) ; */
- INKMimeHdrFieldAppend(resp_bufp, resp_loc, new_field_loc);
- INKMimeHdrFieldNameSet(resp_bufp, resp_loc, new_field_loc, mimehdr1_name, strlen(mimehdr1_name));
+ TSMimeHdrFieldAppend(resp_bufp, resp_loc, new_field_loc);
+ TSMimeHdrFieldNameSet(resp_bufp, resp_loc, new_field_loc, mimehdr1_name, strlen(mimehdr1_name));
- INKMimeHdrFieldValueUintInsert(resp_bufp, resp_loc, new_field_loc, -1, num_refreshes);
+ TSMimeHdrFieldValueUintInsert(resp_bufp, resp_loc, new_field_loc, -1, num_refreshes);
- INKHandleStringRelease(cached_bufp, cached_loc, chkptr);
- INKHandleMLocRelease(resp_bufp, resp_loc, new_field_loc);
- INKHandleMLocRelease(cached_bufp, cached_loc, cached_field_loc);
- INKHandleMLocRelease(cached_bufp, INK_NULL_MLOC, cached_loc);
- INKHandleMLocRelease(resp_bufp, INK_NULL_MLOC, resp_loc);
+ TSHandleStringRelease(cached_bufp, cached_loc, chkptr);
+ TSHandleMLocRelease(resp_bufp, resp_loc, new_field_loc);
+ TSHandleMLocRelease(cached_bufp, cached_loc, cached_field_loc);
+ TSHandleMLocRelease(cached_bufp, TS_NULL_MLOC, cached_loc);
+ TSHandleMLocRelease(resp_bufp, TS_NULL_MLOC, resp_loc);
} else {
- INKDebug("resphdr", "other response code %d", resp_status);
+ TSDebug("resphdr", "other response code %d", resp_status);
}
/*
@@ -221,16 +221,16 @@ modify_header(INKHttpTxn txnp, INKCont c
static int
-modify_response_header_plugin(INKCont contp, INKEvent event, void *edata)
+modify_response_header_plugin(TSCont contp, TSEvent event, void *edata)
{
- INKHttpTxn txnp = (INKHttpTxn) edata;
+ TSHttpTxn txnp = (TSHttpTxn) edata;
switch (event) {
- case INK_EVENT_HTTP_READ_RESPONSE_HDR:
- INKDebug("resphdr", "Called back with INK_EVENT_HTTP_READ_RESPONSE_HDR");
+ case TS_EVENT_HTTP_READ_RESPONSE_HDR:
+ TSDebug("resphdr", "Called back with TS_EVENT_HTTP_READ_RESPONSE_HDR");
modify_header(txnp, contp);
- INKHttpTxnReenable(txnp, INK_EVENT_HTTP_CONTINUE);
+ TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
/* fall through */
default:
@@ -243,7 +243,7 @@ int
check_ts_version()
{
- const char *ts_version = INKTrafficServerVersionGet();
+ const char *ts_version = TSTrafficServerVersionGet();
int result = 0;
if (ts_version) {
@@ -266,30 +266,30 @@ check_ts_version()
}
void
-INKPluginInit(int argc, const char *argv[])
+TSPluginInit(int argc, const char *argv[])
{
- INKMLoc chk_field_loc;
+ TSMLoc chk_field_loc;
- INKPluginRegistrationInfo info;
+ TSPluginRegistrationInfo info;
info.plugin_name = "response-header-1";
info.vendor_name = "MyCompany";
info.support_email = "ts-api-support@MyCompany.com";
- if (!INKPluginRegister(INK_SDK_VERSION_2_0, &info)) {
- INKError("Plugin registration failed.\n");
+ if (!TSPluginRegister(TS_SDK_VERSION_2_0, &info)) {
+ TSError("Plugin registration failed.\n");
}
if (!check_ts_version()) {
- INKError("Plugin requires Traffic Server 2.0 or later\n");
+ TSError("Plugin requires Traffic Server 2.0 or later\n");
return;
}
init_buffer_status = 0;
if (argc > 1) {
- INKError("usage: %s \n", argv[0]);
- INKError("warning: too many args %d\n", argc);
- INKError("warning: ignoring unused arguments beginning with %s\n", argv[1]);
+ TSError("usage: %s \n", argv[0]);
+ TSError("warning: too many args %d\n", argc);
+ TSError("warning: ignoring unused arguments beginning with %s\n", argv[1]);
}
/*
@@ -300,28 +300,28 @@ INKPluginInit(int argc, const char *argv
*/
- hdr_bufp = INKMBufferCreate();
- hdr_loc = INKMimeHdrCreate(hdr_bufp);
+ hdr_bufp = TSMBufferCreate();
+ hdr_loc = TSMimeHdrCreate(hdr_bufp);
- mimehdr1_name = INKstrdup("x-num-served-from-cache");
- mimehdr1_value = INKstrdup("0");
+ mimehdr1_name = TSstrdup("x-num-served-from-cache");
+ mimehdr1_value = TSstrdup("0");
/* Create name here and set DateTime value when o.s.
* response 200 is received
*/
- mimehdr2_name = INKstrdup("x-date-200-recvd");
+ mimehdr2_name = TSstrdup("x-date-200-recvd");
- INKDebug("resphdr", "Inserting header %s with value %s into init buffer", mimehdr1_name, mimehdr1_value);
+ TSDebug("resphdr", "Inserting header %s with value %s into init buffer", mimehdr1_name, mimehdr1_value);
- field_loc = INKMimeHdrFieldCreate(hdr_bufp, hdr_loc);
- INKMimeHdrFieldAppend(hdr_bufp, hdr_loc, field_loc);
- INKMimeHdrFieldNameSet(hdr_bufp, hdr_loc, field_loc, mimehdr1_name, strlen(mimehdr1_name));
- INKMimeHdrFieldValueStringInsert(hdr_bufp, hdr_loc, field_loc, -1, mimehdr1_value, strlen(mimehdr1_value));
- INKDebug("resphdr", "init buffer hdr, field and value locs are %d, %d and %d", hdr_loc, field_loc, value_loc);
+ field_loc = TSMimeHdrFieldCreate(hdr_bufp, hdr_loc);
+ TSMimeHdrFieldAppend(hdr_bufp, hdr_loc, field_loc);
+ TSMimeHdrFieldNameSet(hdr_bufp, hdr_loc, field_loc, mimehdr1_name, strlen(mimehdr1_name));
+ TSMimeHdrFieldValueStringInsert(hdr_bufp, hdr_loc, field_loc, -1, mimehdr1_value, strlen(mimehdr1_value));
+ TSDebug("resphdr", "init buffer hdr, field and value locs are %d, %d and %d", hdr_loc, field_loc, value_loc);
init_buffer_status = 1;
- INKHttpHookAdd(INK_HTTP_READ_RESPONSE_HDR_HOOK, INKContCreate(modify_response_header_plugin, NULL));
+ TSHttpHookAdd(TS_HTTP_READ_RESPONSE_HDR_HOOK, TSContCreate(modify_response_header_plugin, NULL));
/*
* The following code demonstrates how to extract the field_loc from the header.
@@ -329,13 +329,13 @@ INKPluginInit(int argc, const char *argv
* similar to this may be used to extract header fields from any buffer.
*/
- if (0 == (chk_field_loc = INKMimeHdrFieldGet(hdr_bufp, hdr_loc, 0))) {
- INKError("couldn't retrieve header field from init buffer");
- INKError("marking init buffer as corrupt; no more plugin processing");
+ if (0 == (chk_field_loc = TSMimeHdrFieldGet(hdr_bufp, hdr_loc, 0))) {
+ TSError("couldn't retrieve header field from init buffer");
+ TSError("marking init buffer as corrupt; no more plugin processing");
init_buffer_status = 0;
/* bail out here and reenable transaction */
} else {
if (field_loc != chk_field_loc)
- INKError("retrieved buffer field loc is %d when it should be %d", chk_field_loc, field_loc);
+ TSError("retrieved buffer field loc is %d when it should be %d", chk_field_loc, field_loc);
}
}
Modified: trafficserver/traffic/trunk/example/server-transform/server-transform.c
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/example/server-transform/server-transform.c?rev=1035782&r1=1035781&r2=1035782&view=diff
==============================================================================
--- trafficserver/traffic/trunk/example/server-transform/server-transform.c (original)
+++ trafficserver/traffic/trunk/example/server-transform/server-transform.c Tue Nov 16 20:22:02 2010
@@ -73,37 +73,37 @@
typedef struct
{
int state;
- INKHttpTxn txn;
+ TSHttpTxn txn;
- INKIOBuffer input_buf;
- INKIOBufferReader input_reader;
+ TSIOBuffer input_buf;
+ TSIOBufferReader input_reader;
- INKIOBuffer output_buf;
- INKIOBufferReader output_reader;
- INKVConn output_vc;
- INKVIO output_vio;
-
- INKAction pending_action;
- INKVConn server_vc;
- INKVIO server_vio;
+ TSIOBuffer output_buf;
+ TSIOBufferReader output_reader;
+ TSVConn output_vc;
+ TSVIO output_vio;
+
+ TSAction pending_action;
+ TSVConn server_vc;
+ TSVIO server_vio;
int content_length;
} TransformData;
-static INKCont transform_create(INKHttpTxn txnp);
-static void transform_destroy(INKCont contp);
-static int transform_connect(INKCont contp, TransformData * data);
-static int transform_write(INKCont contp, TransformData * data);
-static int transform_read_status(INKCont contp, TransformData * data);
-static int transform_read(INKCont contp, TransformData * data);
-static int transform_bypass(INKCont contp, TransformData * data);
-static int transform_buffer_event(INKCont contp, TransformData * data, INKEvent event, void *edata);
-static int transform_connect_event(INKCont contp, TransformData * data, INKEvent event, void *edata);
-static int transform_write_event(INKCont contp, TransformData * data, INKEvent event, void *edata);
-static int transform_read_status_event(INKCont contp, TransformData * data, INKEvent event, void *edata);
-static int transform_read_event(INKCont contp, TransformData * data, INKEvent event, void *edata);
-static int transform_bypass_event(INKCont contp, TransformData * data, INKEvent event, void *edata);
-static int transform_handler(INKCont contp, INKEvent event, void *edata);
+static TSCont transform_create(TSHttpTxn txnp);
+static void transform_destroy(TSCont contp);
+static int transform_connect(TSCont contp, TransformData * data);
+static int transform_write(TSCont contp, TransformData * data);
+static int transform_read_status(TSCont contp, TransformData * data);
+static int transform_read(TSCont contp, TransformData * data);
+static int transform_bypass(TSCont contp, TransformData * data);
+static int transform_buffer_event(TSCont contp, TransformData * data, TSEvent event, void *edata);
+static int transform_connect_event(TSCont contp, TransformData * data, TSEvent event, void *edata);
+static int transform_write_event(TSCont contp, TransformData * data, TSEvent event, void *edata);
+static int transform_read_status_event(TSCont contp, TransformData * data, TSEvent event, void *edata);
+static int transform_read_event(TSCont contp, TransformData * data, TSEvent event, void *edata);
+static int transform_bypass_event(TSCont contp, TransformData * data, TSEvent event, void *edata);
+static int transform_handler(TSCont contp, TSEvent event, void *edata);
#if !defined (_WIN32)
static in_addr_t server_ip;
@@ -113,18 +113,18 @@ static unsigned int server_ip;
static int server_port;
-static INKCont
-transform_create(INKHttpTxn txnp)
+static TSCont
+transform_create(TSHttpTxn txnp)
{
- INKCont contp;
+ TSCont contp;
TransformData *data;
- if ((contp = INKTransformCreate(transform_handler, txnp)) == INK_ERROR_PTR) {
- INKError("Error in creating Transformation. Retyring...");
+ if ((contp = TSTransformCreate(transform_handler, txnp)) == TS_ERROR_PTR) {
+ TSError("Error in creating Transformation. Retyring...");
return NULL;
}
- data = (TransformData *) INKmalloc(sizeof(TransformData));
+ data = (TransformData *) TSmalloc(sizeof(TransformData));
data->state = STATE_BUFFER;
data->txn = txnp;
data->input_buf = NULL;
@@ -138,64 +138,64 @@ transform_create(INKHttpTxn txnp)
data->server_vio = NULL;
data->content_length = 0;
- if (INKContDataSet(contp, data) != INK_SUCCESS) {
- INKError("Error in setting continuation's data. INKContDataSet doesn't return INK_SUCCESS");
+ if (TSContDataSet(contp, data) != TS_SUCCESS) {
+ TSError("Error in setting continuation's data. TSContDataSet doesn't return TS_SUCCESS");
}
return contp;
}
static void
-transform_destroy(INKCont contp)
+transform_destroy(TSCont contp)
{
TransformData *data;
- data = INKContDataGet(contp);
- if ((data != INK_ERROR_PTR) || (data != NULL)) {
+ data = TSContDataGet(contp);
+ if ((data != TS_ERROR_PTR) || (data != NULL)) {
if (data->input_buf) {
- if (INKIOBufferDestroy(data->input_buf) != INK_SUCCESS) {
- INKError("Unable to destroy input IO buffer");
+ if (TSIOBufferDestroy(data->input_buf) != TS_SUCCESS) {
+ TSError("Unable to destroy input IO buffer");
}
}
if (data->output_buf) {
- if (INKIOBufferDestroy(data->output_buf) != INK_SUCCESS) {
- INKError("Unable to destroy output IO buffer");
+ if (TSIOBufferDestroy(data->output_buf) != TS_SUCCESS) {
+ TSError("Unable to destroy output IO buffer");
}
}
if (data->pending_action) {
- if (INKActionCancel(data->pending_action) != INK_SUCCESS) {
- INKError("Unable to cancel the pending action");
+ if (TSActionCancel(data->pending_action) != TS_SUCCESS) {
+ TSError("Unable to cancel the pending action");
}
}
if (data->server_vc) {
- if (INKVConnAbort(data->server_vc, 1) != INK_SUCCESS) {
- INKError("Unable to abort server VConnection. INKVConnAbort doesn't return INK_SUCESS");
+ if (TSVConnAbort(data->server_vc, 1) != TS_SUCCESS) {
+ TSError("Unable to abort server VConnection. TSVConnAbort doesn't return TS_SUCESS");
}
}
- INKfree(data);
+ TSfree(data);
} else {
- INKError("Unable to get Continuation's Data. INKContDataGet returns INK_ERROR_PTR or NULL");
+ TSError("Unable to get Continuation's Data. TSContDataGet returns TS_ERROR_PTR or NULL");
}
- if (INKContDestroy(contp) != INK_SUCCESS) {
- INKError("Error in Destroying the continuation");
+ if (TSContDestroy(contp) != TS_SUCCESS) {
+ TSError("Error in Destroying the continuation");
}
}
static int
-transform_connect(INKCont contp, TransformData * data)
+transform_connect(TSCont contp, TransformData * data)
{
- INKAction action;
+ TSAction action;
int content_length;
data->state = STATE_CONNECT;
- content_length = INKIOBufferReaderAvail(data->input_reader);
- if (content_length != INK_ERROR) {
+ content_length = TSIOBufferReaderAvail(data->input_reader);
+ if (content_length != TS_ERROR) {
data->content_length = content_length;
data->content_length = htonl(data->content_length);
@@ -206,146 +206,146 @@ transform_connect(INKCont contp, Transfo
*/
{
- INKIOBuffer temp;
- INKIOBufferReader tempReader;
+ TSIOBuffer temp;
+ TSIOBufferReader tempReader;
- temp = INKIOBufferCreate();
- if (temp != INK_ERROR_PTR) {
- tempReader = INKIOBufferReaderAlloc(temp);
-
- if (tempReader != INK_ERROR_PTR) {
-
- if (INKIOBufferWrite(temp, (const char *) &data->content_length, sizeof(int)) == INK_ERROR) {
- INKError("INKIOBufferWrite returns INK_ERROR");
- if (INKIOBufferReaderFree(tempReader) == INK_ERROR) {
- INKError("INKIOBufferReaderFree returns INK_ERROR");
+ temp = TSIOBufferCreate();
+ if (temp != TS_ERROR_PTR) {
+ tempReader = TSIOBufferReaderAlloc(temp);
+
+ if (tempReader != TS_ERROR_PTR) {
+
+ if (TSIOBufferWrite(temp, (const char *) &data->content_length, sizeof(int)) == TS_ERROR) {
+ TSError("TSIOBufferWrite returns TS_ERROR");
+ if (TSIOBufferReaderFree(tempReader) == TS_ERROR) {
+ TSError("TSIOBufferReaderFree returns TS_ERROR");
}
- if (INKIOBufferDestroy(temp) == INK_ERROR) {
- INKError("INKIOBufferDestroy returns INK_ERROR");
+ if (TSIOBufferDestroy(temp) == TS_ERROR) {
+ TSError("TSIOBufferDestroy returns TS_ERROR");
}
return 0;
}
- if (INKIOBufferCopy(temp, data->input_reader, data->content_length, 0) == INK_ERROR) {
- INKError("INKIOBufferCopy returns INK_ERROR");
- if (INKIOBufferReaderFree(tempReader) == INK_ERROR) {
- INKError("INKIOBufferReaderFree returns INK_ERROR");
+ if (TSIOBufferCopy(temp, data->input_reader, data->content_length, 0) == TS_ERROR) {
+ TSError("TSIOBufferCopy returns TS_ERROR");
+ if (TSIOBufferReaderFree(tempReader) == TS_ERROR) {
+ TSError("TSIOBufferReaderFree returns TS_ERROR");
}
- if (INKIOBufferDestroy(temp) == INK_ERROR) {
- INKError("INKIOBufferDestroy returns INK_ERROR");
+ if (TSIOBufferDestroy(temp) == TS_ERROR) {
+ TSError("TSIOBufferDestroy returns TS_ERROR");
}
return 0;
}
- if (INKIOBufferReaderFree(data->input_reader) == INK_ERROR) {
- INKError("Unable to free IOBuffer Reader");
+ if (TSIOBufferReaderFree(data->input_reader) == TS_ERROR) {
+ TSError("Unable to free IOBuffer Reader");
}
- if (INKIOBufferDestroy(data->input_buf) == INK_ERROR) {
- INKError("Trying to destroy IOBuffer returns INK_ERROR");
+ if (TSIOBufferDestroy(data->input_buf) == TS_ERROR) {
+ TSError("Trying to destroy IOBuffer returns TS_ERROR");
}
data->input_buf = temp;
data->input_reader = tempReader;
} else {
- INKError("Unable to allocate a reader for buffer");
- if (INKIOBufferDestroy(temp) == INK_ERROR) {
- INKError("Unable to destroy IOBuffer");
+ TSError("Unable to allocate a reader for buffer");
+ if (TSIOBufferDestroy(temp) == TS_ERROR) {
+ TSError("Unable to destroy IOBuffer");
}
return 0;
}
} else {
- INKError("Unable to create IOBuffer.");
+ TSError("Unable to create IOBuffer.");
return 0;
}
}
} else {
- INKError("INKIOBufferReaderAvail returns INK_ERROR");
+ TSError("TSIOBufferReaderAvail returns TS_ERROR");
return 0;
}
- action = INKNetConnect(contp, server_ip, server_port);
- if (action != INK_ERROR_PTR) {
- if (!INKActionDone(action)) {
+ action = TSNetConnect(contp, server_ip, server_port);
+ if (action != TS_ERROR_PTR) {
+ if (!TSActionDone(action)) {
data->pending_action = action;
}
} else {
- INKError("Unable to connect to server. INKNetConnect returns INK_ERROR_PTR");
+ TSError("Unable to connect to server. TSNetConnect returns TS_ERROR_PTR");
}
return 0;
}
static int
-transform_write(INKCont contp, TransformData * data)
+transform_write(TSCont contp, TransformData * data)
{
int content_length;
data->state = STATE_WRITE;
- content_length = INKIOBufferReaderAvail(data->input_reader);
- if (content_length != INK_ERROR) {
+ content_length = TSIOBufferReaderAvail(data->input_reader);
+ if (content_length != TS_ERROR) {
data->server_vio =
- INKVConnWrite(data->server_vc, contp, INKIOBufferReaderClone(data->input_reader), content_length);
- if (data->server_vio == INK_ERROR_PTR) {
- INKError("INKVConnWrite returns INK_ERROR_PTR");
+ TSVConnWrite(data->server_vc, contp, TSIOBufferReaderClone(data->input_reader), content_length);
+ if (data->server_vio == TS_ERROR_PTR) {
+ TSError("TSVConnWrite returns TS_ERROR_PTR");
}
} else {
- INKError("INKIOBufferReaderAvail returns INK_ERROR");
+ TSError("TSIOBufferReaderAvail returns TS_ERROR");
}
return 0;
}
static int
-transform_read_status(INKCont contp, TransformData * data)
+transform_read_status(TSCont contp, TransformData * data)
{
data->state = STATE_READ_STATUS;
- data->output_buf = INKIOBufferCreate();
- if ((data->output_buf != NULL) && (data->output_buf != INK_ERROR_PTR)) {
- data->output_reader = INKIOBufferReaderAlloc(data->output_buf);
- if ((data->output_reader != NULL) && (data->output_reader != INK_ERROR_PTR)) {
- data->server_vio = INKVConnRead(data->server_vc, contp, data->output_buf, sizeof(int));
- if (data->server_vio == INK_ERROR_PTR) {
- INKError("INKVConnRead returns INK_ERROR_PTR");
+ data->output_buf = TSIOBufferCreate();
+ if ((data->output_buf != NULL) && (data->output_buf != TS_ERROR_PTR)) {
+ data->output_reader = TSIOBufferReaderAlloc(data->output_buf);
+ if ((data->output_reader != NULL) && (data->output_reader != TS_ERROR_PTR)) {
+ data->server_vio = TSVConnRead(data->server_vc, contp, data->output_buf, sizeof(int));
+ if (data->server_vio == TS_ERROR_PTR) {
+ TSError("TSVConnRead returns TS_ERROR_PTR");
}
} else {
- INKError("Error in Allocating a Reader to output buffer. INKIOBufferReaderAlloc returns NULL or INK_ERROR_PTR");
+ TSError("Error in Allocating a Reader to output buffer. TSIOBufferReaderAlloc returns NULL or TS_ERROR_PTR");
}
} else {
- INKError("Error in creating output buffer. INKIOBufferCreate returns INK_ERROR_PTR");
+ TSError("Error in creating output buffer. TSIOBufferCreate returns TS_ERROR_PTR");
}
return 0;
}
static int
-transform_read(INKCont contp, TransformData * data)
+transform_read(TSCont contp, TransformData * data)
{
data->state = STATE_READ;
- if (INKIOBufferDestroy(data->input_buf) != INK_SUCCESS) {
- INKError("Unable to destroy input IO Buffer. INKIOBuffer doesn't return INK_SUCCESS");
+ if (TSIOBufferDestroy(data->input_buf) != TS_SUCCESS) {
+ TSError("Unable to destroy input IO Buffer. TSIOBuffer doesn't return TS_SUCCESS");
}
data->input_buf = NULL;
data->input_reader = NULL;
- data->server_vio = INKVConnRead(data->server_vc, contp, data->output_buf, data->content_length);
+ data->server_vio = TSVConnRead(data->server_vc, contp, data->output_buf, data->content_length);
- if (data->server_vio == INK_ERROR_PTR) {
- INKError("INKVConnRead returns INK_ERROR_PTR");
+ if (data->server_vio == TS_ERROR_PTR) {
+ TSError("TSVConnRead returns TS_ERROR_PTR");
return -1;
}
- data->output_vc = INKTransformOutputVConnGet((INKVConn) contp);
- if ((data->output_vc == INK_ERROR_PTR) || (data->output_vc == NULL)) {
- INKError("INKTransformOutputVConnGet returns NULL or INK_ERROR_PTR");
+ data->output_vc = TSTransformOutputVConnGet((TSVConn) contp);
+ if ((data->output_vc == TS_ERROR_PTR) || (data->output_vc == NULL)) {
+ TSError("TSTransformOutputVConnGet returns NULL or TS_ERROR_PTR");
} else {
- data->output_vio = INKVConnWrite(data->output_vc, contp, data->output_reader, data->content_length);
- if ((data->output_vio == INK_ERROR_PTR) || (data->output_vio == NULL)) {
- INKError("INKVConnWrite returns NULL or INK_ERROR_PTR");
+ data->output_vio = TSVConnWrite(data->output_vc, contp, data->output_reader, data->content_length);
+ if ((data->output_vio == TS_ERROR_PTR) || (data->output_vio == NULL)) {
+ TSError("TSVConnWrite returns NULL or TS_ERROR_PTR");
}
}
@@ -353,59 +353,59 @@ transform_read(INKCont contp, TransformD
}
static int
-transform_bypass(INKCont contp, TransformData * data)
+transform_bypass(TSCont contp, TransformData * data)
{
data->state = STATE_BYPASS;
if (data->server_vc) {
- if (INKVConnAbort(data->server_vc, 1) != INK_SUCCESS) {
- INKError("Error in destroy server vc. INKVConnAbort doesn't return INK_SUCCESS");
+ if (TSVConnAbort(data->server_vc, 1) != TS_SUCCESS) {
+ TSError("Error in destroy server vc. TSVConnAbort doesn't return TS_SUCCESS");
}
data->server_vc = NULL;
data->server_vio = NULL;
}
if (data->output_buf) {
- if (INKIOBufferDestroy(data->output_buf) != INK_SUCCESS) {
- INKError("Error in destroy output IO buffer. INKIOBufferDestroy doesn't return INK_SUCCESS");
+ if (TSIOBufferDestroy(data->output_buf) != TS_SUCCESS) {
+ TSError("Error in destroy output IO buffer. TSIOBufferDestroy doesn't return TS_SUCCESS");
}
data->output_buf = NULL;
data->output_reader = NULL;
}
- if (INKIOBufferReaderConsume(data->input_reader, sizeof(int)) != INK_SUCCESS) {
- INKError("Error in Consuming bytes from Reader. INKIObufferReaderConsume doesn't return INK_SUCCESS");
+ if (TSIOBufferReaderConsume(data->input_reader, sizeof(int)) != TS_SUCCESS) {
+ TSError("Error in Consuming bytes from Reader. TSIObufferReaderConsume doesn't return TS_SUCCESS");
}
- data->output_vc = INKTransformOutputVConnGet((INKVConn) contp);
- if ((data->output_vc == INK_ERROR_PTR) || (data->output_vc == NULL)) {
- INKError("INKTransformOutputVConnGet returns NULL or INK_ERROR_PTR");
+ data->output_vc = TSTransformOutputVConnGet((TSVConn) contp);
+ if ((data->output_vc == TS_ERROR_PTR) || (data->output_vc == NULL)) {
+ TSError("TSTransformOutputVConnGet returns NULL or TS_ERROR_PTR");
} else {
data->output_vio =
- INKVConnWrite(data->output_vc, contp, data->input_reader, INKIOBufferReaderAvail(data->input_reader));
- if ((data->output_vio == INK_ERROR_PTR) || (data->output_vio == NULL)) {
- INKError("INKVConnWrite returns NULL or INK_ERROR_PTR");
+ TSVConnWrite(data->output_vc, contp, data->input_reader, TSIOBufferReaderAvail(data->input_reader));
+ if ((data->output_vio == TS_ERROR_PTR) || (data->output_vio == NULL)) {
+ TSError("TSVConnWrite returns NULL or TS_ERROR_PTR");
}
}
return 1;
}
static int
-transform_buffer_event(INKCont contp, TransformData * data, INKEvent event, void *edata)
+transform_buffer_event(TSCont contp, TransformData * data, TSEvent event, void *edata)
{
- INKVIO write_vio;
+ TSVIO write_vio;
int towrite;
int avail;
if (!data->input_buf) {
- data->input_buf = INKIOBufferCreate();
- if ((data->input_buf == NULL) || (data->input_buf == INK_ERROR_PTR)) {
- INKError("Error in Creating buffer");
+ data->input_buf = TSIOBufferCreate();
+ if ((data->input_buf == NULL) || (data->input_buf == TS_ERROR_PTR)) {
+ TSError("Error in Creating buffer");
return -1;
}
- data->input_reader = INKIOBufferReaderAlloc(data->input_buf);
- if ((data->input_reader == NULL) || (data->input_reader == INK_ERROR_PTR)) {
- INKError("Unable to allocate a reader to input buffer.");
+ data->input_reader = TSIOBufferReaderAlloc(data->input_buf);
+ if ((data->input_reader == NULL) || (data->input_reader == TS_ERROR_PTR)) {
+ TSError("Unable to allocate a reader to input buffer.");
return -1;
}
}
@@ -414,9 +414,9 @@ transform_buffer_event(INKCont contp, Tr
ourself. This VIO contains the buffer that we are to read from
as well as the continuation we are to call when the buffer is
empty. */
- write_vio = INKVConnWriteVIOGet(contp);
- if (write_vio == INK_ERROR_PTR) {
- INKError("Corrupted write VIO received.");
+ write_vio = TSVConnWriteVIOGet(contp);
+ if (write_vio == TS_ERROR_PTR) {
+ TSError("Corrupted write VIO received.");
}
/* We also check to see if the write VIO's buffer is non-NULL. A
@@ -424,20 +424,20 @@ transform_buffer_event(INKCont contp, Tr
shutdown and that the continuation does not want us to send any
more WRITE_READY or WRITE_COMPLETE events. For this buffered
transformation that means we're done buffering data. */
- if (!INKVIOBufferGet(write_vio)) {
+ if (!TSVIOBufferGet(write_vio)) {
return transform_connect(contp, data);
}
/* Determine how much data we have left to read. For this server
transform plugin this is also the amount of data we have left
to write to the output connection. */
- towrite = INKVIONTodoGet(write_vio);
+ towrite = TSVIONTodoGet(write_vio);
if (towrite > 0) {
/* The amount of data left to read needs to be truncated by
the amount of data actually in the read buffer. */
- avail = INKIOBufferReaderAvail(INKVIOReaderGet(write_vio));
- if (avail == INK_ERROR) {
- INKError("Unable to get the number of bytes availabe for reading");
+ avail = TSIOBufferReaderAvail(TSVIOReaderGet(write_vio));
+ if (avail == TS_ERROR) {
+ TSError("Unable to get the number of bytes availabe for reading");
} else {
if (towrite > avail) {
towrite = avail;
@@ -445,41 +445,41 @@ transform_buffer_event(INKCont contp, Tr
if (towrite > 0) {
/* Copy the data from the read buffer to the input buffer. */
- if (INKIOBufferCopy(data->input_buf, INKVIOReaderGet(write_vio), towrite, 0) == INK_ERROR) {
- INKError("Error in Copying the buffer");
+ if (TSIOBufferCopy(data->input_buf, TSVIOReaderGet(write_vio), towrite, 0) == TS_ERROR) {
+ TSError("Error in Copying the buffer");
} else {
/* Tell the read buffer that we have read the data and are no
longer interested in it. */
- if (INKIOBufferReaderConsume(INKVIOReaderGet(write_vio), towrite) != INK_SUCCESS) {
- INKError("Unable to consume bytes from the buffer");
+ if (TSIOBufferReaderConsume(TSVIOReaderGet(write_vio), towrite) != TS_SUCCESS) {
+ TSError("Unable to consume bytes from the buffer");
}
/* Modify the write VIO to reflect how much data we've
completed. */
- if (INKVIONDoneSet(write_vio, INKVIONDoneGet(write_vio) + towrite) != INK_SUCCESS) {
- INKError("Unable to modify the write VIO to reflect how much data we have completed");
+ if (TSVIONDoneSet(write_vio, TSVIONDoneGet(write_vio) + towrite) != TS_SUCCESS) {
+ TSError("Unable to modify the write VIO to reflect how much data we have completed");
}
}
}
}
} else {
- if (towrite == INK_ERROR) {
- INKError("INKVIONTodoGet returns INK_ERROR");
+ if (towrite == TS_ERROR) {
+ TSError("TSVIONTodoGet returns TS_ERROR");
return 0;
}
}
/* Now we check the write VIO to see if there is data left to
read. */
- if (INKVIONTodoGet(write_vio) > 0) {
+ if (TSVIONTodoGet(write_vio) > 0) {
/* Call back the write VIO continuation to let it know that we
are ready for more data. */
- INKContCall(INKVIOContGet(write_vio), INK_EVENT_VCONN_WRITE_READY, write_vio);
+ TSContCall(TSVIOContGet(write_vio), TS_EVENT_VCONN_WRITE_READY, write_vio);
} else {
/* Call back the write VIO continuation to let it know that we
have completed the write operation. */
- INKContCall(INKVIOContGet(write_vio), INK_EVENT_VCONN_WRITE_COMPLETE, write_vio);
+ TSContCall(TSVIOContGet(write_vio), TS_EVENT_VCONN_WRITE_COMPLETE, write_vio);
/* start compression... */
return transform_connect(contp, data);
@@ -489,14 +489,14 @@ transform_buffer_event(INKCont contp, Tr
}
static int
-transform_connect_event(INKCont contp, TransformData * data, INKEvent event, void *edata)
+transform_connect_event(TSCont contp, TransformData * data, TSEvent event, void *edata)
{
switch (event) {
- case INK_EVENT_NET_CONNECT:
+ case TS_EVENT_NET_CONNECT:
data->pending_action = NULL;
- data->server_vc = (INKVConn) edata;
+ data->server_vc = (TSVConn) edata;
return transform_write(contp, data);
- case INK_EVENT_NET_CONNECT_FAILED:
+ case TS_EVENT_NET_CONNECT_FAILED:
data->pending_action = NULL;
return transform_bypass(contp, data);
default:
@@ -507,15 +507,15 @@ transform_connect_event(INKCont contp, T
}
static int
-transform_write_event(INKCont contp, TransformData * data, INKEvent event, void *edata)
+transform_write_event(TSCont contp, TransformData * data, TSEvent event, void *edata)
{
switch (event) {
- case INK_EVENT_VCONN_WRITE_READY:
- if (INKVIOReenable(data->server_vio) != INK_SUCCESS) {
- INKError("Unable to reenable the server vio in INK_EVENT_VCONN_WRITE_READY");
+ case TS_EVENT_VCONN_WRITE_READY:
+ if (TSVIOReenable(data->server_vio) != TS_SUCCESS) {
+ TSError("Unable to reenable the server vio in TS_EVENT_VCONN_WRITE_READY");
}
break;
- case INK_EVENT_VCONN_WRITE_COMPLETE:
+ case TS_EVENT_VCONN_WRITE_COMPLETE:
return transform_read_status(contp, data);
default:
/* An error occurred while writing to the server. Close down
@@ -527,15 +527,15 @@ transform_write_event(INKCont contp, Tra
}
static int
-transform_read_status_event(INKCont contp, TransformData * data, INKEvent event, void *edata)
+transform_read_status_event(TSCont contp, TransformData * data, TSEvent event, void *edata)
{
switch (event) {
- case INK_EVENT_ERROR:
- case INK_EVENT_VCONN_EOS:
+ case TS_EVENT_ERROR:
+ case TS_EVENT_VCONN_EOS:
return transform_bypass(contp, data);
- case INK_EVENT_VCONN_READ_COMPLETE:
- if (INKIOBufferReaderAvail(data->output_reader) == sizeof(int)) {
- INKIOBufferBlock blk;
+ case TS_EVENT_VCONN_READ_COMPLETE:
+ if (TSIOBufferReaderAvail(data->output_reader) == sizeof(int)) {
+ TSIOBufferBlock blk;
char *buf;
void *buf_ptr;
int64 avail;
@@ -544,17 +544,17 @@ transform_read_status_event(INKCont cont
buf_ptr = &data->content_length;
while (read_nbytes > 0) {
- blk = INKIOBufferReaderStart(data->output_reader);
- if (blk == INK_ERROR_PTR) {
- INKError("Error in Getting the pointer to starting of reader block");
+ blk = TSIOBufferReaderStart(data->output_reader);
+ if (blk == TS_ERROR_PTR) {
+ TSError("Error in Getting the pointer to starting of reader block");
} else {
- buf = (char *) INKIOBufferBlockReadStart(blk, data->output_reader, &avail);
- if (buf != INK_ERROR_PTR) {
+ buf = (char *) TSIOBufferBlockReadStart(blk, data->output_reader, &avail);
+ if (buf != TS_ERROR_PTR) {
read_ndone = (avail >= read_nbytes) ? read_nbytes : avail;
memcpy(buf_ptr, buf, read_ndone);
if (read_ndone > 0) {
- if (INKIOBufferReaderConsume(data->output_reader, read_ndone) != INK_SUCCESS) {
- INKError("Error in consuming data from the buffer");
+ if (TSIOBufferReaderConsume(data->output_reader, read_ndone) != TS_SUCCESS) {
+ TSError("Error in consuming data from the buffer");
} else {
read_nbytes -= read_ndone;
/* move ptr frwd by read_ndone bytes */
@@ -562,7 +562,7 @@ transform_read_status_event(INKCont cont
}
}
} else {
- INKError("INKIOBufferBlockReadStart returns INK_ERROR_PTR");
+ TSError("TSIOBufferBlockReadStart returns TS_ERROR_PTR");
}
}
}
@@ -578,59 +578,59 @@ transform_read_status_event(INKCont cont
}
static int
-transform_read_event(INKCont contp, TransformData * data, INKEvent event, void *edata)
+transform_read_event(TSCont contp, TransformData * data, TSEvent event, void *edata)
{
switch (event) {
- case INK_EVENT_ERROR:
- if (INKVConnAbort(data->server_vc, 1) != INK_SUCCESS) {
- INKError("INKVConnAbort doesn't return INK_SUCCESS on server VConnection during INK_EVENT_ERROR");
+ case TS_EVENT_ERROR:
+ if (TSVConnAbort(data->server_vc, 1) != TS_SUCCESS) {
+ TSError("TSVConnAbort doesn't return TS_SUCCESS on server VConnection during TS_EVENT_ERROR");
}
data->server_vc = NULL;
data->server_vio = NULL;
- if (INKVConnAbort(data->output_vc, 1) != INK_SUCCESS) {
- INKError("INKVConnAbort doesn't return INK_SUCCESS on output VConnection during INK_EVENT_ERROR");
+ if (TSVConnAbort(data->output_vc, 1) != TS_SUCCESS) {
+ TSError("TSVConnAbort doesn't return TS_SUCCESS on output VConnection during TS_EVENT_ERROR");
}
data->output_vc = NULL;
data->output_vio = NULL;
break;
- case INK_EVENT_VCONN_EOS:
- if (INKVConnAbort(data->server_vc, 1) != INK_SUCCESS) {
- INKError("INKVConnAbort doesn't return INK_SUCCESS on server VConnection during INK_EVENT_VCONN_EOS");
+ case TS_EVENT_VCONN_EOS:
+ if (TSVConnAbort(data->server_vc, 1) != TS_SUCCESS) {
+ TSError("TSVConnAbort doesn't return TS_SUCCESS on server VConnection during TS_EVENT_VCONN_EOS");
}
data->server_vc = NULL;
data->server_vio = NULL;
- if (INKVConnAbort(data->output_vc, 1) != INK_SUCCESS) {
- INKError("INKVConnAbort doesn't return INK_SUCCESS on output VConnection during INK_EVENT_VCONN_EOS");
+ if (TSVConnAbort(data->output_vc, 1) != TS_SUCCESS) {
+ TSError("TSVConnAbort doesn't return TS_SUCCESS on output VConnection during TS_EVENT_VCONN_EOS");
}
data->output_vc = NULL;
data->output_vio = NULL;
break;
- case INK_EVENT_VCONN_READ_COMPLETE:
- if (INKVConnClose(data->server_vc) != INK_SUCCESS) {
- INKError("INKVConnClose doesn't return INK_SUCCESS on INK_EVENT_VCONN_READ_COMPLETE");
+ case TS_EVENT_VCONN_READ_COMPLETE:
+ if (TSVConnClose(data->server_vc) != TS_SUCCESS) {
+ TSError("TSVConnClose doesn't return TS_SUCCESS on TS_EVENT_VCONN_READ_COMPLETE");
}
data->server_vc = NULL;
data->server_vio = NULL;
- if (INKVIOReenable(data->output_vio) != INK_SUCCESS) {
- INKError("INKVIOReneable doesn't return INK_SUCCESS on INK_EVENT_VCONN_READ_COMPLETE");
+ if (TSVIOReenable(data->output_vio) != TS_SUCCESS) {
+ TSError("TSVIOReneable doesn't return TS_SUCCESS on TS_EVENT_VCONN_READ_COMPLETE");
}
break;
- case INK_EVENT_VCONN_READ_READY:
- if (INKVIOReenable(data->output_vio) != INK_SUCCESS) {
- INKError("INKVIOReneable doesn't return INK_SUCCESS on INK_EVENT_VCONN_READ_READY");
+ case TS_EVENT_VCONN_READ_READY:
+ if (TSVIOReenable(data->output_vio) != TS_SUCCESS) {
+ TSError("TSVIOReneable doesn't return TS_SUCCESS on TS_EVENT_VCONN_READ_READY");
}
break;
- case INK_EVENT_VCONN_WRITE_COMPLETE:
- if (INKVConnShutdown(data->output_vc, 0, 1) != INK_SUCCESS) {
- INKError("INKVConnShutdown doesn't return INK_SUCCESS during INK_EVENT_VCONN_WRITE_COMPLETE");
+ case TS_EVENT_VCONN_WRITE_COMPLETE:
+ if (TSVConnShutdown(data->output_vc, 0, 1) != TS_SUCCESS) {
+ TSError("TSVConnShutdown doesn't return TS_SUCCESS during TS_EVENT_VCONN_WRITE_COMPLETE");
}
break;
- case INK_EVENT_VCONN_WRITE_READY:
- if (INKVIOReenable(data->server_vio) != INK_SUCCESS) {
- INKError("INKVIOReneable doesn't return INK_SUCCESS while reenabling on INK_EVENT_VCONN_WRITE_READY");
+ case TS_EVENT_VCONN_WRITE_READY:
+ if (TSVIOReenable(data->server_vio) != TS_SUCCESS) {
+ TSError("TSVIOReneable doesn't return TS_SUCCESS while reenabling on TS_EVENT_VCONN_WRITE_READY");
}
break;
default:
@@ -641,18 +641,18 @@ transform_read_event(INKCont contp, Tran
}
static int
-transform_bypass_event(INKCont contp, TransformData * data, INKEvent event, void *edata)
+transform_bypass_event(TSCont contp, TransformData * data, TSEvent event, void *edata)
{
switch (event) {
- case INK_EVENT_VCONN_WRITE_COMPLETE:
- if (INKVConnShutdown(data->output_vc, 0, 1) != INK_SUCCESS) {
- INKError("Error in shutting down the VConnection while bypassing the event");
+ case TS_EVENT_VCONN_WRITE_COMPLETE:
+ if (TSVConnShutdown(data->output_vc, 0, 1) != TS_SUCCESS) {
+ TSError("Error in shutting down the VConnection while bypassing the event");
}
break;
- case INK_EVENT_VCONN_WRITE_READY:
+ case TS_EVENT_VCONN_WRITE_READY:
default:
- if (INKVIOReenable(data->output_vio) != INK_SUCCESS) {
- INKError("Error in re-enabling the VIO while bypassing the event");
+ if (TSVIOReenable(data->output_vio) != TS_SUCCESS) {
+ TSError("Error in re-enabling the VIO while bypassing the event");
}
break;
}
@@ -661,20 +661,20 @@ transform_bypass_event(INKCont contp, Tr
}
static int
-transform_handler(INKCont contp, INKEvent event, void *edata)
+transform_handler(TSCont contp, TSEvent event, void *edata)
{
/* Check to see if the transformation has been closed by a call to
- INKVConnClose. */
- if (INKVConnClosedGet(contp)) {
+ TSVConnClose. */
+ if (TSVConnClosedGet(contp)) {
transform_destroy(contp);
return 0;
} else {
TransformData *data;
int val = 0;
- data = (TransformData *) INKContDataGet(contp);
- if ((data == NULL) && (data == INK_ERROR_PTR)) {
- INKError("Didn't get Continuation's Data. Ignoring Event..");
+ data = (TransformData *) TSContDataGet(contp);
+ if ((data == NULL) && (data == TS_ERROR_PTR)) {
+ TSError("Didn't get Continuation's Data. Ignoring Event..");
return 0;
}
do {
@@ -705,7 +705,7 @@ transform_handler(INKCont contp, INKEven
}
static int
-request_ok(INKHttpTxn txnp)
+request_ok(TSHttpTxn txnp)
{
/* Is the initial client request OK for transformation. This is a
good place to check accept headers to see if the client can
@@ -714,7 +714,7 @@ request_ok(INKHttpTxn txnp)
}
static int
-cache_response_ok(INKHttpTxn txnp)
+cache_response_ok(TSHttpTxn txnp)
{
/* Is the response we're reading from cache OK for
* transformation. This is a good place to check the cached
@@ -727,7 +727,7 @@ cache_response_ok(INKHttpTxn txnp)
}
static int
-server_response_ok(INKHttpTxn txnp)
+server_response_ok(TSHttpTxn txnp)
{
/* Is the response the server sent OK for transformation. This is
* a good place to check the server's response to see if it is
@@ -735,73 +735,73 @@ server_response_ok(INKHttpTxn txnp)
* responses.
*/
- INKMBuffer bufp;
- INKMLoc hdr_loc;
- INKHttpStatus resp_status;
+ TSMBuffer bufp;
+ TSMLoc hdr_loc;
+ TSHttpStatus resp_status;
- if (INKHttpTxnServerRespGet(txnp, &bufp, &hdr_loc) == 0) {
- INKError("Unable to get handle to Server Response");
+ if (TSHttpTxnServerRespGet(txnp, &bufp, &hdr_loc) == 0) {
+ TSError("Unable to get handle to Server Response");
return 0;
}
- if ((resp_status = INKHttpHdrStatusGet(bufp, hdr_loc)) == (INKHttpStatus)INK_ERROR) {
- INKError("Error in Getting Status from Server response");
- if (INKHandleMLocRelease(bufp, INK_NULL_MLOC, hdr_loc) != INK_SUCCESS) {
- INKError("Unable to release handle to server request");
+ if ((resp_status = TSHttpHdrStatusGet(bufp, hdr_loc)) == (TSHttpStatus)TS_ERROR) {
+ TSError("Error in Getting Status from Server response");
+ if (TSHandleMLocRelease(bufp, TS_NULL_MLOC, hdr_loc) != TS_SUCCESS) {
+ TSError("Unable to release handle to server request");
}
return 0;
}
- if (INK_HTTP_STATUS_OK == resp_status) {
- if (INKHandleMLocRelease(bufp, INK_NULL_MLOC, hdr_loc) != INK_SUCCESS) {
- INKError("Unable to release handle to server request");
+ if (TS_HTTP_STATUS_OK == resp_status) {
+ if (TSHandleMLocRelease(bufp, TS_NULL_MLOC, hdr_loc) != TS_SUCCESS) {
+ TSError("Unable to release handle to server request");
}
return 1;
} else {
- if (INKHandleMLocRelease(bufp, INK_NULL_MLOC, hdr_loc) != INK_SUCCESS) {
- INKError("Unable to release handle to server request");
+ if (TSHandleMLocRelease(bufp, TS_NULL_MLOC, hdr_loc) != TS_SUCCESS) {
+ TSError("Unable to release handle to server request");
}
return 0;
}
}
static int
-transform_plugin(INKCont contp, INKEvent event, void *edata)
+transform_plugin(TSCont contp, TSEvent event, void *edata)
{
- INKHttpTxn txnp = (INKHttpTxn) edata;
+ TSHttpTxn txnp = (TSHttpTxn) edata;
switch (event) {
- case INK_EVENT_HTTP_READ_REQUEST_HDR:
+ case TS_EVENT_HTTP_READ_REQUEST_HDR:
if (request_ok(txnp)) {
- if (INKHttpTxnHookAdd(txnp, INK_HTTP_READ_CACHE_HDR_HOOK, contp) != INK_SUCCESS) {
- INKError("Unable to add continuation to hook " "INK_HTTP_READ_CACHE_HDR_HOOK for this transaction");
+ if (TSHttpTxnHookAdd(txnp, TS_HTTP_READ_CACHE_HDR_HOOK, contp) != TS_SUCCESS) {
+ TSError("Unable to add continuation to hook " "TS_HTTP_READ_CACHE_HDR_HOOK for this transaction");
}
- if (INKHttpTxnHookAdd(txnp, INK_HTTP_READ_RESPONSE_HDR_HOOK, contp) != INK_SUCCESS) {
- INKError("Unable to add continuation to hook " "INK_HTTP_READ_RESPONSE_HDR_HOOK for this transaction");
+ if (TSHttpTxnHookAdd(txnp, TS_HTTP_READ_RESPONSE_HDR_HOOK, contp) != TS_SUCCESS) {
+ TSError("Unable to add continuation to hook " "TS_HTTP_READ_RESPONSE_HDR_HOOK for this transaction");
}
}
- if (INKHttpTxnReenable(txnp, INK_EVENT_HTTP_CONTINUE) != INK_SUCCESS) {
- INKError("Error in re-enabling transaction at INK_HTTP_READ_REQUEST_HDR_HOOK");
+ if (TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE) != TS_SUCCESS) {
+ TSError("Error in re-enabling transaction at TS_HTTP_READ_REQUEST_HDR_HOOK");
}
break;
- case INK_EVENT_HTTP_READ_CACHE_HDR:
+ case TS_EVENT_HTTP_READ_CACHE_HDR:
if (cache_response_ok(txnp)) {
- if (INKHttpTxnHookAdd(txnp, INK_HTTP_RESPONSE_TRANSFORM_HOOK, transform_create(txnp)) != INK_SUCCESS) {
- INKError("Unable to add continuation to tranformation hook " "for this transaction");
+ if (TSHttpTxnHookAdd(txnp, TS_HTTP_RESPONSE_TRANSFORM_HOOK, transform_create(txnp)) != TS_SUCCESS) {
+ TSError("Unable to add continuation to tranformation hook " "for this transaction");
}
}
- if (INKHttpTxnReenable(txnp, INK_EVENT_HTTP_CONTINUE) != INK_SUCCESS) {
- INKError("Error in re-enabling transaction at INK_HTTP_READ_CACHE_HDR_HOOK");
+ if (TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE) != TS_SUCCESS) {
+ TSError("Error in re-enabling transaction at TS_HTTP_READ_CACHE_HDR_HOOK");
}
break;
- case INK_EVENT_HTTP_READ_RESPONSE_HDR:
+ case TS_EVENT_HTTP_READ_RESPONSE_HDR:
if (server_response_ok(txnp)) {
- if (INKHttpTxnHookAdd(txnp, INK_HTTP_RESPONSE_TRANSFORM_HOOK, transform_create(txnp)) != INK_SUCCESS) {
- INKError("Unable to add continuation to tranformation hook " "for this transaction");
+ if (TSHttpTxnHookAdd(txnp, TS_HTTP_RESPONSE_TRANSFORM_HOOK, transform_create(txnp)) != TS_SUCCESS) {
+ TSError("Unable to add continuation to tranformation hook " "for this transaction");
}
}
- if (INKHttpTxnReenable(txnp, INK_EVENT_HTTP_CONTINUE) != INK_SUCCESS) {
- INKError("Error in re-enabling transaction at INK_HTTP_READ_RESPONSE_HDR_HOOK");
+ if (TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE) != TS_SUCCESS) {
+ TSError("Error in re-enabling transaction at TS_HTTP_READ_RESPONSE_HDR_HOOK");
}
break;
default:
@@ -814,7 +814,7 @@ int
check_ts_version()
{
- const char *ts_version = INKTrafficServerVersionGet();
+ const char *ts_version = TSTrafficServerVersionGet();
int result = 0;
if (ts_version) {
@@ -837,21 +837,21 @@ check_ts_version()
}
void
-INKPluginInit(int argc, const char *argv[])
+TSPluginInit(int argc, const char *argv[])
{
- INKPluginRegistrationInfo info;
- INKCont cont;
+ TSPluginRegistrationInfo info;
+ TSCont cont;
info.plugin_name = "server-transform";
info.vendor_name = "MyCompany";
info.support_email = "ts-api-support@MyCompany.com";
- if (!INKPluginRegister(INK_SDK_VERSION_2_0, &info)) {
- INKError("Plugin registration failed.\n");
+ if (!TSPluginRegister(TS_SDK_VERSION_2_0, &info)) {
+ TSError("Plugin registration failed.\n");
}
if (!check_ts_version()) {
- INKError("Plugin requires Traffic Server 2.0 or later\n");
+ TSError("Plugin requires Traffic Server 2.0 or later\n");
return;
}
@@ -860,15 +860,15 @@ INKPluginInit(int argc, const char *argv
server_ip = htonl(server_ip);
server_port = 7;
- if ((cont = INKContCreate(transform_plugin, NULL)) == INK_ERROR_PTR) {
- INKError("Unable to create continuation. Aborting...");
+ if ((cont = TSContCreate(transform_plugin, NULL)) == TS_ERROR_PTR) {
+ TSError("Unable to create continuation. Aborting...");
return;
}
- if (INKHttpHookAdd(INK_HTTP_READ_REQUEST_HDR_HOOK, cont) == INK_ERROR) {
- INKError("Unable to add the continuation to the hook. Aborting...");
- if (INKContDestroy(cont) == INK_ERROR) {
- INKError("Error in Destroying the continuation.");
+ if (TSHttpHookAdd(TS_HTTP_READ_REQUEST_HDR_HOOK, cont) == TS_ERROR) {
+ TSError("Unable to add the continuation to the hook. Aborting...");
+ if (TSContDestroy(cont) == TS_ERROR) {
+ TSError("Error in Destroying the continuation.");
}
}
}
Modified: trafficserver/traffic/trunk/example/session-1/session-1.c
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/example/session-1/session-1.c?rev=1035782&r1=1035781&r2=1035782&view=diff
==============================================================================
--- trafficserver/traffic/trunk/example/session-1/session-1.c (original)
+++ trafficserver/traffic/trunk/example/session-1/session-1.c Tue Nov 16 20:22:02 2010
@@ -38,50 +38,50 @@ static INKStat av_transaction;
static void
-txn_handler(INKHttpTxn txnp, INKCont contp)
+txn_handler(TSHttpTxn txnp, TSCont contp)
{
int64 num_txns = 0;
INKStatIncrement(transaction_count);
INKStatIntGet(transaction_count, &num_txns);
- INKDebug("tag_session", "The number of transactions is %d\n", num_txns);
+ TSDebug("tag_session", "The number of transactions is %d\n", num_txns);
}
static void
-handle_session(INKHttpSsn ssnp, INKCont contp)
+handle_session(TSHttpSsn ssnp, TSCont contp)
{
int64 num_ssn = 0;
INKStatIncrement(session_count);
INKStatIntGet(session_count, &num_ssn);
- INKDebug("tag_session", "The number of sessions is %d\n", num_ssn);
- INKHttpSsnHookAdd(ssnp, INK_HTTP_TXN_START_HOOK, contp);
+ TSDebug("tag_session", "The number of sessions is %d\n", num_ssn);
+ TSHttpSsnHookAdd(ssnp, TS_HTTP_TXN_START_HOOK, contp);
}
static int
-ssn_handler(INKCont contp, INKEvent event, void *edata)
+ssn_handler(TSCont contp, TSEvent event, void *edata)
{
- INKHttpSsn ssnp;
- INKHttpTxn txnp;
+ TSHttpSsn ssnp;
+ TSHttpTxn txnp;
switch (event) {
- case INK_EVENT_HTTP_SSN_START:
+ case TS_EVENT_HTTP_SSN_START:
- ssnp = (INKHttpSsn) edata;
+ ssnp = (TSHttpSsn) edata;
handle_session(ssnp, contp);
- INKHttpSsnReenable(ssnp, INK_EVENT_HTTP_CONTINUE);
+ TSHttpSsnReenable(ssnp, TS_EVENT_HTTP_CONTINUE);
return 0;
- case INK_EVENT_HTTP_TXN_START:
- txnp = (INKHttpTxn) edata;
+ case TS_EVENT_HTTP_TXN_START:
+ txnp = (TSHttpTxn) edata;
txn_handler(txnp, contp);
- INKHttpTxnReenable(txnp, INK_EVENT_HTTP_CONTINUE);
+ TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
return 0;
default:
- INKDebug("tag_session", "In the default case: event = %d\n", event);
+ TSDebug("tag_session", "In the default case: event = %d\n", event);
break;
}
return 0;
@@ -91,7 +91,7 @@ int
check_ts_version()
{
- const char *ts_version = INKTrafficServerVersionGet();
+ const char *ts_version = TSTrafficServerVersionGet();
int result = 0;
if (ts_version) {
@@ -114,22 +114,22 @@ check_ts_version()
void
-INKPluginInit(int argc, const char *argv[])
+TSPluginInit(int argc, const char *argv[])
{
- INKCont contp;
- INKPluginRegistrationInfo info;
+ TSCont contp;
+ TSPluginRegistrationInfo info;
info.plugin_name = "session-1";
info.vendor_name = "MyCompany";
info.support_email = "ts-api-support@MyCompany.com";
- if (!INKPluginRegister(INK_SDK_VERSION_2_0, &info)) {
- INKError("[PluginInit] Plugin registration failed.\n");
+ if (!TSPluginRegister(TS_SDK_VERSION_2_0, &info)) {
+ TSError("[PluginInit] Plugin registration failed.\n");
goto error;
}
if (!check_ts_version()) {
- INKError("[PluginInit] Plugin requires Traffic Server 2.0 or later\n");
+ TSError("[PluginInit] Plugin requires Traffic Server 2.0 or later\n");
goto error;
}
@@ -137,9 +137,9 @@ INKPluginInit(int argc, const char *argv
session_count = INKStatCreate("session.count", INKSTAT_TYPE_INT64);
av_transaction = INKStatCreate("avg.transactions", INKSTAT_TYPE_FLOAT);
- contp = INKContCreate(ssn_handler, NULL);
- INKHttpHookAdd(INK_HTTP_SSN_START_HOOK, contp);
+ contp = TSContCreate(ssn_handler, NULL);
+ TSHttpHookAdd(TS_HTTP_SSN_START_HOOK, contp);
error:
- INKError("[PluginInit] Plugin not initialized");
+ TSError("[PluginInit] Plugin not initialized");
}
Modified: trafficserver/traffic/trunk/example/thread-1/readme.txt
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/example/thread-1/readme.txt?rev=1035782&r1=1035781&r2=1035782&view=diff
==============================================================================
--- trafficserver/traffic/trunk/example/thread-1/readme.txt (original)
+++ trafficserver/traffic/trunk/example/thread-1/readme.txt Tue Nov 16 20:22:02 2010
@@ -3,18 +3,18 @@ About thread-plugin.c
This plugin sets up a callback to a continuation whose
handler function creates a thread.
-INKPluginInit uses INKHttpHookAdd to create a
+TSPluginInit uses TSHttpHookAdd to create a
continuation that is called back after the HTTP
origin server DNS lookup (the hook is
-INK_HTTP_OS_DNS_HOOK). The handler function
+TS_HTTP_OS_DNS_HOOK). The handler function
for the continuation is thread_plugin.
The thread_plugin function creates a thread using
-INKThreadCreate(), passing it the reenable_txn function
+TSThreadCreate(), passing it the reenable_txn function
as follows:
-INKThreadCreate(reenable_txn, edta);
+TSThreadCreate(reenable_txn, edta);
The thread runs the reenable_txn function, which simply
-reenables the HTTP transaction using INKHttpTxnReenable().
+reenables the HTTP transaction using TSHttpTxnReenable().
The thread is automatically destroyed when the function
returns.
Modified: trafficserver/traffic/trunk/example/thread-1/thread-1.c
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/example/thread-1/thread-1.c?rev=1035782&r1=1035781&r2=1035782&view=diff
==============================================================================
--- trafficserver/traffic/trunk/example/thread-1/thread-1.c (original)
+++ trafficserver/traffic/trunk/example/thread-1/thread-1.c Tue Nov 16 20:22:02 2010
@@ -39,22 +39,22 @@
static void *
reenable_txn(void *data)
{
- INKHttpTxn txnp = (INKHttpTxn) data;
- INKHttpTxnReenable(txnp, INK_EVENT_HTTP_CONTINUE);
+ TSHttpTxn txnp = (TSHttpTxn) data;
+ TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
return NULL;
}
static int
-thread_plugin(INKCont contp, INKEvent event, void *edata)
+thread_plugin(TSCont contp, TSEvent event, void *edata)
{
switch (event) {
- case INK_EVENT_HTTP_OS_DNS:
+ case TS_EVENT_HTTP_OS_DNS:
/**
* Check if the thread has been created successfully or not.
* If the thread has not been created successfully, assert.
*/
- if (!INKThreadCreate(reenable_txn, edata)) {
- INKReleaseAssert(!"Failure in thread creation");
+ if (!TSThreadCreate(reenable_txn, edata)) {
+ TSReleaseAssert(!"Failure in thread creation");
}
return 0;
default:
@@ -67,7 +67,7 @@ int
check_ts_version()
{
- const char *ts_version = INKTrafficServerVersionGet();
+ const char *ts_version = TSTrafficServerVersionGet();
int result = 0;
if (ts_version) {
@@ -90,22 +90,22 @@ check_ts_version()
}
void
-INKPluginInit(int argc, const char *argv[])
+TSPluginInit(int argc, const char *argv[])
{
- INKPluginRegistrationInfo info;
+ TSPluginRegistrationInfo info;
info.plugin_name = "thread-1";
info.vendor_name = "MyCompany";
info.support_email = "ts-api-support@MyCompany.com";
- if (!INKPluginRegister(INK_SDK_VERSION_2_0, &info)) {
- INKError("Plugin registration failed.\n");
+ if (!TSPluginRegister(TS_SDK_VERSION_2_0, &info)) {
+ TSError("Plugin registration failed.\n");
}
if (!check_ts_version()) {
- INKError("Plugin requires Traffic Server 2.0 or later\n");
+ TSError("Plugin requires Traffic Server 2.0 or later\n");
return;
}
- INKHttpHookAdd(INK_HTTP_OS_DNS_HOOK, INKContCreate(thread_plugin, NULL));
+ TSHttpHookAdd(TS_HTTP_OS_DNS_HOOK, TSContCreate(thread_plugin, NULL));
}