You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@trafficserver.apache.org by am...@apache.org on 2010/11/30 02:43:06 UTC

svn commit: r1040383 [10/38] - in /trafficserver/traffic/branches/wccp: ./ build/ contrib/ contrib/perl/AdminClient/lib/Apache/TS/ example/ example/add-header/ example/app-template/ example/append-transform/ example/basic-auth/ example/blacklist-0/ exa...

Modified: trafficserver/traffic/branches/wccp/proxy/InkAPI.cc
URL: http://svn.apache.org/viewvc/trafficserver/traffic/branches/wccp/proxy/InkAPI.cc?rev=1040383&r1=1040382&r2=1040383&view=diff
==============================================================================
--- trafficserver/traffic/branches/wccp/proxy/InkAPI.cc (original)
+++ trafficserver/traffic/branches/wccp/proxy/InkAPI.cc Tue Nov 30 01:42:55 2010
@@ -1,6 +1,6 @@
 /** @file
 
-  Implements callin functions for plugins
+  Implements callin functions for TSAPI plugins.
 
   @section license License
 
@@ -21,10 +21,10 @@
   limitations under the License.
  */
 
-#ifndef INK_NO_API
+#ifndef TS_NO_API
 
 // Avoid complaining about the deprecated APIs.
-#define INK_DEPRECATED
+// #define TS_DEPRECATED
 
 #include <stdio.h>
 
@@ -54,7 +54,7 @@
 #include "LogConfig.h"
 //#include "UserNameCache.h"
 #include "PluginVC.h"
-#include "api/ts/ts_private.h"
+#include "api/ts/experimental.h"
 #include "ICP.h"
 #include "HttpAccept.h"
 #include "PluginVC.h"
@@ -79,42 +79,6 @@
  *   held for the entire duration of the IOCore call
  ***************************************************************/
 
-//
-// FORCE_PLUGIN_MUTEX -- define 'UNSAFE_FORCE_MUTEX' if you
-// do *not* want the locking macro to be thread safe.
-// Otherwise, access during 'null-mutex' case will be serialized
-// in a locking manner (too bad for the net threads).
-//
-
-#define UNSAFE_FORCE_MUTEX
-
-#ifdef UNSAFE_FORCE_MUTEX
-#define LOCK_MONGO_MUTEX
-#define UNLOCK_MONGO_MUTEX
-#define MUX_WARNING(p) \
-INKDebug ("sdk","(SDK) null mutex detected in critical region (mutex created)"); \
-INKDebug ("sdk","(SDK) please create continuation [%p] with mutex", (p));
-#else
-static ink_mutex big_mux;
-
-#define MUX_WARNING(p) 1
-#define LOCK_MONGO_MUTEX   ink_mutex_acquire (&big_mux)
-#define UNLOCK_MONGO_MUTEX ink_mutex_release (&big_mux)
-#endif
-
-#define FORCE_PLUGIN_MUTEX(_c) \
-  MutexLock ml; \
-  LOCK_MONGO_MUTEX; \
-  if (( (INKContInternal*)_c)->mutex == NULL) { \
-      ( (INKContInternal*)_c)->mutex = new_ProxyMutex(); \
-      UNLOCK_MONGO_MUTEX; \
-	  MUX_WARNING(_c); \
-      MUTEX_SET_AND_TAKE_LOCK(ml, ((INKContInternal*)_c)->mutex, this_ethread()); \
-  } else { \
-      UNLOCK_MONGO_MUTEX; \
-      MUTEX_SET_AND_TAKE_LOCK(ml, ((INKContInternal*)_c)->mutex, this_ethread()); \
-  }
-
 // helper macro for setting HTTPHdr data
 #define SET_HTTP_HDR(_HDR, _BUF_PTR, _OBJ_PTR) \
     _HDR.m_heap = ((HdrHeapSDKHandle*) _BUF_PTR)->m_heap; \
@@ -125,259 +89,265 @@ static ink_mutex big_mux;
 volatile int top_stat = 0;
 RecRawStatBlock *api_rsb;
 
+// Globals for the Sessions/Transaction index registry
+volatile int next_argv_index = 0;
+
+struct _STATE_ARG_TABLE {
+  char* name;
+  int name_len;
+  char* description;
+} state_arg_table[HTTP_SSN_TXN_MAX_USER_ARG];
+
 
 /* URL schemes */
-inkapi const char *INK_URL_SCHEME_FILE;
-inkapi const char *INK_URL_SCHEME_FTP;
-inkapi const char *INK_URL_SCHEME_GOPHER;
-inkapi const char *INK_URL_SCHEME_HTTP;
-inkapi const char *INK_URL_SCHEME_HTTPS;
-inkapi const char *INK_URL_SCHEME_MAILTO;
-inkapi const char *INK_URL_SCHEME_NEWS;
-inkapi const char *INK_URL_SCHEME_NNTP;
-inkapi const char *INK_URL_SCHEME_PROSPERO;
-inkapi const char *INK_URL_SCHEME_RTSP;
-inkapi const char *INK_URL_SCHEME_RTSPU;
-inkapi const char *INK_URL_SCHEME_TELNET;
-inkapi const char *INK_URL_SCHEME_WAIS;
+tsapi const char *TS_URL_SCHEME_FILE;
+tsapi const char *TS_URL_SCHEME_FTP;
+tsapi const char *TS_URL_SCHEME_GOPHER;
+tsapi const char *TS_URL_SCHEME_HTTP;
+tsapi const char *TS_URL_SCHEME_HTTPS;
+tsapi const char *TS_URL_SCHEME_MAILTO;
+tsapi const char *TS_URL_SCHEME_NEWS;
+tsapi const char *TS_URL_SCHEME_NNTP;
+tsapi const char *TS_URL_SCHEME_PROSPERO;
+tsapi const char *TS_URL_SCHEME_RTSP;
+tsapi const char *TS_URL_SCHEME_RTSPU;
+tsapi const char *TS_URL_SCHEME_TELNET;
+tsapi const char *TS_URL_SCHEME_WAIS;
 
 /* URL schemes string lengths */
-inkapi int INK_URL_LEN_FILE;
-inkapi int INK_URL_LEN_FTP;
-inkapi int INK_URL_LEN_GOPHER;
-inkapi int INK_URL_LEN_HTTP;
-inkapi int INK_URL_LEN_HTTPS;
-inkapi int INK_URL_LEN_MAILTO;
-inkapi int INK_URL_LEN_NEWS;
-inkapi int INK_URL_LEN_NNTP;
-inkapi int INK_URL_LEN_PROSPERO;
-inkapi int INK_URL_LEN_TELNET;
-inkapi int INK_URL_LEN_WAIS;
+tsapi int TS_URL_LEN_FILE;
+tsapi int TS_URL_LEN_FTP;
+tsapi int TS_URL_LEN_GOPHER;
+tsapi int TS_URL_LEN_HTTP;
+tsapi int TS_URL_LEN_HTTPS;
+tsapi int TS_URL_LEN_MAILTO;
+tsapi int TS_URL_LEN_NEWS;
+tsapi int TS_URL_LEN_NNTP;
+tsapi int TS_URL_LEN_PROSPERO;
+tsapi int TS_URL_LEN_TELNET;
+tsapi int TS_URL_LEN_WAIS;
 
 /* MIME fields */
-inkapi const char *INK_MIME_FIELD_ACCEPT;
-inkapi const char *INK_MIME_FIELD_ACCEPT_CHARSET;
-inkapi const char *INK_MIME_FIELD_ACCEPT_ENCODING;
-inkapi const char *INK_MIME_FIELD_ACCEPT_LANGUAGE;
-inkapi const char *INK_MIME_FIELD_ACCEPT_RANGES;
-inkapi const char *INK_MIME_FIELD_AGE;
-inkapi const char *INK_MIME_FIELD_ALLOW;
-inkapi const char *INK_MIME_FIELD_APPROVED;
-inkapi const char *INK_MIME_FIELD_AUTHORIZATION;
-inkapi const char *INK_MIME_FIELD_BYTES;
-inkapi const char *INK_MIME_FIELD_CACHE_CONTROL;
-inkapi const char *INK_MIME_FIELD_CLIENT_IP;
-inkapi const char *INK_MIME_FIELD_CONNECTION;
-inkapi const char *INK_MIME_FIELD_CONTENT_BASE;
-inkapi const char *INK_MIME_FIELD_CONTENT_ENCODING;
-inkapi const char *INK_MIME_FIELD_CONTENT_LANGUAGE;
-inkapi const char *INK_MIME_FIELD_CONTENT_LENGTH;
-inkapi const char *INK_MIME_FIELD_CONTENT_LOCATION;
-inkapi const char *INK_MIME_FIELD_CONTENT_MD5;
-inkapi const char *INK_MIME_FIELD_CONTENT_RANGE;
-inkapi const char *INK_MIME_FIELD_CONTENT_TYPE;
-inkapi const char *INK_MIME_FIELD_CONTROL;
-inkapi const char *INK_MIME_FIELD_COOKIE;
-inkapi const char *INK_MIME_FIELD_DATE;
-inkapi const char *INK_MIME_FIELD_DISTRIBUTION;
-inkapi const char *INK_MIME_FIELD_ETAG;
-inkapi const char *INK_MIME_FIELD_EXPECT;
-inkapi const char *INK_MIME_FIELD_EXPIRES;
-inkapi const char *INK_MIME_FIELD_FOLLOWUP_TO;
-inkapi const char *INK_MIME_FIELD_FROM;
-inkapi const char *INK_MIME_FIELD_HOST;
-inkapi const char *INK_MIME_FIELD_IF_MATCH;
-inkapi const char *INK_MIME_FIELD_IF_MODIFIED_SINCE;
-inkapi const char *INK_MIME_FIELD_IF_NONE_MATCH;
-inkapi const char *INK_MIME_FIELD_IF_RANGE;
-inkapi const char *INK_MIME_FIELD_IF_UNMODIFIED_SINCE;
-inkapi const char *INK_MIME_FIELD_KEEP_ALIVE;
-inkapi const char *INK_MIME_FIELD_KEYWORDS;
-inkapi const char *INK_MIME_FIELD_LAST_MODIFIED;
-inkapi const char *INK_MIME_FIELD_LINES;
-inkapi const char *INK_MIME_FIELD_LOCATION;
-inkapi const char *INK_MIME_FIELD_MAX_FORWARDS;
-inkapi const char *INK_MIME_FIELD_MESSAGE_ID;
-inkapi const char *INK_MIME_FIELD_NEWSGROUPS;
-inkapi const char *INK_MIME_FIELD_ORGANIZATION;
-inkapi const char *INK_MIME_FIELD_PATH;
-inkapi const char *INK_MIME_FIELD_PRAGMA;
-inkapi const char *INK_MIME_FIELD_PROXY_AUTHENTICATE;
-inkapi const char *INK_MIME_FIELD_PROXY_AUTHORIZATION;
-inkapi const char *INK_MIME_FIELD_PROXY_CONNECTION;
-inkapi const char *INK_MIME_FIELD_PUBLIC;
-inkapi const char *INK_MIME_FIELD_RANGE;
-inkapi const char *INK_MIME_FIELD_REFERENCES;
-inkapi const char *INK_MIME_FIELD_REFERER;
-inkapi const char *INK_MIME_FIELD_REPLY_TO;
-inkapi const char *INK_MIME_FIELD_RETRY_AFTER;
-inkapi const char *INK_MIME_FIELD_SENDER;
-inkapi const char *INK_MIME_FIELD_SERVER;
-inkapi const char *INK_MIME_FIELD_SET_COOKIE;
-inkapi const char *INK_MIME_FIELD_SUBJECT;
-inkapi const char *INK_MIME_FIELD_SUMMARY;
-inkapi const char *INK_MIME_FIELD_TE;
-inkapi const char *INK_MIME_FIELD_TRANSFER_ENCODING;
-inkapi const char *INK_MIME_FIELD_UPGRADE;
-inkapi const char *INK_MIME_FIELD_USER_AGENT;
-inkapi const char *INK_MIME_FIELD_VARY;
-inkapi const char *INK_MIME_FIELD_VIA;
-inkapi const char *INK_MIME_FIELD_WARNING;
-inkapi const char *INK_MIME_FIELD_WWW_AUTHENTICATE;
-inkapi const char *INK_MIME_FIELD_XREF;
-inkapi const char *INK_MIME_FIELD_X_FORWARDED_FOR;
+tsapi const char *TS_MIME_FIELD_ACCEPT;
+tsapi const char *TS_MIME_FIELD_ACCEPT_CHARSET;
+tsapi const char *TS_MIME_FIELD_ACCEPT_ENCODING;
+tsapi const char *TS_MIME_FIELD_ACCEPT_LANGUAGE;
+tsapi const char *TS_MIME_FIELD_ACCEPT_RANGES;
+tsapi const char *TS_MIME_FIELD_AGE;
+tsapi const char *TS_MIME_FIELD_ALLOW;
+tsapi const char *TS_MIME_FIELD_APPROVED;
+tsapi const char *TS_MIME_FIELD_AUTHORIZATION;
+tsapi const char *TS_MIME_FIELD_BYTES;
+tsapi const char *TS_MIME_FIELD_CACHE_CONTROL;
+tsapi const char *TS_MIME_FIELD_CLIENT_IP;
+tsapi const char *TS_MIME_FIELD_CONNECTION;
+tsapi const char *TS_MIME_FIELD_CONTENT_BASE;
+tsapi const char *TS_MIME_FIELD_CONTENT_ENCODING;
+tsapi const char *TS_MIME_FIELD_CONTENT_LANGUAGE;
+tsapi const char *TS_MIME_FIELD_CONTENT_LENGTH;
+tsapi const char *TS_MIME_FIELD_CONTENT_LOCATION;
+tsapi const char *TS_MIME_FIELD_CONTENT_MD5;
+tsapi const char *TS_MIME_FIELD_CONTENT_RANGE;
+tsapi const char *TS_MIME_FIELD_CONTENT_TYPE;
+tsapi const char *TS_MIME_FIELD_CONTROL;
+tsapi const char *TS_MIME_FIELD_COOKIE;
+tsapi const char *TS_MIME_FIELD_DATE;
+tsapi const char *TS_MIME_FIELD_DISTRIBUTION;
+tsapi const char *TS_MIME_FIELD_ETAG;
+tsapi const char *TS_MIME_FIELD_EXPECT;
+tsapi const char *TS_MIME_FIELD_EXPIRES;
+tsapi const char *TS_MIME_FIELD_FOLLOWUP_TO;
+tsapi const char *TS_MIME_FIELD_FROM;
+tsapi const char *TS_MIME_FIELD_HOST;
+tsapi const char *TS_MIME_FIELD_IF_MATCH;
+tsapi const char *TS_MIME_FIELD_IF_MODIFIED_SINCE;
+tsapi const char *TS_MIME_FIELD_IF_NONE_MATCH;
+tsapi const char *TS_MIME_FIELD_IF_RANGE;
+tsapi const char *TS_MIME_FIELD_IF_UNMODIFIED_SINCE;
+tsapi const char *TS_MIME_FIELD_KEEP_ALIVE;
+tsapi const char *TS_MIME_FIELD_KEYWORDS;
+tsapi const char *TS_MIME_FIELD_LAST_MODIFIED;
+tsapi const char *TS_MIME_FIELD_LINES;
+tsapi const char *TS_MIME_FIELD_LOCATION;
+tsapi const char *TS_MIME_FIELD_MAX_FORWARDS;
+tsapi const char *TS_MIME_FIELD_MESSAGE_ID;
+tsapi const char *TS_MIME_FIELD_NEWSGROUPS;
+tsapi const char *TS_MIME_FIELD_ORGANIZATION;
+tsapi const char *TS_MIME_FIELD_PATH;
+tsapi const char *TS_MIME_FIELD_PRAGMA;
+tsapi const char *TS_MIME_FIELD_PROXY_AUTHENTICATE;
+tsapi const char *TS_MIME_FIELD_PROXY_AUTHORIZATION;
+tsapi const char *TS_MIME_FIELD_PROXY_CONNECTION;
+tsapi const char *TS_MIME_FIELD_PUBLIC;
+tsapi const char *TS_MIME_FIELD_RANGE;
+tsapi const char *TS_MIME_FIELD_REFERENCES;
+tsapi const char *TS_MIME_FIELD_REFERER;
+tsapi const char *TS_MIME_FIELD_REPLY_TO;
+tsapi const char *TS_MIME_FIELD_RETRY_AFTER;
+tsapi const char *TS_MIME_FIELD_SENDER;
+tsapi const char *TS_MIME_FIELD_SERVER;
+tsapi const char *TS_MIME_FIELD_SET_COOKIE;
+tsapi const char *TS_MIME_FIELD_SUBJECT;
+tsapi const char *TS_MIME_FIELD_SUMMARY;
+tsapi const char *TS_MIME_FIELD_TE;
+tsapi const char *TS_MIME_FIELD_TRANSFER_ENCODING;
+tsapi const char *TS_MIME_FIELD_UPGRADE;
+tsapi const char *TS_MIME_FIELD_USER_AGENT;
+tsapi const char *TS_MIME_FIELD_VARY;
+tsapi const char *TS_MIME_FIELD_VIA;
+tsapi const char *TS_MIME_FIELD_WARNING;
+tsapi const char *TS_MIME_FIELD_WWW_AUTHENTICATE;
+tsapi const char *TS_MIME_FIELD_XREF;
+tsapi const char *TS_MIME_FIELD_X_FORWARDED_FOR;
 
 /* MIME fields string lengths */
