modules/cachectl: incremental pruning, can clear 64k items in one go

lib/cache: cache fixes, use substruct instead of pointer aliasing

fixes potential cache key oob write

layer/pktcache: treat all cache insert errors as errors

daemon/worker: decommit memory every 1000nth pool delete

contrib: ccan/json possible uninitialized use

daemon: allocate worker from pool, cleanup

tests/test_cache: dladdr is broken for local syms

this relies on a lot of things (intrinsic), frame pointer and symbol dynamic symbol table

build: brought back PIC for modules

daemon/worker: keep freelist of mempools for recycling

Merge branch 'build-changes-q2' into faster-request-proc

contrib: use embedded ucw/mempool instead of libknot internals

contrib/ucw: use stdlib alloc routines instead of xmalloc/xfree

contrib: added mempools from libucw

modules/kmemcached: missing documentation, doc cleanup

build: renamed libkresolve => libkres, kresolved => kresd

also some cleanup and version bump to Q2

build: allow library to be built statically

layer/rrcache: rewritten RR merging code

previously a CNAME RR could be merged as a queried type RR, leading to failed cache lookups as ‘expired’

layer/*cache: lookup only on first iteration

layer/iterate: glue may be in ANSWER, cleanup

lib/resolve: do not reelect NS after addr resolution

previously if NS had no A/AAAA records, they we’re looked up in subrequests, after that a new NS was reelected (possibly preferring another unknown), now it stays true to the NS of choice and changes only if it is unuseable

lib/cache: return records that are going to be expired next second

lib/cache: save cache lookup if record is stale and not missing

the cache_peek() api was reworked to return an error code instead, from this the caller can tell whether the record is present (but expired) or missing. this save a secondary CNAME lookup in case the original record was just expired

lib/nsrep: NS reputation cache in addition to RTT cache

this LRU-like cache tracks lame nameservers, unresolvable
nameservers (to not waste resources in trying to resolve them),
and possibly other features (extension support, …)

lib/zonecut: prefetch A/AAAA records from cache

lib/cache: better handling of TXN_OPEN, cleanup

lib/resolve: fix minimized QNAME if zone cut changes

tests: improved array test

Revert "daemon/worker: ring buffer to recycle mempools"

This reverts commit 91a2945e631b673942ffe62992e03913925a63da.

Conflicts:
daemon/worker.h

Merge branch 'ns-rtt-cache'

daemon: cleanup

Merge branch 'master' into ns-rtt-cache

Merge branch 'fix-ns-badboys'

Merge branch 'master' into fix-ns-badboys

tests: cleanup in lru test

generic/array: shot myself to the foot

daemon/worker: ring buffer to recycle mempools

this avoids repetitive allocation/free cycles on load

tests: added missing lru unit test

Merge branch 'dnssec-integration-test'

tests: converting algorithm identifier to number in DS records in .rpl

The parsing of *.rpl files failed on reading DS records because the
algorithm identifier is a string rather than a number.

lib/resolve: faster subrequests zonecut lookup

if a name server is missing address, it requires launching a recursive query to discover it - starting from root
now however it can start from either closest covering zonecut in cache if it isn’t a subdomain of current zone cut, or as a parent of current zone cut

tests/integration: added RTT LRU cache to tests

lib/nsrep: lower bound on rtt, optional throttling

when a NS is in the TIMEOUT, it can’t be autoselected by default but only probed after a successful dice roll - however in some scenarios we’d like to probe timeouting servers more thoroughly

layer/pktcache: fixed shadowed variable, cleanup

lib/cache: improve cache materialization

layer/iterate: cleanup, use compr hints

lib/nsrep: 5% chance of probing for timeouted servers

layer/iterate: mark answers with SOA proof with AA=1

lib: cleanup, lowered default timeout to 3s

lib/resolve: impose limits on NS election iterations

lib/nsrep: probabilistic NS probing strategy

simplified bee foraging strategy, by default each query goes to the most rewarding NS
however with a chance proportional to the NS RTT, a server may be probed even if it isn’t the most rewarding

tests: test_cache with non-global api

tests: avoiding warnings

tests: avoiding warnings

tests: avoiding warnings

layer/rrcache: refuse very short TTLs

prevents pointless caching of TTL={0,1} records

layer/iterate: ignore glueless-but-mandatory NSs

previously the NS address list was wiped out, this prevents them from being added in the first place

layer/iterate: accept REFUSED as an answer

some servers break qname m12n by sending REFUSED, this accepts such answer and requeries with m12n turned off

daemon/engine: enable NS reputation cache by default

tests: cache_test with non-global api

Merge branch 'cache-memcached'

tests: test_cache.c conflict fixed

tests: test cache with new api scheme

lib/nsrep: persistent NS RTT/reputation tracking

score has now meaning of ‘RTT’, maximum RTT is 10s
which is also the penalty for timeout
unknown servers are favorized as 10ms servers to
encourage resolver to try them out, if they contain
unknown glue they are most favourable

generics: added LRU-like lossy hash table

contrib: included murmurhash3 (public domain)

tests: test cache with new api scheme

layer/iterate: do not presume AA=1 is really authoritative

layer/pktcache: do not take TTLMIN into account

Merge branch 'cache-api-noglobal' into cache-memcached-wip

modules: fixed kmemcached after api change

tests: added test for previous case (bad glue, keep suggesting self)

lib/zonecut: check for duplicate address records

generic/pack: support for lookup

Merge branch 'cache-api-noglobal-wip' of gitlab.labs.nic.cz:knot/resolver into cache-api-noglobal-wip

lib\cache: removing of global instance of cache storage api

lib/pktcache: cache intermediate answers as well

the only condition of caching an answer is that it resolves a query and is not already cached
(ok, it must be negative at this point…)

layer/pktcache: fixed max-ttl for packet cache

layer/iterate: ignore bad NS, don’t fail the packet

if an authoritative answer comes and the server responds correctly, but appends out-of-bailiwick NS records, ignore them but resolve the query

lib/iterate: check bad answers missing question

lib/resolve: faster valid NS election

previously it restarted query production for each NS, now it loops until it finds a suitor or bails out

lib/iterate: fixed check for mandatory glue + test

lib/pktcache: mark cached respones as authoritative

this fixes a bug when storing NODATA without SOA,NS or any other ‘authoritative answer’ hint

lib/resolve: invalidate NS than query on loops/failures

modules/stats: fixed yolo counting of edns/dnssec

modules/stats: don't track 'unresolved' when 'servfail' does the same thing

modules/stats: count slow answers (>1000ms)

lib/cache: track inserts

tests: empty rrset (insert); empty owner (materialize)

tests: empty rrset (insert); empty owner (materialize)

build: support versioned dependencies

lib/caches: lookup direct matches only

since the zone cut is looked up after layers now, it
is pointless to search for minimized names from cache,
since this is the same operation as searching for a zone cut

lib/resolve: deferred zone cut lookup

if the query is satisfied from cache, it doesn’t need a zone cut lookup, so it may be deferred until an outbound query is about the be issued.

layer/iterate: fixed ‘current query’ change, accept in-bailiwick ns

since the next CNAME target query was added on top, it replaced
the original ‘current query’, this caused recaching of an answer
if it came from cache (as the query flags have changed)

modules/kmemcached: fixed broken api

modules/graphite: track cache statistics as well

daemon/bindings: added cache.stats() interface

cache: wrapped namedb_t+txn into structure, counters

this prepares cache/txn structures to hold API as well, so we can get
rid of the global api

Merge branch 'kr_cache_insert_lowmem'

tests: simulation of malloc() failure

tests: simulation of malloc() failure