Using LRU cache to store DNS cookies.

Removed global cookie control structure.

The control structure is part of the resolver context.

Minor fixes.

Reduced amount of cookie control structures.

Using libknot lookup table to store and access cookie algorithms.

Removed some copy-and-paste code.

lib/resolve: always store EDNS data into request if present

Listed cookiectl rst file in module documentation.

Basic cookiectl module documentation.

Documentation fixes.

HMAC-SHA256-64 uses libnettle.

Added header file that has been removed from libknot.

Modification to meet latest libknot changes.

Cookie algorithms based on FNV-64 have been moved into libknot.

Using new cookies API from libknot.

Resolver responds to server cookie queries.

Reflecting latest changes in cookie handling in libknot API.

Experimental code for adding cookies into responses.

Generating FORMERR and BADCOOKIE response codes when processing cookies.

Server cookie algorithm configuration via interactive interface.

Checking cookies in inbound requests.

Started working on 'server' cookie code.

Moved cookie hash functions into separate unit.

Using modified cache interface without transactions.

Presence of libcrypto controls compilation od DNS cookies functionality.

Client cookie hash function can be specified using interactive interface.

Added HMAC-SHA256-64 hash function.

Conditional compilation of DNS cookie code.

Use ENABLE_cookies=yes variable to compile functionality.

Cookies cache TTL can be configured.

Renamed cookie related modules. Some code refactoring.

Using common cache for cookies.

Cookies are not stored in separate cache.

Added missing test whether new query was created in cookie layer.

Querying again when BADCOOKIE received.

The cookies layer injects a new query into the plan when a DADCOOKIE
response is detected. After failing the second attempt a TCP fallback is
signalised.

Moved cookies before iterate layer.

Fall back to TCP when receiving a valid BADCOOKIE response.

Cookie cache uses TTL to limit the cookie life span.

Cookies can be removed from cache.

Added support for TTL in cookies cache.

Checking reply source address against client cookie.

Turned some function parameters contant.

Fixed inserting response source into query context.

The source address was always put into a subsequent query.

Response origin address is stored in the query context.

This simplifies the response source identification on the cookie module.

Resolution fails when receiving invalid cookies.

According to section 5.3 of the cookie draft the resolution should fail
if invalid cookie received.

Support for basic cookies configuration.

Added basic support for client secret rotation.

Force fall-back to TCP when bad cookie received.

Send cookies only in queries.

Use only those cookies that match the current client secret.

Support for cookie options caching.

Checking received cookies against addresses in nsrep.

Added FNV-64 code.

Preparations for using nsrep mechanism to guess response origin.

Temporarily fixed packet corruption when adding cookie data.

Added code trying to obtain client IP address from libuv UDP handle.

Using actual remote server address to re-generate cookie.

Obtaining server IP address when generating query.

Resolver is able to insert dummy client cookies into generated requests.

Trying to insert cookies into request form layer.

Currently without success.

Introduced  empty cookies module.

lib/generic: fixed typo in lru code

this caused a bug in pseudo-lru table that negated
stickiness of values to table slots

scripts: bumped used libknot version to 2.3.0

daemon/lua: support new libknot 2.3 soversion

Merge branch 'fix-segfault-in-early-quit' into 'master'

Fix segmentation fault in early shutdown from `quit()` in config

kresd was segfaulting if configuration file contained `quit()`

See merge request !42

Fix segmentation fault in early shutdown from `quit()` in config

Merge branch 'tls-listen' into 'master'

DNS over TLS and TCP out-of-order processing

Refresh !18

I merged few bits from @dkg branch, but there are two notable things missing:
- watch for on-disk chang of credentials - not sure if this is really needed, I would suggest a separate MR, where we can discuss benefits of doing so.
- ephemeral key generation from `net.tls_servicename` - this is fine, but instead of setting `tls_servicename`, let's make it an explicit generator e.g. net.generate_certificate("name") instead of setting `tls_servicename` in the `struct network`. Again I would suggest a separate MR.

To test the TLS listen, you can use a dns-over-tls branch from Knot DNS:
```
./daemon/kresd --tls=127.0.0.1\#5353
net.tls("cert", "key")
```

