svn commit: r1035782 [7/29] - in /trafficserver/traffic/trunk: example/add-header/ example/append-transform/ example/basic-auth/ example/blacklist-0/ example/blacklist-1/ example/bnull-transform/ example/cache_plugin/ example/cache_scan/ example/file-1...

[zw...@apache.org]

Modified: trafficserver/traffic/trunk/proxy/InkAPI.cc
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/proxy/InkAPI.cc?rev=1035782&r1=1035781&r2=1035782&view=diff
==============================================================================
--- trafficserver/traffic/trunk/proxy/InkAPI.cc (original)
+++ trafficserver/traffic/trunk/proxy/InkAPI.cc Tue Nov 16 20:22:02 2010
@@ -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>
 
@@ -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; \
@@ -127,252 +91,252 @@ RecRawStatBlock *api_rsb;
 
 
 /* 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_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_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;
@@ -385,7 +349,7 @@ 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;
 
 ////////////////////////////////////////////////////////////////////
 //
@@ -393,7 +357,7 @@ inkapi const void *INK_ERROR_PTR = (cons
 //
 ////////////////////////////////////////////////////////////////////
 void
-INKError(const char *fmt, ...)
+TSError(const char *fmt, ...)
 {
   va_list args;
 
@@ -409,7 +373,7 @@ 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);
@@ -417,7 +381,7 @@ _INKReleaseAssert(const char *text, cons
 
 // 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);
@@ -499,218 +463,218 @@ _hdr_obj_to_mime_hdr_impl(HdrHeapObjImpl
 }
 
 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));
 }
 
-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
 }
 
@@ -720,7 +684,7 @@ sdk_sanity_check_null_ptr(void *ptr)
 
 */
 bool
-isWriteable(INKMBuffer bufp)
+isWriteable(TSMBuffer bufp)
 {
   if (bufp != NULL) {
     return (((HdrHeapSDKHandle *) bufp)->m_heap->m_writeable);
@@ -735,7 +699,7 @@ 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;
@@ -747,7 +711,7 @@ sdk_alloc_field_handle(INKMBuffer bufp, 
 }
 
 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;
@@ -759,7 +723,7 @@ sdk_free_field_handle(INKMBuffer bufp, M
 }
 
 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;
@@ -1007,21 +971,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);
 
@@ -1041,7 +1005,7 @@ INKContInternal::destroy()
     m_free_magic = INKCONT_INTERN_MAGIC_DEAD;
     INKContAllocator.free(this);
   } else {
-    INKContSchedule(this, 0);
+    TSContSchedule(this, 0);
   }
 }
 
@@ -1066,10 +1030,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);
@@ -1085,7 +1049,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]);
@@ -1106,7 +1070,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;
 }
@@ -1124,7 +1088,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;
@@ -1132,7 +1096,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);
@@ -1162,7 +1126,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;
 }
@@ -1223,9 +1187,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;
@@ -1282,16 +1246,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:
@@ -1302,7 +1266,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:
@@ -1382,7 +1346,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;
@@ -1394,21 +1358,21 @@ 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)
+HttpAPIHooks::append(TSHttpHookID id, INKContInternal *cont)
 {
   hooks_set = 1;
   m_hooks[id].append(cont);
 }
 
 APIHook *
-HttpAPIHooks::get(INKHttpHookID id)
+HttpAPIHooks::get(TSHttpHookID id)
 {
   return m_hooks[id].get();
 }
@@ -1433,7 +1397,7 @@ CacheAPIHooks::clear()
   APIHook *next_hook;
   int i;
 
