Modified: trafficserver/traffic/trunk/proxy/UserNameCacheTest.cc URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/proxy/UserNameCacheTest.cc?rev=1035782&r1=1035781&r2=1035782&view=diff ============================================================================== --- trafficserver/traffic/trunk/proxy/UserNameCacheTest.cc (original) +++ trafficserver/traffic/trunk/proxy/UserNameCacheTest.cc Tue Nov 16 20:22:02 2010 @@ -25,36 +25,36 @@ #include "UserNameCacheTest.h" #include <stdio.h> -INKMutex testMutexp; +TSMutex testMutexp; char USER_NAME[] = "Lou Sheward."; -char userName[INK_MAX_USER_NAME_LEN]; +char userName[TS_MAX_USER_NAME_LEN]; FILE *fp; void userNameCacheTestInit() { - INKCont cont; + TSCont cont; - testMutexp = INKMutexCreate(); - cont = INKContCreate(&UserNameHandleCallbacks, testMutexp); + testMutexp = TSMutexCreate(); + cont = TSContCreate(&UserNameHandleCallbacks, testMutexp); for (int i = 1; i < 1000; i++) { - if (INKUserNameCacheInsert(cont, i, USER_NAME) == INK_EVENT_IMMEDIATE) { + if (TSUserNameCacheInsert(cont, i, USER_NAME) == TS_EVENT_IMMEDIATE) { fp = fopen("cacheTest.txt", "a+"); fprintf(fp, "Insertion immedaite"); fprintf(fp, " %d,%s\n", i, USER_NAME); fclose(fp); } - if (INKUserNameCacheLookup(cont, i, userName) == INK_EVENT_IMMEDIATE) { + if (TSUserNameCacheLookup(cont, i, userName) == TS_EVENT_IMMEDIATE) { fp = fopen("cacheTest.txt", "a+"); fprintf(fp, "lookup immedaite"); fprintf(fp, " %d,%s\n", i, userName); fclose(fp); } - if (INKUserNameCacheDelete(cont, i) == INK_EVENT_IMMEDIATE) { + if (TSUserNameCacheDelete(cont, i) == TS_EVENT_IMMEDIATE) { fp = fopen("cacheTest.txt", "a+"); fprintf(fp, "delete immediate\n"); fclose(fp); @@ -63,20 +63,20 @@ userNameCacheTestInit() } int -UserNameHandleCallbacks(INKCont cont, INKEvent event, void *e) +UserNameHandleCallbacks(TSCont cont, TSEvent event, void *e) { fp = fopen("cacheTest.txt", "a+"); switch (event) { - case INK_CACHE_COULD_NOT_FIND: + case TS_CACHE_COULD_NOT_FIND: fprintf(fp, "Lookup callback, could not find\n"); break; - case INK_CACHE_LOOKUP_COMPLETE: + case TS_CACHE_LOOKUP_COMPLETE: fprintf(fp, "Lookup callback, success\n"); break; } fclose(fp); - return INK_EVENT_NONE; + return TS_EVENT_NONE; }
Modified: trafficserver/traffic/trunk/proxy/api/ts/InkAPIHughes.h URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/proxy/api/ts/InkAPIHughes.h?rev=1035782&r1=1035781&r2=1035782&view=diff ============================================================================== --- trafficserver/traffic/trunk/proxy/api/ts/InkAPIHughes.h (original) +++ trafficserver/traffic/trunk/proxy/api/ts/InkAPIHughes.h Tue Nov 16 20:22:02 2010 @@ -29,12 +29,12 @@ typedef struct { /*request header */ - INKMBuffer request_buf; - INKMLoc request_loc; + TSMBuffer request_buf; + TSMLoc request_loc; /*response header */ - INKMBuffer response_buf; - INKMLoc response_loc; + TSMBuffer response_buf; + TSMLoc response_loc; /*child ip addr in network order */ unsigned int client_ip; @@ -46,8 +46,8 @@ typedef struct int present_in_cache; /* Reader for the buffer which contains the prefetched object */ - INKIOBuffer object_buf; - INKIOBufferReader object_buf_reader; + TSIOBuffer object_buf; + TSIOBufferReader object_buf_reader; /* This specifies if we need to invoke the OBJECT_HOOK and whether we need to send the buffer to child as well @@ -59,51 +59,51 @@ typedef struct unsigned int url_proto; unsigned int url_response_proto; -} INKPrefetchInfo; +} TSPrefetchInfo; -typedef int (*INKPrefetchHook) (int hook, INKPrefetchInfo * prefetch_info); +typedef int (*TSPrefetchHook) (int hook, TSPrefetchInfo * prefetch_info); enum -{ /* return type for INKPrefetchHook */ - INK_PREFETCH_CONTINUE, - INK_PREFETCH_DISCONTINUE +{ /* return type for TSPrefetchHook */ + TS_PREFETCH_CONTINUE, + TS_PREFETCH_DISCONTINUE }; enum { - INK_PREFETCH_PROTO_TCP = 1, - INK_PREFETCH_PROTO_UDP + TS_PREFETCH_PROTO_TCP = 1, + TS_PREFETCH_PROTO_UDP }; enum { - INK_PREFETCH_OBJ_BUF_NOT_NEEDED = 0, - INK_PREFETCH_OBJ_BUF_NEEDED, /* The user wants the buffer but does not + TS_PREFETCH_OBJ_BUF_NOT_NEEDED = 0, + TS_PREFETCH_OBJ_BUF_NEEDED, /* The user wants the buffer but does not want it to be transmitted to the child */ - INK_PREFETCH_OBJ_BUF_NEEDED_N_TRANSMITTED /* The object should + TS_PREFETCH_OBJ_BUF_NEEDED_N_TRANSMITTED /* The object should be transmitted as well */ }; enum { /* prefetch hooks */ - INK_PREFETCH_PRE_PARSE_HOOK, + TS_PREFETCH_PRE_PARSE_HOOK, /* This hook is invoked just before we begin to parse a document request and response headers are available. - Return value: INK_PREFETCH_CONTINUE :continue parsing - INK_PREFETCH_DISCONTIUE: don't bother parser + Return value: TS_PREFETCH_CONTINUE :continue parsing + TS_PREFETCH_DISCONTIUE: don't bother parser */ - INK_PREFETCH_EMBEDDED_URL_HOOK, + TS_PREFETCH_EMBEDDED_URL_HOOK, /* This hook is invoked when a URL is extracted. url_proto and url_response_proto contain the default protocols used for sending the url and actual url object respectively to the child. The hook can change thes to one of the 3 methods mentioned above. - Return value: INK_PREFETCH_CONTINUE : prefetch this url. - INK_PREFETCH_DISCONTIUE: don't bother prefetching this + Return value: TS_PREFETCH_CONTINUE : prefetch this url. + TS_PREFETCH_DISCONTIUE: don't bother prefetching this url */ - INK_PREFETCH_EMBEDDED_OBJECT_HOOK + TS_PREFETCH_EMBEDDED_OBJECT_HOOK /* This hook is invoked when the user wants to have access to the buffer of the embedded object we prefetched. We pass in the buffer reader. The reader contains the data in the format specified in the Prefetch @@ -111,16 +111,16 @@ enum It is the users responsibility to free the reader. The only valid field in the PrefetchInfo structure object_buf_reader. embedded_url, object_buf, object_buf_reader, and object_buf_status are - set in INKPrefetchInfo passed as arguments + set in TSPrefetchInfo passed as arguments */ /* more hooks */ }; -inkapi int INKPrefetchStart(); +tsapi int TSPrefetchStart(); /* This starts the Prefetch engine in Traffic Server Return value 0 indicates success.*/ -inkapi int INKPrefetchHookSet(int hook_no, INKPrefetchHook hook_fn); +tsapi int TSPrefetchHookSet(int hook_no, TSPrefetchHook hook_fn); /* Registers a hook for the given hook_no. A hook is already present, it is replace by hook_fn return value 0 indicates success */ Modified: trafficserver/traffic/trunk/proxy/api/ts/InkAPIPrivateIOCore.h URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/proxy/api/ts/InkAPIPrivateIOCore.h?rev=1035782&r1=1035781&r2=1035782&view=diff ============================================================================== --- trafficserver/traffic/trunk/proxy/api/ts/InkAPIPrivateIOCore.h (original) +++ trafficserver/traffic/trunk/proxy/api/ts/InkAPIPrivateIOCore.h Tue Nov 16 20:22:02 2010 @@ -50,9 +50,9 @@ class INKContInternal:public DummyVConne { public: INKContInternal(); - INKContInternal(INKEventFunc funcp, INKMutex mutexp); + INKContInternal(TSEventFunc funcp, TSMutex mutexp); - void init(INKEventFunc funcp, INKMutex mutexp); + void init(TSEventFunc funcp, TSMutex mutexp); virtual void destroy(); void handle_event_count(int event); @@ -69,7 +69,7 @@ public: public: void *mdata; - INKEventFunc m_event_func; + TSEventFunc m_event_func; volatile int m_event_count; volatile int m_closed; int m_deletable; @@ -88,12 +88,12 @@ public: }; -enum INKApiDataType +enum TSApiDataType { - INK_API_DATA_READ_VIO = VCONNECTION_API_DATA_BASE, - INK_API_DATA_WRITE_VIO, - INK_API_DATA_OUTPUT_VC, - INK_API_DATA_CLOSED + TS_API_DATA_READ_VIO = VCONNECTION_API_DATA_BASE, + TS_API_DATA_WRITE_VIO, + TS_API_DATA_OUTPUT_VC, + TS_API_DATA_CLOSED }; @@ -101,9 +101,9 @@ class INKVConnInternal:public INKContInt { public: INKVConnInternal(); - INKVConnInternal(INKEventFunc funcp, INKMutex mutexp); + INKVConnInternal(TSEventFunc funcp, TSMutex mutexp); - void init(INKEventFunc funcp, INKMutex mutexp); + void init(TSEventFunc funcp, TSMutex mutexp); virtual void destroy(); int handle_event(int event, void *edata); @@ -157,8 +157,8 @@ public: #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)); +TSDebug ("sdk","(SDK) null mutex detected in critical region (mutex created)"); \ +TSDebug ("sdk","(SDK) please create continuation [%p] with mutex", (p)); #else static ink_mutex big_mux; @@ -173,7 +173,7 @@ static ink_mutex big_mux; if (( (INKContInternal*)_c)->mutex == NULL) { \ ( (INKContInternal*)_c)->mutex = new_ProxyMutex(); \ UNLOCK_MONGO_MUTEX; \ - MUX_WARNING(_c); \ + MUX_WARNING(_c); \ MUTEX_SET_AND_TAKE_LOCK(ml, ((INKContInternal*)_c)->mutex, this_ethread()); \ } else { \ UNLOCK_MONGO_MUTEX; \ @@ -185,9 +185,9 @@ extern "C" { #endif /* __cplusplus */ - INKReturnCode sdk_sanity_check_mutex(INKMutex); - INKReturnCode sdk_sanity_check_hostlookup_structure(INKHostLookupResult); - INKReturnCode sdk_sanity_check_iocore_structure(void *); + TSReturnCode sdk_sanity_check_mutex(TSMutex); + TSReturnCode sdk_sanity_check_hostlookup_structure(TSHostLookupResult); + TSReturnCode sdk_sanity_check_iocore_structure(void *); /* ---------------------------------------------------------------------- * @@ -195,16 +195,14 @@ extern "C" * * ---------------------------------------------------------------------- */ - inkapi INKMutex INKMutexCreateInternal(void); - inkapi int INKMutexCheck(INKMutex mutex); + tsapi TSMutex TSMutexCreateInternal(void); + tsapi int TSMutexCheck(TSMutex mutex); /* IOBuffer */ - inkapi void INKIOBufferReaderCopy(INKIOBufferReader readerp, const void *buf, int64 length); - inkapi int64 INKIOBufferBlockDataSizeGet(INKIOBufferBlock blockp); - inkapi INKReturnCode INKIOBufferBlockDestroy(INKIOBufferBlock blockp); - - + tsapi void TSIOBufferReaderCopy(TSIOBufferReader readerp, const void *buf, int64 length); + tsapi int64 TSIOBufferBlockDataSizeGet(TSIOBufferBlock blockp); + tsapi TSReturnCode TSIOBufferBlockDestroy(TSIOBufferBlock blockp); typedef void *INKUDPPacket; typedef void *INKUDPacketQueue; typedef void *INKUDPConn; @@ -212,60 +210,60 @@ extern "C" /**************************************************************************** * contact: OXYGEN ****************************************************************************/ - inkapi INKAction INKUDPBind(INKCont contp, unsigned int ip, int port); + tsapi TSAction INKUDPBind(TSCont contp, unsigned int ip, int port); /**************************************************************************** * contact: OXYGEN ****************************************************************************/ - inkapi INKAction INKUDPSendTo(INKCont contp, INKUDPConn udp, unsigned int ip, int port, char *buf, int len); + tsapi TSAction INKUDPSendTo(TSCont contp, INKUDPConn udp, unsigned int ip, int port, char *buf, int len); /**************************************************************************** * contact: OXYGEN ****************************************************************************/ - inkapi INKAction INKUDPRecvFrom(INKCont contp, INKUDPConn udp); + tsapi TSAction INKUDPRecvFrom(TSCont contp, INKUDPConn udp); /**************************************************************************** * Return file descriptor. * contact: OXYGEN ****************************************************************************/ - inkapi int INKUDPConnFdGet(INKUDPConn udp); + tsapi int INKUDPConnFdGet(INKUDPConn udp); /* ===== UDP Packet ===== */ /**************************************************************************** * contact: OXYGEN ****************************************************************************/ - inkapi INKUDPPacket INKUDPPacketCreate(); + tsapi INKUDPPacket INKUDPPacketCreate(); /**************************************************************************** * contact: OXYGEN ****************************************************************************/ - inkapi INKIOBufferBlock INKUDPPacketBufferBlockGet(INKUDPPacket packet); + tsapi TSIOBufferBlock INKUDPPacketBufferBlockGet(INKUDPPacket packet); /**************************************************************************** * contact: OXYGEN ****************************************************************************/ - inkapi unsigned int INKUDPPacketFromAddressGet(INKUDPPacket packet); + tsapi unsigned int INKUDPPacketFromAddressGet(INKUDPPacket packet); /**************************************************************************** * contact: OXYGEN ****************************************************************************/ - inkapi int INKUDPPacketFromPortGet(INKUDPPacket packet); + tsapi int INKUDPPacketFromPortGet(INKUDPPacket packet); /**************************************************************************** * contact: OXYGEN ****************************************************************************/ - inkapi INKUDPConn INKUDPPacketConnGet(INKUDPPacket packet); + tsapi INKUDPConn INKUDPPacketConnGet(INKUDPPacket packet); /**************************************************************************** * contact: OXYGEN ****************************************************************************/ - inkapi void INKUDPPacketDestroy(INKUDPPacket packet); + tsapi void INKUDPPacketDestroy(INKUDPPacket packet); /* ===== Packet Queue ===== */ /**************************************************************************** * contact: OXYGEN ****************************************************************************/ - inkapi INKUDPPacket INKUDPPacketGet(INKUDPacketQueue queuep); + tsapi INKUDPPacket INKUDPPacketGet(INKUDPacketQueue queuep); #ifdef __cplusplus } Modified: trafficserver/traffic/trunk/proxy/api/ts/experimental.h URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/proxy/api/ts/experimental.h?rev=1035782&r1=1035781&r2=1035782&view=diff ============================================================================== --- trafficserver/traffic/trunk/proxy/api/ts/experimental.h (original) +++ trafficserver/traffic/trunk/proxy/api/ts/experimental.h Tue Nov 16 20:22:02 2010 @@ -29,8 +29,8 @@ * Traffic Server, DO NOT USE anything in this file. */ -#ifndef __INK_API_EXPERIMENTAL_H__ -#define __INK_API_EXPERIMENTAL_H__ +#ifndef __TS_API_EXPERIMENTAL_H__ +#define __TS_API_EXPERIMENTAL_H__ #ifdef __cplusplus extern "C" @@ -38,74 +38,74 @@ extern "C" #endif /* __cplusplus */ /* Cache APIs that are not yet fully supported and/or frozen nor complete. */ - inkapi INKReturnCode INKCacheBufferInfoGet(INKCacheTxn txnp, uint64 * length, uint64 * offset); + tsapi TSReturnCode TSCacheBufferInfoGet(TSCacheTxn txnp, uint64 * length, uint64 * offset); - inkapi INKCacheHttpInfo INKCacheHttpInfoCreate(); - inkapi void INKCacheHttpInfoReqGet(INKCacheHttpInfo infop, INKMBuffer * bufp, INKMLoc * obj); - inkapi void INKCacheHttpInfoRespGet(INKCacheHttpInfo infop, INKMBuffer * bufp, INKMLoc * obj); - inkapi void INKCacheHttpInfoReqSet(INKCacheHttpInfo infop, INKMBuffer bufp, INKMLoc obj); - inkapi void INKCacheHttpInfoRespSet(INKCacheHttpInfo infop, INKMBuffer bufp, INKMLoc obj); - inkapi void INKCacheHttpInfoKeySet(INKCacheHttpInfo infop, INKCacheKey key); - inkapi void INKCacheHttpInfoSizeSet(INKCacheHttpInfo infop, int64 size); - inkapi int INKCacheHttpInfoVector(INKCacheHttpInfo infop, void *data, int length); + tsapi TSCacheHttpInfo TSCacheHttpInfoCreate(); + tsapi void TSCacheHttpInfoReqGet(TSCacheHttpInfo infop, TSMBuffer * bufp, TSMLoc * obj); + tsapi void TSCacheHttpInfoRespGet(TSCacheHttpInfo infop, TSMBuffer * bufp, TSMLoc * obj); + tsapi void TSCacheHttpInfoReqSet(TSCacheHttpInfo infop, TSMBuffer bufp, TSMLoc obj); + tsapi void TSCacheHttpInfoRespSet(TSCacheHttpInfo infop, TSMBuffer bufp, TSMLoc obj); + tsapi void TSCacheHttpInfoKeySet(TSCacheHttpInfo infop, TSCacheKey key); + tsapi void TSCacheHttpInfoSizeSet(TSCacheHttpInfo infop, int64 size); + tsapi int TSCacheHttpInfoVector(TSCacheHttpInfo infop, void *data, int length); /* -------------------------------------------------------------------------- This is an experimental stat system, which is not compatible with standard TS stats. It is disabled by default, enable it with --with_v2_stats at configure time. */ - inkapi INKReturnCode INKStatCreateV2(const char *name, uint32_t *stat_num); - inkapi INKReturnCode INKStatIncrementV2(uint32_t stat_num, int64 inc_by); - inkapi INKReturnCode INKStatIncrementByNameV2(const char *stat_name, int64 inc_by); - inkapi INKReturnCode INKStatDecrementV2(uint32_t stat_num, int64 dec_by); - inkapi INKReturnCode INKStatDecrementByNameV2(const char *stat_name, int64 dec_by); - inkapi INKReturnCode INKStatGetCurrentV2(uint32_t stat_num, int64 *stat_val); - inkapi INKReturnCode INKStatGetCurrentByNameV2(const char *stat_name, int64 *stat_val); - inkapi INKReturnCode INKStatGetV2(uint32_t stat_num, int64 *stat_val); - inkapi INKReturnCode INKStatGetByNameV2(const char *stat_name, int64 *stat_val); + tsapi TSReturnCode TSStatCreateV2(const char *name, uint32_t *stat_num); + tsapi TSReturnCode TSStatIncrementV2(uint32_t stat_num, int64 inc_by); + tsapi TSReturnCode TSStatIncrementByNameV2(const char *stat_name, int64 inc_by); + tsapi TSReturnCode TSStatDecrementV2(uint32_t stat_num, int64 dec_by); + tsapi TSReturnCode TSStatDecrementByNameV2(const char *stat_name, int64 dec_by); + tsapi TSReturnCode TSStatGetCurrentV2(uint32_t stat_num, int64 *stat_val); + tsapi TSReturnCode TSStatGetCurrentByNameV2(const char *stat_name, int64 *stat_val); + tsapi TSReturnCode TSStatGetV2(uint32_t stat_num, int64 *stat_val); + tsapi TSReturnCode TSStatGetByNameV2(const char *stat_name, int64 *stat_val); /* Do not edit these apis, used internally */ - inkapi int INKMimeHdrFieldEqual(INKMBuffer bufp, INKMLoc hdr_obj, INKMLoc field1, INKMLoc field2); - inkapi int INKHttpTxnHookRegisteredFor(INKHttpTxn txnp, INKHttpHookID id, INKEventFunc funcp); + tsapi int TSMimeHdrFieldEqual(TSMBuffer bufp, TSMLoc hdr_obj, TSMLoc field1, TSMLoc field2); + tsapi int TSHttpTxnHookRegisteredFor(TSHttpTxn txnp, TSHttpHookID id, TSEventFunc funcp); /* IP Lookup */ - typedef void *INKIPLookup; - typedef void *INKIPLookupState; - typedef void (*INKIPLookupPrintFunc) (void *data); - - inkapi void INKIPLookupPrint(INKIPLookup iplu, INKIPLookupPrintFunc pf); - inkapi void INKIPLookupNewEntry(INKIPLookup iplu, uint32 addr1, uint32 addr2, void *data); - inkapi int INKIPLookupMatchFirst(INKIPLookup iplu, uint32 addr, INKIPLookupState iplus, void **data); - inkapi int INKIPLookupMatchNext(INKIPLookup iplu, INKIPLookupState iplus, void **data); + typedef void *TSIPLookup; + typedef void *TSIPLookupState; + typedef void (*TSIPLookupPrintFunc) (void *data); + + tsapi void TSIPLookupPrint(TSIPLookup iplu, TSIPLookupPrintFunc pf); + tsapi void TSIPLookupNewEntry(TSIPLookup iplu, uint32 addr1, uint32 addr2, void *data); + tsapi int TSIPLookupMatchFirst(TSIPLookup iplu, uint32 addr, TSIPLookupState iplus, void **data); + tsapi int TSIPLookupMatchNext(TSIPLookup iplu, TSIPLookupState iplus, void **data); /* for Media-IXT mms over http */ typedef enum { - INK_HTTP_CNTL_GET_LOGGING_MODE, - INK_HTTP_CNTL_SET_LOGGING_MODE, - INK_HTTP_CNTL_GET_INTERCEPT_RETRY_MODE, - INK_HTTP_CNTL_SET_INTERCEPT_RETRY_MODE - } INKHttpCntlType; + TS_HTTP_CNTL_GET_LOGGING_MODE, + TS_HTTP_CNTL_SET_LOGGING_MODE, + TS_HTTP_CNTL_GET_INTERCEPT_RETRY_MODE, + TS_HTTP_CNTL_SET_INTERCEPT_RETRY_MODE + } TSHttpCntlType; -#define INK_HTTP_CNTL_OFF (void*) 0 -#define INK_HTTP_CNTL_ON (void*) 1 +#define TS_HTTP_CNTL_OFF (void*) 0 +#define TS_HTTP_CNTL_ON (void*) 1 /* usage: void *onoff = 0; - INKHttpTxnCntl(.., INK_HTTP_CNTL_GET_LOGGING_MODE, &onoff); - if (onoff == INK_HTTP_CNTL_ON) .... + TSHttpTxnCntl(.., TS_HTTP_CNTL_GET_LOGGING_MODE, &onoff); + if (onoff == TS_HTTP_CNTL_ON) .... */ - inkapi int INKHttpTxnCntl(INKHttpTxn txnp, INKHttpCntlType cntl, void *data); + tsapi int TSHttpTxnCntl(TSHttpTxn txnp, TSHttpCntlType cntl, void *data); /* Protocols APIs */ - inkapi void INKVConnCacheHttpInfoSet(INKVConn connp, INKCacheHttpInfo infop); + tsapi void TSVConnCacheHttpInfoSet(TSVConn connp, TSCacheHttpInfo infop); /* ICP freshness functions */ - typedef int (*INKPluginFreshnessCalcFunc) (INKCont contp); - inkapi void INKICPFreshnessFuncSet(INKPluginFreshnessCalcFunc funcp); + typedef int (*TSPluginFreshnessCalcFunc) (TSCont contp); + tsapi void TSICPFreshnessFuncSet(TSPluginFreshnessCalcFunc funcp); - inkapi int INKICPCachedReqGet(INKCont contp, INKMBuffer * bufp, INKMLoc * obj); - inkapi int INKICPCachedRespGet(INKCont contp, INKMBuffer * bufp, INKMLoc * obj); + tsapi int TSICPCachedReqGet(TSCont contp, TSMBuffer * bufp, TSMLoc * obj); + tsapi int TSICPCachedRespGet(TSCont contp, TSMBuffer * bufp, TSMLoc * obj); /* The rest is from the old "froze" private API include, we should consider @@ -115,74 +115,74 @@ extern "C" /**************************************************************************** * Create a new field and assign it a name ****************************************************************************/ - inkapi INKMLoc INKMimeHdrFieldCreateNamed(INKMBuffer bufp, INKMLoc mh_mloc, const char *name, int name_len); + tsapi TSMLoc TSMimeHdrFieldCreateNamed(TSMBuffer bufp, TSMLoc mh_mloc, const char *name, int name_len); /**************************************************************************** * Test if cache ready to accept request for a specific type of data ****************************************************************************/ - inkapi INKReturnCode INKCacheDataTypeReady(INKCacheDataType type, int *is_ready); + tsapi TSReturnCode TSCacheDataTypeReady(TSCacheDataType type, int *is_ready); /**************************************************************************** * When reenabling a txn in error, keep the connection open in case * of keepalive. ****************************************************************************/ - inkapi int INKHttpTxnClientKeepaliveSet(INKHttpTxn txnp); + tsapi int TSHttpTxnClientKeepaliveSet(TSHttpTxn txnp); /**************************************************************************** * Allow to set the body of a POST request. ****************************************************************************/ - inkapi void INKHttpTxnServerRequestBodySet(INKHttpTxn txnp, char *buf, int64 buflength); + tsapi void TSHttpTxnServerRequestBodySet(TSHttpTxn txnp, char *buf, int64 buflength); /* ===== High Resolution Time ===== */ -#define INK_HRTIME_FOREVER HRTIME_FOREVER -#define INK_HRTIME_DECADE HRTIME_DECADE -#define INK_HRTIME_YEAR HRTIME_YEAR -#define INK_HRTIME_WEEK HRTIME_WEEK -#define INK_HRTIME_DAY HRTIME_DAY -#define INK_HRTIME_HOUR HRTIME_HOUR -#define INK_HRTIME_MINUTE HRTIME_MINUTE -#define INK_HRTIME_SECOND HRTIME_SECOND -#define INK_HRTIME_MSECOND HRTIME_MSECOND -#define INK_HRTIME_USECOND HRTIME_USECOND -#define INK_HRTIME_NSECOND HRTIME_NSECOND +#define TS_HRTIME_FOREVER HRTIME_FOREVER +#define TS_HRTIME_DECADE HRTIME_DECADE +#define TS_HRTIME_YEAR HRTIME_YEAR +#define TS_HRTIME_WEEK HRTIME_WEEK +#define TS_HRTIME_DAY HRTIME_DAY +#define TS_HRTIME_HOUR HRTIME_HOUR +#define TS_HRTIME_MINUTE HRTIME_MINUTE +#define TS_HRTIME_SECOND HRTIME_SECOND +#define TS_HRTIME_MSECOND HRTIME_MSECOND +#define TS_HRTIME_USECOND HRTIME_USECOND +#define TS_HRTIME_NSECOND HRTIME_NSECOND -#define INK_HRTIME_APPROX_SECONDS(_x) HRTIME_APPROX_SECONDS(_x) -#define INK_HRTIME_APPROX_FACTOR HRTIME_APPROX_FACTOR +#define TS_HRTIME_APPROX_SECONDS(_x) HRTIME_APPROX_SECONDS(_x) +#define TS_HRTIME_APPROX_FACTOR HRTIME_APPROX_FACTOR /* //////////////////////////////////////////////////////////////////// // -// Map from units to ink_hrtime values +// Map from units to ts_hrtime values // //////////////////////////////////////////////////////////////////// */ -#define INK_HRTIME_YEARS(_x) HRTIME_YEARS(_x) -#define INK_HRTIME_WEEKS(_x) HRTIME_WEEKS(_x) -#define INK_HRTIME_DAYS(_x) HRTIME_DAYS(_x) -#define INK_HRTIME_HOURS(_x) HRTIME_HOURS(_x) -#define INK_HRTIME_MINUTES(_x) HRTIME_MINUTES(_x) -#define INK_HRTIME_SECONDS(_x) HRTIME_SECONDS(_x) -#define INK_HRTIME_MSECONDS(_x) HRTIME_MSECONDS(_x) -#define INK_HRTIME_USECONDS(_x) HRTIME_USECONDS(_x) -#define INK_HRTIME_NSECONDS(_x) HRTIME_NSECONDS(_x) +#define TS_HRTIME_YEARS(_x) HRTIME_YEARS(_x) +#define TS_HRTIME_WEEKS(_x) HRTIME_WEEKS(_x) +#define TS_HRTIME_DAYS(_x) HRTIME_DAYS(_x) +#define TS_HRTIME_HOURS(_x) HRTIME_HOURS(_x) +#define TS_HRTIME_MINUTES(_x) HRTIME_MINUTES(_x) +#define TS_HRTIME_SECONDS(_x) HRTIME_SECONDS(_x) +#define TS_HRTIME_MSECONDS(_x) HRTIME_MSECONDS(_x) +#define TS_HRTIME_USECONDS(_x) HRTIME_USECONDS(_x) +#define TS_HRTIME_NSECONDS(_x) HRTIME_NSECONDS(_x) /* ===== Time ===== */ - inkapi TSHRTime INKBasedTimeGet(); + tsapi TSHRTime TSBasedTimeGet(); /**************************************************************************** * Get time when Http TXN started ****************************************************************************/ - inkapi int INKHttpTxnStartTimeGet(INKHttpTxn txnp, TSHRTime * start_time); + tsapi int TSHttpTxnStartTimeGet(TSHttpTxn txnp, TSHRTime * start_time); /**************************************************************************** * Get time when Http TXN ended ****************************************************************************/ - inkapi int INKHttpTxnEndTimeGet(INKHttpTxn txnp, TSHRTime * end_time); + tsapi int TSHttpTxnEndTimeGet(TSHttpTxn txnp, TSHRTime * end_time); - inkapi int INKHttpTxnCachedRespTimeGet(INKHttpTxn txnp, time_t *resp_time); + tsapi int TSHttpTxnCachedRespTimeGet(TSHttpTxn txnp, time_t *resp_time); /* ===== Cache ===== */ - inkapi INKReturnCode INKCacheKeyDataTypeSet(INKCacheKey key, INKCacheDataType type); + tsapi TSReturnCode TSCacheKeyDataTypeSet(TSCacheKey key, TSCacheDataType type); /* ===== Utility ===== */ @@ -190,226 +190,204 @@ extern "C" * Create a random number * Return random integer between <X> and <Y> ****************************************************************************/ - inkapi unsigned int INKrandom(void); + tsapi unsigned int TSrandom(void); /**************************************************************************** * Create a random double * Return random double between <X> and <Y> ****************************************************************************/ - inkapi double INKdrandom(void); + tsapi double TSdrandom(void); /**************************************************************************** * Return Hi-resolution current time. (int64) ****************************************************************************/ - inkapi TSHRTime INKhrtime(void); + tsapi TSHRTime TShrtime(void); /* ===== global http stats ===== */ /**************************************************************************** * Get number of current client http connections ****************************************************************************/ - inkapi int INKHttpCurrentClientConnectionsGet(int *num_connections); + tsapi int TSHttpCurrentClientConnectionsGet(int *num_connections); /**************************************************************************** * Get number of current active client http connections ****************************************************************************/ - inkapi int INKHttpCurrentActiveClientConnectionsGet(int *num_connections); + tsapi int TSHttpCurrentActiveClientConnectionsGet(int *num_connections); /**************************************************************************** * Get number of current idle client http connections ****************************************************************************/ - inkapi int INKHttpCurrentIdleClientConnectionsGet(int *num_connections); + tsapi int TSHttpCurrentIdleClientConnectionsGet(int *num_connections); /**************************************************************************** * Get number of current http connections to cache ****************************************************************************/ - inkapi int INKHttpCurrentCacheConnectionsGet(int *num_connections); + tsapi int TSHttpCurrentCacheConnectionsGet(int *num_connections); /**************************************************************************** * Get number of current http server connections ****************************************************************************/ - inkapi int INKHttpCurrentServerConnectionsGet(int *num_connections); + tsapi int TSHttpCurrentServerConnectionsGet(int *num_connections); /**************************************************************************** * Get size of response header ****************************************************************************/ - inkapi int INKHttpTxnServerRespHdrBytesGet(INKHttpTxn txnp, int *bytes); + tsapi int TSHttpTxnServerRespHdrBytesGet(TSHttpTxn txnp, int *bytes); /**************************************************************************** * Get size of response body ****************************************************************************/ - inkapi int INKHttpTxnServerRespBodyBytesGet(INKHttpTxn txnp, int64 *bytes); + tsapi int TSHttpTxnServerRespBodyBytesGet(TSHttpTxn txnp, int64 *bytes); /* ===== CacheHttpInfo ===== */ - inkapi INKCacheHttpInfo INKCacheHttpInfoCopy(INKCacheHttpInfo * infop); - inkapi void INKCacheHttpInfoReqGet(INKCacheHttpInfo infop, INKMBuffer * bufp, INKMLoc * offset); - inkapi void INKCacheHttpInfoRespGet(INKCacheHttpInfo infop, INKMBuffer * bufp, INKMLoc * offset); - inkapi INKReturnCode INKCacheHttpInfoDestroy(INKCacheHttpInfo infop); + tsapi TSCacheHttpInfo TSCacheHttpInfoCopy(TSCacheHttpInfo * infop); + tsapi void TSCacheHttpInfoReqGet(TSCacheHttpInfo infop, TSMBuffer * bufp, TSMLoc * offset); + tsapi void TSCacheHttpInfoRespGet(TSCacheHttpInfo infop, TSMBuffer * bufp, TSMLoc * offset); + tsapi TSReturnCode TSCacheHttpInfoDestroy(TSCacheHttpInfo infop); /* ===== ICP ===== */ - inkapi void INKHttpIcpDynamicSet(int value); + tsapi void TSHttpIcpDynamicSet(int value); /* ===== Http Transactions ===== */ - inkapi int INKHttpTxnCachedRespModifiableGet(INKHttpTxn txnp, INKMBuffer * bufp, INKMLoc * offset); - inkapi int INKHttpTxnCacheLookupStatusSet(INKHttpTxn txnp, int cachelookup); - inkapi int INKHttpTxnCacheLookupUrlGet(INKHttpTxn txnp, INKMBuffer bufp, INKMLoc obj); - inkapi int INKHttpTxnCachedUrlSet(INKHttpTxn txnp, INKMBuffer bufp, INKMLoc obj); - - /**************************************************************************** - * INKHttpTxnCacheLookupCountGet - * Return: INK_SUCESS/INK_ERROR - ****************************************************************************/ - INKReturnCode INKHttpTxnCacheLookupCountGet(INKHttpTxn txnp, int *lookup_count); - inkapi int INKHttpTxnNewCacheLookupDo(INKHttpTxn txnp, INKMBuffer bufp, INKMLoc url_loc); - inkapi int INKHttpTxnSecondUrlTryLock(INKHttpTxn txnp); - inkapi int INKHttpTxnRedirectRequest(INKHttpTxn txnp, INKMBuffer bufp, INKMLoc url_loc); - inkapi int INKHttpTxnCacheLookupSkip(INKHttpTxn txnp); - inkapi int INKHttpTxnServerRespNoStore(INKHttpTxn txnp); - inkapi int INKHttpTxnServerRespIgnore(INKHttpTxn txnp); - inkapi int INKHttpTxnShutDown(INKHttpTxn txnp, INKEvent event); + tsapi int TSHttpTxnCachedRespModifiableGet(TSHttpTxn txnp, TSMBuffer * bufp, TSMLoc * offset); + tsapi int TSHttpTxnCacheLookupStatusSet(TSHttpTxn txnp, int cachelookup); + tsapi int TSHttpTxnCacheLookupUrlGet(TSHttpTxn txnp, TSMBuffer bufp, TSMLoc obj); + tsapi int TSHttpTxnCachedUrlSet(TSHttpTxn txnp, TSMBuffer bufp, TSMLoc obj); + + /**************************************************************************** + * TSHttpTxnCacheLookupCountGet + * Return: TS_SUCESS/TS_ERROR + ****************************************************************************/ + TSReturnCode TSHttpTxnCacheLookupCountGet(TSHttpTxn txnp, int *lookup_count); + tsapi int TSHttpTxnNewCacheLookupDo(TSHttpTxn txnp, TSMBuffer bufp, TSMLoc url_loc); + tsapi int TSHttpTxnSecondUrlTryLock(TSHttpTxn txnp); + tsapi int TSHttpTxnRedirectRequest(TSHttpTxn txnp, TSMBuffer bufp, TSMLoc url_loc); + tsapi int TSHttpTxnCacheLookupSkip(TSHttpTxn txnp); + tsapi int TSHttpTxnServerRespNoStore(TSHttpTxn txnp); + tsapi int TSHttpTxnServerRespIgnore(TSHttpTxn txnp); + tsapi int TSHttpTxnShutDown(TSHttpTxn txnp, TSEvent event); /**************************************************************************** * ?? * Return ?? ****************************************************************************/ - inkapi int INKHttpTxnAborted(INKHttpTxn txnp); + tsapi int TSHttpTxnAborted(TSHttpTxn txnp); /**************************************************************************** * ?? * Return ?? ****************************************************************************/ - inkapi int INKHttpTxnClientReqIsServerStyle(INKHttpTxn txnp); + tsapi int TSHttpTxnClientReqIsServerStyle(TSHttpTxn txnp); /**************************************************************************** * ?? * Return ?? ****************************************************************************/ - inkapi int INKHttpTxnOverwriteExpireTime(INKHttpTxn txnp, time_t expire_time); + tsapi int TSHttpTxnOverwriteExpireTime(TSHttpTxn txnp, time_t expire_time); /**************************************************************************** * ?? * Return ?? ****************************************************************************/ - inkapi int INKHttpTxnUpdateCachedObject(INKHttpTxn txnp); + tsapi int TSHttpTxnUpdateCachedObject(TSHttpTxn txnp); /**************************************************************************** * ?? * Return ?? ****************************************************************************/ - inkapi int INKHttpTxnLookingUpTypeGet(INKHttpTxn txnp); + tsapi int TSHttpTxnLookingUpTypeGet(TSHttpTxn txnp); /**************************************************************************** * ?? * Return ?? ****************************************************************************/ - inkapi int INKHttpTxnClientRespHdrBytesGet(INKHttpTxn txnp, int *bytes); + tsapi int TSHttpTxnClientRespHdrBytesGet(TSHttpTxn txnp, int *bytes); /**************************************************************************** * ?? * Return ?? ****************************************************************************/ - inkapi int INKHttpTxnClientRespBodyBytesGet(INKHttpTxn txnp, int64 *bytes); + tsapi int TSHttpTxnClientRespBodyBytesGet(TSHttpTxn txnp, int64 *bytes); /* ===== Matcher Utils ===== */ -#define INK_MATCHER_LINE_INVALID 0 - typedef void *INKMatcherLine; +#define TS_MATCHER_LINE_INVALID 0 + typedef void *TSMatcherLine; /**************************************************************************** * ?? * Return ****************************************************************************/ - inkapi char *INKMatcherReadIntoBuffer(char *file_name, int *file_len); + tsapi char *TSMatcherReadIntoBuffer(char *file_name, int *file_len); /**************************************************************************** * ?? * Return ****************************************************************************/ - inkapi char *INKMatcherTokLine(char *buffer, char **last); + tsapi char *TSMatcherTokLine(char *buffer, char **last); /**************************************************************************** * ?? * Return ****************************************************************************/ - inkapi char *INKMatcherExtractIPRange(char *match_str, uint32 * addr1, uint32 * addr2); + tsapi char *TSMatcherExtractIPRange(char *match_str, uint32 * addr1, uint32 * addr2); /**************************************************************************** * ?? * Return ****************************************************************************/ - inkapi INKMatcherLine INKMatcherLineCreate(); + tsapi TSMatcherLine TSMatcherLineCreate(); /**************************************************************************** * ?? * Return ****************************************************************************/ - inkapi void INKMatcherLineDestroy(INKMatcherLine ml); + tsapi void TSMatcherLineDestroy(TSMatcherLine ml); /**************************************************************************** * ?? * Return ****************************************************************************/ - inkapi const char *INKMatcherParseSrcIPConfigLine(char *line, INKMatcherLine ml); + tsapi const char *TSMatcherParseSrcIPConfigLine(char *line, TSMatcherLine ml); /**************************************************************************** * ?? * Return ****************************************************************************/ - inkapi char *INKMatcherLineName(INKMatcherLine ml, int element); + tsapi char *TSMatcherLineName(TSMatcherLine ml, int element); /**************************************************************************** * ?? * Return ****************************************************************************/ - inkapi char *INKMatcherLineValue(INKMatcherLine ml, int element); - - /**************************************************************************** - * ?? - * Return - ****************************************************************************/ - - /**************************************************************************** - * ?? - * Return - ****************************************************************************/ - - /**************************************************************************** - * ?? - * Return - ****************************************************************************/ - - /**************************************************************************** - * ?? - * Return - ****************************************************************************/ - - /* ===== Configuration Setting ===== */ + tsapi char *TSMatcherLineValue(TSMatcherLine ml, int element); /**************************************************************************** * Set a records.config integer variable ****************************************************************************/ - inkapi int INKMgmtConfigIntSet(const char *var_name, INKMgmtInt value); + tsapi int TSMgmtConfigIntSet(const char *var_name, TSMgmtInt value); /* ---------------------------------------------------------------------- * Interfaces used by Wireless group * ---------------------------------------------------------------------- */ -#define INK_NET_EVENT_DATAGRAM_READ_COMPLETE INK_EVENT_INTERNAL_206 -#define INK_NET_EVENT_DATAGRAM_READ_ERROR INK_EVENT_INTERNAL_207 -#define INK_NET_EVENT_DATAGRAM_WRITE_COMPLETE INK_EVENT_INTERNAL_208 -#define INK_NET_EVENT_DATAGRAM_WRITE_ERROR INK_EVENT_INTERNAL_209 -#define INK_NET_EVENT_DATAGRAM_READ_READY INK_EVENT_INTERNAL_210 -#define INK_NET_EVENT_DATAGRAM_OPEN INK_EVENT_INTERNAL_211 -#define INK_NET_EVENT_DATAGRAM_ERROR INK_EVENT_INTERNAL_212 +#define TS_NET_EVENT_DATAGRAM_READ_COMPLETE TS_EVENT_INTERNAL_206 +#define TS_NET_EVENT_DATAGRAM_READ_ERROR TS_EVENT_INTERNAL_207 +#define TS_NET_EVENT_DATAGRAM_WRITE_COMPLETE TS_EVENT_INTERNAL_208 +#define TS_NET_EVENT_DATAGRAM_WRITE_ERROR TS_EVENT_INTERNAL_209 +#define TS_NET_EVENT_DATAGRAM_READ_READY TS_EVENT_INTERNAL_210 +#define TS_NET_EVENT_DATAGRAM_OPEN TS_EVENT_INTERNAL_211 +#define TS_NET_EVENT_DATAGRAM_ERROR TS_EVENT_INTERNAL_212 typedef enum { - INK_SIGNAL_WDA_BILLING_CONNECTION_DIED = 100, - INK_SIGNAL_WDA_BILLING_CORRUPTED_DATA = 101, - INK_SIGNAL_WDA_XF_ENGINE_DOWN = 102, - INK_SIGNAL_WDA_RADIUS_CORRUPTED_PACKETS = 103 - } INKAlarmType; + TS_SIGNAL_WDA_BILLING_CONNECTION_DIED = 100, + TS_SIGNAL_WDA_BILLING_CORRUPTED_DATA = 101, + TS_SIGNAL_WDA_XF_ENGINE_DOWN = 102, + TS_SIGNAL_WDA_RADIUS_CORRUPTED_PACKETS = 103 + } TSAlarmType; /* ===== Alarm ===== */ /**************************************************************************** @@ -417,7 +395,7 @@ extern "C" * Return ?? * contact: OXYGEN ****************************************************************************/ - inkapi int INKSignalWarning(INKAlarmType code, char *msg); + tsapi int TSSignalWarning(TSAlarmType code, char *msg); /***************************************************************************** * Cluster RPC API support * @@ -433,44 +411,44 @@ extern "C" * is assumed to have no prior knowledge of messages processed in * the past. * 5) Key point to reiterate, actions taken in the functions specified in - * INKAddClusterStatusFunction() and INKAddClusterRPCFunction() must - * be non-blocking (i.e. usage of INKMutexLock() and file i/o is + * TSAddClusterStatusFunction() and TSAddClusterRPCFunction() must + * be non-blocking (i.e. usage of TSMutexLock() and file i/o is * not allowed). - * 6) INKSendClusterRPC() can only process INKClusterRPCMsg_t generated - * by INKAllocClusterRPCMsg(). Failure to adhere to this rule will + * 6) TSSendClusterRPC() can only process TSClusterRPCMsg_t generated + * by TSAllocClusterRPCMsg(). Failure to adhere to this rule will * result in heap corruption. - * 7) Messages sent via INKSendClusterRPC() must be at least 4 bytes in + * 7) Messages sent via TSSendClusterRPC() must be at least 4 bytes in * length. * 8) The user is not provided with any alignment guarantees on the - * 'm_data' field in the INKClusterRPCMsg_t returned via - * INKAllocClusterRPCMsg(). Assume byte alignment. - * 9) INKSendClusterRPC() interface owns the memory and is responsible + * 'm_data' field in the TSClusterRPCMsg_t returned via + * TSAllocClusterRPCMsg(). Assume byte alignment. + * 9) TSSendClusterRPC() interface owns the memory and is responsible * for freeing the memory. - * 10) RPC functions defined via INKAddClusterRPCFunction() own the + * 10) RPC functions defined via TSAddClusterRPCFunction() own the * memory when invoked and are responsible for freeing it via - * INKFreeRPCMsg(). + * TSFreeRPCMsg(). */ #define MAX_CLUSTER_NODES 256 - typedef struct INKClusterRPCHandle + typedef struct TSClusterRPCHandle { int opaque[2]; - } INKClusterRPCHandle_t; + } TSClusterRPCHandle_t; - typedef int INKClusterStatusHandle_t; - typedef int INKNodeHandle_t; + typedef int TSClusterStatusHandle_t; + typedef int TSNodeHandle_t; - typedef struct INKClusterRPCMsg + typedef struct TSClusterRPCMsg { - INKClusterRPCHandle_t m_handle; + TSClusterRPCHandle_t m_handle; char m_data[4]; - } INKClusterRPCMsg_t; + } TSClusterRPCMsg_t; typedef enum { NODE_ONLINE = 1, NODE_OFFLINE - } INKNodeStatus_t; + } TSNodeStatus_t; typedef enum { @@ -484,10 +462,10 @@ extern "C" RPC_API_WIRELESS_F08, RPC_API_WIRELESS_F09, RPC_API_WIRELESS_F10 - } INKClusterRPCKey_t; + } TSClusterRPCKey_t; - typedef void (*INKClusterRPCFunction) (INKNodeHandle_t * node, INKClusterRPCMsg_t * msg, int msg_data_len); - typedef void (*INKClusterStatusFunction) (INKNodeHandle_t * node, INKNodeStatus_t s); + typedef void (*TSClusterRPCFunction) (TSNodeHandle_t * node, TSClusterRPCMsg_t * msg, int msg_data_len); + typedef void (*TSClusterStatusFunction) (TSNodeHandle_t * node, TSNodeStatus_t s); /**************************************************************************** * Subscribe to node up/down status notification. * @@ -495,35 +473,35 @@ extern "C" * Return != 0 Failure * * contact: OXY, DY ****************************************************************************/ - inkapi int INKAddClusterStatusFunction(INKClusterStatusFunction Status_Function, INKMutex m, INKClusterStatusHandle_t * h); + tsapi int TSAddClusterStatusFunction(TSClusterStatusFunction Status_Function, TSMutex m, TSClusterStatusHandle_t * h); /**************************************************************************** * Cancel subscription to node up/down status notification. * * Return == 0 Success * * Return != 0 Failure * * contact: OXY, DY ****************************************************************************/ - inkapi int INKDeleteClusterStatusFunction(INKClusterStatusHandle_t * h); + tsapi int TSDeleteClusterStatusFunction(TSClusterStatusHandle_t * h); /**************************************************************************** - * Get the struct in_addr associated with the INKNodeHandle_t. * + * Get the struct in_addr associated with the TSNodeHandle_t. * * Return == 0 Success * * Return != 0 Failure * * contact: OXY, DY ****************************************************************************/ - inkapi int INKNodeHandleToIPAddr(INKNodeHandle_t * h, struct in_addr *in); + tsapi int TSNodeHandleToIPAddr(TSNodeHandle_t * h, struct in_addr *in); /**************************************************************************** - * Get the INKNodeHandle_t for the local node. * + * Get the TSNodeHandle_t for the local node. * * contact: OXY, DY ****************************************************************************/ - inkapi void INKGetMyNodeHandle(INKNodeHandle_t * h); + tsapi void TSGetMyNodeHandle(TSNodeHandle_t * h); /**************************************************************************** * Enable node up/down notification for subscription added via * - * INKAddClusterStatusFunction(). * + * TSAddClusterStatusFunction(). * * contact: OXY, DY ****************************************************************************/ - inkapi void INKEnableClusterStatusCallout(INKClusterStatusHandle_t * h); + tsapi void TSEnableClusterStatusCallout(TSClusterStatusHandle_t * h); /**************************************************************************** * Associate the given key with the given RPC function. * @@ -531,30 +509,30 @@ extern "C" * Return != 0 Failure * * contact: OXY, DY ****************************************************************************/ - inkapi int INKAddClusterRPCFunction(INKClusterRPCKey_t k, INKClusterRPCFunction RPC_Function, INKClusterRPCHandle_t * h); + tsapi int TSAddClusterRPCFunction(TSClusterRPCKey_t k, TSClusterRPCFunction RPC_Function, TSClusterRPCHandle_t * h); /**************************************************************************** * Delete the key to function association created via * - * INKAddClusterRPCFunction(). * + * TSAddClusterRPCFunction(). * * Return == 0 Success * * Return != 0 Failure * * contact: OXY, DY ****************************************************************************/ - inkapi int INKDeleteClusterRPCFunction(INKClusterRPCHandle_t * h); + tsapi int TSDeleteClusterRPCFunction(TSClusterRPCHandle_t * h); /**************************************************************************** - * Free INKClusterRPCMsg_t received via RPC function * + * Free TSClusterRPCMsg_t received via RPC function * * contact: OXY, DY ****************************************************************************/ - inkapi void INKFreeRPCMsg(INKClusterRPCMsg_t * msg, int msg_data_len); + tsapi void TSFreeRPCMsg(TSClusterRPCMsg_t * msg, int msg_data_len); /**************************************************************************** - * Allocate INKClusterRPCMsg_t for use in INKSendClusterRPC() * + * Allocate TSClusterRPCMsg_t for use in TSSendClusterRPC() * * Return != 0 Success * * Return == 0 Allocation failed * * contact: OXY, DY ****************************************************************************/ - inkapi INKClusterRPCMsg_t *INKAllocClusterRPCMsg(INKClusterRPCHandle_t * h, int data_size); + tsapi TSClusterRPCMsg_t *TSAllocClusterRPCMsg(TSClusterRPCHandle_t * h, int data_size); /**************************************************************************** * Send the RPC message to the specified node. * @@ -564,7 +542,7 @@ extern "C" * Return != 0 Failure * * contact: OXY, DY ****************************************************************************/ - inkapi int INKSendClusterRPC(INKNodeHandle_t * nh, INKClusterRPCMsg_t * msg); + tsapi int TSSendClusterRPC(TSNodeHandle_t * nh, TSClusterRPCMsg_t * msg); /* ---------------------------------------------------------------------- * Interfaces used for the AAA project @@ -576,23 +554,23 @@ extern "C" * Return * contact: AAA, CPOINT ****************************************************************************/ - inkapi int INKUserNameCacheInsert(INKCont contp, unsigned long ip, const char *userName); + tsapi int TSUserNameCacheInsert(TSCont contp, unsigned long ip, const char *userName); /**************************************************************************** * Lookup a name in the user-name cache * Return * contact: AAA, CPOINT ****************************************************************************/ - inkapi int INKUserNameCacheLookup(INKCont contp, unsigned long ip, char *userName); + tsapi int TSUserNameCacheLookup(TSCont contp, unsigned long ip, char *userName); /**************************************************************************** * Remove a name from the user-name cache * Return * contact: AAA, CPOINT ****************************************************************************/ - inkapi int INKUserNameCacheDelete(INKCont contp, unsigned long ip); + tsapi int TSUserNameCacheDelete(TSCont contp, unsigned long ip); #ifdef __cplusplus } #endif /* __cplusplus */ -#endif /* __INK_API_EXPERIMENTAL_H__ */ +#endif /* __TS_API_EXPERIMENTAL_H__ */ Modified: trafficserver/traffic/trunk/proxy/api/ts/remap.h URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/proxy/api/ts/remap.h?rev=1035782&r1=1035781&r2=1035782&view=diff ============================================================================== --- trafficserver/traffic/trunk/proxy/api/ts/remap.h (original) +++ trafficserver/traffic/trunk/proxy/api/ts/remap.h Tue Nov 16 20:22:02 2010 @@ -156,7 +156,7 @@ extern "C" /* Remap new request Return: != 0 - request was remapped, TS must look at new_... fields in TSRemapRequestInfo == 0 - request was not processed. TS must perform default remap - Note: rhandle == INKHttpTxn (see ts/ts.h for more details) + Note: rhandle == TSHttpTxn (see ts/ts.h for more details) Remap API plugin can use InkAPI function calls inside tsremap_remap() */ int tsremap_remap(ihandle ih, rhandle rh, TSRemapRequestInfo * rri); @@ -165,8 +165,8 @@ extern "C" /* Check response code from Origin Server Return: none - Note: rhandle == INKHttpTxn (see ts/ts.h for more details) - os_response_type -> INKServerState + Note: rhandle == TSHttpTxn (see ts/ts.h for more details) + os_response_type -> TSServerState Remap API plugin can use InkAPI function calls inside tsremap_remap() */ void tsremap_os_response(ihandle ih, rhandle rh, int os_response_type);
