Make ping intervals and timeouts configurable for each device class.

Better use of enum dev_class_t.

Add support for AIO using filedescriptors.

This adds support to enqueue transmits between channels and filedescriptors.
Currently, it requires that read() and write() calls on the filedescriptors
are non-blocking and always succeed, which limits it to reading from and
writing to files.

Use relative URLs for the submodules.

Ignore REQ_KEY only if we very recently sent one ourselves.

In case the SPTPS state between two nodes becomes desynchronized, we must
allow a new SPTPS connection to be set up eventually.

Remove redundant call to graph().

When we receive an ADD_EDGE for an existing edge but with new information,
don't call graph() between removing the old edge and adding the new one.
This prevents a node from temporarily being considered unreachable, which
in turn would cause the SPTPS state to that node being reset.

Send REQ_KEY after a successful meta-connection only from the initiator.

Test concurrent AIO and non-AIO transfers.

Create 5 channels; 4 transfer a large amount of data via AIO, the 5th does
a regular meshlink_channel_send(). Verify that there is concurrency between
all channels.

Allow the channel send and receive buffer size to be changed.

This also adds a test to see if this works in combination with
MESHLINK_CHANNEL_NO_PARTIAL.

Add meshlink_channel_aio_receive().

This function allows handing over a large buffer to MeshLink which will be
used to receive data without needing intervention from the application.
A callback is called when MeshLink has filled the buffer with the data.

Add a test case for meshlink_channel_aio_send().

Add meshlink_channel_aio_send().

This function allows handing over a large amount of data to MeshLink
which will be sent without needing intervention from the application.
A callback is called when MeshLink is done with the data, so the
application can call any cleanup function it needs to call.

Add the MESHLINK_CHANNEL_NO_PARTIAL flag.

This ensures that calls to meshlink_channel_send() either succeed with all
data sent, or no data sent at all.

Use condition variables to wait for threads to finish initializing.

To prevent a race condition when calling meshlink_stop() right after
meshlink_start(), we need to wait for the MeshLink and Catta threads to
finish initializing before we can return from meshlink_start().

Remove global variables.

There still were some global variables and buffers that were either unused
or should be local to a MeshLink instance.

Avoid unnecessary calls to time().

We already have the current time from the event loop.

Correctly set device class after joining if the server didn't specify one.

Correctly update device class when receiving an ADD_EDGE message.

In some cases we didn't update the device class information when receiving
an ADD_EDGE message. This could cause autoconnect to fail to work as
expected.

Run Catta in the same network namespace as MeshLink.

Ignore online/offline state from Catta.

Catta only works on Ethernet interfaces. However, if there is a
non-Ethernet interface, MeshLink might still be able to connect to
peers. So just rely on getifaddrs() for checking whether to terminate
connections or not.

Close connections if the local address is no longer valid.

When we detect that there are changes on the network interfaces, check for
each active connection whether the local side of the connection has an
address that exists on at least one network interface. If not, then
communication via that connection is not possible. Instead of waiting for
a timeout, immediately terminate those connections.

Remove unused member variables.

In MeshLink, we are not using node/edge options, and we don't support
compression or setting a custom local discovery broadcast address.

Keep the internal support for meta-connections via proxies for now, even
though it currently isn't exposed via the API.

Reorganize structs for better packing and access patterns.

Used the pahole tool to find gaps in structs. Move the lesser accessed
members to the end of the struct.

Speed up reconnections on network interface changes.

Catta informs us whenever an interface comes online or goes offline. If we
detect that there are no online interfaces, immediately terminate all meta-
connections. Otherwise, reset the ping timers and reconnection timers for
outgoing connections.

Fix a small memory leak.

When registering ourselves to Catta, we called meshlink_get_fingerprint()
without freeing the returned string afterwards.

Fix potential segmentation fault on node reachability change.

Inform UTCP when a node is offline, so it will start connection timeouts.

When there are open channels to a node that is offline for longer than the
connection timeout, the channels will be marked closed, and callbacks will
be fired.

Update UTCP to correctly handle timeouts sending data.

Also add a test case that checks whether we get a callback when sent data
is not acked in a reasonable amount of time.

Prevent meshlink_join() when the joining node is already part of a mesh.

Fix compiler warnings in the test suites.

Speed up initial autoconnect after joining a mesh.

When we just joined a mesh, we quickly want to establish redundant
connections. We do this by resetting the outgoing timer if we receive a
public key for a node that we are trying to connect to, and by speeding up
the autoconnect algorithm if we don't have 3 connections (in progress) yet.

Autoconnect to reachable nodes without known public keys

We must allow the autoconnect algorithm to try connections to nodes that
are online but for which we don't have a public key, otherwise we risk
that no connections are formed at all, except to the inviting node.

Ensure we can pass arbitrary binary blobs for keys.

Add encrypted key rotation feature api

Modify meshlink configuration base file structre

Add unit test cases for encrypted storage key rotation

Various fixes for the encrypted storage support.

- create_initial_config_files() and node_write_config() are now the only
  functions that generate the content of new config files from scratch.
- All public API functions that change config files now immediately
  write them out.
- Config files of nodes that join using an invitation file are immediately
  written out.
- Ensure nodes marked dirty have their config files written out in
  periodic_handler(), and on meshlink_stop().
- Fix some memory leaks.
- Write out updated config files, and recreate mesh->self in meshlink_set_port().

