GitLab

The problem was the mm_malloc() typo :-/ so allocation was going through
malloc() instead of the packet's allocator (always memory pool ATM).
I added mm_free() for better correctness anyway.

- session: data length would be difference between start and end
  indices, but the function is unused so why even have it?

When decoding large packets, gnutls gives the application chunks
of size 16kb. So that tls session wirebuffer must be at least
KNOT_WIRE_MAX_PKTSIZE + 16kb.  (message re-formatted by vcunat)

Fixes #424.

Fixes #424.

There's only very little that makes sense to "inline".
My understanding that it makes sense to have such heavier
optimization only for the case when no verbose logging is done.
This might actually help due to decreasing code size.

It's about a hundred of them.  The price is making two printf calls
instead of one.  That seems acceptable; these warning tools can help us
in future, and the likelihood of mixing outputs from different processes
seems relatively small.

Function pointers and void* probably can't well interact
when using -Wpedantic.

There's still an unresolved "problem" with QRVERBOSE getting
empty variadic list sometimes, and I can't see a good way around that.

To simplify this, some of the zonecut API was generalized
(API+ABI break).  Detected by -Wpedantic.

Detected by -Wpedantic

There seems no potential for modifying this one.

This allows changing of secret in the checkout layer.

The checkout layer was moved to where upstream address is known, but
before outbound message is sent (or connected to upstream).
The reason is to allow checkout layer to block outbound queries
without wasting time waiting for connect.

We had 35 reports, now we'll have just 7
and mostly in code that's not ours (contrib/*).

... and avoid a scan-build error.

Also simplify l_ffi_deinit().

Again, it's just a mechanical change,
looking at occurences of the identifiers.

It's just a few lines apart.  It's been generating lots of noise
in CI lint:clang-scan-build.

This fixes a case when inserting into LRU, and the entry for given
key exists, but has allocated smaller value than what's requested.

Sometimes it's useful to express that pointed-to memory is constant,
and free-like functions then just cause extra unreadability.

It's more efficient for some our use cases,
and hopefully also more idiomatic.