Fix the channels-udp test case.

Close channels gracefully after the server has finished sending the streams.

Combine blackbox join test cases into the invite-join test.

Don't attempt to sync confbase for ephemeral nodes during a join.

Port the blackbox status_cb test.

Use ephemeral MeshLink instances to speed up the test.

Port the blackbox meta-connections test using network namespaces.

When activating a meta-connection, remember the address of the peer.

There was a possible situation where we did not remember the address of a
peer when there is only a TCP connection.

Reset last_connect_try for all nodes when starting the mesh.

This helps the autoconnect algorithm reconnect faster if the mesh was
stopped and restarted in quick succession.

Add reset_sync_flag().

This is for the test suite to reset a flag without broadcasting that it
changed state.

Add devtool_set_meta_status_cb().

This function is similar to meshlink_set_node_status_cb(), except that
this callback will only be called when a meta-connection to a node is
activated or terminated. This is mainly useful for the test suite.

Don't store empty canonical addresses.

Use a NULL pointer instead of an empty string to signal the lack of a
canonical address.

Fix invitation URL generation when running in a network namespace.

MeshLink could call getifaddrs() in the namespace of the caller instead of
the MeshLink thread, causing the wrong addresses to be put in the inviation
URL.

Export missing meshlink_open_params_* symbols.

Fix a crash with some network configurations.

It is apparently possible for getifaddrs() to return a struct ifaddrs that
contains a NULL ifa_addr pointer.

Add meshlink_reset_timers().

This resets the outgoing connections timers and ping timers, exactly what
is done when the network intterface status changes.

Check for the presence of stdatomic.h before using it.

Don't use assert() to check the results of pthread_*() calls.

This was done to debug the code, but it fails when MeshLink is compiled with
-DNDEBUG. Remove all assert()s from calls to pthread functions, and instead
add explicit checks to only those functions that can fail.

Export meshlink_set_dev_class_maxtimeout().

Ensure the maxtimeout value is taken from the destination node's device class.

Make the maximum outgoing connection timeout runtime configurable.

This moves maxtimeout to the dev_class_traits, and adds a function to
change it, similar to how we handle other configurable timeouts.

Fix compiling the C++ examples.

Revert "Fix warnings caused by C-only flags passed to the C++ compiler."

This reverts commit 9382f55b3f1c14c74e3bda229e277400743b11cc.

Revert "Don't overwrite CFLAGS when adding -std=c11."

This reverts commit 6d0820fda557de28c014b8ad4c40c385d23029a7.

Don't overwrite CFLAGS when adding -std=c11.

React faster to network changes, including point-to-point links.

Tell Catta to also include point-to-point links, and when we get an
update from the Catta thread, wake up the main MeshLink thread so we
react to it immediately.

Only call setitimer if ITIMER_REAL is defined.

Musl doesn't implement setitimer().

Set NOSIGPIPE on all sockets.

MacOS can raise a SIGPIPE when a local socket gets disconnected.

Fix warnings and missing mutex/cond initialization in the test suite.

Initialize the adns_done_queue.

Fix warnings caused by C-only flags passed to the C++ compiler.

Add missing initialization of a condition variable.

Fix some test cases using the same configuration directory.

Use atomic operations to check whether to write to the signal pipe.

We need to do an atomic test-and-set operation to check whether we can
avoid writing to the signal pipe. Use C11 atomics to do this in a portable
way (hopefully).

Remove gettimeofday() usage from test cases.

Add asserts() to all pthread related function calls.

We normally expect all pthread-related functions to succeed, so in all
places where we didn't already explicitly check the return value, assert()
that the functions return 0.

Properly initialize mutexes and condition variables.

On Linux, zeroing a pthread_mutex_t or pthread_cond_t variable ensures
the mutex/cond is properly initialized, however this is not the case om
some other platforms. Ensure we always call pthread_mutex/cond_init().

Fix compiler warnings on macOS.

Check whether IP_MTU is defined.

Fix meshlink_join() failing on Android.

