static void
replace_header(INKHttpTxn txnp, INKCont contp)
{
INKMBuffer resp_bufp;
INKMLoc resp_loc;
INKMLoc field_loc;
if (!INKHttpTxnServerRespGet(txnp, &resp_bufp, &resp_loc)) {
INKError("couldn't retrieve server response header.\n");
goto done;
}
field_loc = INKMimeHdrFieldRetrieve(resp_bufp, resp_loc, INK_MIME_FIELD_ACCEPT_RANGES);
if (field_loc == 0) {
/* field was not found */
/* create a new field in the header */
field_loc = INKMimeHdrFieldCreate(resp_bufp, resp_loc);
/* set its name */
INKMimeHdrFieldNameSet(resp_bufp, resp_loc, field_loc, INK_MIME_FIELD_ACCEPT_RANGES, INK_MIME_LEN_ACCEPT_RANGES);
/* set its value */
INKMimeHdrFieldValueInsert(resp_bufp, resp_loc, field_loc, "none", 4, -1);
/* insert it into the header */
INKMimeHdrFieldInsert(resp_bufp, resp_loc, field_loc, -1);
INKHandleMLocRelease(resp_bufp, resp_loc, field_loc);
INKHandleMLocRelease(resp_bufp, INK_NULL_MLOC, resp_loc);
} else {
/* clear the field */
INKMimeHdrFieldValuesClear(resp_bufp, resp_loc, field_loc);
/* set the value to "none" */
INKMimeHdrFieldValueInsert(resp_bufp, resp_loc, field_loc, "none", 4, -1);
INKHandleMLocRelease(resp_bufp, resp_loc, field_loc);
INKHandleMLocRelease(resp_bufp, INK_NULL_MLOC, resp_loc);
}
done:
INKHttpTxnReenable(txnp, INK_EVENT_HTTP_CONTINUE);
}
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;
}
/********************************************************************
* 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;
}
/***********************************************************************
* 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;
}
static void
add_header(INKHttpTxn txnp, INKCont contp)
{
INKMBuffer req_bufp;
INKMLoc req_loc;
INKMLoc field_loc;
INKMLoc next_field_loc;
INKMLoc new_field_loc;
int retval;
if (!INKHttpTxnClientReqGet(txnp, &req_bufp, &req_loc)) {
INKError("[add_header] Error while retrieving client request header\n");
goto done;
}
field_loc = INKMimeHdrFieldGet(hdr_bufp, hdr_loc, 0);
if (new_field_loc == INK_ERROR_PTR) {
INKError("[add_header] Error while getting field");
goto error;
}
/* Loop on our header containing fields to add */
while (field_loc) {
/* First create a new field in the client request header */
new_field_loc = INKMimeHdrFieldCreate(req_bufp, req_loc);
if (new_field_loc == INK_ERROR_PTR) {
INKError("[add_header] Error while creating new field");
INKHandleMLocRelease(hdr_bufp, hdr_loc, field_loc);
break;
}
/* Then copy our new field at this new location */
retval = INKMimeHdrFieldCopy(req_bufp, req_loc, new_field_loc, hdr_bufp, hdr_loc, field_loc);
if (retval == INK_ERROR) {
INKError("[add_header] Error while copying new field");
INKHandleMLocRelease(hdr_bufp, hdr_loc, field_loc);
break;
}
/* Add this field to the Http client request header */
retval = INKMimeHdrFieldAppend(req_bufp, req_loc, new_field_loc);
if (retval == INK_ERROR) {
INKError("[add_header] Error while appending new field");
INKHandleMLocRelease(hdr_bufp, hdr_loc, field_loc);
break;
}
/* We can now release this handle */
INKHandleMLocRelease(req_bufp, req_loc, new_field_loc);
next_field_loc = INKMimeHdrFieldNext(hdr_bufp, hdr_loc, field_loc);
if (next_field_loc == INK_ERROR_PTR) {
INKError("[add_header] Error while getting next field to add");
INKHandleMLocRelease(hdr_bufp, hdr_loc, field_loc);
goto error;
}
INKHandleMLocRelease(hdr_bufp, hdr_loc, field_loc);
field_loc = next_field_loc;
}
error:
INKHandleMLocRelease(req_bufp, INK_NULL_MLOC, req_loc);
done:
INKHttpTxnReenable(txnp, INK_EVENT_HTTP_CONTINUE);
}
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);
}
