static int
transformable(TSHttpTxn txnp)
{
/*
* We are only interested in transforming "200 OK" responses.
*/
TSMBuffer bufp;
TSMLoc hdr_loc;
TSHttpStatus resp_status;
int retv;
TSDebug("null-transform", "Entering transformable()");
TSHttpTxnServerRespGet(txnp, &bufp, &hdr_loc);
resp_status = TSHttpHdrStatusGet(bufp, hdr_loc);
retv = (resp_status == TS_HTTP_STATUS_OK);
if (TSHandleMLocRelease(bufp, TS_NULL_MLOC, hdr_loc) == TS_ERROR) {
TSError("[null-transform] Error releasing MLOC while checking " "header status\n");
}
TSDebug("null-transform", "Exiting transformable with return %d", retv);
return retv;
}
//响应添加报文头
TSReturnCode StaSerRespMimeHdrFieldAppend(TSHttpTxn txnp,char *name,int name_length,char *value,int value_len)
{
TSMBuffer bufp;
TSMLoc hdr_loc;
TSMLoc field_loc;
if (TSHttpTxnServerRespGet(txnp, &bufp, &hdr_loc) != TS_SUCCESS) {
return TS_ERROR;
}
field_loc = TSMimeHdrFieldFind(bufp, hdr_loc, name, name_length);
if(field_loc != TS_NULL_MLOC){
TSMimeHdrFieldValuesClear(bufp, hdr_loc, field_loc);
TSMimeHdrFieldValueStringInsert(bufp, hdr_loc, field_loc, -1, value, value_len);
TSHandleMLocRelease(bufp, hdr_loc, field_loc);
}else{
if (TSMimeHdrFieldCreate(bufp, hdr_loc, &field_loc) != TS_SUCCESS) {
return TS_ERROR;
}
TSMimeHdrFieldAppend(bufp, hdr_loc, field_loc);
TSMimeHdrFieldValuesClear(bufp, hdr_loc, field_loc);
TSMimeHdrFieldNameSet(bufp, hdr_loc, field_loc, name, name_length);
TSMimeHdrFieldValueStringInsert(bufp, hdr_loc, field_loc, -1, value, value_len);
TSHandleMLocRelease(bufp, hdr_loc, field_loc);
}
TSHandleMLocRelease(bufp, TS_NULL_MLOC, hdr_loc);
return TS_SUCCESS;
}
static int
server_response_ok(TSHttpTxn txnp)
{
/* Is the response the server sent OK for transformation. This is
* a good place to check the server's response to see if it is
* transformable. In this example, we will transform only "200 OK"
* responses.
*/
TSMBuffer bufp;
TSMLoc hdr_loc;
TSHttpStatus resp_status;
if (TSHttpTxnServerRespGet(txnp, &bufp, &hdr_loc) != TS_SUCCESS) {
TSError("Unable to get handle to Server Response");
return 0;
}
resp_status = TSHttpHdrStatusGet(bufp, hdr_loc);
if (TS_HTTP_STATUS_OK == resp_status) {
if (TSHandleMLocRelease(bufp, TS_NULL_MLOC, hdr_loc) != TS_SUCCESS) {
TSError("Unable to release handle to server request");
}
return 1;
} else {
if (TSHandleMLocRelease(bufp, TS_NULL_MLOC, hdr_loc) != TS_SUCCESS) {
TSError("Unable to release handle to server request");
}
return 0;
}
}
//获取源服务器响应的状态
TSHttpStatus StaServerRespStatusGet(TSHttpTxn txnp)
{
TSMBuffer resp_bufp;
TSMLoc resp_loc;
TSHttpStatus resp_status = TS_HTTP_STATUS_NONE;
if (TSHttpTxnServerRespGet(txnp, &resp_bufp, &resp_loc) != TS_SUCCESS) {
return TS_HTTP_STATUS_NONE;
}
resp_status = TSHttpHdrStatusGet(resp_bufp, resp_loc);
TSHandleMLocRelease(resp_bufp, TS_NULL_MLOC, resp_loc);
return resp_status;
}
//设置源服务器响应的状态
TSReturnCode StaServerRespStatusSet(TSHttpTxn txnp,TSHttpStatus status)
{
TSMBuffer resp_bufp;
TSMLoc resp_loc;
TSReturnCode ret;
if (TSHttpTxnServerRespGet(txnp, &resp_bufp, &resp_loc) != TS_SUCCESS) {
return TS_ERROR;
}
ret = TSHttpHdrStatusSet(resp_bufp, resp_loc, status);
TSHandleMLocRelease(resp_bufp, TS_NULL_MLOC, resp_loc);
return ret;
}
//响应删除报文头
TSReturnCode StaSerRespMimeHdrFieldDestroy(TSHttpTxn txnp,char *name,int length)
{
TSMBuffer bufp;
TSMLoc hdr_loc;
TSMLoc field_loc;
TSReturnCode ret = TS_ERROR;
if (TSHttpTxnServerRespGet(txnp, &bufp, &hdr_loc) != TS_SUCCESS) {
return TS_ERROR;
}
field_loc = TSMimeHdrFieldFind(bufp, hdr_loc, name, length);
if(field_loc != TS_NULL_MLOC)
{
ret = TSMimeHdrFieldDestroy(bufp,hdr_loc,field_loc);
TSHandleMLocRelease(bufp, hdr_loc, field_loc);
}
TSHandleMLocRelease(bufp, TS_NULL_MLOC, hdr_loc);
return ret;
}
/*-------------------------------------------------------------------------
transformable
Determine if the current transaction should be transformed or not
Input:
txnp current transaction
Output :
Return Value:
1 if transformable
0 if not
-------------------------------------------------------------------------*/
static int
transformable(TSHttpTxn txnp)
{
/* We are only interested in transforming "200 OK" responses
with a Content-Type: text/ header and with X-Psi header */
TSMBuffer bufp;
TSMLoc hdr_loc, field_loc;
TSHttpStatus resp_status;
const char *value;
TSHttpTxnServerRespGet(txnp, &bufp, &hdr_loc);
resp_status = TSHttpHdrStatusGet(bufp, hdr_loc);
if (resp_status != TS_HTTP_STATUS_OK) {
TSHandleMLocRelease(bufp, TS_NULL_MLOC, hdr_loc);
return 0;
}
field_loc = TSMimeHdrFieldFind(bufp, hdr_loc, TS_MIME_FIELD_CONTENT_TYPE, -1);
if (field_loc == TS_NULL_MLOC) {
TSError("[transformable] Error while searching Content-Type field");
TSHandleMLocRelease(bufp, TS_NULL_MLOC, hdr_loc);
return 0;
}
value = TSMimeHdrFieldValueStringGet(bufp, hdr_loc, field_loc, 0, NULL);
if ((value == NULL) || (strncasecmp(value, "text/", sizeof("text/") - 1) != 0)) {
TSHandleMLocRelease(bufp, hdr_loc, field_loc);
TSHandleMLocRelease(bufp, TS_NULL_MLOC, hdr_loc);
return 0;
}
TSHandleMLocRelease(bufp, hdr_loc, field_loc);
field_loc = TSMimeHdrFieldFind(bufp, hdr_loc, MIME_FIELD_XPSI, -1);
TSHandleMLocRelease(bufp, hdr_loc, field_loc);
TSHandleMLocRelease(bufp, TS_NULL_MLOC, hdr_loc);
return 1;
}
static void
replace_header(TSHttpTxn txnp)
{
TSMBuffer resp_bufp;
TSMLoc resp_loc;
TSMLoc field_loc;
if (TSHttpTxnServerRespGet(txnp, &resp_bufp, &resp_loc) != TS_SUCCESS) {
TSError("couldn't retrieve server response header.\n");
goto done;
}
field_loc = TSMimeHdrFieldFind(resp_bufp, resp_loc, TS_MIME_FIELD_ACCEPT_RANGES, TS_MIME_LEN_ACCEPT_RANGES);
if (field_loc == TS_NULL_MLOC) {
/* field was not found */
/* create a new field in the header */
TSMimeHdrFieldCreate(resp_bufp, resp_loc, &field_loc); /* Probably should check for errors. */
/* set its name */
TSMimeHdrFieldNameSet(resp_bufp, resp_loc, field_loc, TS_MIME_FIELD_ACCEPT_RANGES, TS_MIME_LEN_ACCEPT_RANGES);
/* set its value */
TSMimeHdrFieldValueAppend(resp_bufp, resp_loc, field_loc, -1, "none", 4);
/* insert it into the header */
TSMimeHdrFieldAppend(resp_bufp, resp_loc, field_loc);
TSHandleMLocRelease(resp_bufp, resp_loc, field_loc);
TSHandleMLocRelease(resp_bufp, TS_NULL_MLOC, resp_loc);
} else {
/* clear the field */
TSMimeHdrFieldValuesClear(resp_bufp, resp_loc, field_loc);
/* set the value to "none" */
TSMimeHdrFieldValueStringInsert(resp_bufp, resp_loc, field_loc, -1, "none", 4);
TSHandleMLocRelease(resp_bufp, resp_loc, field_loc);
TSHandleMLocRelease(resp_bufp, TS_NULL_MLOC, resp_loc);
}
done:
TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
}
static void
modify_header(TSHttpTxn txnp)
{
TSMBuffer resp_bufp;
TSMBuffer cached_bufp;
TSMLoc resp_loc;
TSMLoc cached_loc;
TSHttpStatus resp_status;
TSMLoc new_field_loc;
TSMLoc cached_field_loc;
time_t recvd_time;
const char *chkptr;
int chklength;
int num_refreshes = 0;
if (!init_buffer_status)
return; /* caller reenables */
if (TSHttpTxnServerRespGet(txnp, &resp_bufp, &resp_loc) != TS_SUCCESS) {
TSError("couldn't retrieve server response header\n");
return; /* caller reenables */
}
/* TSqa06246/TSqa06144 */
resp_status = TSHttpHdrStatusGet(resp_bufp, resp_loc);
if (TS_HTTP_STATUS_OK == resp_status) {
TSDebug("resphdr", "Processing 200 OK");
TSMimeHdrFieldCreate(resp_bufp, resp_loc, &new_field_loc); /* Probably should check for errors */
TSDebug("resphdr", "Created new resp field with loc %p", new_field_loc);
/* copy name/values created at init
* ( "x-num-served-from-cache" ) : ( "0" )
*/
TSMimeHdrFieldCopy(resp_bufp, resp_loc, new_field_loc, hdr_bufp, hdr_loc, field_loc);
/*********** Unclear why this is needed **************/
TSMimeHdrFieldAppend(resp_bufp, resp_loc, new_field_loc);
/* Cache-Control: Public */
TSMimeHdrFieldCreate(resp_bufp, resp_loc, &new_field_loc); /* Probably should check for errors */
TSDebug("resphdr", "Created new resp field with loc %p", new_field_loc);
TSMimeHdrFieldAppend(resp_bufp, resp_loc, new_field_loc);
TSMimeHdrFieldNameSet(resp_bufp, resp_loc, new_field_loc, TS_MIME_FIELD_CACHE_CONTROL, TS_MIME_LEN_CACHE_CONTROL);
TSMimeHdrFieldValueStringInsert(resp_bufp, resp_loc, new_field_loc, -1, TS_HTTP_VALUE_PUBLIC, TS_HTTP_LEN_PUBLIC);
/*
* mimehdr2_name = TSstrdup( "x-date-200-recvd" ) : CurrentDateTime
*/
TSMimeHdrFieldCreate(resp_bufp, resp_loc, &new_field_loc); /* Probably should check for errors */
TSDebug("resphdr", "Created new resp field with loc %p", new_field_loc);
TSMimeHdrFieldAppend(resp_bufp, resp_loc, new_field_loc);
TSMimeHdrFieldNameSet(resp_bufp, resp_loc, new_field_loc, mimehdr2_name, strlen(mimehdr2_name));
recvd_time = time(NULL);
TSMimeHdrFieldValueDateInsert(resp_bufp, resp_loc, new_field_loc, recvd_time);
TSHandleMLocRelease(resp_bufp, resp_loc, new_field_loc);
TSHandleMLocRelease(resp_bufp, TS_NULL_MLOC, resp_loc);
} else if (TS_HTTP_STATUS_NOT_MODIFIED == resp_status) {
TSDebug("resphdr", "Processing 304 Not Modified");
/* N.B.: Protect writes to data (hash on URL + mutex: (ies)) */
/* Get the cached HTTP header */
if (TSHttpTxnCachedRespGet(txnp, &cached_bufp, &cached_loc) != TS_SUCCESS) {
TSError("STATUS 304, TSHttpTxnCachedRespGet():");
TSError("couldn't retrieve cached response header\n");
TSHandleMLocRelease(resp_bufp, TS_NULL_MLOC, resp_loc);
return; /* Caller reenables */
}
/* Get the cached MIME field name for this HTTP header */
cached_field_loc = TSMimeHdrFieldFind(cached_bufp, cached_loc, (const char *)mimehdr1_name, strlen(mimehdr1_name));
if (TS_NULL_MLOC == cached_field_loc) {
TSError("Can't find header %s in cached document", mimehdr1_name);
TSHandleMLocRelease(resp_bufp, TS_NULL_MLOC, resp_loc);
TSHandleMLocRelease(cached_bufp, TS_NULL_MLOC, cached_loc);
return; /* Caller reenables */
}
/* Get the cached MIME value for this name in this HTTP header */
chkptr = TSMimeHdrFieldValueStringGet(cached_bufp, cached_loc, cached_field_loc, -1, &chklength);
if (NULL == chkptr || !chklength) {
TSError("Could not find value for cached MIME field name %s", mimehdr1_name);
TSHandleMLocRelease(resp_bufp, TS_NULL_MLOC, resp_loc);
TSHandleMLocRelease(cached_bufp, TS_NULL_MLOC, cached_loc);
TSHandleMLocRelease(cached_bufp, cached_loc, cached_field_loc);
return; /* Caller reenables */
}
TSDebug("resphdr", "Header field value is %s, with length %d", chkptr, chklength);
/* Get the cached MIME value for this name in this HTTP header */
/*
TSMimeHdrFieldValueUintGet(cached_bufp, cached_loc, cached_field_loc, 0, &num_refreshes);
TSDebug("resphdr",
"Cached header shows %d refreshes so far", num_refreshes );
num_refreshes++ ;
*/
/* txn origin server response for this transaction stored
* in resp_bufp, resp_loc
*
* Create a new MIME field/value. Cached value has been incremented.
* Insert new MIME field/value into the server response buffer,
* allow HTTP processing to continue. This will update
* (indirectly invalidates) the cached HTTP headers MIME field.
* It is apparently not necessary to update all of the MIME fields
* in the in-process response in order to have the cached response
* become invalid.
*/
TSMimeHdrFieldCreate(resp_bufp, resp_loc, &new_field_loc); /* Probaby should check for errrors */
/* mimehdr1_name : TSstrdup( "x-num-served-from-cache" ) ; */
TSMimeHdrFieldAppend(resp_bufp, resp_loc, new_field_loc);
TSMimeHdrFieldNameSet(resp_bufp, resp_loc, new_field_loc, mimehdr1_name, strlen(mimehdr1_name));
TSMimeHdrFieldValueUintInsert(resp_bufp, resp_loc, new_field_loc, -1, num_refreshes);
TSHandleMLocRelease(resp_bufp, resp_loc, new_field_loc);
TSHandleMLocRelease(cached_bufp, cached_loc, cached_field_loc);
TSHandleMLocRelease(cached_bufp, TS_NULL_MLOC, cached_loc);
TSHandleMLocRelease(resp_bufp, TS_NULL_MLOC, resp_loc);
} else {
TSDebug("resphdr", "other response code %d", resp_status);
}
/*
* Additional 200/304 processing can go here, if so desired.
*/
/* Caller reneables */
}
