Karel Slaný authored 8 years ago and Ondřej Surý committed 8 years ago

The control structure is part of the resolver context.

* in the begin() layer, the incoming query is
  exposed as req->qsource.packet, it is invalidated
  after begin() and should not be modified
* the destination address (local interface) is
  also tracked for filtering purposes

during the consume step, the information about
upstream authoritative (address and current rtt)
is exposed in the request structure, just like
information about current query

breathe failed to process the typedef thinking
the macro expansion was a function pointer

this is not going to be backwards compatible change, but it will be the first tagged libknot release sufficient for resolver

* PIE,RELRO+NOW and other security features enabled
* support for both static/dynamic builds with BUILDMODE
* dynamic library is ABI-versioned, starting at 1
* pkg-config file is installed

as the libknot packet interface disallows out-of-order packet
writes, authority and additional records must be written after
the answer is complete; records in the rr arrays will be written to final answer during finalization

current processed query is always in `request->current_query`

the selected address is now an array with selection, caller can then send the same query to multiple offered targets

refs #35

config:
trust_anchors.negative = { ‘bad.cz’, ‘here.com’ }

all names below these NTA will not be validated
(unless there is an island of trust below these anchors)

preparations for TA rotation and management
in config:
trust_anchors.file = ‘root.key’
trust_anchors.auto = true // NOTIMPL
trust_anchors.add(‘. IN DS …’) // Manual addition

subrequests may be insecure (e.g. out of bailiwick insecure NS),
but the final answer may be secured
the commit also fixes caching in this case

the reason is that it's not actively used since we moved to binary
testing, and it depends on libknot internal api that has changed
also removed several unused libknot internal headers

the requestor can provide information identifying the query originator
here (address and TSIG key), both fields are optional
update Lua FFI bindings

this is a small step for me, but a huge step for resolver

this is a first step of leaning towards LuaJIT.
the FFI bindings are much faster, simpler and don’t abort traces

daemon core scripting engine is still going to support interpreted Lua, but modules requiring library bindings (such as ‘block’) will require LuaJIT for FFI

this fixes a problem when a module was removed, but pending
queries referenced it, causing a crash. usually when the
server was busy and a module was unloaded.
as we don’t need to copy layers at all, they’re just iterated
from the array of modules using a macro

the only flag supported now is the KR_REQ_DNSSEC,
which indicates that the caller wants a secure answer

before root hints were hardcoded to the resolver,
now they are present in form of a cut in the resolution
context, and the modules can add/remove/replace them
on the fly

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

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

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

the module memory not be moved (reallocd), turned array of modules to array of pointers to modules