-  for (i = 0; i < INK_CACHE_LAST_HOOK; i++) {
+  for (i = 0; i < TS_CACHE_LAST_HOOK; i++) {
     api_hook = m_hooks[i].get();
     while (api_hook) {
       next_hook = api_hook->m_link.next;
@@ -1445,20 +1409,20 @@ CacheAPIHooks::clear()
 }
 
 void
-CacheAPIHooks::append(INKCacheHookID id, INKContInternal *cont)
+CacheAPIHooks::append(TSCacheHookID id, INKContInternal *cont)
 {
   hooks_set = 1;
   m_hooks[id].append(cont);
 }
 
 APIHook *
-CacheAPIHooks::get(INKCacheHookID id)
+CacheAPIHooks::get(TSCacheHookID id)
 {
   return m_hooks[id].get();
 }
 
 void
-CacheAPIHooks::prepend(INKCacheHookID id, INKContInternal *cont)
+CacheAPIHooks::prepend(TSCacheHookID id, INKContInternal *cont)
 {
   hooks_set = 1;
   m_hooks[id].prepend(cont);
@@ -1556,244 +1520,244 @@ 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_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;
+    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);
@@ -1822,26 +1786,26 @@ api_init()
 ////////////////////////////////////////////////////////////////////
 
 void *
-_INKmalloc(size_t size, const char *path)
+_TSmalloc(size_t size, const char *path)
 {
   return _xmalloc(size, path);
 }
 
 void *
-_INKrealloc(void *ptr, size_t 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, int64 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);
 }
@@ -1853,19 +1817,19 @@ _INKfree(void *ptr)
 ////////////////////////////////////////////////////////////////////
 
 unsigned int
-INKrandom()
+TSrandom()
 {
   return this_ethread()->generator.random();
 }
 
 double
-INKdrandom()
+TSdrandom()
 {
   return this_ethread()->generator.drandom();
 }
 
 ink_hrtime
-INKhrtime()
+TShrtime()
 {
   return ink_get_based_hrtime();
 }
@@ -1877,25 +1841,25 @@ 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;
 }
 
 const char *
-INKPluginDirGet(void)
+TSPluginDirGet(void)
 {
   static char path[PATH_NAME_MAX + 1] = "";
 
@@ -1921,20 +1885,20 @@ 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;
@@ -1961,16 +1925,16 @@ 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;
 
@@ -1989,7 +1953,7 @@ INKPluginInfoRegister(INKPluginRegistrat
     plugin_reg_current->support_email = xstrdup(plugin_info->support_email);
   }
 
-  return INK_SUCCESS;
+  return TS_SUCCESS;
 }
 
 ////////////////////////////////////////////////////////////////////
@@ -1998,8 +1962,8 @@ INKPluginInfoRegister(INKPluginRegistrat
 //
 ////////////////////////////////////////////////////////////////////
 
-INKFile
-INKfopen(const char *filename, const char *mode)
+TSFile
+TSfopen(const char *filename, const char *mode)
 {
   FileImpl *file;
 
@@ -2009,11 +1973,11 @@ 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();
@@ -2021,28 +1985,28 @@ INKfclose(INKFile filep)
 }
 
 size_t
-INKfread(INKFile filep, void *buf, size_t length)
+TSfread(TSFile filep, void *buf, size_t length)
 {
   FileImpl *file = (FileImpl *) filep;
   return file->fread(buf, length);
 }
 
 size_t
-INKfwrite(INKFile filep, const void *buf, size_t length)
+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, size_t length)
+TSfgets(TSFile filep, char *buf, size_t length)
 {
   FileImpl *file = (FileImpl *) filep;
   return file->fgets(buf, length);
@@ -2054,55 +2018,55 @@ INKfgets(INKFile filep, char *buf, size_
 //
 ////////////////////////////////////////////////////////////////////
 
-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);
 }
 
 ////////////////////////////////////////////////////////////////////
@@ -2111,37 +2075,37 @@ 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);
 }
 
-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;
+    return TS_SUCCESS;
   } else {
-    return INK_ERROR;
+    return TS_ERROR;
   }
 }
 