The adns_blocking_request() function did not pass a hint to
getaddrinfo(). With glibc, the resulting struct addrinfo sets socktype
and protocol to SOCK_STREAM and IPPROTO_TCP, and the call to connect()
copied these values. However, bionic doesn't set the socktype and
protocol to those values if no hint was specified.

Ensure utcp-test is compiled with the same flags as libmeshlink.

Include "system.h" in the UTCP sources.

The UTCP sources were not using the system.h header file like the rest
of the code, resulting in issues with some compilers.

Don't crash when trying to connect a channel to port 0.

Explicitly set the stack size for the MeshLink thread.

Different libcs have different default sizes for newly created threads. In
particular, Musl defaults to 80 kB, which is too small for MeshLink. We now
request 1 MB, which should be more than enough to handle the deepest call
stacks.

Limit the size of the fd read buffer in channel_poll().

Add a test for AIO callback cornercases.

Fix assert that could incorrectly be triggered when a peer closed the channel.

If we are sending AIO data on a channel and the peer closed the connection,
we could trigger an assert incorrectly.

Report the amount of actual data sent/received in AIO callbacks.

We did this for fds but not for memory buffers.

Reset closed connections if there is incoming data.

Include our own key in REQ_PUBKEY requests.

If we don't know a peer's public key, it most likely means the peer
doesn't know our public key, so proactively send it along with the
REQ_PUBKEY request.

Handle UTCP receive buffer wraparound corner cases.

Before we allowed buf->offset to be equal to buf->size. This caused an
issue where buffer_call() would call the callback twice, once for 0
bytes at the end of the buffer, and once for len bytes at the start of
the buffer.  This would cause the callback function to think the channel
had encountered an error.

If the data in the ringbuffer wraps around, and we call the receive
callback for the first part of the data, the callback function might
close the channel, so we must not call the callback for the second part
of the data.

Fix mismatch in supported compile flags tested for and added to CPPFLAGS.

Fix more compiler warnings.

This enables much more compiler warnings by default, and fixes all the
warnings we get from GCC 10 and Clang 10 in the library.

The blackbox test cases still produce a lot of warnings that have not
been fixed yet.

Fix make distcheck.

Add Doxygen support to the build system.

Move UTCP into the MeshLink repository.

UTCP is not used outside of MeshLink at the moment, and there is a tight
coupling between the two, so it makes more sense to have it as part of
MeshLink itself.

Handle EINTR when reading/writing to AIO fds.

Handle meshlink_channel_close() being called in callbacks.

When it's called in a callback, we can't free the channel until the
function that called the callback has a chance to safely complete. This
is not a problem for regular receive and poll callbacks, but it is for AIO,
where there can be multiple outstanding AIO buffers that each need their
callback called to signal completion, and each of them could potentially
call meshlink_channel_close().

This also ensures that when the channel is explicitly closed by the
application, it will not receive any further callbacks.

Update UTCP to fix retransmission of SYNACK packets.

Avoid a segfault when setting a timeout to 0.

The event loop was assuming that a timespec value of {0, 0} meant that the
timer was not added to the timer tree. However, it was possible for other
parts of the code to set the value to {0, 0}, which could result in a
segmentation fault. Use the splay_node_t data pointer to check whether a
timeout is linked into the tree instead.

Several fixes for channel AIO send and receive functions.

- Process multiple buffers if possible
- Better handling error conditions
  - fd errors now cancel the AIO buffer
  - channel errors cancel all outstanding AIO buffers
- Don't call the poll callback with a length larger than the remaining
  UTCP send buffer.

Fix a potential read from a freed buffer when sending data to a blacklisted node.

Avoid a crash when graph() is called when the event loop is not running.

Make UTCP retranmissions trigger PMTU probes immediately.

If there are network problems while data is being transferred over a
channel, we want to react to this as soon as possible. Set the retranmission
callback to trigger the next PMTU probe immediately if there as none in
progress.

Use nanosleep() instead of clock_nanosleep().

Mac OS X does not support the latter.

Update UTCP to fix a potential segmentation fault.

Ensure exported host files have a port in the canonical address.

Update UTCP.

Check that we can send up to 65536 bytes at a time on UDP-style channels.

