Fix a NULL pointer dereference when unable to bind to NETLINK_ROUTE socket.

Add meshlink_hint_network_change().

This is intended to be used when there is no way for MeshLink to get
notifications of local network changes. It forces MeshLink to scan all
network interfaces for changes in up/down status and new/removed addresses,
and will immediately check if all connections to other nodes are still
alive.

Handle network change detection on macOS and iOS.

Apple has no usable PFROUTE sockets anymore, instead network change
detection should be done via SystemConfiguration callbacks. However,
actually parsing the messages is very annoying in C, so we only use it to
get notified of changes, we use getifaddrs() to get the actual list of
network interfaces and addresses.

The only issue is that interface up/down state changes do not result in a
notification, only interface and address addition/removal.

Improved mDNS compliance.

Split the mDNS packets into separate request and response packets, and only
send responses when we receive a valid request.

It's now possible to find local MeshLink nodes using tools like dns-sd and
avahi-browse, if told to explicitly search for the _appname._tcp service.

Set SO_REUSEPORT on the multicast sockets.

On Linux this doesn't make any difference, but on macOS this is required
if any other process has already opened an mDNS multicast socket locally,
otherwise bind() will fail.

Add local discovery support for macOS.

This implements the pfroute counterpart to Linux's netlink interface.
Pfroute doesn't allow easy querying the current interfaces and addresses,
so we use getifaddrs() for that.

Fix outgoing connection attempts after local discovery.

We were trying the wrong port due to a forgotten byteswap. Also, if no
address was known at all for a node, there might be an outgoing structure
for it that would never be retried.

Remove debug messages.

When receiving an mDNS request, send a unicast response back.

Group discovery related variables together.

Resend mDNS packets on all known addresses if meshlink_reset_timers() is called.

Ensure we compile discovery.c unconditionally.

Don't link with Catta anymore.

Send and receive multicast mDNS packets.

We don't actually support the full mDNS spec, we just send something that
passes for a valid mDNS packet, and expect other nodes to send packets back
with exactly the same format. All other mDNS packets will be ignored.

Keep track of interfaces and local addresses.

Parse Netlink NEW/DELLINK and NEW/DELADDR messages.

Parse link and address information. Also send GETLINK and GETADDR
messages to the Netlink socket, so we get the current state of the
interfaces and addresses.

Monitor a Netlink socket on Linux.

Monitor a PFROUTE socket on *BSD and macOS.

Catta is not handling network changes correctly on *BSD and macOS. In
particular, after the initial startup, interfaces that go up and down
do not cause a callback to be generated, so MeshLink is not notified of
the changes.

To ensure MeshLink responds rapidly to network changes on these
platforms, we open a PFROUTE socket and monitor it ourself. We only
check the message type, and don't track exactly what addresses get added
or removed.

Check the return value of catta_simple_poll_get().

This ensures we gracefully handle the case of Catta not being able to bind
to the NETLINK_ROUTE socket.

Use AI_* instead of NI_* constants for getaddrinfo().

Send our canonical address to nodes we want to communicate with.

This ensures canonical addresses are propagated automatically, and can be
used when making meta and UDP connections.

Clean up the request jump table.

Use C99 designated array initializers to ensure the jump table and list of
request names is kept in sync with the enums.

Use the canonical address during UDP probes.

It is possible that a node has a canonical address, but due to NAT or other
reasons, the meta-connections with that node use other addresses. If UDP is
only possible to the canonical address, then we need to include that during
the initial UDP probing phase.

Add missing calls to init_sync_flag() in test cases.

Fix deleting configuration directories with hidden files.

We incorrectly skipped files starting with a dot when deleting directories.
This is a problem on macOS, which might add .DS_Store files.

Fix potential NULL pointer dereference.

It is possible that an attempt is made to forward a request to a node
that is not reachable via meta-connections. This would trigger an assert
in debug builds, or cause a segmentation fault in release builds. Add
checks before attempts to send a request to node->nexthop->connection.

Don't try to renew SPTPS keys for unreachable nodes.

This caused other functions that incorrectly used status.validkey to check
if they could send data to a node to pass a NULL pointer to send_request(),
causing a crash about an hour after a node went offline.

Only reset UDP SPTPS sessions if the session ID changed.

Previously we reset the SPTPS session if we detected if a node was
unreachable. However, that node might not think it was unreachable,
leading to only one side to reset the SPTPS connection. This would then
take some time to resolve itself.

We already had code to detect whether a node was restarted, so we use
that to detect if, once a node becomes reachable again, it remembers the
old SPTPS session or whether we have to start a new one. This should be
deterministic and not depend on the exact timing of events.

