int
get_client_req(INKHttpTxn txnp, char **p_url_line, char **p_client_req, int *neg_test_val, int *pin_val)
{
INKMBuffer bufp;
INKReturnCode ret_code;
INKMLoc hdr_loc;
INKMLoc url_loc;
INKMLoc neg_loc;
INKMLoc pin_loc;
INKIOBuffer output_buffer;
INKIOBufferReader reader;
int total_avail;
INKIOBufferBlock block;
const char *block_start;
int block_avail;
char *output_string;
char *url_str;
int url_len;
int output_len;
LOG_SET_FUNCTION_NAME("get_client_req");
*p_url_line = NULL;
*p_client_req = NULL;
*neg_test_val = 0;
*pin_val = 0;
#ifdef DEBUG
if (INKHttpTxnClientReqGet(NULL, &bufp, &hdr_loc) != 0) {
LOG_ERROR_NEG("INKHttpTxnClientReqGet(null, buf, hdr_loc)");
}
if (INKHttpTxnClientReqGet(txnp, NULL, &hdr_loc) != 0) {
LOG_ERROR_NEG("INKHttpTxnClientReqGet(txnp, null, hdr_loc)");
}
if (INKHttpTxnClientReqGet(txnp, &bufp, NULL) != 0) {
LOG_ERROR_NEG("INKHttpTxnClientReqGet(txnp, buf, null)");
}
#endif
if (!INKHttpTxnClientReqGet(txnp, &bufp, &hdr_loc)) {
LOG_ERROR_AND_RETURN("INKHttpTxnClientReqGet");
}
if ((url_loc = INKHttpHdrUrlGet(bufp, hdr_loc)) == INK_ERROR_PTR) {
INKHandleMLocRelease(bufp, INK_NULL_MLOC, hdr_loc);
LOG_ERROR_AND_RETURN("INKHttpHdrUrlGet");
}
#ifdef DEBUG
if (INKUrlStringGet(NULL, url_loc, &url_len) != INK_ERROR_PTR) {
LOG_ERROR_NEG("INKUrlStringGet(NULL, url_loc, &int)");
}
if (INKUrlStringGet(bufp, NULL, &url_len) != INK_ERROR_PTR) {
LOG_ERROR_NEG("INKUrlStringGet(bufp, NULL, &int)");
}
#endif
if ((url_str = INKUrlStringGet(bufp, url_loc, &url_len)) == INK_ERROR_PTR) {
INKHandleMLocRelease(bufp, hdr_loc, url_loc);
INKHandleMLocRelease(bufp, INK_NULL_MLOC, hdr_loc);
LOG_ERROR_AND_RETURN("INKUrlStringGet");
}
if (INKHandleMLocRelease(bufp, hdr_loc, url_loc) == INK_ERROR) {
INKfree(url_str);
INKHandleMLocRelease(bufp, INK_NULL_MLOC, hdr_loc);
LOG_ERROR_AND_RETURN("INKHandleMLocRelease");
}
url_str[url_len] = '\0';
*p_url_line = url_str;
if ((output_buffer = INKIOBufferCreate()) == INK_ERROR_PTR) {
INKfree(url_str);
INKHandleMLocRelease(bufp, INK_NULL_MLOC, hdr_loc);
LOG_ERROR_AND_RETURN("INKIOBufferCreate");
}
#ifdef DEBUG
if (INKIOBufferReaderAlloc(NULL) != INK_ERROR_PTR) {
LOG_ERROR_NEG("INKIOBufferReaderAlloc(NULL)");
}
#endif
if ((reader = INKIOBufferReaderAlloc(output_buffer)) == INK_ERROR_PTR) {
INKfree(url_str);
INKHandleMLocRelease(bufp, INK_NULL_MLOC, hdr_loc);
INKIOBufferDestroy(output_buffer);
LOG_ERROR_AND_RETURN("INKIOBufferReaderAlloc");
}
/* This will print just MIMEFields and not
the http request line */
if (INKMimeHdrPrint(bufp, hdr_loc, output_buffer) == INK_ERROR) {
INKfree(url_str);
INKHandleMLocRelease(bufp, INK_NULL_MLOC, hdr_loc);
INKIOBufferDestroy(output_buffer);
LOG_ERROR_AND_RETURN("INKMimeHdrPrint");
}
if ((neg_loc = INKMimeHdrFieldFind(bufp, hdr_loc, "CacheTester-HostNameSet", -1)) == INK_ERROR_PTR) {
INKfree(url_str);
INKHandleMLocRelease(bufp, INK_NULL_MLOC, hdr_loc);
INKIOBufferDestroy(output_buffer);
LOG_ERROR_AND_RETURN("INKMimeHdrFieldFind");
}
if (neg_loc != NULL) {
ret_code = INKMimeHdrFieldValueIntGet(bufp, hdr_loc, neg_loc, 0, neg_test_val);
if (ret_code == INK_ERROR) {
INKfree(url_str);
INKHandleMLocRelease(bufp, hdr_loc, neg_loc);
INKHandleMLocRelease(bufp, INK_NULL_MLOC, hdr_loc);
INKIOBufferDestroy(output_buffer);
LOG_ERROR_AND_RETURN("INKMimeHdrFieldValueIntGet");
}
if (INKHandleMLocRelease(bufp, hdr_loc, neg_loc) == INK_ERROR) {
INKfree(url_str);
INKHandleMLocRelease(bufp, INK_NULL_MLOC, hdr_loc);
INKIOBufferDestroy(output_buffer);
LOG_ERROR_AND_RETURN("INKHandleMLocRelease");
}
}
if ((pin_loc = INKMimeHdrFieldFind(bufp, hdr_loc, "CacheTester-Pin", -1)) == INK_ERROR_PTR) {
INKfree(url_str);
INKHandleMLocRelease(bufp, INK_NULL_MLOC, hdr_loc);
INKIOBufferDestroy(output_buffer);
LOG_ERROR_AND_RETURN("INKMimeHdrFieldFind");
}
if (pin_loc != NULL) {
ret_code = INKMimeHdrFieldValueIntGet(bufp, hdr_loc, pin_loc, 0, pin_val);
if (ret_code == INK_ERROR) {
INKfree(url_str);
INKHandleMLocRelease(bufp, hdr_loc, pin_loc);
INKHandleMLocRelease(bufp, INK_NULL_MLOC, hdr_loc);
INKIOBufferDestroy(output_buffer);
LOG_ERROR_AND_RETURN("INKMimeHdrFieldValueIntGet");
}
if (INKHandleMLocRelease(bufp, hdr_loc, pin_loc) == INK_ERROR) {
INKfree(url_str);
INKHandleMLocRelease(bufp, INK_NULL_MLOC, hdr_loc);
INKIOBufferDestroy(output_buffer);
LOG_ERROR_AND_RETURN("INKHandleMLocRelease");
}
}
if (INKHandleMLocRelease(bufp, INK_NULL_MLOC, hdr_loc) == INK_ERROR) {
INKfree(url_str);
INKIOBufferDestroy(output_buffer);
LOG_ERROR_AND_RETURN("INKHandleMLocRelease");
}
/* 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 */
if ((total_avail = INKIOBufferReaderAvail(reader)) == INK_ERROR) {
INKfree(url_str);
INKIOBufferDestroy(output_buffer);
LOG_ERROR_AND_RETURN("INKIOBufferReaderAvail");
}
#ifdef DEBUG
if (INKIOBufferReaderAvail(NULL) != INK_ERROR) {
LOG_ERROR_NEG("INKIOBufferReaderAvail(NULL)");
}
#endif
/* 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);
if (block == INK_ERROR_PTR) {
INKfree(url_str);
INKfree(output_string);
LOG_ERROR_AND_RETURN("INKIOBufferReaderStart");
}
#ifdef DEBUG
if (INKIOBufferReaderStart(NULL) != INK_ERROR_PTR) {
LOG_ERROR_NEG("INKIOBufferReaderStart(NULL)");
}
if (INKIOBufferBlockReadStart(NULL, reader, &block_avail) != INK_ERROR_PTR) {
LOG_ERROR_NEG("INKIOBufferBlockReadStart(null, reader, &int)");
}
if (INKIOBufferBlockReadStart(block, NULL, &block_avail) != INK_ERROR_PTR) {
LOG_ERROR_NEG("INKIOBufferBlockReadStart(block, null, &int)");
}
#endif
while (block) {
block_start = INKIOBufferBlockReadStart(block, reader, &block_avail);
if (block_start == INK_ERROR_PTR) {
INKfree(url_str);
INKfree(output_string);
LOG_ERROR_AND_RETURN("INKIOBufferBlockReadStart");
}
/* FC paranoia: make sure we don't copy more bytes than buffer size can handle */
if ((output_len + block_avail) > total_avail) {
INKfree(url_str);
INKfree(output_string);
LOG_ERROR_AND_RETURN("More bytes than expected in IOBuffer");
}
/* 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) {
INKfree(url_str);
INKfree(output_string);
LOG_ERROR_AND_RETURN("INKIOBufferReaderConsume");
}
#ifdef DEBUG
if (INKIOBufferReaderConsume(NULL, block_avail) != INK_ERROR) {
LOG_ERROR_NEG("INKIOBufferReaderConsume(null, int)");
}
if (INKIOBufferReaderConsume(reader, -1) != INK_ERROR) {
LOG_ERROR_NEG("INKIOBufferReaderConsume(reader, -1)");
}
#endif
/* Get the next block now that we've consumed the
data off the last block */
if ((block = INKIOBufferReaderStart(reader)) == INK_ERROR_PTR) {
INKfree(url_str);
INKfree(output_string);
LOG_ERROR_AND_RETURN("INKIOBufferReaderStart");
}
}
/* 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_ERROR) {
INKfree(url_str);
INKfree(output_string);
LOG_ERROR_AND_RETURN("INKIOBufferReaderFree");
}
#ifdef DEBUG
if (INKIOBufferReaderFree(NULL) != INK_ERROR) {
LOG_ERROR_NEG("INKIOBufferReaderFree(NULL)");
}
#endif
if (INKIOBufferDestroy(output_buffer) == INK_ERROR) {
INKfree(url_str);
INKfree(output_string);
LOG_ERROR_AND_RETURN("INKIOBufferDestroy");
}
*p_client_req = output_string;
return 1;
}
int
insert_in_response(INKHttpTxn txnp, char *result_val)
{
INKMBuffer resp_bufp;
INKMLoc resp_loc;
INKMLoc field_loc;
LOG_SET_FUNCTION_NAME("insert_in_response");
#ifdef DEBUG
if (INKHttpTxnClientRespGet(NULL, &resp_bufp, &resp_loc) != 0) {
LOG_ERROR_NEG("INKHttpTxnClientRespGet(null, buf, hdr_loc)");
}
if (INKHttpTxnClientRespGet(txnp, NULL, &resp_loc) != 0) {
LOG_ERROR_NEG("INKHttpTxnClientRespGet(txnp, null, hdr_loc)");
}
if (INKHttpTxnClientRespGet(txnp, &resp_bufp, NULL) != 0) {
LOG_ERROR_NEG("INKHttpTxnClientRespGet(txnp, buf, null)");
}
#endif
if (!INKHttpTxnClientRespGet(txnp, &resp_bufp, &resp_loc)) {
LOG_ERROR_AND_RETURN("INKHttpTxnClientRespGet");
}
/* create a new field in the response header */
if ((field_loc = INKMimeHdrFieldCreate(resp_bufp, resp_loc)) == INK_ERROR_PTR) {
INKHandleMLocRelease(resp_bufp, INK_NULL_MLOC, resp_loc);
LOG_ERROR_AND_RETURN("INKMimeHdrFieldCreate");
}
/* set its name */
if (INKMimeHdrFieldNameSet(resp_bufp, resp_loc, field_loc, "CacheTester-Result", 18) == INK_ERROR) {
INKHandleMLocRelease(resp_bufp, resp_loc, field_loc);
INKHandleMLocRelease(resp_bufp, INK_NULL_MLOC, resp_loc);
LOG_ERROR_AND_RETURN("INKMimeHdrFieldNameSet");
}
/* set its value */
if (INKMimeHdrFieldValueStringInsert(resp_bufp, resp_loc, field_loc, -1, result_val, strlen(result_val)) == INK_ERROR) {
INKHandleMLocRelease(resp_bufp, resp_loc, field_loc);
INKHandleMLocRelease(resp_bufp, INK_NULL_MLOC, resp_loc);
LOG_ERROR_AND_RETURN("INKMimeHdrFieldValueIntInsert");
}
/* insert it into the header */
if (INKMimeHdrFieldAppend(resp_bufp, resp_loc, field_loc) == INK_ERROR) {
INKHandleMLocRelease(resp_bufp, resp_loc, field_loc);
INKHandleMLocRelease(resp_bufp, INK_NULL_MLOC, resp_loc);
LOG_ERROR_AND_RETURN("INKMimeHdrFieldAppend");
}
if (INKHandleMLocRelease(resp_bufp, resp_loc, field_loc) == INK_ERROR) {
INKHandleMLocRelease(resp_bufp, INK_NULL_MLOC, resp_loc);
LOG_ERROR_AND_RETURN("INKHandleMLocRelease");
}
if (INKHandleMLocRelease(resp_bufp, INK_NULL_MLOC, resp_loc) == INK_ERROR) {
LOG_ERROR_AND_RETURN("INKHandleMLocRelease");
}
return 1;
}
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;
}
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;
}
/***********************************************************************
* Get the server ip and request method in the client request. Get the
* next hop ip from the server response.
* Create a new http header field MY_HDR in the server response and
* insert server ip, request method and next hop ip into the field as
* field values.
***********************************************************************/
static int
handle_response_hdr(INKCont contp, INKHttpTxn txnp)
{
LOG_SET_FUNCTION_NAME("handle_response_hdr");
INKMBuffer resp_bufp;
INKMLoc resp_loc = NULL;
INKMLoc field_loc = NULL;
unsigned int next_hop_ip = 0;
unsigned int server_ip = 0;
const char *request_method = NULL;
char *r_method = NULL;
int length;
INKMBuffer req_bufp;
INKMLoc req_loc = NULL;
int incoming_port = 0, port = 0;
char *hostname = NULL;
int ret_value = -1;
/* negative test */
#ifdef DEBUG
if (INKHttpTxnServerIPGet(NULL) != 0)
LOG_ERROR_NEG("INKHttpTxnServerIPGet");
if (INKHttpTxnNextHopIPGet(NULL) != 0)
LOG_ERROR_NEG("INKHttpTxnNextHopIPGet");
if (INKHttpTxnParentProxyGet(NULL, &hostname, &port) != INK_ERROR)
LOG_ERROR_NEG("INKHttpTxnParentProxyGet");
#endif
/* get the server ip */
if ((server_ip = INKHttpTxnServerIPGet(txnp)) == 0)
LOG_ERROR_AND_RETURN("INKHttpTxnServerIPGet");
/* get the request method */
if (!INKHttpTxnServerReqGet(txnp, &req_bufp, &req_loc))
LOG_ERROR_AND_RETURN("INKHttpTxnServerReqGet");
if ((request_method = INKHttpHdrMethodGet(req_bufp, req_loc, &length)) == INK_ERROR_PTR || request_method == NULL)
LOG_ERROR_AND_CLEANUP("INKHttpHdrMethodGet");
r_method = INKstrndup(request_method, length);
/* get the next hop ip */
if ((next_hop_ip = INKHttpTxnNextHopIPGet(txnp)) == INK_ERROR)
LOG_ERROR_AND_CLEANUP("INKHttpTxnNextHopIPGet");
/* get the client incoming port */
if ((incoming_port = INKHttpTxnClientIncomingPortGet(txnp)) == INK_ERROR)
LOG_ERROR_AND_CLEANUP("INKHttpTxnClientIncomingPortGet");
/* get the parent proxy */
if (INKHttpTxnParentProxyGet(txnp, &hostname, &port) == INK_ERROR)
LOG_ERROR_AND_CLEANUP("INKHttpTxnParentProxyGet");
/* If no parent defined in records.config, set hostname to NULL and port to -1 */
if (hostname == NULL) {
hostname = "NULL";
port = -1;
}
/* retrieve the server response header */
if (!INKHttpTxnServerRespGet(txnp, &resp_bufp, &resp_loc))
LOG_ERROR_AND_CLEANUP("INKHttpTxnServerRespGet");
/* create and insert into hdr a new mime header field */
if ((field_loc = INKMimeHdrFieldCreate(resp_bufp, resp_loc)) == INK_ERROR_PTR || field_loc == NULL)
LOG_ERROR_AND_CLEANUP("INKMimeHdrFieldCreate");
if (INKMimeHdrFieldAppend(resp_bufp, resp_loc, field_loc) == INK_ERROR)
LOG_ERROR_AND_CLEANUP("INKMimeHdrFieldAppend");
if (INKMimeHdrFieldNameSet(resp_bufp, resp_loc, field_loc, MY_HDR, strlen(MY_HDR)) == INK_ERROR)
LOG_ERROR_AND_CLEANUP("INKMimeHdrFieldNameSet");
/* Add value to the new mime header field */
if (INKMimeHdrFieldValueStringInsert(resp_bufp, resp_loc, field_loc, -1, r_method, strlen(r_method)) == INK_ERROR)
LOG_ERROR_AND_CLEANUP("INKMimeHdrFieldValueStringInsert");
if (INKMimeHdrFieldValueUintInsert(resp_bufp, resp_loc, field_loc, -1, server_ip) == INK_ERROR)
LOG_ERROR_AND_CLEANUP("INKMimeHdrFieldValueUintInsert");
if (INKMimeHdrFieldValueUintInsert(resp_bufp, resp_loc, field_loc, -1, next_hop_ip) == INK_ERROR)
LOG_ERROR_AND_CLEANUP("INKMimeHdrFieldValueUintInsert");
if (INKMimeHdrFieldValueIntInsert(resp_bufp, resp_loc, field_loc, -1, incoming_port) == INK_ERROR)
LOG_ERROR_AND_CLEANUP("INKMimeHdrFieldValueIntInsert");
if (INKMimeHdrFieldValueIntInsert(resp_bufp, resp_loc, field_loc, -1, port) == INK_ERROR)
LOG_ERROR_AND_CLEANUP("INKMimeHdrFieldValueIntInsert");
/* success */
ret_value = 0;
Lcleanup:
if (VALID_POINTER(r_method))
INKfree(r_method);
/* negative test for INKHandleStringRelease */
#ifdef DEBUG
if (INKHandleStringRelease(NULL, req_loc, request_method) != INK_ERROR) {
LOG_ERROR_NEG("INKHandleStringRelease");
}
#endif
/* release the buffer handles */
if (VALID_POINTER(request_method))
INKHandleStringRelease(req_bufp, req_loc, request_method);
if (VALID_POINTER(req_loc))
INKHandleMLocRelease(req_bufp, INK_NULL_MLOC, req_loc);
/* free the handles and continuation data */
if (VALID_POINTER(field_loc))
INKHandleMLocRelease(resp_bufp, resp_loc, field_loc);
if (VALID_POINTER(resp_loc))
INKHandleMLocRelease(resp_bufp, INK_NULL_MLOC, resp_loc);
return ret_value;
}
