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 [13/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/InkAPITestTool.cc
URL: http://svn.apache.org/viewvc/trafficserver/traffic/branches/wccp/proxy/InkAPITestTool.cc?rev=1040383&r1=1040382&r2=1040383&view=diff
==============================================================================
--- trafficserver/traffic/branches/wccp/proxy/InkAPITestTool.cc (original)
+++ trafficserver/traffic/branches/wccp/proxy/InkAPITestTool.cc Tue Nov 30 01:42:55 2010
@@ -61,20 +61,20 @@
// STRUCTURES
//////////////////////////////////////////////////////////////////////////////
-typedef int (*TxnHandler) (INKCont contp, INKEvent event, void *data);
+typedef int (*TxnHandler) (TSCont contp, TSEvent event, void *data);
/* Server transaction structure */
typedef struct
{
- INKVConn vconn;
+ TSVConn vconn;
- INKVIO read_vio;
- INKIOBuffer req_buffer;
- INKIOBufferReader req_reader;
-
- INKVIO write_vio;
- INKIOBuffer resp_buffer;
- INKIOBufferReader resp_reader;
+ TSVIO read_vio;
+ TSIOBuffer req_buffer;
+ TSIOBufferReader req_reader;
+
+ TSVIO write_vio;
+ TSIOBuffer resp_buffer;
+ TSIOBufferReader resp_reader;
char request[REQUEST_MAX_SIZE + 1];
int request_len;
@@ -87,8 +87,8 @@ typedef struct
typedef struct
{
int accept_port;
- INKAction accept_action;
- INKCont accept_cont;
+ TSAction accept_action;
+ TSCont accept_cont;
unsigned int magic;
} SocketServer;
@@ -102,15 +102,15 @@ typedef enum
/* Client structure */
typedef struct
{
- INKVConn vconn;
+ TSVConn vconn;
- INKVIO read_vio;
- INKIOBuffer req_buffer;
- INKIOBufferReader req_reader;
-
- INKVIO write_vio;
- INKIOBuffer resp_buffer;
- INKIOBufferReader resp_reader;
+ TSVIO read_vio;
+ TSIOBuffer req_buffer;
+ TSIOBufferReader req_reader;
+
+ TSVIO write_vio;
+ TSIOBuffer resp_buffer;
+ TSIOBufferReader resp_reader;
char *request;
char response[RESPONSE_MAX_SIZE + 1];
@@ -120,8 +120,8 @@ typedef struct
int connect_port;
int local_port;
- INKU64 connect_ip;
- INKAction connect_action;
+ uint64 connect_ip;
+ TSAction connect_action;
TxnHandler current_handler;
@@ -137,34 +137,34 @@ typedef struct
static char *get_body_ptr(const char *request);
static char *generate_request(int test_case);
static char *generate_response(const char *request);
-static int get_request_id(INKHttpTxn txnp);
+static int get_request_id(TSHttpTxn txnp);
/* client side */
static ClientTxn *synclient_txn_create(void);
static int synclient_txn_delete(ClientTxn * txn);
-static int synclient_txn_close(INKCont contp);
+static int synclient_txn_close(TSCont contp);
static int synclient_txn_send_request(ClientTxn * txn, char *request);
-static int synclient_txn_send_request_to_vc(ClientTxn * txn, char *request, INKVConn vc);
-static int synclient_txn_read_response(INKCont contp);
-static int synclient_txn_read_response_handler(INKCont contp, INKEvent event, void *data);
-static int synclient_txn_write_request(INKCont contp);
-static int synclient_txn_write_request_handler(INKCont contp, INKEvent event, void *data);
-static int synclient_txn_connect_handler(INKCont contp, INKEvent event, void *data);
-static int synclient_txn_main_handler(INKCont contp, INKEvent event, void *data);
+static int synclient_txn_send_request_to_vc(ClientTxn * txn, char *request, TSVConn vc);
+static int synclient_txn_read_response(TSCont contp);
+static int synclient_txn_read_response_handler(TSCont contp, TSEvent event, void *data);
+static int synclient_txn_write_request(TSCont contp);
+static int synclient_txn_write_request_handler(TSCont contp, TSEvent event, void *data);
+static int synclient_txn_connect_handler(TSCont contp, TSEvent event, void *data);
+static int synclient_txn_main_handler(TSCont contp, TSEvent event, void *data);
/* Server side */
SocketServer *synserver_create(int port);
static int synserver_start(SocketServer * s);
static int synserver_stop(SocketServer * s);
static int synserver_delete(SocketServer * s);
-static int synserver_accept_handler(INKCont contp, INKEvent event, void *data);
-static int synserver_txn_close(INKCont contp);
-static int synserver_txn_write_response(INKCont contp);
-static int synserver_txn_write_response_handler(INKCont contp, INKEvent event, void *data);
-static int synserver_txn_read_request(INKCont contp);
-static int synserver_txn_read_request_handler(INKCont contp, INKEvent event, void *data);
-static int synserver_txn_main_handler(INKCont contp, INKEvent event, void *data);
+static int synserver_accept_handler(TSCont contp, TSEvent event, void *data);
+static int synserver_txn_close(TSCont contp);
+static int synserver_txn_write_response(TSCont contp);
+static int synserver_txn_write_response_handler(TSCont contp, TSEvent event, void *data);
+static int synserver_txn_read_request(TSCont contp);
+static int synserver_txn_read_request_handler(TSCont contp, TSEvent event, void *data);
+static int synserver_txn_main_handler(TSCont contp, TSEvent event, void *data);
//////////////////////////////////////////////////////////////////////////////
// REQUESTS/RESPONSES GENERATION
@@ -185,39 +185,39 @@ generate_request(int test_case)
// We define request formats.
// Each format has an X-Request-ID field that contains the id of the testcase
-#define HTTP_REQUEST_DEFAULT_FORMAT "GET http://localhost:%d/default.html HTTP/1.0\r\n" \
+#define HTTP_REQUEST_DEFAULT_FORMAT "GET http://127.0.0.1:%d/default.html HTTP/1.0\r\n" \
"X-Request-ID: %d\r\n" \
"\r\n"
-#define HTTP_REQUEST_FORMAT1 "GET http://localhost:%d/format1.html HTTP/1.0\r\n" \
+#define HTTP_REQUEST_FORMAT1 "GET http://127.0.0.1:%d/format1.html HTTP/1.0\r\n" \
"X-Request-ID: %d\r\n" \
"\r\n"
-#define HTTP_REQUEST_FORMAT2 "GET http://localhost:%d/format2.html HTTP/1.0\r\n" \
+#define HTTP_REQUEST_FORMAT2 "GET http://127.0.0.1:%d/format2.html HTTP/1.0\r\n" \
"X-Request-ID: %d\r\n" \
"Content-Type: text/html\r\n" \
"\r\n"
-#define HTTP_REQUEST_FORMAT3 "GET http://localhost:%d/format3.html/ HTTP/1.0\r\n" \
+#define HTTP_REQUEST_FORMAT3 "GET http://127.0.0.1:%d/format3.html/ HTTP/1.0\r\n" \
"X-Request-ID: %d\r\n" \
"Response: Error\r\n" \
"\r\n"
-#define HTTP_REQUEST_FORMAT4 "GET http://localhost:%d/format4.html/ HTTP/1.0\r\n" \
+#define HTTP_REQUEST_FORMAT4 "GET http://127.0.0.1:%d/format4.html/ HTTP/1.0\r\n" \
"X-Request-ID: %d\r\n" \
"Request:%d\r\n" \
"\r\n"
-#define HTTP_REQUEST_FORMAT5 "GET http://localhost:%d/format5.html/ HTTP/1.0\r\n" \
+#define HTTP_REQUEST_FORMAT5 "GET http://127.0.0.1:%d/format5.html/ HTTP/1.0\r\n" \
"X-Request-ID: %d\r\n" \
"Request:%d\r\n" \
"\r\n"
-#define HTTP_REQUEST_FORMAT6 "GET http://localhost:%d/format.html/ HTTP/1.0\r\n" \
+#define HTTP_REQUEST_FORMAT6 "GET http://127.0.0.1:%d/format.html/ HTTP/1.0\r\n" \
"X-Request-ID: %d\r\n" \
"Accept-Language:English\r\n" \
"\r\n"
-#define HTTP_REQUEST_FORMAT7 "GET http://localhost:%d/format.html/ HTTP/1.0\r\n" \
+#define HTTP_REQUEST_FORMAT7 "GET http://127.0.0.1:%d/format.html/ HTTP/1.0\r\n" \
"X-Request-ID: %d\r\n" \
"Accept-Language:French\r\n" \
"\r\n"
-#define HTTP_REQUEST_FORMAT8 "GET http://localhost:%d/format.html/ HTTP/1.0\r\n" \
+#define HTTP_REQUEST_FORMAT8 "GET http://127.0.0.1:%d/format.html/ HTTP/1.0\r\n" \
"X-Request-ID: %d\r\n" \
"Accept-Language:English,French\r\n" \
"\r\n"
@@ -228,7 +228,7 @@ generate_request(int test_case)
"X-Request-ID: %d\r\n" \
"\r\n"
- char *request = (char *) INKmalloc(REQUEST_MAX_SIZE + 1);
+ char *request = (char *) TSmalloc(REQUEST_MAX_SIZE + 1);
switch (test_case) {
case 1:
@@ -337,7 +337,7 @@ generate_response(const char *request)
int test_case, match, http_version;
- char *response = (char *) INKmalloc(RESPONSE_MAX_SIZE + 1);
+ char *response = (char *) TSmalloc(RESPONSE_MAX_SIZE + 1);
char url[1024];
// coverity[secure_coding]
@@ -388,32 +388,32 @@ generate_response(const char *request)
// to figure out the id of a test message
// Returns id/-1 in case of error
static int
-get_request_id(INKHttpTxn txnp)
+get_request_id(TSHttpTxn txnp)
{
- INKMBuffer bufp;
- INKMLoc hdr_loc, id_loc;
+ TSMBuffer bufp;
+ TSMLoc hdr_loc, id_loc;
int id = -1;
int ret_val;
- if (!INKHttpTxnClientReqGet(txnp, &bufp, &hdr_loc)) {
+ if (!TSHttpTxnClientReqGet(txnp, &bufp, &hdr_loc)) {
return -1;
}
- id_loc = INKMimeHdrFieldFind(bufp, hdr_loc, X_REQUEST_ID, -1);
- if ((id_loc == INK_NULL_MLOC) || (id_loc == INK_ERROR_PTR)) {
- INKHandleMLocRelease(bufp, INK_NULL_MLOC, hdr_loc);
+ id_loc = TSMimeHdrFieldFind(bufp, hdr_loc, X_REQUEST_ID, -1);
+ if ((id_loc == TS_NULL_MLOC) || (id_loc == TS_ERROR_PTR)) {
+ TSHandleMLocRelease(bufp, TS_NULL_MLOC, hdr_loc);
return -1;
}
- ret_val = INKMimeHdrFieldValueIntGet(bufp, hdr_loc, id_loc, 0, &id);
- if (ret_val == INK_ERROR) {
- INKHandleMLocRelease(bufp, hdr_loc, id_loc);
- INKHandleMLocRelease(bufp, INK_NULL_MLOC, hdr_loc);
+ ret_val = TSMimeHdrFieldValueIntGet(bufp, hdr_loc, id_loc, 0, &id);
+ if (ret_val == TS_ERROR) {
+ TSHandleMLocRelease(bufp, hdr_loc, id_loc);
+ TSHandleMLocRelease(bufp, TS_NULL_MLOC, hdr_loc);
return -1;
}
- INKHandleMLocRelease(bufp, hdr_loc, id_loc);
- INKHandleMLocRelease(bufp, INK_NULL_MLOC, hdr_loc);
+ TSHandleMLocRelease(bufp, hdr_loc, id_loc);
+ TSHandleMLocRelease(bufp, TS_NULL_MLOC, hdr_loc);
return id;
}
@@ -426,10 +426,10 @@ get_request_id(INKHttpTxn txnp)
static ClientTxn *
synclient_txn_create(void)
{
- INKMgmtInt proxy_port;
+ TSMgmtInt proxy_port;
- ClientTxn *txn = (ClientTxn *) INKmalloc(sizeof(ClientTxn));
- if (!INKMgmtIntGet(PROXY_CONFIG_NAME_HTTP_PORT, &proxy_port)) {
+ ClientTxn *txn = (ClientTxn *) TSmalloc(sizeof(ClientTxn));
+ if (!TSMgmtIntGet(PROXY_CONFIG_NAME_HTTP_PORT, &proxy_port)) {
proxy_port = PROXY_HTTP_DEFAULT_PORT;
}
txn->connect_port = (int) proxy_port;
@@ -445,150 +445,150 @@ synclient_txn_create(void)
txn->magic = MAGIC_ALIVE;
txn->connect_action = NULL;
- INKDebug(CDBG_TAG, "Connecting to proxy localhost on port %d", (int) proxy_port);
+ TSDebug(CDBG_TAG, "Connecting to proxy 127.0.0.1 on port %d", (int) proxy_port);
return txn;
}
static int
synclient_txn_delete(ClientTxn * txn)
{
- INKAssert(txn->magic == MAGIC_ALIVE);
- if (txn->connect_action && !INKActionDone(txn->connect_action)) {
- INKActionCancel(txn->connect_action);
+ TSAssert(txn->magic == MAGIC_ALIVE);
+ if (txn->connect_action && !TSActionDone(txn->connect_action)) {
+ TSActionCancel(txn->connect_action);
txn->connect_action = NULL;
}
if (txn->request) {
free(txn->request);
}
txn->magic = MAGIC_DEAD;
- INKfree(txn);
+ TSfree(txn);
return 1;
}
static int
-synclient_txn_close(INKCont contp)
+synclient_txn_close(TSCont contp)
{
- ClientTxn *txn = (ClientTxn *) INKContDataGet(contp);
- INKAssert(txn->magic == MAGIC_ALIVE);
+ ClientTxn *txn = (ClientTxn *) TSContDataGet(contp);
+ TSAssert(txn->magic == MAGIC_ALIVE);
if (txn->vconn != NULL) {
- INKVConnClose(txn->vconn);
+ TSVConnClose(txn->vconn);
}
if (txn->req_buffer != NULL) {
- INKIOBufferDestroy(txn->req_buffer);
+ TSIOBufferDestroy(txn->req_buffer);
}
if (txn->resp_buffer != NULL) {
- INKIOBufferDestroy(txn->resp_buffer);
+ TSIOBufferDestroy(txn->resp_buffer);
}
- INKContDestroy(contp);
+ TSContDestroy(contp);
- INKDebug(CDBG_TAG, "Client Txn destroyed");
- return INK_EVENT_IMMEDIATE;
+ TSDebug(CDBG_TAG, "Client Txn destroyed");
+ return TS_EVENT_IMMEDIATE;
}
static int
synclient_txn_send_request(ClientTxn * txn, char *request)
{
- INKCont cont;
- INKAssert(txn->magic == MAGIC_ALIVE);
+ TSCont cont;
+ TSAssert(txn->magic == MAGIC_ALIVE);
txn->request = strdup(request);
SET_TEST_HANDLER(txn->current_handler, synclient_txn_connect_handler);
- cont = INKContCreate(synclient_txn_main_handler, INKMutexCreate());
- INKContDataSet(cont, txn);
- INKNetConnect(cont, txn->connect_ip, txn->connect_port);
+ cont = TSContCreate(synclient_txn_main_handler, TSMutexCreate());
+ TSContDataSet(cont, txn);
+ TSNetConnect(cont, txn->connect_ip, txn->connect_port);
return 1;
}
/* This can be used to send a request to a specific VC */
static int
-synclient_txn_send_request_to_vc(ClientTxn * txn, char *request, INKVConn vc)
+synclient_txn_send_request_to_vc(ClientTxn * txn, char *request, TSVConn vc)
{
- INKCont cont;
- INKAssert(txn->magic == MAGIC_ALIVE);
+ TSCont cont;
+ TSAssert(txn->magic == MAGIC_ALIVE);
txn->request = strdup(request);
SET_TEST_HANDLER(txn->current_handler, synclient_txn_connect_handler);
- cont = INKContCreate(synclient_txn_main_handler, INKMutexCreate());
- INKContDataSet(cont, txn);
+ cont = TSContCreate(synclient_txn_main_handler, TSMutexCreate());
+ TSContDataSet(cont, txn);
- INKContCall(cont, INK_EVENT_NET_CONNECT, vc);
+ TSContCall(cont, TS_EVENT_NET_CONNECT, vc);
return 1;
}
static int
-synclient_txn_read_response(INKCont contp)
+synclient_txn_read_response(TSCont contp)
{
- ClientTxn *txn = (ClientTxn *) INKContDataGet(contp);
- INKAssert(txn->magic == MAGIC_ALIVE);
+ ClientTxn *txn = (ClientTxn *) TSContDataGet(contp);
+ TSAssert(txn->magic == MAGIC_ALIVE);
- INKIOBufferBlock block = INKIOBufferReaderStart(txn->resp_reader);
+ TSIOBufferBlock block = TSIOBufferReaderStart(txn->resp_reader);
while (block != NULL) {
- int blocklen;
- const char *blockptr = INKIOBufferBlockReadStart(block, txn->resp_reader, &blocklen);
+ int64 blocklen;
+ const char *blockptr = TSIOBufferBlockReadStart(block, txn->resp_reader, &blocklen);
if (txn->response_len+blocklen <= RESPONSE_MAX_SIZE) {
memcpy((char *) (txn->response + txn->response_len), blockptr, blocklen);
txn->response_len += blocklen;
} else {
- INKError("Error: Response length %d > response buffer size %d", txn->response_len+blocklen, RESPONSE_MAX_SIZE);
+ TSError("Error: Response length %d > response buffer size %d", txn->response_len+blocklen, RESPONSE_MAX_SIZE);
}
- block = INKIOBufferBlockNext(block);
+ block = TSIOBufferBlockNext(block);
}
txn->response[txn->response_len + 1] = '\0';
- INKDebug(CDBG_TAG, "Response = |%s|, req len = %d", txn->response, txn->response_len);
+ TSDebug(CDBG_TAG, "Response = |%s|, req len = %d", txn->response, txn->response_len);
return 1;
}
static int
-synclient_txn_read_response_handler(INKCont contp, INKEvent event, void *data)
+synclient_txn_read_response_handler(TSCont contp, TSEvent event, void *data)
{
NOWARN_UNUSED(data);
- ClientTxn *txn = (ClientTxn *) INKContDataGet(contp);
- INKAssert(txn->magic == MAGIC_ALIVE);
+ ClientTxn *txn = (ClientTxn *) TSContDataGet(contp);
+ TSAssert(txn->magic == MAGIC_ALIVE);
int avail;
switch (event) {
- case INK_EVENT_VCONN_READ_READY:
- case INK_EVENT_VCONN_READ_COMPLETE:
- if (event == INK_EVENT_VCONN_READ_READY) {
- INKDebug(CDBG_TAG, "READ_READY");
+ case TS_EVENT_VCONN_READ_READY:
+ case TS_EVENT_VCONN_READ_COMPLETE:
+ if (event == TS_EVENT_VCONN_READ_READY) {
+ TSDebug(CDBG_TAG, "READ_READY");
} else {
- INKDebug(CDBG_TAG, "READ_COMPLETE");
+ TSDebug(CDBG_TAG, "READ_COMPLETE");
}
- avail = INKIOBufferReaderAvail(txn->resp_reader);
- INKDebug(CDBG_TAG, "%d bytes available in buffer", avail);
+ avail = TSIOBufferReaderAvail(txn->resp_reader);
+ TSDebug(CDBG_TAG, "%d bytes available in buffer", avail);
if (avail > 0) {
synclient_txn_read_response(contp);
- INKIOBufferReaderConsume(txn->resp_reader, avail);
+ TSIOBufferReaderConsume(txn->resp_reader, avail);
}
- INKVIOReenable(txn->read_vio);
+ TSVIOReenable(txn->read_vio);
break;
- case INK_EVENT_VCONN_EOS:
- INKDebug(CDBG_TAG, "READ_EOS");
+ case TS_EVENT_VCONN_EOS:
+ TSDebug(CDBG_TAG, "READ_EOS");
// Connection closed. In HTTP/1.0 it means we're done for this request.
txn->status = REQUEST_SUCCESS;
return synclient_txn_close(contp);
break;
- case INK_EVENT_ERROR:
- INKDebug(CDBG_TAG, "READ_ERROR");
+ case TS_EVENT_ERROR:
+ TSDebug(CDBG_TAG, "READ_ERROR");
txn->status = REQUEST_FAILURE;
return synclient_txn_close(contp);
break;
default:
- INKAssert(!"Invalid event");
+ TSAssert(!"Invalid event");
break;
}
return 1;
@@ -596,99 +596,99 @@ synclient_txn_read_response_handler(INKC
static int
-synclient_txn_write_request(INKCont contp)
+synclient_txn_write_request(TSCont contp)
{
- ClientTxn *txn = (ClientTxn *) INKContDataGet(contp);
- INKAssert(txn->magic == MAGIC_ALIVE);
+ ClientTxn *txn = (ClientTxn *) TSContDataGet(contp);
+ TSAssert(txn->magic == MAGIC_ALIVE);
- INKIOBufferBlock block;
+ TSIOBufferBlock block;
char *ptr_block;
- int len, ndone, ntodo, towrite, avail;
+ int64 len, ndone, ntodo, towrite, avail;
len = strlen(txn->request);
ndone = 0;
ntodo = len;
while (ntodo > 0) {
- block = INKIOBufferStart(txn->req_buffer);
- ptr_block = INKIOBufferBlockWriteStart(block, &avail);
+ block = TSIOBufferStart(txn->req_buffer);
+ ptr_block = TSIOBufferBlockWriteStart(block, &avail);
towrite = MIN(ntodo, avail);
memcpy(ptr_block, txn->request + ndone, towrite);
- INKIOBufferProduce(txn->req_buffer, towrite);
+ TSIOBufferProduce(txn->req_buffer, towrite);
ntodo -= towrite;
ndone += towrite;
}
/* Start writing the response */
- INKDebug(CDBG_TAG, "Writing |%s| (%d) bytes", txn->request, len);
- txn->write_vio = INKVConnWrite(txn->vconn, contp, txn->req_reader, len);
+ TSDebug(CDBG_TAG, "Writing |%s| (%d) bytes", txn->request, len);
+ txn->write_vio = TSVConnWrite(txn->vconn, contp, txn->req_reader, len);
return 1;
}
static int
-synclient_txn_write_request_handler(INKCont contp, INKEvent event, void *data)
+synclient_txn_write_request_handler(TSCont contp, TSEvent event, void *data)
{
NOWARN_UNUSED(data);
- ClientTxn *txn = (ClientTxn *) INKContDataGet(contp);
- INKAssert(txn->magic == MAGIC_ALIVE);
+ ClientTxn *txn = (ClientTxn *) TSContDataGet(contp);
+ TSAssert(txn->magic == MAGIC_ALIVE);
switch (event) {
- case INK_EVENT_VCONN_WRITE_READY:
- INKDebug(CDBG_TAG, "WRITE_READY");
- INKVIOReenable(txn->write_vio);
+ case TS_EVENT_VCONN_WRITE_READY:
+ TSDebug(CDBG_TAG, "WRITE_READY");
+ TSVIOReenable(txn->write_vio);
break;
- case INK_EVENT_VCONN_WRITE_COMPLETE:
- INKDebug(CDBG_TAG, "WRITE_COMPLETE");
+ case TS_EVENT_VCONN_WRITE_COMPLETE:
+ TSDebug(CDBG_TAG, "WRITE_COMPLETE");
// Weird: synclient should not close the write part of vconn.
// Otherwise some strangeness...
/* Start reading */
SET_TEST_HANDLER(txn->current_handler, synclient_txn_read_response_handler);
- txn->read_vio = INKVConnRead(txn->vconn, contp, txn->resp_buffer, INT_MAX);
+ txn->read_vio = TSVConnRead(txn->vconn, contp, txn->resp_buffer, INT_MAX);
break;
- case INK_EVENT_VCONN_EOS:
- INKDebug(CDBG_TAG, "WRITE_EOS");
+ case TS_EVENT_VCONN_EOS:
+ TSDebug(CDBG_TAG, "WRITE_EOS");
txn->status = REQUEST_FAILURE;
return synclient_txn_close(contp);
break;
- case INK_EVENT_ERROR:
- INKDebug(CDBG_TAG, "WRITE_ERROR");
+ case TS_EVENT_ERROR:
+ TSDebug(CDBG_TAG, "WRITE_ERROR");
txn->status = REQUEST_FAILURE;
return synclient_txn_close(contp);
break;
default:
- INKAssert(!"Invalid event");
+ TSAssert(!"Invalid event");
break;
}
- return INK_EVENT_IMMEDIATE;
+ return TS_EVENT_IMMEDIATE;
}
static int
-synclient_txn_connect_handler(INKCont contp, INKEvent event, void *data)
+synclient_txn_connect_handler(TSCont contp, TSEvent event, void *data)
{
- INKAssert((event == INK_EVENT_NET_CONNECT) || (event == INK_EVENT_NET_CONNECT_FAILED));
+ TSAssert((event == TS_EVENT_NET_CONNECT) || (event == TS_EVENT_NET_CONNECT_FAILED));
- ClientTxn *txn = (ClientTxn *) INKContDataGet(contp);
- INKAssert(txn->magic == MAGIC_ALIVE);
+ ClientTxn *txn = (ClientTxn *) TSContDataGet(contp);
+ TSAssert(txn->magic == MAGIC_ALIVE);
- if (event == INK_EVENT_NET_CONNECT) {
- INKDebug(CDBG_TAG, "NET_CONNECT");
+ if (event == TS_EVENT_NET_CONNECT) {
+ TSDebug(CDBG_TAG, "NET_CONNECT");
- txn->req_buffer = INKIOBufferCreate();
- txn->req_reader = INKIOBufferReaderAlloc(txn->req_buffer);
- txn->resp_buffer = INKIOBufferCreate();
- txn->resp_reader = INKIOBufferReaderAlloc(txn->resp_buffer);
+ txn->req_buffer = TSIOBufferCreate();
+ txn->req_reader = TSIOBufferReaderAlloc(txn->req_buffer);
+ txn->resp_buffer = TSIOBufferCreate();
+ txn->resp_reader = TSIOBufferReaderAlloc(txn->resp_buffer);
txn->response[0] = '\0';
txn->response_len = 0;
- txn->vconn = (INKVConn) data;
+ txn->vconn = (TSVConn) data;
txn->local_port = (int) ((NetVConnection *) data)->get_local_port();
txn->write_vio = NULL;
@@ -698,22 +698,22 @@ synclient_txn_connect_handler(INKCont co
SET_TEST_HANDLER(txn->current_handler, synclient_txn_write_request_handler);
synclient_txn_write_request(contp);
- return INK_EVENT_IMMEDIATE;
+ return TS_EVENT_IMMEDIATE;
} else {
- INKDebug(CDBG_TAG, "NET_CONNECT_FAILED");
+ TSDebug(CDBG_TAG, "NET_CONNECT_FAILED");
txn->status = REQUEST_FAILURE;
synclient_txn_close(contp);
}
- return INK_EVENT_IMMEDIATE;
+ return TS_EVENT_IMMEDIATE;
}
static int
-synclient_txn_main_handler(INKCont contp, INKEvent event, void *data)
+synclient_txn_main_handler(TSCont contp, TSEvent event, void *data)
{
- ClientTxn *txn = (ClientTxn *) INKContDataGet(contp);
- INKAssert(txn->magic == MAGIC_ALIVE);
+ ClientTxn *txn = (ClientTxn *) TSContDataGet(contp);
+ TSAssert(txn->magic == MAGIC_ALIVE);
TxnHandler handler = txn->current_handler;
return (*handler) (contp, event, data);
@@ -727,134 +727,134 @@ synclient_txn_main_handler(INKCont contp
SocketServer *
synserver_create(int port)
{
- SocketServer *s = (SocketServer *) INKmalloc(sizeof(SocketServer));
+ SocketServer *s = (SocketServer *) TSmalloc(sizeof(SocketServer));
s->magic = MAGIC_ALIVE;
s->accept_port = port;
s->accept_action = NULL;
- s->accept_cont = INKContCreate(synserver_accept_handler, INKMutexCreate());
- INKContDataSet(s->accept_cont, s);
+ s->accept_cont = TSContCreate(synserver_accept_handler, TSMutexCreate());
+ TSContDataSet(s->accept_cont, s);
return s;
}
static int
synserver_start(SocketServer * s)
{
- INKAssert(s->magic == MAGIC_ALIVE);
- s->accept_action = INKNetAccept(s->accept_cont, s->accept_port);
+ TSAssert(s->magic == MAGIC_ALIVE);
+ s->accept_action = TSNetAccept(s->accept_cont, s->accept_port);
return 1;
}
static int
synserver_stop(SocketServer * s)
{
- INKAssert(s->magic == MAGIC_ALIVE);
- if (s->accept_action && !INKActionDone(s->accept_action)) {
- INKActionCancel(s->accept_action);
+ TSAssert(s->magic == MAGIC_ALIVE);
+ if (s->accept_action && !TSActionDone(s->accept_action)) {
+ TSActionCancel(s->accept_action);
s->accept_action = NULL;
- INKDebug(SDBG_TAG, "Had to cancel action");
+ TSDebug(SDBG_TAG, "Had to cancel action");
}
- INKDebug(SDBG_TAG, "stopped");
+ TSDebug(SDBG_TAG, "stopped");
return 1;
}
static int
synserver_delete(SocketServer * s)
{
- INKAssert(s->magic == MAGIC_ALIVE);
+ TSAssert(s->magic == MAGIC_ALIVE);
synserver_stop(s);
if (s->accept_cont) {
- INKContDestroy(s->accept_cont);
+ TSContDestroy(s->accept_cont);
s->accept_cont = NULL;
- INKDebug(SDBG_TAG, "destroyed accept cont");
+ TSDebug(SDBG_TAG, "destroyed accept cont");
}
s->magic = MAGIC_DEAD;
- INKfree(s);
- INKDebug(SDBG_TAG, "deleted server");
+ TSfree(s);
+ TSDebug(SDBG_TAG, "deleted server");
return 1;
}
static int
-synserver_accept_handler(INKCont contp, INKEvent event, void *data)
+synserver_accept_handler(TSCont contp, TSEvent event, void *data)
{
- INKAssert((event == INK_EVENT_NET_ACCEPT) || (event == INK_EVENT_NET_ACCEPT_FAILED));
+ TSAssert((event == TS_EVENT_NET_ACCEPT) || (event == TS_EVENT_NET_ACCEPT_FAILED));
- SocketServer *s = (SocketServer *) INKContDataGet(contp);
- INKAssert(s->magic == MAGIC_ALIVE);
+ SocketServer *s = (SocketServer *) TSContDataGet(contp);
+ TSAssert(s->magic == MAGIC_ALIVE);
- if (event == INK_EVENT_NET_ACCEPT_FAILED) {
+ if (event == TS_EVENT_NET_ACCEPT_FAILED) {
ink_release_assert(!"Synserver must be able to bind to a port, check system netstat");
- INKDebug(SDBG_TAG, "NET_ACCEPT_FAILED");
- return INK_EVENT_IMMEDIATE;
+ TSDebug(SDBG_TAG, "NET_ACCEPT_FAILED");
+ return TS_EVENT_IMMEDIATE;
}
- INKDebug(SDBG_TAG, "NET_ACCEPT");
+ TSDebug(SDBG_TAG, "NET_ACCEPT");
/* Create a new transaction */
- ServerTxn *txn = (ServerTxn *) INKmalloc(sizeof(ServerTxn));
+ ServerTxn *txn = (ServerTxn *) TSmalloc(sizeof(ServerTxn));
txn->magic = MAGIC_ALIVE;
SET_TEST_HANDLER(txn->current_handler, synserver_txn_read_request_handler);
- INKCont txn_cont = INKContCreate(synserver_txn_main_handler, INKMutexCreate());
- INKContDataSet(txn_cont, txn);
+ TSCont txn_cont = TSContCreate(synserver_txn_main_handler, TSMutexCreate());
+ TSContDataSet(txn_cont, txn);
- txn->req_buffer = INKIOBufferCreate();
- txn->req_reader = INKIOBufferReaderAlloc(txn->req_buffer);
+ txn->req_buffer = TSIOBufferCreate();
+ txn->req_reader = TSIOBufferReaderAlloc(txn->req_buffer);
- txn->resp_buffer = INKIOBufferCreate();
- txn->resp_reader = INKIOBufferReaderAlloc(txn->resp_buffer);
+ txn->resp_buffer = TSIOBufferCreate();
+ txn->resp_reader = TSIOBufferReaderAlloc(txn->resp_buffer);
txn->request[0] = '\0';
txn->request_len = 0;
- txn->vconn = (INKVConn) data;
+ txn->vconn = (TSVConn) data;
txn->write_vio = NULL;
/* start reading */
- txn->read_vio = INKVConnRead(txn->vconn, txn_cont, txn->req_buffer, INT_MAX);
+ txn->read_vio = TSVConnRead(txn->vconn, txn_cont, txn->req_buffer, INT_MAX);
- return INK_EVENT_IMMEDIATE;
+ return TS_EVENT_IMMEDIATE;
}
static int
-synserver_txn_close(INKCont contp)
+synserver_txn_close(TSCont contp)
{
- ServerTxn *txn = (ServerTxn *) INKContDataGet(contp);
- INKAssert(txn->magic == MAGIC_ALIVE);
+ ServerTxn *txn = (ServerTxn *) TSContDataGet(contp);
+ TSAssert(txn->magic == MAGIC_ALIVE);
if (txn->vconn != NULL) {
- INKVConnClose(txn->vconn);
+ TSVConnClose(txn->vconn);
}
if (txn->req_buffer) {
- INKIOBufferDestroy(txn->req_buffer);
+ TSIOBufferDestroy(txn->req_buffer);
}
if (txn->resp_buffer) {
- INKIOBufferDestroy(txn->resp_buffer);
+ TSIOBufferDestroy(txn->resp_buffer);
}
txn->magic = MAGIC_DEAD;
- INKfree(txn);
- INKContDestroy(contp);
+ TSfree(txn);
+ TSContDestroy(contp);
- INKDebug(SDBG_TAG, "Server Txn destroyed");
- return INK_EVENT_IMMEDIATE;
+ TSDebug(SDBG_TAG, "Server Txn destroyed");
+ return TS_EVENT_IMMEDIATE;
}
static int
-synserver_txn_write_response(INKCont contp)
+synserver_txn_write_response(TSCont contp)
{
- ServerTxn *txn = (ServerTxn *) INKContDataGet(contp);
- INKAssert(txn->magic == MAGIC_ALIVE);
+ ServerTxn *txn = (ServerTxn *) TSContDataGet(contp);
+ TSAssert(txn->magic == MAGIC_ALIVE);
SET_TEST_HANDLER(txn->current_handler, synserver_txn_write_response_handler);
- INKIOBufferBlock block;
+ TSIOBufferBlock block;
char *ptr_block;
- int len, ndone, ntodo, towrite, avail;
+ int64 len, ndone, ntodo, towrite, avail;
char *response;
response = generate_response(txn->request);
@@ -863,147 +863,147 @@ synserver_txn_write_response(INKCont con
ndone = 0;
ntodo = len;
while (ntodo > 0) {
- block = INKIOBufferStart(txn->resp_buffer);
- ptr_block = INKIOBufferBlockWriteStart(block, &avail);
+ block = TSIOBufferStart(txn->resp_buffer);
+ ptr_block = TSIOBufferBlockWriteStart(block, &avail);
towrite = MIN(ntodo, avail);
memcpy(ptr_block, response + ndone, towrite);
- INKIOBufferProduce(txn->resp_buffer, towrite);
+ TSIOBufferProduce(txn->resp_buffer, towrite);
ntodo -= towrite;
ndone += towrite;
}
/* Start writing the response */
- INKDebug(SDBG_TAG, "Writing response: |%s| (%d) bytes)", response, len);
- txn->write_vio = INKVConnWrite(txn->vconn, contp, txn->resp_reader, len);
+ TSDebug(SDBG_TAG, "Writing response: |%s| (%d) bytes)", response, len);
+ txn->write_vio = TSVConnWrite(txn->vconn, contp, txn->resp_reader, len);
/* Now that response is in IOBuffer, free up response */
- INKfree(response);
+ TSfree(response);
- return INK_EVENT_IMMEDIATE;
+ return TS_EVENT_IMMEDIATE;
}
static int
-synserver_txn_write_response_handler(INKCont contp, INKEvent event, void *data)
+synserver_txn_write_response_handler(TSCont contp, TSEvent event, void *data)
{
NOWARN_UNUSED(data);
- ServerTxn *txn = (ServerTxn *) INKContDataGet(contp);
- INKAssert(txn->magic == MAGIC_ALIVE);
+ ServerTxn *txn = (ServerTxn *) TSContDataGet(contp);
+ TSAssert(txn->magic == MAGIC_ALIVE);
switch (event) {
- case INK_EVENT_VCONN_WRITE_READY:
- INKDebug(SDBG_TAG, "WRITE_READY");
- INKVIOReenable(txn->write_vio);
+ case TS_EVENT_VCONN_WRITE_READY:
+ TSDebug(SDBG_TAG, "WRITE_READY");
+ TSVIOReenable(txn->write_vio);
break;
- case INK_EVENT_VCONN_WRITE_COMPLETE:
- INKDebug(SDBG_TAG, "WRITE_COMPLETE");
- INKVConnShutdown(txn->vconn, 0, 1);
+ case TS_EVENT_VCONN_WRITE_COMPLETE:
+ TSDebug(SDBG_TAG, "WRITE_COMPLETE");
+ TSVConnShutdown(txn->vconn, 0, 1);
return synserver_txn_close(contp);
break;
- case INK_EVENT_VCONN_EOS:
- INKDebug(SDBG_TAG, "WRITE_EOS");
+ case TS_EVENT_VCONN_EOS:
+ TSDebug(SDBG_TAG, "WRITE_EOS");
return synserver_txn_close(contp);
break;
- case INK_EVENT_ERROR:
- INKDebug(SDBG_TAG, "WRITE_ERROR");
+ case TS_EVENT_ERROR:
+ TSDebug(SDBG_TAG, "WRITE_ERROR");
return synserver_txn_close(contp);
break;
default:
- INKAssert(!"Invalid event");
+ TSAssert(!"Invalid event");
break;
}
- return INK_EVENT_IMMEDIATE;
+ return TS_EVENT_IMMEDIATE;
}
static int
-synserver_txn_read_request(INKCont contp)
+synserver_txn_read_request(TSCont contp)
{
- ServerTxn *txn = (ServerTxn *) INKContDataGet(contp);
- INKAssert(txn->magic == MAGIC_ALIVE);
+ ServerTxn *txn = (ServerTxn *) TSContDataGet(contp);
+ TSAssert(txn->magic == MAGIC_ALIVE);
int end;
- INKIOBufferBlock block = INKIOBufferReaderStart(txn->req_reader);
+ TSIOBufferBlock block = TSIOBufferReaderStart(txn->req_reader);
while (block != NULL) {
- int blocklen;
- const char *blockptr = INKIOBufferBlockReadStart(block, txn->req_reader, &blocklen);
+ int64 blocklen;
+ const char *blockptr = TSIOBufferBlockReadStart(block, txn->req_reader, &blocklen);
if (txn->request_len+blocklen <= REQUEST_MAX_SIZE) {
memcpy((char *) (txn->request + txn->request_len), blockptr, blocklen);
txn->request_len += blocklen;
} else {
- INKError("Error: Request length %d > request buffer size %d", txn->request_len+blocklen, REQUEST_MAX_SIZE);
+ TSError("Error: Request length %d > request buffer size %d", txn->request_len+blocklen, REQUEST_MAX_SIZE);
}
- block = INKIOBufferBlockNext(block);
+ block = TSIOBufferBlockNext(block);
}
txn->request[txn->request_len] = '\0';
- INKDebug(SDBG_TAG, "Request = |%s|, req len = %d", txn->request, txn->request_len);
+ TSDebug(SDBG_TAG, "Request = |%s|, req len = %d", txn->request, txn->request_len);
end = (strstr(txn->request, HTTP_REQUEST_END) != NULL);
- INKDebug(SDBG_TAG, "End of request = %d", end);
+ TSDebug(SDBG_TAG, "End of request = %d", end);
return end;
}
static int
-synserver_txn_read_request_handler(INKCont contp, INKEvent event, void *data)
+synserver_txn_read_request_handler(TSCont contp, TSEvent event, void *data)
{
NOWARN_UNUSED(data);
- ServerTxn *txn = (ServerTxn *) INKContDataGet(contp);
- INKAssert(txn->magic == MAGIC_ALIVE);
+ ServerTxn *txn = (ServerTxn *) TSContDataGet(contp);
+ TSAssert(txn->magic == MAGIC_ALIVE);
int avail, end_of_request;
switch (event) {
- case INK_EVENT_VCONN_READ_READY:
- case INK_EVENT_VCONN_READ_COMPLETE:
- INKDebug(SDBG_TAG, (event == INK_EVENT_VCONN_READ_READY) ? "READ_READY" : "READ_COMPLETE");
- avail = INKIOBufferReaderAvail(txn->req_reader);
- INKDebug(SDBG_TAG, "%d bytes available in buffer", avail);
+ case TS_EVENT_VCONN_READ_READY:
+ case TS_EVENT_VCONN_READ_COMPLETE:
+ TSDebug(SDBG_TAG, (event == TS_EVENT_VCONN_READ_READY) ? "READ_READY" : "READ_COMPLETE");
+ avail = TSIOBufferReaderAvail(txn->req_reader);
+ TSDebug(SDBG_TAG, "%d bytes available in buffer", avail);
if (avail > 0) {
end_of_request = synserver_txn_read_request(contp);
- INKIOBufferReaderConsume(txn->req_reader, avail);
+ TSIOBufferReaderConsume(txn->req_reader, avail);
if (end_of_request) {
- INKVConnShutdown(txn->vconn, 1, 0);
+ TSVConnShutdown(txn->vconn, 1, 0);
return synserver_txn_write_response(contp);
}
}
- INKVIOReenable(txn->read_vio);
+ TSVIOReenable(txn->read_vio);
break;
- case INK_EVENT_VCONN_EOS:
- INKDebug(SDBG_TAG, "READ_EOS");
+ case TS_EVENT_VCONN_EOS:
+ TSDebug(SDBG_TAG, "READ_EOS");
return synserver_txn_close(contp);
break;
- case INK_EVENT_ERROR:
- INKDebug(SDBG_TAG, "READ_ERROR");
+ case TS_EVENT_ERROR:
+ TSDebug(SDBG_TAG, "READ_ERROR");
return synserver_txn_close(contp);
break;
default:
- INKAssert(!"Invalid event");
+ TSAssert(!"Invalid event");
break;
}
- return INK_EVENT_IMMEDIATE;
+ return TS_EVENT_IMMEDIATE;
}
static int
-synserver_txn_main_handler(INKCont contp, INKEvent event, void *data)
+synserver_txn_main_handler(TSCont contp, TSEvent event, void *data)
{
- ServerTxn *txn = (ServerTxn *) INKContDataGet(contp);
- INKAssert(txn->magic == MAGIC_ALIVE);
+ ServerTxn *txn = (ServerTxn *) TSContDataGet(contp);
+ TSAssert(txn->magic == MAGIC_ALIVE);
TxnHandler handler = txn->current_handler;
return (*handler) (contp, event, data);
Modified: trafficserver/traffic/branches/wccp/proxy/InkIOCoreAPI.cc
URL: http://svn.apache.org/viewvc/trafficserver/traffic/branches/wccp/proxy/InkIOCoreAPI.cc?rev=1040383&r1=1040382&r2=1040383&view=diff
==============================================================================
--- trafficserver/traffic/branches/wccp/proxy/InkIOCoreAPI.cc (original)
+++ trafficserver/traffic/branches/wccp/proxy/InkIOCoreAPI.cc Tue Nov 30 01:42:55 2010
@@ -39,48 +39,48 @@
#include "I_Cache.h"
#include "I_HostDB.h"
-INKReturnCode
-sdk_sanity_check_mutex(INKMutex mutex)
+TSReturnCode
+sdk_sanity_check_mutex(TSMutex mutex)
{
#ifdef DEBUG
- if (mutex == NULL || mutex == INK_ERROR_PTR)
- return INK_ERROR;
+ if (mutex == NULL || mutex == TS_ERROR_PTR)
+ return TS_ERROR;
ProxyMutex *mutexp = (ProxyMutex *) mutex;
if (mutexp->m_refcount < 0)
- return INK_ERROR;
+ return TS_ERROR;
if (mutexp->nthread_holding < 0)
- return INK_ERROR;
- return INK_SUCCESS;
+ return TS_ERROR;
+ return TS_SUCCESS;
#else
NOWARN_UNUSED(mutex);
- return INK_SUCCESS;
+ return TS_SUCCESS;
#endif
}
-INKReturnCode
-sdk_sanity_check_hostlookup_structure(INKHostLookupResult data)
+TSReturnCode
+sdk_sanity_check_hostlookup_structure(TSHostLookupResult data)
{
#ifdef DEBUG
- if (data == NULL || data == INK_ERROR_PTR)
- return INK_ERROR;
- return INK_SUCCESS;
+ if (data == NULL || data == TS_ERROR_PTR)
+ return TS_ERROR;
+ return TS_SUCCESS;
#else
NOWARN_UNUSED(data);
- return INK_SUCCESS;
+ return TS_SUCCESS;
#endif
}
-INKReturnCode
+TSReturnCode
sdk_sanity_check_iocore_structure(void *data)
{
#ifdef DEBUG
- if (data == NULL || data == INK_ERROR_PTR)
- return INK_ERROR;
- return INK_SUCCESS;
+ if (data == NULL || data == TS_ERROR_PTR)
+ return TS_ERROR;
+ return TS_SUCCESS;
#else
NOWARN_UNUSED(data);
- return INK_SUCCESS;
+ return TS_SUCCESS;
#endif
}
@@ -101,7 +101,7 @@ struct INKThreadInternal:public EThread
}
#endif
- INKThreadFunc func;
+ TSThreadFunc func;
void *data;
};
@@ -123,10 +123,10 @@ ink_thread_trampoline(void *data)
}
/*
- * INKqa12653. Return INKThread or NULL if error
+ * INKqa12653. Return TSThread or NULL if error
*/
-INKThread
-INKThreadCreate(INKThreadFunc func, void *data)
+TSThread
+TSThreadCreate(TSThreadFunc func, void *data)
{
INKThreadInternal *thread;
@@ -140,14 +140,14 @@ INKThreadCreate(INKThreadFunc func, void
thread->data = data;
if (!(ink_thread_create(ink_thread_trampoline, (void *) thread, 1))) {
- return (INKThread) NULL;
+ return (TSThread) NULL;
}
- return (INKThread) thread;
+ return (TSThread) thread;
}
-INKThread
-INKThreadInit()
+TSThread
+TSThreadInit()
{
INKThreadInternal *thread;
@@ -155,7 +155,7 @@ INKThreadInit()
#ifdef DEBUG
if (thread == NULL)
- return (INKThread) NULL;
+ return (TSThread) NULL;
#endif
thread->set_specific();
@@ -163,24 +163,24 @@ INKThreadInit()
return thread;
}
-INKReturnCode
-INKThreadDestroy(INKThread thread)
+TSReturnCode
+TSThreadDestroy(TSThread thread)
{
- if (sdk_sanity_check_iocore_structure(thread) != INK_SUCCESS)
- return INK_ERROR;
+ if (sdk_sanity_check_iocore_structure(thread) != TS_SUCCESS)
+ return TS_ERROR;
INKThreadInternal *ithread = (INKThreadInternal *) thread;
delete ithread;
- return INK_SUCCESS;
+ return TS_SUCCESS;
}
-INKThread
-INKThreadSelf(void)
+TSThread
+TSThreadSelf(void)
{
- INKThread ithread = (INKThread) this_ethread();
+ TSThread ithread = (TSThread) this_ethread();
#ifdef DEBUG
if (ithread == NULL)
- return (INKThread) NULL;
+ return (TSThread) NULL;
#endif
return ithread;
}
@@ -192,14 +192,14 @@ INKThreadSelf(void)
//
////////////////////////////////////////////////////////////////////
-INKMutex
-INKMutexCreate()
+TSMutex
+TSMutexCreate()
{
ProxyMutex *mutexp = new_ProxyMutex();
- if (sdk_sanity_check_mutex((INKMutex) mutexp) != INK_SUCCESS)
- return (INKMutex) INK_ERROR_PTR;
- return (INKMutex) mutexp;
-// return (INKMutex*) new_ProxyMutex ();
+ if (sdk_sanity_check_mutex((TSMutex) mutexp) != TS_SUCCESS)
+ return (TSMutex) TS_ERROR_PTR;
+ return (TSMutex) mutexp;
+// return (TSMutex*) new_ProxyMutex ();
}
/* The following two APIs are for Into work, actually, APIs of Mutex
@@ -207,16 +207,16 @@ INKMutexCreate()
of the mutex pointer, plugins may want more control of the creation
and destroy of the mutex.*/
-INKMutex
-INKMutexCreateInternal()
+TSMutex
+TSMutexCreateInternal()
{
ProxyMutex *new_mutex = new_ProxyMutex();
new_mutex->refcount_inc();
- return (INKMutex *) new_mutex;
+ return (TSMutex *) new_mutex;
}
int
-INKMutexCheck(INKMutex mutex)
+TSMutexCheck(TSMutex mutex)
{
ProxyMutex *mutexp = (ProxyMutex *) mutex;
if (mutexp->m_refcount < 0)
@@ -226,184 +226,171 @@ INKMutexCheck(INKMutex mutex)
return 1;
}
-INKReturnCode
-INKMutexLock(INKMutex mutexp)
+TSReturnCode
+TSMutexLock(TSMutex mutexp)
{
- if (sdk_sanity_check_mutex(mutexp) != INK_SUCCESS)
- return INK_ERROR;
+ if (sdk_sanity_check_mutex(mutexp) != TS_SUCCESS)
+ return TS_ERROR;
MUTEX_TAKE_LOCK((ProxyMutex *) mutexp, this_ethread());
- return INK_SUCCESS;
+ return TS_SUCCESS;
}
-INKReturnCode
-INKMutexLockTry(INKMutex mutexp, int *lock)
+TSReturnCode
+TSMutexLockTry(TSMutex mutexp, int *lock)
{
- if (sdk_sanity_check_mutex(mutexp) != INK_SUCCESS)
- return INK_ERROR;
+ if (sdk_sanity_check_mutex(mutexp) != TS_SUCCESS)
+ return TS_ERROR;
*lock = MUTEX_TAKE_TRY_LOCK((ProxyMutex *) mutexp, this_ethread());
- return INK_SUCCESS;
+ return TS_SUCCESS;
}
-/* deprecated in SDK3.0 */
-int
-INKMutexTryLock(INKMutex mutexp)
+TSReturnCode
+TSMutexUnlock(TSMutex mutexp)
{
- return MUTEX_TAKE_TRY_LOCK((ProxyMutex *) mutexp, this_ethread());
-}
-
-INKReturnCode
-INKMutexUnlock(INKMutex mutexp)
-{
- if (sdk_sanity_check_mutex(mutexp) != INK_SUCCESS)
- return INK_ERROR;
+ if (sdk_sanity_check_mutex(mutexp) != TS_SUCCESS)
+ return TS_ERROR;
MUTEX_UNTAKE_LOCK((ProxyMutex *) mutexp, this_ethread());
- return INK_SUCCESS;
+ return TS_SUCCESS;
}
/* VIOs */
-INKReturnCode
-INKVIOReenable(INKVIO viop)
+TSReturnCode
+TSVIOReenable(TSVIO viop)
{
- if (sdk_sanity_check_iocore_structure(viop) != INK_SUCCESS)
- return INK_ERROR;
+ if (sdk_sanity_check_iocore_structure(viop) != TS_SUCCESS)
+ return TS_ERROR;
VIO *vio = (VIO *) viop;
vio->reenable();
- return INK_SUCCESS;
+ return TS_SUCCESS;
}
-INKIOBuffer
-INKVIOBufferGet(INKVIO viop)
+TSIOBuffer
+TSVIOBufferGet(TSVIO viop)
{
- if (sdk_sanity_check_iocore_structure(viop) != INK_SUCCESS)
- return (INKIOBuffer) INK_ERROR_PTR;
+ if (sdk_sanity_check_iocore_structure(viop) != TS_SUCCESS)
+ return (TSIOBuffer) TS_ERROR_PTR;
VIO *vio = (VIO *) viop;
return vio->get_writer();
}
-INKIOBufferReader
-INKVIOReaderGet(INKVIO viop)
+TSIOBufferReader
+TSVIOReaderGet(TSVIO viop)
{
- if (sdk_sanity_check_iocore_structure(viop) != INK_SUCCESS)
- return (INKIOBufferReader) INK_ERROR_PTR;
+ if (sdk_sanity_check_iocore_structure(viop) != TS_SUCCESS)
+ return (TSIOBufferReader) TS_ERROR_PTR;
VIO *vio = (VIO *) viop;
return vio->get_reader();
}
-int
-INKVIONBytesGet(INKVIO viop)
+int64
+TSVIONBytesGet(TSVIO viop)
{
- if (sdk_sanity_check_iocore_structure(viop) != INK_SUCCESS)
- return INK_ERROR;
+ if (sdk_sanity_check_iocore_structure(viop) != TS_SUCCESS)
+ return TS_ERROR;
VIO *vio = (VIO *) viop;
return vio->nbytes;
}
-INKReturnCode
-INKVIONBytesSet(INKVIO viop, int nbytes)
+TSReturnCode
+TSVIONBytesSet(TSVIO viop, int64 nbytes)
{
- if ((sdk_sanity_check_iocore_structure(viop) != INK_SUCCESS) || nbytes < 0)
- return INK_ERROR;
+ if ((sdk_sanity_check_iocore_structure(viop) != TS_SUCCESS) || nbytes < 0)
+ return TS_ERROR;
VIO *vio = (VIO *) viop;
vio->nbytes = nbytes;
- return INK_SUCCESS;
+ return TS_SUCCESS;
}
-int
-INKVIONDoneGet(INKVIO viop)
+int64
+TSVIONDoneGet(TSVIO viop)
{
- if (sdk_sanity_check_iocore_structure(viop) != INK_SUCCESS)
- return INK_ERROR;
+ if (sdk_sanity_check_iocore_structure(viop) != TS_SUCCESS)
+ return TS_ERROR;
VIO *vio = (VIO *) viop;
return vio->ndone;
}
-INKReturnCode
-INKVIONDoneSet(INKVIO viop, int ndone)
+TSReturnCode
+TSVIONDoneSet(TSVIO viop, int64 ndone)
{
- if ((sdk_sanity_check_iocore_structure(viop) != INK_SUCCESS) || ndone < 0)
- return INK_ERROR;
+ if ((sdk_sanity_check_iocore_structure(viop) != TS_SUCCESS) || ndone < 0)
+ return TS_ERROR;
VIO *vio = (VIO *) viop;
vio->ndone = ndone;
- return INK_SUCCESS;
+ return TS_SUCCESS;
}
-int
-INKVIONTodoGet(INKVIO viop)
+int64
+TSVIONTodoGet(TSVIO viop)
{
- if (sdk_sanity_check_iocore_structure(viop) != INK_SUCCESS)
- return INK_ERROR;
+ if (sdk_sanity_check_iocore_structure(viop) != TS_SUCCESS)
+ return TS_ERROR;
VIO *vio = (VIO *) viop;
return vio->ntodo();
}
-INKCont
-INKVIOContGet(INKVIO viop)
+TSCont
+TSVIOContGet(TSVIO viop)
{
- if (sdk_sanity_check_iocore_structure(viop) != INK_SUCCESS)
- return (INKCont) INK_ERROR_PTR;
+ if (sdk_sanity_check_iocore_structure(viop) != TS_SUCCESS)
+ return (TSCont) TS_ERROR_PTR;
VIO *vio = (VIO *) viop;
- return (INKCont) vio->_cont;
+ return (TSCont) vio->_cont;
}
-INKVConn
-INKVIOVConnGet(INKVIO viop)
+TSVConn
+TSVIOVConnGet(TSVIO viop)
{
- if (sdk_sanity_check_iocore_structure(viop) != INK_SUCCESS)
- return (INKVConn) INK_ERROR_PTR;
+ if (sdk_sanity_check_iocore_structure(viop) != TS_SUCCESS)
+ return (TSVConn) TS_ERROR_PTR;
VIO *vio = (VIO *) viop;
- return (INKVConn) vio->vc_server;
+ return (TSVConn) vio->vc_server;
}
-INKMutex
-INKVIOMutexGet(INKVIO viop)
+TSMutex
+TSVIOMutexGet(TSVIO viop)
{
- if (sdk_sanity_check_iocore_structure(viop) != INK_SUCCESS)
- return (INKVConn) INK_ERROR_PTR;
+ if (sdk_sanity_check_iocore_structure(viop) != TS_SUCCESS)
+ return (TSVConn) TS_ERROR_PTR;
VIO *vio = (VIO *) viop;
- return (INKMutex) ((ProxyMutex *) vio->mutex);
+ return (TSMutex) ((ProxyMutex *) vio->mutex);
}
/* High Resolution Time */
-unsigned int
+ink_hrtime
INKBasedTimeGet()
{
return ink_get_based_hrtime();
}
-double
-INKBasedTimeGetD()
-{
- return (double) ink_get_based_hrtime();
-}
-
/* UDP Connection Interface */
-INKAction
-INKUDPBind(INKCont contp, unsigned int ip, int port)
+TSAction
+INKUDPBind(TSCont contp, unsigned int ip, int port)
{
FORCE_PLUGIN_MUTEX(contp);
return (udpNet.UDPBind((Continuation *) contp, port, ip, INK_ETHERNET_MTU_SIZE, INK_ETHERNET_MTU_SIZE));
}
-INKAction
-INKUDPSendTo(INKCont contp, INKUDPConn udp, unsigned int ip, int port, char *data, int len)
+TSAction
+INKUDPSendTo(TSCont contp, INKUDPConn udp, unsigned int ip, int port, char *data, int64 len)
{
FORCE_PLUGIN_MUTEX(contp);
UDPPacket *packet = new_UDPPacket();
@@ -433,8 +420,8 @@ INKUDPSendTo(INKCont contp, INKUDPConn u
}
-INKAction
-INKUDPRecvFrom(INKCont contp, INKUDPConn udp)
+TSAction
+INKUDPRecvFrom(TSCont contp, INKUDPConn udp)
{
FORCE_PLUGIN_MUTEX(contp);
UDPConnection *conn = (UDPConnection *) udp;
@@ -456,11 +443,11 @@ INKUDPPacketCreate()
return ((INKUDPPacket) packet);
}
-INKIOBufferBlock
+TSIOBufferBlock
INKUDPPacketBufferBlockGet(INKUDPPacket packet)
{
UDPPacket *p = (UDPPacket *) packet;
- return ((INKIOBufferBlock) p->getIOBlockChain());
+ return ((TSIOBufferBlock) p->getIOBlockChain());
}
unsigned int
@@ -508,47 +495,47 @@ INKUDPPacketGet(INKUDPacketQueue queuep)
/* Buffers */
-INKIOBuffer
-INKIOBufferCreate()
+TSIOBuffer
+TSIOBufferCreate()
{
MIOBuffer *b = new_empty_MIOBuffer();
- if (sdk_sanity_check_iocore_structure(b) != INK_SUCCESS) {
- return (INKIOBuffer) INK_ERROR_PTR;
+ if (sdk_sanity_check_iocore_structure(b) != TS_SUCCESS) {
+ return (TSIOBuffer) TS_ERROR_PTR;
}
- return (INKIOBuffer *) b;
+ return (TSIOBuffer *) b;
}
-INKIOBuffer
-INKIOBufferSizedCreate(INKIOBufferSizeIndex index)
+TSIOBuffer
+TSIOBufferSizedCreate(TSIOBufferSizeIndex index)
{
- if ((index<INK_IOBUFFER_SIZE_INDEX_128) || (index> INK_IOBUFFER_SIZE_INDEX_32K)) {
- return (INKIOBuffer) INK_ERROR_PTR;
+ if ((index<TS_IOBUFFER_SIZE_INDEX_128) || (index> TS_IOBUFFER_SIZE_INDEX_32K)) {
+ return (TSIOBuffer) TS_ERROR_PTR;
}
MIOBuffer *b = new_MIOBuffer(index);
- if (sdk_sanity_check_iocore_structure(b) != INK_SUCCESS) {
- return (INKIOBuffer) INK_ERROR_PTR;
+ if (sdk_sanity_check_iocore_structure(b) != TS_SUCCESS) {
+ return (TSIOBuffer) TS_ERROR_PTR;
}
- return (INKIOBuffer *) b;
+ return (TSIOBuffer *) b;
}
-INKReturnCode
-INKIOBufferDestroy(INKIOBuffer bufp)
+TSReturnCode
+TSIOBufferDestroy(TSIOBuffer bufp)
{
- if (sdk_sanity_check_iocore_structure(bufp) != INK_SUCCESS)
- return INK_ERROR;
+ if (sdk_sanity_check_iocore_structure(bufp) != TS_SUCCESS)
+ return TS_ERROR;
free_MIOBuffer((MIOBuffer *) bufp);
- return INK_SUCCESS;
+ return TS_SUCCESS;
}
-INKIOBufferBlock
-INKIOBufferStart(INKIOBuffer bufp)
+TSIOBufferBlock
+TSIOBufferStart(TSIOBuffer bufp)
{
- if (sdk_sanity_check_iocore_structure(bufp) != INK_SUCCESS)
- return (INKIOBufferBlock) INK_ERROR_PTR;
+ if (sdk_sanity_check_iocore_structure(bufp) != TS_SUCCESS)
+ return (TSIOBufferBlock) TS_ERROR_PTR;
MIOBuffer *b = (MIOBuffer *) bufp;
IOBufferBlock *blk = b->get_current_block();
@@ -563,32 +550,32 @@ INKIOBufferStart(INKIOBuffer bufp)
// ink_debug_assert (blk->write_avail () > 0);
#ifdef DEBUG
if (blk == NULL || (blk->write_avail() <= 0))
- return (INKIOBufferBlock) INK_ERROR_PTR;
+ return (TSIOBufferBlock) TS_ERROR_PTR;
#endif
- return (INKIOBufferBlock) blk;
+ return (TSIOBufferBlock) blk;
}
-INKReturnCode
-INKIOBufferAppend(INKIOBuffer bufp, INKIOBufferBlock blockp)
+TSReturnCode
+TSIOBufferAppend(TSIOBuffer bufp, TSIOBufferBlock blockp)
{
- if ((sdk_sanity_check_iocore_structure(bufp) != INK_SUCCESS) ||
- (sdk_sanity_check_iocore_structure(blockp) != INK_SUCCESS))
- return INK_ERROR;
+ if ((sdk_sanity_check_iocore_structure(bufp) != TS_SUCCESS) ||
+ (sdk_sanity_check_iocore_structure(blockp) != TS_SUCCESS))
+ return TS_ERROR;
MIOBuffer *b = (MIOBuffer *) bufp;
IOBufferBlock *blk = (IOBufferBlock *) blockp;
b->append_block(blk);
- return INK_SUCCESS;
+ return TS_SUCCESS;
}
-int
-INKIOBufferCopy(INKIOBuffer bufp, INKIOBufferReader readerp, int length, int offset)
+int64
+TSIOBufferCopy(TSIOBuffer bufp, TSIOBufferReader readerp, int64 length, int64 offset)
{
- if ((sdk_sanity_check_iocore_structure(bufp) != INK_SUCCESS) ||
- (sdk_sanity_check_iocore_structure(readerp) != INK_SUCCESS) || length < 0 || offset < 0)
- return INK_ERROR;
+ if ((sdk_sanity_check_iocore_structure(bufp) != TS_SUCCESS) ||
+ (sdk_sanity_check_iocore_structure(readerp) != TS_SUCCESS) || length < 0 || offset < 0)
+ return TS_ERROR;
MIOBuffer *b = (MIOBuffer *) bufp;
IOBufferReader *r = (IOBufferReader *) readerp;
@@ -596,11 +583,11 @@ INKIOBufferCopy(INKIOBuffer bufp, INKIOB
return b->write(r, length, offset);
}
-int
-INKIOBufferWrite(INKIOBuffer bufp, const void *buf, int length)
+int64
+TSIOBufferWrite(TSIOBuffer bufp, const void *buf, int64 length)
{
- if ((sdk_sanity_check_iocore_structure(bufp) != INK_SUCCESS) || (buf == NULL) || (length < 0)) {
- return INK_ERROR;
+ if ((sdk_sanity_check_iocore_structure(bufp) != TS_SUCCESS) || (buf == NULL) || (length < 0)) {
+ return TS_ERROR;
}
MIOBuffer *b = (MIOBuffer *) bufp;
@@ -609,96 +596,96 @@ INKIOBufferWrite(INKIOBuffer bufp, const
// not in SDK3.0
void
-INKIOBufferReaderCopy(INKIOBufferReader readerp, const void *buf, int length)
+TSIOBufferReaderCopy(TSIOBufferReader readerp, const void *buf, int64 length)
{
IOBufferReader *r = (IOBufferReader *) readerp;
r->memcpy(buf, length);
}
-INKReturnCode
-INKIOBufferProduce(INKIOBuffer bufp, int nbytes)
+TSReturnCode
+TSIOBufferProduce(TSIOBuffer bufp, int64 nbytes)
{
- if ((sdk_sanity_check_iocore_structure(bufp) != INK_SUCCESS) || nbytes < 0)
- return INK_ERROR;
+ if ((sdk_sanity_check_iocore_structure(bufp) != TS_SUCCESS) || nbytes < 0)
+ return TS_ERROR;
MIOBuffer *b = (MIOBuffer *) bufp;
b->fill(nbytes);
- return INK_SUCCESS;
+ return TS_SUCCESS;
}
-INKIOBufferData
-INKIOBufferDataCreate(void *data, int size, INKIOBufferDataFlags flags)
+TSIOBufferData
+TSIOBufferDataCreate(void *data, int64 size, TSIOBufferDataFlags flags)
{
#ifdef DEBUG
- if (data == NULL || data == INK_ERROR_PTR || size <= 0 ||
- ((flags != INK_DATA_ALLOCATE) && (flags != INK_DATA_MALLOCED) && (flags != INK_DATA_CONSTANT)))
- return (INKIOBufferData) INK_ERROR_PTR;
+ if (data == NULL || data == TS_ERROR_PTR || size <= 0 ||
+ ((flags != TS_DATA_ALLOCATE) && (flags != TS_DATA_MALLOCED) && (flags != TS_DATA_CONSTANT)))
+ return (TSIOBufferData) TS_ERROR_PTR;
#endif
// simply return error_ptr
//ink_assert (size > 0);
switch (flags) {
- case INK_DATA_ALLOCATE:
+ case TS_DATA_ALLOCATE:
ink_assert(data == NULL);
- return (INKIOBufferData) new_IOBufferData(iobuffer_size_to_index(size));
+ return (TSIOBufferData) new_IOBufferData(iobuffer_size_to_index(size));
- case INK_DATA_MALLOCED:
+ case TS_DATA_MALLOCED:
ink_assert(data != NULL);
- return (INKIOBufferData) new_xmalloc_IOBufferData(data, size);
+ return (TSIOBufferData) new_xmalloc_IOBufferData(data, size);
- case INK_DATA_CONSTANT:
+ case TS_DATA_CONSTANT:
ink_assert(data != NULL);
- return (INKIOBufferData) new_constant_IOBufferData(data, size);
+ return (TSIOBufferData) new_constant_IOBufferData(data, size);
}
// simply return error_ptr
// ink_assert (!"not reached");
- return (INKIOBufferData) INK_ERROR_PTR;
+ return (TSIOBufferData) TS_ERROR_PTR;
}
-INKIOBufferBlock
-INKIOBufferBlockCreate(INKIOBufferData datap, int size, int offset)
+TSIOBufferBlock
+TSIOBufferBlockCreate(TSIOBufferData datap, int64 size, int64 offset)
{
- if ((sdk_sanity_check_iocore_structure(datap) != INK_SUCCESS) || size < 0 || offset < 0)
- return (INKIOBufferBlock) INK_ERROR;
+ if ((sdk_sanity_check_iocore_structure(datap) != TS_SUCCESS) || size < 0 || offset < 0)
+ return (TSIOBufferBlock) TS_ERROR;
IOBufferData *d = (IOBufferData *) datap;
- return (INKIOBufferBlock) new_IOBufferBlock(d, size, offset);
+ return (TSIOBufferBlock) new_IOBufferBlock(d, size, offset);
}
// dev API, not exposed
-INKReturnCode
-INKIOBufferBlockDestroy(INKIOBufferBlock blockp)
+TSReturnCode
+TSIOBufferBlockDestroy(TSIOBufferBlock blockp)
{
IOBufferBlock *blk = (IOBufferBlock *) blockp;
blk->free();
- return INK_SUCCESS;
+ return TS_SUCCESS;
}
-INKIOBufferBlock
-INKIOBufferBlockNext(INKIOBufferBlock blockp)
+TSIOBufferBlock
+TSIOBufferBlockNext(TSIOBufferBlock blockp)
{
- if (sdk_sanity_check_iocore_structure(blockp) != INK_SUCCESS) {
- return (INKIOBuffer) INK_ERROR_PTR;
+ if (sdk_sanity_check_iocore_structure(blockp) != TS_SUCCESS) {
+ return (TSIOBuffer) TS_ERROR_PTR;
}
IOBufferBlock *blk = (IOBufferBlock *) blockp;
- return (INKIOBufferBlock) ((IOBufferBlock *) blk->next);
+ return (TSIOBufferBlock) ((IOBufferBlock *) blk->next);
}
// dev API, not exposed
-int
-INKIOBufferBlockDataSizeGet(INKIOBufferBlock blockp)
+int64
+TSIOBufferBlockDataSizeGet(TSIOBufferBlock blockp)
{
IOBufferBlock *blk = (IOBufferBlock *) blockp;
return (blk->read_avail());
}
const char *
-INKIOBufferBlockReadStart(INKIOBufferBlock blockp, INKIOBufferReader readerp, int *avail)
+TSIOBufferBlockReadStart(TSIOBufferBlock blockp, TSIOBufferReader readerp, int64 *avail)
{
- if ((sdk_sanity_check_iocore_structure(blockp) != INK_SUCCESS) ||
- (sdk_sanity_check_iocore_structure(readerp) != INK_SUCCESS))
- return (const char *) INK_ERROR_PTR;
+ if ((sdk_sanity_check_iocore_structure(blockp) != TS_SUCCESS) ||
+ (sdk_sanity_check_iocore_structure(readerp) != TS_SUCCESS))
+ return (const char *) TS_ERROR_PTR;
IOBufferBlock *blk = (IOBufferBlock *) blockp;
IOBufferReader *reader = (IOBufferReader *) readerp;
@@ -722,16 +709,16 @@ INKIOBufferBlockReadStart(INKIOBufferBlo
return (const char *) p;
}
-int
-INKIOBufferBlockReadAvail(INKIOBufferBlock blockp, INKIOBufferReader readerp)
+int64
+TSIOBufferBlockReadAvail(TSIOBufferBlock blockp, TSIOBufferReader readerp)
{
- if ((sdk_sanity_check_iocore_structure(blockp) != INK_SUCCESS) ||
- (sdk_sanity_check_iocore_structure(readerp) != INK_SUCCESS))
- return INK_ERROR;
+ if ((sdk_sanity_check_iocore_structure(blockp) != TS_SUCCESS) ||
+ (sdk_sanity_check_iocore_structure(readerp) != TS_SUCCESS))
+ return TS_ERROR;
IOBufferBlock *blk = (IOBufferBlock *) blockp;
IOBufferReader *reader = (IOBufferReader *) readerp;
- int avail;
+ int64 avail;
avail = blk->read_avail();
@@ -746,10 +733,10 @@ INKIOBufferBlockReadAvail(INKIOBufferBlo
}
char *
-INKIOBufferBlockWriteStart(INKIOBufferBlock blockp, int *avail)
+TSIOBufferBlockWriteStart(TSIOBufferBlock blockp, int64 *avail)
{
- if (sdk_sanity_check_iocore_structure(blockp) != INK_SUCCESS)
- return (char *) INK_ERROR_PTR;
+ if (sdk_sanity_check_iocore_structure(blockp) != TS_SUCCESS)
+ return (char *) TS_ERROR_PTR;
IOBufferBlock *blk = (IOBufferBlock *) blockp;
if (avail) {
@@ -758,106 +745,106 @@ INKIOBufferBlockWriteStart(INKIOBufferBl
return blk->end();
}
-int
-INKIOBufferBlockWriteAvail(INKIOBufferBlock blockp)
+int64
+TSIOBufferBlockWriteAvail(TSIOBufferBlock blockp)
{
- if (sdk_sanity_check_iocore_structure(blockp) != INK_SUCCESS) {
- return INK_ERROR;
+ if (sdk_sanity_check_iocore_structure(blockp) != TS_SUCCESS) {
+ return TS_ERROR;
}
IOBufferBlock *blk = (IOBufferBlock *) blockp;
return blk->write_avail();
}
-INKReturnCode
-INKIOBufferWaterMarkGet(INKIOBuffer bufp, int *water_mark)
+TSReturnCode
+TSIOBufferWaterMarkGet(TSIOBuffer bufp, int64 *water_mark)
{
- if ((sdk_sanity_check_iocore_structure(bufp) != INK_SUCCESS) || (water_mark == NULL)) {
- return INK_ERROR;
+ if ((sdk_sanity_check_iocore_structure(bufp) != TS_SUCCESS) || (water_mark == NULL)) {
+ return TS_ERROR;
}
MIOBuffer *b = (MIOBuffer *) bufp;
*water_mark = b->water_mark;
- return INK_SUCCESS;
+ return TS_SUCCESS;
}
-INKReturnCode
-INKIOBufferWaterMarkSet(INKIOBuffer bufp, int water_mark)
+TSReturnCode
+TSIOBufferWaterMarkSet(TSIOBuffer bufp, int64 water_mark)
{
- if ((sdk_sanity_check_iocore_structure(bufp) != INK_SUCCESS) || water_mark < 0)
- return INK_ERROR;
+ if ((sdk_sanity_check_iocore_structure(bufp) != TS_SUCCESS) || water_mark < 0)
+ return TS_ERROR;
MIOBuffer *b = (MIOBuffer *) bufp;
b->water_mark = water_mark;
- return INK_SUCCESS;
+ return TS_SUCCESS;
}
-INKIOBufferReader
-INKIOBufferReaderAlloc(INKIOBuffer bufp)
+TSIOBufferReader
+TSIOBufferReaderAlloc(TSIOBuffer bufp)
{
- if (sdk_sanity_check_iocore_structure(bufp) != INK_SUCCESS)
- return (INKIOBufferReader) INK_ERROR_PTR;
+ if (sdk_sanity_check_iocore_structure(bufp) != TS_SUCCESS)
+ return (TSIOBufferReader) TS_ERROR_PTR;
MIOBuffer *b = (MIOBuffer *) bufp;
- INKIOBufferReader readerp = (INKIOBufferReader) b->alloc_reader();
+ TSIOBufferReader readerp = (TSIOBufferReader) b->alloc_reader();
#ifdef DEBUG
if (readerp == NULL)
- return (INKIOBufferReader) INK_ERROR_PTR;
+ return (TSIOBufferReader) TS_ERROR_PTR;
#endif
return readerp;
}
-INKIOBufferReader
-INKIOBufferReaderClone(INKIOBufferReader readerp)
+TSIOBufferReader
+TSIOBufferReaderClone(TSIOBufferReader readerp)
{
- if (sdk_sanity_check_iocore_structure(readerp) != INK_SUCCESS)
- return (INKIOBufferReader) INK_ERROR_PTR;
+ if (sdk_sanity_check_iocore_structure(readerp) != TS_SUCCESS)
+ return (TSIOBufferReader) TS_ERROR_PTR;
IOBufferReader *r = (IOBufferReader *) readerp;
- return (INKIOBufferReader) r->clone();
+ return (TSIOBufferReader) r->clone();
}
-INKReturnCode
-INKIOBufferReaderFree(INKIOBufferReader readerp)
+TSReturnCode
+TSIOBufferReaderFree(TSIOBufferReader readerp)
{
- if (sdk_sanity_check_iocore_structure(readerp) != INK_SUCCESS)
- return INK_ERROR;
+ if (sdk_sanity_check_iocore_structure(readerp) != TS_SUCCESS)
+ return TS_ERROR;
IOBufferReader *r = (IOBufferReader *) readerp;
r->mbuf->dealloc_reader(r);
- return INK_SUCCESS;
+ return TS_SUCCESS;
}
-INKIOBufferBlock
-INKIOBufferReaderStart(INKIOBufferReader readerp)
+TSIOBufferBlock
+TSIOBufferReaderStart(TSIOBufferReader readerp)
{
- if (sdk_sanity_check_iocore_structure(readerp) != INK_SUCCESS)
- return (INKIOBufferBlock) INK_ERROR_PTR;
+ if (sdk_sanity_check_iocore_structure(readerp) != TS_SUCCESS)
+ return (TSIOBufferBlock) TS_ERROR_PTR;
IOBufferReader *r = (IOBufferReader *) readerp;
if (r->block != NULL) {
r->skip_empty_blocks();
}
- return (INKIOBufferBlock) r->block;
+ return (TSIOBufferBlock) r->block;
}
-INKReturnCode
-INKIOBufferReaderConsume(INKIOBufferReader readerp, int nbytes)
+TSReturnCode
+TSIOBufferReaderConsume(TSIOBufferReader readerp, int64 nbytes)
{
- if ((sdk_sanity_check_iocore_structure(readerp) != INK_SUCCESS) || nbytes < 0)
- return INK_ERROR;
+ if ((sdk_sanity_check_iocore_structure(readerp) != TS_SUCCESS) || nbytes < 0)
+ return TS_ERROR;
IOBufferReader *r = (IOBufferReader *) readerp;
r->consume(nbytes);
- return INK_SUCCESS;
+ return TS_SUCCESS;
}
-int
-INKIOBufferReaderAvail(INKIOBufferReader readerp)
+int64
+TSIOBufferReaderAvail(TSIOBufferReader readerp)
{
- if (sdk_sanity_check_iocore_structure(readerp) != INK_SUCCESS)
- return INK_ERROR;
+ if (sdk_sanity_check_iocore_structure(readerp) != TS_SUCCESS)
+ return TS_ERROR;
IOBufferReader *r = (IOBufferReader *) readerp;
return r->read_avail();
Modified: trafficserver/traffic/branches/wccp/proxy/InkXml.cc
URL: http://svn.apache.org/viewvc/trafficserver/traffic/branches/wccp/proxy/InkXml.cc?rev=1040383&r1=1040382&r2=1040383&view=diff
==============================================================================
--- trafficserver/traffic/branches/wccp/proxy/InkXml.cc (original)
+++ trafficserver/traffic/branches/wccp/proxy/InkXml.cc Tue Nov 30 01:42:55 2010
@@ -165,14 +165,14 @@ int
InkXmlConfigFile::parse(int fd)
{
ink_assert(fd >= 0);
- Debug("log2", "Parsing XML config info from memory..");
+ Debug("log", "Parsing XML config info from memory..");
m_line = 1;
m_col = 0;
InkXmlObject *obj;
while ((obj = get_next_xml_object(fd)) != NULL) {
- Debug("log2", "Adding XML object <%s>", obj->object_name());
+ Debug("log", "Adding XML object <%s>", obj->object_name());
add_object(obj);
}
Modified: trafficserver/traffic/branches/wccp/proxy/Main.cc
URL: http://svn.apache.org/viewvc/trafficserver/traffic/branches/wccp/proxy/Main.cc?rev=1040383&r1=1040382&r2=1040383&view=diff
==============================================================================
--- trafficserver/traffic/branches/wccp/proxy/Main.cc (original)
+++ trafficserver/traffic/branches/wccp/proxy/Main.cc Tue Nov 30 01:42:55 2010
@@ -75,11 +75,7 @@ extern "C" int plock(int);
//#include "ClusterTest.h"
#include "CacheControl.h"
#include "IPAllow.h"
-#include "CacheInspectorAllow.h"
#include "ParentSelection.h"
-#ifdef RNI_STATIC_LINK
-#include "RniProcessor.h"
-#endif
//#include "simple/Simple.h"
#include "MgmtUtils.h"
@@ -117,13 +113,11 @@ extern "C" int plock(int);
#define DEFAULT_NUMBER_OF_THREADS ink_number_of_processors()
#define DEFAULT_NUMBER_OF_UDP_THREADS 1
#define DEFAULT_NUMBER_OF_CLUSTER_THREADS 1
-//#define DEFAULT_NUMBER_OF_AUTH_THREADS (ink_number_of_processors() + 1)
#define DEFAULT_NUMBER_OF_SSL_THREADS 0
-#define DEFAULT_USE_ACCEPT_THREAD 0
+#define DEFAULT_NUM_ACCEPT_THREADS 0
#define DEFAULT_HTTP_ACCEPT_PORT_NUMBER 0
#define DEFAULT_COMMAND_FLAG 0
#define DEFAULT_LOCK_PROCESS 0
-#define MAX_NUMBER_OF_THREADS 1024
#define DEFAULT_VERBOSE_FLAG 0
#define DEFAULT_VERSION_FLAG 0
@@ -145,8 +139,7 @@ int num_of_net_threads = DEFAULT_NUMBER_
int num_of_cluster_threads = DEFAULT_NUMBER_OF_CLUSTER_THREADS;
int num_of_udp_threads = DEFAULT_NUMBER_OF_UDP_THREADS;
int num_of_ssl_threads = DEFAULT_NUMBER_OF_SSL_THREADS;
-extern int use_accept_thread;
-// = DEFAULT_USE_ACCEPT_THREAD;
+int num_accept_threads = DEFAULT_NUM_ACCEPT_THREADS;
int run_test_hook = 0;
int http_accept_port_number = DEFAULT_HTTP_ACCEPT_PORT_NUMBER;
int http_accept_file_descriptor = NO_FD;
@@ -154,7 +147,7 @@ int ssl_accept_file_descriptor = NO_FD;
char accept_fd_list[1024] = "";
char core_file[255] = "";
int command_flag = DEFAULT_COMMAND_FLAG;
-#ifndef INK_NO_TESTS
+#if TS_HAS_TESTS
char regression_test[1024] = "";
#endif
int auto_clear_hostdb_flag = 0;
@@ -196,10 +189,10 @@ static int cmd_line_dprintf_level = 0;
AppVersionInfo appVersionInfo; // Build info for this application
-#ifndef INK_NO_TESTS
-extern int test_net_processor();
-
+#if TS_HAS_TESTS
extern int run_TestHook();
+// TODO: Maybe review and "fix" this test at some point?
+//
//extern void run_SimpleHttp();
#endif
void deinitSubAgent();
@@ -220,7 +213,7 @@ ArgumentDescription argument_description
&num_of_cluster_threads, "PROXY_CLUSTER_THREADS", NULL},
{"udp_threads", 'U', "Number of UDP Threads", "I",
&num_of_udp_threads, "PROXY_UDP_THREADS", NULL},
- {"accept_thread", 'a', "Use an Accept Thread", "T", &use_accept_thread,
+ {"accept_thread", 'a', "Use an Accept Thread", "T", &num_accept_threads,
"PROXY_ACCEPT_THREAD", NULL},
{"accept_till_done", 'b', "Accept Till Done", "T", &accept_till_done,
"PROXY_ACCEPT_TILL_DONE", NULL},
@@ -234,7 +227,7 @@ ArgumentDescription argument_description
"PROXY_DPRINTF_LEVEL", NULL},
{"version", 'V', "Print Version String", "T", &version_flag,
NULL, NULL},
-#ifndef INK_NO_TESTS
+#if TS_HAS_TESTS
{"regression", 'R',
#ifdef DEBUG
"Regression Level (quick:1..long:3)",
@@ -257,7 +250,7 @@ ArgumentDescription argument_description
#endif
"T",
&run_test_hook, "PROXY_RUN_TEST_HOOK", NULL},
-#endif //INK_NO_TESTS
+#endif //TS_HAS_TESTS
#if TS_USE_DIAGS
{"debug_tags", 'T', "Vertical-bar-separated Debug Tags", "S1023", error_tags,
"PROXY_DEBUG_TAGS", NULL},
@@ -450,12 +443,12 @@ init_dirs(void)
}
if (access(system_log_dir, W_OK) == -1) {
- REC_ReadConfigString(buf, "proxy.config.log2.logfile_dir", PATH_NAME_MAX);
+ REC_ReadConfigString(buf, "proxy.config.log.logfile_dir", PATH_NAME_MAX);
Layout::get()->relative(system_log_dir, PATH_NAME_MAX, buf);
if (access(system_log_dir, W_OK) == -1) {
fprintf(stderr,"unable to access() log dir'%s':%d, %s\n",
system_log_dir, errno, strerror(errno));
- fprintf(stderr,"please set 'proxy.config.log2.logfile_dir'\n");
+ fprintf(stderr,"please set 'proxy.config.log.logfile_dir'\n");
_exit(1);
}
}
@@ -987,8 +980,8 @@ parse_accept_fd_list()
if (attr_str == NULL) {
attr = SERVER_PORT_DEFAULT;
} else {
- if (strlen(attr_str) > 1) {
- Warning("too many port attribute fields (more than 1) '%s'", attr);
+ if (strlen(attr_str) > 2) {
+ Warning("too many port attribute fields (more than 2) '%s'", attr);
attr = SERVER_PORT_DEFAULT;
} else {
switch (*attr_str) {
@@ -1091,24 +1084,6 @@ init_core_size()
}
}
-static void
-init_ink_memalign_heap(void)
-{
- int64 ram_cache_max = -1;
- int enable_preallocation = 1;
-
- TS_ReadConfigInteger(enable_preallocation, "proxy.config.system.memalign_heap");
- if (enable_preallocation) {
- TS_ReadConfigInteger(ram_cache_max, "proxy.config.cache.ram_cache.size");
- if (ram_cache_max > 0) {
- if (!ink_memalign_heap_init(ram_cache_max))
- Warning("Unable to init memalign heap");
- } else {
- Warning("Unable to read proxy.config.cache.ram_cache.size var from config");
- }
- }
-}
-
#if TS_USE_POSIX_CAP
// Restore the effective capabilities that we need.
int
@@ -1188,43 +1163,43 @@ struct ShowStats: public Continuation
printf("r:rr w:ww r:rbs w:wbs open polls\n");
ink_statval_t sval, cval;
- NET_READ_DYN_STAT(net_calls_to_readfromnet_stat, sval, cval);
+ NET_READ_DYN_SUM(net_calls_to_readfromnet_stat, sval);
int64 d_rb = sval - last_rb;
- last_rb += d_rb;
- NET_READ_DYN_STAT(net_calls_to_readfromnet_afterpoll_stat, sval, cval);
+ last_rb += d_rb;
+ NET_READ_DYN_SUM(net_calls_to_readfromnet_afterpoll_stat, sval);
int64 d_r = sval - last_r;
- last_r += d_r;
+ last_r += d_r;
- NET_READ_DYN_STAT(net_calls_to_writetonet_stat, sval, cval);
+ NET_READ_DYN_SUM(net_calls_to_writetonet_stat, sval);
int64 d_wb = sval - last_wb;
- last_wb += d_wb;
- NET_READ_DYN_STAT(net_calls_to_writetonet_afterpoll_stat, sval, cval);
+ last_wb += d_wb;
+ NET_READ_DYN_SUM(net_calls_to_writetonet_afterpoll_stat, sval);
int64 d_w = sval - last_w;
- last_w += d_w;
+ last_w += d_w;
- NET_READ_DYN_STAT(net_read_bytes_stat, sval, cval);
+ NET_READ_DYN_STAT(net_read_bytes_stat, sval, cval);
int64 d_nrb = sval - last_nrb;
- last_nrb += d_nrb;
+ last_nrb += d_nrb;
int64 d_nr = cval - last_nr;
- last_nr += d_nr;
+ last_nr += d_nr;
- NET_READ_DYN_STAT(net_write_bytes_stat, sval, cval);
+ NET_READ_DYN_STAT(net_write_bytes_stat, sval, cval);
int64 d_nwb = sval - last_nwb;
- last_nwb += d_nwb;
+ last_nwb += d_nwb;
int64 d_nw = cval - last_nw;
- last_nw += d_nw;
+ last_nw += d_nw;
- NET_READ_DYN_STAT(net_connections_currently_open_stat, sval, cval);
- int64 d_o = cval;
+ NET_READ_GLOBAL_DYN_SUM(net_connections_currently_open_stat, sval);
+ int64 d_o = sval;
- NET_READ_DYN_STAT(net_handler_run_stat, sval, cval);
+ NET_READ_DYN_STAT(net_handler_run_stat, sval, cval);
int64 d_p = cval - last_p;
- last_p += d_p;
- printf("%lld:%lld %lld:%lld %lld:%lld %lld:%lld %lld %lld\n",
- d_rb, d_r, d_wb, d_w, d_nrb, d_nr, d_nwb, d_nw, d_o, d_p);
+ last_p += d_p;
+ printf("%lld:%lld %lld:%lld %lld:%lld %lld:%lld %lld %lld\n",
+ d_rb, d_r, d_wb, d_w, d_nrb, d_nr, d_nwb, d_nw, d_o, d_p);
#ifdef ENABLE_TIME_TRACE
int i;
- fprintf(fp, "immediate_events_time_dist\n");
+ fprintf(fp, "immediate_events_time_dist\n");
for (i = 0; i < TIME_DIST_BUCKETS_SIZE; i++)
{
if ((i % 10) == 0)
@@ -1422,7 +1397,7 @@ run_AutoStop()
eventProcessor.schedule_in(NEW(new AutoStopCont), HRTIME_SECONDS(atoi(getenv("PROXY_AUTO_EXIT"))));
}
-#ifndef INK_NO_TESTS
+#if TS_HAS_TESTS
struct RegressionCont: public Continuation
{
int initialized;
@@ -1460,7 +1435,7 @@ run_RegressionTest()
if (regression_level)
eventProcessor.schedule_every(NEW(new RegressionCont), HRTIME_SECONDS(1));
}
-#endif //INK_NO_TESTS
+#endif //TS_HAS_TESTS
static void
@@ -1530,8 +1505,8 @@ adjust_num_of_net_threads(void)
TS_ReadConfigInteger(num_of_threads_tmp, "proxy.config.exec_thread.limit");
if (num_of_threads_tmp <= 0)
num_of_threads_tmp = 1;
- else if (num_of_threads_tmp > MAX_NUMBER_OF_THREADS)
- num_of_threads_tmp = MAX_NUMBER_OF_THREADS;
+ else if (num_of_threads_tmp > MAX_EVENT_THREADS)
+ num_of_threads_tmp = MAX_EVENT_THREADS;
num_of_net_threads = num_of_threads_tmp;
if (is_debug_tag_set("threads")) {
fprintf(stderr, "# net threads Auto config - disabled - use config file settings\n");
@@ -1543,8 +1518,8 @@ adjust_num_of_net_threads(void)
if (num_of_threads_tmp) {
num_of_net_threads = num_of_threads_tmp;
}
- if (unlikely(num_of_threads_tmp > MAX_NUMBER_OF_THREADS)) {
- num_of_threads_tmp = MAX_NUMBER_OF_THREADS;
+ if (unlikely(num_of_threads_tmp > MAX_EVENT_THREADS)) {
+ num_of_threads_tmp = MAX_EVENT_THREADS;
}
if (is_debug_tag_set("threads")) {
fprintf(stderr, "# net threads Auto config - enabled\n");
@@ -1682,7 +1657,6 @@ main(int argc, char **argv)
#if TS_HAS_PROFILER
ProfilerStart("/tmp/ts.prof");
#endif
- int mem_throttling;
NOWARN_UNUSED(argc);
@@ -1752,8 +1726,6 @@ main(int argc, char **argv)
init_core_size();
init_system();
- // Init memalign heaps
- init_ink_memalign_heap();
// Adjust system and process settings
adjust_sys_settings();
@@ -1761,8 +1733,8 @@ main(int argc, char **argv)
// Restart syslog now that we have configuration info
syslog_log_configure();
- if (!use_accept_thread)
- TS_ReadConfigInteger(use_accept_thread, "proxy.config.accept_threads");
+ if (!num_accept_threads)
+ TS_ReadConfigInteger(num_accept_threads, "proxy.config.accept_threads");
// This call is required for win_9xMe
//without this this_ethread() is failing when
@@ -1792,14 +1764,8 @@ main(int argc, char **argv)
// before calling RecProcessInit()
TS_ReadConfigInteger(history_info_enabled, "proxy.config.history_info_enabled");
- TS_ReadConfigInteger(mem_throttling, "proxy.config.resource.target_maxmem_mb");
TS_ReadConfigInteger(res_track_memory, "proxy.config.res_track_memory");
- if (!res_track_memory && mem_throttling > 0) {
- Warning("Cannot disable proxy.config.res_track_memory when " "proxy.config.resource.target_maxmem_mb is enabled");
- res_track_memory = 1;
- }
-
{
XMLDom schema;
bool xmlBandwidthSchemaRead(XMLNode * node);
@@ -1913,24 +1879,16 @@ main(int argc, char **argv)
_exit(1); // in error
}
} else {
-#ifndef RNI_ONLY
#ifndef INK_NO_ACL
initCacheControl();
#endif
initCongestionControl();
-
- //initMixtAPIInternal();
- // #ifndef INK_NO_ACL
- // initContentControl();
- // #endif
initIPAllow();
- initCacheInspectorAllow();
ParentConfig::startup();
-#ifndef INK_NO_HOSTDB
- // fixme
+#ifdef SPLIT_DNS
SplitDNSConfig::startup();
#endif
-#endif
+
if (!accept_mss)
TS_ReadConfigInteger(accept_mss, "proxy.config.net.sock_mss_in");
@@ -1959,7 +1917,7 @@ main(int argc, char **argv)
Log::init(remote_management_flag ? 0 : Log::NO_REMOTE_MANAGEMENT);
#endif
-#if !defined(RNI_ONLY) && !defined(INK_NO_API)
+#if !defined(TS_NO_API)
plugin_init(system_config_directory, true); // extensions.config
#endif
@@ -1974,14 +1932,6 @@ main(int argc, char **argv)
// Initialize Response Body Factory
body_factory = NEW(new HttpBodyFactory);
- // Initialize the system for RNI support
- // All this is handled by plugin support code
- //Rni::init ();
-#ifdef RNI_STATIC_LINK
- rniProcessor.start();
-#endif
-
-
// Start IP to userName cache processor used
// by RADIUS and FW1 plug-ins.
//ipToUserNameCacheProcessor.start();
@@ -2002,7 +1952,7 @@ main(int argc, char **argv)
// if in test hook mode, run the test hook //
/////////////////////////////////////////////
-#ifndef INK_NO_TESTS
+#if TS_HAS_TESTS
if (run_test_hook) {
Note("Running TestHook Instead of Main Server");
run_TestHook();
@@ -2013,8 +1963,7 @@ main(int argc, char **argv)
// main server logic initiated here //
//////////////////////////////////////
-#ifndef RNI_ONLY
-#ifndef INK_NO_API
+#ifndef TS_NO_API
plugin_init(system_config_directory, false); // plugin.config
#else
api_init(); // we still need to initialize some of the data structure other module needs.
@@ -2022,7 +1971,7 @@ main(int argc, char **argv)
init_inkapi_stat_system();
// i.e. http_global_hooks
#endif
-#ifndef INK_NO_TRANSFORM
+#ifndef TS_NO_TRANSFORM
transformProcessor.start();
#endif
@@ -2040,7 +1989,7 @@ main(int argc, char **argv)
TS_ReadConfigInteger(http_enabled, "proxy.config.http.enabled");
if (http_enabled) {
- start_HttpProxyServer(http_accept_file_descriptor, http_accept_port_number, ssl_accept_file_descriptor);
+ start_HttpProxyServer(http_accept_file_descriptor, http_accept_port_number, ssl_accept_file_descriptor, num_accept_threads);
int hashtable_enabled = 0;
TS_ReadConfigInteger(hashtable_enabled, "proxy.config.connection_collapsing.hashtable_enabled");
if (hashtable_enabled) {
@@ -2050,12 +1999,11 @@ main(int argc, char **argv)
#ifndef INK_NO_ICP
icpProcessor.start();
#endif
-#endif
int back_door_port = NO_FD;
TS_ReadConfigInteger(back_door_port, "proxy.config.process_manager.mgmt_port");
if (back_door_port != NO_FD)
- start_HttpProxyServerBackDoor(back_door_port);
+ start_HttpProxyServerBackDoor(back_door_port, num_accept_threads > 0 ? 1 : 0); // One accept thread is enough
#ifndef INK_NO_SOCKS
if (netProcessor.socks_conf_stuff->accept_enabled) {
@@ -2079,17 +2027,15 @@ main(int argc, char **argv)
Note("traffic server running");
-#ifndef INK_NO_TESTS
+#if TS_HAS_TESTS
TransformTest::run();
-#endif
-
#ifndef INK_NO_HOSTDB
run_HostDBTest();
#endif
// run_SimpleHttp();
-#ifndef INK_NO_TESTS
run_RegressionTest();
#endif
+
run_AutoStop();
}
@@ -2187,7 +2133,7 @@ xmlBandwidthSchemaRead(XMLNode * node)
}
-#ifndef INK_NO_TESTS
+#if TS_HAS_TESTS
//////////////////////////////
// Unit Regresion Test Hook //
//////////////////////////////
Modified: trafficserver/traffic/branches/wccp/proxy/Main.h
URL: http://svn.apache.org/viewvc/trafficserver/traffic/branches/wccp/proxy/Main.h?rev=1040383&r1=1040382&r2=1040383&view=diff
==============================================================================
--- trafficserver/traffic/branches/wccp/proxy/Main.h (original)
+++ trafficserver/traffic/branches/wccp/proxy/Main.h Tue Nov 30 01:42:55 2010
@@ -56,7 +56,6 @@
// Global Data
//
// Global Configuration
-extern int use_accept_thread;
extern int accept_till_done;
//extern int ssl_accept_port_number;
//extern int ssl_enabled;
@@ -123,6 +122,7 @@ extern AppVersionInfo appVersionInfo;
struct HttpOtherPortEntry
{
int port;
+ int domain;
HttpPortTypes type;
/// Set if outbound connections (to origin servers) are transparent.
bool f_outbound_transparent;
Modified: trafficserver/traffic/branches/wccp/proxy/Makefile.am
URL: http://svn.apache.org/viewvc/trafficserver/traffic/branches/wccp/proxy/Makefile.am?rev=1040383&r1=1040382&r2=1040383&view=diff
==============================================================================
--- trafficserver/traffic/branches/wccp/proxy/Makefile.am (original)
+++ trafficserver/traffic/branches/wccp/proxy/Makefile.am Tue Nov 30 01:42:55 2010
@@ -29,8 +29,6 @@ bin_PROGRAMS = \
traffic_logcat \
traffic_logstats \
traffic_sac
-
-noinst_PROGRAMS = traffic_cust_log_fmt_cnvrt
endif
AM_CPPFLAGS = \
@@ -51,9 +49,7 @@ includedir=$(prefix)/include/ts
include_HEADERS = \
api/ts/ts.h \
api/ts/remap.h \
- api/ts/experimental.h \
- api/ts/ts_private.h \
- api/ts/ts_private_frozen.h
+ api/ts/experimental.h
noinst_HEADERS = \
api/ts/InkAPIHughes.h \
@@ -78,8 +74,6 @@ traffic_server_SOURCES = \
AbstractBuffer.h \
CacheControl.cc \
CacheControl.h \
- CacheInspectorAllow.cc \
- CacheInspectorAllow.h \
ProxyConfig.cc \
ProxyConfig.h \
ControlBase.cc \
@@ -106,7 +100,6 @@ traffic_server_SOURCES = \
InkAPI.cc \
FetchSM.cc \
InkAPIInternal.h \
- InkAPITest.cc \
InkIOCoreAPI.cc \
InkXml.cc \
InkXml.h \
@@ -125,8 +118,6 @@ traffic_server_SOURCES = \
Prefetch.cc \
Prefetch.h \
Raf.h \
- RegressionSM.h \
- RegressionSM.cc \
ReverseProxy.cc \
ReverseProxy.h \
RniTransStats.h \
@@ -138,7 +129,6 @@ traffic_server_SOURCES = \
StatSystem.cc \
StatSystem.h \
StatAPITypes.cc \
- TestHook.cc \
Transform.cc \
Transform.h \
TransformInternal.h \
@@ -149,6 +139,12 @@ if BUILD_V2STATS
traffic_server_SOURCES += StatSystemV2.cc
endif
+if BUILD_TESTS
+ traffic_server_SOURCES += InkAPITest.cc \
+ RegressionSM.h \
+ RegressionSM.cc \
+ TestHook.cc
+endif
traffic_server_LDFLAGS = @EXTRA_CXX_LDFLAGS@
traffic_server_LDADD = \
@@ -192,7 +188,6 @@ traffic_logcat_LDADD = \
ControlMatcher.o CacheControl.o \
StatSystem.o \
StatAPITypes.o \
- CacheInspectorAllow.o \
ReverseProxy.o \
ProxyConfig.o \
signals.o \
@@ -205,8 +200,6 @@ traffic_logcat_LDADD = \
Transform.o \
Prefetch.o \
Update.o \
- TestHook.o \
- RegressionSM.o \
Plugin.o \
PluginDB.o \
InkAPI.o \
@@ -244,6 +237,11 @@ if BUILD_V2STATS
traffic_logcat_LDADD += StatSystemV2.o
endif
+if BUILD_TESTS
+ traffic_logcat_LDADD += RegressionSM.o \
+ TestHook.o
+endif
+
traffic_logstats_SOURCES = logstats.cc
traffic_logstats_LDFLAGS = @EXTRA_CXX_LDFLAGS@
traffic_logstats_LDADD = \
@@ -258,7 +256,6 @@ traffic_logstats_LDADD = \
CacheControl.o \
StatSystem.o \
StatAPITypes.o \
- CacheInspectorAllow.o \
ReverseProxy.o \
ProxyConfig.o \
signals.o \
@@ -271,8 +268,6 @@ traffic_logstats_LDADD = \
Transform.o \
Prefetch.o \
Update.o \
- TestHook.o \
- RegressionSM.o \
Plugin.o \
PluginDB.o \
InkAPI.o \
@@ -311,6 +306,11 @@ if BUILD_V2STATS
traffic_logstats_LDADD += StatSystemV2.o
endif
+if BUILD_TESTS
+ traffic_logstats_LDADD += RegressionSM.o \
+ TestHook.o
+endif
+
traffic_sac_SOURCES = sac.cc
traffic_sac_LDFLAGS = @EXTRA_CXX_LDFLAGS@
traffic_sac_LDADD = \
@@ -325,7 +325,6 @@ traffic_sac_LDADD = \
CacheControl.o \
StatSystem.o \
StatAPITypes.o \
- CacheInspectorAllow.o \
ReverseProxy.o \
ProxyConfig.o \
signals.o \
@@ -338,8 +337,6 @@ traffic_sac_LDADD = \
Transform.o \
Prefetch.o \
Update.o \
- TestHook.o \
- RegressionSM.o \
Plugin.o \
PluginDB.o \
InkAPI.o \
@@ -376,12 +373,10 @@ if BUILD_V2STATS
traffic_sac_LDADD += StatSystemV2.o
endif
-traffic_cust_log_fmt_cnvrt_SOURCES = cust_log_fmt_cnvrt.cc
-traffic_cust_log_fmt_cnvrt_LDADD = \
- $(top_builddir)/iocore/utils/libinkutils.a \
- $(top_builddir)/libinktomi++/libinktomi++.a \
- @LIBTHREAD@ \
- @LIBTCL@ @LIBRT@ @LIBICONV@ @LIBDL@ @LIBEXECINFO@
+if BUILD_TESTS
+ traffic_sac_LDADD += RegressionSM.o \
+ TestHook.o
+endif
libClusterHashStandalone_a_SOURCES = \
ClusterHashStandalone.cc \
Modified: trafficserver/traffic/branches/wccp/proxy/Plugin.cc
URL: http://svn.apache.org/viewvc/trafficserver/traffic/branches/wccp/proxy/Plugin.cc?rev=1040383&r1=1040382&r2=1040383&view=diff
==============================================================================
--- trafficserver/traffic/branches/wccp/proxy/Plugin.cc (original)
+++ trafficserver/traffic/branches/wccp/proxy/Plugin.cc Tue Nov 30 01:42:55 2010
@@ -56,7 +56,7 @@ typedef void (*init_func_t) (int argc, c
typedef void (*init_func_w_handle_t) (void *handle, int argc, char *argv[]);
typedef int (*lic_req_func_t) (void);
-inkapi int
+tsapi int
load_in_export_symbols(int j)
{
int i = eight_bit_table[j];
@@ -142,7 +142,7 @@ plugin_load(int argc, char *argv[], bool
abort();
}
- lic_req = (lic_req_func_t) dll_findsym(handle, "INKPluginLicenseRequired");
+ lic_req = (lic_req_func_t) dll_findsym(handle, "TSPluginLicenseRequired");
if (lic_req && lic_req() != 0) {
PluginDB::CheckLicenseResult result = plugin_db->CheckLicense(argv[0]);
if (result != PluginDB::license_ok) {
@@ -157,15 +157,15 @@ plugin_load(int argc, char *argv[], bool
plugin_reg_current = new PluginRegInfo;
plugin_reg_current->plugin_path = xstrdup(path);
- init_func_w_handle_t inith = (init_func_w_handle_t) dll_findsym(handle, "INKPluginInitwDLLHandle");
+ init_func_w_handle_t inith = (init_func_w_handle_t) dll_findsym(handle, "TSPluginInitwDLLHandle");
if (inith) {
inith(handle, argc, argv);
return;
}
- init = (init_func_t) dll_findsym(handle, "INKPluginInit");
+ init = (init_func_t) dll_findsym(handle, "TSPluginInit");
if (!init) {
- Error("unable to find INKPluginInit function '%s': %s", path, dll_error(handle));
+ Error("unable to find TSPluginInit function '%s': %s", path, dll_error(handle));
dll_close(handle);
abort();
}
Modified: trafficserver/traffic/branches/wccp/proxy/PluginVC.cc
URL: http://svn.apache.org/viewvc/trafficserver/traffic/branches/wccp/proxy/PluginVC.cc?rev=1040383&r1=1040382&r2=1040383&view=diff
==============================================================================
--- trafficserver/traffic/branches/wccp/proxy/PluginVC.cc (original)
+++ trafficserver/traffic/branches/wccp/proxy/PluginVC.cc Tue Nov 30 01:42:55 2010
@@ -1126,15 +1126,15 @@ PluginVCCore::kill_no_connect()
void
PluginVCCore::set_passive_addr(uint32 ip, int port)
{
- passive_addr_struct.sin_addr.s_addr = htonl(ip);
- passive_addr_struct.sin_port = htons(port);
+ ((struct sockaddr_in *)&(passive_addr_struct))->sin_addr.s_addr = htonl(ip);
+ ((struct sockaddr_in *)&(passive_addr_struct))->sin_port = htons(port);
}
void
PluginVCCore::set_active_addr(uint32 ip, int port)
{
- active_addr_struct.sin_addr.s_addr = htonl(ip);
- active_addr_struct.sin_port = htons(port);
+ ((struct sockaddr_in *)&(active_addr_struct))->sin_addr.s_addr = htonl(ip);
+ ((struct sockaddr_in *)&(active_addr_struct))->sin_port = htons(port);
}
void
@@ -1155,7 +1155,7 @@ PluginVCCore::set_active_data(void *data
*
**************************************************************/
-
+#if TS_HAS_TESTS
class PVCTestDriver:public NetTestDriver
{
public:
@@ -1248,3 +1248,4 @@ EXCLUSIVE_REGRESSION_TEST(PVC) (Regressi
PVCTestDriver *driver = NEW(new PVCTestDriver);
driver->start_tests(t, pstatus);
}
+#endif
Modified: trafficserver/traffic/branches/wccp/proxy/PluginVC.h
URL: http://svn.apache.org/viewvc/trafficserver/traffic/branches/wccp/proxy/PluginVC.h?rev=1040383&r1=1040382&r2=1040383&view=diff
==============================================================================
--- trafficserver/traffic/branches/wccp/proxy/PluginVC.h (original)
+++ trafficserver/traffic/branches/wccp/proxy/PluginVC.h Tue Nov 30 01:42:55 2010
@@ -200,8 +200,8 @@ private:
MIOBuffer *a_to_p_buffer;
IOBufferReader *a_to_p_reader;
- struct sockaddr_in passive_addr_struct;
- struct sockaddr_in active_addr_struct;
+ struct sockaddr_storage passive_addr_struct;
+ struct sockaddr_storage active_addr_struct;
void *passive_data;
void *active_data;
@@ -224,8 +224,8 @@ passive_data(NULL),
active_data(NULL),
id(0)
{
- memset(&active_addr_struct, 0, sizeof(struct sockaddr_in));
- memset(&passive_addr_struct, 0, sizeof(struct sockaddr_in));
+ memset(&active_addr_struct, 0, sizeof(struct sockaddr_storage));
+ memset(&passive_addr_struct, 0, sizeof(struct sockaddr_storage));
id = ink_atomic_increment(&nextid, 1);
}