GDB pretty printer for resource pools

Fixed pipe reload/refeed

Stored pages release routine

Fixed channel export map confusion

BGP: End route refresh before another starts

RPKI has its own loop

RPKI: Use the route refresh mechanism also for the first load

More information on RPKI errors

Higher settle times when route refresh in the source table is running

Corking also feed start to keep BIRD running when refeeds would easily cause congestion

Route attribute cache is now lockless on read / clone.

Lots of time was spent locking when accessing route attribute cache.
This overhead should be now reduced to a minimum.

Route sources have their separate global lock

Introducing basic RCU primitives for lock-less shared data structures

VRF setting reduced to one argument, using default dummy iface for default vrf

Route table import-to-export announcement indirection to reduce pipe traffic

Keeping un-unmmappable pages until they can be reused

On Linux, munmap() may fail with ENOMEM when virtual memory is too
fragmented. Working this around by just keeping such blocks for future
use.

Pipe runs in parallel.

Routing tables now have their own loops.

This basically means that:
* there are some more levels of indirection and asynchronicity, mostly
  in cleanup procedures, requiring correct lock ordering
* all the internal table operations (prune, next hop update) are done
  without blocking the other parts of BIRD
* the protocols may get their own loops very soon

Route subscription uses events

Global table update pool removed

Locking route attributes cache

To access route attribute cache from multiple threads at once, we have
to lock the cache on writing. The route attributes data structures are
safe to read unless somebody tries to tamper with the cache itself.

Route sources have an explicit owner

This commit prevents use-after-free of routes belonging to protocols
which have been already destroyed, delaying also all the protocols'
shutdown until all of their routes have been finally propagated through
all the pipes down to the appropriate exports.

The use-after-free was somehow hypothetic yet theoretically possible in
rare conditions, when one BGP protocol authors a lot of routes and the
user deletes that protocol by reconfiguring in the same time as next hop
update is requested, causing rte_better() to be called on a
not-yet-pruned network prefix while the owner protocol has been already
freed.

In parallel execution environments, this would happen an inter-thread
use-after-free, causing possible heisenbugs or other nasty problems.

Table cork: Stop creating updates when there are too many pending.

The corked procedure gets a callback when uncorked. Supported by table
maintenance routines and also BGP.

Split route table event into separate events

The former rt_event is dropped in favour of separate table events.
This allows for selective corking of NHU and prune.

Adding a generic cork mechanism for events

Converting the former BFD loop to a universal IO loop and protocol loop.

There is a simple universal IO loop, taking care of events, timers and
sockets. Primarily, one instance of a protocol should use exactly one IO
loop to do all its work, as is now done in BFD.

Contrary to previous versions, the loop is now launched and cleaned by
the nest/proto.c code, allowing for a protocol to just request its own
loop by setting the loop's lock order in config higher than the_bird.

It is not supported nor checked if any protocol changed the requested
lock order in reconfigure. No protocol should do it at all.

Moved BFD IO loop out of BFD as we want to use it as socket-io coroutine

Unified time for whole BIRD

In previous versions, every thread used its own time structures,
effectively leading to different time in every thread and strange
logging messages.

The time processing code now uses global atomic variables to keep
current time available for fast concurrent reading and safe updates.

Debug messages with timestamps.

On most of current hardware, getting monotonic clock is fast enough to
get it and write for each debug message.

Lock position checking allows for safe lock unions

Coroutines: A simple and lightweight parallel execution framework.

Locking subsystem: Just a global BIRD lock to begin with.

Dropping the POSIX thread-local variables in favor of much easier-to-use C11 thread-local variables

POSIX threads and thread-local storage is needed for concurrent execution

Multithreaded BIRD needs reasonably new software to compile

Fixing expensive list checks. Debug only commit.

GDB: SKIP_BACK and linked list tools

Type checking in SKIP_BACK macro

Route export is now asynchronous.

To allow for multithreaded execution, we need to break the import-export
chain and buffer the exports before actually processing them.

Better profylaction recursive route loops

In some specific configurations, it was possible to send BIRD into an
infinite loop of recursive next hop resolution. This was caused by route
priority inversion.