-inkapi int INK_MIME_LEN_ACCEPT;
-inkapi int INK_MIME_LEN_ACCEPT_CHARSET;
-inkapi int INK_MIME_LEN_ACCEPT_ENCODING;
-inkapi int INK_MIME_LEN_ACCEPT_LANGUAGE;
-inkapi int INK_MIME_LEN_ACCEPT_RANGES;
-inkapi int INK_MIME_LEN_AGE;
-inkapi int INK_MIME_LEN_ALLOW;
-inkapi int INK_MIME_LEN_APPROVED;
-inkapi int INK_MIME_LEN_AUTHORIZATION;
-inkapi int INK_MIME_LEN_BYTES;
-inkapi int INK_MIME_LEN_CACHE_CONTROL;
-inkapi int INK_MIME_LEN_CLIENT_IP;
-inkapi int INK_MIME_LEN_CONNECTION;
-inkapi int INK_MIME_LEN_CONTENT_BASE;
-inkapi int INK_MIME_LEN_CONTENT_ENCODING;
-inkapi int INK_MIME_LEN_CONTENT_LANGUAGE;
-inkapi int INK_MIME_LEN_CONTENT_LENGTH;
-inkapi int INK_MIME_LEN_CONTENT_LOCATION;
-inkapi int INK_MIME_LEN_CONTENT_MD5;
-inkapi int INK_MIME_LEN_CONTENT_RANGE;
-inkapi int INK_MIME_LEN_CONTENT_TYPE;
-inkapi int INK_MIME_LEN_CONTROL;
-inkapi int INK_MIME_LEN_COOKIE;
-inkapi int INK_MIME_LEN_DATE;
-inkapi int INK_MIME_LEN_DISTRIBUTION;
-inkapi int INK_MIME_LEN_ETAG;
-inkapi int INK_MIME_LEN_EXPECT;
-inkapi int INK_MIME_LEN_EXPIRES;
-inkapi int INK_MIME_LEN_FOLLOWUP_TO;
-inkapi int INK_MIME_LEN_FROM;
-inkapi int INK_MIME_LEN_HOST;
-inkapi int INK_MIME_LEN_IF_MATCH;
-inkapi int INK_MIME_LEN_IF_MODIFIED_SINCE;
-inkapi int INK_MIME_LEN_IF_NONE_MATCH;
-inkapi int INK_MIME_LEN_IF_RANGE;
-inkapi int INK_MIME_LEN_IF_UNMODIFIED_SINCE;
-inkapi int INK_MIME_LEN_KEEP_ALIVE;
-inkapi int INK_MIME_LEN_KEYWORDS;
-inkapi int INK_MIME_LEN_LAST_MODIFIED;
-inkapi int INK_MIME_LEN_LINES;
-inkapi int INK_MIME_LEN_LOCATION;
-inkapi int INK_MIME_LEN_MAX_FORWARDS;
-inkapi int INK_MIME_LEN_MESSAGE_ID;
-inkapi int INK_MIME_LEN_NEWSGROUPS;
-inkapi int INK_MIME_LEN_ORGANIZATION;
-inkapi int INK_MIME_LEN_PATH;
-inkapi int INK_MIME_LEN_PRAGMA;
-inkapi int INK_MIME_LEN_PROXY_AUTHENTICATE;
-inkapi int INK_MIME_LEN_PROXY_AUTHORIZATION;
-inkapi int INK_MIME_LEN_PROXY_CONNECTION;
-inkapi int INK_MIME_LEN_PUBLIC;
-inkapi int INK_MIME_LEN_RANGE;
-inkapi int INK_MIME_LEN_REFERENCES;
-inkapi int INK_MIME_LEN_REFERER;
-inkapi int INK_MIME_LEN_REPLY_TO;
-inkapi int INK_MIME_LEN_RETRY_AFTER;
-inkapi int INK_MIME_LEN_SENDER;
-inkapi int INK_MIME_LEN_SERVER;
-inkapi int INK_MIME_LEN_SET_COOKIE;
-inkapi int INK_MIME_LEN_SUBJECT;
-inkapi int INK_MIME_LEN_SUMMARY;
-inkapi int INK_MIME_LEN_TE;
-inkapi int INK_MIME_LEN_TRANSFER_ENCODING;
-inkapi int INK_MIME_LEN_UPGRADE;
-inkapi int INK_MIME_LEN_USER_AGENT;
-inkapi int INK_MIME_LEN_VARY;
-inkapi int INK_MIME_LEN_VIA;
-inkapi int INK_MIME_LEN_WARNING;
-inkapi int INK_MIME_LEN_WWW_AUTHENTICATE;
-inkapi int INK_MIME_LEN_XREF;
-inkapi int INK_MIME_LEN_X_FORWARDED_FOR;
+tsapi int TS_MIME_LEN_ACCEPT;
+tsapi int TS_MIME_LEN_ACCEPT_CHARSET;
+tsapi int TS_MIME_LEN_ACCEPT_ENCODING;
+tsapi int TS_MIME_LEN_ACCEPT_LANGUAGE;
+tsapi int TS_MIME_LEN_ACCEPT_RANGES;
+tsapi int TS_MIME_LEN_AGE;
+tsapi int TS_MIME_LEN_ALLOW;
+tsapi int TS_MIME_LEN_APPROVED;
+tsapi int TS_MIME_LEN_AUTHORIZATION;
+tsapi int TS_MIME_LEN_BYTES;
+tsapi int TS_MIME_LEN_CACHE_CONTROL;
+tsapi int TS_MIME_LEN_CLIENT_IP;
+tsapi int TS_MIME_LEN_CONNECTION;
+tsapi int TS_MIME_LEN_CONTENT_BASE;
+tsapi int TS_MIME_LEN_CONTENT_ENCODING;
+tsapi int TS_MIME_LEN_CONTENT_LANGUAGE;
+tsapi int TS_MIME_LEN_CONTENT_LENGTH;
+tsapi int TS_MIME_LEN_CONTENT_LOCATION;
+tsapi int TS_MIME_LEN_CONTENT_MD5;
+tsapi int TS_MIME_LEN_CONTENT_RANGE;
+tsapi int TS_MIME_LEN_CONTENT_TYPE;
+tsapi int TS_MIME_LEN_CONTROL;
+tsapi int TS_MIME_LEN_COOKIE;
+tsapi int TS_MIME_LEN_DATE;
+tsapi int TS_MIME_LEN_DISTRIBUTION;
+tsapi int TS_MIME_LEN_ETAG;
+tsapi int TS_MIME_LEN_EXPECT;
+tsapi int TS_MIME_LEN_EXPIRES;
+tsapi int TS_MIME_LEN_FOLLOWUP_TO;
+tsapi int TS_MIME_LEN_FROM;
+tsapi int TS_MIME_LEN_HOST;
+tsapi int TS_MIME_LEN_IF_MATCH;
+tsapi int TS_MIME_LEN_IF_MODIFIED_SINCE;
+tsapi int TS_MIME_LEN_IF_NONE_MATCH;
+tsapi int TS_MIME_LEN_IF_RANGE;
+tsapi int TS_MIME_LEN_IF_UNMODIFIED_SINCE;
+tsapi int TS_MIME_LEN_KEEP_ALIVE;
+tsapi int TS_MIME_LEN_KEYWORDS;
+tsapi int TS_MIME_LEN_LAST_MODIFIED;
+tsapi int TS_MIME_LEN_LINES;
+tsapi int TS_MIME_LEN_LOCATION;
+tsapi int TS_MIME_LEN_MAX_FORWARDS;
+tsapi int TS_MIME_LEN_MESSAGE_ID;
+tsapi int TS_MIME_LEN_NEWSGROUPS;
+tsapi int TS_MIME_LEN_ORGANIZATION;
+tsapi int TS_MIME_LEN_PATH;
+tsapi int TS_MIME_LEN_PRAGMA;
+tsapi int TS_MIME_LEN_PROXY_AUTHENTICATE;
+tsapi int TS_MIME_LEN_PROXY_AUTHORIZATION;
+tsapi int TS_MIME_LEN_PROXY_CONNECTION;
+tsapi int TS_MIME_LEN_PUBLIC;
+tsapi int TS_MIME_LEN_RANGE;
+tsapi int TS_MIME_LEN_REFERENCES;
+tsapi int TS_MIME_LEN_REFERER;
+tsapi int TS_MIME_LEN_REPLY_TO;
+tsapi int TS_MIME_LEN_RETRY_AFTER;
+tsapi int TS_MIME_LEN_SENDER;
+tsapi int TS_MIME_LEN_SERVER;
+tsapi int TS_MIME_LEN_SET_COOKIE;
+tsapi int TS_MIME_LEN_SUBJECT;
+tsapi int TS_MIME_LEN_SUMMARY;
+tsapi int TS_MIME_LEN_TE;
+tsapi int TS_MIME_LEN_TRANSFER_ENCODING;
+tsapi int TS_MIME_LEN_UPGRADE;
+tsapi int TS_MIME_LEN_USER_AGENT;
+tsapi int TS_MIME_LEN_VARY;
+tsapi int TS_MIME_LEN_VIA;
+tsapi int TS_MIME_LEN_WARNING;
+tsapi int TS_MIME_LEN_WWW_AUTHENTICATE;
+tsapi int TS_MIME_LEN_XREF;
+tsapi int TS_MIME_LEN_X_FORWARDED_FOR;
 
 
 /* HTTP miscellaneous values */
-inkapi const char *INK_HTTP_VALUE_BYTES;
-inkapi const char *INK_HTTP_VALUE_CHUNKED;
-inkapi const char *INK_HTTP_VALUE_CLOSE;
-inkapi const char *INK_HTTP_VALUE_COMPRESS;
-inkapi const char *INK_HTTP_VALUE_DEFLATE;
-inkapi const char *INK_HTTP_VALUE_GZIP;
-inkapi const char *INK_HTTP_VALUE_IDENTITY;
-inkapi const char *INK_HTTP_VALUE_KEEP_ALIVE;
-inkapi const char *INK_HTTP_VALUE_MAX_AGE;
-inkapi const char *INK_HTTP_VALUE_MAX_STALE;
-inkapi const char *INK_HTTP_VALUE_MIN_FRESH;
-inkapi const char *INK_HTTP_VALUE_MUST_REVALIDATE;
-inkapi const char *INK_HTTP_VALUE_NONE;
-inkapi const char *INK_HTTP_VALUE_NO_CACHE;
-inkapi const char *INK_HTTP_VALUE_NO_STORE;
-inkapi const char *INK_HTTP_VALUE_NO_TRANSFORM;
-inkapi const char *INK_HTTP_VALUE_ONLY_IF_CACHED;
-inkapi const char *INK_HTTP_VALUE_PRIVATE;
-inkapi const char *INK_HTTP_VALUE_PROXY_REVALIDATE;
-inkapi const char *INK_HTTP_VALUE_PUBLIC;
-inkapi const char *INK_HTTP_VALUE_SMAX_AGE;
-inkapi const char *INK_HTTP_VALUE_S_MAXAGE;
+tsapi const char *TS_HTTP_VALUE_BYTES;
+tsapi const char *TS_HTTP_VALUE_CHUNKED;
+tsapi const char *TS_HTTP_VALUE_CLOSE;
+tsapi const char *TS_HTTP_VALUE_COMPRESS;
+tsapi const char *TS_HTTP_VALUE_DEFLATE;
+tsapi const char *TS_HTTP_VALUE_GZIP;
+tsapi const char *TS_HTTP_VALUE_IDENTITY;
+tsapi const char *TS_HTTP_VALUE_KEEP_ALIVE;
+tsapi const char *TS_HTTP_VALUE_MAX_AGE;
+tsapi const char *TS_HTTP_VALUE_MAX_STALE;
+tsapi const char *TS_HTTP_VALUE_MIN_FRESH;
+tsapi const char *TS_HTTP_VALUE_MUST_REVALIDATE;
+tsapi const char *TS_HTTP_VALUE_NONE;
+tsapi const char *TS_HTTP_VALUE_NO_CACHE;
+tsapi const char *TS_HTTP_VALUE_NO_STORE;
+tsapi const char *TS_HTTP_VALUE_NO_TRANSFORM;
+tsapi const char *TS_HTTP_VALUE_ONLY_IF_CACHED;
+tsapi const char *TS_HTTP_VALUE_PRIVATE;
+tsapi const char *TS_HTTP_VALUE_PROXY_REVALIDATE;
+tsapi const char *TS_HTTP_VALUE_PUBLIC;
+tsapi const char *TS_HTTP_VALUE_S_MAXAGE;
 
 /* HTTP miscellaneous values string lengths */
-inkapi int INK_HTTP_LEN_BYTES;
-inkapi int INK_HTTP_LEN_CHUNKED;
-inkapi int INK_HTTP_LEN_CLOSE;
-inkapi int INK_HTTP_LEN_COMPRESS;
-inkapi int INK_HTTP_LEN_DEFLATE;
-inkapi int INK_HTTP_LEN_GZIP;
-inkapi int INK_HTTP_LEN_IDENTITY;
-inkapi int INK_HTTP_LEN_KEEP_ALIVE;
-inkapi int INK_HTTP_LEN_MAX_AGE;
-inkapi int INK_HTTP_LEN_MAX_STALE;
-inkapi int INK_HTTP_LEN_MIN_FRESH;
-inkapi int INK_HTTP_LEN_MUST_REVALIDATE;
-inkapi int INK_HTTP_LEN_NONE;
-inkapi int INK_HTTP_LEN_NO_CACHE;
-inkapi int INK_HTTP_LEN_NO_STORE;
-inkapi int INK_HTTP_LEN_NO_TRANSFORM;
-inkapi int INK_HTTP_LEN_ONLY_IF_CACHED;
-inkapi int INK_HTTP_LEN_PRIVATE;
-inkapi int INK_HTTP_LEN_PROXY_REVALIDATE;
-inkapi int INK_HTTP_LEN_PUBLIC;
-inkapi int INK_HTTP_LEN_SMAX_AGE;
-inkapi int INK_HTTP_LEN_S_MAXAGE;
+tsapi int TS_HTTP_LEN_BYTES;
+tsapi int TS_HTTP_LEN_CHUNKED;
+tsapi int TS_HTTP_LEN_CLOSE;
+tsapi int TS_HTTP_LEN_COMPRESS;
+tsapi int TS_HTTP_LEN_DEFLATE;
+tsapi int TS_HTTP_LEN_GZIP;
+tsapi int TS_HTTP_LEN_IDENTITY;
+tsapi int TS_HTTP_LEN_KEEP_ALIVE;
+tsapi int TS_HTTP_LEN_MAX_AGE;
+tsapi int TS_HTTP_LEN_MAX_STALE;
+tsapi int TS_HTTP_LEN_MIN_FRESH;
+tsapi int TS_HTTP_LEN_MUST_REVALIDATE;
+tsapi int TS_HTTP_LEN_NONE;
+tsapi int TS_HTTP_LEN_NO_CACHE;
+tsapi int TS_HTTP_LEN_NO_STORE;
+tsapi int TS_HTTP_LEN_NO_TRANSFORM;
+tsapi int TS_HTTP_LEN_ONLY_IF_CACHED;
+tsapi int TS_HTTP_LEN_PRIVATE;
+tsapi int TS_HTTP_LEN_PROXY_REVALIDATE;
+tsapi int TS_HTTP_LEN_PUBLIC;
+tsapi int TS_HTTP_LEN_S_MAXAGE;
 
 /* HTTP methods */
-inkapi const char *INK_HTTP_METHOD_CONNECT;
-inkapi const char *INK_HTTP_METHOD_DELETE;
-inkapi const char *INK_HTTP_METHOD_GET;
-inkapi const char *INK_HTTP_METHOD_HEAD;
-inkapi const char *INK_HTTP_METHOD_ICP_QUERY;
-inkapi const char *INK_HTTP_METHOD_OPTIONS;
-inkapi const char *INK_HTTP_METHOD_POST;
-inkapi const char *INK_HTTP_METHOD_PURGE;
-inkapi const char *INK_HTTP_METHOD_PUT;
-inkapi const char *INK_HTTP_METHOD_TRACE;
+tsapi const char *TS_HTTP_METHOD_CONNECT;
+tsapi const char *TS_HTTP_METHOD_DELETE;
+tsapi const char *TS_HTTP_METHOD_GET;
+tsapi const char *TS_HTTP_METHOD_HEAD;
+tsapi const char *TS_HTTP_METHOD_ICP_QUERY;
+tsapi const char *TS_HTTP_METHOD_OPTIONS;
+tsapi const char *TS_HTTP_METHOD_POST;
+tsapi const char *TS_HTTP_METHOD_PURGE;
+tsapi const char *TS_HTTP_METHOD_PUT;
+tsapi const char *TS_HTTP_METHOD_TRACE;
 
 /* HTTP methods string lengths */
-inkapi int INK_HTTP_LEN_CONNECT;
-inkapi int INK_HTTP_LEN_DELETE;
-inkapi int INK_HTTP_LEN_GET;
-inkapi int INK_HTTP_LEN_HEAD;
-inkapi int INK_HTTP_LEN_ICP_QUERY;
-inkapi int INK_HTTP_LEN_OPTIONS;
-inkapi int INK_HTTP_LEN_POST;
-inkapi int INK_HTTP_LEN_PURGE;
-inkapi int INK_HTTP_LEN_PUT;
-inkapi int INK_HTTP_LEN_TRACE;
+tsapi int TS_HTTP_LEN_CONNECT;
+tsapi int TS_HTTP_LEN_DELETE;
+tsapi int TS_HTTP_LEN_GET;
+tsapi int TS_HTTP_LEN_HEAD;
+tsapi int TS_HTTP_LEN_ICP_QUERY;
+tsapi int TS_HTTP_LEN_OPTIONS;
+tsapi int TS_HTTP_LEN_POST;
+tsapi int TS_HTTP_LEN_PURGE;
+tsapi int TS_HTTP_LEN_PUT;
+tsapi int TS_HTTP_LEN_TRACE;
 
 /* MLoc Constants */
-inkapi const INKMLoc INK_NULL_MLOC = (INKMLoc) NULL;
+tsapi const TSMLoc TS_NULL_MLOC = (TSMLoc)NULL;
 
 HttpAPIHooks *http_global_hooks = NULL;
