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 [20/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/assembly/common.h
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/test/plugin/assembly/common.h?rev=1035782&r1=1035781&r2=1035782&view=diff
==============================================================================
--- trafficserver/traffic/trunk/test/plugin/assembly/common.h (original)
+++ trafficserver/traffic/trunk/test/plugin/assembly/common.h Tue Nov 16 20:22:02 2010
@@ -142,52 +142,52 @@ typedef struct
AsmStateType state;
/* Store current transaction */
- INKHttpTxn txn;
+ TSHttpTxn txn;
/* The input is the Http response coming from the OS */
- INKIOBuffer input_buffer;
- INKIOBufferReader input_parse_reader;
+ TSIOBuffer input_buffer;
+ TSIOBufferReader input_parse_reader;
/* The ouput is the transformed Http response sent to the client */
- INKIOBuffer output_buffer;
- INKIOBufferReader output_reader;
- INKVConn output_vc;
- INKVIO output_vio;
+ TSIOBuffer output_buffer;
+ TSIOBufferReader output_reader;
+ TSVConn output_vc;
+ TSVIO output_vio;
/* used to cancel any pending action when we exit */
- INKAction pending_action;
+ TSAction pending_action;
/* Connection via socket back to TS */
- INKVConn ts_vc;
- INKVIO ts_vio;
+ TSVConn ts_vc;
+ TSVIO ts_vio;
/* cache input = Http request sent to TS on socket back */
- INKIOBuffer ts_input_buffer;
- INKIOBufferReader ts_input_reader;
+ TSIOBuffer ts_input_buffer;
+ TSIOBufferReader ts_input_reader;
/* cache output = result sent by TS on socket back */
- INKIOBuffer ts_output_buffer;
- INKIOBufferReader ts_output_reader;
+ TSIOBuffer ts_output_buffer;
+ TSIOBufferReader ts_output_reader;
/* The block is bufferized in this iobuffer */
- INKIOBuffer block_buffer;
- INKIOBufferReader block_reader;
+ TSIOBuffer block_buffer;
+ TSIOBufferReader block_reader;
/* Connection to the cache */
- INKVConn cache_vc;
- INKVIO cache_read_vio;
- INKVIO cache_write_vio;
+ TSVConn cache_vc;
+ TSVIO cache_read_vio;
+ TSVIO cache_write_vio;
/* Buffer/Reader to read/write block to the cache */
- INKIOBuffer cache_read_buffer;
- INKIOBuffer cache_write_buffer;
- INKIOBufferReader cache_read_reader;
- INKIOBufferReader cache_write_reader;
+ TSIOBuffer cache_read_buffer;
+ TSIOBuffer cache_write_buffer;
+ TSIOBufferReader cache_read_reader;
+ TSIOBufferReader cache_write_reader;
int cache_read_retry_counter;
/* key used to store/fetch block from the cache */
- INKCacheKey block_key;
+ TSCacheKey block_key;
/* TTL for the block in the cache */
int block_ttl;
@@ -219,11 +219,11 @@ typedef struct
typedef struct
{
/* To store requested Url and Url actually used for cache lookup */
- INKMBuffer request_url_buf;
- INKMLoc request_url_loc;
+ TSMBuffer request_url_buf;
+ TSMLoc request_url_loc;
- INKMBuffer template_url_buf;
- INKMLoc template_url_loc;
+ TSMBuffer template_url_buf;
+ TSMLoc template_url_loc;
/* flag used to know whether or not transformation has been already set up */
int transform_created;
Modified: trafficserver/traffic/trunk/test/plugin/assembly/headers.c
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/test/plugin/assembly/headers.c?rev=1035782&r1=1035781&r2=1035782&view=diff
==============================================================================
--- trafficserver/traffic/trunk/test/plugin/assembly/headers.c (original)
+++ trafficserver/traffic/trunk/test/plugin/assembly/headers.c Tue Nov 16 20:22:02 2010
@@ -44,13 +44,13 @@
int
query_string_extract(TxnData * txn_data, char **query_store)
{
- INKMBuffer bufp;
- INKMLoc url_loc;
+ TSMBuffer bufp;
+ TSMLoc url_loc;
const char *query_string;
int len;
- INKAssert(txn_data->magic == MAGIC_ALIVE);
- INKDebug(MED, "In query_string_extract");
+ TSAssert(txn_data->magic == MAGIC_ALIVE);
+ TSDebug(MED, "In query_string_extract");
if (txn_data != NULL) {
bufp = txn_data->request_url_buf;
@@ -59,17 +59,17 @@ query_string_extract(TxnData * txn_data,
return -1;
}
- query_string = INKUrlHttpQueryGet(bufp, url_loc, &len);
+ query_string = TSUrlHttpQueryGet(bufp, url_loc, &len);
if ((len != 0) && (query_string != NULL)) {
- *query_store = INKmalloc(len + 1);
+ *query_store = TSmalloc(len + 1);
strncpy(*query_store, query_string, len);
(*query_store)[len] = '\0';
- INKHandleStringRelease(bufp, url_loc, query_string);
+ TSHandleStringRelease(bufp, url_loc, query_string);
} else {
*query_store = NULL;
}
- INKDebug(LOW, "query string = |%s|", (*query_store != NULL) ? *query_store : "NULL");
+ TSDebug(LOW, "query string = |%s|", (*query_store != NULL) ? *query_store : "NULL");
return 0;
}
@@ -86,36 +86,36 @@ query_string_extract(TxnData * txn_data,
Returns 0 or -1 if an error occured
-------------------------------------------------------------------------*/
int
-query_and_cookies_extract(INKHttpTxn txnp, TxnData * txn_data, PairList * query, PairList * cookies)
+query_and_cookies_extract(TSHttpTxn txnp, TxnData * txn_data, PairList * query, PairList * cookies)
{
- INKMBuffer bufp;
- INKMLoc hdr_loc, url_loc, cookies_loc;
+ TSMBuffer bufp;
+ TSMLoc hdr_loc, url_loc, cookies_loc;
const char *query_string;
const char *cookies_string;
int len;
- INKAssert(txn_data->magic == MAGIC_ALIVE);
- INKDebug(MED, "In query_and_cookies_extract");
+ TSAssert(txn_data->magic == MAGIC_ALIVE);
+ TSDebug(MED, "In query_and_cookies_extract");
- if (!INKHttpTxnClientReqGet(txnp, &bufp, &hdr_loc)) {
+ if (!TSHttpTxnClientReqGet(txnp, &bufp, &hdr_loc)) {
return -1;
}
/* Deal with query string */
/* OLD IMPLEMENTATION
- if ((url_loc = INKHttpHdrUrlGet(bufp, hdr_loc)) == NULL) {
- INKHandleMLocRelease(bufp, INK_NULL_MLOC, hdr_loc);
+ if ((url_loc = TSHttpHdrUrlGet(bufp, hdr_loc)) == NULL) {
+ TSHandleMLocRelease(bufp, TS_NULL_MLOC, hdr_loc);
return -1;
}
- query_string = INKUrlHttpQueryGet(bufp, url_loc, &len); */
+ query_string = TSUrlHttpQueryGet(bufp, url_loc, &len); */
if (txn_data != NULL) {
- query_string = INKUrlHttpQueryGet(txn_data->request_url_buf, txn_data->request_url_loc, &len);
+ query_string = TSUrlHttpQueryGet(txn_data->request_url_buf, txn_data->request_url_loc, &len);
} else {
query_string = NULL;
}
- INKDebug(LOW, "query string = |%s|", query_string);
+ TSDebug(LOW, "query string = |%s|", query_string);
if ((len != 0) && (query_string != NULL)) {
char *str;
@@ -124,7 +124,7 @@ query_and_cookies_extract(INKHttpTxn txn
char *separator;
/* life is easier with a null terminated string ... */
- str = (char *) INKmalloc(len + 1);
+ str = (char *) TSmalloc(len + 1);
memcpy(str, query_string, len);
str[len] = '\0';
@@ -152,7 +152,7 @@ query_and_cookies_extract(INKHttpTxn txn
}
if ((name != NULL) && (value != NULL)) {
- INKDebug(LOW, "Adding query pair |%s| |%s|", name, value);
+ TSDebug(LOW, "Adding query pair |%s| |%s|", name, value);
pairListAdd(query, name, value);
}
@@ -160,23 +160,23 @@ query_and_cookies_extract(INKHttpTxn txn
free(value);
} while (separator != NULL);
- INKfree(str);
+ TSfree(str);
- /* old implementation INKHandleStringRelease(bufp, url_loc, query_string); */
- INKHandleStringRelease(txn_data->request_url_buf, txn_data->request_url_loc, query_string);
+ /* old implementation TSHandleStringRelease(bufp, url_loc, query_string); */
+ TSHandleStringRelease(txn_data->request_url_buf, txn_data->request_url_loc, query_string);
}
- /* old implementation INKHandleMLocRelease(bufp, hdr_loc, url_loc); */
+ /* old implementation TSHandleMLocRelease(bufp, hdr_loc, url_loc); */
/* Extract cookies */
- cookies_loc = INKMimeHdrFieldFind(bufp, hdr_loc, INK_MIME_FIELD_COOKIE, INK_MIME_LEN_COOKIE);
+ cookies_loc = TSMimeHdrFieldFind(bufp, hdr_loc, TS_MIME_FIELD_COOKIE, TS_MIME_LEN_COOKIE);
if (cookies_loc == NULL) {
- INKHandleMLocRelease(bufp, INK_NULL_MLOC, hdr_loc);
+ TSHandleMLocRelease(bufp, TS_NULL_MLOC, hdr_loc);
return 0;
}
- INKMimeHdrFieldValueStringGet(bufp, hdr_loc, cookies_loc, -1, &cookies_string, &len);
- INKDebug(LOW, "Cookies = %s", cookies_string);
+ TSMimeHdrFieldValueStringGet(bufp, hdr_loc, cookies_loc, -1, &cookies_string, &len);
+ TSDebug(LOW, "Cookies = %s", cookies_string);
if ((len != 0) && (cookies_string != NULL)) {
char *str;
@@ -185,7 +185,7 @@ query_and_cookies_extract(INKHttpTxn txn
char *separator;
/* life is easier with a null terminated string ... */
- str = (char *) INKmalloc(len + 1);
+ str = (char *) TSmalloc(len + 1);
memcpy(str, cookies_string, len);
str[len] = '\0';
@@ -218,7 +218,7 @@ query_and_cookies_extract(INKHttpTxn txn
}
if ((name != NULL) && (value != NULL)) {
- INKDebug(LOW, "Adding cookie pair |%s| |%s|", name, value);
+ TSDebug(LOW, "Adding cookie pair |%s| |%s|", name, value);
pairListAdd(cookies, name, value);
}
@@ -226,11 +226,11 @@ query_and_cookies_extract(INKHttpTxn txn
free(value);
} while (separator != NULL);
- INKfree(str);
- INKHandleMLocRelease(bufp, hdr_loc, cookies_loc);
+ TSfree(str);
+ TSHandleMLocRelease(bufp, hdr_loc, cookies_loc);
}
- INKHandleMLocRelease(bufp, INK_NULL_MLOC, hdr_loc);
+ TSHandleMLocRelease(bufp, TS_NULL_MLOC, hdr_loc);
return 0;
}
@@ -247,55 +247,55 @@ query_and_cookies_extract(INKHttpTxn txn
Returns 1 if it's a template header 0 otherwise
-------------------------------------------------------------------------*/
int
-is_template_header(INKMBuffer bufp, INKMLoc hdr_loc)
+is_template_header(TSMBuffer bufp, TSMLoc hdr_loc)
{
- INKHttpStatus resp_status;
- INKMLoc field_loc;
+ TSHttpStatus resp_status;
+ TSMLoc field_loc;
const char *str;
int len;
- INKDebug(MED, "In is_template_header");
+ TSDebug(MED, "In is_template_header");
/* Check out that status is 200 */
- resp_status = INKHttpHdrStatusGet(bufp, hdr_loc);
- if ((resp_status != INK_HTTP_STATUS_OK) && (resp_status != INK_HTTP_STATUS_NOT_MODIFIED)) {
- INKDebug(LOW, "Not a template: status is [%d], not 200 nor 304", resp_status);
+ resp_status = TSHttpHdrStatusGet(bufp, hdr_loc);
+ if ((resp_status != TS_HTTP_STATUS_OK) && (resp_status != TS_HTTP_STATUS_NOT_MODIFIED)) {
+ TSDebug(LOW, "Not a template: status is [%d], not 200 nor 304", resp_status);
return 0;
}
/* Check out that content type is text/html */
- field_loc = INKMimeHdrFieldFind(bufp, hdr_loc, INK_MIME_FIELD_CONTENT_TYPE, INK_MIME_LEN_CONTENT_TYPE);
- if (field_loc == INK_NULL_MLOC) {
- INKDebug(LOW, "Not a template: could not find header %s", INK_MIME_FIELD_CONTENT_TYPE);
+ field_loc = TSMimeHdrFieldFind(bufp, hdr_loc, TS_MIME_FIELD_CONTENT_TYPE, TS_MIME_LEN_CONTENT_TYPE);
+ if (field_loc == TS_NULL_MLOC) {
+ TSDebug(LOW, "Not a template: could not find header %s", TS_MIME_FIELD_CONTENT_TYPE);
return 0;
}
- INKMimeHdrFieldValueStringGet(bufp, hdr_loc, field_loc, 0, &str, &len);
+ TSMimeHdrFieldValueStringGet(bufp, hdr_loc, field_loc, 0, &str, &len);
if (str == NULL) {
- INKDebug(LOW, "Not a template: could not get value of header %s", INK_MIME_FIELD_CONTENT_TYPE);
- INKHandleMLocRelease(bufp, hdr_loc, field_loc);
+ TSDebug(LOW, "Not a template: could not get value of header %s", TS_MIME_FIELD_CONTENT_TYPE);
+ TSHandleMLocRelease(bufp, hdr_loc, field_loc);
return 0;
}
if (strncasecmp(str, CONTENT_TYPE_TEXT_HTML, CONTENT_TYPE_TEXT_HTML_LEN) != 0) {
- INKDebug(LOW, "Not a template: could value of header %s is %s, not %s",
- INK_MIME_FIELD_CONTENT_TYPE, str, CONTENT_TYPE_TEXT_HTML);
- INKHandleStringRelease(bufp, hdr_loc, str);
- INKHandleMLocRelease(bufp, hdr_loc, field_loc);
+ TSDebug(LOW, "Not a template: could value of header %s is %s, not %s",
+ TS_MIME_FIELD_CONTENT_TYPE, str, CONTENT_TYPE_TEXT_HTML);
+ TSHandleStringRelease(bufp, hdr_loc, str);
+ TSHandleMLocRelease(bufp, hdr_loc, field_loc);
return 0;
}
- INKHandleStringRelease(bufp, hdr_loc, str);
- INKHandleMLocRelease(bufp, hdr_loc, field_loc);
+ TSHandleStringRelease(bufp, hdr_loc, str);
+ TSHandleMLocRelease(bufp, hdr_loc, field_loc);
/* Check out that header X-Include is present */
- field_loc = INKMimeHdrFieldFind(bufp, hdr_loc, HEADER_X_TEMPLATE, -1);
- if (field_loc == INK_NULL_MLOC) {
- INKDebug(LOW, "Not a template: could not find header %s", HEADER_X_TEMPLATE);
+ field_loc = TSMimeHdrFieldFind(bufp, hdr_loc, HEADER_X_TEMPLATE, -1);
+ if (field_loc == TS_NULL_MLOC) {
+ TSDebug(LOW, "Not a template: could not find header %s", HEADER_X_TEMPLATE);
return 0;
}
- INKHandleMLocRelease(bufp, hdr_loc, field_loc);
+ TSHandleMLocRelease(bufp, hdr_loc, field_loc);
/* We're done with checks. This is a template page that has to be transformed */
- INKDebug(LOW, "This is a template, transform it !");
+ TSDebug(LOW, "This is a template, transform it !");
return 1;
}
@@ -308,14 +308,14 @@ is_template_header(INKMBuffer bufp, INKM
to let the TS know that the template should not be cached.
-------------------------------------------------------------------------*/
int
-has_nocache_header(INKMLoc bufp, INKMLoc hdr_loc)
+has_nocache_header(TSMLoc bufp, TSMLoc hdr_loc)
{
- INKMLoc field_loc;
- INKDebug(MED, "In has_no_cacheheader");
+ TSMLoc field_loc;
+ TSDebug(MED, "In has_no_cacheheader");
- field_loc = INKMimeHdrFieldFind(bufp, hdr_loc, HEADER_X_NOCACHE, -1);
+ field_loc = TSMimeHdrFieldFind(bufp, hdr_loc, HEADER_X_NOCACHE, -1);
if (field_loc != NULL) {
- INKHandleMLocRelease(bufp, hdr_loc, field_loc);
+ TSHandleMLocRelease(bufp, hdr_loc, field_loc);
return 1;
}
@@ -334,50 +334,50 @@ has_nocache_header(INKMLoc bufp, INKMLoc
Returns 1 if dynamic, 0 if not dynamic, -1 in case of error
-------------------------------------------------------------------------*/
int
-request_looks_dynamic(INKMBuffer bufp, INKMLoc hdr_loc)
+request_looks_dynamic(TSMBuffer bufp, TSMLoc hdr_loc)
{
- INKMLoc url_loc, cookie_loc;
+ TSMLoc url_loc, cookie_loc;
const char *path;
const char *query;
int len;
- INKDebug(MED, "In request_looks_dynamic");
+ TSDebug(MED, "In request_looks_dynamic");
- url_loc = INKHttpHdrUrlGet(bufp, hdr_loc);
+ url_loc = TSHttpHdrUrlGet(bufp, hdr_loc);
if (url_loc == NULL) {
- INKError("Could not retrieve Url");
+ TSError("Could not retrieve Url");
return -1;
}
- path = INKUrlPathGet(bufp, url_loc, &len);
+ path = TSUrlPathGet(bufp, url_loc, &len);
if ((path != NULL) && (len > 0)) {
- char *str = INKmalloc(len + 1);
+ char *str = TSmalloc(len + 1);
strncpy(str, path, len);
str[len] = '\0';
if ((strstr(str, ASP_EXTENSION) != NULL) || (strstr(str, JSP_EXTENSION) != NULL) || (strstr(str, CGI_BIN) != NULL)) {
- INKHandleStringRelease(bufp, url_loc, path);
- INKHandleMLocRelease(bufp, hdr_loc, url_loc);
+ TSHandleStringRelease(bufp, url_loc, path);
+ TSHandleMLocRelease(bufp, hdr_loc, url_loc);
return 1;
}
- INKHandleStringRelease(bufp, url_loc, path);
+ TSHandleStringRelease(bufp, url_loc, path);
}
- query = INKUrlHttpQueryGet(bufp, url_loc, &len);
+ query = TSUrlHttpQueryGet(bufp, url_loc, &len);
if ((query != NULL) && (len > 0)) {
- INKHandleStringRelease(bufp, url_loc, query);
- INKHandleMLocRelease(bufp, hdr_loc, url_loc);
+ TSHandleStringRelease(bufp, url_loc, query);
+ TSHandleMLocRelease(bufp, hdr_loc, url_loc);
return 1;
}
- cookie_loc = INKMimeHdrFieldFind(bufp, hdr_loc, INK_MIME_FIELD_COOKIE, INK_MIME_LEN_COOKIE);
+ cookie_loc = TSMimeHdrFieldFind(bufp, hdr_loc, TS_MIME_FIELD_COOKIE, TS_MIME_LEN_COOKIE);
if (cookie_loc != NULL) {
- INKHandleMLocRelease(bufp, hdr_loc, cookie_loc);
- INKHandleMLocRelease(bufp, hdr_loc, url_loc);
+ TSHandleMLocRelease(bufp, hdr_loc, cookie_loc);
+ TSHandleMLocRelease(bufp, hdr_loc, url_loc);
return 1;
}
- INKHandleMLocRelease(bufp, hdr_loc, url_loc);
+ TSHandleMLocRelease(bufp, hdr_loc, url_loc);
return 0;
}
@@ -389,15 +389,15 @@ request_looks_dynamic(INKMBuffer bufp, I
Look for header X-Block in request.
-------------------------------------------------------------------------*/
int
-is_block_request(INKMBuffer bufp, INKMLoc hdr_loc)
+is_block_request(TSMBuffer bufp, TSMLoc hdr_loc)
{
- INKMLoc field_loc;
+ TSMLoc field_loc;
- INKDebug(MED, "In is_block_request");
+ TSDebug(MED, "In is_block_request");
- field_loc = INKMimeHdrFieldFind(bufp, hdr_loc, HEADER_X_BLOCK, -1);
+ field_loc = TSMimeHdrFieldFind(bufp, hdr_loc, HEADER_X_BLOCK, -1);
if (field_loc != NULL) {
- INKHandleMLocRelease(bufp, hdr_loc, field_loc);
+ TSHandleMLocRelease(bufp, hdr_loc, field_loc);
return 1;
}
@@ -414,10 +414,10 @@ is_block_request(INKMBuffer bufp, INKMLo
- store the original url in the txn_data structure
-------------------------------------------------------------------------*/
void
-modify_request_url(INKMBuffer bufp, INKMLoc url_loc, TxnData * txn_data)
+modify_request_url(TSMBuffer bufp, TSMLoc url_loc, TxnData * txn_data)
{
- INKMBuffer template_url_buf = txn_data->template_url_buf;
- INKMLoc template_url_loc = txn_data->template_url_loc;
+ TSMBuffer template_url_buf = txn_data->template_url_buf;
+ TSMLoc template_url_loc = txn_data->template_url_loc;
const char *user;
const char *password;
const char *host;
@@ -427,54 +427,54 @@ modify_request_url(INKMBuffer bufp, INKM
const char *params;
int len;
- INKAssert(txn_data->magic == MAGIC_ALIVE);
- INKDebug(LOW, "In modify_request_url");
+ TSAssert(txn_data->magic == MAGIC_ALIVE);
+ TSDebug(LOW, "In modify_request_url");
/* Note: We have to do all the copy manually due to a bug
- in INKHttpUrlQuerySet: if used to set query to NULL,
+ in TSHttpUrlQuerySet: if used to set query to NULL,
the "?" is not removed. */
- INKUrlSchemeSet(template_url_buf, template_url_loc, INK_URL_SCHEME_HTTP, INK_URL_LEN_HTTP);
+ TSUrlSchemeSet(template_url_buf, template_url_loc, TS_URL_SCHEME_HTTP, TS_URL_LEN_HTTP);
- user = INKUrlUserGet(bufp, url_loc, &len);
+ user = TSUrlUserGet(bufp, url_loc, &len);
if ((user != NULL) && (len > 0)) {
- INKUrlUserSet(template_url_buf, template_url_loc, user, len);
- INKHandleStringRelease(bufp, url_loc, user);
+ TSUrlUserSet(template_url_buf, template_url_loc, user, len);
+ TSHandleStringRelease(bufp, url_loc, user);
}
- password = INKUrlPasswordGet(bufp, url_loc, &len);
+ password = TSUrlPasswordGet(bufp, url_loc, &len);
if ((password != NULL) && (len > 0)) {
- INKUrlPasswordSet(template_url_buf, template_url_loc, password, len);
- INKHandleStringRelease(bufp, url_loc, password);
+ TSUrlPasswordSet(template_url_buf, template_url_loc, password, len);
+ TSHandleStringRelease(bufp, url_loc, password);
}
- host = INKUrlHostGet(bufp, url_loc, &len);
+ host = TSUrlHostGet(bufp, url_loc, &len);
if ((host != NULL) && (len > 0)) {
- INKUrlHostSet(template_url_buf, template_url_loc, host, len);
- INKHandleStringRelease(bufp, url_loc, host);
+ TSUrlHostSet(template_url_buf, template_url_loc, host, len);
+ TSHandleStringRelease(bufp, url_loc, host);
}
- port = INKUrlPortGet(bufp, url_loc);
+ port = TSUrlPortGet(bufp, url_loc);
if (port != HTTP_DEFAULT_PORT) {
- INKUrlPortSet(template_url_buf, template_url_loc, port);
+ TSUrlPortSet(template_url_buf, template_url_loc, port);
}
- path = INKUrlPathGet(bufp, url_loc, &len);
+ path = TSUrlPathGet(bufp, url_loc, &len);
if ((path != NULL) && (len > 0)) {
int new_path_len = len + sizeof(TEMPLATE_CACHE_SUFFIX);
- char *new_path = INKmalloc(new_path_len);
+ char *new_path = TSmalloc(new_path_len);
sprintf(new_path, "%s%s", path, TEMPLATE_CACHE_SUFFIX);
- INKUrlPathSet(template_url_buf, template_url_loc, new_path, -1);
- INKfree(new_path);
- INKHandleStringRelease(bufp, url_loc, path);
+ TSUrlPathSet(template_url_buf, template_url_loc, new_path, -1);
+ TSfree(new_path);
+ TSHandleStringRelease(bufp, url_loc, path);
}
- params = INKUrlHttpParamsGet(bufp, url_loc, &len);
+ params = TSUrlHttpParamsGet(bufp, url_loc, &len);
if ((params != NULL) && (len > 0)) {
- INKUrlHttpParamsSet(template_url_buf, template_url_loc, params, len);
- INKHandleStringRelease(bufp, url_loc, params);
+ TSUrlHttpParamsSet(template_url_buf, template_url_loc, params, len);
+ TSHandleStringRelease(bufp, url_loc, params);
}
- fragment = INKUrlHttpFragmentGet(bufp, url_loc, &len);
+ fragment = TSUrlHttpFragmentGet(bufp, url_loc, &len);
if ((fragment != NULL) && (len > 0)) {
- INKUrlHttpFragmentSet(template_url_buf, template_url_loc, fragment, len);
- INKHandleStringRelease(bufp, url_loc, fragment);
+ TSUrlHttpFragmentSet(template_url_buf, template_url_loc, fragment, len);
+ TSHandleStringRelease(bufp, url_loc, fragment);
}
/* Replace the original url by the template url */
- INKUrlCopy(bufp, url_loc, template_url_buf, template_url_loc);
+ TSUrlCopy(bufp, url_loc, template_url_buf, template_url_loc);
}
Modified: trafficserver/traffic/trunk/test/plugin/assembly/headers.h
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/test/plugin/assembly/headers.h?rev=1035782&r1=1035781&r2=1035782&view=diff
==============================================================================
--- trafficserver/traffic/trunk/test/plugin/assembly/headers.h (original)
+++ trafficserver/traffic/trunk/test/plugin/assembly/headers.h Tue Nov 16 20:22:02 2010
@@ -28,10 +28,10 @@
#include "common.h"
int query_string_extract(TxnData * txn_data, char **query_store);
-void query_and_cookies_extract(INKHttpTxn txnp, TxnData * txn_data, PairList * query, PairList * cookies);
-int is_template_header(INKMBuffer bufp, INKMLoc hdr_loc);
-int has_nocache_header(INKMLoc bufp, INKMLoc hdr_loc);
-int request_looks_dynamic(INKMBuffer bufp, INKMLoc hdr_loc);
-void modify_request_url(INKMBuffer bufp, INKMLoc url_loc, TxnData * txn_data);
+void query_and_cookies_extract(TSHttpTxn txnp, TxnData * txn_data, PairList * query, PairList * cookies);
+int is_template_header(TSMBuffer bufp, TSMLoc hdr_loc);
+int has_nocache_header(TSMLoc bufp, TSMLoc hdr_loc);
+int request_looks_dynamic(TSMBuffer bufp, TSMLoc hdr_loc);
+void modify_request_url(TSMBuffer bufp, TSMLoc url_loc, TxnData * txn_data);
#endif
Modified: trafficserver/traffic/trunk/test/plugin/assembly/list.c
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/test/plugin/assembly/list.c?rev=1035782&r1=1035781&r2=1035782&view=diff
==============================================================================
--- trafficserver/traffic/trunk/test/plugin/assembly/list.c (original)
+++ trafficserver/traffic/trunk/test/plugin/assembly/list.c Tue Nov 16 20:22:02 2010
@@ -76,7 +76,7 @@ getNextValue(const char *list, char **of
*offset = end;
}
- ret = INKmalloc(len + 1);
+ ret = TSmalloc(len + 1);
memcpy(ret, begin, len);
ret[len] = '\0';
Modified: trafficserver/traffic/trunk/test/plugin/blacklist-1-neg/blacklist-1-neg.c
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/test/plugin/blacklist-1-neg/blacklist-1-neg.c?rev=1035782&r1=1035781&r2=1035782&view=diff
==============================================================================
--- trafficserver/traffic/trunk/test/plugin/blacklist-1-neg/blacklist-1-neg.c (original)
+++ trafficserver/traffic/trunk/test/plugin/blacklist-1-neg/blacklist-1-neg.c Tue Nov 16 20:22:02 2010
@@ -46,17 +46,17 @@
#define LOG_SET_FUNCTION_NAME(NAME) const char * FUNCTION_NAME = NAME
#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__); \
}
static char *sites[MAX_NSITES];
static int nsites;
-static INKMutex sites_mutex;
-static INKTextLogObject log;
-static INKCont global_contp;
+static TSMutex sites_mutex;
+static TSTextLogObject log;
+static TSCont global_contp;
-static void handle_txn_start(INKCont contp, INKHttpTxn txnp);
+static void handle_txn_start(TSCont contp, TSHttpTxn txnp);
typedef struct contp_data
{
@@ -68,39 +68,39 @@ typedef struct contp_data
READ_BLACKLIST
} cf;
- INKHttpTxn txnp;
+ TSHttpTxn txnp;
} cdata;
static void
-handle_dns(INKHttpTxn txnp, INKCont contp)
+handle_dns(TSHttpTxn txnp, TSCont contp)
{
- INKMBuffer bufp;
- INKMLoc hdr_loc;
- INKMLoc url_loc;
+ TSMBuffer bufp;
+ TSMLoc hdr_loc;
+ TSMLoc url_loc;
const char *host;
int i;
int host_length;
cdata *cd;
- if (!INKHttpTxnClientReqGet(txnp, &bufp, &hdr_loc)) {
- INKError("couldn't retrieve client request header\n");
+ if (!TSHttpTxnClientReqGet(txnp, &bufp, &hdr_loc)) {
+ TSError("couldn't retrieve client request header\n");
goto done;
}
- url_loc = INKHttpHdrUrlGet(bufp, hdr_loc);
+ url_loc = TSHttpHdrUrlGet(bufp, hdr_loc);
if (!url_loc) {
- INKError("couldn't retrieve request url\n");
- INKHandleMLocRelease(bufp, INK_NULL_MLOC, hdr_loc);
+ TSError("couldn't retrieve request url\n");
+ TSHandleMLocRelease(bufp, TS_NULL_MLOC, hdr_loc);
goto done;
}
- host = INKUrlHostGet(bufp, url_loc, &host_length);
+ host = TSUrlHostGet(bufp, url_loc, &host_length);
if (!host) {
- INKError("couldn't retrieve request hostname\n");
- INKHandleMLocRelease(bufp, hdr_loc, url_loc);
- INKHandleMLocRelease(bufp, INK_NULL_MLOC, hdr_loc);
+ TSError("couldn't retrieve request hostname\n");
+ TSHandleMLocRelease(bufp, hdr_loc, url_loc);
+ TSHandleMLocRelease(bufp, TS_NULL_MLOC, hdr_loc);
goto done;
}
@@ -110,39 +110,39 @@ handle_dns(INKHttpTxn txnp, INKCont cont
for (i = 0; i < nsites; i++) {
if (strncmp(host, sites[i], host_length) == 0) {
if (log) {
- INKTextLogObjectWrite(log, "blacklisting site: %s", sites[i]);
+ TSTextLogObjectWrite(log, "blacklisting site: %s", sites[i]);
} else {
- INKDebug("blacklist-1", "blacklisting site: %s\n", sites[i]);
+ TSDebug("blacklist-1", "blacklisting site: %s\n", sites[i]);
}
- INKHttpTxnHookAdd(txnp, INK_HTTP_SEND_RESPONSE_HDR_HOOK, contp);
- INKHandleStringRelease(bufp, url_loc, host);
- INKHandleMLocRelease(bufp, hdr_loc, url_loc);
- INKHandleMLocRelease(bufp, INK_NULL_MLOC, hdr_loc);
- INKHttpTxnReenable(txnp, INK_EVENT_HTTP_ERROR);
- INKMutexUnlock(sites_mutex);
+ TSHttpTxnHookAdd(txnp, TS_HTTP_SEND_RESPONSE_HDR_HOOK, contp);
+ TSHandleStringRelease(bufp, url_loc, host);
+ TSHandleMLocRelease(bufp, hdr_loc, url_loc);
+ TSHandleMLocRelease(bufp, TS_NULL_MLOC, hdr_loc);
+ TSHttpTxnReenable(txnp, TS_EVENT_HTTP_ERROR);
+ TSMutexUnlock(sites_mutex);
return;
}
}
- INKHandleStringRelease(bufp, url_loc, host);
- INKHandleMLocRelease(bufp, hdr_loc, url_loc);
- INKHandleMLocRelease(bufp, INK_NULL_MLOC, hdr_loc);
+ TSHandleStringRelease(bufp, url_loc, host);
+ TSHandleMLocRelease(bufp, hdr_loc, url_loc);
+ TSHandleMLocRelease(bufp, TS_NULL_MLOC, hdr_loc);
done:
- INKHttpTxnReenable(txnp, INK_EVENT_HTTP_CONTINUE);
+ TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
/* If not a blacklist site, then destroy the continuation created for
this transaction */
- cd = (cdata *) INKContDataGet(contp);
- INKfree(cd);
- INKContDestroy(contp);
+ cd = (cdata *) TSContDataGet(contp);
+ TSfree(cd);
+ TSContDestroy(contp);
}
static void
-handle_response(INKHttpTxn txnp, INKCont contp)
+handle_response(TSHttpTxn txnp, TSCont contp)
{
- INKMBuffer bufp;
- INKMLoc hdr_loc;
- INKMLoc url_loc;
+ TSMBuffer bufp;
+ TSMLoc hdr_loc;
+ TSMLoc url_loc;
char *url_str;
char *buf;
int url_length;
@@ -150,88 +150,88 @@ handle_response(INKHttpTxn txnp, INKCont
LOG_SET_FUNCTION_NAME("handle_response");
- if (!INKHttpTxnClientRespGet(txnp, &bufp, &hdr_loc)) {
- INKError("couldn't retrieve client response header\n");
+ if (!TSHttpTxnClientRespGet(txnp, &bufp, &hdr_loc)) {
+ TSError("couldn't retrieve client response header\n");
goto done;
}
- INKHttpHdrStatusSet(bufp, hdr_loc, INK_HTTP_STATUS_FORBIDDEN);
- INKHttpHdrReasonSet(bufp, hdr_loc,
- INKHttpHdrReasonLookup(INK_HTTP_STATUS_FORBIDDEN),
- strlen(INKHttpHdrReasonLookup(INK_HTTP_STATUS_FORBIDDEN)));
-
- if (!INKHttpTxnClientReqGet(txnp, &bufp, &hdr_loc)) {
- INKError("couldn't retrieve client request header\n");
- INKHandleMLocRelease(bufp, INK_NULL_MLOC, hdr_loc);
+ TSHttpHdrStatusSet(bufp, hdr_loc, TS_HTTP_STATUS_FORBIDDEN);
+ TSHttpHdrReasonSet(bufp, hdr_loc,
+ TSHttpHdrReasonLookup(TS_HTTP_STATUS_FORBIDDEN),
+ strlen(TSHttpHdrReasonLookup(TS_HTTP_STATUS_FORBIDDEN)));
+
+ if (!TSHttpTxnClientReqGet(txnp, &bufp, &hdr_loc)) {
+ TSError("couldn't retrieve client request header\n");
+ TSHandleMLocRelease(bufp, TS_NULL_MLOC, hdr_loc);
goto done;
}
- url_loc = INKHttpHdrUrlGet(bufp, hdr_loc);
+ url_loc = TSHttpHdrUrlGet(bufp, hdr_loc);
if (!url_loc) {
- INKError("couldn't retrieve request url\n");
- INKHandleMLocRelease(bufp, INK_NULL_MLOC, hdr_loc);
+ TSError("couldn't retrieve request url\n");
+ TSHandleMLocRelease(bufp, TS_NULL_MLOC, hdr_loc);
goto done;
}
- buf = (char *) INKmalloc(4096);
+ buf = (char *) TSmalloc(4096);
- url_str = INKUrlStringGet(bufp, url_loc, &url_length);
+ url_str = TSUrlStringGet(bufp, url_loc, &url_length);
sprintf(buf, "You are forbidden from accessing \"%s\"\n", url_str);
- INKfree(url_str);
- INKHandleMLocRelease(bufp, hdr_loc, url_loc);
- INKHandleMLocRelease(bufp, INK_NULL_MLOC, hdr_loc);
+ TSfree(url_str);
+ TSHandleMLocRelease(bufp, hdr_loc, url_loc);
+ TSHandleMLocRelease(bufp, TS_NULL_MLOC, hdr_loc);
- INKHttpTxnErrorBodySet(txnp, buf, strlen(buf), NULL);
+ TSHttpTxnErrorBodySet(txnp, buf, strlen(buf), NULL);
- /* negative test for INKHttpTxnErrorBodySet */
+ /* negative test for TSHttpTxnErrorBodySet */
#ifdef DEBUG
- if (INKHttpTxnErrorBodySet(NULL, buf, strlen(buf), NULL) != INK_ERROR) {
- LOG_ERROR_NEG("INKHttpTxnErrorBodySet");
+ if (TSHttpTxnErrorBodySet(NULL, buf, strlen(buf), NULL) != TS_ERROR) {
+ LOG_ERROR_NEG("TSHttpTxnErrorBodySet");
}
- if (INKHttpTxnErrorBodySet(txnp, NULL, 10, NULL) != INK_ERROR) {
- LOG_ERROR_NEG("INKHttpTxnErrorBodySet");
+ if (TSHttpTxnErrorBodySet(txnp, NULL, 10, NULL) != TS_ERROR) {
+ LOG_ERROR_NEG("TSHttpTxnErrorBodySet");
}
#endif
done:
- INKHttpTxnReenable(txnp, INK_EVENT_HTTP_CONTINUE);
+ TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
/* After everything's done, Destroy the continuation
created for this transaction */
- cd = (cdata *) INKContDataGet(contp);
- INKfree(cd);
- INKContDestroy(contp);
+ cd = (cdata *) TSContDataGet(contp);
+ TSfree(cd);
+ TSContDestroy(contp);
}
static void
-read_blacklist(INKCont contp)
+read_blacklist(TSCont contp)
{
char blacklist_file[1024];
- INKFile file;
+ TSFile file;
int lock;
- INKReturnCode ret_code;
+ TSReturnCode ret_code;
LOG_SET_FUNCTION_NAME("read_blacklist");
- sprintf(blacklist_file, "%s/blacklist.txt", INKPluginDirGet());
- file = INKfopen(blacklist_file, "r");
+ sprintf(blacklist_file, "%s/blacklist.txt", TSPluginDirGet());
+ file = TSfopen(blacklist_file, "r");
- ret_code = INKMutexLockTry(sites_mutex, &lock);
+ ret_code = TSMutexLockTry(sites_mutex, &lock);
- if (ret_code == INK_ERROR) {
- INKError("Failed to lock mutex. Cannot read new blacklist file. Exiting ...\n");
+ if (ret_code == TS_ERROR) {
+ TSError("Failed to lock mutex. Cannot read new blacklist file. Exiting ...\n");
return;
}
nsites = 0;
/* If the Mutext lock is not successful try again in RETRY_TIME */
if (!lock) {
- INKContSchedule(contp, RETRY_TIME);
+ TSContSchedule(contp, RETRY_TIME);
return;
}
if (file != NULL) {
char buffer[1024];
- while (INKfgets(file, buffer, sizeof(buffer) - 1) != NULL && nsites < MAX_NSITES) {
+ while (TSfgets(file, buffer, sizeof(buffer) - 1) != NULL && nsites < MAX_NSITES) {
char *eol;
if ((eol = strstr(buffer, "\r\n")) != NULL) {
/* To handle newlines on Windows */
@@ -243,72 +243,72 @@ read_blacklist(INKCont contp)
continue;
}
if (sites[nsites] != NULL) {
- INKfree(sites[nsites]);
+ TSfree(sites[nsites]);
}
- sites[nsites] = INKstrdup(buffer);
+ sites[nsites] = TSstrdup(buffer);
nsites++;
}
- INKfclose(file);
+ TSfclose(file);
} else {
- INKError("unable to open %s\n", blacklist_file);
- INKError("all sites will be allowed\n", blacklist_file);
+ TSError("unable to open %s\n", blacklist_file);
+ TSError("all sites will be allowed\n", blacklist_file);
}
- INKMutexUnlock(sites_mutex);
+ TSMutexUnlock(sites_mutex);
- /* negative test for INKContSchedule */
+ /* negative test for TSContSchedule */
#ifdef DEBUG
- if (INKContSchedule(NULL, 10) != INK_ERROR_PTR) {
- LOG_ERROR_NEG("INKContSchedule");
+ if (TSContSchedule(NULL, 10) != TS_ERROR_PTR) {
+ LOG_ERROR_NEG("TSContSchedule");
}
#endif
}
static int
-blacklist_plugin(INKCont contp, INKEvent event, void *edata)
+blacklist_plugin(TSCont contp, TSEvent event, void *edata)
{
- INKHttpTxn txnp;
+ TSHttpTxn txnp;
cdata *cd;
switch (event) {
- case INK_EVENT_HTTP_TXN_START:
- txnp = (INKHttpTxn) edata;
+ case TS_EVENT_HTTP_TXN_START:
+ txnp = (TSHttpTxn) edata;
handle_txn_start(contp, txnp);
return 0;
- case INK_EVENT_HTTP_OS_DNS:
+ case TS_EVENT_HTTP_OS_DNS:
if (contp != global_contp) {
- cd = (cdata *) INKContDataGet(contp);
+ cd = (cdata *) TSContDataGet(contp);
cd->cf = HANDLE_DNS;
handle_dns(cd->txnp, contp);
return 0;
} else {
break;
}
- case INK_EVENT_HTTP_SEND_RESPONSE_HDR:
+ case TS_EVENT_HTTP_SEND_RESPONSE_HDR:
if (contp != global_contp) {
- cd = (cdata *) INKContDataGet(contp);
+ cd = (cdata *) TSContDataGet(contp);
cd->cf = HANDLE_RESPONSE;
handle_response(cd->txnp, contp);
return 0;
} else {
break;
}
- case INK_EVENT_MGMT_UPDATE:
+ case TS_EVENT_MGMT_UPDATE:
if (contp == global_contp) {
read_blacklist(contp);
return 0;
} else {
break;
}
- case INK_EVENT_TIMEOUT:
+ case TS_EVENT_TIMEOUT:
/* when mutex lock is not acquired and continuation is rescheduled,
- the plugin is called back with INK_EVENT_TIMEOUT with a NULL
+ the plugin is called back with TS_EVENT_TIMEOUT with a NULL
edata. We need to decide, in which function did the MutexLock
failed and call that function again */
if (contp != global_contp) {
- cd = (cdata *) INKContDataGet(contp);
+ cd = (cdata *) TSContDataGet(contp);
switch (cd->cf) {
case HANDLE_DNS:
handle_dns(cd->txnp, contp);
@@ -330,21 +330,21 @@ blacklist_plugin(INKCont contp, INKEvent
}
static void
-handle_txn_start(INKCont contp, INKHttpTxn txnp)
+handle_txn_start(TSCont contp, TSHttpTxn txnp)
{
- INKCont txn_contp;
+ TSCont txn_contp;
cdata *cd;
- txn_contp = INKContCreate((INKEventFunc) blacklist_plugin, INKMutexCreate());
+ txn_contp = TSContCreate((TSEventFunc) blacklist_plugin, TSMutexCreate());
/* create the data that'll be associated with the continuation */
- cd = (cdata *) INKmalloc(sizeof(cdata));
- INKContDataSet(txn_contp, cd);
+ cd = (cdata *) TSmalloc(sizeof(cdata));
+ TSContDataSet(txn_contp, cd);
cd->txnp = txnp;
- INKHttpTxnHookAdd(txnp, INK_HTTP_OS_DNS_HOOK, txn_contp);
+ TSHttpTxnHookAdd(txnp, TS_HTTP_OS_DNS_HOOK, txn_contp);
- INKHttpTxnReenable(txnp, INK_EVENT_HTTP_CONTINUE);
+ TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
}
@@ -352,7 +352,7 @@ int
check_ts_version()
{
- const char *ts_version = INKTrafficServerVersionGet();
+ const char *ts_version = TSTrafficServerVersionGet();
int result = 0;
if (ts_version) {
@@ -375,66 +375,66 @@ check_ts_version()
}
void
-INKPluginInit(int argc, const char *argv[])
+TSPluginInit(int argc, const char *argv[])
{
int i;
- INKPluginRegistrationInfo info;
- INKReturnCode error;
+ TSPluginRegistrationInfo info;
+ TSReturnCode error;
- LOG_SET_FUNCTION_NAME("INKPluginInit");
+ LOG_SET_FUNCTION_NAME("TSPluginInit");
info.plugin_name = "blacklist-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;
}
- /* create an INKTextLogObject to log blacklisted requests to */
- error = INKTextLogObjectCreate("blacklist", INK_LOG_MODE_ADD_TIMESTAMP, &log);
- if (!log || error == INK_ERROR) {
- INKDebug("blacklist-1", "error while creating log");
+ /* create an TSTextLogObject to log blacklisted requests to */
+ error = TSTextLogObjectCreate("blacklist", TS_LOG_MODE_ADD_TIMESTAMP, &log);
+ if (!log || error == TS_ERROR) {
+ TSDebug("blacklist-1", "error while creating log");
}
- sites_mutex = INKMutexCreate();
+ sites_mutex = TSMutexCreate();
nsites = 0;
for (i = 0; i < MAX_NSITES; i++) {
sites[i] = NULL;
}
- global_contp = INKContCreate(blacklist_plugin, sites_mutex);
+ global_contp = TSContCreate(blacklist_plugin, sites_mutex);
read_blacklist(global_contp);
- /*INKHttpHookAdd (INK_HTTP_OS_DNS_HOOK, contp); */
- INKHttpHookAdd(INK_HTTP_TXN_START_HOOK, global_contp);
+ /*TSHttpHookAdd (TS_HTTP_OS_DNS_HOOK, contp); */
+ TSHttpHookAdd(TS_HTTP_TXN_START_HOOK, global_contp);
- INKMgmtUpdateRegister(global_contp, "Inktomi Blacklist Plugin", "blacklist.cgi");
+ TSMgmtUpdateRegister(global_contp, "Inktomi Blacklist Plugin", "blacklist.cgi");
#ifdef DEBUG
- /* negative test for INKMgmtUpdateRegister */
- if (INKMgmtUpdateRegister(NULL, "Inktomi Blacklist Plugin", "blacklist.cgi") != INK_ERROR) {
- LOG_ERROR_NEG("INKMgmtUpdateRegister");
+ /* negative test for TSMgmtUpdateRegister */
+ if (TSMgmtUpdateRegister(NULL, "Inktomi Blacklist Plugin", "blacklist.cgi") != TS_ERROR) {
+ LOG_ERROR_NEG("TSMgmtUpdateRegister");
}
- if (INKMgmtUpdateRegister(global_contp, NULL, "blacklist.cgi") != INK_ERROR) {
- LOG_ERROR_NEG("INKMgmtUpdateRegister");
+ if (TSMgmtUpdateRegister(global_contp, NULL, "blacklist.cgi") != TS_ERROR) {
+ LOG_ERROR_NEG("TSMgmtUpdateRegister");
}
- if (INKMgmtUpdateRegister(global_contp, "Inktomi Blacklist Plugin", NULL) != INK_ERROR) {
- LOG_ERROR_NEG("INKMgmtUpdateRegister");
+ if (TSMgmtUpdateRegister(global_contp, "Inktomi Blacklist Plugin", NULL) != TS_ERROR) {
+ LOG_ERROR_NEG("TSMgmtUpdateRegister");
}
- /* negative test for INKIOBufferReaderClone & INKVConnAbort */
- if (INKIOBufferReaderClone(NULL) != INK_ERROR_PTR) {
- LOG_ERROR_NEG("INKIOBufferReaderClone");
+ /* negative test for TSIOBufferReaderClone & TSVConnAbort */
+ if (TSIOBufferReaderClone(NULL) != TS_ERROR_PTR) {
+ LOG_ERROR_NEG("TSIOBufferReaderClone");
}
- if (INKVConnAbort(NULL, 1) != INK_ERROR) {
- LOG_ERROR_NEG("INKVConnAbort");
+ if (TSVConnAbort(NULL, 1) != TS_ERROR) {
+ LOG_ERROR_NEG("TSVConnAbort");
}
#endif
}
Modified: trafficserver/traffic/trunk/test/plugin/check-constants/check-constants.c
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/test/plugin/check-constants/check-constants.c?rev=1035782&r1=1035781&r2=1035782&view=diff
==============================================================================
--- trafficserver/traffic/trunk/test/plugin/check-constants/check-constants.c (original)
+++ trafficserver/traffic/trunk/test/plugin/check-constants/check-constants.c Tue Nov 16 20:22:02 2010
@@ -50,273 +50,273 @@
} \
}
-#define ORIG_INK_MAX_USER_NAME_LEN 256
+#define ORIG_TS_MAX_USER_NAME_LEN 256
int file_changed = 0;
typedef enum
{
- ORIG_INK_PARSE_ERROR = -1,
- ORIG_INK_PARSE_DONE = 0,
- ORIG_INK_PARSE_OK = 1,
- ORIG_INK_PARSE_CONT = 2
-} ORIG_INKParseResult;
+ ORIG_TS_PARSE_ERROR = -1,
+ ORIG_TS_PARSE_DONE = 0,
+ ORIG_TS_PARSE_OK = 1,
+ ORIG_TS_PARSE_CONT = 2
+} ORIG_TSParseResult;
typedef enum
{
- ORIG_INK_HTTP_TYPE_UNKNOWN,
- ORIG_INK_HTTP_TYPE_REQUEST,
- ORIG_INK_HTTP_TYPE_RESPONSE
-} ORIG_INKHttpType;
+ ORIG_TS_HTTP_TYPE_UNKNOWN,
+ ORIG_TS_HTTP_TYPE_REQUEST,
+ ORIG_TS_HTTP_TYPE_RESPONSE
+} ORIG_TSHttpType;
typedef enum
{
- ORIG_INK_HTTP_STATUS_NONE = 0,
+ ORIG_TS_HTTP_STATUS_NONE = 0,
- ORIG_INK_HTTP_STATUS_CONTINUE = 100,
- ORIG_INK_HTTP_STATUS_SWITCHING_PROTOCOL = 101,
+ ORIG_TS_HTTP_STATUS_CONTINUE = 100,
+ ORIG_TS_HTTP_STATUS_SWITCHING_PROTOCOL = 101,
- ORIG_INK_HTTP_STATUS_OK = 200,
- ORIG_INK_HTTP_STATUS_CREATED = 201,
- ORIG_INK_HTTP_STATUS_ACCEPTED = 202,
- ORIG_INK_HTTP_STATUS_NON_AUTHORITATIVE_INFORMATION = 203,
- ORIG_INK_HTTP_STATUS_NO_CONTENT = 204,
- ORIG_INK_HTTP_STATUS_RESET_CONTENT = 205,
- ORIG_INK_HTTP_STATUS_PARTIAL_CONTENT = 206,
-
- ORIG_INK_HTTP_STATUS_MULTIPLE_CHOICES = 300,
- ORIG_INK_HTTP_STATUS_MOVED_PERMANENTLY = 301,
- ORIG_INK_HTTP_STATUS_MOVED_TEMPORARILY = 302,
- ORIG_INK_HTTP_STATUS_SEE_OTHER = 303,
- ORIG_INK_HTTP_STATUS_NOT_MODIFIED = 304,
- ORIG_INK_HTTP_STATUS_USE_PROXY = 305,
-
- ORIG_INK_HTTP_STATUS_BAD_REQUEST = 400,
- ORIG_INK_HTTP_STATUS_UNAUTHORIZED = 401,
- ORIG_INK_HTTP_STATUS_PAYMENT_REQUIRED = 402,
- ORIG_INK_HTTP_STATUS_FORBIDDEN = 403,
- ORIG_INK_HTTP_STATUS_NOT_FOUND = 404,
- ORIG_INK_HTTP_STATUS_METHOD_NOT_ALLOWED = 405,
- ORIG_INK_HTTP_STATUS_NOT_ACCEPTABLE = 406,
- ORIG_INK_HTTP_STATUS_PROXY_AUTHENTICATION_REQUIRED = 407,
- ORIG_INK_HTTP_STATUS_REQUEST_TIMEOUT = 408,
- ORIG_INK_HTTP_STATUS_CONFLICT = 409,
- ORIG_INK_HTTP_STATUS_GONE = 410,
- ORIG_INK_HTTP_STATUS_LENGTH_REQUIRED = 411,
- ORIG_INK_HTTP_STATUS_PRECONDITION_FAILED = 412,
- ORIG_INK_HTTP_STATUS_REQUEST_ENTITY_TOO_LARGE = 413,
- ORIG_INK_HTTP_STATUS_REQUEST_URI_TOO_LONG = 414,
- ORIG_INK_HTTP_STATUS_UNSUPPORTED_MEDIA_TYPE = 415,
-
- ORIG_INK_HTTP_STATUS_INTERNAL_SERVER_ERROR = 500,
- ORIG_INK_HTTP_STATUS_NOT_IMPLEMENTED = 501,
- ORIG_INK_HTTP_STATUS_BAD_GATEWAY = 502,
- ORIG_INK_HTTP_STATUS_SERVICE_UNAVAILABLE = 503,
- ORIG_INK_HTTP_STATUS_GATEWAY_TIMEOUT = 504,
- ORIG_INK_HTTP_STATUS_HTTPVER_NOT_SUPPORTED = 505
-} ORIG_INKHttpStatus;
+ ORIG_TS_HTTP_STATUS_OK = 200,
+ ORIG_TS_HTTP_STATUS_CREATED = 201,
+ ORIG_TS_HTTP_STATUS_ACCEPTED = 202,
+ ORIG_TS_HTTP_STATUS_NON_AUTHORITATIVE_INFORMATION = 203,
+ ORIG_TS_HTTP_STATUS_NO_CONTENT = 204,
+ ORIG_TS_HTTP_STATUS_RESET_CONTENT = 205,
+ ORIG_TS_HTTP_STATUS_PARTIAL_CONTENT = 206,
+
+ ORIG_TS_HTTP_STATUS_MULTIPLE_CHOICES = 300,
+ ORIG_TS_HTTP_STATUS_MOVED_PERMANENTLY = 301,
+ ORIG_TS_HTTP_STATUS_MOVED_TEMPORARILY = 302,
+ ORIG_TS_HTTP_STATUS_SEE_OTHER = 303,
+ ORIG_TS_HTTP_STATUS_NOT_MODIFIED = 304,
+ ORIG_TS_HTTP_STATUS_USE_PROXY = 305,
+
+ ORIG_TS_HTTP_STATUS_BAD_REQUEST = 400,
+ ORIG_TS_HTTP_STATUS_UNAUTHORIZED = 401,
+ ORIG_TS_HTTP_STATUS_PAYMENT_REQUIRED = 402,
+ ORIG_TS_HTTP_STATUS_FORBIDDEN = 403,
+ ORIG_TS_HTTP_STATUS_NOT_FOUND = 404,
+ ORIG_TS_HTTP_STATUS_METHOD_NOT_ALLOWED = 405,
+ ORIG_TS_HTTP_STATUS_NOT_ACCEPTABLE = 406,
+ ORIG_TS_HTTP_STATUS_PROXY_AUTHENTICATION_REQUIRED = 407,
+ ORIG_TS_HTTP_STATUS_REQUEST_TIMEOUT = 408,
+ ORIG_TS_HTTP_STATUS_CONFLICT = 409,
+ ORIG_TS_HTTP_STATUS_GONE = 410,
+ ORIG_TS_HTTP_STATUS_LENGTH_REQUIRED = 411,
+ ORIG_TS_HTTP_STATUS_PRECONDITION_FAILED = 412,
+ ORIG_TS_HTTP_STATUS_REQUEST_ENTITY_TOO_LARGE = 413,
+ ORIG_TS_HTTP_STATUS_REQUEST_URI_TOO_LONG = 414,
+ ORIG_TS_HTTP_STATUS_UNSUPPORTED_MEDIA_TYPE = 415,
+
+ ORIG_TS_HTTP_STATUS_INTERNAL_SERVER_ERROR = 500,
+ ORIG_TS_HTTP_STATUS_NOT_IMPLEMENTED = 501,
+ ORIG_TS_HTTP_STATUS_BAD_GATEWAY = 502,
+ ORIG_TS_HTTP_STATUS_SERVICE_UNAVAILABLE = 503,
+ ORIG_TS_HTTP_STATUS_GATEWAY_TIMEOUT = 504,
+ ORIG_TS_HTTP_STATUS_HTTPVER_NOT_SUPPORTED = 505
+} ORIG_TSHttpStatus;
typedef enum
{
- ORIG_INK_HTTP_READ_REQUEST_HDR_HOOK,
- ORIG_INK_HTTP_OS_DNS_HOOK,
- ORIG_INK_HTTP_SEND_REQUEST_HDR_HOOK,
- ORIG_INK_HTTP_READ_CACHE_HDR_HOOK,
- ORIG_INK_HTTP_READ_RESPONSE_HDR_HOOK,
- ORIG_INK_HTTP_SEND_RESPONSE_HDR_HOOK,
- ORIG_INK_HTTP_REQUEST_TRANSFORM_HOOK,
- ORIG_INK_HTTP_RESPONSE_TRANSFORM_HOOK,
- ORIG_INK_HTTP_SELECT_ALT_HOOK,
- ORIG_INK_HTTP_TXN_START_HOOK,
- ORIG_INK_HTTP_TXN_CLOSE_HOOK,
- ORIG_INK_HTTP_SSN_START_HOOK,
- ORIG_INK_HTTP_SSN_CLOSE_HOOK,
+ ORIG_TS_HTTP_READ_REQUEST_HDR_HOOK,
+ ORIG_TS_HTTP_OS_DNS_HOOK,
+ ORIG_TS_HTTP_SEND_REQUEST_HDR_HOOK,
+ ORIG_TS_HTTP_READ_CACHE_HDR_HOOK,
+ ORIG_TS_HTTP_READ_RESPONSE_HDR_HOOK,
+ ORIG_TS_HTTP_SEND_RESPONSE_HDR_HOOK,
+ ORIG_TS_HTTP_REQUEST_TRANSFORM_HOOK,
+ ORIG_TS_HTTP_RESPONSE_TRANSFORM_HOOK,
+ ORIG_TS_HTTP_SELECT_ALT_HOOK,
+ ORIG_TS_HTTP_TXN_START_HOOK,
+ ORIG_TS_HTTP_TXN_CLOSE_HOOK,
+ ORIG_TS_HTTP_SSN_START_HOOK,
+ ORIG_TS_HTTP_SSN_CLOSE_HOOK,
- ORIG_INK_HTTP_LAST_HOOK
-} ORIG_INKHttpHookID;
+ ORIG_TS_HTTP_LAST_HOOK
+} ORIG_TSHttpHookID;
typedef enum
{
- ORIG_INK_EVENT_NONE = 0,
- ORIG_INK_EVENT_IMMEDIATE = 1,
- ORIG_INK_EVENT_TIMEOUT = 2,
- ORIG_INK_EVENT_ERROR = 3,
- ORIG_INK_EVENT_CONTINUE = 4,
-
- ORIG_INK_EVENT_VCONN_READ_READY = 100,
- ORIG_INK_EVENT_VCONN_WRITE_READY = 101,
- ORIG_INK_EVENT_VCONN_READ_COMPLETE = 102,
- ORIG_INK_EVENT_VCONN_WRITE_COMPLETE = 103,
- ORIG_INK_EVENT_VCONN_EOS = 104,
-
- ORIG_INK_EVENT_NET_CONNECT = 200,
- ORIG_INK_EVENT_NET_CONNECT_FAILED = 201,
-
- ORIG_INK_EVENT_HTTP_CONTINUE = 60000,
- ORIG_INK_EVENT_HTTP_ERROR = 60001,
- ORIG_INK_EVENT_HTTP_READ_REQUEST_HDR = 60002,
- ORIG_INK_EVENT_HTTP_OS_DNS = 60003,
- ORIG_INK_EVENT_HTTP_SEND_REQUEST_HDR = 60004,
- ORIG_INK_EVENT_HTTP_READ_CACHE_HDR = 60005,
- ORIG_INK_EVENT_HTTP_READ_RESPONSE_HDR = 60006,
- ORIG_INK_EVENT_HTTP_SEND_RESPONSE_HDR = 60007,
- ORIG_INK_EVENT_HTTP_REQUEST_TRANSFORM = 60008,
- ORIG_INK_EVENT_HTTP_RESPONSE_TRANSFORM = 60009,
- ORIG_INK_EVENT_HTTP_SELECT_ALT = 60010,
- ORIG_INK_EVENT_HTTP_TXN_START = 60011,
- ORIG_INK_EVENT_HTTP_TXN_CLOSE = 60012,
- ORIG_INK_EVENT_HTTP_SSN_START = 60013,
- ORIG_INK_EVENT_HTTP_SSN_CLOSE = 60014,
+ ORIG_TS_EVENT_NONE = 0,
+ ORIG_TS_EVENT_IMMEDIATE = 1,
+ ORIG_TS_EVENT_TIMEOUT = 2,
+ ORIG_TS_EVENT_ERROR = 3,
+ ORIG_TS_EVENT_CONTINUE = 4,
+
+ ORIG_TS_EVENT_VCONN_READ_READY = 100,
+ ORIG_TS_EVENT_VCONN_WRITE_READY = 101,
+ ORIG_TS_EVENT_VCONN_READ_COMPLETE = 102,
+ ORIG_TS_EVENT_VCONN_WRITE_COMPLETE = 103,
+ ORIG_TS_EVENT_VCONN_EOS = 104,
+
+ ORIG_TS_EVENT_NET_CONNECT = 200,
+ ORIG_TS_EVENT_NET_CONNECT_FAILED = 201,
+
+ ORIG_TS_EVENT_HTTP_CONTINUE = 60000,
+ ORIG_TS_EVENT_HTTP_ERROR = 60001,
+ ORIG_TS_EVENT_HTTP_READ_REQUEST_HDR = 60002,
+ ORIG_TS_EVENT_HTTP_OS_DNS = 60003,
+ ORIG_TS_EVENT_HTTP_SEND_REQUEST_HDR = 60004,
+ ORIG_TS_EVENT_HTTP_READ_CACHE_HDR = 60005,
+ ORIG_TS_EVENT_HTTP_READ_RESPONSE_HDR = 60006,
+ ORIG_TS_EVENT_HTTP_SEND_RESPONSE_HDR = 60007,
+ ORIG_TS_EVENT_HTTP_REQUEST_TRANSFORM = 60008,
+ ORIG_TS_EVENT_HTTP_RESPONSE_TRANSFORM = 60009,
+ ORIG_TS_EVENT_HTTP_SELECT_ALT = 60010,
+ ORIG_TS_EVENT_HTTP_TXN_START = 60011,
+ ORIG_TS_EVENT_HTTP_TXN_CLOSE = 60012,
+ ORIG_TS_EVENT_HTTP_SSN_START = 60013,
+ ORIG_TS_EVENT_HTTP_SSN_CLOSE = 60014,
- ORIG_INK_EVENT_MGMT_UPDATE = 60100
-} ORIG_INKEvent;
+ ORIG_TS_EVENT_MGMT_UPDATE = 60100
+} ORIG_TSEvent;
typedef enum
{
- ORIG_INK_DATA_ALLOCATE,
- ORIG_INK_DATA_MALLOCED,
- ORIG_INK_DATA_CONSTANT
-} ORIG_INKIOBufferDataFlags;
+ ORIG_TS_DATA_ALLOCATE,
+ ORIG_TS_DATA_MALLOCED,
+ ORIG_TS_DATA_CONSTANT
+} ORIG_TSIOBufferDataFlags;
typedef enum
{
- ORIG_INK_VC_CLOSE_ABORT = -1,
- ORIG_INK_VC_CLOSE_NORMAL = 1
-} ORIG_INKVConnCloseFlags;
+ ORIG_TS_VC_CLOSE_ABORT = -1,
+ ORIG_TS_VC_CLOSE_NORMAL = 1
+} ORIG_TSVConnCloseFlags;
typedef enum
{
- ORIG_INK_SDK_VERSION_2_0 = 0,
-} ORIG_INKSDKVersion;
+ ORIG_TS_SDK_VERSION_2_0 = 0,
+} ORIG_TSSDKVersion;
void
-INKPluginInit(int argc, const char *argv[])
+TSPluginInit(int argc, const char *argv[])
{
- PRINT_DIFF("INK_MAX_USER_NAME_LEN", INK_MAX_USER_NAME_LEN, ORIG_INK_MAX_USER_NAME_LEN);
+ PRINT_DIFF("TS_MAX_USER_NAME_LEN", TS_MAX_USER_NAME_LEN, ORIG_TS_MAX_USER_NAME_LEN);
- PRINT_DIFF("INK_PARSE_ERROR", INK_PARSE_ERROR, ORIG_INK_PARSE_ERROR);
- PRINT_DIFF("INK_PARSE_DONE", INK_PARSE_DONE, ORIG_INK_PARSE_DONE);
- PRINT_DIFF("INK_PARSE_OK", INK_PARSE_OK, ORIG_INK_PARSE_OK);
- PRINT_DIFF("INK_PARSE_CONT", INK_PARSE_CONT, ORIG_INK_PARSE_CONT);
-
- PRINT_DIFF("INK_HTTP_STATUS_NONE", INK_HTTP_STATUS_NONE, ORIG_INK_HTTP_STATUS_NONE);
- PRINT_DIFF("INK_HTTP_STATUS_CONTINUE", INK_HTTP_STATUS_CONTINUE, ORIG_INK_HTTP_STATUS_CONTINUE);
- PRINT_DIFF("INK_HTTP_STATUS_SWITCHING_PROTOCOL", INK_HTTP_STATUS_SWITCHING_PROTOCOL,
- ORIG_INK_HTTP_STATUS_SWITCHING_PROTOCOL);
- PRINT_DIFF("INK_HTTP_STATUS_OK", INK_HTTP_STATUS_OK, ORIG_INK_HTTP_STATUS_OK);
- PRINT_DIFF("INK_HTTP_STATUS_CREATED", INK_HTTP_STATUS_CREATED, ORIG_INK_HTTP_STATUS_CREATED);
-
-
- PRINT_DIFF("INK_HTTP_STATUS_ACCEPTED", INK_HTTP_STATUS_ACCEPTED, ORIG_INK_HTTP_STATUS_ACCEPTED);
- PRINT_DIFF("INK_HTTP_STATUS_NON_AUTHORITATIVE_INFORMATION", INK_HTTP_STATUS_NON_AUTHORITATIVE_INFORMATION,
- ORIG_INK_HTTP_STATUS_NON_AUTHORITATIVE_INFORMATION);
- PRINT_DIFF("INK_HTTP_STATUS_NO_CONTENT", INK_HTTP_STATUS_NO_CONTENT, ORIG_INK_HTTP_STATUS_NO_CONTENT);
- PRINT_DIFF("INK_HTTP_STATUS_RESET_CONTENT", INK_HTTP_STATUS_RESET_CONTENT, ORIG_INK_HTTP_STATUS_RESET_CONTENT);
- PRINT_DIFF("INK_HTTP_STATUS_PARTIAL_CONTENT", INK_HTTP_STATUS_PARTIAL_CONTENT, ORIG_INK_HTTP_STATUS_PARTIAL_CONTENT);
-
- PRINT_DIFF("INK_HTTP_STATUS_MULTIPLE_CHOICES", INK_HTTP_STATUS_MULTIPLE_CHOICES,
- ORIG_INK_HTTP_STATUS_MULTIPLE_CHOICES);
- PRINT_DIFF("INK_HTTP_STATUS_MOVED_PERMANENTLY", INK_HTTP_STATUS_MOVED_PERMANENTLY,
- ORIG_INK_HTTP_STATUS_MOVED_PERMANENTLY);
- PRINT_DIFF("INK_HTTP_STATUS_MOVED_TEMPORARILY", INK_HTTP_STATUS_MOVED_TEMPORARILY,
- ORIG_INK_HTTP_STATUS_MOVED_TEMPORARILY);
- PRINT_DIFF("INK_HTTP_STATUS_SEE_OTHER", INK_HTTP_STATUS_SEE_OTHER, ORIG_INK_HTTP_STATUS_SEE_OTHER);
- PRINT_DIFF("INK_HTTP_STATUS_NOT_MODIFIED", INK_HTTP_STATUS_NOT_MODIFIED, ORIG_INK_HTTP_STATUS_NOT_MODIFIED);
- PRINT_DIFF("INK_HTTP_STATUS_USE_PROXY", INK_HTTP_STATUS_USE_PROXY, ORIG_INK_HTTP_STATUS_USE_PROXY);
-
- PRINT_DIFF("INK_HTTP_STATUS_BAD_REQUEST", INK_HTTP_STATUS_BAD_REQUEST, ORIG_INK_HTTP_STATUS_BAD_REQUEST);
- PRINT_DIFF("INK_HTTP_STATUS_UNAUTHORIZED", INK_HTTP_STATUS_UNAUTHORIZED, ORIG_INK_HTTP_STATUS_UNAUTHORIZED);
- PRINT_DIFF("INK_HTTP_STATUS_FORBIDDEN", INK_HTTP_STATUS_FORBIDDEN, ORIG_INK_HTTP_STATUS_FORBIDDEN);
- PRINT_DIFF("INK_HTTP_STATUS_NOT_FOUND", INK_HTTP_STATUS_NOT_FOUND, ORIG_INK_HTTP_STATUS_NOT_FOUND);
-
- PRINT_DIFF("INK_HTTP_STATUS_METHOD_NOT_ALLOWED", INK_HTTP_STATUS_METHOD_NOT_ALLOWED,
- ORIG_INK_HTTP_STATUS_METHOD_NOT_ALLOWED);
- PRINT_DIFF("INK_HTTP_STATUS_NOT_ACCEPTABLE", INK_HTTP_STATUS_NOT_ACCEPTABLE, ORIG_INK_HTTP_STATUS_NOT_ACCEPTABLE);
- PRINT_DIFF("INK_HTTP_STATUS_PROXY_AUTHENTICATION_REQUIRED", INK_HTTP_STATUS_PROXY_AUTHENTICATION_REQUIRED,
- ORIG_INK_HTTP_STATUS_PROXY_AUTHENTICATION_REQUIRED);
- PRINT_DIFF("INK_HTTP_STATUS_REQUEST_TIMEOUT", INK_HTTP_STATUS_REQUEST_TIMEOUT, ORIG_INK_HTTP_STATUS_REQUEST_TIMEOUT);
- PRINT_DIFF("INK_HTTP_STATUS_CONFLICT", INK_HTTP_STATUS_CONFLICT, ORIG_INK_HTTP_STATUS_CONFLICT);
- PRINT_DIFF("INK_HTTP_STATUS_GONE", INK_HTTP_STATUS_GONE, ORIG_INK_HTTP_STATUS_GONE);
- PRINT_DIFF("INK_HTTP_STATUS_PRECONDITION_FAILED", INK_HTTP_STATUS_PRECONDITION_FAILED,
- ORIG_INK_HTTP_STATUS_PRECONDITION_FAILED);
- PRINT_DIFF("INK_HTTP_STATUS_REQUEST_ENTITY_TOO_LARGE", INK_HTTP_STATUS_REQUEST_ENTITY_TOO_LARGE,
- ORIG_INK_HTTP_STATUS_REQUEST_ENTITY_TOO_LARGE);
- PRINT_DIFF("INK_HTTP_STATUS_REQUEST_URI_TOO_LONG", INK_HTTP_STATUS_REQUEST_URI_TOO_LONG,
- ORIG_INK_HTTP_STATUS_REQUEST_URI_TOO_LONG);
- PRINT_DIFF("INK_HTTP_STATUS_UNSUPPORTED_MEDIA_TYPE", INK_HTTP_STATUS_UNSUPPORTED_MEDIA_TYPE,
- ORIG_INK_HTTP_STATUS_UNSUPPORTED_MEDIA_TYPE);
-
-
- PRINT_DIFF("INK_HTTP_STATUS_INTERNAL_SERVER_ERROR", INK_HTTP_STATUS_INTERNAL_SERVER_ERROR,
- ORIG_INK_HTTP_STATUS_INTERNAL_SERVER_ERROR);
- PRINT_DIFF("INK_HTTP_STATUS_NOT_IMPLEMENTED", INK_HTTP_STATUS_NOT_IMPLEMENTED, ORIG_INK_HTTP_STATUS_NOT_IMPLEMENTED);
- PRINT_DIFF("INK_HTTP_STATUS_BAD_GATEWAY", INK_HTTP_STATUS_BAD_GATEWAY, ORIG_INK_HTTP_STATUS_BAD_GATEWAY);
- PRINT_DIFF("INK_HTTP_STATUS_GATEWAY_TIMEOUT", INK_HTTP_STATUS_GATEWAY_TIMEOUT, ORIG_INK_HTTP_STATUS_GATEWAY_TIMEOUT);
- PRINT_DIFF("INK_HTTP_STATUS_HTTPVER_NOT_SUPPORTED", INK_HTTP_STATUS_HTTPVER_NOT_SUPPORTED,
- ORIG_INK_HTTP_STATUS_HTTPVER_NOT_SUPPORTED);
-
-
- PRINT_DIFF("INK_HTTP_READ_REQUEST_HDR_HOOK", INK_HTTP_READ_REQUEST_HDR_HOOK, ORIG_INK_HTTP_READ_REQUEST_HDR_HOOK);
- PRINT_DIFF("INK_HTTP_OS_DNS_HOOK", INK_HTTP_OS_DNS_HOOK, ORIG_INK_HTTP_OS_DNS_HOOK);
- PRINT_DIFF("INK_HTTP_SEND_REQUEST_HDR_HOOK", INK_HTTP_SEND_REQUEST_HDR_HOOK, ORIG_INK_HTTP_SEND_REQUEST_HDR_HOOK);
- PRINT_DIFF("INK_HTTP_READ_RESPONSE_HDR_HOOK", INK_HTTP_READ_RESPONSE_HDR_HOOK, ORIG_INK_HTTP_READ_RESPONSE_HDR_HOOK);
- PRINT_DIFF("INK_HTTP_SEND_RESPONSE_HDR_HOOK", INK_HTTP_SEND_RESPONSE_HDR_HOOK, ORIG_INK_HTTP_SEND_RESPONSE_HDR_HOOK);
- PRINT_DIFF("INK_HTTP_REQUEST_TRANSFORM_HOOK", INK_HTTP_REQUEST_TRANSFORM_HOOK, ORIG_INK_HTTP_REQUEST_TRANSFORM_HOOK);
- PRINT_DIFF("INK_HTTP_RESPONSE_TRANSFORM_HOOK", INK_HTTP_RESPONSE_TRANSFORM_HOOK,
- ORIG_INK_HTTP_RESPONSE_TRANSFORM_HOOK);
- PRINT_DIFF("INK_HTTP_SELECT_ALT_HOOK", INK_HTTP_SELECT_ALT_HOOK, ORIG_INK_HTTP_SELECT_ALT_HOOK);
- PRINT_DIFF("INK_HTTP_TXN_START_HOOK", INK_HTTP_TXN_START_HOOK, ORIG_INK_HTTP_TXN_START_HOOK);
- PRINT_DIFF("INK_HTTP_TXN_CLOSE_HOOK", INK_HTTP_TXN_CLOSE_HOOK, ORIG_INK_HTTP_TXN_CLOSE_HOOK);
- PRINT_DIFF("INK_HTTP_SSN_START_HOOK", INK_HTTP_SSN_START_HOOK, ORIG_INK_HTTP_SSN_START_HOOK);
- PRINT_DIFF("INK_HTTP_SSN_CLOSE_HOOK", INK_HTTP_SSN_CLOSE_HOOK, ORIG_INK_HTTP_SSN_CLOSE_HOOK);
- PRINT_DIFF("INK_HTTP_LAST_HOOK", INK_HTTP_LAST_HOOK, ORIG_INK_HTTP_LAST_HOOK);
-
- PRINT_DIFF("INK_EVENT_NONE", INK_EVENT_NONE, ORIG_INK_EVENT_NONE);
- PRINT_DIFF("INK_EVENT_IMMEDIATE", INK_EVENT_IMMEDIATE, ORIG_INK_EVENT_IMMEDIATE);
- PRINT_DIFF("INK_EVENT_TIMEOUT", INK_EVENT_TIMEOUT, ORIG_INK_EVENT_TIMEOUT);
- PRINT_DIFF("INK_EVENT_ERROR", INK_EVENT_ERROR, ORIG_INK_EVENT_ERROR);
- PRINT_DIFF("INK_EVENT_CONTINUE", INK_EVENT_CONTINUE, ORIG_INK_EVENT_CONTINUE);
- PRINT_DIFF("INK_EVENT_VCONN_READ_READY", INK_EVENT_VCONN_READ_READY, ORIG_INK_EVENT_VCONN_READ_READY);
- PRINT_DIFF("INK_EVENT_VCONN_WRITE_READY", INK_EVENT_VCONN_WRITE_READY, ORIG_INK_EVENT_VCONN_WRITE_READY);
- PRINT_DIFF("INK_EVENT_VCONN_READ_COMPLETE", INK_EVENT_VCONN_READ_COMPLETE, ORIG_INK_EVENT_VCONN_READ_COMPLETE);
- PRINT_DIFF("INK_EVENT_VCONN_WRITE_COMPLETE", INK_EVENT_VCONN_WRITE_COMPLETE, ORIG_INK_EVENT_VCONN_WRITE_COMPLETE);
- PRINT_DIFF("INK_EVENT_VCONN_EOS", INK_EVENT_VCONN_EOS, ORIG_INK_EVENT_VCONN_EOS);
- PRINT_DIFF("INK_EVENT_NET_CONNECT", INK_EVENT_NET_CONNECT, ORIG_INK_EVENT_NET_CONNECT);
- PRINT_DIFF("INK_EVENT_NET_CONNECT_FAILED", INK_EVENT_NET_CONNECT_FAILED, ORIG_INK_EVENT_NET_CONNECT_FAILED);
- PRINT_DIFF("INK_EVENT_HTTP_CONTINUE", INK_EVENT_HTTP_CONTINUE, ORIG_INK_EVENT_HTTP_CONTINUE);
- PRINT_DIFF("INK_EVENT_HTTP_ERROR", INK_EVENT_HTTP_ERROR, ORIG_INK_EVENT_HTTP_ERROR);
- PRINT_DIFF("INK_EVENT_HTTP_READ_REQUEST_HDR", INK_EVENT_HTTP_READ_REQUEST_HDR, ORIG_INK_EVENT_HTTP_READ_REQUEST_HDR);
- PRINT_DIFF("INK_EVENT_HTTP_OS_DNS", INK_EVENT_HTTP_OS_DNS, ORIG_INK_EVENT_HTTP_OS_DNS);
- PRINT_DIFF("INK_EVENT_HTTP_SEND_REQUEST_HDR", INK_EVENT_HTTP_SEND_REQUEST_HDR, ORIG_INK_EVENT_HTTP_SEND_REQUEST_HDR);
- PRINT_DIFF("INK_EVENT_HTTP_READ_CACHE_HDR", INK_EVENT_HTTP_READ_CACHE_HDR, ORIG_INK_EVENT_HTTP_READ_CACHE_HDR);
- PRINT_DIFF("INK_EVENT_HTTP_READ_RESPONSE_HDR", INK_EVENT_HTTP_READ_RESPONSE_HDR,
- ORIG_INK_EVENT_HTTP_READ_RESPONSE_HDR);
- PRINT_DIFF("INK_EVENT_HTTP_SEND_RESPONSE_HDR", INK_EVENT_HTTP_SEND_RESPONSE_HDR,
- ORIG_INK_EVENT_HTTP_SEND_RESPONSE_HDR);
- PRINT_DIFF("INK_EVENT_HTTP_REQUEST_TRANSFORM", INK_EVENT_HTTP_REQUEST_TRANSFORM,
- ORIG_INK_EVENT_HTTP_REQUEST_TRANSFORM);
- PRINT_DIFF("INK_EVENT_HTTP_RESPONSE_TRANSFORM", INK_EVENT_HTTP_RESPONSE_TRANSFORM,
- ORIG_INK_EVENT_HTTP_RESPONSE_TRANSFORM);
- PRINT_DIFF("INK_EVENT_HTTP_SELECT_ALT", INK_EVENT_HTTP_SELECT_ALT, ORIG_INK_EVENT_HTTP_SELECT_ALT);
- PRINT_DIFF("INK_EVENT_HTTP_TXN_START", INK_EVENT_HTTP_TXN_START, ORIG_INK_EVENT_HTTP_TXN_START);
- PRINT_DIFF("INK_EVENT_HTTP_TXN_CLOSE", INK_EVENT_HTTP_TXN_CLOSE, ORIG_INK_EVENT_HTTP_TXN_CLOSE);
- PRINT_DIFF("INK_EVENT_HTTP_SSN_START", INK_EVENT_HTTP_SSN_START, ORIG_INK_EVENT_HTTP_SSN_START);
- PRINT_DIFF("INK_EVENT_HTTP_SSN_CLOSE", INK_EVENT_HTTP_SSN_CLOSE, ORIG_INK_EVENT_HTTP_SSN_CLOSE);
- PRINT_DIFF("INK_EVENT_MGMT_UPDATE", INK_EVENT_MGMT_UPDATE, ORIG_INK_EVENT_MGMT_UPDATE);
-
- PRINT_DIFF("INK_EVENT_MGMT_UPDATE", INK_EVENT_MGMT_UPDATE, ORIG_INK_EVENT_MGMT_UPDATE);
-
- PRINT_DIFF("INK_DATA_ALLOCATE", INK_DATA_ALLOCATE, ORIG_INK_DATA_ALLOCATE);
- PRINT_DIFF("INK_DATA_MALLOCED", INK_DATA_MALLOCED, ORIG_INK_DATA_MALLOCED);
- PRINT_DIFF("INK_DATA_CONSTANT", INK_DATA_CONSTANT, ORIG_INK_DATA_CONSTANT);
+ PRINT_DIFF("TS_PARSE_ERROR", TS_PARSE_ERROR, ORIG_TS_PARSE_ERROR);
+ PRINT_DIFF("TS_PARSE_DONE", TS_PARSE_DONE, ORIG_TS_PARSE_DONE);
+ PRINT_DIFF("TS_PARSE_OK", TS_PARSE_OK, ORIG_TS_PARSE_OK);
+ PRINT_DIFF("TS_PARSE_CONT", TS_PARSE_CONT, ORIG_TS_PARSE_CONT);
+
+ PRINT_DIFF("TS_HTTP_STATUS_NONE", TS_HTTP_STATUS_NONE, ORIG_TS_HTTP_STATUS_NONE);
+ PRINT_DIFF("TS_HTTP_STATUS_CONTINUE", TS_HTTP_STATUS_CONTINUE, ORIG_TS_HTTP_STATUS_CONTINUE);
+ PRINT_DIFF("TS_HTTP_STATUS_SWITCHING_PROTOCOL", TS_HTTP_STATUS_SWITCHING_PROTOCOL,
+ ORIG_TS_HTTP_STATUS_SWITCHING_PROTOCOL);
+ PRINT_DIFF("TS_HTTP_STATUS_OK", TS_HTTP_STATUS_OK, ORIG_TS_HTTP_STATUS_OK);
+ PRINT_DIFF("TS_HTTP_STATUS_CREATED", TS_HTTP_STATUS_CREATED, ORIG_TS_HTTP_STATUS_CREATED);
+
+
+ PRINT_DIFF("TS_HTTP_STATUS_ACCEPTED", TS_HTTP_STATUS_ACCEPTED, ORIG_TS_HTTP_STATUS_ACCEPTED);
+ PRINT_DIFF("TS_HTTP_STATUS_NON_AUTHORITATIVE_INFORMATION", TS_HTTP_STATUS_NON_AUTHORITATIVE_INFORMATION,
+ ORIG_TS_HTTP_STATUS_NON_AUTHORITATIVE_INFORMATION);
+ PRINT_DIFF("TS_HTTP_STATUS_NO_CONTENT", TS_HTTP_STATUS_NO_CONTENT, ORIG_TS_HTTP_STATUS_NO_CONTENT);
+ PRINT_DIFF("TS_HTTP_STATUS_RESET_CONTENT", TS_HTTP_STATUS_RESET_CONTENT, ORIG_TS_HTTP_STATUS_RESET_CONTENT);
+ PRINT_DIFF("TS_HTTP_STATUS_PARTIAL_CONTENT", TS_HTTP_STATUS_PARTIAL_CONTENT, ORIG_TS_HTTP_STATUS_PARTIAL_CONTENT);
+
+ PRINT_DIFF("TS_HTTP_STATUS_MULTIPLE_CHOICES", TS_HTTP_STATUS_MULTIPLE_CHOICES,
+ ORIG_TS_HTTP_STATUS_MULTIPLE_CHOICES);
+ PRINT_DIFF("TS_HTTP_STATUS_MOVED_PERMANENTLY", TS_HTTP_STATUS_MOVED_PERMANENTLY,
+ ORIG_TS_HTTP_STATUS_MOVED_PERMANENTLY);
+ PRINT_DIFF("TS_HTTP_STATUS_MOVED_TEMPORARILY", TS_HTTP_STATUS_MOVED_TEMPORARILY,
+ ORIG_TS_HTTP_STATUS_MOVED_TEMPORARILY);
+ PRINT_DIFF("TS_HTTP_STATUS_SEE_OTHER", TS_HTTP_STATUS_SEE_OTHER, ORIG_TS_HTTP_STATUS_SEE_OTHER);
+ PRINT_DIFF("TS_HTTP_STATUS_NOT_MODIFIED", TS_HTTP_STATUS_NOT_MODIFIED, ORIG_TS_HTTP_STATUS_NOT_MODIFIED);
+ PRINT_DIFF("TS_HTTP_STATUS_USE_PROXY", TS_HTTP_STATUS_USE_PROXY, ORIG_TS_HTTP_STATUS_USE_PROXY);
+
+ PRINT_DIFF("TS_HTTP_STATUS_BAD_REQUEST", TS_HTTP_STATUS_BAD_REQUEST, ORIG_TS_HTTP_STATUS_BAD_REQUEST);
+ PRINT_DIFF("TS_HTTP_STATUS_UNAUTHORIZED", TS_HTTP_STATUS_UNAUTHORIZED, ORIG_TS_HTTP_STATUS_UNAUTHORIZED);
+ PRINT_DIFF("TS_HTTP_STATUS_FORBIDDEN", TS_HTTP_STATUS_FORBIDDEN, ORIG_TS_HTTP_STATUS_FORBIDDEN);
+ PRINT_DIFF("TS_HTTP_STATUS_NOT_FOUND", TS_HTTP_STATUS_NOT_FOUND, ORIG_TS_HTTP_STATUS_NOT_FOUND);
+
+ PRINT_DIFF("TS_HTTP_STATUS_METHOD_NOT_ALLOWED", TS_HTTP_STATUS_METHOD_NOT_ALLOWED,
+ ORIG_TS_HTTP_STATUS_METHOD_NOT_ALLOWED);
+ PRINT_DIFF("TS_HTTP_STATUS_NOT_ACCEPTABLE", TS_HTTP_STATUS_NOT_ACCEPTABLE, ORIG_TS_HTTP_STATUS_NOT_ACCEPTABLE);
+ PRINT_DIFF("TS_HTTP_STATUS_PROXY_AUTHENTICATION_REQUIRED", TS_HTTP_STATUS_PROXY_AUTHENTICATION_REQUIRED,
+ ORIG_TS_HTTP_STATUS_PROXY_AUTHENTICATION_REQUIRED);
+ PRINT_DIFF("TS_HTTP_STATUS_REQUEST_TIMEOUT", TS_HTTP_STATUS_REQUEST_TIMEOUT, ORIG_TS_HTTP_STATUS_REQUEST_TIMEOUT);
+ PRINT_DIFF("TS_HTTP_STATUS_CONFLICT", TS_HTTP_STATUS_CONFLICT, ORIG_TS_HTTP_STATUS_CONFLICT);
+ PRINT_DIFF("TS_HTTP_STATUS_GONE", TS_HTTP_STATUS_GONE, ORIG_TS_HTTP_STATUS_GONE);
+ PRINT_DIFF("TS_HTTP_STATUS_PRECONDITION_FAILED", TS_HTTP_STATUS_PRECONDITION_FAILED,
+ ORIG_TS_HTTP_STATUS_PRECONDITION_FAILED);
+ PRINT_DIFF("TS_HTTP_STATUS_REQUEST_ENTITY_TOO_LARGE", TS_HTTP_STATUS_REQUEST_ENTITY_TOO_LARGE,
+ ORIG_TS_HTTP_STATUS_REQUEST_ENTITY_TOO_LARGE);
+ PRINT_DIFF("TS_HTTP_STATUS_REQUEST_URI_TOO_LONG", TS_HTTP_STATUS_REQUEST_URI_TOO_LONG,
+ ORIG_TS_HTTP_STATUS_REQUEST_URI_TOO_LONG);
+ PRINT_DIFF("TS_HTTP_STATUS_UNSUPPORTED_MEDIA_TYPE", TS_HTTP_STATUS_UNSUPPORTED_MEDIA_TYPE,
+ ORIG_TS_HTTP_STATUS_UNSUPPORTED_MEDIA_TYPE);
+
+
+ PRINT_DIFF("TS_HTTP_STATUS_INTERNAL_SERVER_ERROR", TS_HTTP_STATUS_INTERNAL_SERVER_ERROR,
+ ORIG_TS_HTTP_STATUS_INTERNAL_SERVER_ERROR);
+ PRINT_DIFF("TS_HTTP_STATUS_NOT_IMPLEMENTED", TS_HTTP_STATUS_NOT_IMPLEMENTED, ORIG_TS_HTTP_STATUS_NOT_IMPLEMENTED);
+ PRINT_DIFF("TS_HTTP_STATUS_BAD_GATEWAY", TS_HTTP_STATUS_BAD_GATEWAY, ORIG_TS_HTTP_STATUS_BAD_GATEWAY);
+ PRINT_DIFF("TS_HTTP_STATUS_GATEWAY_TIMEOUT", TS_HTTP_STATUS_GATEWAY_TIMEOUT, ORIG_TS_HTTP_STATUS_GATEWAY_TIMEOUT);
+ PRINT_DIFF("TS_HTTP_STATUS_HTTPVER_NOT_SUPPORTED", TS_HTTP_STATUS_HTTPVER_NOT_SUPPORTED,
+ ORIG_TS_HTTP_STATUS_HTTPVER_NOT_SUPPORTED);
+
+
+ PRINT_DIFF("TS_HTTP_READ_REQUEST_HDR_HOOK", TS_HTTP_READ_REQUEST_HDR_HOOK, ORIG_TS_HTTP_READ_REQUEST_HDR_HOOK);
+ PRINT_DIFF("TS_HTTP_OS_DNS_HOOK", TS_HTTP_OS_DNS_HOOK, ORIG_TS_HTTP_OS_DNS_HOOK);
+ PRINT_DIFF("TS_HTTP_SEND_REQUEST_HDR_HOOK", TS_HTTP_SEND_REQUEST_HDR_HOOK, ORIG_TS_HTTP_SEND_REQUEST_HDR_HOOK);
+ PRINT_DIFF("TS_HTTP_READ_RESPONSE_HDR_HOOK", TS_HTTP_READ_RESPONSE_HDR_HOOK, ORIG_TS_HTTP_READ_RESPONSE_HDR_HOOK);
+ PRINT_DIFF("TS_HTTP_SEND_RESPONSE_HDR_HOOK", TS_HTTP_SEND_RESPONSE_HDR_HOOK, ORIG_TS_HTTP_SEND_RESPONSE_HDR_HOOK);
+ PRINT_DIFF("TS_HTTP_REQUEST_TRANSFORM_HOOK", TS_HTTP_REQUEST_TRANSFORM_HOOK, ORIG_TS_HTTP_REQUEST_TRANSFORM_HOOK);
+ PRINT_DIFF("TS_HTTP_RESPONSE_TRANSFORM_HOOK", TS_HTTP_RESPONSE_TRANSFORM_HOOK,
+ ORIG_TS_HTTP_RESPONSE_TRANSFORM_HOOK);
+ PRINT_DIFF("TS_HTTP_SELECT_ALT_HOOK", TS_HTTP_SELECT_ALT_HOOK, ORIG_TS_HTTP_SELECT_ALT_HOOK);
+ PRINT_DIFF("TS_HTTP_TXN_START_HOOK", TS_HTTP_TXN_START_HOOK, ORIG_TS_HTTP_TXN_START_HOOK);
+ PRINT_DIFF("TS_HTTP_TXN_CLOSE_HOOK", TS_HTTP_TXN_CLOSE_HOOK, ORIG_TS_HTTP_TXN_CLOSE_HOOK);
+ PRINT_DIFF("TS_HTTP_SSN_START_HOOK", TS_HTTP_SSN_START_HOOK, ORIG_TS_HTTP_SSN_START_HOOK);
+ PRINT_DIFF("TS_HTTP_SSN_CLOSE_HOOK", TS_HTTP_SSN_CLOSE_HOOK, ORIG_TS_HTTP_SSN_CLOSE_HOOK);
+ PRINT_DIFF("TS_HTTP_LAST_HOOK", TS_HTTP_LAST_HOOK, ORIG_TS_HTTP_LAST_HOOK);
+
+ PRINT_DIFF("TS_EVENT_NONE", TS_EVENT_NONE, ORIG_TS_EVENT_NONE);
+ PRINT_DIFF("TS_EVENT_IMMEDIATE", TS_EVENT_IMMEDIATE, ORIG_TS_EVENT_IMMEDIATE);
+ PRINT_DIFF("TS_EVENT_TIMEOUT", TS_EVENT_TIMEOUT, ORIG_TS_EVENT_TIMEOUT);
+ PRINT_DIFF("TS_EVENT_ERROR", TS_EVENT_ERROR, ORIG_TS_EVENT_ERROR);
+ PRINT_DIFF("TS_EVENT_CONTINUE", TS_EVENT_CONTINUE, ORIG_TS_EVENT_CONTINUE);
+ PRINT_DIFF("TS_EVENT_VCONN_READ_READY", TS_EVENT_VCONN_READ_READY, ORIG_TS_EVENT_VCONN_READ_READY);
+ PRINT_DIFF("TS_EVENT_VCONN_WRITE_READY", TS_EVENT_VCONN_WRITE_READY, ORIG_TS_EVENT_VCONN_WRITE_READY);
+ PRINT_DIFF("TS_EVENT_VCONN_READ_COMPLETE", TS_EVENT_VCONN_READ_COMPLETE, ORIG_TS_EVENT_VCONN_READ_COMPLETE);
+ PRINT_DIFF("TS_EVENT_VCONN_WRITE_COMPLETE", TS_EVENT_VCONN_WRITE_COMPLETE, ORIG_TS_EVENT_VCONN_WRITE_COMPLETE);
+ PRINT_DIFF("TS_EVENT_VCONN_EOS", TS_EVENT_VCONN_EOS, ORIG_TS_EVENT_VCONN_EOS);
+ PRINT_DIFF("TS_EVENT_NET_CONNECT", TS_EVENT_NET_CONNECT, ORIG_TS_EVENT_NET_CONNECT);
+ PRINT_DIFF("TS_EVENT_NET_CONNECT_FAILED", TS_EVENT_NET_CONNECT_FAILED, ORIG_TS_EVENT_NET_CONNECT_FAILED);
+ PRINT_DIFF("TS_EVENT_HTTP_CONTINUE", TS_EVENT_HTTP_CONTINUE, ORIG_TS_EVENT_HTTP_CONTINUE);
+ PRINT_DIFF("TS_EVENT_HTTP_ERROR", TS_EVENT_HTTP_ERROR, ORIG_TS_EVENT_HTTP_ERROR);
+ PRINT_DIFF("TS_EVENT_HTTP_READ_REQUEST_HDR", TS_EVENT_HTTP_READ_REQUEST_HDR, ORIG_TS_EVENT_HTTP_READ_REQUEST_HDR);
+ PRINT_DIFF("TS_EVENT_HTTP_OS_DNS", TS_EVENT_HTTP_OS_DNS, ORIG_TS_EVENT_HTTP_OS_DNS);
+ PRINT_DIFF("TS_EVENT_HTTP_SEND_REQUEST_HDR", TS_EVENT_HTTP_SEND_REQUEST_HDR, ORIG_TS_EVENT_HTTP_SEND_REQUEST_HDR);
+ PRINT_DIFF("TS_EVENT_HTTP_READ_CACHE_HDR", TS_EVENT_HTTP_READ_CACHE_HDR, ORIG_TS_EVENT_HTTP_READ_CACHE_HDR);
+ PRINT_DIFF("TS_EVENT_HTTP_READ_RESPONSE_HDR", TS_EVENT_HTTP_READ_RESPONSE_HDR,
+ ORIG_TS_EVENT_HTTP_READ_RESPONSE_HDR);
+ PRINT_DIFF("TS_EVENT_HTTP_SEND_RESPONSE_HDR", TS_EVENT_HTTP_SEND_RESPONSE_HDR,
+ ORIG_TS_EVENT_HTTP_SEND_RESPONSE_HDR);
+ PRINT_DIFF("TS_EVENT_HTTP_REQUEST_TRANSFORM", TS_EVENT_HTTP_REQUEST_TRANSFORM,
+ ORIG_TS_EVENT_HTTP_REQUEST_TRANSFORM);
+ PRINT_DIFF("TS_EVENT_HTTP_RESPONSE_TRANSFORM", TS_EVENT_HTTP_RESPONSE_TRANSFORM,
+ ORIG_TS_EVENT_HTTP_RESPONSE_TRANSFORM);
+ PRINT_DIFF("TS_EVENT_HTTP_SELECT_ALT", TS_EVENT_HTTP_SELECT_ALT, ORIG_TS_EVENT_HTTP_SELECT_ALT);
+ PRINT_DIFF("TS_EVENT_HTTP_TXN_START", TS_EVENT_HTTP_TXN_START, ORIG_TS_EVENT_HTTP_TXN_START);
+ PRINT_DIFF("TS_EVENT_HTTP_TXN_CLOSE", TS_EVENT_HTTP_TXN_CLOSE, ORIG_TS_EVENT_HTTP_TXN_CLOSE);
+ PRINT_DIFF("TS_EVENT_HTTP_SSN_START", TS_EVENT_HTTP_SSN_START, ORIG_TS_EVENT_HTTP_SSN_START);
+ PRINT_DIFF("TS_EVENT_HTTP_SSN_CLOSE", TS_EVENT_HTTP_SSN_CLOSE, ORIG_TS_EVENT_HTTP_SSN_CLOSE);
+ PRINT_DIFF("TS_EVENT_MGMT_UPDATE", TS_EVENT_MGMT_UPDATE, ORIG_TS_EVENT_MGMT_UPDATE);
+
+ PRINT_DIFF("TS_EVENT_MGMT_UPDATE", TS_EVENT_MGMT_UPDATE, ORIG_TS_EVENT_MGMT_UPDATE);
+
+ PRINT_DIFF("TS_DATA_ALLOCATE", TS_DATA_ALLOCATE, ORIG_TS_DATA_ALLOCATE);
+ PRINT_DIFF("TS_DATA_MALLOCED", TS_DATA_MALLOCED, ORIG_TS_DATA_MALLOCED);
+ PRINT_DIFF("TS_DATA_CONSTANT", TS_DATA_CONSTANT, ORIG_TS_DATA_CONSTANT);
- PRINT_DIFF("INK_VC_CLOSE_ABORT", INK_VC_CLOSE_ABORT, ORIG_INK_VC_CLOSE_ABORT);
- PRINT_DIFF("INK_VC_CLOSE_NORMAL", INK_VC_CLOSE_NORMAL, ORIG_INK_VC_CLOSE_NORMAL);
+ PRINT_DIFF("TS_VC_CLOSE_ABORT", TS_VC_CLOSE_ABORT, ORIG_TS_VC_CLOSE_ABORT);
+ PRINT_DIFF("TS_VC_CLOSE_NORMAL", TS_VC_CLOSE_NORMAL, ORIG_TS_VC_CLOSE_NORMAL);
- PRINT_DIFF("INK_SDK_VERSION_2_0", INK_SDK_VERSION_2_0, ORIG_INK_SDK_VERSION_2_0);
+ PRINT_DIFF("TS_SDK_VERSION_2_0", TS_SDK_VERSION_2_0, ORIG_TS_SDK_VERSION_2_0);
if (file_changed) {
printf("\n***************************************************************************************");