To prevent priority inversions affecting other next hops, we simply
refuse to resolve any next hop if the best route for the matching prefix
is recursive or any other route with the same preference is recursive.

Next hop resolution doesn't change route priority, therefore it is
perfectly OK to resolve BGP next hops e.g. by an OSPF route, yet if the
same (or covering) prefix is also announced by iBGP, by retraction of
the OSPF route we would get a possible priority inversion.

Special table hooks rectified.

* internal tables are now more standalone, having their own import and
  export hooks
* route refresh/reload uses stale counter instead of stale flag,
  allowing to drop walking the table at the beginning
* route modify (by BGP LLGR) is now done by a special refeed hook,
  reimporting the modified routes directly without filters

Table import and export are now explicit hooks.

Channels have now included rt_import_req and rt_export_req to hook into
the table instead of just one list node. This will (in future) allow for:

* channel import and export bound to different tables
* more efficient pipe code (dropping most of the channel code)
* conversion of 'show route' to a special kind of export
* temporary static routes from CLI

The import / export states are also updated to the new algorithms.

Limit containment

RPKI: Do nothing when protocol is stopping

RPKI shouldn't process more packets when being stopped

Kernel routes are flushed on shutdown by kernel scan, not by table scan

Secondary and merged exports get a whole feed instead of traversing the table structures directly

Route export: rejected by filter bitmap

If a route has been rejected by filter, store that information
to avoid repeated export filter runs on rejected routes.

Protocol stats split to import and export

Nest: Route generations and explicit tracking route propagion through pipes

Refeed is done from export table when appropriate

Recursive route nexthop updates now announced with valid new_best/old_best information

Suppressed MRT unused static function warning

Split route data structure to storage (ro) / manipulation (rw) structures.

Routes are now allocated only when they are just to be inserted to the
table. Updating a route needs a locally allocated route structure.
Ownership of the attributes is also now not transfered from protocols to
tables and vice versa but just borrowed which should be easier to handle
in a multithreaded environment.

Extended route trace: logging Path Identifiers

Dropping the unused rte_same hook

Dropping rte-local dumper entries

RIP fixup + dropping the tmp_attrs mechanism as obsolete

BGP: Moved the suppressed and stale flags to pflags

Kernel: Convert the rte-local attributes to extended attributes and flags to pflags

Dropping the RTS_DUMMY temporary route storage.

Kernel route sync is done by other ways now and this code is not used
currently.

Babel: Convert the rte-local attributes to extended attributes

OSPF: Convert the rte-local attributes to extended attributes

RIP: convert the rte-local attributes to extended attributes

Extended route attributes may include also pointers

IGP metric getter refactoring to protocol callback

Direct protocol hooks for IGP metric inside nest/rt-table.c make the
protocol API unnecessarily complex. Instead, we use a proper callback.

Route: moved rte_src pointer from rta to rte

It is an auxiliary key in the routing table, not a route attribute.

Preference moved to RTA and set explicitly in protocols

Preexport: No route modification, no linpool needed

Export table: Delay freeing of old stored route.

This is needed to provide the protocols the full old route after filters
when export table is enabled.

There may be a symbol with NULL protocol when reconfiguring

Show route may be accidentally called on shutdown also when not all default tables are present

fixup! Multipage allocation

Multipage allocation

We can also quite simply allocate bigger blocks. Anyway, we need these
blocks to be aligned to their size which needs one mmap() two times
bigger and then two munmap()s returning the unaligned parts.

The user can specify -B <N> on startup when <N> is the exponent of 2,
setting the block size to 2^N. On most systems, N is 12, anyway if you
know that your configuration is going to eat gigabytes of RAM, you are
almost forced to raise your block size as you may easily get into memory
fragmentation issues or you have to raise your maximum mapping count,
e.g. "sysctl vm.max_map_count=(number)".

CLI socket accept() may also fail and should produce some message, not a coredump.

OSPF: explicitly stop the periodic tick on shutdown to avoid recalculation races

Linpools may use pages instead of xmalloc

fixup! Bound allocated pages to resource pools with page caches to avoid unnecessary syscalls

