Set the priv pointer at channel open time in the channels-cornercases test.

Add a way to set the channel's priv pointer when opening it.

This prevents a race condition where between opening a channel and
setting the priv pointer, the receive callback is called.

Set a very small channel timeout in channels-failure test.

This tests both the meshlink_set_node_channel_timeout() function and greatly
speeds up the test.

Remove some more superfluous parentheses.

Rename mesh_mutex to mutex.

Add meshlink_set_node_channel_timeout().

This function allows setting the user timeout for UTCP connections.

Fix waiting for two nodes to become reachable in the test suite.

Correctly handle incoming retransmissions of SYN packets.

If the SYNACK got lost, the peer that initiated a channel would retransmit
the SYN packet. However, the responder would ignore the retransmitted SYN
packet, causing the channel to stall and eventually time out.

Don't load config files partially.

There are various points where we update node information and store a new
host config file to disk. However, at startup we read only part of the host
config files. This allowed a corner case where we never read the full host
config file, but did write it to disk, losing information in the process.

Fix spurious channel closures after meshlink_stop()+meshlink_start().

When restarting the mesh without fully closing the handle, channels should
continue to work MeshLink was only stopped briefly. However, we were
accidentily always setting the connection timeout when a node's UDP status
changed, which would cause channels that didn't have any unsent data to
time out.

Check the return value of node_write_config() while handling invitations.

Add an error callback.

Normally, API functions report potential errors. However, it might happen
that the background thread runs into a serious error that prevents
MeshLink from operating as expected. Add a callback that is called in those
cases.

Currently, the only time it is called is when it can not create or modify
config files in the background thread.

Fix a double call to pthread_mutex_unlock().

Found by ThreadSanitizer.

Don't use static variables when choosing a broadcast address.

Found by ThreadSanitizer.

Unlock the mesh_mutex before destroying it.

Found by ThreadSanitizer.

Refactor the non-blackbox test suite.

- Add a default log callback function to utils.[ch]
- Use the functions from utils.[ch] where appropriate.
- Use assert() where possible.
- Make functions and variables static where possible.
- Remove the need for wrapper scripts.

Replace rand() by xoshiro256** with per-mesh state.

We need a reasonable fast PRNG that doesn't have to be secure, for things
like timer randomization, port number generation and so on. Already some
platforms warn about the use of rand(). Also, when calling fork(), both
parent and child have the same PRNG seed, which causes some inefficiencies
in the test suite.

Add the /whitelist command to the chat examples.

This allows undoing a /kick.

Fix the channels-no-partial test case.

Remove unused functions, and make more functions static.

Add assert() calls to the library.

To aid in debugging, start using assert() to ensure preconditions hold.
At the moment, we assume that NULL-pointer dereferences will always cause
segfaults, so we don't add assert(ptr) statements in those cases, but that
might change in the future.

Clean up resources in the test cases.

Not doing so prevents tools such as AddressSanitizer and Valgrind from
declaring the tests free of memory leaks.

Fix potential memory leaks in the autoconnect algorithm.

Avoid casting function pointers.

Fix memory leaks from timers.

Have meshlink_get_node() and _submesh() set MESHLINK_ENOENT when appropriate.

These functions can return NULL both when the parameters are invalid or if
the node or submesh does not exist, meshlink_errno must be set correctly
to distinguish between the two cases.

Fix memory leaks in the outgoing packet queue.

Found by AddressSanitizer.

Fix several memory leaks found by AddressSanitizer.

Ensure only valid hostnames end up in the invitation URL.

Fix errors found by Clang's static analyzer.

Fix winerror() returning a pointer to a stack-allocated array.

Found by cppcheck.

Fix potential double fclose().

We were calling fclose() inside config_read_file(), which never called
fopen() itself. It is the caller's responsibility to close the file on
error. Also fix two error cases where the caller forgot to close fclose().

Update mesh->loop.now right after select() returns.

It can be that select() waits for a few seconds before an event or
timeout arives. We didn't update mesh->loop.now before calling any of
the callback functions, which meant they could use a time a few seconds
in the past. In particular, the last_ping_time of connections could be
set to a value such that they would immediately be considered timed out.

Add missing mutex locks.

Add missing mutex locks.

meshlink_channel_close() and meshlink_channel_shutdown() did not lock
the mutex, which could cause some race conditions.

Avoid using typedefs in meshlink.h.

Use struct meshlink_foo instead of meshlink_foo_t in meshlink.h, so
links to function parameter types go to the struct definitions.

Add \memberof annotations to the C API documentation.

Fix doxygen warnings.

Add missing parts of meshlink_set_node_pmtu_cb().

Add a callback for PMTU changes.

This can be used to detect changes in UDP reachability of peers, and
allows the application to change the maximum packet size for UDP
channels.

Reset UTCP timers when learning a node's public key.

If we try to open a channel to a node whose public key we do not yet
have, a REQ_KEY request is sent out. When the answer comes back we know
the key, but we have to tell UTCP to reset the timers, otherwise we have
to wait for a retransmission timeout to occur before resending the SYN
packet.

Fix compiler warnings from Clang 10 and GCC 9.

Test UDP channels.

Simulate three simultaneous UDP channels transmitting 40 Mbps. Check that
>95% of the packets arrive, and that there is no TCP-like merging or
splitting of packets. This also checks that channels can be opened and
closed like regular TCP channels.

Ensure Catta gets a valid service name.

Normally the appname is used as the service name as well. However,
Catta's rules are that the service name must be at least two characters,
and only contain alphanumeric characters, dashses and underscores.

Ensure the channel poll callback is called with len 0 on error.

Correctly update our own host config file after meshlink_set_port().

We wrote the host config file before we updated mesh->self, causing the
old port number to remain in the host config file. This would cause
subsequent calls to meshlink_invite() to have the wrong port number in
the invitation.

Fix deadlock during discovery failure

Fix starting the channels-fork test.

The test started by cleaning the wrong config files, and could potentially
fail when started at the same time as the non-forking channels test.

Call fsync() on the configuration directories where appropriate.

Just ensuring individual config files are written atomically is good enough
to keep internal consistency, but we want to make sure directory metadata
is also synced to disk when returning from functions that expect the changes
to have been made permanent, such as meshlink_import() and
meshlink_blacklist(). Also do this when we create the initial directory
structure.

We already took care of syncing directory metadata when rotating keys for
encrypted storage.

Write config files atomically.

When opening a mesh handle, inherit the global log callback.

This prevents losing log messages halfway during meshlink_open().

Fix a potential crash when restarting the mesh.

The tv value must not be changed for a timeout that is still linked into the
tree of timeouts, otherwise the tree can get corrupted.

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.