Also send the blacklist notification when we already have a connection.

Instead of just closing the connection, and having to wait for the
reconnection to happen to send the blacklist notification, we do it
immediately when meshlink_blacklist() is called.

Add a callback that notifies the application when it is blacklisted.

If an outgoing connection is made to a node that blacklists the local node,
a callback can now be set that informs the application of it.

Fix Doxygen errors.

Add API functions to query the blacklist status of nodes.

Check blacklist status before committing an invitation.

Although we delete invitation files when blacklisting a node, there is a
race condition where an invitation connection is created right before the
invitee is blacklisted. So check that the node is blacklisted right before
committing the node config file to disk.

Remove invitation files when blacklisting or forgetting a node.

When a new connection is activated, terminate any pending connections to the same peer.

This prevents issues mainly in the test suite where peers try to connect to
each other simultaneously, and have to terminate one of the connections.
Before both connections would succeed, and both would be terminated, leading
to a loop of reconnections until enough randomness got in to break the tie.

Don't reset the UDP SPTPS session when a node becomes reachable.

Only do this when it becomes unreachable. This fixes an issue where right
after a meta-connection is established, the initiator sends a proactive
REQ_KEY, before the peer really becomes reachable according to the graph.
When the latter happened, it would reset the session so far, causing a new
REQ_KEY to be sent, which could cross the ANS_KEY from the peer. This would
resolve itself after a few seconds, but causes an unnecessary delay that is
easy to trigger.

Fix waiting for peer node to become reachable in test suite.

Fix cornercases closing channels.

Closing a channel while there was data in the receive buffer would cause a
RST to be sent instead of a FIN. We now always send a FIN, and let data
in the receive buffer be handled for a later data handling (which would
then send a RST if necessary).

The RST could be dropped if the ACK seqno was not in the correct range.
We now always accept RSTs for established connections.

Finally, when receiving more data after closing the channel, we would just
accept the data but discard it, instead of sending a RST back. Now we do
send a RST back.

Send RST packets when receiving data after we closed a UDP channel.

If the application closed a channel, we keep the UTCP connection alive for
a bit longer to handle resends of FIN packets. However, if this is missed
for some reason, either because the FIN got lost or the peer ignored the
receive callback, and the peer is sending new data, we need to inform it
that we are no longer listening. To do this, send a RST back.

Extend the timeout period of the authentication phase on progress.

If there is progress during the authentication phase of connections, we reset
the ping timer to give extra time to complete the authentication.

We do the same for invitation connections.

Don't use fast timeouts for fully established connections.

During the fast retry period, we want to have a fast ping timeout until we have
a fully working connection. However, the code still used fast timeouts during
the fast retry window even if the connection was fully established.

Fix timeouts of 1 second expiring in less than one second.

Allow sptps_force_kex() in all situations.

Also allow sptps_force_kex() during the initial key exchange.

Allow sptps_force_kex() while a key exchange is in progress

We should not do anything if we are already exchanging a new key, and
just return true. This change prevents higher layers in MeshLink from
terminating a connection between two nodes if both peers call
sptps_force_kex() at nearly the same time.

Use the canonical address exclusively for making outgoing meta-connections.

If we have a node's canonical address, we now always use that as a source
for addresses for outgoing meta-connection attempts. This commit also adds
the function meshlink_clear_canonical_address() to ensure the canonical
address can be removed if it is no longer valid.

Update the invite-join test to update the canonical address after a port change.

Always ensure we store a port number when setting the canonical address.

Use the fast retry period of the destination node's device class.

Remove temporary files at startup.

When something happens while a host config files is written, a temporary
file might be left over. Clean these up when we find them when starting
MeshLink.

Add meshlink_set_channel_listen_cb().

The accept callback is called when the peer has already fully established a
connection. The listen callback is called earlier, when there is no
fully established channel yet. However, the listen callback itself does not
get a channel handle, it can only make a decision based on the peer node
and port number whether to accept the channel, and if so the accept callback
will be called later.

Ensure the poll callback is called when a UDP channel has finished connecting.

Speed up the import-export test by using the PMTU callback.

Fix the import-export test failing sporadically.

Since two nodes connecting simultaneously can cause a node to be seen as
temporarily being down, thus setting the last_unreachable status.

Always let the initiator send a REQ_KEY once a connection is activated.

Before, the logic was to do this when the graph reported a bidirectional
edge. However, there was a possibility that if two nodes connect to each
other simultaneously, causing a second connection to be activated while the
first was also still active, which caused the REQ_KEY to not be sent.

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.