Ref #3661

Spotted by Flexelint.

The larger the response we hit, the more likely we are to hit an ongoing
fetch and since we buffer transaction logs it can become really tedious
to infer whether the backend transaction may have already been overrun
or not flushed yet. At least, such a heuristic was impossible with a VSL
query until now.

It's a thin wrapper on top of vre_capture() that returns the number of
groups captured during a match.

Now that txt appears in vre.h we need vdef.h anywhere the former is
included. There was one generated file where that wasn't the case.

Closes #3655

And add a bunch of assertions in addition to the implicit ones from
pdiff().

There are other components than the cache process that could benefit
from it, in particular libvcc. The relationship with vas.h is somewhat
unfortunate but that also centralize the Tcheck() logic in pdiff() and
doesn't actually require vas.h unless the macros are used, in which
case it's almost guaranteed that the calling code already included
vas.h in the first place.

The benefits should outweigh the drawbacks.

My absolute bad on this copy-pasta mistake.

Only from a git clone, and only from the root directory, which should
leave alone distcheck and builds from release archives.

Refs #3442
Refs #3661

This parameter allows the user to choose which storage backend / stevedore
that the H/2 receive buffers are allocated from. By default it uses
Transient.

This was found lacking in our H2 implementation. Previously we would have
included any padding bytes in the request body. Possibly it would have
caused errors if there also was a C-L present, or more likely just corrupt
request bodies.

If the client sends nothing but padding bytes and ends up consuming the
entire stream window with no actual request bytes buffered, the request
thread side of things would not send any stream window updates. Handle
this corner case by sending a window update from the session thread.

According to the spec the padding is an 8-bit field, and fields should be
treated as unsigned unless otherwise specified, which it is not for any of
the padding related places. Allow varnishtest to generate padding up to
255 bytes long.

This is the test case that fails if these changes aren't in tree. Note the
commented out rxwinup commands that are necessary for the proper fail mode
when run without the varnishtest window update changes.

With the new request body data handling, Varnish changes behaviour
significantly wrt to stream window updates sent to the client. Window
updates will only be sent once the data is consumed by the client through
the request body VFP handling. Test cases that rely on receiving a window
update to sync the H/2 stream needs to be adopted.

This makes it easier to not have to know exactly when and how many window
updates to expect in a test case.

We have a strict min at the protocol default here. This is because we
don't have the 'use settings only after peer ack' in place yet. If the
value is lower than the protocol default, the very first stream could get
a flow control error.

H2 streams waiting for request body data will timeout after timeout_idle
seconds if no new data on the stream is being received. This will ensure
that individual H2 streams can be reaped if there is no data received from
the peer.