Bound allocated pages to resource pools with page caches to avoid unnecessary syscalls

Reducing filter stack size to allow for lesser thread stack size

OSPF: Setting a list node NULL before use

Fixed memory poisoning in slab

Debug output uses local buffer to avoid clashes between threads.

Filter: Additional consistency checks

Nest: Clean up main channel handling

Remove assumption that main channel is the only channel.

CI: Allow Babel tests

Nest: Allow both 'password' and 'key' keywords for authentication keys

Babel: Simplify auth expiration

Just use hello_expiry for that, keep init_expiry for initial
unauthentized neighbors.

Nest: Fix password list parsing code

One of previous patches broke password list parsing code, fix that.

Lib: Fix static assert macro

Babel: Add MAC authentication support - update

Some cleanups and bugfixes to the previous patch, including:

 - Fix rate limiting in index mismatch check

 - Fix missing BABEL_AUTH_INDEX_LEN in auth_tx_overhead computation

 - Fix missing auth_tx_overhead recalculation during reconfiguration

 - Fix pseudoheader construction in babel_auth_sign() (sport vs fport)

 - Fix typecasts for ptrdiffs in log messages

 - Make auth log messages similar to corresponding RIP/OSPF ones

 - Change auth log messages for events that happen during regular
   operation to debug messages

 - Switch meaning of babel_auth_check*() functions for consistency
   with corresponding RIP/OSPF ones

 - Remove requirement for min/max key length, only those required by
   given MAC code are enforced

Babel: Add MAC authentication support

This implements support for MAC authentication in the Babel protocol, as
specified by RFC 8967. The implementation seeks to follow the RFC as close
as possible, with the only deliberate deviation being the addition of
support for all the HMAC algorithms already supported by Bird, as well as
the Blake2b variant of the Blake algorithm.

For description of applicability, assumptions and security properties,
see RFC 8967 sections 1.1 and 1.2.

Babel: Refactor TLV parsing code for easier reuse

In preparation for adding authentication checks, refactor the TLV
walking code so it can be reused for a separate pass of the packet
for authentication checks.

Nest: Allow MAC algorithms to specify min/max key length

Add min/max key length fields to the MAC algorithm description and
validate configured keys before they are used.

Nest: Allow specifying security keys as hex bytes as well as strings

Add support for specifying a password in hexadecimal format, The result
is the same whether a password is specified as a quoted string or a
hex-encoded byte string, this just makes it more convenient to input
high-entropy byte strings as MAC keys.

Lib: Add tests for blake2s and blake2b

Import the blake2-kat.h header with test vector output from the blake
reference implementation, and add tests to mac_test.c to compare the
output of the Bird MAC algorithm implementations with that reference
output.

Since the reference implementation only has test vectors for the full
output size, there are no tests for the smaller-sized output variants.

Lib: Add Blake2s and Blake2b hash functions

The Babel MAC authentication RFC recommends implementing Blake2s as one of
the supported algorithms. In order to achieve do this, add the blake2b and
blake2s hash functions for MAC authentication. The hashing function
implementations are the reference implementations from blake2.net.

The Blake2 algorithms allow specifying an arbitrary output size, and the
Babel MAC spec says to implement Blake2s with 128-bit output. To satisfy
this, we add two different variants of each of the algorithms, one using
the default size (256 bits for Blake2s, 512 bits for Blake2b), and one
using half the default output size.

Update to BIRD coding style done by committer.

sysdep: Add wrapper to get random bytes - update

Simplify the code and fix an issue with getentropy() return value.

sysdep: Add wrapper to get random bytes

Add a wrapper function in sysdep to get random bytes, and required checks
in configure.ac to select how to do it. The configure script tries, in
order, getrandom(), getentropy() and reading from /dev/urandom.

BGP: Ensure that freed neighbor entry is not accessed

Routes from downed protocols stay in rtable (until next rtable prune
cycle ends) and may be even exported to another protocol. In BGP case,
source BGP protocol is examined, although dynamic parts (including
neighbor entries) are already freed. That may lead to crash under some
race conditions. Ensure that freed neighbor entry is not accessed to
avoid this issue.