/*****************************************************************************
* Periodic handler to send RPC messages.
*****************************************************************************/
static int
periodic_event(INKCont contp, INKEvent event, void *e)
{
/*************************************************************************
* Note: Event subsystem always calls us with 'node_status_mutex' held.
*************************************************************************/
int n, size, ret;
INKClusterRPCMsg_t *rmsg;
hello_msg_t hello_msg;
struct in_addr in;
if (clusterRPC_plugin_shutdown) {
shutdown();
INKContDestroy(contp);
return 0;
}
/*************************************************************************
* Send a hello message to all online nodes.
*************************************************************************/
for (n = 1; n <= MAX_CLUSTER_NODES; ++n) {
if (nodes[n]) {
INKNodeHandleToIPAddr(&nodes[n], &in);
hello_msg.hm_version = HELLO_MSG_VERSION;
hello_msg.hm_source_handle = my_node_handle;
hello_msg.hm_dest_handle = nodes[n];
hello_msg.hm_instance = msg_instance++;
size = random() % (1 * 1024 * 1024);
if (size < sizeof(hello_msg_t)) {
size = sizeof(hello_msg_t);
}
rmsg = INKAllocClusterRPCMsg(&rpc_wireless_f10_handle, size);
hello_msg.hm_data_size = size;
/******************************************************************
* Marshal data into message.
*****************************************************************/
memcpy(rmsg->m_data, (char *) &hello_msg, sizeof(hello_msg));
fill_data(rmsg->m_data +
sizeof(hello_msg) - sizeof(hello_msg.hm_data_size),
size - sizeof(hello_msg) + sizeof(hello_msg.hm_data));
INKDebug(PLUGIN_DEBUG_TAG,
"Sending hello to [%u.%u.%u.%u] instance %d bytes %d\n",
DOT_SEPARATED(in.s_addr), hello_msg.hm_instance, size);
ret = INKSendClusterRPC(&nodes[n], rmsg);
if (ret) {
INKDebug(PLUGIN_DEBUG_ERR_TAG, "INKSendClusterRPC failed\n");
}
}
}
periodic_event_action = INKContSchedule(periodic_event_cont, (1 * 1000) /* 1 sec */ );
return 0;
}
static void
clusterRPC_init()
{
int ret;
/***********************************************************************
* Create plugin mutex
***********************************************************************/
node_status_mutex = INKMutexCreate();
if (!node_status_mutex) {
INKDebug(PLUGIN_DEBUG_ERR_TAG, "INKMutexCreate for node_status failed\n");
return;
}
if (!INKMutexTryLock(node_status_mutex)) {
/* Should never fail */
INKDebug(PLUGIN_DEBUG_ERR_TAG, "INKMutexTryLock failed\n");
}
/***********************************************************************
* Register our RPC handler.
***********************************************************************/
ret = INKAddClusterRPCFunction(RPC_API_WIRELESS_F10, rpc_wireless_f10_func, &rpc_wireless_f10_handle);
if (ret) {
INKDebug(PLUGIN_DEBUG_ERR_TAG, "INKAddClusterRPCFunction failed\n");
return;
}
/***********************************************************************
* Subscribe to cluster node status callouts.
***********************************************************************/
ret = INKAddClusterStatusFunction(status_callout, node_status_mutex, &status_callout_handle);
if (ret) {
INKDebug(PLUGIN_DEBUG_ERR_TAG, "INKAddClusterStatusFunction failed\n");
return;
}
/***********************************************************************
* Perform node status initializations.
***********************************************************************/
INKGetMyNodeHandle(&my_node_handle);
/***********************************************************************
* Enable cluster node status callouts.
***********************************************************************/
INKEnableClusterStatusCallout(&status_callout_handle);
/***********************************************************************
* Establish the periodic event.
***********************************************************************/
periodic_event_cont = INKContCreate(periodic_event, node_status_mutex);
if (!periodic_event_cont) {
INKDebug(PLUGIN_DEBUG_ERR_TAG, "INKContCreate for periodic_event failed\n");
return;
}
periodic_event_action = INKContSchedule(periodic_event_cont, (1 * 1000) /* 1 sec */ );
INKMutexUnlock(node_status_mutex);
}
static int
event_mux(INKCont contp, INKEvent event, void *edata)
{
INKHttpTxn txnp = (INKHttpTxn) edata;
INKCont newcont;
char *client_req;
char *url_line;
int ret_status;
int neg_test_val;
int pin_val;
LOG_SET_FUNCTION_NAME("event_mux");
switch (event) {
case INK_EVENT_HTTP_SEND_RESPONSE_HDR:
if ((newcont = INKContCreate(handle_cache_events, INKMutexCreate())) == INK_ERROR_PTR) {
LOG_ERROR_AND_REENABLE("INKContCreate");
return 0;
}
/* FC When called back for txn close, the plugins test if the value of the
continuation data ptr is null or not. Initialize it here to null. */
INKContDataSet(newcont, NULL);
if (INKHttpTxnHookAdd(edata, INK_HTTP_TXN_CLOSE_HOOK, newcont) == INK_ERROR) {
LOG_ERROR_AND_REENABLE("INKHttpTxnHookAdd");
return 0;
}
ret_status = get_client_req(txnp, &url_line, &client_req, &neg_test_val, &pin_val);
/* FC: added test on url and client req too */
if ((ret_status == -1) || (url_line == NULL) || (client_req == NULL)) {
INKDebug(DEBUG_TAG, "Unable to get client request header\n");
INKHttpTxnReenable(txnp, INK_EVENT_HTTP_CONTINUE);
return 0;
}
INKDebug(DEBUG_TAG, "\n%s\n%s", url_line, client_req);
INKfree(client_req);
cache_exercise(txnp, url_line, pin_val, neg_test_val, newcont);
break;
default:
;
}
return 0;
}
static int
check_data(char *p, int size)
{
int n;
char val = p[0];
for (n = 0; n < size; ++n, ++val) {
if (p[n] != val) {
INKDebug(PLUGIN_DEBUG_ERR_TAG, "check_data fail actual %d expected %d n %d data 0x%x\n", p[n], val, n, &p[n]);
return 1;
}
}
return 0;
}
void
INKPluginInit(int argc, const char *argv[])
{
LOG_SET_FUNCTION_NAME("INKPluginInit");
INKCont contp;
INKDebug(DEBUG_TAG, "INKPluginInit");
if ((contp = INKContCreate(event_mux, NULL)) == INK_ERROR_PTR) {
LOG_ERROR("INKContCreate");
} else if (INKHttpHookAdd(INK_HTTP_SEND_RESPONSE_HDR_HOOK, contp) == INK_ERROR) {
LOG_ERROR("INKHttpHookAdd");
}
}
void
INKPluginInit(int argc, const char *argv[])
{
INKCont contp, contp2;
int timeOut = 10;
INKDebug("tag_sched6643", "INKContSchedule: Initial data value for contp is %d\n", timeOut);
/* contp = INKContCreate(EventHandler, INKMutexCreate() ); */
contp = INKContCreate(EventHandler, NULL);
INKContDataSet(contp, (void *) timeOut);
INKHttpHookAdd(INK_HTTP_OS_DNS_HOOK, contp);
}
/* Verification code for: INKqa06643 */
static int
EventHandler(INKCont contp, INKEvent event, void *eData)
{
INKHttpTxn txn = (INKHttpTxn) eData;
int iVal;
time_t tVal;
if (time(&tVal) != (time_t) (-1)) {
INKDebug("tag_sched6643", "INKContSchedule: EventHandler: called at %s\n", ctime(&tVal));
}
iVal = (int) INKContDataGet(contp);
INKDebug("tag_sched6643", "INKContSchedule: handler called with value %d\n", iVal);
switch (event) {
case INK_EVENT_HTTP_OS_DNS:
INKDebug("tag_sched6643", "INKContSchedule: Seed event %s\n", "INK_EVENT_HTTP_OS_DNS");
break;
case INK_EVENT_TIMEOUT:
INKDebug("tag_sched6643", "INKContSchedule: TIMEOUT event\n");
break;
default:
INKDebug("tag_sched6643", "INKContSchedule: Error: default event\n");
break;
}
iVal += 100; /* seed + timeout val */
INKContDataSet(contp, (void *) iVal);
INKContSchedule(contp, iVal);
/* INKHttpTxnReenable(txn, INK_EVENT_HTTP_CONTINUE); */
}
/*****************************************************************************
* RPC Handler for key RPC_API_WIRELESS_F10.
*****************************************************************************/
static void
rpc_wireless_f10_func(INKNodeHandle_t * nh, INKClusterRPCMsg_t * msg, int msg_data_len)
{
hello_msg_t hello_msg;
struct in_addr in;
if (msg_data_len >= sizeof(hello_msg_t)) {
/*********************************************************************
* Unmarshal data.
*********************************************************************/
memcpy((char *) &hello_msg, msg->m_data, sizeof(hello_msg));
/*********************************************************************
* Message consistency checks.
*********************************************************************/
INKNodeHandleToIPAddr(&hello_msg.hm_source_handle, &in);
if (hello_msg.hm_version != HELLO_MSG_VERSION) {
INKDebug(PLUGIN_DEBUG_ERR_TAG,
"rpc_wireless_f10_func() vers, actual %d expected %d \n", hello_msg.hm_version, HELLO_MSG_VERSION);
return;
}
if (hello_msg.hm_source_handle != *nh) {
INKDebug(PLUGIN_DEBUG_ERR_TAG,
"rpc_wireless_f10_func() src, actual %d expected %d \n", hello_msg.hm_source_handle, *nh);
return;
}
if (hello_msg.hm_data_size != msg_data_len) {
INKDebug(PLUGIN_DEBUG_ERR_TAG,
"rpc_wireless_f10_func() len, actual %d expected %d \n", msg_data_len, hello_msg.hm_data_size);
return;
}
if (check_data(msg->m_data +
sizeof(hello_msg) - sizeof(hello_msg.hm_data_size),
msg_data_len - sizeof(hello_msg) + sizeof(hello_msg.hm_data))) {
INKDebug(PLUGIN_DEBUG_ERR_TAG,
"rpc_wireless_f10_func() data check failed, "
"[%u.%u.%u.%u] len %d data 0x%x\n", DOT_SEPARATED(in.s_addr), msg_data_len, msg->m_data);
}
log_msg(&hello_msg, msg_data_len);
INKFreeRPCMsg(msg, msg_data_len);
INKDebug(PLUGIN_DEBUG_TAG,
"Received hello from [%u.%u.%u.%u] instance %d\n", DOT_SEPARATED(in.s_addr), hello_msg.hm_instance);
} else {
INKFreeRPCMsg(msg, msg_data_len);
INKDebug(PLUGIN_DEBUG_ERR_TAG,
"rpc_wireless_f10_func() msglen, actual %d expect >= %d \n", msg_data_len, sizeof(hello_msg_t));
}
}
void
log_msg(hello_msg_t * h, int msg_data_len)
{
int n;
int n_free = -1;
struct in_addr in;
for (n = 0; n < MAX_CLUSTER_NODES; ++n) {
if (log[n].ml_nh == h->hm_source_handle) {
log[n].ml_msgs_received++;
log[n].ml_bytes_received += msg_data_len;
break;
} else if ((n_free < 0) && !log[n].ml_nh) {
n_free = n;
}
}
if (n >= MAX_CLUSTER_NODES) {
log[n_free].ml_nh = h->hm_source_handle;
log[n_free].ml_msgs_received++;
log[n_free].ml_bytes_received += msg_data_len;
}
total_msgs_received++;
if (total_msgs_received % 10) {
return;
}
for (n = 0; n < MAX_CLUSTER_NODES; ++n) {
if (log[n].ml_nh && (log[n].ml_msgs_received != log[n].ml_last_msgs_received)) {
log[n].ml_last_msgs_received = log[n].ml_msgs_received;
INKNodeHandleToIPAddr(&log[n].ml_nh, &in);
INKDebug(PLUGIN_DEBUG_ERR_TAG,
"[%u.%u.%u.%u] msgs rcvd: %d total bytes rcvd: %d\n",
DOT_SEPARATED(in.s_addr), log[n].ml_msgs_received, log[n].ml_bytes_received);
}
}
}
/*****************************************************************************
* Handler for node status callouts.
*****************************************************************************/
static void
status_callout(INKNodeHandle_t * nhp, INKNodeStatus_t status)
{
/*************************************************************************
* Note: Cluster always calls us with 'node_status_mutex' held.
*************************************************************************/
int found, n;
INKNodeHandle_t nh = *nhp;
struct in_addr in;
INKNodeHandleToIPAddr(&nh, &in);
found = find_node_entry(nh);
if (status == NODE_ONLINE) {
if (!found) {
n = find_free_node_entry();
if (n > 0) {
nodes[n] = nh;
online_nodes++;
INKDebug(PLUGIN_DEBUG_TAG, "Node [%u.%u.%u.%u] online, nodes=%d\n", DOT_SEPARATED(in.s_addr), online_nodes);
} else {
/* Should never happen */
INKDebug(PLUGIN_DEBUG_ERR_TAG, "clusterRPC plugin: No free entries.\n");
INKDebug(PLUGIN_DEBUG_TAG,
"Node [%u.%u.%u.%u] online observed, nodes=%d\n", DOT_SEPARATED(in.s_addr), online_nodes);
}
} else {
INKDebug(PLUGIN_DEBUG_TAG,
"Duplicate node [%u.%u.%u.%u] online, nodes=%d\n", DOT_SEPARATED(in.s_addr), online_nodes);
}
} else {
if (found) {
nodes[found] = 0;
online_nodes--;
INKDebug(PLUGIN_DEBUG_TAG, "Node [%u.%u.%u.%u] offline, nodes=%d\n", DOT_SEPARATED(in.s_addr), online_nodes);
} else {
INKDebug(PLUGIN_DEBUG_TAG,
"Unexpected node [%u.%u.%u.%u] offline, nodes=%d\n", DOT_SEPARATED(in.s_addr), online_nodes);
}
}
}
static void
handle_dns(INKHttpTxn txnp, INKCont contp)
{
INKMBuffer bufp;
INKMLoc hdr_loc;
INKIOBuffer output_buffer;
INKIOBufferReader reader;
int total_avail;
INKIOBufferBlock block;
const char *block_start;
int block_avail;
char *output_string;
int output_len;
if (!INKHttpTxnClientReqGet(txnp, &bufp, &hdr_loc)) {
INKDebug(DEBUG_TAG, "couldn't retrieve client request header");
INKError("couldn't retrieve client request header\n");
goto done;
}
output_buffer = INKIOBufferCreate();
/* INKIOBufferCreate may return an error pointer */
if ((void *) output_buffer == INK_ERROR_PTR) {
INKDebug(DEBUG_TAG, "couldn't allocate IOBuffer");
INKError("couldn't allocate IOBuffer\n");
goto done;
}
reader = INKIOBufferReaderAlloc(output_buffer);
/* INKIOBufferReaderAlloc may return an error pointer */
if ((void *) reader == INK_ERROR_PTR) {
INKDebug(DEBUG_TAG, "couldn't allocate IOBufferReader");
INKError("couldn't allocate IOBufferReader\n");
goto done;
}
/* This will print just MIMEFields and not
the http request line */
INKDebug(DEBUG_TAG, "Printing the hdrs ... ");
if (INKMimeHdrPrint(bufp, hdr_loc, output_buffer) == INK_ERROR) {
INKDebug(DEBUG_TAG, "non-fatal: error printing mime-hdrs");
INKError("non-fatal: error printing mime-hdrs\n");
}
if (INKHandleMLocRelease(bufp, INK_NULL_MLOC, hdr_loc) == INK_ERROR) {
INKDebug(DEBUG_TAG, "non-fatal: error releasing MLoc");
INKError("non-fatal: error releasing MLoc\n");
}
/* Find out how the big the complete header is by
seeing the total bytes in the buffer. We need to
look at the buffer rather than the first block to
see the size of the entire header */
total_avail = INKIOBufferReaderAvail(reader);
/* INKIOBufferReaderAvail may send an INK_ERROR */
if ((INKReturnCode) total_avail == INK_ERROR) {
INKDebug(DEBUG_TAG, "couldn't get available byte-count from IO-read-buffer");
INKError("couldn't get available byte-count from IO-read-buffer\n");
goto done;
}
/* Allocate the string with an extra byte for the string
terminator */
output_string = (char *) INKmalloc(total_avail + 1);
output_len = 0;
/* We need to loop over all the buffer blocks to make
sure we get the complete header since the header can
be in multiple blocks */
block = INKIOBufferReaderStart(reader);
/* INKIOBufferReaderStart may return an error pointer */
if (block == INK_ERROR_PTR) {
INKDebug(DEBUG_TAG, "couldn't get from IOBufferBlock");
INKError("couldn't get from IOBufferBlock\n");
goto done;
}
while (block) {
block_start = INKIOBufferBlockReadStart(block, reader, &block_avail);
/* INKIOBufferBlockReadStart may return an error pointer */
if (block_start == INK_ERROR_PTR) {
INKDebug(DEBUG_TAG, "couldn't read from IOBuffer");
INKError("couldn't read from IOBuffer\n");
goto done;
}
/* We'll get a block pointer back even if there is no data
left to read so check for this condition and break out of
the loop. A block with no data to read means we've exhausted
buffer of data since if there was more data on a later
block in the chain, this block would have been skipped over */
if (block_avail == 0) {
break;
}
memcpy(output_string + output_len, block_start, block_avail);
output_len += block_avail;
/* Consume the data so that we get to the next block */
if (INKIOBufferReaderConsume(reader, block_avail) == INK_ERROR) {
INKDebug(DEBUG_TAG, "error consuming data from the ReaderBlock");
INKError("error consuming data from the ReaderBlock\n");
}
/* Get the next block now that we've consumed the
data off the last block */
block = INKIOBufferReaderStart(reader);
/* INKIOBufferReaderStart may return an error pointer */
if (block == INK_ERROR_PTR) {
INKDebug(DEBUG_TAG, "couldn't get from IOBufferBlock");
INKError("couldn't get from IOBufferBlock\n");
goto done;
}
}
/* Terminate the string */
output_string[output_len] = '\0';
output_len++;
/* Free up the INKIOBuffer that we used to print out the header */
if (INKIOBufferReaderFree(reader) != INK_SUCCESS) {
INKDebug(DEBUG_TAG, "non-fatal: error releasing IOBufferReader");
INKError("non-fatal: error releasing IOBufferReader\n");
}
if (INKIOBufferDestroy(output_buffer) != INK_SUCCESS) {
INKDebug(DEBUG_TAG, "non-fatal: error destroying IOBuffer");
INKError("non-fatal: error destroying IOBuffer\n");
}
/* Although I'd never do this a production plugin, printf
the header so that we can see it's all there */
INKDebug("debug-output-header", "%s", output_string);
INKfree(output_string);
done:
INKHttpTxnReenable(txnp, INK_EVENT_HTTP_CONTINUE);
}
static void
handleSendResponse(INKCont pCont, INKHttpTxn pTxn)
{
LOG_SET_FUNCTION_NAME("handleSendResponse");
INKMBuffer respHdrBuf = NULL, newHttpHdrBuf = NULL, parseBuffer = NULL;
INKMLoc respHttpHdrLoc = NULL, newHttpHdrLoc = NULL, parseHttpHdrLoc = NULL;
INKHttpStatus oldHttpStatus, tmpHttpStatus;
INKHttpType httpType;
INKHttpParser httpRespParser = NULL;
HdrInfo_T *pRespHdrInfo = NULL, *pNewRespHdrInfo = NULL;
int iHttpHdrReasonLength, iOldHttpVersion, iTmpHttpVersion, iTmpHttpHdrReasonLength;
const char *sHttpHdrReason = NULL, *sTmpHttpHdrReason = NULL, *pHttpParseStart = NULL, *pHttpParseEnd = NULL;
char *sOldHttpReason = NULL;
const char *sRespHdrStr1 =
"HTTP/1.1 200 OK\r\nServer: Netscape-Enterprise/4.1\r\nDate: Tue, 31 Oct 2000 03:38:19 GMT\r\nContent-type: text/html\r\nAge: 3476\r\nContent-Length: 12440\r\nVia: HTTP/1.1 ts-sun14 (Traffic-Server/4.0.0 [cHs f ])\r\n\r\n";
const char *sRespHdrStr2 =
"HTTP/1.1 404 Not Found \r\nServer: Netscape-Enterprise/4.1\r\nDate: Tue, 31 Oct 2000 03:38:19 GMT\r\nContent-type: text/html\r\nAge: 3476\r\nContent-Length: 12440\r\nVia: HTTP/1.1 ts-sun24 (Traffic-Server/4.0.0 [cHs f ])\r\n\r\n";
const char *sRespHdrStr3 =
"HTTP/1.1 505 HTTP Version Not Supported \r\nServer: Netscape-Enterprise/4.1\r\nDate: Tue, 31 Oct 2000 03:38:19 GMT\r\nContent-type: text/html\r\nAge: 3476\r\nContent-Length: 12440\r\nVia: HTTP/1.1 ts-sun34 (Traffic-Server/4.0.0 [cHs f ])\r\n\r\n";
pRespHdrInfo = initHdr();
pNewRespHdrInfo = initHdr();
INKDebug(RESP, ">>> handleSendResponse <<<<\n");
/* Get Response Marshall Buffer */
if (!INKHttpTxnClientRespGet(pTxn, &respHdrBuf, &respHttpHdrLoc)) {
LOG_API_ERROR_COMMENT("INKHttpTxnClientReqGet", "ERROR: Can't retrieve client req hdr");
goto done;
}
#ifdef DEBUG
negTesting(respHdrBuf, respHttpHdrLoc);
#endif
/******* (1): Exercise all possible INK*GET and print the values **********/
INKDebug(RESP, "--------------------------------");
getHdrInfo(pRespHdrInfo, respHdrBuf, respHttpHdrLoc);
printHttpHeader(respHdrBuf, respHttpHdrLoc, RESP, 1);
/******* (2): Create a new header and check everything is copied correctly *********/
INKDebug(RESP, "--------------------------------");
if ((newHttpHdrBuf = INKMBufferCreate()) == INK_ERROR_PTR) {
LOG_API_ERROR_COMMENT("INKMBufferCreate", "skipping to section(4)");
goto resp_4;
}
/*** INKHttpHdrCreate ***/
if ((newHttpHdrLoc = INKHttpHdrCreate(newHttpHdrBuf)) == INK_ERROR_PTR) {
LOG_API_ERROR_COMMENT("INKMHTTPHdrCreate", "skipping to section(4)");
goto resp_4;
}
/* Make sure the newly created HTTP header has INKHttpType value of INK_HTTP_TYPE_UNKNOWN */
if ((httpType = INKHttpHdrTypeGet(newHttpHdrBuf, newHttpHdrLoc)) == INK_ERROR) {
LOG_API_ERROR_COMMENT("INKMHTTPHdrCreate", "continuing");
} else if (httpType != INK_HTTP_TYPE_UNKNOWN) {
LOG_AUTO_ERROR("INKHttpHdrCreate", "Newly created hdr not of type INK_HTTP_TYPE_UNKNOWN");
}
/*** INKHttpHdrCopy ***/
if (INKHttpHdrCopy(newHttpHdrBuf, newHttpHdrLoc, respHdrBuf, respHttpHdrLoc) == INK_ERROR) {
LOG_API_ERROR("INKHttpHdrCopy");
}
getHdrInfo(pNewRespHdrInfo, newHttpHdrBuf, newHttpHdrLoc);
printHttpHeader(newHttpHdrBuf, newHttpHdrLoc, RESP, 2);
if (!identical_hdr(pRespHdrInfo, pNewRespHdrInfo)) {
LOG_AUTO_ERROR("INKHttpHdrCopy", "copy of the resp header not identical to the original");
}
/* Reuse:
* newHttpHdrBuf, newHttHdrLoc */
/******* (3): Now excercise some INK..SETs on the new header ********/
INKDebug(RESP, "--------------------------------");
/*** INKHttpHdrTypeSet ***/
/* ERROR:
* 1. Setting type other than INK_HTTP_TYPE_UNKNOWN, INK_HTTP_TYPE_REQUEST,
* INK_HTTP_TYPE_RESPONSE, and,
* 2. Setting the type twice. The hdr type has been already set during INKHttpHdrCopy
* above, so setting it again is incorrect */
if (INKHttpHdrTypeSet(newHttpHdrBuf, newHttpHdrLoc, INK_HTTP_TYPE_RESPONSE) == INK_ERROR) {
LOG_API_ERROR("INKHttpHdrTypeSet");
}
/*** INKHttpHdrReasonSet ***/
/* save the original reason */
if ((sHttpHdrReason = INKHttpHdrReasonGet(newHttpHdrBuf, newHttpHdrLoc, &iHttpHdrReasonLength))
== INK_ERROR_PTR) {
LOG_API_ERROR("INKHttpHdrReasonGet");
} else {
sOldHttpReason = INKstrndup(sHttpHdrReason, iHttpHdrReasonLength);
}
/* Note:
* INKHttpHdrReasonGet may return a NULL reason string (for e.g. I tried www.eyesong.8m.com).
* Do NOT assume that INKstrndup always returns a null terminated string. INKstrndup does
* not returns a NULL terminated string for a NULL ptr as i/p parameter. It simply returns
* it backs. So functions like strlen() on the return value might cause TS to crash */
if (INKHttpHdrReasonSet(newHttpHdrBuf, newHttpHdrLoc, "dummy reason", strlen("dummy reason")) == INK_ERROR) {
LOG_API_ERROR("INKHttpHdrReasonGet");
} else {
if ((sTmpHttpHdrReason = INKHttpHdrReasonGet(newHttpHdrBuf, newHttpHdrLoc, &iTmpHttpHdrReasonLength))
== INK_ERROR_PTR) {
LOG_API_ERROR("INKHttpHdrReasonGet");
} else if (sTmpHttpHdrReason && strncmp(sTmpHttpHdrReason, "dummy reason", iTmpHttpHdrReasonLength)) {
LOG_AUTO_ERROR("INKHttpHdrReasonSet/Get", "GET reason different from the SET reason");
}
STR_RELEASE(newHttpHdrBuf, newHttpHdrLoc, sTmpHttpHdrReason);
}
/*** INKHttpStatusSet ***/
/* save the original value */
if ((oldHttpStatus = INKHttpHdrStatusGet(newHttpHdrBuf, newHttpHdrLoc)) == INK_ERROR) {
LOG_API_ERROR("INKHttpHdrStatusGet");
}
/* change it to some unknown value */
if (INKHttpHdrStatusSet(newHttpHdrBuf, newHttpHdrLoc, INK_HTTP_STATUS_NONE) == INK_ERROR) {
LOG_API_ERROR("INKHttpHdrStatusSet");
} else if ((tmpHttpStatus = INKHttpHdrStatusGet(newHttpHdrBuf, newHttpHdrLoc)) == INK_ERROR) {
LOG_API_ERROR("INKHttpHdrStatusGet");
} else if (tmpHttpStatus != INK_HTTP_STATUS_NONE) {
LOG_AUTO_ERROR("INKHttpHdrStatusGet/Set", "GET status different from the SET status");
}
/*** INKHttpHdrVersionSet ***/
/* get the original version */
if ((iOldHttpVersion = INKHttpHdrVersionGet(newHttpHdrBuf, newHttpHdrLoc)) == INK_ERROR) {
LOG_API_ERROR("INKHttpHdrVersionGet");
}
/* change it to some unknown version */
if (INKHttpHdrVersionSet(newHttpHdrBuf, newHttpHdrLoc, INK_HTTP_VERSION(10, 10)) == INK_ERROR) {
LOG_API_ERROR("INKHttpHdrVersionSet");
} else if ((iTmpHttpVersion = INKHttpHdrVersionGet(newHttpHdrBuf, newHttpHdrLoc)) == INK_ERROR) {
LOG_API_ERROR("INKHttpHdrVersionGet");
} else if (INK_HTTP_MAJOR(iTmpHttpVersion) != 10 && INK_HTTP_MINOR(iTmpHttpVersion) != 10) {
LOG_AUTO_ERROR("INKHttpHdrVersionSet", "GET version different from SET version");
}
printHttpHeader(newHttpHdrBuf, newHttpHdrLoc, RESP, 3);
/* Restore the original values */
/* Here we can't use strlen(sOldHttpReason) to set the length. This would crash TS if
* sOldHttpReason happens to be NULL */
if (INKHttpHdrReasonSet(newHttpHdrBuf, newHttpHdrLoc, sOldHttpReason, iHttpHdrReasonLength) == INK_ERROR) {
LOG_API_ERROR("INKHttpHdrReasonSet");
}
/*INKHttpHdrReasonSet (newHttpHdrBuf, newHttpHdrLoc, sOldHttpReason, strlen(sOldHttpReason)); */
if (INKHttpHdrStatusSet(newHttpHdrBuf, newHttpHdrLoc, oldHttpStatus) == INK_ERROR) {
LOG_API_ERROR("INKHttpHdrStatusSet");
}
if (INKHttpHdrVersionSet(newHttpHdrBuf, newHttpHdrLoc, iOldHttpVersion) == INK_ERROR) {
LOG_API_ERROR("INKHttpHdrStatusSet");
}
if (!identical_hdr(pRespHdrInfo, pNewRespHdrInfo)) {
LOG_AUTO_ERROR("INK..SET", "Hdr values not properly restored");
}
/* (3): clean-up */
STR_RELEASE(newHttpHdrBuf, newHttpHdrLoc, sHttpHdrReason);
FREE(sOldHttpReason);
resp_4:
/******* (4): Now excercise some SETs on the response header ********/
INKDebug(RESP, "--------------------------------");
/*** INKHttpHdrReasonSet ***/
/* save the original reason */
if ((sHttpHdrReason = INKHttpHdrReasonGet(respHdrBuf, respHttpHdrLoc, &iHttpHdrReasonLength))
== INK_ERROR_PTR) {
LOG_API_ERROR("INKHttpHdrReasonGet");
} else {
sOldHttpReason = INKstrndup(sHttpHdrReason, iHttpHdrReasonLength);
}
/* change the reason phrase */
if (INKHttpHdrReasonSet(respHdrBuf, respHttpHdrLoc, "dummy reason", strlen("dummy reason")) == INK_ERROR) {
LOG_API_ERROR("INKHttpHdrReasonSet");
}
if ((sTmpHttpHdrReason = INKHttpHdrReasonGet(respHdrBuf, respHttpHdrLoc, &iTmpHttpHdrReasonLength))
== INK_ERROR_PTR) {
LOG_API_ERROR("INKHttpHdrReasonGet");
} else if (sTmpHttpHdrReason && strncmp(sTmpHttpHdrReason, "dummy reason", iTmpHttpHdrReasonLength)) {
LOG_AUTO_ERROR("INKHttpHdrReasonSet/Get", "GET reason string different from SET reason");
}
STR_RELEASE(respHdrBuf, respHttpHdrLoc, sTmpHttpHdrReason);
/*** INKHttpStatusSet ***/
/* save the original value */
if ((oldHttpStatus = INKHttpHdrStatusGet(respHdrBuf, respHttpHdrLoc)) == INK_ERROR) {
LOG_API_ERROR("INKHttpHdrStatusGet");
}
/* change it to some unknown value */
if (INKHttpHdrStatusSet(respHdrBuf, respHttpHdrLoc, INK_HTTP_STATUS_NONE) == INK_ERROR) {
LOG_API_ERROR("INKHttpHdrStatusSet");
} else if (INKHttpHdrStatusGet(respHdrBuf, respHttpHdrLoc) != INK_HTTP_STATUS_NONE) {
LOG_AUTO_ERROR("INKHttpHdrStatusSet/GET", "GET status value different from SET status");
}
/*** INKHttpHdrTypeSet ***/
/* ERROR:
* 1. Setting type other than INK_HTTP_TYPE_UNKNOWN, INK_HTTP_TYPE_REQUEST,
* INK_HTTP_TYPE_RESPONSE and,
* 2. Setting the type twice. The hdr type has been already set during INKHttpTxnClientRespGet
* above, so setting it again should fail */
if (INKHttpHdrTypeSet(respHdrBuf, respHttpHdrLoc, INK_HTTP_TYPE_RESPONSE) == INK_ERROR) {
LOG_API_ERROR("INKHttpHdrTypeSet");
}
if (INKHttpHdrTypeGet(respHdrBuf, respHttpHdrLoc) == INK_HTTP_TYPE_UNKNOWN) {
LOG_AUTO_ERROR("INKHttpHdrTypeSet/Get", "respHdrBuf CAN be set to INK_HTTP_TYPE_UNKNOWN");
}
/*** INKHttpHdrVersionSet ***/
/* get the original version */
if ((iOldHttpVersion = INKHttpHdrVersionGet(respHdrBuf, respHttpHdrLoc)) == INK_ERROR) {
LOG_API_ERROR("INKHttpHdrVersionGet");
}
/* change it to some unknown version */
if (INKHttpHdrVersionSet(respHdrBuf, respHttpHdrLoc, INK_HTTP_VERSION(10, 10)) == INK_ERROR) {
LOG_API_ERROR("INKHttpHdrVersionSet");
} else if ((iTmpHttpVersion = INKHttpHdrVersionGet(respHdrBuf, respHttpHdrLoc)) == INK_ERROR) {
LOG_API_ERROR("INKHttpHdrVersionGet");
} else if (INK_HTTP_MAJOR(iTmpHttpVersion) != 10 && INK_HTTP_MINOR(iTmpHttpVersion) != 10) {
LOG_AUTO_ERROR("INKHttpHdrVersionGet/Set", "GET HTTP version different from SET version");
}
printHttpHeader(respHdrBuf, respHttpHdrLoc, RESP, 4);
/* restore the original values */
/* For INKHttpHdrReasonSet, do NOT use strlen(sOldHttpReason) to set the length.
* This would crash TS if sOldHttpReason happened to be NULL */
if (INKHttpHdrReasonSet(respHdrBuf, respHttpHdrLoc, sOldHttpReason, iHttpHdrReasonLength) == INK_ERROR) {
LOG_API_ERROR("INKHttpHdrReasonSet");
}
/*INKHttpHdrReasonSet (respHdrBuf, respHttpHdrLoc, sOldHttpReason, strlen(sOldHttpReason)); */
if (INKHttpHdrStatusSet(respHdrBuf, respHttpHdrLoc, oldHttpStatus) == INK_ERROR) {
LOG_API_ERROR("INKHttpHdrStatusSet");
}
if (INKHttpHdrVersionSet(respHdrBuf, respHttpHdrLoc, iOldHttpVersion) == INK_ERROR) {
LOG_API_ERROR("INKHttpHdrVersionSet");
}
FREE(pNewRespHdrInfo->hdrReason);
getHdrInfo(pNewRespHdrInfo, respHdrBuf, respHttpHdrLoc);
if (!identical_hdr(pRespHdrInfo, pNewRespHdrInfo)) {
LOG_AUTO_ERROR("INK..SET", "Hdr values not properly restored");
}
/* (4): clean-up */
STR_RELEASE(respHdrBuf, respHttpHdrLoc, sHttpHdrReason);
FREE(sOldHttpReason);
/********************************/
/** (5): INKHttpHdrParseResp **/
/********************************/
INKDebug(RESP, "--------------------------------");
/* Create a parser Buffer and header location */
if ((parseBuffer = INKMBufferCreate()) == INK_ERROR_PTR || parseBuffer == NULL) {
LOG_API_ERROR_COMMENT("INKMBufferCreate", "abnormal exit");
goto done;
} else if ((parseHttpHdrLoc = INKHttpHdrCreate(parseBuffer)) == INK_ERROR_PTR || parseHttpHdrLoc == NULL) {
LOG_API_ERROR_COMMENT("INKHttpHdrCreate", "abnormal exit");
goto done;
}
pHttpParseStart = sRespHdrStr1;
pHttpParseEnd = pHttpParseStart + strlen(pHttpParseStart);
httpRespParser = INKHttpParserCreate();
if (INKHttpHdrParseResp(httpRespParser, parseBuffer, parseHttpHdrLoc, &pHttpParseStart, pHttpParseEnd)
== INK_PARSE_ERROR) {
LOG_API_ERROR("INKHttpHdrParseResp");
}
printHttpHeader(parseBuffer, parseHttpHdrLoc, RESP, 5.1);
if (INKHttpParserClear(httpRespParser) == INK_ERROR) {
LOG_API_ERROR("INKHttpParseClear");
}
INKDebug(RESP, "--------------------------------");
pHttpParseStart = sRespHdrStr2;
pHttpParseEnd = pHttpParseStart + strlen(pHttpParseStart);
/* httpRespParser = INKHttpParserCreate(); */
if (INKHttpHdrParseResp(httpRespParser, parseBuffer, parseHttpHdrLoc, &pHttpParseStart, pHttpParseEnd)
== INK_PARSE_ERROR) {
LOG_API_ERROR("INKHttpHdrParseResp");
}
printHttpHeader(parseBuffer, parseHttpHdrLoc, RESP, 5.2);
if (INKHttpParserClear(httpRespParser) == INK_ERROR) {
LOG_API_ERROR("INKHttpParseClear");
}
INKDebug(RESP, "--------------------------------");
pHttpParseStart = sRespHdrStr3;
pHttpParseEnd = pHttpParseStart + strlen(pHttpParseStart);
/* httpRespParser = INKHttpParserCreate(); */
if (INKHttpHdrParseResp(httpRespParser, parseBuffer, parseHttpHdrLoc, &pHttpParseStart, pHttpParseEnd)
== INK_PARSE_ERROR) {
LOG_API_ERROR("INKHttpHdrParseResp");
}
printHttpHeader(parseBuffer, parseHttpHdrLoc, RESP, 5.3);
done:
/* Clean-up */
freeHdr(pRespHdrInfo);
freeHdr(pNewRespHdrInfo);
/* release hdrLoc */
HANDLE_RELEASE(respHdrBuf, INK_NULL_MLOC, respHttpHdrLoc);
HANDLE_RELEASE(newHttpHdrBuf, INK_NULL_MLOC, newHttpHdrLoc);
HANDLE_RELEASE(parseBuffer, INK_NULL_MLOC, parseHttpHdrLoc);
/* destroy hdrLoc */
HDR_DESTROY(respHdrBuf, respHttpHdrLoc);
HDR_DESTROY(parseBuffer, parseHttpHdrLoc);
/* destroy mbuffer */
BUFFER_DESTROY(newHttpHdrBuf);
BUFFER_DESTROY(parseBuffer);
/* destroy the parser */
if (INKHttpParserDestroy(httpRespParser) == INK_ERROR) {
LOG_API_ERROR("INKHttpParserDestroy");
}
if (INKHttpTxnReenable(pTxn, INK_EVENT_HTTP_CONTINUE) == INK_ERROR) {
LOG_API_ERROR("INKHttpTxnReenable");
}
INKDebug(RESP, "......... exiting handleRespResponse .............\n");
} /* handleSendResponse */
void
cache_exercise(INKHttpTxn txnp, char *url, int pin_val, int hostname_set, INKCont cache_handler_cont)
{
INKCacheKey cache_key;
CACHE_URL_DATA *url_data;
int cache_ready;
char *pchar;
char hostname[MAX_URL_LEN];
LOG_SET_FUNCTION_NAME("cache_exercise");
pchar = strstr(url, "://");
if (pchar == NULL) {
pchar = url;
} else {
pchar += 3;
}
strncpy(hostname, pchar, MAX_URL_LEN - 1);
pchar = strstr(hostname, "/");
if (pchar != NULL) {
*pchar = '\0';
}
if (INKCacheReady(&cache_ready) == INK_ERROR) {
LOG_ERROR_AND_REENABLE("INKCacheReady");
return;
}
#ifdef DEBUG
/*INKDebug(DEBUG_TAG, "Starting Negative Test for INKCacheReady"); */
if (INKCacheReady(NULL) != INK_ERROR) {
LOG_ERROR_NEG("INKCacheReady(NULL)");
}
/*INKDebug(DEBUG_TAG, "Done Negative Test for INKCacheReady"); */
#endif
if (cache_ready == 0) {
INKDebug(DEBUG_TAG, "%s: ERROR!! Cache Not Ready\n", PLUGIN_NAME);
insert_in_response(txnp, "MISS");
INKHttpTxnReenable(txnp, INK_EVENT_HTTP_CONTINUE);
return;
}
if (INKCacheKeyCreate(&cache_key) == INK_ERROR) {
LOG_ERROR_AND_REENABLE("INKCacheKeyCreate");
return;
}
#ifdef DEBUG
/*INKDebug(DEBUG_TAG, "Starting Negative Test for INKCacheKeyCreate"); */
if (INKCacheKeyCreate(NULL) != INK_ERROR) {
LOG_ERROR_NEG("INKCacheKeyCreate(NULL)");
}
/*INKDebug(DEBUG_TAG, "Done Negative Test for INKCacheKeyCreate"); */
#endif
#ifdef DEBUG
/*INKDebug(DEBUG_TAG, "Starting Negative Test for INKCacheKeyDigestSet"); */
if (INKCacheKeyDigestSet(NULL, (unsigned char *) url, strlen(url)) != INK_ERROR) {
LOG_ERROR_NEG("INKCacheKeyDigestSet(NULL, string, len)");
}
if (INKCacheKeyDigestSet(cache_key, NULL, strlen(url)) != INK_ERROR) {
LOG_ERROR_NEG("INKCacheKeyDigestSet(cache_key, NULL, len)");
}
if (INKCacheKeyDigestSet(cache_key, (unsigned char *) url, -1) != INK_ERROR) {
LOG_ERROR_NEG("INKCacheKeyDigestSet(cache_key, string, -1)");
}
/*INKDebug(DEBUG_TAG, "Done Negative Test for INKCacheKeyDigestSet"); */
#endif
if (INKCacheKeyDigestSet(cache_key, (unsigned char *) url, strlen(url)) == INK_ERROR) {
INKCacheKeyDestroy(cache_key);
LOG_ERROR_AND_REENABLE("INKCacheKeyDigestSet");
return;
}
url_data = INKmalloc(sizeof(CACHE_URL_DATA));
if (url_data == NULL) {
INKCacheKeyDestroy(cache_key);
LOG_ERROR_AND_REENABLE("INKmalloc");
return;
}
url_data->magic = MAGIC_ALIVE;
url_data->url = url;
url_data->url_len = strlen(url);
url_data->key = cache_key;
url_data->pin_time = pin_val;
url_data->write_again_after_remove = 0;
url_data->txnp = txnp;
url_data->bufp = INKIOBufferCreate();
if (url_data->bufp == INK_ERROR_PTR) {
INKCacheKeyDestroy(cache_key);
INKfree(url_data);
LOG_ERROR_AND_REENABLE("INKIOBufferCreate");
return;
}
if (INKContDataSet(cache_handler_cont, url_data) == INK_ERROR) {
INKCacheKeyDestroy(cache_key);
INKfree(url_data);
LOG_ERROR_AND_REENABLE("INKContDataSet");
return;
}
#ifdef DEBUG
/*INKDebug(DEBUG_TAG, "Starting Negative Test for INKCacheKeyHostNameSet"); */
if (INKCacheKeyHostNameSet(NULL, (unsigned char *) hostname, strlen(hostname)) != INK_ERROR) {
LOG_ERROR_NEG("INKCacheKeyHostNameSet(NULL, string, len)");
}
if (INKCacheKeyHostNameSet(url_data->key, NULL, strlen(hostname)) != INK_ERROR) {
LOG_ERROR_NEG("INKCacheKeyHostNameSet(cache_key, NULL, len)");
}
if (INKCacheKeyHostNameSet(url_data->key, (unsigned char *) hostname, -1) != INK_ERROR) {
LOG_ERROR_NEG("INKCacheKeyHostNameSet(cache_key, string, -1)");
}
/*INKDebug(DEBUG_TAG, "Done Negative Test for INKCacheKeyHostNameSet"); */
#endif
if (hostname_set > 0) {
INKDebug(DEBUG_TAG, "HostName set for cache_key to %s", hostname);
if (INKCacheKeyHostNameSet(url_data->key, (unsigned char *) hostname, strlen(hostname)) == INK_ERROR) {
INKCacheKeyDestroy(cache_key);
INKfree(url_data);
LOG_ERROR_AND_REENABLE("INKCacheKeyHostNameSet");
return;
}
}
/* try to read from the cache */
if (INKCacheRead(cache_handler_cont, cache_key) == INK_ERROR_PTR) {
INKCacheKeyDestroy(cache_key);
INKfree(url_data);
LOG_ERROR_AND_REENABLE("INKCacheRead");
return;
}
#ifdef DEBUG
/*INKDebug(DEBUG_TAG, "Starting Negative Test for INKCacheRead"); */
if (INKCacheRead(cache_handler_cont, NULL) != INK_ERROR_PTR) {
LOG_ERROR_NEG("INKCacheRead(cache_handler_cont, NULL)");
}
if (INKCacheRead(NULL, cache_key) != INK_ERROR_PTR) {
LOG_ERROR_NEG("INKCacheRead(NULL, cache_key)");
}
/*INKDebug(DEBUG_TAG, "Done Negative Test for INKCacheRead"); */
#endif
return;
}
static int
handle_cache_events(INKCont contp, INKEvent event, void *edata)
{
CACHE_URL_DATA *url_data;
INKVConn connp = (INKVConn) edata;
char tempstr[32];
LOG_SET_FUNCTION_NAME("handle_cache_events");
url_data = (CACHE_URL_DATA *) INKContDataGet(contp);
if (url_data == INK_ERROR_PTR) {
LOG_ERROR_AND_RETURN("INKContDataGet");
}
if (event != INK_EVENT_HTTP_TXN_CLOSE) {
INKReleaseAssert(url_data->magic == MAGIC_ALIVE);
} else {
INKReleaseAssert((url_data == NULL) || (url_data->magic == MAGIC_ALIVE));
}
switch (event) {
case INK_EVENT_CACHE_OPEN_READ:
/*handle_cache_read(); */
INKDebug(DEBUG_TAG, "INK_EVENT_CACHE_OPEN_READ\n");
if (url_data->pin_time != 0) {
sprintf(tempstr, "PIN%d", url_data->pin_time);
} else {
sprintf(tempstr, "HIT");
}
insert_in_response(url_data->txnp, tempstr);
if (url_data->pin_time != 0) {
url_data->write_again_after_remove = 1;
if (INKCacheRemove(contp, url_data->key) == INK_ERROR_PTR) {
LOG_ERROR("INKCacheRemove");
INKHttpTxnReenable(url_data->txnp, INK_EVENT_HTTP_CONTINUE);
return -1;
}
#ifdef DEBUG
if (INKCacheRemove(NULL, url_data->key) != INK_ERROR_PTR) {
LOG_ERROR_NEG("INKCacheRemove(NULL, cache_key)");
}
if (INKCacheRemove(contp, NULL) != INK_ERROR_PTR) {
LOG_ERROR_NEG("INKCacheRemove(contp, NULL)");
}
#endif
return 0;
}
#ifdef DEBUG
if (INKVConnRead(NULL, contp, url_data->bufp, url_data->url_len) != INK_ERROR_PTR) {
LOG_ERROR_NEG("INKVConnRead(NULL, contp, bufp, url_len)");
}
if (INKVConnRead(connp, NULL, url_data->bufp, url_data->url_len) != INK_ERROR_PTR) {
LOG_ERROR_NEG("INKVConnRead(connp, NULL, bufp, url_len)");
}
if (INKVConnRead(connp, contp, NULL, url_data->url_len) != INK_ERROR_PTR) {
LOG_ERROR_NEG("INKVConnRead(connp, contp, NULL, url_len)");
}
if (INKVConnRead(connp, contp, url_data->bufp, -1) != INK_ERROR_PTR) {
LOG_ERROR_NEG("INKVConnRead(connp, contp, bufp, -1)");
}
#endif
if (INKVConnRead(connp, contp, url_data->bufp, url_data->url_len) == INK_ERROR_PTR) {
LOG_ERROR("INKVConnRead");
INKHttpTxnReenable(url_data->txnp, INK_EVENT_HTTP_CONTINUE);
return -1;
}
break;
case INK_EVENT_CACHE_OPEN_READ_FAILED:
/*handle_cache_read_fail(); */
INKDebug(DEBUG_TAG, "INK_EVENT_CACHE_OPEN_READ_FAILED(%d)\n", edata);
if (url_data->pin_time != 0) {
sprintf(tempstr, "PIN%d", url_data->pin_time);
} else {
sprintf(tempstr, "MISS");
}
insert_in_response(url_data->txnp, tempstr);
if (url_data->pin_time != 0) {
INKDebug(DEBUG_TAG, "url Pinned in cache for %d secs", url_data->pin_time);
if (INKCacheKeyPinnedSet(url_data->key, url_data->pin_time) == INK_ERROR) {
LOG_ERROR("INKCacheKeyPinnedSet");
INKHttpTxnReenable(url_data->txnp, INK_EVENT_HTTP_CONTINUE);
return -1;
}
#ifdef DEBUG
if (INKCacheKeyPinnedSet(NULL, url_data->pin_time) != INK_ERROR) {
LOG_ERROR_NEG("INKCacheKeyPinnedSet(NULL, pin_time)");
}
if (INKCacheKeyPinnedSet(url_data->key, -1) != INK_ERROR) {
LOG_ERROR_NEG("INKCacheKeyPinnedSet(cache_key, -1)");
}
#endif
}
if (INKCacheWrite(contp, url_data->key) == INK_ERROR_PTR) {
LOG_ERROR("INKCacheWrite");
INKHttpTxnReenable(url_data->txnp, INK_EVENT_HTTP_CONTINUE);
return -1;
}
#ifdef DEBUG
if (INKCacheWrite(contp, NULL) != INK_ERROR_PTR) {
LOG_ERROR_NEG("INKCacheWrite(contp, NULL)");
}
if (INKCacheWrite(NULL, url_data->key) != INK_ERROR_PTR) {
LOG_ERROR_NEG("INKCacheWrite(NULL, url_data->key)");
}
#endif
break;
case INK_EVENT_CACHE_OPEN_WRITE:
/*handle_cache_write(); */
INKDebug(DEBUG_TAG, "INK_EVENT_CACHE_OPEN_WRITE\n");
if (INKIOBufferWrite(url_data->bufp, url_data->url, url_data->url_len) == INK_ERROR) {
LOG_ERROR("INKIOBufferWrite");
INKHttpTxnReenable(url_data->txnp, INK_EVENT_HTTP_CONTINUE);
return -1;
}
url_data->bufp_reader = INKIOBufferReaderAlloc(url_data->bufp);
if (url_data->bufp_reader == INK_ERROR_PTR) {
LOG_ERROR("INKIOBufferReaderAlloc");
INKHttpTxnReenable(url_data->txnp, INK_EVENT_HTTP_CONTINUE);
return -1;
}
#ifdef DEBUG
if (INKVConnWrite(NULL, contp, url_data->bufp_reader, url_data->url_len) != INK_ERROR_PTR) {
LOG_ERROR_NEG("INKVConnWrite(NULL, contp, bufp_reader, url_len");
}
if (INKVConnWrite(connp, NULL, url_data->bufp_reader, url_data->url_len) != INK_ERROR_PTR) {
LOG_ERROR_NEG("INKVConnWrite(connp, NULL, bufp_reader, url_len");
}
if (INKVConnWrite(connp, contp, NULL, url_data->url_len) != INK_ERROR_PTR) {
LOG_ERROR_NEG("INKVConnWrite(connp, contp, NULL, url_len");
}
if (INKVConnWrite(connp, contp, url_data->bufp_reader, -1) != INK_ERROR_PTR) {
LOG_ERROR_NEG("INKVConnWrite(connp, contp, bufp_reader, -1");
}
#endif
if (INKVConnWrite(connp, contp, url_data->bufp_reader, url_data->url_len) == INK_ERROR_PTR) {
LOG_ERROR("INKVConnWrite");
INKHttpTxnReenable(url_data->txnp, INK_EVENT_HTTP_CONTINUE);
return -1;
}
break;
case INK_EVENT_CACHE_OPEN_WRITE_FAILED:
/*handle_cache_write_fail(); */
INKDebug(DEBUG_TAG, "INK_EVENT_CACHE_OPEN_WRITE_FAILED(%d)\n", edata);
INKHttpTxnReenable(url_data->txnp, INK_EVENT_HTTP_CONTINUE);
break;
case INK_EVENT_CACHE_REMOVE:
/*handle_cache_remove(); */
INKDebug(DEBUG_TAG, "INK_EVENT_CACHE_REMOVE\n");
if (url_data->write_again_after_remove != 0) {
INKDebug(DEBUG_TAG, "url Pinned in cache for %d secs", url_data->pin_time);
if (url_data->pin_time != 0) {
if (INKCacheKeyPinnedSet(url_data->key, url_data->pin_time) == INK_ERROR) {
LOG_ERROR("INKCacheKeyPinnedSet");
INKHttpTxnReenable(url_data->txnp, INK_EVENT_HTTP_CONTINUE);
return -1;
}
}
if (INKCacheWrite(contp, url_data->key) == INK_ERROR_PTR) {
LOG_ERROR("INKCacheWrite");
INKHttpTxnReenable(url_data->txnp, INK_EVENT_HTTP_CONTINUE);
return -1;
}
} else {
INKHttpTxnReenable(url_data->txnp, INK_EVENT_HTTP_CONTINUE);
}
break;
case INK_EVENT_CACHE_REMOVE_FAILED:
/*handle_cache_remove_fail(); */
INKDebug(DEBUG_TAG, "INK_EVENT_CACHE_REMOVE_FAILED(%d)\n", edata);
INKHttpTxnReenable(url_data->txnp, INK_EVENT_HTTP_CONTINUE);
break;
case INK_EVENT_VCONN_READ_READY:
INKDebug(DEBUG_TAG, "INK_EVENT_VCONN_READ_READY\n");
if (INKVIOReenable(edata) == INK_ERROR) {
LOG_ERROR("INKVIOReenable");
}
#ifdef DEBUG
if (INKVIOReenable(NULL) != INK_ERROR) {
LOG_ERROR_NEG("INKVIOReenable");
}
#endif
break;
case INK_EVENT_VCONN_WRITE_READY:
INKDebug(DEBUG_TAG, "INK_EVENT_VCONN_WRITE_READY\n");
if (INKVIOReenable(edata) == INK_ERROR) {
LOG_ERROR("INKVIOReenable");
}
#ifdef DEBUG
if (INKVIOReenable(NULL) != INK_ERROR) {
LOG_ERROR_NEG("INKVIOReenable");
}
#endif
break;
case INK_EVENT_VCONN_READ_COMPLETE:
INKDebug(DEBUG_TAG, "INK_EVENT_VCONN_READ_COMPLETE\n");
{
INKIOBufferBlock blk;
char *src;
char dst[MAX_URL_LEN];
int avail;
int url_len_from_cache;
if ((connp = INKVIOVConnGet(edata)) == INK_ERROR_PTR) {
LOG_ERROR("INKVIOVConnGet");
INKHttpTxnReenable(url_data->txnp, INK_EVENT_HTTP_CONTINUE);
return -1;
}
#ifdef DEBUG
if (INKVConnCacheObjectSizeGet(NULL, &url_len_from_cache) != INK_ERROR) {
LOG_ERROR_NEG("INKVConnCacheObjectSizeGet(NULL, &size)");
}
if (INKVConnCacheObjectSizeGet(connp, NULL) != INK_ERROR) {
LOG_ERROR_NEG("INKVConnCacheObjectSizeGet(inkvconn, NULL)");
}
#endif
if (INKVConnCacheObjectSizeGet(connp, &url_len_from_cache) == INK_ERROR) {
LOG_ERROR("INKVConnCacheObjectSizeGet");
INKHttpTxnReenable(url_data->txnp, INK_EVENT_HTTP_CONTINUE);
return -1;
}
if (url_len_from_cache != url_data->url_len) {
LOG_ERROR("INKVConnCacheObjectSizeGet-mismatch");
INKHttpTxnReenable(url_data->txnp, INK_EVENT_HTTP_CONTINUE);
return -1;
}
if ((connp = INKVIOVConnGet(edata)) == INK_ERROR_PTR) {
LOG_ERROR("INKVIOVConnGet");
INKHttpTxnReenable(url_data->txnp, INK_EVENT_HTTP_CONTINUE);
return -1;
}
#ifdef DEBUG
if (INKVIOVConnGet(NULL) != INK_ERROR_PTR) {
LOG_ERROR_NEG("INKVIOVConnGet(null)");
}
if (INKVConnClose(NULL) != INK_ERROR) {
LOG_ERROR_NEG("INKVConnClose(NULL)");
}
#endif
if (INKVConnClose(connp) == INK_ERROR) {
LOG_ERROR("INKVConnClose");
INKHttpTxnReenable(url_data->txnp, INK_EVENT_HTTP_CONTINUE);
return -1;
}
url_data = (CACHE_URL_DATA *) INKContDataGet(contp);
INKReleaseAssert(url_data->magic == MAGIC_ALIVE);
url_data->bufp_reader = INKIOBufferReaderAlloc(url_data->bufp);
blk = INKIOBufferReaderStart(url_data->bufp_reader);
if (blk == INK_ERROR_PTR) {
LOG_ERROR("INKIOBufferReaderStart");
INKHttpTxnReenable(url_data->txnp, INK_EVENT_HTTP_CONTINUE);
return -1;
}
src = (char *) INKIOBufferBlockReadStart(blk, url_data->bufp_reader, &avail);
/* FC: make sure we do not copy more than MAX_URL_LEN-1 bytes into dst */
if (avail < 0) {
avail = 0;
}
avail = (avail < MAX_URL_LEN - 1) ? avail : (MAX_URL_LEN - 1);
strncpy(dst, src, avail);
dst[avail] = '\0';
if (strcmp(dst, url_data->url) != 0) {
INKDebug(DEBUG_TAG, "URL in cache NO_MATCH\ndst=[%s]\nurl=[%s]\n", dst, url_data->url);
}
}
INKHttpTxnReenable(url_data->txnp, INK_EVENT_HTTP_CONTINUE);
break;
case INK_EVENT_VCONN_WRITE_COMPLETE:
INKDebug(DEBUG_TAG, "INK_EVENT_VCONN_WRITE_COMPLETE\n");
if ((connp = INKVIOVConnGet(edata)) == INK_ERROR_PTR) {
LOG_ERROR("INKVIOVConnGet");
INKHttpTxnReenable(url_data->txnp, INK_EVENT_HTTP_CONTINUE);
return -1;
}
#ifdef DEBUG
if (INKVIOVConnGet(NULL) != INK_ERROR_PTR) {
LOG_ERROR_NEG("INKVIOVConnGet(null)");
}
if (INKVConnClose(NULL) != INK_ERROR) {
LOG_ERROR_NEG("INKVConnClose(NULL)");
}
#endif
if (INKVConnClose(connp) == INK_ERROR) {
LOG_ERROR("INKVConnClose");
INKHttpTxnReenable(url_data->txnp, INK_EVENT_HTTP_CONTINUE);
return -1;
}
INKHttpTxnReenable(url_data->txnp, INK_EVENT_HTTP_CONTINUE);
break;
case INK_EVENT_VCONN_EOS:
INKDebug(DEBUG_TAG, "INK_EVENT_VCONN_EOS\n");
break;
case INK_EVENT_ERROR:
INKDebug(DEBUG_TAG, "INK_EVENT_ERROR\n");
INKHttpTxnReenable(url_data->txnp, INK_EVENT_HTTP_CONTINUE);
break;
case INK_EVENT_HTTP_TXN_CLOSE:
INKDebug(DEBUG_TAG, "INK_EVENT_HTTP_TXN_CLOSE\n");
if (url_data == NULL) {
INKHttpTxnReenable(edata, INK_EVENT_HTTP_CONTINUE);
break;
}
if (url_data->url != NULL) {
INKfree(url_data->url);
}
if (INKCacheKeyDestroy(url_data->key) == INK_ERROR) {
LOG_ERROR("INKCacheKeyDestroy");
}
#ifdef DEBUG
if (INKCacheKeyDestroy(NULL) != INK_ERROR) {
LOG_ERROR_NEG("INKCacheKeyDestroy(NULL)");
}
if (INKIOBufferDestroy(NULL) != INK_ERROR) {
LOG_ERROR_NEG("INKIOBufferDestroy(NULL)");
}
#endif
if (INKIOBufferDestroy(url_data->bufp) == INK_ERROR) {
LOG_ERROR("INKIOBufferDestroy");
}
url_data->magic = MAGIC_DEAD;
INKfree(url_data);
INKContDestroy(contp);
INKHttpTxnReenable(edata, INK_EVENT_HTTP_CONTINUE);
break;
default:
;
}
return 0;
}
/********************************************************************
* When the client sends the same request the second time, get the
* header field MY_HDR from the caches response header, print it out
* and save it in a text file.
********************************************************************/
static int
handle_cache_hdr(INKHttpTxn txnp)
{
LOG_SET_FUNCTION_NAME("handle_cache_hdr");
INKMBuffer cache_bufp;
INKMLoc cache_loc = NULL, field_loc = NULL;
const char *my_hdr;
int value_count, i, length;
char output_file[1024], output_str[1024];
INKFile file;
output_str[0] = '\0';
/* get the cached response header */
if (!INKHttpTxnCachedRespGet(txnp, &cache_bufp, &cache_loc))
LOG_ERROR_AND_RETURN("INKHttpTxnCachedRespGet");
/* get the MY_HDR field in the header */
if ((field_loc = INKMimeHdrFieldFind(cache_bufp, cache_loc, MY_HDR, strlen(MY_HDR))) == INK_ERROR_PTR ||
field_loc == NULL)
LOG_ERROR_AND_CLEANUP("INKMimeHdrFieldFind");
if ((value_count = INKMimeHdrFieldValuesCount(cache_bufp, cache_loc, field_loc)) == INK_ERROR)
LOG_ERROR_AND_CLEANUP("INKMimeHdrFieldValuesCount");
for (i = 0; i <= value_count - 1; i++) {
if (INKMimeHdrFieldValueStringGet(cache_bufp, cache_loc, field_loc, i, &my_hdr, &length) == INK_ERROR)
LOG_ERROR_AND_CLEANUP("INKMimeHdrFieldValueStringGet");
/* concatenate the field to output_str */
if (my_hdr) {
snprintf(output_str, 1024, "%s MY_HDR(%d): %.*s \n", output_str, i, length, my_hdr);
INKHandleStringRelease(cache_bufp, field_loc, my_hdr);
}
}
snprintf(output_file, 1024, "%s/write_server_ip.txt", plugin_dir);
INKDebug(DEBUG_TAG, "Writing record\n%s\nto file %s", output_str, output_file);
/* append to the text file */
if (INKMutexLock(file_mutex) == INK_ERROR)
LOG_ERROR_AND_CLEANUP("INKMutexLock");
if ((file = INKfopen(output_file, "w")) == NULL)
LOG_ERROR_AND_CLEANUP("INKfopen");
INKfwrite(file, output_str, strlen(output_str));
INKfflush(file);
INKfclose(file);
if (INKMutexUnlock(file_mutex) == INK_ERROR)
LOG_ERROR_AND_CLEANUP("INKMutexUnlock");
/* cleanup */
Lcleanup:
/* release mlocs */
if (VALID_POINTER(field_loc))
INKHandleMLocRelease(cache_bufp, cache_loc, field_loc);
if (VALID_POINTER(cache_loc))
INKHandleMLocRelease(cache_bufp, INK_NULL_MLOC, cache_loc);
return 0;
}
static void
printHttpHeader(INKMBuffer hdrBuf, INKMLoc hdrLoc, char *debugTag, float section)
{
LOG_SET_FUNCTION_NAME("printHttpHeader");
INKMLoc urlLoc = NULL;
INKHttpStatus httpStatus;
INKHttpType httpType;
int iHostLength, iHttpHdrLength, iHttpMethodLength, iHttpHdrReasonLength, iHttpVersion;
const char *sHostName = NULL, *sHttpMethod = NULL, *sHttpHdrReason = NULL;
char *outputString = NULL;
/*** INKHttpHdrTypeGet ***/
if ((httpType = INKHttpHdrTypeGet(hdrBuf, hdrLoc)) == INK_ERROR) {
LOG_API_ERROR("INKHttpHdrTypeGet");
}
INKDebug(debugTag, "(%g) HTTP Header Type = %d", section, httpType);
/*** INKHttpHdrLengthGet ***/
if ((iHttpHdrLength = INKHttpHdrLengthGet(hdrBuf, hdrLoc)) == INK_ERROR) {
LOG_API_ERROR("INKHttpHdrLengthGet");
}
INKDebug(debugTag, "(%g) HTTP Header Length = %d", section, iHttpHdrLength);
/*** INKHttpVersionGet ***/
if ((iHttpVersion = INKHttpHdrVersionGet(hdrBuf, hdrLoc)) == INK_ERROR) {
LOG_API_ERROR("INKHttpHdrVersionGet");
}
INKDebug(debugTag, "(%g) HTTP Header Version = %d", section, iHttpVersion);
INKDebug(debugTag, "(%g) Major Version = %d, Minor Version = %d", section,
INK_HTTP_MAJOR(iHttpVersion), INK_HTTP_MINOR(iHttpVersion));
if (httpType == INK_HTTP_TYPE_REQUEST) {
/*** INKHttpHdrMethodGet ***/
if ((sHttpMethod = INKHttpHdrMethodGet(hdrBuf, hdrLoc, &iHttpMethodLength)) == INK_ERROR_PTR) {
LOG_API_ERROR("INKHttpHdrMethodGet");
} else {
outputString = INKstrndup(sHttpMethod, iHttpMethodLength);
INKDebug(debugTag, "(%g) HTTP Header Method = %s", section, outputString);
FREE(outputString);
STR_RELEASE(hdrBuf, urlLoc, sHttpMethod);
}
/*** INKHttpHdrUrlGet ***/
if ((urlLoc = INKHttpHdrUrlGet(hdrBuf, hdrLoc)) == INK_ERROR_PTR) {
LOG_API_ERROR("INKHttpHdrUrlGet");
} else if ((sHostName = INKUrlHostGet(hdrBuf, urlLoc, &iHostLength)) == INK_ERROR_PTR) {
LOG_API_ERROR("INKUrlHostGet");
} else if (sHostName) {
outputString = INKstrndup(sHostName, iHostLength);
INKDebug(debugTag, "(%g) HTTP Host = %s", section, outputString);
FREE(outputString);
STR_RELEASE(hdrBuf, urlLoc, sHostName);
}
/* Clean-up */
HANDLE_RELEASE(hdrBuf, hdrLoc, urlLoc);
} else if (httpType == INK_HTTP_TYPE_RESPONSE) {
/*** INKHttpHdrReasonGet ***/
/* Try getting reason phrase from the request header - this is an error */
if ((sHttpHdrReason = INKHttpHdrReasonGet(hdrBuf, hdrLoc, &iHttpHdrReasonLength)) == INK_ERROR_PTR) {
LOG_API_ERROR("INKHttpHdrReasonGet");
} else {
outputString = INKstrndup(sHttpHdrReason, iHttpHdrReasonLength);
INKDebug(debugTag, "(%g) HTTP Header Reason = %s", section, outputString);
FREE(outputString);
STR_RELEASE(hdrBuf, hdrLoc, sHttpHdrReason);
}
/*** INKHttpHdrStatusGet ***/
/* Try getting status phrase from the request header - this is an error */
if ((httpStatus = INKHttpHdrStatusGet(hdrBuf, hdrLoc)) == INK_ERROR) {
LOG_API_ERROR("INKHttpHdrStatusGet");
} else {
INKDebug(debugTag, "(%g) HTTP Header Status = %d", section, httpStatus);
}
}
}
static void
handleReadRequest(INKCont pCont, INKHttpTxn pTxn)
{
LOG_SET_FUNCTION_NAME("handleReadRequest");
INKMBuffer reqHdrBuf = NULL, newHttpHdrBuf = NULL;
INKMLoc reqHdrLoc = NULL, newHttpHdrLoc = NULL;
INKHttpType httpType;
int iOldHttpVersion, iHttpMethodLength, iHttpVersion;
const char *sHttpMethod = NULL;
char *outputString = NULL, *sOldHttpMethod = NULL;
HdrInfo_T *pReqHdrInfo = NULL, *pNewReqHdrInfo = NULL;
#if 0
const char *constant_request_header_str =
"GET http://www.joes-hardware.com/ HTTP/1.0\r\nDate: Wed, 05 Jul 2000 22:12:26 GMT\r\nConnection: Keep-Alive\r\nUser-Agent: Mozilla/4.51 [en] (X11; U; IRIX 6.2 IP22)\r\nHost: www.joes-hardware.com\r\nCache-Control: no-cache\r\nAccept: image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, image/png, */*\r\nAccept-Charset: iso-8859-1,*,utf-8\r\nAccept-Encoding: gzip\r\nAccept-Language: en\r\nX-Number-Header: 12345\r\nX-Silly-Header: frobnichek grobbledegook\r\nAccept-Charset: windows-1250, koi8-r\r\nX-Silly-Header: wawaaa\r\n\r\n";
#endif
pReqHdrInfo = initHdr();
pNewReqHdrInfo = initHdr();
INKDebug(REQ, "\n>>>>>> handleReadRequest <<<<<<<\n");
/* Get Request Marshall Buffer */
if (!INKHttpTxnClientReqGet(pTxn, &reqHdrBuf, &reqHdrLoc)) {
LOG_API_ERROR_COMMENT("INKHttpTxnClientReqGet", "ERROR: Can't retrieve client req hdr");
goto done;
}
/******* (1): Get every specifics from the HTTP header *********/
INKDebug(REQ, "--------------------------------");
getHdrInfo(pReqHdrInfo, reqHdrBuf, reqHdrLoc);
printHttpHeader(reqHdrBuf, reqHdrLoc, REQ, 1);
#ifdef DEBUG
negTesting(reqHdrBuf, reqHdrLoc);
#endif
/*********** (2): Create/Copy/Destroy **********/
/* For every request, create, copy and destroy a new HTTP header and
* print the details */
INKDebug(REQ, "--------------------------------");
if ((newHttpHdrBuf = INKMBufferCreate()) == INK_ERROR_PTR) {
LOG_API_ERROR_COMMENT("INKMBufferCreate", "skipping to section 3");
goto section_3; /* Skip to section (3) down the line directly; I hate GOTOs */
}
/*** INKHttpHdrCreate ***/
if ((newHttpHdrLoc = INKHttpHdrCreate(newHttpHdrBuf)) == INK_ERROR_PTR) {
LOG_API_ERROR_COMMENT("INKHttpHdrCreate", "skipping to section 3");
goto section_3; /* Skip to section (3) down the line directly; I hate GOTOs */
}
/* Make sure the newly created HTTP header has INKHttpType value of INK_HTTP_TYPE_UNKNOWN */
if ((httpType = INKHttpHdrTypeGet(newHttpHdrBuf, newHttpHdrLoc)) == INK_ERROR) {
LOG_API_ERROR_COMMENT("INKHttpHdrTypeGet", "but still continuing...");
} else if (httpType != INK_HTTP_TYPE_UNKNOWN) {
LOG_AUTO_ERROR("INKHttpHdrCreate", "Newly created hdr not of type INK_HTTP_TYPE_UNKNOWN");
}
/* set the HTTP header type: a new buffer has a type INK_HTTP_TYPE_UNKNOWN by default */
if (INKHttpHdrTypeSet(newHttpHdrBuf, newHttpHdrLoc, INK_HTTP_TYPE_REQUEST) == INK_ERROR) {
LOG_API_ERROR_COMMENT("INKHttpHdrTypeSet", "unable to set it to INK_HTTP_TYPE_REQUEST");
} else if ((httpType = INKHttpHdrTypeGet(newHttpHdrBuf, newHttpHdrLoc)) == INK_ERROR) {
LOG_API_ERROR_COMMENT("INKHttpHdrTypeGet", "still continuing");
} else if (httpType != INK_HTTP_TYPE_REQUEST) {
LOG_AUTO_ERROR("INKHttpHdrTypeSet", "Type not set to INK_HTTP_TYPE_REQUEST");
}
/*** INKHttpHdrCopy ***/
if (INKHttpHdrCopy(newHttpHdrBuf, newHttpHdrLoc, reqHdrBuf, reqHdrLoc) == INK_ERROR) {
LOG_API_ERROR("INKHttpHdrCopy");
}
getHdrInfo(pNewReqHdrInfo, newHttpHdrBuf, newHttpHdrLoc);
if (!identical_hdr(pNewReqHdrInfo, pReqHdrInfo)) {
LOG_AUTO_ERROR("INKHttpHdrCopy", "New req buffer not identical to the original");
}
printHttpHeader(newHttpHdrBuf, newHttpHdrLoc, REQ, 2);
FREE(pNewReqHdrInfo->httpMethod);
FREE(pNewReqHdrInfo->hostName);
section_3:
/********* (3): Excercise all the INK__Set on ReqBuf *********/
INKDebug(REQ, "--------------------------------");
/*** INKHttpHdrMethodSet ***/
/* save the original method */
if ((sHttpMethod = INKHttpHdrMethodGet(reqHdrBuf, reqHdrLoc, &iHttpMethodLength)) == INK_ERROR_PTR) {
LOG_API_ERROR("INKHttpHdrMethodGet");
} else {
sOldHttpMethod = INKstrndup(sHttpMethod, iHttpMethodLength);
}
/* change it to some unknown method */
if (INKHttpHdrMethodSet(reqHdrBuf, reqHdrLoc, "FOOBAR", strlen("FOOBAR")) == INK_ERROR) {
LOG_API_ERROR("INKHttpHdrMethodSet");
} else {
if ((sHttpMethod = INKHttpHdrMethodGet(reqHdrBuf, reqHdrLoc, &iHttpMethodLength)) == INK_ERROR_PTR) {
LOG_API_ERROR("INKHttpHdrMethodGet");
} else if (strncmp(sHttpMethod, "FOOBAR", iHttpMethodLength)) {
LOG_AUTO_ERROR("INKHttpHdrMethodSet/Get", "GET method different from SET method");
}
}
outputString = INKstrndup(sHttpMethod, iHttpMethodLength);
INKDebug(REQ, "(3): new HTTP Header Method = %s", outputString);
FREE(outputString);
STR_RELEASE(reqHdrBuf, reqHdrLoc, sHttpMethod);
printHttpHeader(reqHdrBuf, reqHdrLoc, REQ, 3);
/* set it back to the original method */
/*INKHttpHdrMethodSet (reqHdrBuf, reqHdrLoc, sOldHttpMethod, iHttpMethodLength); */
if (INKHttpHdrMethodSet(reqHdrBuf, reqHdrLoc, sOldHttpMethod, strlen(sOldHttpMethod)) == INK_ERROR) {
LOG_API_ERROR("INKHttpHdrMethodSet");
} else if ((sHttpMethod = INKHttpHdrMethodGet(reqHdrBuf, reqHdrLoc, &iHttpMethodLength)) == INK_ERROR_PTR) {
LOG_API_ERROR("INKHttpHdrMethodGet");
} else if (strncmp(sHttpMethod, sOldHttpMethod, iHttpMethodLength)) {
LOG_AUTO_ERROR("INKHttpHdrMethodSet/Get", "GET method different from SET method");
}
outputString = INKstrndup(sHttpMethod, iHttpMethodLength);
INKDebug(REQ, "(3): original HTTP Header Method = %s", outputString);
FREE(outputString);
STR_RELEASE(reqHdrBuf, reqHdrLoc, sHttpMethod);
/*** INKHttpHdrVersionSet ***/
/* get the original version */
if ((iOldHttpVersion = INKHttpHdrVersionGet(reqHdrBuf, reqHdrLoc)) == INK_ERROR) {
LOG_API_ERROR("INKHttpHdrVersionGet");
}
/* change it to some unknown version */
if (INKHttpHdrVersionSet(reqHdrBuf, reqHdrLoc, INK_HTTP_VERSION(10, 10)) == INK_ERROR) {
LOG_API_ERROR("INKHttpHdrVersionSet");
} else if ((iHttpVersion = INKHttpHdrVersionGet(reqHdrBuf, reqHdrLoc)) == INK_ERROR) {
LOG_API_ERROR("INKHttpHdrVersionGet");
} else if ((INK_HTTP_MAJOR(iHttpVersion) != 10) || (INK_HTTP_MINOR(iHttpVersion) != 10)) {
LOG_AUTO_ERROR("INKHttpHdrVersionSet/Get", "SET HTTP version different from GET version");
}
INKDebug(REQ, "(3): new HTTP version; Major = %d Minor = %d",
INK_HTTP_MAJOR(iHttpVersion), INK_HTTP_MINOR(iHttpVersion));
/* change it back to the original version */
if (INKHttpHdrVersionSet(reqHdrBuf, reqHdrLoc, iOldHttpVersion) == INK_ERROR) {
LOG_API_ERROR("INKHttpHdrVersionSet");
} else if ((iHttpVersion = INKHttpHdrVersionGet(reqHdrBuf, reqHdrLoc)) == INK_ERROR) {
LOG_API_ERROR("INKHttpHdrVersionGet");
} else if (iHttpVersion != iOldHttpVersion) {
LOG_AUTO_ERROR("INKHttpHdrVersionSet/Get", "SET HTTP version different from GET version");
}
getHdrInfo(pNewReqHdrInfo, reqHdrBuf, reqHdrLoc);
if (!identical_hdr(pNewReqHdrInfo, pReqHdrInfo)) {
LOG_AUTO_ERROR("INK..Set", "ReqBuf: Values not restored properly");
}
/* (3): clean-up */
FREE(sOldHttpMethod);
done:
/*************** Clean-up ***********************/
/*
FREE(pReqHdrInfo->httpMethod);
FREE(pReqHdrInfo->hostName);
FREE(pNewReqHdrInfo->httpMethod);
FREE(pNewReqHdrInfo->hostName);
FREE(pReqHdrInfo);
FREE(pNewReqHdrInfo);
*/
freeHdr(pReqHdrInfo);
freeHdr(pNewReqHdrInfo);
/* release hdrLoc */
HANDLE_RELEASE(reqHdrBuf, INK_NULL_MLOC, reqHdrLoc);
HANDLE_RELEASE(newHttpHdrBuf, INK_NULL_MLOC, newHttpHdrLoc);
/* destroy hdr */
HDR_DESTROY(newHttpHdrBuf, newHttpHdrLoc);
/* destroy mbuffer */
BUFFER_DESTROY(newHttpHdrBuf);
if (INKHttpTxnReenable(pTxn, INK_EVENT_HTTP_CONTINUE) == INK_ERROR) {
LOG_API_ERROR("INKHttpTxnReenable");
}
INKDebug(REQ, "..... exiting handleReadRequest ......\n");
} /* handleReadReadRequest */