Have nodes remember in which submesh they live.

This exposes the submesh a node lives in to the node itself.

Allow meshlink_open() to be called with a NULL name.

This will use the name used last time the MeshLink instance was initialized.
If there is no initialized instance at the given confbase, it will return
an error.

Opening an instance with a different name than the one in the configuration
files will now also result in an error.

When resetting timers that use CLOCK_MONOTONIC, use a negative value.

CLOCK_MONOTONIC might be implemented as the time since the CPU booted, so
if MeshLink starts soon after booting, setting timers to "0" might not
actually be far enough in the past to trigger a timeout.

This has almost no effect in practice, since most timeouts are a minute or
less, but it might affect running tests in virtual machines.

Add a probe point for SPTPS renewal and devtool_force_sptps_renewal().

The latter function just sets the timers so they should time out immediately.

Also renew SPTPS keys for meta-connections.

Add a probe point for async DNS resolving.

Add UTCP UDP channel corner cases and test cases on channel get MSS length API

Add channel poll callback corner cases

Add missing atomic test cases to the APIs that affects disk writes

Use blocking ADNS requests for most other hostname resolving.

We keep calling getaddrinfo() directly if we know we only need to resolve
a numerical address.

Add "blocking" asynchronous DNS requests.

These block for a limited amount of time, preventing lookups from taking
too long. Because these requests can be done without the main MeshLink
thread running, we don't use the request queue, but instead spawn a
thread for each blocking request.

Add asynchronous DNS lookups for outgoing connections.

Remove unused support for proxies.

Add an asynchronous DNS thread.

Add a thread dedicated to making DNS lookups. There are two queues, one
for pending DNS requests and one for done DNS requests. The async DNS
thread reads from the pending request queue, checks for each request if
the deadline has not been met yet, and if so calls getaddrinfo(). Once
the result is obtained, it adds that to the done request queue and
signals the main meshlink thread, which will then call the callback
function associated with the DNS request.

Assume getaddrinfo() and IPv6 are supported.

All major operating systems of the last 10 years have supported IPv6 and
provide getaddrinfo().

Fix a debug message being logged incorrectly.

Update UTCP to fix retransmit timeout calculation.

Update UTCP to fix RTT measurements.

Update UTCP to support fragmenting packets on UDP style channels.

This allows the application to send packets of arbitrary size (up to 64 kiB)
without worrying about the path MTU to the destination node, which might
vary, especially at the start of a connection.

If the application doesn't want packets to fragment, it should use
meshlink_channel_get_mss() to query the maximum size for unfragmented
packets.

Updated test vectors for get node reachability

Add meshlink_get_all_nodes_by_last_reachable API, meshlink_get_node_reachability API and its test vectors

MeshLink now keeps track of when a node was last reachable. This can be
used by an application to detect nodes that were never reachable or which
have not been reachable for a certain amount of time.

Update UTCP to fix a compile error.

Allow setting the UTCP clock granularity.

This sets the granularity to 10 ms by default, and adds the function
meshlink_set_scheduling_granularity() to be able to change it.

Fix key renewal being called too often after the first renewal.

Try addresses found by Catta for UDP probes.

Renew SPTPS keys every hour.

We did do this in the past, but in some commit we stopped automatically
renewing keys every hour.

Avoid allocating packet buffers unnecessarily.

Unless we have to queue a packet, we can avoid allocating and freeing
memory by keeping a permanently allocated packet buffer around.

Propagate the discovered PMTU between nodes to UTCP.

Update UTCP and replace gettimeofday() with clock_gettime().

Send out channel data immediately, bypassing the packet queue.

Reduce how often we have to poll the packet queue.

Packets are moved to the MeshLink thread via the packet queue. However,
each packet required a trigger byte to be sent to the event loop, requiring
more calls to select() than necessary. Now we make event loop signals level
triggered, and dequeue all enqueued packets at once.

This also adds debug log statements for the packet queue.

Remove redundant call to add_local_addresses().

Have try_bind() reuse the setup_*_listen_socket() functions.

This ensures try_bind() configures sockets exactly the same as the actual
listening sockets.