Varnish Cache Plus

Bodyaccess

Description

vmod_bodyaccess gives vcl some access to the request body. A common use case is to allow caching of POST requests, where the request body needs to be part of the hash.

Examle VCL

vcl 4.0;
import std;
import bodyaccess;

backend default { .host = "192.0.2.11"; .port = "8080"; }

sub vcl_recv {
	if (req.method == "POST") {
		set req.http.x-method = req.method;
		if (std.cache_req_body(110KB)) {
			set req.http.x-len = bodyaccess.len_req_body();
			set req.http.x-re = bodyaccess.rematch_req_body("Regex");
			bodyaccess.log_req_body("PREFIX:", 3);
		}
	}
	return(hash);
}

sub vcl_hash {
	bodyaccess.hash_req_body();
	return (lookup);
}

sub vcl_backend_fetch {
	set bereq.method = bereq.http.x-method;
}

sub vcl_deliver {
	set resp.http.x-len = req.http.x-len;
	set resp.http.x-re = req.http.x-re;
}

API

Not that the request body must be retrieved before doing any operations on it. It can be buffered using the cache_req_body() function from libvmod_std.

Note that, according to RFC 2616, caching should never happen for PUT, DELETE and POST. However, there are good reasons allow POST requests to some resources and still chache the result. Examples include REST methods that are idempotent.

For this reason, it is only adviced to use these functions on POST requests.

Search for a string in the request body

INT rematch_req_body(PRIV_CALL, STRING re)

  • Returns -1 if an error occurrs.
  • Returns 0 if the request body doesn’t contain the string re.
  • Returns 1 if the request body contains the string re.

Note that the comparison is case sensitive and the request body must be buffered.

Example

	std.cache_req_body(1KB);

	if (bodyaccess.rematch_req_body("FOO") == 1) {
		std.log("is true");
	}

Adding the request body to the hash

VOID hash_req_body()

This adds the (available) request body bytes to the lookup hash key. Note that this function can only be used in vcl_hash and the request body must be buffered for it to work properly.

Example

sub vcl_recv {
	std.cache_req_body(1KB);
}

sub vcl_hash{
	bodyaccess.hash_req_body();
}

Getting the request body length

INT len_req_body()

This returns the request body length, or -1 if an error occurs. The request body must be buffered.

Example

	std.cache_req_body(1KB);
	set req.http.x-len = bodyaccess.len_req_body();

Logging the request body

VOID log_req_body(STRING prefix = "", INT length = 200)

This logs the request body to the VSL, making it available for other components. When logging, it takes an optional prefix and a max line length, so the body could be split up across multiple lines. This is sometimes necessary, as there is a limit to how large a single line can be.

Example

	std.cache_req_body(1KB);
	bodyaccess.log_req_body("PREFIX:", 40);