```
$ ./src/kdig +tls -p 5353 www.cmu.edu @127.0.0.1
;; ->>HEADER<<- opcode: QUERY; status: NOERROR; id: 9741
;; Flags: qr rd ra; QUERY: 1; ANSWER: 2; AUTHORITY: 0; ADDITIONAL: 0

;; QUESTION SECTION:
;; www.cmu.edu.         IN A

;; ANSWER SECTION:
www.cmu.edu.         86400 IN CNAME www-cmu-prod-vip.andrew.cmu.edu.
www-cmu-prod-vip.andrew.cmu.edu. 21600 IN A 128.2.42.52

;; Received 107 B
;; Time 2016-08-05 11:52:25 CEST
;; From 127.0.0.1@5353(TCP) in 2146.1 ms
;; TLS session info: (TLS1.2)-(ECDHE-RSA-SECP256R1)-(AES-256-GCM)
```

See merge request !41

Merge branch 'unbuffer-kr_log_info' into 'master'

Ensure that kr_log_info() gets sent promptly to stdout

If stdout is buffered, kr_log_info() might take ages to show up in the
output stream.  Since this stream could be interleaved with stderr
(e.g. kr_log_error()), it would be good to be able to see the messages
in the order in which they are generated.

See merge request !40

Ensure that kr_log_info() gets sent promptly to stdout

If stdout is buffered, kr_log_info() might take ages to show up in the
output stream.  Since this stream could be interleaved with stderr
(e.g. kr_log_error()), it would be good to be able to see the messages
in the order in which they are generated.

daemon/tls: cleanup, documented tls functions

Make the travis builds verbose

gnutls_certificate_get_x509_crt requires gnutls 3.4.0

Log key-pinning strings for TLS keys

RFC 7858 explicitly defines an out-of-band key pinning profile as one
authentication mechanism.  It uses the same format for representing
the pin as HPKP does (RFC 7469).

By logging this pin directly upon first use of the X.509 credentials,
we make it a little bit easier for an admin to publish part of a
pinset.

For ideal operation (including preparation for key rollover), a backup
public key should also be provided, but this is not defined
functionally here.

daemon/main.c, daemon/bindings.c, daemon/tls.c, daemon/worker.h: cleanup

Move tls_credentials to struct network

provide a way for systemd-supervised services to listen on TLS via socket activation

initialize GnuTLS logging cleanly, once at daemon/worker start.

We also propagate kresd's verbosity into the TLS logging level

Remove the extra indirection in tls_certificate_free

Move struct tls_credentials_t from daemon/worker.h to daemon/tls.h

daemon/tls: cleanup

Fix the memory leak by returning kr_error(ECONNRESET) on end of stream

Add reference counting to gnutls credentials, so they don't get destroyed while used

Initialize global TLS credentials in the worker_ctx and initialize GnuTLS logging at global level

Miscelaneous fixes in coding style

Revert default EDNS0 buffer size to 4096

daemon: lower minimum allowed edns bufsize to 512

there are cases where switches or middle-boxes
block DNS/UDP answers >512 octets completely,
this gives user an option to mitigate that.
however, there are authoritatives serving
large answers that don't support TCP, so it's
a compromise as always

listen using TLS on specific sockets

kresd has --tls/-t by analogy with --addr/-a where the daemon opens
the socket itself.

This changeset adds equivalent functionality for inherited sockets:
--tlsfd/-T by analogy with --fd/-Sa

fix kresd internal help docs, describe --tls in kresd(8)

Handle more processing from tls_process to worker_process_tcp

daemon/tls: fixed improper use of callback, leaks

the TLS sessions now bypass the usuall event loop asynchronous iops
this is because the whole operation is synchronous right now, and
implementing asynchronous send operations would require TLS session to
restart write events on the event loop and making sure the "on complete"
callback is called eventually

daemon/tls: process all records on input

this is a workaround probably, but we need to
process all records in received buffer otherwise
it loses the rest of the data

WIP: first pass at TLS implementation

daemon/network: global TLS certificate and key configuration

daemon: ported DNS/TLS preparation code to 1.1

Actively link to gnutls

TLS: update documentation

sd_listen_fds_with_names() requires libsystemd >= 227

Merge branch 'systemctl-help' into 'master'

add Documentation= reference to knot-resolver.service

This makes "systemctl help knot-resolver" bring up the appropriate man
page.

See merge request !39

add Documentation= reference to knot-resolver.service

This makes "systemctl help knot-resolver" bring up the appropriate man
page.

Merge branch 'control-socket-activation' into 'master'

Control socket activation

This branch provides reasonable configs for full systemd socket activation for kresd.

See merge request !36

update documentation to explain systemd socket-activation configuration

systemd rules for closely-supervised knot-resolver service

This is a fully-socket-activated knot-resolver service that can run as
a non-priivleged user named knot-resolver.