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.

Fix the order of socket operations when setting up listening sockets.

Commit db8e6e4 caused calls to setsockopt() for setting up socket parameters
to be called after the call to bind().

Use slashes internally to separate hostnames and ports in invitation addresses.

This avoids possible confusion when an IPv6 hostname is used without an
explicit port number.

Fix IPv6 address validation bug preventing IPv6 addresses that are added for invitation from getting added

Correctly remove all duplicates when having many hostnames in an invitation URL.

Commit fbcf089 missed adjusting one call to
remove_duplicate_hostnames().

Fix some log messages being reported for the wrong log levels.

Add all recent addresses resolved from a hostname in meshlink_invite().

When a canonical hostname or an invitation address resolves to multiple
numeric addresses, add all of them as recent addresses for ourself, so
they are all part of the host config file we send to the invitee.

Update the invite-join test.

- Check that duplicate addresses get culled correctly.
- Check that we can add lots of extra invitation addresses, and that
  they are in the expected order in the invitation URL.

Ensure we process all hostnames for invitation URLs.

Commit 3febbb4 allowed more addresses to be added to invitation URLs, but
part of the still code assumed a maximum of 4 addresses in the URL.

Fix potential double free when using meshlink_add_invitation_address().

Handle not being able to bind to the configured port at startup.

When starting a MeshLink node that has already been configured to run on a
certain port, but that port is in use (for one or more of the supported
address families), it would either ignore some address families, or would
try to bind to port 0 if all address families failed. However, this is
problematic, because it makes discovery and invitation URL generation much
harder.

Fix this by checking if any port binding fails for a supported address
family, and if so, try to find another port that does support binding on
all address families. If it fails to find any available port, it will fall
back to binding to port 0, so that outgoing connections are still possible.

Don't abort on empty lines in receive_request().

Remove the assertion that lines are not empty, since this could lead to
a DoS attack. Empty lines are already handled correctly by the rest of
the logic in receive_request().

Add meshlink_add_invitation_address(), deprecate meshlink_add_address().

This adds a function to add one or more application-controlled address and
port combinations to invitation URLs. It is meant to replace
meshlink_add_address(), which is too limited because it only allows one
address to be set, and doesn't allow a different port number to be set.

Add meshlink_set_external_address_discovery_url().

This function can be used to override the default meshlink.io service to
query a host's own externally visible address.

Use the first working outgoing socket during meshlink_join().

Avoid ports that are in use by not all address families.

It could happen that a port is bound by another application, but only
for some of the supported address families (ie, only IPv4 but not IPv6).
We don't want MeshLink to then bind to the other address familie(s), but
rather have it try another port altogether.

Further improve try_bind().

Make try_bind() do the same checks as add_listen_address() does: try to
create both a TCP and UDP socket on a given port for all address
families. If one address family succeeds for both TCP and UDP, consider
this a valid port.

Fix logic in try_bind().

Fix the check for successful socket creation. Also make sure we only
return success if we can bind to IPv4 and IPv6, but ignore other
network protocols.

Check that importing the same data twice is fine, but importing garbage is not.

Move assert()s that dereference a pointer to after the pointer NULL check.

Add missing NULL-check in meshlink_verify().

Update the blackbox join test cases.

Fix compilation error caused by ACX_THREAD

Make the join commit order configurable.

By default, when an invitee joins a mesh, it will commit its configuration
to disk first, then the inviter. This adds a function to reverse that order.

Fix a memory leak when an invitation file contains an invalid submesh name.

Found by Clang's static analyzer.

Move join state out of meshlink_handle_t, and ensure proper cleanup on errors.

Move the state we keep when calling meshlink_join() out of meshlink_handle_t
and just put it on the stack of meshlink_join(). Also make sure we properly
release allocated resources in all error conditions during a join.

Fix garbage being sent at start of a UDP channel.

If meshlink_channel_send() was called before a UDP channel had finished
the handshake, it caused UTCP to send garbage data.

Fall back to getifaddrs() to get an interface address if there is no default route.

