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 ...]