@@ -2151,49 +2115,49 @@ INKMBufferDestroy(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)));
+    return ((TSMLoc) (url_create(heap)));
   } else {
-    return (INKMLoc) INK_ERROR_PTR;
+    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;
+    return TS_SUCCESS;
   } else {
-    return INK_ERROR;
+    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;
@@ -2203,23 +2167,23 @@ 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);
+    return ((TSMLoc) d_url);
   } else {
-    return (INKMLoc) INK_ERROR_PTR;
+    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;
@@ -2230,14 +2194,14 @@ 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;
+    return TS_SUCCESS;
   } else {
-    return INK_ERROR;
+    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;
@@ -2245,9 +2209,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;
@@ -2271,17 +2235,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;
@@ -2292,20 +2256,20 @@ 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));
 }
 
 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));
@@ -2316,12 +2280,12 @@ typedef const char *(URL::*URLPartGetF) 
 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;
@@ -2339,14 +2303,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;
@@ -2357,78 +2321,78 @@ 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;
@@ -2437,50 +2401,50 @@ 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;
+    return TS_SUCCESS;
   } else {
-    return INK_ERROR;
+    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;
@@ -2489,80 +2453,80 @@ INKUrlFtpTypeGet(INKMBuffer bufp, INKMLo
   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) &&
+  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;
+    return TS_SUCCESS;
   } else {
-    return INK_ERROR;
+    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
-INKUrlHttpParamsSet(INKMBuffer bufp, INKMLoc obj, const char *value, int length)
+TSReturnCode
+TSUrlHttpParamsSet(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::params_set);
   }
 
-  return INK_ERROR;
+  return TS_ERROR;
 
 }
 
 const char *
-INKUrlHttpQueryGet(INKMBuffer bufp, INKMLoc obj, int *length)
+TSUrlHttpQueryGet(TSMBuffer bufp, TSMLoc obj, int *length)
 {
   return URLPartGet(bufp, obj, length, &URL::query_get);
 }
 
-INKReturnCode
-INKUrlHttpQuerySet(INKMBuffer bufp, INKMLoc obj, const char *value, int length)
+TSReturnCode
+TSUrlHttpQuerySet(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::query_set);
   }
 
-  return INK_ERROR;
+  return TS_ERROR;
 }
 
 const char *
-INKUrlHttpFragmentGet(INKMBuffer bufp, INKMLoc obj, int *length)
+TSUrlHttpFragmentGet(TSMBuffer bufp, TSMLoc obj, int *length)
 {
   return URLPartGet(bufp, obj, length, &URL::fragment_get);
 }
 
-INKReturnCode
-INKUrlHttpFragmentSet(INKMBuffer bufp, INKMLoc obj, const char *value, int length)
+TSReturnCode
+TSUrlHttpFragmentSet(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::fragment_set);
   }
 
-  return INK_ERROR;
+  return TS_ERROR;
 
 }
 