When generating invitations, we try to find a suitable local interface
address by faking an outgoing connection to the Internet. However,
that doesn't work if there is no default route. In this case, fall back
to using getifaddrs() if that function is available, and filter out any
link-local and loopback addresses.

Use bind() to check if a local address is still valid.

Some platforms don't support getifaddrs(). We use this to check if the
local address of a socket is still available on any network interface.
Instead, try to bind() a new socket to the same address (but port 0) as
existing sockets. If it returns EADDRNOTAVAIL, we know that this address
is no longer valid.

Fix android (Android 6 or before) compilation issue around getifaddr

Clear reachability times in imported host config files.

This mirrors what we do with host config files received during a join.

Force -fPIC when compiling libcatta.

Clear reachability times in host config files received during a join.

When a node joins an existing mesh, it gets passed one or more host config
files from the inviter. However, these might contain non-zero reachability
times, but the invitee has never seen those nodes, so clear them before
storing the host config files.

Prevent meshlink_errno from being set incorrectly by meshlink_invite()

We called a public API function inside meshlink_invite() to check that we
don't try to invite a node that's already known. That causes it to set
meshlink_errno to MESHLINK_ENOENT. Fix this by calling lookup_node()
instead.

Fix spelling errors.

Found by codespell.

Fix reachability queries for blacklisted nodes.

Fix compiling with GCC 10.

Fix potential segmentation fault on iOS.

The PONG handler could call freeaddrinfo() on a struct that was not
allocated with getaddrinfo(). On most platforms this apparently works
fine, but on iOS it will try to free memory that wasn't allocated. Fix
this by moving the code to reset an outgoing_t to a separate function,
and calling that from the PONG handler.

Only let mesh->self be reachable when the mesh is started.

This ensures meshlink_node_get_reachability(mesh->self) returns true only
if the mesh has been started. It also handles reachability of self in
graph.c just like any other node. This means there will now also be a
node status callback generated when the mesh is started and stopped.

Sync host config file immediately after initial connect.

Add meshlink_get_node_reachability().

This function returns the current state of a node's reachability, as
well as the last time the node became reachable and the last time it
became unreachable.

Add a configurable fast connection retry period.

If no nodes are reachable, allow connections to retry once every second for a
per device-class configurable amount of time.

Remember the address used by an invitee.

When a new node uses an invitation succesfully, store the address it
used to connect.

Remember the address used when connecting to an inviting node.

The inviter sends us its own host config file, which should be populated
with its known addresses. However, if a symbolic hostname is in the
invitation URL and it can resolve to multiple IP addresses, or if the IP
address associated with it is currently different from when the invitation
was generated, the address used to connect to the inviter might not be
present in its host config file. This could cause the invitation to succeed,
but then the nodes would fail to make a regular MeshLink connection.

Ensure all addresses in the invitation URL are also in the invitation file.

Prefer sockaddr_t over struct sockaddr_*.

This avoids a lot of pointer casts, and also fixes some problems with the
sockaddr length potentially being smaller than necessary.

Don't add duplicates to the list of recently seen addresses.

Duplicate addresses would be appended to the list, and could push out other
addresses. If the address already exists, only move it to the top if it is
not already there.

Also don't force an immediate write of the host config file when trying to
add an address that already exists.

Destroy new/ and old/ subdirectories when creating a new instance.

Add meshlink_get_all_nodes_by_last_reachable().

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.

Add a #define for the maximum number of tracked recently seen addresses.

Sync the base configuration directory at the end of meshlink_join().

While joining a mesh, we create a new current/ subdirectory. While the
contents were already synced to disk, we need to ensure the subdirectory
itself is also synced before returning.

Sync the base configuration directory after each subdirectory rename operation.

This ensures the proper ordering of the renames in the event of a crash.

Sync the base configuration directory after each call to config_destroy().

This guarantees proper ordering when deleting the current/, new/ and old/
subdirectories.

Fix logic error preventing fast update of reflexive address.