Add support for opening a MeshLink instance without permanent storage.

Add missing declaration of chacha_ivsetup_96().

Add support for encrypted storage.

This is a large overhaul of how configuration files are handled. All files
are now in PackMessage format, and are read from disk in to memory in one
go, and also saved to disk from memory in one go, using functions in conf.c.

Add the PackMessage library.

Make retry outgoing logic instantaneously connect when a change is discovered on any node in catta

Add test cases for random port bindings

Make meshlink_set_port() return false if we didn't bind to the requested port.

Re-enable building the chatpp example.

Add missing symbols to meshlink.sym.

Also ensure automake treats it as a dependency, so it will rebuild the
library correctly whenever it is updated.

Update android build

Fix compiling warnings

Update README.android.

Emphasize getting a recent version of the NDK, and also set the CXX
variable to ensure the C++ examples are compiled properly for Android.

Also ensure that README.android is a valid Markdown/CommonMark file.

Add meta-connection attempt callback feature

Add meshlink_get_submesh API

* Add meshlink_get_submesh API

* Modify submesh test vector to test meshlink_get_submesh API

Add condition check in auto connect for blacklisted nodes

* Add condition check in auto connect for blacklisted nodes

* Add test vector to test autoconnect

Add functions to get the amount of bytes in chanenl send and receive buffers.

meshlink_channel_get_sendq() and meshlink_channel_get_recvq() call the
underlying UTCP connection's utcp_get_sendq() and utcp_get_recvq().
These return the amount of bytes waiting in the send and receive buffers.
In particular, a non-zero value for sendq means that sent data has not been
ACKed by the peer yet.

Remove extra locks causing deadlocks for wait_sync_flag function

Fix spelling errors.

Found by codespell.

Make Doxygen more strict, and fix errors in the documentation.

Remove make check warnings

Add blackbox test cases for submesh

Fix NULL checking of addrinfo structure in try_bind function

Check for astyle version 3 before formatting the code.

Unfortunately, code formatters change their behaviour between versions.
The code currently requires astyle version 3.x, so check this before
running astyle. If the wrong version is installed, print an error.

Reduce locking in Catta callback functions to a minimum.

Add a groupchat example program that uses the submesh feature.

Add devtool_get_all_submeshes().

Improve support for submeshes.

Add channel disconnection fix when node blacklisted

Fix building the channels test.

Do not define struct meshlink_open_params at all in meshlink.h.

Don't try to build node_* binaries for the optimal PMTU test cases anymore.

Add test case for channel blacklist

Code formatting.

Add optimal pmtu test cases

Update invite API in blackbox test cases

Add network namespace test framework

Modified meshlink_invite to generate invites for submesh

Added meshlink_submesh_open

Add a test case for meshlink_get_all_nodes_by_dev_class().

Add API functions to query nodes by device class.

Add test cases for the PMTU discovery mechanism.

Update the blackbox test infrastructure.

Provide a way to open MeshLink in its own network namespace.

This causes all sockets from MeshLink to be opened in the given network
namespace, without affecting the application's namespace. Note that since
callback functions run inside MeshLink's own thread, the callback functions
inherit MeshLink's network namespace.

Only compile the monitor example application if ncurses is available.

Code formatting.

Fix indentation.

Fix discovering node addresses from edges.

The logic always skipped the first unique address found via edges, and since
in most cases there is only one such address, this would skip them altogether.

Simplify rate limiting of incoming connections.

We now really allow max_connection_burst connections per second, rather
than only allowing one second per connection on average, but allowing
a burst of max_connection_burst connections to go through.

Fix a potential segfault.

This was found by Lakshminarayana Gurram.

Remove debug messages printed to stderr.

Fix socket leak every time meshlink_invite() is called.

getlocaladdrname() would leak a socket every time it was called, which is
twice for every call to meshlink_invite() using the default flags.

Try all CanonicalAddress and Address statements.

Add autoconf checks for LXC and cmocka.

If LXC or cmocka are not installed, don't build the blackbox test suite.

Add the blackbox channel connection tests.

Add the blackbox container based test suite.

This test suite uses LXC containers to simulate various nodes connected
to each other in different network topologies, and allows for realistic
testing of the MeshLink library.

Really add both local and external address to the invitation URL.

Also make sure we add both IPv4 and IPv6 if possible, use numeric addresses
unless hostnames resolve back to the same numeric address.

Add meshlink_invite_ex() that takes a flag that makes URL generation more
configurable.

Reformat the code.

Add an example using curses to monitor the state of MeshLink.

Lock meshlink.conf to ensure only one instance can run at a time.

Fix "Connection from (null)" log message.

Always add both CanonicalAddress and any local address to the invitation URL.

We don't know in advance if the invitee will be on the LAN or outside
the LAN, and because hairpin routing is not working on many home
routers, it is safer to add all possible addresses.

Also, add the port number to each individual address in the URL, instead
of allowing only one port number.

Add missing code for the duplicate node testcase.

Add duplicate node detection callback.

MeshLink can detect if two nodes are online simultaneously using the same
Name. Normally, one or both of the duplicate nodes will terminate its
connection. Now there is a duplicate node callback that will be called when
the local node detects a duplicate node. One use for this is to blacklist
the duplicate node and/or notify the user of the problem.

Remove the -fPIE and -pie compiler flags.

Since we are building a library, these flags shouldn't be used. They
appear to cause problems when linking libmeshlink into another shared
library.