-CacheAPIHooks *cache_global_hooks = NULL;
 ConfigUpdateCbTable *global_config_cbs = NULL;
 
 static char traffic_server_version[128] = "";
@@ -390,16 +360,15 @@ static ClassAllocator<INKContInternal> I
 static ClassAllocator<INKVConnInternal> INKVConnAllocator("INKVConnAllocator");
 
 // Error Ptr.
-inkapi const void *INK_ERROR_PTR = (const void *) 0x00000bad;
+tsapi const void *TS_ERROR_PTR = (const void *) 0x00000bad;
 
 ////////////////////////////////////////////////////////////////////
 //
 // API error logging
 //
 ////////////////////////////////////////////////////////////////////
-
 void
-INKError(const char *fmt, ...)
+TSError(const char *fmt, ...)
 {
   va_list args;
 
@@ -415,15 +384,15 @@ INKError(const char *fmt, ...)
 
 // Assert in debug AND optim
 int
-_INKReleaseAssert(const char *text, const char *file, int line)
+_TSReleaseAssert(const char *text, const char *file, int line)
 {
   _ink_assert(text, file, line);
-  return (0);
+  return 0;
 }
 
 // Assert only in debug
 int
-_INKAssert(const char *text, const char *file, int line)
+_TSAssert(const char *text, const char *file, int line)
 {
 #ifdef DEBUG
   _ink_assert(text, file, line);
@@ -433,7 +402,7 @@ _INKAssert(const char *text, const char 
   NOWARN_UNUSED(line);
 #endif
 
-  return (0);
+  return 0;
 }
 
 ////////////////////////////////////////////////////////////////////
@@ -501,224 +470,222 @@ _hdr_obj_to_mime_hdr_impl(HdrHeapObjImpl
     ink_release_assert(!"mloc not a header type");
     impl = NULL;                /* gcc does not know about 'ink_release_assert' - make him happy */
   }
-  return (impl);
+  return impl;
 }
 
 inline MIMEHdrImpl *
-_hdr_mloc_to_mime_hdr_impl(INKMLoc mloc)
+_hdr_mloc_to_mime_hdr_impl(TSMLoc mloc)
 {
-  return (_hdr_obj_to_mime_hdr_impl((HdrHeapObjImpl *) mloc));
+  return _hdr_obj_to_mime_hdr_impl((HdrHeapObjImpl *) mloc);
 }
 
-inline INKReturnCode
-sdk_sanity_check_field_handle(INKMLoc field, INKMLoc parent_hdr = NULL)
+inline TSReturnCode
+sdk_sanity_check_field_handle(TSMLoc field, TSMLoc parent_hdr = NULL)
 {
 #ifdef DEBUG
-  if ((field == INK_NULL_MLOC) || (field == INK_ERROR_PTR)) {
-    return INK_ERROR;
+  if ((field == TS_NULL_MLOC) || (field == TS_ERROR_PTR)) {
+    return TS_ERROR;
   }
   MIMEFieldSDKHandle *field_handle = (MIMEFieldSDKHandle *) field;
   if (field_handle->m_type != HDR_HEAP_OBJ_FIELD_SDK_HANDLE) {
-    return INK_ERROR;
+    return TS_ERROR;
   }
   if (parent_hdr != NULL) {
     MIMEHdrImpl *mh = _hdr_mloc_to_mime_hdr_impl(parent_hdr);
     if (field_handle->mh != mh) {
-      return INK_ERROR;
+      return TS_ERROR;
     }
   }
-  return INK_SUCCESS;
+  return TS_SUCCESS;
 #else
   NOWARN_UNUSED(field);
   NOWARN_UNUSED(parent_hdr);
-  return INK_SUCCESS;
+  return TS_SUCCESS;
 #endif
 }
 
-inline INKReturnCode
-sdk_sanity_check_mbuffer(INKMBuffer bufp)
+inline TSReturnCode
+sdk_sanity_check_mbuffer(TSMBuffer bufp)
 {
 #ifdef DEBUG
   HdrHeapSDKHandle *handle = (HdrHeapSDKHandle *) bufp;
   if ((handle == NULL) ||
-      (handle == INK_ERROR_PTR) || (handle->m_heap == NULL) || (handle->m_heap->m_magic != HDR_BUF_MAGIC_ALIVE)
-    ) {
-    return INK_ERROR;
+      (handle == TS_ERROR_PTR) || (handle->m_heap == NULL) || (handle->m_heap->m_magic != HDR_BUF_MAGIC_ALIVE)) {
+    return TS_ERROR;
   }
-  return INK_SUCCESS;
+  return TS_SUCCESS;
 #else
   NOWARN_UNUSED(bufp);
-  return INK_SUCCESS;
+  return TS_SUCCESS;
 #endif
 }
 
-INKReturnCode
-sdk_sanity_check_mime_hdr_handle(INKMLoc field)
+TSReturnCode
+sdk_sanity_check_mime_hdr_handle(TSMLoc field)
 {
 #ifdef DEBUG
-  if ((field == INK_NULL_MLOC) || (field == INK_ERROR_PTR)) {
-    return INK_ERROR;
+  if ((field == TS_NULL_MLOC) || (field == TS_ERROR_PTR)) {
+    return TS_ERROR;
   }
   MIMEFieldSDKHandle *field_handle = (MIMEFieldSDKHandle *) field;
   if (field_handle->m_type != HDR_HEAP_OBJ_MIME_HEADER) {
-    return INK_ERROR;
+    return TS_ERROR;
   }
-  return INK_SUCCESS;
+  return TS_SUCCESS;
 #else
   NOWARN_UNUSED(field);
-  return INK_SUCCESS;
+  return TS_SUCCESS;
 #endif
 }
 
-INKReturnCode
-sdk_sanity_check_url_handle(INKMLoc field)
+TSReturnCode
+sdk_sanity_check_url_handle(TSMLoc field)
 {
 #ifdef DEBUG
-  if ((field == INK_NULL_MLOC) || (field == INK_ERROR_PTR)) {
-    return INK_ERROR;
+  if ((field == TS_NULL_MLOC) || (field == TS_ERROR_PTR)) {
+    return TS_ERROR;
   }
   MIMEFieldSDKHandle *field_handle = (MIMEFieldSDKHandle *) field;
   if (field_handle->m_type != HDR_HEAP_OBJ_URL) {
-    return INK_ERROR;
+    return TS_ERROR;
   }
-  return INK_SUCCESS;
+  return TS_SUCCESS;
 #else
   NOWARN_UNUSED(field);
-  return INK_SUCCESS;
+  return TS_SUCCESS;
 #endif
 }
 
-inline INKReturnCode
-sdk_sanity_check_http_hdr_handle(INKMLoc field)
+inline TSReturnCode
+sdk_sanity_check_http_hdr_handle(TSMLoc field)
 {
 #ifdef DEBUG
-  if ((field == INK_NULL_MLOC) || (field == INK_ERROR_PTR)) {
-    return INK_ERROR;
+  if ((field == TS_NULL_MLOC) || (field == TS_ERROR_PTR)) {
+    return TS_ERROR;
   }
   HTTPHdrImpl *field_handle = (HTTPHdrImpl *) field;
   if (field_handle->m_type != HDR_HEAP_OBJ_HTTP_HEADER) {
-    return INK_ERROR;
+    return TS_ERROR;
   }
-  return INK_SUCCESS;
+  return TS_SUCCESS;
 #else
   NOWARN_UNUSED(field);
-  return INK_SUCCESS;
+  return TS_SUCCESS;
 #endif
 }
 
-inline INKReturnCode
-sdk_sanity_check_continuation(INKCont cont)
+inline TSReturnCode
+sdk_sanity_check_continuation(TSCont cont)
 {
 #ifdef DEBUG
-  if ((cont != NULL) && (cont != INK_ERROR_PTR) &&
+  if ((cont != NULL) && (cont != TS_ERROR_PTR) &&
       (((INKContInternal *) cont)->m_free_magic != INKCONT_INTERN_MAGIC_DEAD)) {
-    return INK_SUCCESS;
+    return TS_SUCCESS;
   } else {
-    return INK_ERROR;
+    return TS_ERROR;
   }
 #else
   NOWARN_UNUSED(cont);
-  return INK_SUCCESS;
+  return TS_SUCCESS;
 #endif
 }
 
-inline INKReturnCode
-sdk_sanity_check_http_ssn(INKHttpSsn ssnp)
+inline TSReturnCode
+sdk_sanity_check_http_ssn(TSHttpSsn ssnp)
 {
 #ifdef DEBUG
-  if ((ssnp != NULL) && (ssnp != INK_ERROR_PTR)) {
-    return INK_SUCCESS;
+  if ((ssnp != NULL) && (ssnp != TS_ERROR_PTR)) {
+    return TS_SUCCESS;
   } else {
-    return INK_ERROR;
+    return TS_ERROR;
   }
 #else
   NOWARN_UNUSED(ssnp);
-  return INK_SUCCESS;
+  return TS_SUCCESS;
 #endif
 }
 
-inline INKReturnCode
-sdk_sanity_check_txn(INKHttpTxn txnp)
+inline TSReturnCode
+sdk_sanity_check_txn(TSHttpTxn txnp)
 {
 #ifdef DEBUG
-  if ((txnp != NULL) && (txnp != INK_ERROR_PTR) && (((HttpSM *) txnp)->magic == HTTP_SM_MAGIC_ALIVE)
-    ) {
-    return INK_SUCCESS;
+  if ((txnp != NULL) && (txnp != TS_ERROR_PTR) && (((HttpSM *) txnp)->magic == HTTP_SM_MAGIC_ALIVE)) {
+    return TS_SUCCESS;
   } else {
-    return INK_ERROR;
+    return TS_ERROR;
   }
 #else
   NOWARN_UNUSED(txnp);
-  return INK_SUCCESS;
+  return TS_SUCCESS;
 #endif
 }
 
-inline INKReturnCode
-sdk_sanity_check_mime_parser(INKMimeParser parser)
+inline TSReturnCode
+sdk_sanity_check_mime_parser(TSMimeParser parser)
 {
 #ifdef DEBUG
-  if ((parser != NULL) && (parser != INK_ERROR_PTR)) {
-    return INK_SUCCESS;
+  if ((parser != NULL) && (parser != TS_ERROR_PTR)) {
+    return TS_SUCCESS;
   } else {
-    return INK_ERROR;
+    return TS_ERROR;
   }
 #endif
   NOWARN_UNUSED(parser);
-  return INK_SUCCESS;
+  return TS_SUCCESS;
 }
 
-inline INKReturnCode
-sdk_sanity_check_http_parser(INKHttpParser parser)
+inline TSReturnCode
+sdk_sanity_check_http_parser(TSHttpParser parser)
 {
 #ifdef DEBUG
-  if ((parser != NULL) && (parser != INK_ERROR_PTR)) {
-    return INK_SUCCESS;
+  if ((parser != NULL) && (parser != TS_ERROR_PTR)) {
+    return TS_SUCCESS;
   } else {
-    return INK_ERROR;
+    return TS_ERROR;
   }
 #endif
   NOWARN_UNUSED(parser);
-  return INK_SUCCESS;
+  return TS_SUCCESS;
 }
 
-inline INKReturnCode
-sdk_sanity_check_alt_info(INKHttpAltInfo info)
+inline TSReturnCode
+sdk_sanity_check_alt_info(TSHttpAltInfo info)
 {
 #ifdef DEBUG
-  if ((info != NULL) && (info != INK_ERROR_PTR)) {
-    return INK_SUCCESS;
+  if ((info != NULL) && (info != TS_ERROR_PTR)) {
+    return TS_SUCCESS;
   } else {
-    return INK_ERROR;
+    return TS_ERROR;
   }
 #endif
   NOWARN_UNUSED(info);
-  return INK_SUCCESS;
+  return TS_SUCCESS;
 }
 
-inline INKReturnCode
-sdk_sanity_check_hook_id(INKHttpHookID id)
+inline TSReturnCode
+sdk_sanity_check_hook_id(TSHttpHookID id)
 {
 #ifdef DEBUG
-  if (id<INK_HTTP_READ_REQUEST_HDR_HOOK || id> INK_HTTP_LAST_HOOK)
-    return INK_ERROR;
-  return INK_SUCCESS;
+  if (id<TS_HTTP_READ_REQUEST_HDR_HOOK || id> TS_HTTP_LAST_HOOK)
+    return TS_ERROR;
+  return TS_SUCCESS;
 #else
   NOWARN_UNUSED(id);
-  return INK_SUCCESS;
+  return TS_SUCCESS;
 #endif
 }
 
 
-inline INKReturnCode
+inline TSReturnCode
 sdk_sanity_check_null_ptr(void *ptr)
 {
 #ifdef DEBUG
   if (ptr == NULL)
-    return INK_ERROR;
-  return INK_SUCCESS;
+    return TS_ERROR;
+  return TS_SUCCESS;
 #else
   NOWARN_UNUSED(ptr);
-  return INK_SUCCESS;
+  return TS_SUCCESS;
 #endif
 }
 
@@ -728,13 +695,12 @@ sdk_sanity_check_null_ptr(void *ptr)
 
 */
 bool
-isWriteable(INKMBuffer bufp)
+isWriteable(TSMBuffer bufp)
 {
   if (bufp != NULL) {
-    return (((HdrHeapSDKHandle *) bufp)->m_heap->m_writeable);
-  } else {
-    return false;
+    return ((HdrHeapSDKHandle *) bufp)->m_heap->m_writeable;
   }
+  return false;
 }
 
 
@@ -743,50 +709,44 @@ isWriteable(INKMBuffer bufp)
 /******************************************************/
 
 static MIMEFieldSDKHandle *
-sdk_alloc_field_handle(INKMBuffer bufp, MIMEHdrImpl *mh)
+sdk_alloc_field_handle(TSMBuffer bufp, MIMEHdrImpl *mh)
 {
-  sdk_sanity_check_mbuffer(bufp);
-  HdrHeapSDKHandle *sdk_heap = (HdrHeapSDKHandle *) bufp;
+  if (sdk_sanity_check_mbuffer(bufp) == TS_SUCCESS) {
+    HdrHeapSDKHandle *sdk_heap = (HdrHeapSDKHandle *) bufp;
 
-  MIMEFieldSDKHandle *handle = sdk_heap->m_sdk_alloc.allocate_mhandle();
-  obj_init_header(handle, HDR_HEAP_OBJ_FIELD_SDK_HANDLE, sizeof(MIMEFieldSDKHandle), 0);
-  handle->mh = mh;
-  return (handle);
+    MIMEFieldSDKHandle *handle = sdk_heap->m_sdk_alloc.allocate_mhandle();
+    obj_init_header(handle, HDR_HEAP_OBJ_FIELD_SDK_HANDLE, sizeof(MIMEFieldSDKHandle), 0);
+    handle->mh = mh;
+    return handle;
+  }
+  return NULL;
 }
 
 static void
-sdk_free_field_handle(INKMBuffer bufp, MIMEFieldSDKHandle *field_handle)
+sdk_free_field_handle(TSMBuffer bufp, MIMEFieldSDKHandle *field_handle)
 {
-  sdk_sanity_check_mbuffer(bufp);
-  HdrHeapSDKHandle *sdk_heap = (HdrHeapSDKHandle *) bufp;
-  field_handle->m_type = HDR_HEAP_OBJ_EMPTY;
-  field_handle->mh = NULL;
-  field_handle->field_ptr = NULL;
-
-  sdk_heap->m_sdk_alloc.free_mhandle(field_handle);
-}
+  if (sdk_sanity_check_mbuffer(bufp) == TS_SUCCESS) {
+    HdrHeapSDKHandle *sdk_heap = (HdrHeapSDKHandle *) bufp;
 
-static MIMEField *
-sdk_alloc_standalone_field(INKMBuffer bufp)
-{
-  sdk_sanity_check_mbuffer(bufp);
-  HdrHeapSDKHandle *sdk_heap = (HdrHeapSDKHandle *) bufp;
+    field_handle->m_type = HDR_HEAP_OBJ_EMPTY;
+    field_handle->mh = NULL;
+    field_handle->field_ptr = NULL;
 
-  MIMEField *sa_field = sdk_heap->m_sdk_alloc.allocate_mfield();
-  return (sa_field);
+    sdk_heap->m_sdk_alloc.free_mhandle(field_handle);
+  }
 }
 
 static void
-sdk_free_standalone_field(INKMBuffer bufp, MIMEField *sa_field)
+sdk_free_standalone_field(TSMBuffer bufp, MIMEField *sa_field)
 {
-  sdk_sanity_check_mbuffer(bufp);
-  HdrHeapSDKHandle *sdk_heap = (HdrHeapSDKHandle *) bufp;
-
-  // FIX: can remove memset once debugged --- only here to help catch bugs
-  memset(sa_field, NUL, sizeof(MIMEField));
-  sa_field->m_readiness = MIME_FIELD_SLOT_READINESS_DELETED;
+  if (sdk_sanity_check_mbuffer(bufp) == TS_SUCCESS) {
+    HdrHeapSDKHandle *sdk_heap = (HdrHeapSDKHandle *) bufp;
 
-  sdk_heap->m_sdk_alloc.free_mfield(sa_field);
+    // TODO/ FIX: can remove memset once debugged --- only here to help catch bugs
+    // memset(sa_field, NUL, sizeof(MIMEField));
+    sa_field->m_readiness = MIME_FIELD_SLOT_READINESS_DELETED;
+    sdk_heap->m_sdk_alloc.free_mfield(sa_field);
+  }
 }
 
 ////////////////////////////////////////////////////////////////////
@@ -1025,21 +985,21 @@ FileImpl::fgets(char *buf, int length)
 ////////////////////////////////////////////////////////////////////
 
 INKContInternal::INKContInternal()
-:DummyVConnection(NULL), mdata(NULL), m_event_func(NULL), m_event_count(0), m_closed(1), m_deletable(0), m_deleted(0),
-  m_free_magic(INKCONT_INTERN_MAGIC_ALIVE)
+ : DummyVConnection(NULL), mdata(NULL), m_event_func(NULL), m_event_count(0), m_closed(1), m_deletable(0), m_deleted(0),
+   m_free_magic(INKCONT_INTERN_MAGIC_ALIVE)
 {
 }
 
-INKContInternal::INKContInternal(INKEventFunc funcp, INKMutex mutexp)
-:DummyVConnection((ProxyMutex *) mutexp),
-mdata(NULL), m_event_func(funcp), m_event_count(0), m_closed(1), m_deletable(0), m_deleted(0),
-  m_free_magic(INKCONT_INTERN_MAGIC_ALIVE)
+INKContInternal::INKContInternal(TSEventFunc funcp, TSMutex mutexp)
+ : DummyVConnection((ProxyMutex *) mutexp),
+   mdata(NULL), m_event_func(funcp), m_event_count(0), m_closed(1), m_deletable(0), m_deleted(0),
+   m_free_magic(INKCONT_INTERN_MAGIC_ALIVE)
 {
   SET_HANDLER(&INKContInternal::handle_event);
 }
 
 void
-INKContInternal::init(INKEventFunc funcp, INKMutex mutexp)
+INKContInternal::init(TSEventFunc funcp, TSMutex mutexp)
 {
   SET_HANDLER(&INKContInternal::handle_event);
 
@@ -1059,7 +1019,7 @@ INKContInternal::destroy()
     m_free_magic = INKCONT_INTERN_MAGIC_DEAD;
     INKContAllocator.free(this);
   } else {
-    INKContSchedule(this, 0);
+    TSContSchedule(this, 0);
   }
 }
 
@@ -1084,10 +1044,10 @@ INKContInternal::handle_event_count(int 
 void INKContInternal::setName(const char *name) {
   cont_name = name;
 
-  cont_time_stats.resize((int)(INK_HTTP_LAST_HOOK + 1));
-  cont_calls.resize((int)(INK_HTTP_LAST_HOOK + 1));
+  cont_time_stats.resize((int)(TS_HTTP_LAST_HOOK + 1));
+  cont_calls.resize((int)(TS_HTTP_LAST_HOOK + 1));
 
-  for(INKHttpHookID cur_hook_id = INK_HTTP_READ_REQUEST_HDR_HOOK; cur_hook_id <= INK_HTTP_LAST_HOOK; cur_hook_id = INKHttpHookID(cur_hook_id+1)) {
+  for(TSHttpHookID cur_hook_id = TS_HTTP_READ_REQUEST_HDR_HOOK; cur_hook_id <= TS_HTTP_LAST_HOOK; cur_hook_id = TSHttpHookID(cur_hook_id+1)) {
     // TODO: Fix the name of these stats to be something appropriate, e.g. proxy.x.y.z or some such (for now at least)
     // TODO: Get rid of std::string (snprintf anyone?)
     std::string stat_base = "cont." + cont_name + "." + HttpDebugNames::get_api_hook_name(cur_hook_id);
@@ -1103,7 +1063,7 @@ const char *INKContInternal::getName() {
   return cont_name.c_str();
 }
 
-void INKContInternal::statCallsMade(INKHttpHookID hook_id) {
+void INKContInternal::statCallsMade(TSHttpHookID hook_id) {
   if(cont_name == "")
     return;
   StatSystemV2::increment(cont_calls[hook_id]);
@@ -1124,7 +1084,7 @@ INKContInternal::handle_event(int event,
       INKContAllocator.free(this);
     }
   } else {
-    return m_event_func((INKCont) this, (INKEvent) event, edata);
+    return m_event_func((TSCont) this, (TSEvent) event, edata);
   }
   return EVENT_DONE;
 }
@@ -1142,7 +1102,7 @@ INKVConnInternal::INKVConnInternal()
   m_closed = 0;
 }
 
-INKVConnInternal::INKVConnInternal(INKEventFunc funcp, INKMutex mutexp)
+INKVConnInternal::INKVConnInternal(TSEventFunc funcp, TSMutex mutexp)
 :INKContInternal(funcp, mutexp), m_read_vio(), m_write_vio(), m_output_vc(NULL)
 {
   m_closed = 0;
@@ -1150,7 +1110,7 @@ INKVConnInternal::INKVConnInternal(INKEv
 }
 
 void
-INKVConnInternal::init(INKEventFunc funcp, INKMutex mutexp)
+INKVConnInternal::init(TSEventFunc funcp, TSMutex mutexp)
 {
   INKContInternal::init(funcp, mutexp);
   SET_HANDLER(&INKVConnInternal::handle_event);
@@ -1180,7 +1140,7 @@ INKVConnInternal::handle_event(int event
       INKVConnAllocator.free(this);
     }
   } else {
-    return m_event_func((INKCont) this, (INKEvent) event, edata);
+    return m_event_func((TSCont) this, (TSEvent) event, edata);
   }
   return EVENT_DONE;
 }
@@ -1241,9 +1201,9 @@ INKVConnInternal::do_io_close(int error)
 
   if (error != -1) {
     lerrno = error;
-    m_closed = INK_VC_CLOSE_ABORT;
+    m_closed = TS_VC_CLOSE_ABORT;
   } else {
-    m_closed = INK_VC_CLOSE_NORMAL;
+    m_closed = TS_VC_CLOSE_NORMAL;
   }
 
   m_read_vio.op = VIO::NONE;
@@ -1300,16 +1260,16 @@ INKVConnInternal::retry(unsigned int del
 bool INKVConnInternal::get_data(int id, void *data)
 {
   switch (id) {
-  case INK_API_DATA_READ_VIO:
-    *((INKVIO *) data) = &m_read_vio;
+  case TS_API_DATA_READ_VIO:
+    *((TSVIO *) data) = &m_read_vio;
     return true;
-  case INK_API_DATA_WRITE_VIO:
-    *((INKVIO *) data) = &m_write_vio;
+  case TS_API_DATA_WRITE_VIO:
+    *((TSVIO *) data) = &m_write_vio;
     return true;
-  case INK_API_DATA_OUTPUT_VC:
-    *((INKVConn *) data) = m_output_vc;
+  case TS_API_DATA_OUTPUT_VC:
+    *((TSVConn *) data) = m_output_vc;
     return true;
-  case INK_API_DATA_CLOSED:
+  case TS_API_DATA_CLOSED:
     *((int *) data) = m_closed;
     return true;
   default:
@@ -1320,7 +1280,7 @@ bool INKVConnInternal::get_data(int id, 
 bool INKVConnInternal::set_data(int id, void *data)
 {
   switch (id) {
-  case INK_API_DATA_OUTPUT_VC:
+  case TS_API_DATA_OUTPUT_VC:
     m_output_vc = (VConnection *) data;
     return true;
   default:
@@ -1400,7 +1360,7 @@ HttpAPIHooks::clear()
   APIHook *next_hook;
   int i;
 
-  for (i = 0; i < INK_HTTP_LAST_HOOK; i++) {
+  for (i = 0; i < TS_HTTP_LAST_HOOK; i++) {
     api_hook = m_hooks[i].get();
     while (api_hook) {
       next_hook = api_hook->m_link.next;
@@ -1412,76 +1372,25 @@ HttpAPIHooks::clear()
 }
 
 void
-HttpAPIHooks::prepend(INKHttpHookID id, INKContInternal *cont)
+HttpAPIHooks::prepend(TSHttpHookID id, INKContInternal *cont)
 {
   hooks_set = 1;
   m_hooks[id].prepend(cont);
 }
 
 void
-HttpAPIHooks::append(INKHttpHookID id, INKContInternal *cont)
-{
-  hooks_set = 1;
-  m_hooks[id].append(cont);
-}
-
-APIHook *
-HttpAPIHooks::get(INKHttpHookID id)
-{
-  return m_hooks[id].get();
-}
-
-
-//Cache API
-
-CacheAPIHooks::CacheAPIHooks():
-hooks_set(0)
-{
-}
-
-CacheAPIHooks::~CacheAPIHooks()
-{
-  clear();
-}
-
-void
-CacheAPIHooks::clear()
-{
-  APIHook *api_hook;
-  APIHook *next_hook;
-  int i;
-
-  for (i = 0; i < INK_CACHE_LAST_HOOK; i++) {
-    api_hook = m_hooks[i].get();
-    while (api_hook) {
-      next_hook = api_hook->m_link.next;
-      apiHookAllocator.free(api_hook);
-      api_hook = next_hook;
-    }
-  }
-  hooks_set = 0;
-}
-
-void
-CacheAPIHooks::append(INKCacheHookID id, INKContInternal *cont)
+HttpAPIHooks::append(TSHttpHookID id, INKContInternal *cont)
 {
   hooks_set = 1;
   m_hooks[id].append(cont);
 }
 
 APIHook *
-CacheAPIHooks::get(INKCacheHookID id)
+HttpAPIHooks::get(TSHttpHookID id)
 {
   return m_hooks[id].get();
 }
 
-void
-CacheAPIHooks::prepend(INKCacheHookID id, INKContInternal *cont)
-{
-  hooks_set = 1;
-  m_hooks[id].prepend(cont);
-}
-
 
 ////////////////////////////////////////////////////////////////////
 //
@@ -1574,249 +1483,246 @@ api_init()
 #endif
 
     /* URL schemes */
-    INK_URL_SCHEME_FILE = URL_SCHEME_FILE;
-    INK_URL_SCHEME_FTP = URL_SCHEME_FTP;
-    INK_URL_SCHEME_GOPHER = URL_SCHEME_GOPHER;
-    INK_URL_SCHEME_HTTP = URL_SCHEME_HTTP;
-    INK_URL_SCHEME_HTTPS = URL_SCHEME_HTTPS;
-    INK_URL_SCHEME_MAILTO = URL_SCHEME_MAILTO;
-    INK_URL_SCHEME_NEWS = URL_SCHEME_NEWS;
-    INK_URL_SCHEME_NNTP = URL_SCHEME_NNTP;
-    INK_URL_SCHEME_PROSPERO = URL_SCHEME_PROSPERO;
-    INK_URL_SCHEME_TELNET = URL_SCHEME_TELNET;
-    INK_URL_SCHEME_WAIS = URL_SCHEME_WAIS;
-
-    INK_URL_LEN_FILE = URL_LEN_FILE;
-    INK_URL_LEN_FTP = URL_LEN_FTP;
-    INK_URL_LEN_GOPHER = URL_LEN_GOPHER;
-    INK_URL_LEN_HTTP = URL_LEN_HTTP;
-    INK_URL_LEN_HTTPS = URL_LEN_HTTPS;
-    INK_URL_LEN_MAILTO = URL_LEN_MAILTO;
-    INK_URL_LEN_NEWS = URL_LEN_NEWS;
-    INK_URL_LEN_NNTP = URL_LEN_NNTP;
-    INK_URL_LEN_PROSPERO = URL_LEN_PROSPERO;
-    INK_URL_LEN_TELNET = URL_LEN_TELNET;
-    INK_URL_LEN_WAIS = URL_LEN_WAIS;
+    TS_URL_SCHEME_FILE = URL_SCHEME_FILE;
+    TS_URL_SCHEME_FTP = URL_SCHEME_FTP;
+    TS_URL_SCHEME_GOPHER = URL_SCHEME_GOPHER;
+    TS_URL_SCHEME_HTTP = URL_SCHEME_HTTP;
+    TS_URL_SCHEME_HTTPS = URL_SCHEME_HTTPS;
+    TS_URL_SCHEME_MAILTO = URL_SCHEME_MAILTO;
+    TS_URL_SCHEME_NEWS = URL_SCHEME_NEWS;
+    TS_URL_SCHEME_NNTP = URL_SCHEME_NNTP;
+    TS_URL_SCHEME_PROSPERO = URL_SCHEME_PROSPERO;
+    TS_URL_SCHEME_TELNET = URL_SCHEME_TELNET;
+    TS_URL_SCHEME_WAIS = URL_SCHEME_WAIS;
+
+    TS_URL_LEN_FILE = URL_LEN_FILE;
+    TS_URL_LEN_FTP = URL_LEN_FTP;
+    TS_URL_LEN_GOPHER = URL_LEN_GOPHER;
+    TS_URL_LEN_HTTP = URL_LEN_HTTP;
+    TS_URL_LEN_HTTPS = URL_LEN_HTTPS;
+    TS_URL_LEN_MAILTO = URL_LEN_MAILTO;
+    TS_URL_LEN_NEWS = URL_LEN_NEWS;
+    TS_URL_LEN_NNTP = URL_LEN_NNTP;
+    TS_URL_LEN_PROSPERO = URL_LEN_PROSPERO;
+    TS_URL_LEN_TELNET = URL_LEN_TELNET;
+    TS_URL_LEN_WAIS = URL_LEN_WAIS;
 
     /* MIME fields */
-    INK_MIME_FIELD_ACCEPT = MIME_FIELD_ACCEPT;
-    INK_MIME_FIELD_ACCEPT_CHARSET = MIME_FIELD_ACCEPT_CHARSET;
-    INK_MIME_FIELD_ACCEPT_ENCODING = MIME_FIELD_ACCEPT_ENCODING;
-    INK_MIME_FIELD_ACCEPT_LANGUAGE = MIME_FIELD_ACCEPT_LANGUAGE;
-    INK_MIME_FIELD_ACCEPT_RANGES = MIME_FIELD_ACCEPT_RANGES;
-    INK_MIME_FIELD_AGE = MIME_FIELD_AGE;
-    INK_MIME_FIELD_ALLOW = MIME_FIELD_ALLOW;
-    INK_MIME_FIELD_APPROVED = MIME_FIELD_APPROVED;
-    INK_MIME_FIELD_AUTHORIZATION = MIME_FIELD_AUTHORIZATION;
-    INK_MIME_FIELD_BYTES = MIME_FIELD_BYTES;
-    INK_MIME_FIELD_CACHE_CONTROL = MIME_FIELD_CACHE_CONTROL;
-    INK_MIME_FIELD_CLIENT_IP = MIME_FIELD_CLIENT_IP;
-    INK_MIME_FIELD_CONNECTION = MIME_FIELD_CONNECTION;
-    INK_MIME_FIELD_CONTENT_BASE = MIME_FIELD_CONTENT_BASE;
-    INK_MIME_FIELD_CONTENT_ENCODING = MIME_FIELD_CONTENT_ENCODING;
-    INK_MIME_FIELD_CONTENT_LANGUAGE = MIME_FIELD_CONTENT_LANGUAGE;
-    INK_MIME_FIELD_CONTENT_LENGTH = MIME_FIELD_CONTENT_LENGTH;
-    INK_MIME_FIELD_CONTENT_LOCATION = MIME_FIELD_CONTENT_LOCATION;
-    INK_MIME_FIELD_CONTENT_MD5 = MIME_FIELD_CONTENT_MD5;
-    INK_MIME_FIELD_CONTENT_RANGE = MIME_FIELD_CONTENT_RANGE;
-    INK_MIME_FIELD_CONTENT_TYPE = MIME_FIELD_CONTENT_TYPE;
-    INK_MIME_FIELD_CONTROL = MIME_FIELD_CONTROL;
-    INK_MIME_FIELD_COOKIE = MIME_FIELD_COOKIE;
-    INK_MIME_FIELD_DATE = MIME_FIELD_DATE;
-    INK_MIME_FIELD_DISTRIBUTION = MIME_FIELD_DISTRIBUTION;
-    INK_MIME_FIELD_ETAG = MIME_FIELD_ETAG;
-    INK_MIME_FIELD_EXPECT = MIME_FIELD_EXPECT;
-    INK_MIME_FIELD_EXPIRES = MIME_FIELD_EXPIRES;
-    INK_MIME_FIELD_FOLLOWUP_TO = MIME_FIELD_FOLLOWUP_TO;
-    INK_MIME_FIELD_FROM = MIME_FIELD_FROM;
-    INK_MIME_FIELD_HOST = MIME_FIELD_HOST;
-    INK_MIME_FIELD_IF_MATCH = MIME_FIELD_IF_MATCH;
-    INK_MIME_FIELD_IF_MODIFIED_SINCE = MIME_FIELD_IF_MODIFIED_SINCE;
-    INK_MIME_FIELD_IF_NONE_MATCH = MIME_FIELD_IF_NONE_MATCH;
-    INK_MIME_FIELD_IF_RANGE = MIME_FIELD_IF_RANGE;
-    INK_MIME_FIELD_IF_UNMODIFIED_SINCE = MIME_FIELD_IF_UNMODIFIED_SINCE;
-    INK_MIME_FIELD_KEEP_ALIVE = MIME_FIELD_KEEP_ALIVE;
-    INK_MIME_FIELD_KEYWORDS = MIME_FIELD_KEYWORDS;
-    INK_MIME_FIELD_LAST_MODIFIED = MIME_FIELD_LAST_MODIFIED;
-    INK_MIME_FIELD_LINES = MIME_FIELD_LINES;
-    INK_MIME_FIELD_LOCATION = MIME_FIELD_LOCATION;
-    INK_MIME_FIELD_MAX_FORWARDS = MIME_FIELD_MAX_FORWARDS;
-    INK_MIME_FIELD_MESSAGE_ID = MIME_FIELD_MESSAGE_ID;
-    INK_MIME_FIELD_NEWSGROUPS = MIME_FIELD_NEWSGROUPS;
-    INK_MIME_FIELD_ORGANIZATION = MIME_FIELD_ORGANIZATION;
-    INK_MIME_FIELD_PATH = MIME_FIELD_PATH;
-    INK_MIME_FIELD_PRAGMA = MIME_FIELD_PRAGMA;
-    INK_MIME_FIELD_PROXY_AUTHENTICATE = MIME_FIELD_PROXY_AUTHENTICATE;
-    INK_MIME_FIELD_PROXY_AUTHORIZATION = MIME_FIELD_PROXY_AUTHORIZATION;
-    INK_MIME_FIELD_PROXY_CONNECTION = MIME_FIELD_PROXY_CONNECTION;
-    INK_MIME_FIELD_PUBLIC = MIME_FIELD_PUBLIC;
-    INK_MIME_FIELD_RANGE = MIME_FIELD_RANGE;
-    INK_MIME_FIELD_REFERENCES = MIME_FIELD_REFERENCES;
-    INK_MIME_FIELD_REFERER = MIME_FIELD_REFERER;
-    INK_MIME_FIELD_REPLY_TO = MIME_FIELD_REPLY_TO;
-    INK_MIME_FIELD_RETRY_AFTER = MIME_FIELD_RETRY_AFTER;
-    INK_MIME_FIELD_SENDER = MIME_FIELD_SENDER;
-    INK_MIME_FIELD_SERVER = MIME_FIELD_SERVER;
-    INK_MIME_FIELD_SET_COOKIE = MIME_FIELD_SET_COOKIE;
-    INK_MIME_FIELD_SUBJECT = MIME_FIELD_SUBJECT;
-    INK_MIME_FIELD_SUMMARY = MIME_FIELD_SUMMARY;
-    INK_MIME_FIELD_TE = MIME_FIELD_TE;
-    INK_MIME_FIELD_TRANSFER_ENCODING = MIME_FIELD_TRANSFER_ENCODING;
-    INK_MIME_FIELD_UPGRADE = MIME_FIELD_UPGRADE;
-    INK_MIME_FIELD_USER_AGENT = MIME_FIELD_USER_AGENT;
-    INK_MIME_FIELD_VARY = MIME_FIELD_VARY;
-    INK_MIME_FIELD_VIA = MIME_FIELD_VIA;
-    INK_MIME_FIELD_WARNING = MIME_FIELD_WARNING;
-    INK_MIME_FIELD_WWW_AUTHENTICATE = MIME_FIELD_WWW_AUTHENTICATE;
-    INK_MIME_FIELD_XREF = MIME_FIELD_XREF;
-    INK_MIME_FIELD_X_FORWARDED_FOR = MIME_FIELD_X_FORWARDED_FOR;
-
-
-    INK_MIME_LEN_ACCEPT = MIME_LEN_ACCEPT;
-    INK_MIME_LEN_ACCEPT_CHARSET = MIME_LEN_ACCEPT_CHARSET;
-    INK_MIME_LEN_ACCEPT_ENCODING = MIME_LEN_ACCEPT_ENCODING;
-    INK_MIME_LEN_ACCEPT_LANGUAGE = MIME_LEN_ACCEPT_LANGUAGE;
-    INK_MIME_LEN_ACCEPT_RANGES = MIME_LEN_ACCEPT_RANGES;
-    INK_MIME_LEN_AGE = MIME_LEN_AGE;
-    INK_MIME_LEN_ALLOW = MIME_LEN_ALLOW;
-    INK_MIME_LEN_APPROVED = MIME_LEN_APPROVED;
-    INK_MIME_LEN_AUTHORIZATION = MIME_LEN_AUTHORIZATION;
-    INK_MIME_LEN_BYTES = MIME_LEN_BYTES;
-    INK_MIME_LEN_CACHE_CONTROL = MIME_LEN_CACHE_CONTROL;
-    INK_MIME_LEN_CLIENT_IP = MIME_LEN_CLIENT_IP;
-    INK_MIME_LEN_CONNECTION = MIME_LEN_CONNECTION;
-    INK_MIME_LEN_CONTENT_BASE = MIME_LEN_CONTENT_BASE;
-    INK_MIME_LEN_CONTENT_ENCODING = MIME_LEN_CONTENT_ENCODING;
-    INK_MIME_LEN_CONTENT_LANGUAGE = MIME_LEN_CONTENT_LANGUAGE;
-    INK_MIME_LEN_CONTENT_LENGTH = MIME_LEN_CONTENT_LENGTH;
-    INK_MIME_LEN_CONTENT_LOCATION = MIME_LEN_CONTENT_LOCATION;
-    INK_MIME_LEN_CONTENT_MD5 = MIME_LEN_CONTENT_MD5;
-    INK_MIME_LEN_CONTENT_RANGE = MIME_LEN_CONTENT_RANGE;
-    INK_MIME_LEN_CONTENT_TYPE = MIME_LEN_CONTENT_TYPE;
-    INK_MIME_LEN_CONTROL = MIME_LEN_CONTROL;
-    INK_MIME_LEN_COOKIE = MIME_LEN_COOKIE;
-    INK_MIME_LEN_DATE = MIME_LEN_DATE;
-    INK_MIME_LEN_DISTRIBUTION = MIME_LEN_DISTRIBUTION;
-    INK_MIME_LEN_ETAG = MIME_LEN_ETAG;
-    INK_MIME_LEN_EXPECT = MIME_LEN_EXPECT;
-    INK_MIME_LEN_EXPIRES = MIME_LEN_EXPIRES;
-    INK_MIME_LEN_FOLLOWUP_TO = MIME_LEN_FOLLOWUP_TO;
-    INK_MIME_LEN_FROM = MIME_LEN_FROM;
-    INK_MIME_LEN_HOST = MIME_LEN_HOST;
-    INK_MIME_LEN_IF_MATCH = MIME_LEN_IF_MATCH;
-    INK_MIME_LEN_IF_MODIFIED_SINCE = MIME_LEN_IF_MODIFIED_SINCE;
-    INK_MIME_LEN_IF_NONE_MATCH = MIME_LEN_IF_NONE_MATCH;
-    INK_MIME_LEN_IF_RANGE = MIME_LEN_IF_RANGE;
-    INK_MIME_LEN_IF_UNMODIFIED_SINCE = MIME_LEN_IF_UNMODIFIED_SINCE;
-    INK_MIME_LEN_KEEP_ALIVE = MIME_LEN_KEEP_ALIVE;
-    INK_MIME_LEN_KEYWORDS = MIME_LEN_KEYWORDS;
-    INK_MIME_LEN_LAST_MODIFIED = MIME_LEN_LAST_MODIFIED;
-    INK_MIME_LEN_LINES = MIME_LEN_LINES;
-    INK_MIME_LEN_LOCATION = MIME_LEN_LOCATION;
-    INK_MIME_LEN_MAX_FORWARDS = MIME_LEN_MAX_FORWARDS;
-    INK_MIME_LEN_MESSAGE_ID = MIME_LEN_MESSAGE_ID;
-    INK_MIME_LEN_NEWSGROUPS = MIME_LEN_NEWSGROUPS;
-    INK_MIME_LEN_ORGANIZATION = MIME_LEN_ORGANIZATION;
-    INK_MIME_LEN_PATH = MIME_LEN_PATH;
-    INK_MIME_LEN_PRAGMA = MIME_LEN_PRAGMA;
-    INK_MIME_LEN_PROXY_AUTHENTICATE = MIME_LEN_PROXY_AUTHENTICATE;
-    INK_MIME_LEN_PROXY_AUTHORIZATION = MIME_LEN_PROXY_AUTHORIZATION;
-    INK_MIME_LEN_PROXY_CONNECTION = MIME_LEN_PROXY_CONNECTION;
-    INK_MIME_LEN_PUBLIC = MIME_LEN_PUBLIC;
-    INK_MIME_LEN_RANGE = MIME_LEN_RANGE;
-    INK_MIME_LEN_REFERENCES = MIME_LEN_REFERENCES;
-    INK_MIME_LEN_REFERER = MIME_LEN_REFERER;
-    INK_MIME_LEN_REPLY_TO = MIME_LEN_REPLY_TO;
-    INK_MIME_LEN_RETRY_AFTER = MIME_LEN_RETRY_AFTER;
-    INK_MIME_LEN_SENDER = MIME_LEN_SENDER;
-    INK_MIME_LEN_SERVER = MIME_LEN_SERVER;
-    INK_MIME_LEN_SET_COOKIE = MIME_LEN_SET_COOKIE;
-    INK_MIME_LEN_SUBJECT = MIME_LEN_SUBJECT;
-    INK_MIME_LEN_SUMMARY = MIME_LEN_SUMMARY;
-    INK_MIME_LEN_TE = MIME_LEN_TE;
-    INK_MIME_LEN_TRANSFER_ENCODING = MIME_LEN_TRANSFER_ENCODING;
-    INK_MIME_LEN_UPGRADE = MIME_LEN_UPGRADE;
-    INK_MIME_LEN_USER_AGENT = MIME_LEN_USER_AGENT;
-    INK_MIME_LEN_VARY = MIME_LEN_VARY;
-    INK_MIME_LEN_VIA = MIME_LEN_VIA;
-    INK_MIME_LEN_WARNING = MIME_LEN_WARNING;
-    INK_MIME_LEN_WWW_AUTHENTICATE = MIME_LEN_WWW_AUTHENTICATE;
-    INK_MIME_LEN_XREF = MIME_LEN_XREF;
-    INK_MIME_LEN_X_FORWARDED_FOR = MIME_LEN_X_FORWARDED_FOR;
+    TS_MIME_FIELD_ACCEPT = MIME_FIELD_ACCEPT;
+    TS_MIME_FIELD_ACCEPT_CHARSET = MIME_FIELD_ACCEPT_CHARSET;
+    TS_MIME_FIELD_ACCEPT_ENCODING = MIME_FIELD_ACCEPT_ENCODING;
+    TS_MIME_FIELD_ACCEPT_LANGUAGE = MIME_FIELD_ACCEPT_LANGUAGE;
+    TS_MIME_FIELD_ACCEPT_RANGES = MIME_FIELD_ACCEPT_RANGES;
+    TS_MIME_FIELD_AGE = MIME_FIELD_AGE;
+    TS_MIME_FIELD_ALLOW = MIME_FIELD_ALLOW;
+    TS_MIME_FIELD_APPROVED = MIME_FIELD_APPROVED;
+    TS_MIME_FIELD_AUTHORIZATION = MIME_FIELD_AUTHORIZATION;
+    TS_MIME_FIELD_BYTES = MIME_FIELD_BYTES;
+    TS_MIME_FIELD_CACHE_CONTROL = MIME_FIELD_CACHE_CONTROL;
+    TS_MIME_FIELD_CLIENT_IP = MIME_FIELD_CLIENT_IP;
+    TS_MIME_FIELD_CONNECTION = MIME_FIELD_CONNECTION;
+    TS_MIME_FIELD_CONTENT_BASE = MIME_FIELD_CONTENT_BASE;
+    TS_MIME_FIELD_CONTENT_ENCODING = MIME_FIELD_CONTENT_ENCODING;
+    TS_MIME_FIELD_CONTENT_LANGUAGE = MIME_FIELD_CONTENT_LANGUAGE;
+    TS_MIME_FIELD_CONTENT_LENGTH = MIME_FIELD_CONTENT_LENGTH;
+    TS_MIME_FIELD_CONTENT_LOCATION = MIME_FIELD_CONTENT_LOCATION;
+    TS_MIME_FIELD_CONTENT_MD5 = MIME_FIELD_CONTENT_MD5;
+    TS_MIME_FIELD_CONTENT_RANGE = MIME_FIELD_CONTENT_RANGE;
+    TS_MIME_FIELD_CONTENT_TYPE = MIME_FIELD_CONTENT_TYPE;
+    TS_MIME_FIELD_CONTROL = MIME_FIELD_CONTROL;
+    TS_MIME_FIELD_COOKIE = MIME_FIELD_COOKIE;
+    TS_MIME_FIELD_DATE = MIME_FIELD_DATE;
+    TS_MIME_FIELD_DISTRIBUTION = MIME_FIELD_DISTRIBUTION;
+    TS_MIME_FIELD_ETAG = MIME_FIELD_ETAG;
+    TS_MIME_FIELD_EXPECT = MIME_FIELD_EXPECT;
+    TS_MIME_FIELD_EXPIRES = MIME_FIELD_EXPIRES;
+    TS_MIME_FIELD_FOLLOWUP_TO = MIME_FIELD_FOLLOWUP_TO;
+    TS_MIME_FIELD_FROM = MIME_FIELD_FROM;
+    TS_MIME_FIELD_HOST = MIME_FIELD_HOST;
+    TS_MIME_FIELD_IF_MATCH = MIME_FIELD_IF_MATCH;
+    TS_MIME_FIELD_IF_MODIFIED_SINCE = MIME_FIELD_IF_MODIFIED_SINCE;
+    TS_MIME_FIELD_IF_NONE_MATCH = MIME_FIELD_IF_NONE_MATCH;
+    TS_MIME_FIELD_IF_RANGE = MIME_FIELD_IF_RANGE;
+    TS_MIME_FIELD_IF_UNMODIFIED_SINCE = MIME_FIELD_IF_UNMODIFIED_SINCE;
+    TS_MIME_FIELD_KEEP_ALIVE = MIME_FIELD_KEEP_ALIVE;
+    TS_MIME_FIELD_KEYWORDS = MIME_FIELD_KEYWORDS;
+    TS_MIME_FIELD_LAST_MODIFIED = MIME_FIELD_LAST_MODIFIED;
+    TS_MIME_FIELD_LINES = MIME_FIELD_LINES;
+    TS_MIME_FIELD_LOCATION = MIME_FIELD_LOCATION;
+    TS_MIME_FIELD_MAX_FORWARDS = MIME_FIELD_MAX_FORWARDS;
+    TS_MIME_FIELD_MESSAGE_ID = MIME_FIELD_MESSAGE_ID;
+    TS_MIME_FIELD_NEWSGROUPS = MIME_FIELD_NEWSGROUPS;
+    TS_MIME_FIELD_ORGANIZATION = MIME_FIELD_ORGANIZATION;
+    TS_MIME_FIELD_PATH = MIME_FIELD_PATH;
+    TS_MIME_FIELD_PRAGMA = MIME_FIELD_PRAGMA;
+    TS_MIME_FIELD_PROXY_AUTHENTICATE = MIME_FIELD_PROXY_AUTHENTICATE;
+    TS_MIME_FIELD_PROXY_AUTHORIZATION = MIME_FIELD_PROXY_AUTHORIZATION;
+    TS_MIME_FIELD_PROXY_CONNECTION = MIME_FIELD_PROXY_CONNECTION;
+    TS_MIME_FIELD_PUBLIC = MIME_FIELD_PUBLIC;
+    TS_MIME_FIELD_RANGE = MIME_FIELD_RANGE;
+    TS_MIME_FIELD_REFERENCES = MIME_FIELD_REFERENCES;
+    TS_MIME_FIELD_REFERER = MIME_FIELD_REFERER;
+    TS_MIME_FIELD_REPLY_TO = MIME_FIELD_REPLY_TO;
+    TS_MIME_FIELD_RETRY_AFTER = MIME_FIELD_RETRY_AFTER;
+    TS_MIME_FIELD_SENDER = MIME_FIELD_SENDER;
+    TS_MIME_FIELD_SERVER = MIME_FIELD_SERVER;
+    TS_MIME_FIELD_SET_COOKIE = MIME_FIELD_SET_COOKIE;
+    TS_MIME_FIELD_SUBJECT = MIME_FIELD_SUBJECT;
+    TS_MIME_FIELD_SUMMARY = MIME_FIELD_SUMMARY;
+    TS_MIME_FIELD_TE = MIME_FIELD_TE;
+    TS_MIME_FIELD_TRANSFER_ENCODING = MIME_FIELD_TRANSFER_ENCODING;
+    TS_MIME_FIELD_UPGRADE = MIME_FIELD_UPGRADE;
+    TS_MIME_FIELD_USER_AGENT = MIME_FIELD_USER_AGENT;
+    TS_MIME_FIELD_VARY = MIME_FIELD_VARY;
+    TS_MIME_FIELD_VIA = MIME_FIELD_VIA;
+    TS_MIME_FIELD_WARNING = MIME_FIELD_WARNING;
+    TS_MIME_FIELD_WWW_AUTHENTICATE = MIME_FIELD_WWW_AUTHENTICATE;
+    TS_MIME_FIELD_XREF = MIME_FIELD_XREF;
+    TS_MIME_FIELD_X_FORWARDED_FOR = MIME_FIELD_X_FORWARDED_FOR;
+
+
+    TS_MIME_LEN_ACCEPT = MIME_LEN_ACCEPT;
+    TS_MIME_LEN_ACCEPT_CHARSET = MIME_LEN_ACCEPT_CHARSET;
+    TS_MIME_LEN_ACCEPT_ENCODING = MIME_LEN_ACCEPT_ENCODING;
+    TS_MIME_LEN_ACCEPT_LANGUAGE = MIME_LEN_ACCEPT_LANGUAGE;
+    TS_MIME_LEN_ACCEPT_RANGES = MIME_LEN_ACCEPT_RANGES;
+    TS_MIME_LEN_AGE = MIME_LEN_AGE;
+    TS_MIME_LEN_ALLOW = MIME_LEN_ALLOW;
+    TS_MIME_LEN_APPROVED = MIME_LEN_APPROVED;
+    TS_MIME_LEN_AUTHORIZATION = MIME_LEN_AUTHORIZATION;
+    TS_MIME_LEN_BYTES = MIME_LEN_BYTES;
+    TS_MIME_LEN_CACHE_CONTROL = MIME_LEN_CACHE_CONTROL;
+    TS_MIME_LEN_CLIENT_IP = MIME_LEN_CLIENT_IP;
+    TS_MIME_LEN_CONNECTION = MIME_LEN_CONNECTION;
+    TS_MIME_LEN_CONTENT_BASE = MIME_LEN_CONTENT_BASE;
+    TS_MIME_LEN_CONTENT_ENCODING = MIME_LEN_CONTENT_ENCODING;
+    TS_MIME_LEN_CONTENT_LANGUAGE = MIME_LEN_CONTENT_LANGUAGE;
+    TS_MIME_LEN_CONTENT_LENGTH = MIME_LEN_CONTENT_LENGTH;
+    TS_MIME_LEN_CONTENT_LOCATION = MIME_LEN_CONTENT_LOCATION;
+    TS_MIME_LEN_CONTENT_MD5 = MIME_LEN_CONTENT_MD5;
+    TS_MIME_LEN_CONTENT_RANGE = MIME_LEN_CONTENT_RANGE;
+    TS_MIME_LEN_CONTENT_TYPE = MIME_LEN_CONTENT_TYPE;
+    TS_MIME_LEN_CONTROL = MIME_LEN_CONTROL;
+    TS_MIME_LEN_COOKIE = MIME_LEN_COOKIE;
+    TS_MIME_LEN_DATE = MIME_LEN_DATE;
+    TS_MIME_LEN_DISTRIBUTION = MIME_LEN_DISTRIBUTION;
+    TS_MIME_LEN_ETAG = MIME_LEN_ETAG;
+    TS_MIME_LEN_EXPECT = MIME_LEN_EXPECT;
+    TS_MIME_LEN_EXPIRES = MIME_LEN_EXPIRES;
+    TS_MIME_LEN_FOLLOWUP_TO = MIME_LEN_FOLLOWUP_TO;
+    TS_MIME_LEN_FROM = MIME_LEN_FROM;
+    TS_MIME_LEN_HOST = MIME_LEN_HOST;
+    TS_MIME_LEN_IF_MATCH = MIME_LEN_IF_MATCH;
+    TS_MIME_LEN_IF_MODIFIED_SINCE = MIME_LEN_IF_MODIFIED_SINCE;
+    TS_MIME_LEN_IF_NONE_MATCH = MIME_LEN_IF_NONE_MATCH;
+    TS_MIME_LEN_IF_RANGE = MIME_LEN_IF_RANGE;
+    TS_MIME_LEN_IF_UNMODIFIED_SINCE = MIME_LEN_IF_UNMODIFIED_SINCE;
+    TS_MIME_LEN_KEEP_ALIVE = MIME_LEN_KEEP_ALIVE;
+    TS_MIME_LEN_KEYWORDS = MIME_LEN_KEYWORDS;
+    TS_MIME_LEN_LAST_MODIFIED = MIME_LEN_LAST_MODIFIED;
+    TS_MIME_LEN_LINES = MIME_LEN_LINES;
+    TS_MIME_LEN_LOCATION = MIME_LEN_LOCATION;
+    TS_MIME_LEN_MAX_FORWARDS = MIME_LEN_MAX_FORWARDS;
+    TS_MIME_LEN_MESSAGE_ID = MIME_LEN_MESSAGE_ID;
+    TS_MIME_LEN_NEWSGROUPS = MIME_LEN_NEWSGROUPS;
+    TS_MIME_LEN_ORGANIZATION = MIME_LEN_ORGANIZATION;
+    TS_MIME_LEN_PATH = MIME_LEN_PATH;
+    TS_MIME_LEN_PRAGMA = MIME_LEN_PRAGMA;
+    TS_MIME_LEN_PROXY_AUTHENTICATE = MIME_LEN_PROXY_AUTHENTICATE;
+    TS_MIME_LEN_PROXY_AUTHORIZATION = MIME_LEN_PROXY_AUTHORIZATION;
+    TS_MIME_LEN_PROXY_CONNECTION = MIME_LEN_PROXY_CONNECTION;
+    TS_MIME_LEN_PUBLIC = MIME_LEN_PUBLIC;
+    TS_MIME_LEN_RANGE = MIME_LEN_RANGE;
+    TS_MIME_LEN_REFERENCES = MIME_LEN_REFERENCES;
+    TS_MIME_LEN_REFERER = MIME_LEN_REFERER;
+    TS_MIME_LEN_REPLY_TO = MIME_LEN_REPLY_TO;
+    TS_MIME_LEN_RETRY_AFTER = MIME_LEN_RETRY_AFTER;
+    TS_MIME_LEN_SENDER = MIME_LEN_SENDER;
+    TS_MIME_LEN_SERVER = MIME_LEN_SERVER;
+    TS_MIME_LEN_SET_COOKIE = MIME_LEN_SET_COOKIE;
+    TS_MIME_LEN_SUBJECT = MIME_LEN_SUBJECT;
+    TS_MIME_LEN_SUMMARY = MIME_LEN_SUMMARY;
+    TS_MIME_LEN_TE = MIME_LEN_TE;
+    TS_MIME_LEN_TRANSFER_ENCODING = MIME_LEN_TRANSFER_ENCODING;
+    TS_MIME_LEN_UPGRADE = MIME_LEN_UPGRADE;
+    TS_MIME_LEN_USER_AGENT = MIME_LEN_USER_AGENT;
+    TS_MIME_LEN_VARY = MIME_LEN_VARY;
+    TS_MIME_LEN_VIA = MIME_LEN_VIA;
+    TS_MIME_LEN_WARNING = MIME_LEN_WARNING;
+    TS_MIME_LEN_WWW_AUTHENTICATE = MIME_LEN_WWW_AUTHENTICATE;
+    TS_MIME_LEN_XREF = MIME_LEN_XREF;
+    TS_MIME_LEN_X_FORWARDED_FOR = MIME_LEN_X_FORWARDED_FOR;
 
 
     /* HTTP methods */
-    INK_HTTP_METHOD_CONNECT = HTTP_METHOD_CONNECT;
-    INK_HTTP_METHOD_DELETE = HTTP_METHOD_DELETE;
-    INK_HTTP_METHOD_GET = HTTP_METHOD_GET;
-    INK_HTTP_METHOD_HEAD = HTTP_METHOD_HEAD;
-    INK_HTTP_METHOD_ICP_QUERY = HTTP_METHOD_ICP_QUERY;
-    INK_HTTP_METHOD_OPTIONS = HTTP_METHOD_OPTIONS;
-    INK_HTTP_METHOD_POST = HTTP_METHOD_POST;
-    INK_HTTP_METHOD_PURGE = HTTP_METHOD_PURGE;
-    INK_HTTP_METHOD_PUT = HTTP_METHOD_PUT;
-    INK_HTTP_METHOD_TRACE = HTTP_METHOD_TRACE;
-
-    INK_HTTP_LEN_CONNECT = HTTP_LEN_CONNECT;
-    INK_HTTP_LEN_DELETE = HTTP_LEN_DELETE;
-    INK_HTTP_LEN_GET = HTTP_LEN_GET;
-    INK_HTTP_LEN_HEAD = HTTP_LEN_HEAD;
-    INK_HTTP_LEN_ICP_QUERY = HTTP_LEN_ICP_QUERY;
-    INK_HTTP_LEN_OPTIONS = HTTP_LEN_OPTIONS;
-    INK_HTTP_LEN_POST = HTTP_LEN_POST;
-    INK_HTTP_LEN_PURGE = HTTP_LEN_PURGE;
-    INK_HTTP_LEN_PUT = HTTP_LEN_PUT;
-    INK_HTTP_LEN_TRACE = HTTP_LEN_TRACE;
+    TS_HTTP_METHOD_CONNECT = HTTP_METHOD_CONNECT;
+    TS_HTTP_METHOD_DELETE = HTTP_METHOD_DELETE;
+    TS_HTTP_METHOD_GET = HTTP_METHOD_GET;
+    TS_HTTP_METHOD_HEAD = HTTP_METHOD_HEAD;
+    TS_HTTP_METHOD_ICP_QUERY = HTTP_METHOD_ICP_QUERY;
+    TS_HTTP_METHOD_OPTIONS = HTTP_METHOD_OPTIONS;
+    TS_HTTP_METHOD_POST = HTTP_METHOD_POST;
+    TS_HTTP_METHOD_PURGE = HTTP_METHOD_PURGE;
+    TS_HTTP_METHOD_PUT = HTTP_METHOD_PUT;
+    TS_HTTP_METHOD_TRACE = HTTP_METHOD_TRACE;
+
+    TS_HTTP_LEN_CONNECT = HTTP_LEN_CONNECT;
+    TS_HTTP_LEN_DELETE = HTTP_LEN_DELETE;
+    TS_HTTP_LEN_GET = HTTP_LEN_GET;
+    TS_HTTP_LEN_HEAD = HTTP_LEN_HEAD;
+    TS_HTTP_LEN_ICP_QUERY = HTTP_LEN_ICP_QUERY;
+    TS_HTTP_LEN_OPTIONS = HTTP_LEN_OPTIONS;
+    TS_HTTP_LEN_POST = HTTP_LEN_POST;
+    TS_HTTP_LEN_PURGE = HTTP_LEN_PURGE;
+    TS_HTTP_LEN_PUT = HTTP_LEN_PUT;
+    TS_HTTP_LEN_TRACE = HTTP_LEN_TRACE;
 
     /* HTTP miscellaneous values */
-    INK_HTTP_VALUE_BYTES = HTTP_VALUE_BYTES;
-    INK_HTTP_VALUE_CHUNKED = HTTP_VALUE_CHUNKED;
-    INK_HTTP_VALUE_CLOSE = HTTP_VALUE_CLOSE;
-    INK_HTTP_VALUE_COMPRESS = HTTP_VALUE_COMPRESS;
-    INK_HTTP_VALUE_DEFLATE = HTTP_VALUE_DEFLATE;
-    INK_HTTP_VALUE_GZIP = HTTP_VALUE_GZIP;
-    INK_HTTP_VALUE_IDENTITY = HTTP_VALUE_IDENTITY;
-    INK_HTTP_VALUE_KEEP_ALIVE = HTTP_VALUE_KEEP_ALIVE;
-    INK_HTTP_VALUE_MAX_AGE = HTTP_VALUE_MAX_AGE;
-    INK_HTTP_VALUE_MAX_STALE = HTTP_VALUE_MAX_STALE;
-    INK_HTTP_VALUE_MIN_FRESH = HTTP_VALUE_MIN_FRESH;
-    INK_HTTP_VALUE_MUST_REVALIDATE = HTTP_VALUE_MUST_REVALIDATE;
-    INK_HTTP_VALUE_NONE = HTTP_VALUE_NONE;
-    INK_HTTP_VALUE_NO_CACHE = HTTP_VALUE_NO_CACHE;
-    INK_HTTP_VALUE_NO_STORE = HTTP_VALUE_NO_STORE;
-    INK_HTTP_VALUE_NO_TRANSFORM = HTTP_VALUE_NO_TRANSFORM;
-    INK_HTTP_VALUE_ONLY_IF_CACHED = HTTP_VALUE_ONLY_IF_CACHED;
-    INK_HTTP_VALUE_PRIVATE = HTTP_VALUE_PRIVATE;
-    INK_HTTP_VALUE_PROXY_REVALIDATE = HTTP_VALUE_PROXY_REVALIDATE;
-    INK_HTTP_VALUE_PUBLIC = HTTP_VALUE_PUBLIC;
-    INK_HTTP_VALUE_S_MAXAGE = HTTP_VALUE_S_MAXAGE;
-    INK_HTTP_VALUE_SMAX_AGE = HTTP_VALUE_S_MAXAGE;      // deprecated
-
-    INK_HTTP_LEN_BYTES = HTTP_LEN_BYTES;
-    INK_HTTP_LEN_CHUNKED = HTTP_LEN_CHUNKED;
-    INK_HTTP_LEN_CLOSE = HTTP_LEN_CLOSE;
-    INK_HTTP_LEN_COMPRESS = HTTP_LEN_COMPRESS;
-    INK_HTTP_LEN_DEFLATE = HTTP_LEN_DEFLATE;
-    INK_HTTP_LEN_GZIP = HTTP_LEN_GZIP;
-    INK_HTTP_LEN_IDENTITY = HTTP_LEN_IDENTITY;
-    INK_HTTP_LEN_KEEP_ALIVE = HTTP_LEN_KEEP_ALIVE;
-    INK_HTTP_LEN_MAX_AGE = HTTP_LEN_MAX_AGE;
-    INK_HTTP_LEN_MAX_STALE = HTTP_LEN_MAX_STALE;
-    INK_HTTP_LEN_MIN_FRESH = HTTP_LEN_MIN_FRESH;
-    INK_HTTP_LEN_MUST_REVALIDATE = HTTP_LEN_MUST_REVALIDATE;
-    INK_HTTP_LEN_NONE = HTTP_LEN_NONE;
-    INK_HTTP_LEN_NO_CACHE = HTTP_LEN_NO_CACHE;
-    INK_HTTP_LEN_NO_STORE = HTTP_LEN_NO_STORE;
-    INK_HTTP_LEN_NO_TRANSFORM = HTTP_LEN_NO_TRANSFORM;
-    INK_HTTP_LEN_ONLY_IF_CACHED = HTTP_LEN_ONLY_IF_CACHED;
-    INK_HTTP_LEN_PRIVATE = HTTP_LEN_PRIVATE;
-    INK_HTTP_LEN_PROXY_REVALIDATE = HTTP_LEN_PROXY_REVALIDATE;
-    INK_HTTP_LEN_PUBLIC = HTTP_LEN_PUBLIC;
-    INK_HTTP_LEN_S_MAXAGE = HTTP_LEN_S_MAXAGE;
-    INK_HTTP_LEN_SMAX_AGE = HTTP_LEN_S_MAXAGE;
+    TS_HTTP_VALUE_BYTES = HTTP_VALUE_BYTES;
+    TS_HTTP_VALUE_CHUNKED = HTTP_VALUE_CHUNKED;
+    TS_HTTP_VALUE_CLOSE = HTTP_VALUE_CLOSE;
+    TS_HTTP_VALUE_COMPRESS = HTTP_VALUE_COMPRESS;
+    TS_HTTP_VALUE_DEFLATE = HTTP_VALUE_DEFLATE;
+    TS_HTTP_VALUE_GZIP = HTTP_VALUE_GZIP;
+    TS_HTTP_VALUE_IDENTITY = HTTP_VALUE_IDENTITY;
+    TS_HTTP_VALUE_KEEP_ALIVE = HTTP_VALUE_KEEP_ALIVE;
+    TS_HTTP_VALUE_MAX_AGE = HTTP_VALUE_MAX_AGE;
+    TS_HTTP_VALUE_MAX_STALE = HTTP_VALUE_MAX_STALE;
+    TS_HTTP_VALUE_MIN_FRESH = HTTP_VALUE_MIN_FRESH;
+    TS_HTTP_VALUE_MUST_REVALIDATE = HTTP_VALUE_MUST_REVALIDATE;
+    TS_HTTP_VALUE_NONE = HTTP_VALUE_NONE;
+    TS_HTTP_VALUE_NO_CACHE = HTTP_VALUE_NO_CACHE;
+    TS_HTTP_VALUE_NO_STORE = HTTP_VALUE_NO_STORE;
+    TS_HTTP_VALUE_NO_TRANSFORM = HTTP_VALUE_NO_TRANSFORM;
+    TS_HTTP_VALUE_ONLY_IF_CACHED = HTTP_VALUE_ONLY_IF_CACHED;
+    TS_HTTP_VALUE_PRIVATE = HTTP_VALUE_PRIVATE;
+    TS_HTTP_VALUE_PROXY_REVALIDATE = HTTP_VALUE_PROXY_REVALIDATE;
+    TS_HTTP_VALUE_PUBLIC = HTTP_VALUE_PUBLIC;
+    TS_HTTP_VALUE_S_MAXAGE = HTTP_VALUE_S_MAXAGE;
+
+    TS_HTTP_LEN_BYTES = HTTP_LEN_BYTES;
+    TS_HTTP_LEN_CHUNKED = HTTP_LEN_CHUNKED;
+    TS_HTTP_LEN_CLOSE = HTTP_LEN_CLOSE;
+    TS_HTTP_LEN_COMPRESS = HTTP_LEN_COMPRESS;
+    TS_HTTP_LEN_DEFLATE = HTTP_LEN_DEFLATE;
+    TS_HTTP_LEN_GZIP = HTTP_LEN_GZIP;
+    TS_HTTP_LEN_IDENTITY = HTTP_LEN_IDENTITY;
+    TS_HTTP_LEN_KEEP_ALIVE = HTTP_LEN_KEEP_ALIVE;
+    TS_HTTP_LEN_MAX_AGE = HTTP_LEN_MAX_AGE;
+    TS_HTTP_LEN_MAX_STALE = HTTP_LEN_MAX_STALE;
+    TS_HTTP_LEN_MIN_FRESH = HTTP_LEN_MIN_FRESH;
+    TS_HTTP_LEN_MUST_REVALIDATE = HTTP_LEN_MUST_REVALIDATE;
+    TS_HTTP_LEN_NONE = HTTP_LEN_NONE;
+    TS_HTTP_LEN_NO_CACHE = HTTP_LEN_NO_CACHE;
+    TS_HTTP_LEN_NO_STORE = HTTP_LEN_NO_STORE;
+    TS_HTTP_LEN_NO_TRANSFORM = HTTP_LEN_NO_TRANSFORM;
+    TS_HTTP_LEN_ONLY_IF_CACHED = HTTP_LEN_ONLY_IF_CACHED;
+    TS_HTTP_LEN_PRIVATE = HTTP_LEN_PRIVATE;
+    TS_HTTP_LEN_PROXY_REVALIDATE = HTTP_LEN_PROXY_REVALIDATE;
+    TS_HTTP_LEN_PUBLIC = HTTP_LEN_PUBLIC;
+    TS_HTTP_LEN_S_MAXAGE = HTTP_LEN_S_MAXAGE;
 
     http_global_hooks = NEW(new HttpAPIHooks);
-    cache_global_hooks = NEW(new CacheAPIHooks);
     global_config_cbs = NEW(new ConfigUpdateCbTable);
 
     if (TS_MAX_API_STATS > 0) {
@@ -1830,6 +1736,8 @@ api_init()
       api_rsb = NULL;
     }
 
+    memset(state_arg_table, 0, sizeof(state_arg_table));
+
     // Setup the version string for returning to plugins
     ink_strncpy(traffic_server_version, appVersionInfo.VersionStr, sizeof(traffic_server_version));
     // Extract the elements.
@@ -1847,25 +1755,26 @@ api_init()
 ////////////////////////////////////////////////////////////////////
 
 void *
-_INKmalloc(unsigned int size, const char *path)
+_TSmalloc(size_t size, const char *path)
 {
   return _xmalloc(size, path);
 }
 
 void *
-_INKrealloc(void *ptr, unsigned int size, const char *path)
+_TSrealloc(void *ptr, size_t size, const char *path)
 {
   return _xrealloc(ptr, size, path);
 }
 
+// length has to be int64 and not size_t, since -1 means to call strlen() to get length
 char *
-_INKstrdup(const char *str, int length, const char *path)
+_TSstrdup(const char *str, int64 length, const char *path)
 {
   return _xstrdup(str, length, path);
 }
 
 void
-_INKfree(void *ptr)
+_TSfree(void *ptr)
 {
   _xfree(ptr);
 }
@@ -1877,19 +1786,19 @@ _INKfree(void *ptr)
 ////////////////////////////////////////////////////////////////////
 
 unsigned int
-INKrandom()
+TSrandom()
 {
   return this_ethread()->generator.random();
 }
 
 double
-INKdrandom()
+TSdrandom()
 {
   return this_ethread()->generator.drandom();
 }
 
-INK64
-INKhrtime()
+ink_hrtime
+TShrtime()
 {
   return ink_get_based_hrtime();
 }
@@ -1901,19 +1810,19 @@ INKhrtime()
 ////////////////////////////////////////////////////////////////////
 
 const char *
-INKInstallDirGet(void)
+TSInstallDirGet(void)
 {
   return system_root_dir;
 }
 
 const char *
-INKConfigDirGet(void)
+TSConfigDirGet(void)
 {
   return system_config_directory;
 }
 
 const char *
-INKTrafficServerVersionGet(void)
+TSTrafficServerVersionGet(void)
 {
   return traffic_server_version;
 }
@@ -1922,7 +1831,7 @@ int INKTrafficServerVersionGetMinor() { 
 int INKTrafficServerVersionGetPatch() { return ts_patch_version; }
 
 const char *
-INKPluginDirGet(void)
+TSPluginDirGet(void)
 {
   static char path[PATH_NAME_MAX + 1] = "";
 
@@ -1948,20 +1857,19 @@ INKPluginDirGet(void)
 ////////////////////////////////////////////////////////////////////
 
 int
-INKPluginRegister(INKSDKVersion sdk_version, INKPluginRegistrationInfo *plugin_info)
+TSPluginRegister(TSSDKVersion sdk_version, TSPluginRegistrationInfo *plugin_info)
 {
 
   ink_assert(plugin_reg_current != NULL);
   if (!plugin_reg_current)
     return 0;
 
-  if (sdk_sanity_check_null_ptr((void *) plugin_info) != INK_SUCCESS) {
+  if (sdk_sanity_check_null_ptr((void *) plugin_info) != TS_SUCCESS)
     return 0;
-  }
 
   plugin_reg_current->plugin_registered = true;
 
-  if (sdk_version >= INK_SDK_VERSION_2_0 && sdk_version <= INK_SDK_VERSION_2_0) {
+  if (sdk_version >= TS_SDK_VERSION_2_0 && sdk_version <= TS_SDK_VERSION_2_0) {
     plugin_reg_current->sdk_version = (PluginSDKVersion) sdk_version;
   } else {
     plugin_reg_current->sdk_version = PLUGIN_SDK_VERSION_UNKNOWN;
@@ -1979,7 +1887,7 @@ INKPluginRegister(INKSDKVersion sdk_vers
     plugin_reg_current->support_email = xstrdup(plugin_info->support_email);
   }
 
-  return (1);
+  return 1;
 }
 
 ////////////////////////////////////////////////////////////////////
@@ -1988,16 +1896,15 @@ INKPluginRegister(INKSDKVersion sdk_vers
 //
 ////////////////////////////////////////////////////////////////////
 
-INKReturnCode
-INKPluginInfoRegister(INKPluginRegistrationInfo *plugin_info)
+TSReturnCode
+TSPluginInfoRegister(TSPluginRegistrationInfo *plugin_info)
 {
-  if (sdk_sanity_check_null_ptr((void *) plugin_info) == INK_ERROR) {
-    return INK_ERROR;
-  }
+  if (sdk_sanity_check_null_ptr((void *) plugin_info) == TS_ERROR)
+    return TS_ERROR;
 
   ink_assert(plugin_reg_current != NULL);
   if (!plugin_reg_current)
-    return INK_ERROR;
+    return TS_ERROR;
 
   plugin_reg_current->plugin_registered = true;
 
@@ -2016,7 +1923,7 @@ INKPluginInfoRegister(INKPluginRegistrat
     plugin_reg_current->support_email = xstrdup(plugin_info->support_email);
   }
 
-  return INK_SUCCESS;
+  return TS_SUCCESS;
 }
 
 ////////////////////////////////////////////////////////////////////
@@ -2025,8 +1932,8 @@ INKPluginInfoRegister(INKPluginRegistrat
 //
 ////////////////////////////////////////////////////////////////////
 
-INKFile
-INKfopen(const char *filename, const char *mode)
+TSFile
+TSfopen(const char *filename, const char *mode)
 {
   FileImpl *file;
 
@@ -2036,40 +1943,40 @@ INKfopen(const char *filename, const cha
     return NULL;
   }
 
-  return (INKFile) file;
+  return (TSFile) file;
 }
 
 void
-INKfclose(INKFile filep)
+TSfclose(TSFile filep)
 {
   FileImpl *file = (FileImpl *) filep;
   file->fclose();
   delete file;
 }
 
-int
-INKfread(INKFile filep, void *buf, int length)
+size_t
+TSfread(TSFile filep, void *buf, size_t length)
 {
   FileImpl *file = (FileImpl *) filep;
   return file->fread(buf, length);
 }
 
-int
-INKfwrite(INKFile filep, const void *buf, int length)
+size_t
+TSfwrite(TSFile filep, const void *buf, size_t length)
 {
   FileImpl *file = (FileImpl *) filep;
   return file->fwrite(buf, length);
 }
 
 void
-INKfflush(INKFile filep)
+TSfflush(TSFile filep)
 {
   FileImpl *file = (FileImpl *) filep;
   file->fflush();
 }
 
 char *
-INKfgets(INKFile filep, char *buf, int length)
+TSfgets(TSFile filep, char *buf, size_t length)
 {
   FileImpl *file = (FileImpl *) filep;
   return file->fgets(buf, length);
@@ -2081,55 +1988,54 @@ INKfgets(INKFile filep, char *buf, int l
 //
 ////////////////////////////////////////////////////////////////////
 
-INKReturnCode
-INKHandleMLocRelease(INKMBuffer bufp, INKMLoc parent, INKMLoc mloc)
+TSReturnCode
+TSHandleMLocRelease(TSMBuffer bufp, TSMLoc parent, TSMLoc mloc)
 {
   MIMEFieldSDKHandle *field_handle;
   HdrHeapObjImpl *obj = (HdrHeapObjImpl *) mloc;
 
-  if (mloc == INK_NULL_MLOC)
-    return (INK_SUCCESS);
+  if (mloc == TS_NULL_MLOC)
+    return TS_SUCCESS;
 
-  if (sdk_sanity_check_mbuffer(bufp) != INK_SUCCESS) {
-    return INK_ERROR;
-  }
+  if (sdk_sanity_check_mbuffer(bufp) != TS_SUCCESS)
+    return TS_ERROR;
 
   switch (obj->m_type) {
   case HDR_HEAP_OBJ_URL:
   case HDR_HEAP_OBJ_HTTP_HEADER:
   case HDR_HEAP_OBJ_MIME_HEADER:
-    return (INK_SUCCESS);
+    return TS_SUCCESS;
 
   case HDR_HEAP_OBJ_FIELD_SDK_HANDLE:
     field_handle = (MIMEFieldSDKHandle *) obj;
-    if (sdk_sanity_check_field_handle(mloc, parent) != INK_SUCCESS) {
-      return INK_ERROR;
-    }
+    if (sdk_sanity_check_field_handle(mloc, parent) != TS_SUCCESS)
+      return TS_ERROR;
+
     sdk_free_field_handle(bufp, field_handle);
-    return (INK_SUCCESS);
+    return TS_SUCCESS;
 
   default:
     ink_release_assert(!"invalid mloc");
-    return (INK_ERROR);
+    return TS_ERROR;
   }
 }
 
-INKReturnCode
-INKHandleStringRelease(INKMBuffer bufp, INKMLoc parent, const char *str)
+TSReturnCode
+TSHandleStringRelease(TSMBuffer bufp, TSMLoc parent, const char *str)
 {
   NOWARN_UNUSED(parent);
   if (str == NULL)
-    return (INK_SUCCESS);
+    return TS_SUCCESS;
   if (bufp == NULL)
-    return (INK_ERROR);
+    return TS_ERROR;
 
   if (hdrtoken_is_wks(str))
-    return (INK_SUCCESS);
+    return TS_SUCCESS;
 
   HdrHeapSDKHandle *sdk_h = (HdrHeapSDKHandle *) bufp;
   int r = sdk_h->destroy_sdk_string((char *) str);
 
-  return ((r == 0) ? INK_ERROR : INK_SUCCESS);
+  return ((r == 0) ? TS_ERROR : TS_SUCCESS);
 }
 
 ////////////////////////////////////////////////////////////////////
@@ -2138,86 +2044,39 @@ INKHandleStringRelease(INKMBuffer bufp, 
 //
 ////////////////////////////////////////////////////////////////////
 
-// INKMBuffer: pointers to HdrHeapSDKHandle objects
+// TSMBuffer: pointers to HdrHeapSDKHandle objects
 
-INKMBuffer
-INKMBufferCreate()
+TSMBuffer
+TSMBufferCreate()
 {
-  INKMBuffer bufp;
+  TSMBuffer bufp;
   HdrHeapSDKHandle *new_heap = NEW(new HdrHeapSDKHandle);
   new_heap->m_heap = new_HdrHeap();
-  bufp = (INKMBuffer) new_heap;
-  if (sdk_sanity_check_mbuffer(bufp) != INK_SUCCESS) {
+  bufp = (TSMBuffer) new_heap;
+  if (sdk_sanity_check_mbuffer(bufp) != TS_SUCCESS) {
     delete new_heap;
-    return (INKMBuffer) INK_ERROR_PTR;
+    return (TSMBuffer) TS_ERROR_PTR;
   }
-  return (bufp);
+  return bufp;
 }
 
-INKReturnCode
-INKMBufferDestroy(INKMBuffer bufp)
+TSReturnCode
+TSMBufferDestroy(TSMBuffer bufp)
 {
   // Allow to modify the buffer only
   // if bufp is modifiable. If bufp is not modifiable return
-  // INK_ERROR. If allowed, return INK_SUCCESS. Changed the
-  // return value of function from void to INKReturnCode.
+  // TS_ERROR. If allowed, return TS_SUCCESS. Changed the
+  // return value of function from void to TSReturnCode.
   if (isWriteable(bufp)) {
-    sdk_sanity_check_mbuffer(bufp);
-    HdrHeapSDKHandle *sdk_heap = (HdrHeapSDKHandle *) bufp;
-    sdk_heap->m_heap->destroy();
-    delete sdk_heap;
-    return INK_SUCCESS;
-  } else {
-    return INK_ERROR;
-  }
-}
-
-// DEPRECATED
-int
-INKMBufferDataSet(INKMBuffer bufp, void *data)
-{
-  NOWARN_UNUSED(data);
-  sdk_sanity_check_mbuffer(bufp);
-  return 0;
-}
-
-// DEPRECATED
-void *
-INKMBufferDataGet(INKMBuffer bufp, int *length)
-{
-  sdk_sanity_check_mbuffer(bufp);
-  if (length)
-    *length = 0;
-  return NULL;
-}
-
-// DEPRECATED
-int
-INKMBufferLengthGet(INKMBuffer bufp)
-{
-  sdk_sanity_check_mbuffer(bufp);
-  return 0;
-}
-
-// DEPRECATED
-void
-INKMBufferRef(INKMBuffer bufp)
-{
-  sdk_sanity_check_mbuffer(bufp);
-}
+    if (sdk_sanity_check_mbuffer(bufp) == TS_SUCCESS) {
+      HdrHeapSDKHandle *sdk_heap = (HdrHeapSDKHandle *) bufp;
 
-// DEPRECATED
-void
-INKMBufferUnref(INKMBuffer bufp)
-{
-  sdk_sanity_check_mbuffer(bufp);
-}
-
-// DEPRECATED
-void
-INKMBufferCompress(INKMBuffer bufp)
-{
-  sdk_sanity_check_mbuffer(bufp);
+      sdk_heap->m_heap->destroy();
+      delete sdk_heap;
+      return TS_SUCCESS;
+    }
+  }
+  return TS_ERROR;
 }
 
 ////////////////////////////////////////////////////////////////////
@@ -2226,49 +2085,47 @@ INKMBufferCompress(INKMBuffer bufp)
 //
 ////////////////////////////////////////////////////////////////////
 
-// INKMBuffer: pointers to HdrHeapSDKHandle objects
-// INKMLoc:    pointers to URLImpl objects
+// TSMBuffer: pointers to HdrHeapSDKHandle objects
+// TSMLoc:    pointers to URLImpl objects
 
-INKMLoc
-INKUrlCreate(INKMBuffer bufp)
+TSMLoc
+TSUrlCreate(TSMBuffer bufp)
 {
   // Allow to modify the buffer only
   // if bufp is modifiable. If bufp is not modifiable return
-  // INK_ERROR. If not allowed, return INK_ERROR_PTR.
-  if ((sdk_sanity_check_mbuffer(bufp) == INK_SUCCESS) && isWriteable(bufp)) {
+  // TS_ERROR. If not allowed, return TS_ERROR_PTR.
+  if ((sdk_sanity_check_mbuffer(bufp) == TS_SUCCESS) && isWriteable(bufp)) {
     HdrHeap *heap = ((HdrHeapSDKHandle *) bufp)->m_heap;
-    return ((INKMLoc) (url_create(heap)));
-  } else {
-    return (INKMLoc) INK_ERROR_PTR;
+    return ((TSMLoc) (url_create(heap)));
   }
+  return (TSMLoc) TS_ERROR_PTR;
 }
 
-INKReturnCode
-INKUrlDestroy(INKMBuffer bufp, INKMLoc url_loc)
+TSReturnCode
+TSUrlDestroy(TSMBuffer bufp, TSMLoc url_loc)
 {
   // Allow to modify the buffer only
   // if bufp is modifiable. If bufp is not modifiable return
-  // INK_ERROR. If allowed, return INK_SUCCESS. Changed the
-  // return value of function from void to INKReturnCode.
-  if ((sdk_sanity_check_mbuffer(bufp) == INK_SUCCESS) &&
-      (sdk_sanity_check_url_handle(url_loc) == INK_SUCCESS) && isWriteable(bufp)) {
+  // TS_ERROR. If allowed, return TS_SUCCESS. Changed the
+  // return value of function from void to TSReturnCode.
+  if ((sdk_sanity_check_mbuffer(bufp) == TS_SUCCESS) &&
+      (sdk_sanity_check_url_handle(url_loc) == TS_SUCCESS) && isWriteable(bufp)) {
     // No more objects counts in heap or deallocation so do nothing!
     // FIX ME - Did this free the MBuffer in Pete's old system?
-    return INK_SUCCESS;
-  } else {
-    return INK_ERROR;
+    return TS_SUCCESS;
   }
+  return TS_ERROR;
 }
 
-INKMLoc
-INKUrlClone(INKMBuffer dest_bufp, INKMBuffer src_bufp, INKMLoc src_url)
+TSMLoc
+TSUrlClone(TSMBuffer dest_bufp, TSMBuffer src_bufp, TSMLoc src_url)
 {
   // Allow to modify the buffer only
   // if bufp is modifiable. If bufp is not modifiable return
-  // INK_ERROR. If not allowed, return NULL.
-  if ((sdk_sanity_check_mbuffer(src_bufp) == INK_SUCCESS) &&
-      (sdk_sanity_check_mbuffer(dest_bufp) == INK_SUCCESS) &&
-      (sdk_sanity_check_url_handle(src_url) == INK_SUCCESS) && isWriteable(dest_bufp)) {
+  // TS_ERROR. If not allowed, return NULL.
+  if ((sdk_sanity_check_mbuffer(src_bufp) == TS_SUCCESS) &&
+      (sdk_sanity_check_mbuffer(dest_bufp) == TS_SUCCESS) &&
+      (sdk_sanity_check_url_handle(src_url) == TS_SUCCESS) && isWriteable(dest_bufp)) {
 
     HdrHeap *s_heap, *d_heap;
     URLImpl *s_url, *d_url;
@@ -2278,23 +2135,22 @@ INKUrlClone(INKMBuffer dest_bufp, INKMBu
     s_url = (URLImpl *) src_url;
 
     d_url = url_copy(s_url, s_heap, d_heap, (s_heap != d_heap));
-    return ((INKMLoc) d_url);
-  } else {
-    return (INKMLoc) INK_ERROR_PTR;
+    return ((TSMLoc) d_url);
   }
+  return (TSMLoc) TS_ERROR_PTR;
 }
 
-INKReturnCode
-INKUrlCopy(INKMBuffer dest_bufp, INKMLoc dest_obj, INKMBuffer src_bufp, INKMLoc src_obj)
+TSReturnCode
+TSUrlCopy(TSMBuffer dest_bufp, TSMLoc dest_obj, TSMBuffer src_bufp, TSMLoc src_obj)
 {
   // Allow to modify the buffer only
   // if bufp is modifiable. If bufp is not modifiable return
-  // INK_ERROR. If allowed, return INK_SUCCESS. Changed the
-  // return value of function from void to INKReturnCode.
-  if ((sdk_sanity_check_mbuffer(src_bufp) == INK_SUCCESS) &&
-      (sdk_sanity_check_mbuffer(dest_bufp) == INK_SUCCESS) &&
-      (sdk_sanity_check_url_handle(src_obj) == INK_SUCCESS) &&
-      (sdk_sanity_check_url_handle(dest_obj) == INK_SUCCESS) && isWriteable(dest_bufp)) {
+  // TS_ERROR. If allowed, return TS_SUCCESS. Changed the
+  // return value of function from void to TSReturnCode.
+  if ((sdk_sanity_check_mbuffer(src_bufp) == TS_SUCCESS) &&
+      (sdk_sanity_check_mbuffer(dest_bufp) == TS_SUCCESS) &&
+      (sdk_sanity_check_url_handle(src_obj) == TS_SUCCESS) &&
+      (sdk_sanity_check_url_handle(dest_obj) == TS_SUCCESS) && isWriteable(dest_bufp)) {
 
     HdrHeap *s_heap, *d_heap;
     URLImpl *s_url, *d_url;
@@ -2305,14 +2161,13 @@ INKUrlCopy(INKMBuffer dest_bufp, INKMLoc
     d_url = (URLImpl *) dest_obj;
 
     url_copy_onto(s_url, s_heap, d_url, d_heap, (s_heap != d_heap));
-    return INK_SUCCESS;
-  } else {
-    return INK_ERROR;
+    return TS_SUCCESS;
   }
+  return TS_ERROR;
 }
 
-INKReturnCode
-INKUrlPrint(INKMBuffer bufp, INKMLoc obj, INKIOBuffer iobufp)
+TSReturnCode
+TSUrlPrint(TSMBuffer bufp, TSMLoc obj, TSIOBuffer iobufp)
 {
   MIOBuffer *b = (MIOBuffer *) iobufp;
   IOBufferBlock *blk;
@@ -2320,11 +2175,9 @@ INKUrlPrint(INKMBuffer bufp, INKMLoc obj
   int tmp, dumpoffset;
   int done;
 
-  if ((sdk_sanity_check_mbuffer(bufp) != INK_SUCCESS) ||
-      (sdk_sanity_check_url_handle(obj) != INK_SUCCESS) || (sdk_sanity_check_iocore_structure(iobufp) != INK_SUCCESS)
-    ) {
-    return INK_ERROR;
-  }
+  if ((sdk_sanity_check_mbuffer(bufp) != TS_SUCCESS) ||
+      (sdk_sanity_check_url_handle(obj) != TS_SUCCESS) || (sdk_sanity_check_iocore_structure(iobufp) != TS_SUCCESS))
+    return TS_ERROR;
 
   URL u;
   u.m_heap = ((HdrHeapSDKHandle *) bufp)->m_heap;
@@ -2347,19 +2200,17 @@ INKUrlPrint(INKMBuffer bufp, INKMLoc obj
     dumpoffset += bufindex;
     b->fill(bufindex);
   } while (!done);
-  return INK_SUCCESS;
+  return TS_SUCCESS;
 }
 
 int
-INKUrlParse(INKMBuffer bufp, INKMLoc obj, const char **start, const char *end)
+TSUrlParse(TSMBuffer bufp, TSMLoc obj, const char **start, const char *end)
 {
-  if ((sdk_sanity_check_mbuffer(bufp) != INK_SUCCESS) ||
-      (sdk_sanity_check_url_handle(obj) != INK_SUCCESS) ||
+  if ((sdk_sanity_check_mbuffer(bufp) != TS_SUCCESS) ||
+      (sdk_sanity_check_url_handle(obj) != TS_SUCCESS) ||
       (start == NULL) || (*start == NULL) ||
-      sdk_sanity_check_null_ptr((void *) end) != INK_SUCCESS || (!isWriteable(bufp))
-    ) {
-    return INK_PARSE_ERROR;
-  }
+      sdk_sanity_check_null_ptr((void *) end) != TS_SUCCESS || (!isWriteable(bufp)))
+    return TS_PARSE_ERROR;
 
   URL u;
   u.m_heap = ((HdrHeapSDKHandle *) bufp)->m_heap;
@@ -2369,41 +2220,40 @@ INKUrlParse(INKMBuffer bufp, INKMLoc obj
 }
 
 int
-INKUrlLengthGet(INKMBuffer bufp, INKMLoc obj)
+TSUrlLengthGet(TSMBuffer bufp, TSMLoc obj)
 {
-  if ((sdk_sanity_check_mbuffer(bufp) != INK_SUCCESS) || (sdk_sanity_check_url_handle(obj) != INK_SUCCESS)
-    ) {
-    return INK_ERROR;
-  }
+  if ((sdk_sanity_check_mbuffer(bufp) != TS_SUCCESS) || (sdk_sanity_check_url_handle(obj) != TS_SUCCESS))
+    return TS_ERROR;
+
   URLImpl *url_impl = (URLImpl *) obj;
-  return (url_length_get(url_impl));
+
+  return url_length_get(url_impl);
 }
 
 char *
-INKUrlStringGet(INKMBuffer bufp, INKMLoc obj, int *length)
+TSUrlStringGet(TSMBuffer bufp, TSMLoc obj, int *length)
 {
-  if ((sdk_sanity_check_mbuffer(bufp) != INK_SUCCESS) || (sdk_sanity_check_url_handle(obj) != INK_SUCCESS)) {
-    return (char *) INK_ERROR_PTR;
-  }
+  if ((sdk_sanity_check_mbuffer(bufp) != TS_SUCCESS) || (sdk_sanity_check_url_handle(obj) != TS_SUCCESS))
+    return (char *) TS_ERROR_PTR;
+
   URLImpl *url_impl = (URLImpl *) obj;
-  return (url_string_get(url_impl, NULL, length, NULL));
 
+  return url_string_get(url_impl, NULL, length, NULL);
 }
 
 typedef const char *(URL::*URLPartGetF) (int *length);
 typedef void (URL::*URLPartSetF) (const char *value, int length);
 
 static const char *
-URLPartGet(INKMBuffer bufp, INKMLoc obj, int *length, URLPartGetF url_f)
+URLPartGet(TSMBuffer bufp, TSMLoc obj, int *length, URLPartGetF url_f)
 {
 
-  if ((sdk_sanity_check_mbuffer(bufp) != INK_SUCCESS) ||
-      (sdk_sanity_check_url_handle(obj) != INK_SUCCESS) || (length == NULL)
-    ) {
-    return (const char *) INK_ERROR_PTR;
-  }
+  if ((sdk_sanity_check_mbuffer(bufp) != TS_SUCCESS) ||
+      (sdk_sanity_check_url_handle(obj) != TS_SUCCESS) || (length == NULL))
+    return (const char *) TS_ERROR_PTR;
 
   URL u;
+
   u.m_heap = ((HdrHeapSDKHandle *) bufp)->m_heap;
   u.m_url_impl = (URLImpl *) obj;
 
@@ -2418,16 +2268,14 @@ URLPartGet(INKMBuffer bufp, INKMLoc obj,
   return ((HdrHeapSDKHandle *) bufp)->make_sdk_string(str_ptr, str_len);
 }
 
-static INKReturnCode
-URLPartSet(INKMBuffer bufp, INKMLoc obj, const char *value, int length, URLPartSetF url_f)
+static TSReturnCode
+URLPartSet(TSMBuffer bufp, TSMLoc obj, const char *value, int length, URLPartSetF url_f)
 {
 
-  if ((sdk_sanity_check_mbuffer(bufp) != INK_SUCCESS) ||
-      (sdk_sanity_check_url_handle(obj) != INK_SUCCESS) ||
-      (sdk_sanity_check_null_ptr((void *) value) != INK_SUCCESS) || (!isWriteable(bufp))
-    ) {
-    return INK_ERROR;
-  }
+  if ((sdk_sanity_check_mbuffer(bufp) != TS_SUCCESS) ||
+      (sdk_sanity_check_url_handle(obj) != TS_SUCCESS) ||
+      (sdk_sanity_check_null_ptr((void *) value) != TS_SUCCESS) || (!isWriteable(bufp)))
+    return TS_ERROR;
 
   URL u;
   u.m_heap = ((HdrHeapSDKHandle *) bufp)->m_heap;
@@ -2437,80 +2285,71 @@ URLPartSet(INKMBuffer bufp, INKMLoc obj,
     length = strlen(value);
 
   (u.*url_f) (value, length);
-  return INK_SUCCESS;
+  return TS_SUCCESS;
 }
 
 const char *
-INKUrlSchemeGet(INKMBuffer bufp, INKMLoc obj, int *length)
+TSUrlSchemeGet(TSMBuffer bufp, TSMLoc obj, int *length)
 {
   return URLPartGet(bufp, obj, length, &URL::scheme_get);
 }
 
-INKReturnCode
-INKUrlSchemeSet(INKMBuffer bufp, INKMLoc obj, const char *value, int length)
+TSReturnCode
+TSUrlSchemeSet(TSMBuffer bufp, TSMLoc obj, const char *value, int length)
 {
-  if (sdk_sanity_check_null_ptr((void *) value) == INK_SUCCESS) {
+  if (sdk_sanity_check_null_ptr((void *) value) == TS_SUCCESS)
     return URLPartSet(bufp, obj, value, length, &URL::scheme_set);
-  }
-
-  return INK_ERROR;
+  return TS_ERROR;
 }
 
 /* Internet specific URLs */
 
 const char *
-INKUrlUserGet(INKMBuffer bufp, INKMLoc obj, int *length)
+TSUrlUserGet(TSMBuffer bufp, TSMLoc obj, int *length)
 {
   return URLPartGet(bufp, obj, length, &URL::user_get);
 }
 
-INKReturnCode
-INKUrlUserSet(INKMBuffer bufp, INKMLoc obj, const char *value, int length)
+TSReturnCode
+TSUrlUserSet(TSMBuffer bufp, TSMLoc obj, const char *value, int length)
 {
   return URLPartSet(bufp, obj, value, length, &URL::user_set);
 }
 
 const char *
-INKUrlPasswordGet(INKMBuffer bufp, INKMLoc obj, int *length)
+TSUrlPasswordGet(TSMBuffer bufp, TSMLoc obj, int *length)
 {
   return URLPartGet(bufp, obj, length, &URL::password_get);
 }
 
-INKReturnCode
-INKUrlPasswordSet(INKMBuffer bufp, INKMLoc obj, const char *value, int length)
+TSReturnCode
+TSUrlPasswordSet(TSMBuffer bufp, TSMLoc obj, const char *value, int length)
 {
-  if (sdk_sanity_check_null_ptr((void *) value) == INK_SUCCESS) {
+  if (sdk_sanity_check_null_ptr((void *) value) == TS_SUCCESS)
     return URLPartSet(bufp, obj, value, length, &URL::password_set);
-  }
-
-  return INK_ERROR;
-
+  return TS_ERROR;
 }
 
 const char *
-INKUrlHostGet(INKMBuffer bufp, INKMLoc obj, int *length)
+TSUrlHostGet(TSMBuffer bufp, TSMLoc obj, int *length)
 {
   return URLPartGet(bufp, obj, length, &URL::host_get);
 }
 
-INKReturnCode
-INKUrlHostSet(INKMBuffer bufp, INKMLoc obj, const char *value, int length)
+TSReturnCode
+TSUrlHostSet(TSMBuffer bufp, TSMLoc obj, const char *value, int length)
 {
-  if (sdk_sanity_check_null_ptr((void *) value) == INK_SUCCESS) {
+  if (sdk_sanity_check_null_ptr((void *) value) == TS_SUCCESS)
     return URLPartSet(bufp, obj, value, length, &URL::host_set);
-  }
-
-  return INK_ERROR;
-
+  return TS_ERROR;
 }
 
 int
-INKUrlPortGet(INKMBuffer bufp, INKMLoc obj)
+TSUrlPortGet(TSMBuffer bufp, TSMLoc obj)
 {
-  if ((sdk_sanity_check_mbuffer(bufp) != INK_SUCCESS) || (sdk_sanity_check_url_handle(obj) != INK_SUCCESS)
-    ) {
-    return INK_ERROR;
-  }
+  if ((sdk_sanity_check_mbuffer(bufp) != TS_SUCCESS) || (sdk_sanity_check_url_handle(obj) != TS_SUCCESS))
+    return TS_ERROR;
+
   URL u;
   u.m_heap = ((HdrHeapSDKHandle *) bufp)->m_heap;
   u.m_url_impl = (URLImpl *) obj;
@@ -2518,136 +2357,123 @@ INKUrlPortGet(INKMBuffer bufp, INKMLoc o
   return u.port_get();
 }
 
-INKReturnCode
-INKUrlPortSet(INKMBuffer bufp, INKMLoc obj, int port)
+TSReturnCode
+TSUrlPortSet(TSMBuffer bufp, TSMLoc obj, int port)
 {
   // Allow to modify the buffer only
   // if bufp is modifiable. If bufp is not modifiable return
-  // INK_ERROR. If allowed, return INK_SUCCESS. Changed the
-  // return value of function from void to INKReturnCode.
-  if ((sdk_sanity_check_mbuffer(bufp) == INK_SUCCESS) &&
-      (sdk_sanity_check_url_handle(obj) == INK_SUCCESS) && isWriteable(bufp) && (port > 0)
-    ) {
+  // TS_ERROR. If allowed, return TS_SUCCESS. Changed the
+  // return value of function from void to TSReturnCode.
+  if ((sdk_sanity_check_mbuffer(bufp) == TS_SUCCESS) &&
+      (sdk_sanity_check_url_handle(obj) == TS_SUCCESS) && isWriteable(bufp) && (port > 0)) {
     URL u;
+
     u.m_heap = ((HdrHeapSDKHandle *) bufp)->m_heap;
     u.m_url_impl = (URLImpl *) obj;
     u.port_set(port);
-    return INK_SUCCESS;
-  } else {
-    return INK_ERROR;
+    return TS_SUCCESS;
   }
+  return TS_ERROR;
 }
 
 /* FTP and HTTP specific URLs  */
 
 const char *
-INKUrlPathGet(INKMBuffer bufp, INKMLoc obj, int *length)
+TSUrlPathGet(TSMBuffer bufp, TSMLoc obj, int *length)
 {
   return URLPartGet(bufp, obj, length, &URL::path_get);
 }
 
-INKReturnCode
-INKUrlPathSet(INKMBuffer bufp, INKMLoc obj, const char *value, int length)
+TSReturnCode
+TSUrlPathSet(TSMBuffer bufp, TSMLoc obj, const char *value, int length)
 {
-  if (sdk_sanity_check_null_ptr((void *) value) == INK_SUCCESS) {
+  if (sdk_sanity_check_null_ptr((void *) value) == TS_SUCCESS)
     return URLPartSet(bufp, obj, value, length, &URL::path_set);
-  }
-
-  return INK_ERROR;
+  return TS_ERROR;
 }
 
 /* FTP specific URLs */
 
 int
-INKUrlFtpTypeGet(INKMBuffer bufp, INKMLoc obj)
+TSUrlFtpTypeGet(TSMBuffer bufp, TSMLoc obj)
 {
-  if ((sdk_sanity_check_mbuffer(bufp) != INK_SUCCESS) || (sdk_sanity_check_url_handle(obj) != INK_SUCCESS)
-    ) {
-    return INK_ERROR;
-  }
+  if ((sdk_sanity_check_mbuffer(bufp) != TS_SUCCESS) || (sdk_sanity_check_url_handle(obj) != TS_SUCCESS))
+    return TS_ERROR;
+
   URL u;
   u.m_heap = ((HdrHeapSDKHandle *) bufp)->m_heap;
   u.m_url_impl = (URLImpl *) obj;
-
   return u.type_get();
 }
 
-INKReturnCode
-INKUrlFtpTypeSet(INKMBuffer bufp, INKMLoc obj, int type)
+TSReturnCode
+TSUrlFtpTypeSet(TSMBuffer bufp, TSMLoc obj, int type)
 {
   // Allow to modify the buffer only
   // if bufp is modifiable. If bufp is not modifiable return
-  // INK_ERROR. If allowed, return INK_SUCCESS. Changed the
-  // return value of function from void to INKReturnCode.
+  // TS_ERROR. If allowed, return TS_SUCCESS. Changed the
+  // return value of function from void to TSReturnCode.
 
   //The valid values are : 0, 65('A'), 97('a'),
   //69('E'), 101('e'), 73 ('I') and 105('i').
 
-  if ((sdk_sanity_check_mbuffer(bufp) == INK_SUCCESS) &&
-      (sdk_sanity_check_url_handle(obj) == INK_SUCCESS) &&
-      (type == 0 || type == 'A' || type == 'E' || type == 'I' ||
-       type == 'a' || type == 'i' || type == 'e') && isWriteable(bufp)
-    ) {
+  if ((sdk_sanity_check_mbuffer(bufp) == TS_SUCCESS) &&
+      (sdk_sanity_check_url_handle(obj) == TS_SUCCESS) &&
+      (type == 0 || type == 'A' || type == 'E' || type == 'I' || type == 'a' || type == 'i' || type == 'e') &&
+      isWriteable(bufp)) {
     URL u;
+
     u.m_heap = ((HdrHeapSDKHandle *) bufp)->m_heap;
     u.m_url_impl = (URLImpl *) obj;
     u.type_set(type);
-    return INK_SUCCESS;
-  } else {
-    return INK_ERROR;
+    return TS_SUCCESS;
   }
+  return TS_ERROR;
 }
 
 /* HTTP specific URLs */
 
 const char *
-INKUrlHttpParamsGet(INKMBuffer bufp, INKMLoc obj, int *length)
+TSUrlHttpParamsGet(TSMBuffer bufp, TSMLoc obj, int *length)
 {
   return URLPartGet(bufp, obj, length, &URL::params_get);
 }
 
-INKReturnCode

[... 6972 lines stripped ...]