@@ -2576,90 +2540,90 @@ INKUrlHttpFragmentSet(INKMBuffer bufp, I
 /* MimeParser */
 /**************/
 
-INKMimeParser
-INKMimeParserCreate()
+TSMimeParser
+TSMimeParserCreate()
 {
-  INKMimeParser parser;
+  TSMimeParser parser;
 
-  parser = INKmalloc(sizeof(MIMEParser));
-  if (sdk_sanity_check_mime_parser(parser) != INK_SUCCESS) {
-    INKfree(parser);
-    return (INKMimeParser) INK_ERROR_PTR;
+  parser = xmalloc(sizeof(MIMEParser));
+  if (sdk_sanity_check_mime_parser(parser) != TS_SUCCESS) {
+    xfree(parser);
+    return (TSMimeParser) TS_ERROR_PTR;
   }
   mime_parser_init((MIMEParser *) parser);
 
   return parser;
 }
 
-INKReturnCode
-INKMimeParserClear(INKMimeParser parser)
+TSReturnCode
+TSMimeParserClear(TSMimeParser parser)
 {
-  if (sdk_sanity_check_mime_parser(parser) != INK_SUCCESS) {
-    return INK_ERROR;
+  if (sdk_sanity_check_mime_parser(parser) != TS_SUCCESS) {
+    return TS_ERROR;
   }
   mime_parser_clear((MIMEParser *) parser);
-  return INK_SUCCESS;
+  return TS_SUCCESS;
 }
 
-INKReturnCode
-INKMimeParserDestroy(INKMimeParser parser)
+TSReturnCode
+TSMimeParserDestroy(TSMimeParser parser)
 {
-  if (sdk_sanity_check_mime_parser(parser) != INK_SUCCESS) {
-    return INK_ERROR;
+  if (sdk_sanity_check_mime_parser(parser) != TS_SUCCESS) {
+    return TS_ERROR;
   }
   mime_parser_clear((MIMEParser *) parser);
-  INKfree(parser);
-  return INK_SUCCESS;
+  xfree(parser);
+  return TS_SUCCESS;
 }
 
 /***********/
 /* MimeHdr */
 /***********/
 
-// INKMBuffer: pointers to HdrHeapSDKHandle objects
-// INKMLoc:    pointers to MIMEFieldSDKHandle objects
+// TSMBuffer: pointers to HdrHeapSDKHandle objects
+// TSMLoc:    pointers to MIMEFieldSDKHandle objects
 
-INKMLoc
-INKMimeHdrCreate(INKMBuffer bufp)
+TSMLoc
+TSMimeHdrCreate(TSMBuffer bufp)
 {
   // Allow to modify the buffer only
   // if bufp is modifiable. If bufp is not modifiable return
-  // INK_ERROR. If not allowed, return NULL.
-  // Changed the return value for SDK3.0 from NULL to INK_ERROR_PTR.
-  if ((sdk_sanity_check_mbuffer(bufp) == INK_SUCCESS) && isWriteable(bufp)) {
-    return (INKMLoc) mime_hdr_create(((HdrHeapSDKHandle *) bufp)->m_heap);
+  // TS_ERROR. If not allowed, return NULL.
+  // Changed the return value for SDK3.0 from NULL to TS_ERROR_PTR.
+  if ((sdk_sanity_check_mbuffer(bufp) == TS_SUCCESS) && isWriteable(bufp)) {
+    return (TSMLoc) mime_hdr_create(((HdrHeapSDKHandle *) bufp)->m_heap);
   } else {
-    return (INKMLoc) INK_ERROR_PTR;
+    return (TSMLoc) TS_ERROR_PTR;
   }
 }
 
-INKReturnCode
-INKMimeHdrDestroy(INKMBuffer bufp, INKMLoc obj)
+TSReturnCode
+TSMimeHdrDestroy(TSMBuffer bufp, TSMLoc 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(bufp) == INK_SUCCESS) &&
-      ((sdk_sanity_check_mime_hdr_handle(obj) == INK_SUCCESS) || (sdk_sanity_check_http_hdr_handle(obj) == INK_SUCCESS))
+  // 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_mime_hdr_handle(obj) == TS_SUCCESS) || (sdk_sanity_check_http_hdr_handle(obj) == TS_SUCCESS))
       && isWriteable(bufp)) {
     MIMEHdrImpl *mh = _hdr_mloc_to_mime_hdr_impl(obj);
     mime_hdr_destroy(((HdrHeapSDKHandle *) bufp)->m_heap, mh);
-    return INK_SUCCESS;
+    return TS_SUCCESS;
   } else {
-    return INK_ERROR;
+    return TS_ERROR;
   }
 }
 
-INKMLoc
-INKMimeHdrClone(INKMBuffer dest_bufp, INKMBuffer src_bufp, INKMLoc src_hdr)
+TSMLoc
+TSMimeHdrClone(TSMBuffer dest_bufp, TSMBuffer src_bufp, TSMLoc src_hdr)
 {
   // Allow to modify the buffer only
   // if bufp is modifiable. If bufp is not modifiable return
-  // INK_ERROR. If not allowed, return NULL.

[... 5516 lines stripped ...]