When we are trying to communicate with peers that don't know our
reflexive address, and we just learned our own one, we want to inform
those peers of it immediately, so they can send PMTU probes to the right
address. A logic error prevented this from happening in the common case.

Assert that nodes black/whitelisted by name persist after closing the mesh.

Add support for black/whitelisting by name, and forgetting nodes.

Fix __warn_unused_result__, add more of it and fix the resulting warnings.

Due to a bug in the autoconf test for function attributes, we were always
disabling __warn_unused_result__. Fix this, and add this function attribute
to a lot more functions whose results are definitely important.

This change makes it clear where we ignore the results of a function that
might fail. The proper fix in most cases is to propagate the result to the
caller. For meshlink_blacklist() and meshlink_whitelist(), we were not
return an error condition, even if we might fail to commit the blacklist
operation to permanent storage. So we now make these functions return a
bool.

Use a separate lockfile to lock the configuration directory.

We can't use meshlink.conf as the lock file, since it can move around.
Instead, create meshlink.lock right below confbase, and keep it always
locked while a meshlink handle is valid.

meshlink_destroy() will also use this lockfile to ensure we don't destroy
a directory that is still in use, and prevent race conditions between
meshlink_destroy() and meshlink_open().

Sync the host config directory after accepting an invitee.

Refuse invitees if we can't delete the invitation file.

If the call to unlink() or a subsequent sync of the invitation directory
fails, don't allow the invitee access, to prevent an invitation from
being used twice.

Sync invitation directory when calling meshlink_invite().

Don't fail to start MeshLink if some host config files couldn't be read.

Handle host config files without a public key.

Commit fa05f996c5500c056a36c1d43e33a407f876643c broke reading config
files for hosts for which no public key is known.

Add missing calls to fflush().

We need to ensure file handles have flushed the stream buffer to disk
before calling fsync().

Also remove redundant calls to fsync(), config_write_file() already
takes care of it.

Allow nodes to learn their own reflexive UDP address.

When a node gets a succesful UDP probe reply, it informs the peer of the
UDP address and port that it has. The peer can then use this information to
inform other nodes it wants to communicate with.

Currently, this is only done to close the time window where two nodes have
established an SPTPS session via a third node, while the third node hasn't
learned of the two nodes' UDP addresses, in which case it was too late for
the third node to assist with hole punching.

Try to get a new reflexive UDP address if UDP probes failed.

If we are sending data to a node, but we don't have working UDP, it could
be because we don't have a good reflexive UDP address. Send a dummy ANS_KEY
once in a while as long as we still want to exchange data.

Avoid compiler warnings when compiling with -DNDEBUG.

Only add confirmed reflexive UDP addresses to ANS_KEY messages.

Ensure NDEBUG is not set in the test suite.

We rely on assert() in the test suite, so it should not be compiled out
when doing a release build with -DNDEBUG.

Fix another case of assert() with side-effects.

Fix signal pipe creation when compiling with -DNDEBUG.

Argument of a call to assert() should never have side effects.

Don't call terminate_connection() from meshlink_blacklist().

If meshlink_blacklist() is called from a callback function, this can result
in a use-after-free bug. Instead, shut down the socket, so the event loop
will take care of it.

Set meshlink_errno when trying to create a channel to a blacklisted node.

Create a new errno value MESHLINK_EBLACKLISTED, which is used when trying
to send something or create a channel to a blacklisted node. Also improve
some log messages.

Ensure an invitation timeout of 0 means no invitations are valid.

Don't close active connections when a node is discovered via Catta.

When a node was discovered by Catta, but we already had an active
meta-connection with it, it would erroneously close that connection.

Don't call graph() twice when a new connection replaces an older one.

This prevents a node from being considered unreachable for just a small
moment, even though we know it is reachable.

Restart UDP SPTPS when a node reconnects with a new session ID.

If a node restarts, but its old connection was not considered closed
yet, the graph algorithm never saw it go down. We still want to ensure
we restart UDP SPTPS in this case.